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