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