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