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