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