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