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