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