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