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