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