Оптимизируй и выполни рефакторинг, отправь только исправленный код
   public class ChangePricesToUp
   {
       // 
       [DllImport("user32.dll", SetLastError = true)]
       static extern bool SetCursorPos(int X, int Y);
       [DllImport("user32.dll", SetLastError = true)]
       static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, int dwExtraInfo);
       private const uint MOUSEEVENTF_LEFTDOWN = 0x02;
       private const uint MOUSEEVENTF_LEFTUP = 0x04;
       [DllImport("user32.dll")]
       static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
       const uint MOUSEEVENTF_MOVE = 0x0001;
       static readonly Random random = new Random();



       public void ProcessList()
       {
           const int startX = 1295;
           int[] startYpoints = { 365, 435, 506, 565 };
           int currentPositionIndex = 0; // Индекс текущей позиции для startYpoints
           Point clickPoint = new Point(startX, startYpoints[currentPositionIndex]);
           bool endOfList = false;

           // Характеристики доверительного интервала
           Color endListColor = Color.FromArgb(255, 61, 60, 64);
           int tolerance = 12; // Допуск по цветовым компонентам


           while (true)
           {
               int steps = 5;
               // Плавное перемещение до точки нажатия
               SmoothMove(Cursor.Position, clickPoint, steps);
               mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
               Thread.Sleep(300); // Задержка перед вызовом CheckPrice

               var price = CheckPrice();
               if (price.HasValue)
               {
                   ChangePrice(price);
               }
               else
               {
                   Thread.Sleep(120);
               }

               // Нужно ли скроллить вниз или мы в конце списка
               if (!endOfList)
               {
                   // Прокрутка списка
                   SimMouse.Act(SimMouse.Action.LeftButtonDown, 1200, 480);
                   Thread.Sleep(200);
                   SmoothMoveList(1200, 480, 1200, 417);
                   SimMouse.Act(SimMouse.Action.LeftButtonUp, 1200, 417);

                   // Взятие скриншота для проверки, находимся ли в конце списка
                   using (Bitmap bmpScreenshot = new Bitmap(1, 1, PixelFormat.Format32bppArgb))
                   {
                       using (Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot))
                       {
                           gfxScreenshot.CopyFromScreen(1445, 592, 0, 0, new Size(1, 1), CopyPixelOperation.SourceCopy);
                           Color pixelColor = bmpScreenshot.GetPixel(0, 0);
                           endOfList = IsColorSimilar(endListColor, pixelColor, tolerance);
                       }
                   }
               }
               else
               {
                   // Если достигнут конец списка, проверяем следующую позицию
                   currentPositionIndex++;
                   if (currentPositionIndex >= startYpoints.Length)
                   {
                       break; // Выходим из цикла когда все позиции проверены
                   }
               }

               // Установка следующей точки нажатия
               clickPoint.Y = startYpoints[currentPositionIndex];
           }
       }
       static void SmoothMoveList(int startX, int startY, int endX, int endY)
       {
           int steps = Math.Max(Math.Abs(endX - startX), Math.Abs(endY - startY));
           double timeToMove = 0.5; // В секундах
           int delayBetweenSteps = (int)((timeToMove / steps) * 1000);

           Cursor.Position = new System.Drawing.Point(startX, startY);

           for (int i = 0; i <= steps; i++)
           {
               int newX = startX + (endX - startX) * i / steps;
               int newY = startY + (endY - startY) * i / steps;
               Cursor.Position = new System.Drawing.Point(newX, newY);
               Thread.Sleep(delayBetweenSteps);
           }


       }
       // SimMouse.Act(SimMouse.Action.LeftButtonDown, startX, startY);
       //     SimMouse.Act(SimMouse.Action.LeftButtonUp, startX, startY);

       // Распознование цены и ее изменение
       public long? CheckPrice()
       {
           using (Bitmap bmpScreenshot = new Bitmap(115, 20, PixelFormat.Format32bppArgb))
           using (Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot))
           {
               gfxScreenshot.CopyFromScreen(1335, 325, 0, 0, new Size(115, 20), CopyPixelOperation.SourceCopy);
               if (IsOurNumber(bmpScreenshot))
               {
                   int steps = 5;
                   Point endPoint = new Point(935, 255);
                   SmoothMove(Cursor.Position, endPoint, steps);
                   mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
                   // Если число наше, мы не делаем ничего и возвращаем null
                   return null;
               }
               else
               {
                   // Это не наша цена, используем улучшенное изображение для OCR
                   using (Bitmap enhancedImage = EnhanceImage(bmpScreenshot))
                   {
                       return RecognizeNumberAndAddOne(enhancedImage);
                   }
               }
           }
       }
       private void SmoothMove(Point start, Point end, int steps)
       {
           int startX = start.X;
           int startY = start.Y;
           int endX = end.X;
           int endY = end.Y;
           // Чем больше шагов, тем плавнее кривая

           // Контрольная точка для кривой Безье
           int ctrlX = random.Next(Math.Min(startX, endX), Math.Max(startX, endX));
           int ctrlY = random.Next(Math.Min(startY, endY), Math.Max(startY, endY));

           // Плавное перемещение курсора от начала до конца
           for (int i = 0; i <= steps; i++)
           {
               double t = (double)i / steps;
               double xt = (1 - t) * (1 - t) * startX + 2 * (1 - t) * t * ctrlX + t * t * endX;
               double yt = (1 - t) * (1 - t) * startY + 2 * (1 - t) * t * ctrlY + t * t * endY;
               SetCursorPos((int)xt, (int)yt);
               Thread.Sleep(1);
           }
       }
       public bool IsOurNumber(Bitmap bmp)
       {
           // Цвет числа, когда оно является "нашим"
           Color ourNumberColor = Color.FromArgb(255, 182, 153, 127);
           // Допуск по каждому из цветовых компонентов
           int tolerance = 4;


           // Проверяем цвет пикселя в нижнем правом углу (чуть внутри от края)
           // Учитывая, что координаты начинаются с 0, (98, 18) находится в краю
           Color pixelColor = bmp.GetPixel(98, 18);

           return IsColorSimilar(ourNumberColor, pixelColor, tolerance);
       }
       public bool IsColorSimilar(Color color1, Color color2, int tolerance)
       {
           return Math.Abs(color1.R - color2.R) <= tolerance &&
                  Math.Abs(color1.G - color2.G) <= tolerance &&
                  Math.Abs(color1.B - color2.B) <= tolerance;
       }
       public Bitmap EnhanceImage(Bitmap originalImage)
       {
           // Увеличиваем изображение в 3 раза
           int newWidth = originalImage.Width * 3;
           int newHeight = originalImage.Height * 3;
           Bitmap resizedImage = new Bitmap(newWidth, newHeight);
           using (Graphics g = Graphics.FromImage(resizedImage))
           {
               g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
               g.DrawImage(originalImage, 0, 0, newWidth, newHeight);
           }

           // Конвертация увеличенного изображения в оттенки серого
           Bitmap grayImage = ConvertToGrayscale(resizedImage);
           resizedImage.Dispose(); // Освобождаем ресурсы временного изображения, оно нам больше не нужно

           // Применение пороговой обработки для бинаризации изображения
           int threshold = 128;
           using (Image<Gray, byte> imGray = new Image<Gray, byte>(grayImage))
           {
               imGray._ThresholdBinary(new Gray(threshold), new Gray(255));
               grayImage.Dispose(); // Освобождаем ресурсы, так как они больше не нужны
               return imGray.ToBitmap();
           }
       }
       private static Bitmap ConvertToGrayscale(Bitmap originalImage)
       {
           Bitmap grayImage = new Bitmap(originalImage.Width, originalImage.Height);
           using (Graphics g = Graphics.FromImage(grayImage))
           {
               ColorMatrix grayscaleMatrix = new ColorMatrix(
                   new float[][]
                   {
               new float[] {0.299f, 0.299f, 0.299f, 0, 0},
               new float[] {0.587f, 0.587f, 0.587f, 0, 0},
               new float[] {0.114f, 0.114f, 0.114f, 0, 0},
               new float[] {0, 0, 0, 1, 0},
               new float[] {0, 0, 0, 0, 1}
                   });
               using (ImageAttributes attributes = new ImageAttributes())
               {
                   attributes.SetColorMatrix(grayscaleMatrix);
                   g.DrawImage(originalImage,
                       new Rectangle(0, 0, originalImage.Width, originalImage.Height),
                       0, 0, originalImage.Width, originalImage.Height,
                       GraphicsUnit.Pixel, attributes);
               }
           }
           return grayImage;
       }
       public long? RecognizeNumberAndAddOne(Bitmap bitmapImage)
       {
           try
           {
               // Увеличиваем и улучшаем контраст перед OCR
               using (Bitmap resultImage = EnhanceImage(bitmapImage))
               {
                   // Замените путь к папке tessdata на путь, где хранятся ваши данные Tesseract
                   string tessDataPath = @"MainMenu/tessdata";

                   // Используем новую версию API Tesseract
                   using (var engine = new TesseractEngine(tessDataPath, "eng", EngineMode.TesseractAndLstm)) // Можете использовать EngineMode.TesseractOnly или EngineMode.TesseractAndLstm в зависимости от ваших требований
                   {
                       // Устанавливаем режим распознавания только для цифр
                       engine.DefaultPageSegMode = Tesseract.PageSegMode.RawLine;
                       engine.SetVariable("tessedit_char_whitelist", "0123456789");

                       // Применяем OCR на изображение
                       using (var img = PixConverter.ToPix(resultImage))
                       using (var page = engine.Process(img))
                       {
                           // Получаем распознанный текст
                           string recognizedText = page.GetText().Trim();

                           // Пытаемся преобразовать текст в число
                           if (long.TryParse(recognizedText, out long number))
                           {
                               // Прибавляем 1 к числу
                               return number + 1;
                           }
                       }
                   }
               }
           }
           catch (Exception ex)
           {
               // Обработка исключений
               MessageBox.Show("An error occurred: " + ex.Message);
           }

           // Возвращаем null, если число не было распознано
           return null;
       }
       public void ChangePrice(long? number = null)
       {
           // Проверяем, что переданное число не равно null
           if (!number.HasValue)
               return; // Если значение не задано, прерываем выполнение метода

           List<Point> pointsToMove = new List<Point>
             {
               new Point(560, 655), // клик на цену
               //new Point(865, 785), // кнопка публиковать
               new Point(935, 255), // клик закрыть
           };

           for (int i = 0; i < pointsToMove.Count; i++)
           {
               int steps = 5;
               Point endPoint = pointsToMove[i];
               SmoothMove(Cursor.Position, endPoint, steps); // Используйте текущую позицию курсора как начальную точку

               // Если это первая точка, произведите клик и введите число
               if (i == 0)
               {
                   mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); // Симулируем клик ЛКМ
                   Thread.Sleep(100);
                   // Здесь мы допускаем ввод значения number, а не price
                   SendKeys.SendWait(number.Value.ToString()); // Добавляем нажатие ENTER для подтверждения ввода
               }
               // Если это вторая точка, производим клик на кнопке "Публиковать"
               else if (i == 1)
               {
                   mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
                   Thread.Sleep(100); // Имитация задержки после клика
                   Point pointToMove = new Point(1200, 480);
                   SmoothMove(Cursor.Position, pointToMove, 10);
                   Thread.Sleep(100);
               }

           }
       }
   }