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