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