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