Вот мой код python:
```py
import requests


class DiscordFixClient:
    def __init__(self, base_url="http://127.0.0.1:7684"):
        self.base_url = base_url.rstrip('/')

    def start_fix(self, mode):
        """
        Запускает исправление Discord.
        :param mode: "beeline", "mgts", "general"
        """
        url = f"{self.base_url}/start"
        payload = {"mode": mode}
        try:
            response = requests.post(url, json=payload)
            response.raise_for_status()
            print(f"Запуск режима '{mode}': {response.text}")
        except requests.exceptions.RequestException as e:
            print(f"Ошибка при запуске режима '{mode}': {e}")

    def clear_driver(self):
        """
        Очищает драйвер WinDivert.
        """
        url = f"{self.base_url}/clear-driver"
        try:
            response = requests.post(url)
            response.raise_for_status()
            print(f"Очистка драйвера: {response.text}")
        except requests.exceptions.RequestException as e:
            print(f"Ошибка при очистке драйвера: {e}")

    def terminate(self):
        """
        Завершает запущенный процесс DiscordFix.
        """
        url = f"{self.base_url}/terminate"
        try:
            response = requests.post(url)
            response.raise_for_status()
            print(f"Завершение процесса: {response.text}")
        except requests.exceptions.RequestException as e:
            print(f"Ошибка при завершении процесса: {e}")


# Пример использования:
if __name__ == "__main__":
    client = DiscordFixClient()

    # Запуск режима "general"
    client.start_fix("general")  # Можно заменить на "beeline" или "mgts"

    # Очистка драйвера WinDivert
    # client.clear_driver()

    # Завершение процесса DiscordFix
    # client.terminate()
```


Вот код на rust:
```rs
//#![windows_subsystem = "windows"] // Предотвращает открытие консольного окна на Windows

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::Deserialize;
use std::process::{Child, Command, Stdio};
use std::sync::{Arc, Mutex};
use std::path::PathBuf;

// Структура для глобального состояния
struct AppState {
    process: Mutex<Option<Child>>,
}

// Структура для запроса на запуск
#[derive(Deserialize)]
struct StartRequest {
    mode: String, // "beeline", "mgts", "general"
}

// Функция для запуска процесса исправления Discord
async fn start_fix(data: web::Data<Arc<AppState>>, req: web::Json<StartRequest>) -> impl Responder {
    let mut process_lock = data.process.lock().unwrap();

    if process_lock.is_some() {
        return HttpResponse::BadRequest().body("Процесс уже запущен");
    }

    let mode = req.mode.as_str();

    // Определение базового пути (предполагается, что исполняемый файл находится в корне проекта DiscordUnlock)
    //let base_path = match std::env::current_exe() {
    //    Ok(exe_path) => exe_path.parent().map_or_else(|| PathBuf::from("."), |p| p.to_path_buf()),
    //    Err(e) => return HttpResponse::InternalServerError().body(format!("Ошибка получения пути к исполняемому файлу: {}", e)),
    //};

    let base_path = PathBuf::from("D:/RustroverProjects/DarkDiscordFix/src");
    // Пути к необходимым файлам
    let bin_path = base_path.join("winws.exe");
    let quic_path = base_path.join("quic_initial_www_google_com.bin");
    let tls_path = base_path.join("tls_clienthello_www_google_com.bin");
    let list_path = base_path.join("list-discord.txt");

    // Проверка наличия необходимых файлов
    if !bin_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл winws.exe");
    }
    if !quic_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл quic_initial_www_google_com.bin");
    }
    if !tls_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл tls_clienthello_www_google_com.bin");
    }
    if !list_path.exists() {
        return HttpResponse::InternalServerError().body("Не найден файл list-discord.txt");
    }

    // Создание команды
    let mut cmd = Command::new(&bin_path);

    // Добавление аргументов в зависимости от режима
    match mode {
        "general" => {
            // Аргументы из DiscordFix.bat для режима "general"
            cmd.args(&[
                "--wf-tcp=443",
                "--wf-udp=443,50000-65535",
                "--filter-udp=443",
                &format!(r#"--hostlist="{}""#, list_path.to_str().unwrap()),
                "--dpi-desync=fake",
                "--dpi-desync-udplen-increment=10",
                "--dpi-desync-repeats=6",
                "--dpi-desync-udplen-pattern=0xDEADBEEF",
                &format!(r#"--dpi-desync-fake-quic="{}""#, quic_path.to_str().unwrap()),
                "--new",
                "--filter-udp=50000-65535",
                "--dpi-desync=fake",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                &format!(r#"--dpi-desync-fake-quic="{}""#, quic_path.to_str().unwrap()),
                "--new",
                "--filter-tcp=443",
                &format!(r#"--hostlist="{}""#, list_path.to_str().unwrap()),
                "--dpi-desync=fake,split",
                "--dpi-desync-autottl=2",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fooling=badseq",
                &format!(r#"--dpi-desync-fake-tls="{}""#, tls_path.to_str().unwrap()),
            ]);
        },
        "beeline" => {
            // Аргументы из DiscordFix (для Билайн, Ростелеком, Инфолинк).bat
            cmd.args(&[
                "--wf-udp=50000-65535",
                "--filter-udp=50000-65535",
                &format!(r#"--hostlist="{}""#, list_path.to_str().unwrap()),
                "--dpi-desync=fake",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                &format!(r#"--dpi-desync-fake-quic="{}""#, quic_path.to_str().unwrap()),
                "--new",
                "--wf-l3=ipv4",
                "--wf-tcp=443",
                "--dpi-desync=syndata",
                // Дополнительные аргументы для режима "beeline"
                "--dpi-desync-split2",
                "--dpi-desync-disorder2",
                &format!(r#"--dpi-desync-fake-syndata="{}""#, base_path.join("blockcheck").join("zapret").join("files").join("fake").join("tls_clienthello_iana_org.bin").to_str().unwrap()),
                "--wssize",
                "1:6",
                "--dpi-desync-fake-syndata=",
                &base_path.join("blockcheck").join("zapret").join("files").join("fake").join("tls_clienthello_iana_org.bin").to_str().unwrap(),
            ]);
        },
        "mgts" => {
            // Аргументы из DiscordFix (для МГТС).bat
            cmd.args(&[
                "--wf-tcp=443",
                "--wf-udp=443,50000-65535",
                "--filter-udp=443",
                &format!(r#"--hostlist="{}""#, list_path.to_str().unwrap()),
                "--dpi-desync=fake",
                "--dpi-desync-udplen-increment=10",
                "--dpi-desync-repeats=6",
                "--dpi-desync-udplen-pattern=0xDEADBEEF",
                &format!(r#"--dpi-desync-fake-quic="{}""#, quic_path.to_str().unwrap()),
                "--new",
                "--filter-udp=50000-65535",
                "--dpi-desync=fake,tamper",
                "--dpi-desync-any-protocol",
                "--dpi-desync-cutoff=d3",
                "--dpi-desync-repeats=6",
                &format!(r#"--dpi-desync-fake-quic="{}""#, quic_path.to_str().unwrap()),
                "--new",
                "--filter-tcp=443",
                &format!(r#"--hostlist="{}""#, list_path.to_str().unwrap()),
                "--dpi-desync=fake",
                "--dpi-desync-autottl=2",
                "--dpi-desync-repeats=6",
                "--dpi-desync-fooling=md5sig",
                &format!(r#"--dpi-desync-fake-tls="{}""#, tls_path.to_str().unwrap()),
            ]);
        },
        _ => {
            return HttpResponse::BadRequest().body("Неизвестный режим");
        }
    }

    // Настройка запуска процесса
    match cmd
        // Переключение текущей директории на базовый путь
        .current_dir(&base_path)
        // Перенаправление вывода процесса в null (без GUI)
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        // Запуск процесса
        .spawn()
    {
        Ok(child) => {
            *process_lock = Some(child);
            HttpResponse::Ok().body("Процесс запущен")
        },
        Err(e) => {
            HttpResponse::InternalServerError().body(format!("Ошибка запуска процесса: {}", e))
        }
    }
}

// Функция для очистки драйвера WinDivert
async fn clear_driver(data: web::Data<Arc<AppState>>) -> impl Responder {
    // Команды для очистки драйвера
    let commands = vec![
        "sc stop WinDivert",
        "sc delete WinDivert",
    ];

    for cmd_str in commands {
        let status = Command::new("cmd")
            .args(&["/C", cmd_str])
            .status();

        match status {
            Ok(status) if status.success() => {},
            Ok(status) => return HttpResponse::InternalServerError().body(format!("Команда {:?} завершилась с кодом {}", cmd_str, status)),
            Err(e) => return HttpResponse::InternalServerError().body(format!("Ошибка выполнения команды {:?}: {}", cmd_str, e)),
        }
    }

    HttpResponse::Ok().body("Драйвер WinDivert очищен")
}

// Функция для завершения запущенного процесса
async fn terminate(data: web::Data<Arc<AppState>>) -> impl Responder {
    let mut process_lock = data.process.lock().unwrap();

    if let Some(child) = process_lock.as_mut() {
        match child.kill() {
            Ok(_) => {
                *process_lock = None;
                HttpResponse::Ok().body("Процесс завершен")
            },
            Err(e) => {
                HttpResponse::InternalServerError().body(format!("Ошибка при завершении процесса: {}", e))
            }
        }
    } else {
        HttpResponse::BadRequest().body("Нет запущенных процессов")
    }
}

// Главная функция
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Инициализация глобального состояния
    let state = Arc::new(AppState {
        process: Mutex::new(None),
    });

    println!("Server running at http://127.0.0.1:7684");

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(state.clone()))
            .route("/start", web::post().to(start_fix))
            .route("/clear-driver", web::post().to(clear_driver))
            .route("/terminate", web::post().to(terminate))
    })
        .bind("127.0.0.1:7684")?
        .run()
        .await
}
```

На python пишется: `Ошибка при запуске режима 'general': 500 Server Error: Internal Server Error for url: http://127.0.0.1:7684/start`

То есть, не пишется ни не `Не найден файл winws.exe`, ни `Не найден файл quic_initial_www_google_com.bin` и т.д. Ошибка где-то в другом месте.

Я также прикреплю файл bat, который работает 100%:
```
@echo off
chcp 65001 >nul
:: 65001 - UTF-8

cd /d "%~dp0"
set BIN=%~dp0bin\

set LIST_TITLE=ZAPRET: Discord Fix
set LIST_PATH=%~dp0lists\list-discord.txt

start "%LIST_TITLE%" /min "%BIN%winws.exe" ^
--wf-tcp=443 --wf-udp=443,50000-65535 ^
--filter-udp=443 --hostlist="%LIST_PATH%" --dpi-desync=fake --dpi-desync-udplen-increment=10 --dpi-desync-repeats=6 --dpi-desync-udplen-pattern=0xDEADBEEF --dpi-desync-fake-quic="%BIN%quic_initial_www_google_com.bin" --new ^
--filter-udp=50000-65535 --dpi-desync=fake --dpi-desync-any-protocol --dpi-desync-cutoff=d3 --dpi-desync-repeats=6 --dpi-desync-fake-quic="%BIN%quic_initial_www_google_com.bin" --new ^
--filter-tcp=443 --hostlist="%LIST_PATH%" --dpi-desync=fake,split --dpi-desync-autottl=2 --dpi-desync-repeats=6 --dpi-desync-fooling=badseq --dpi-desync-fake-tls="%BIN%tls_clienthello_www_google_com.bin"
```
Однако, я убрал папки bin и lists и поместил их всех в одну общую