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