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