这可能是最终版了，感谢使用

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <shellapi.h>
#include <tlhelp32.h>
#include <ctime>
#include <vector>
#include <psapi.h>
using namespace std;
#define endl "\n" 
#ifndef _countof
#define _countof(arr) (sizeof(arr) / sizeof(arr[0]))
#endif

#ifndef _TRUNCATE
#define _TRUNCATE 0
#endif

inline void strcpy_s(char* dest, size_t destSize, const char* src, int truncate) {
    if (dest == NULL || src == NULL || destSize == 0) return;
    strncpy(dest, src, destSize - 1);
    dest[destSize - 1] = '\0';
}

inline void strcat_s(char* dest, size_t destSize, const char* src, int truncate) {
    if (dest == NULL || src == NULL || destSize == 0) return;
    size_t len = strlen(dest);
    if (len >= destSize - 1) return;
    strncpy(dest + len, src, destSize - len - 1);
    dest[destSize - 1] = '\0';
}

#ifndef KEY_WOW64_64KEY
#define KEY_WOW64_64KEY 0x0100
#endif
#define KEY_STATE_PRESSED 0x8000
#define SHELLEXECUTE_FAILURE_THRESHOLD 32
#define CONSOLE_CODE_PAGE 65001
#define WM_TRAY_NOTIFY (WM_USER + 1)
#define MAX_PROCESS_COUNT 1024

const char* STUDENT_MAIN_PATH = "C:\\Program Files (x86)\\Mythware\\极域课堂管理系统软件V6.0 2016 豪华版\\StudentMain.exe";
const char* FROZEN_WND_CLASS = "ClassScreenFrozenWnd";
const char* ALLOWED_DOMAIN = "https://www.bcoi.cn/";
const char* TOOL_TITLE = "极域V6.0 2016豪华版工具v20.0Pro";
const char* TOOL_NAME = "极域工具箱v20.0Pro";
const char* ANTI_CLOSE_WND_CLASS = "AntiCloseConsoleWnd";

const char* CAST_WND_CLASSES[] = {
    "ScreenRenderWin",
    "TPlayerWindow",
    "TClassScreenForm"
};
const int CAST_WND_COUNT = sizeof(CAST_WND_CLASSES) / sizeof(CAST_WND_CLASSES[0]);

#ifdef __MINGW32__
#pragma comment(linker, "-ladvapi32 -lsetupapi -lgdi32 -luser32 -lshell32 -lole32 -lkernel32 -lpsapi")
#endif

char g_SelfPath[MAX_PATH] = {0};
bool g_AllowExit = false;
int g_killCount = 0;
bool g_keyStates[256] = {false};
bool g_isScreenFrozen = false;
HWND g_hFrozenWnd = NULL;
HINSTANCE g_hInstance = NULL;
HBITMAP g_hScreenBmp = NULL;
int g_nScreenW = 0;
int g_nScreenH = 0;
HANDLE g_hCaptureThread = NULL;
bool g_bCapturing = false;
CRITICAL_SECTION g_csGlobal;

bool g_bDetectingCast = true;
HANDLE g_hCastDetectThread = NULL;

bool g_bDetectingRemoteControl = true;
HANDLE g_hRemoteControlDetectThread = NULL;

bool g_bAntiCloseEnabled = true;
WNDPROC g_originalWndProc = NULL;

bool g_bDoubleGuardEnabled = true;
HANDLE g_hDoubleGuardThread = NULL;

bool g_bAutoRunEnabled = true;

typedef struct {
    char title[64];
    char message[256];
} NOTIFY_PARAM, *PNOTIFY_PARAM;

DWORD WINAPI NotificationThread(LPVOID lpParam) {
    PNOTIFY_PARAM pParam = (PNOTIFY_PARAM)lpParam;
    if (pParam == NULL) return 1;

    NOTIFYICONDATA nid = {0};
    
#ifdef _WIN32_WINNT
    nid.cbSize = NOTIFYICONDATA_V2_SIZE;
#else
    nid.cbSize = sizeof(NOTIFYICONDATA);
#endif
    
    nid.hWnd = GetForegroundWindow();
    nid.uID = 1001;
    nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_INFO;
    nid.uCallbackMessage = WM_TRAY_NOTIFY;
    nid.hIcon = (HICON)LoadImage(NULL, IDI_INFORMATION, IMAGE_ICON, 0, 0, LR_SHARED);
    
    strcpy_s(nid.szInfoTitle, _countof(nid.szInfoTitle), pParam->title, _TRUNCATE);
    strcpy_s(nid.szInfo, _countof(nid.szInfo), pParam->message, _TRUNCATE);
    
    nid.uTimeout = 3000;
    nid.dwInfoFlags = NIIF_INFO;

    Shell_NotifyIcon(NIM_ADD, &nid);
    Shell_NotifyIcon(NIM_MODIFY, &nid);

    Sleep(4000);
    
    Shell_NotifyIcon(NIM_DELETE, &nid);

    if (nid.hIcon) {
        DestroyIcon(nid.hIcon);
    }

    delete pParam;
    return 0;
}

void ShowSystemNotification(const char* title, const char* message)
{
    if (!title || !message) return;

    PNOTIFY_PARAM pParam = new NOTIFY_PARAM;
    strcpy_s(pParam->title, _countof(pParam->title), title, _TRUNCATE);
    strcpy_s(pParam->message, _countof(pParam->message), message, _TRUNCATE);

    HANDLE hThread = CreateThread(
        NULL,
        0,
        NotificationThread,
        pParam,
        0,
        NULL
    );

    if (hThread != NULL) {
        CloseHandle(hThread);
    } else {
        delete pParam;
        cout << "创建通知线程失败，错误码：" << GetLastError() << endl;
    }
}

DWORD WINAPI DoubleGuardThread(LPVOID lpParam) {
    DWORD selfPid = GetCurrentProcessId();
    while (g_AllowExit && g_bDoubleGuardEnabled) {
        Sleep(600);

        HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (hSnap == INVALID_HANDLE_VALUE) continue;

        PROCESSENTRY32 pe = {0};
        pe.dwSize = sizeof(PROCESSENTRY32);

        int selfCount = 0;
        if (Process32First(hSnap, &pe)) {
            do {
                if (pe.th32ProcessID != selfPid) {
                    char procPath[MAX_PATH] = {0};
                    HANDLE hProc = OpenProcess(
                        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
                        FALSE, pe.th32ProcessID
                    );
                    if (hProc != NULL) {
                        GetModuleFileNameExA(hProc, NULL, procPath, MAX_PATH);
                        CloseHandle(hProc);
                        if (_stricmp(procPath, g_SelfPath) == 0) {
                            selfCount++;
                        }
                    }
                }
            } while (Process32Next(hSnap, &pe));
        }
        CloseHandle(hSnap);

        if (selfCount < 1 && !g_AllowExit && g_bDoubleGuardEnabled) {
            ShellExecuteA(NULL, NULL, g_SelfPath, NULL, NULL, SW_SHOW);
        }
    }
    return 0;
}

LRESULT CALLBACK AntiCloseWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    if (!g_bAntiCloseEnabled && g_originalWndProc != NULL) {
        return CallWindowProcA(g_originalWndProc, hWnd, uMsg, wParam, lParam);
    }

    switch (uMsg) {
        case WM_QUERYENDSESSION:
        case WM_ENDSESSION:
            ShowSystemNotification(TOOL_NAME, "禁止关机/注销！极域工具正在运行");
            return 0;
        case WM_CLOSE:
        case WM_DESTROY:
            ShowSystemNotification(TOOL_NAME, "禁止关闭！请按ESC键正常退出");
            return 0;
        default:
            if (g_originalWndProc != NULL) {
                return CallWindowProcA(g_originalWndProc, hWnd, uMsg, wParam, lParam);
            } else {
                return DefWindowProcA(hWnd, uMsg, wParam, lParam);
            }
    }
}

void ToggleAntiCloseWndProc(bool enable) {
    HWND hConsole = GetConsoleWindow();
    if (hConsole == NULL) return;

    if (enable) {
        WNDCLASSEXA wc = {0};
        wc.cbSize = sizeof(WNDCLASSEXA);
        wc.lpfnWndProc = AntiCloseWndProc;
        wc.hInstance = g_hInstance;
        wc.lpszClassName = ANTI_CLOSE_WND_CLASS;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)COLOR_WINDOW;

        if (!RegisterClassExA(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) {
            cout << "注册防关闭窗口类失败，错误码：" << GetLastError() << endl;
            ShowSystemNotification(TOOL_NAME, "注册防关闭窗口类失败");
            return;
        }

        if (g_originalWndProc == NULL) {
            g_originalWndProc = (WNDPROC)GetWindowLongPtrA(hConsole, GWLP_WNDPROC);
            SetWindowLongPtrA(hConsole, GWLP_WNDPROC, (LONG_PTR)AntiCloseWndProc);
        }
        cout << "关机/关闭拦截已开启！" << endl;
        ShowSystemNotification(TOOL_NAME, "关机/关闭拦截已开启！");
    } else {
        if (g_originalWndProc != NULL) {
            SetWindowLongPtrA(hConsole, GWLP_WNDPROC, (LONG_PTR)g_originalWndProc);
            g_originalWndProc = NULL;
        }
        cout << "关机/关闭拦截已关闭！" << endl;
        ShowSystemNotification(TOOL_NAME, "关机/关闭拦截已关闭！");
    }
}

void ToggleDoubleGuard(bool enable) {
    if (enable) {
        if (g_hDoubleGuardThread == NULL || WaitForSingleObject(g_hDoubleGuardThread, 0) == WAIT_OBJECT_0) {
            g_hDoubleGuardThread = CreateThread(NULL, 0, DoubleGuardThread, NULL, 0, NULL);
            if (g_hDoubleGuardThread != NULL) {
                cout << "双进程守护已开启！" << endl;
                ShowSystemNotification(TOOL_NAME, "双进程守护已开启！");
            } else {
                cout << "创建双进程守护线程失败！" << endl;
                ShowSystemNotification(TOOL_NAME, "创建双进程守护线程失败！");
            }
        }
    } else {
        if (g_hDoubleGuardThread != NULL) {
            WaitForSingleObject(g_hDoubleGuardThread, 1000);
            CloseHandle(g_hDoubleGuardThread);
            g_hDoubleGuardThread = NULL;
        }
        cout << "双进程守护已关闭！" << endl;
        ShowSystemNotification(TOOL_NAME, "双进程守护已关闭！");
    }
}

void ToggleAutoRun(bool enable) {
    if (enable) {
        char regCmd[512] = {0};
        sprintf(regCmd,
            "reg add \"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\" /v JiyuProtect /t REG_SZ /d \"%s\" /f",
            g_SelfPath
        );
        system(regCmd);
        cout << "临时自启动已开启！" << endl;
        ShowSystemNotification(TOOL_NAME, "临时自启动已开启！");
    } else {
        system("reg delete \"HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\" /v JiyuProtect /f >nul 2>&1");
        cout << "临时自启动已关闭！" << endl;
        ShowSystemNotification(TOOL_NAME, "临时自启动已关闭！");
    }
}

void DisableConsoleClose() {
    HWND hConsole = GetConsoleWindow();
    if (hConsole != NULL) {
        HMENU hMenu = GetSystemMenu(hConsole, FALSE);
        if (hMenu != NULL) {
            EnableMenuItem(hMenu, SC_CLOSE, MF_GRAYED);
            RemoveMenu(hMenu, SC_CLOSE, MF_BYCOMMAND);
        }
    }
}

void KillChildProcesses(DWORD dwParentPID) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return;

    PROCESSENTRY32 pe32 = {0};
    pe32.dwSize = sizeof(PROCESSENTRY32);

    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (pe32.th32ParentProcessID == dwParentPID) {
                KillChildProcesses(pe32.th32ProcessID);
                
                HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe32.th32ProcessID);
                if (hProcess) {
                    TerminateProcess(hProcess, 0);
                    CloseHandle(hProcess);
                    cout << "  已终止子进程：" << pe32.szExeFile << " (PID: " << pe32.th32ProcessID << ")" << endl;
                }
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    CloseHandle(hSnapshot);
}

void KillProcessTreeByName(const char* szProcessName) {
    if (!szProcessName || strlen(szProcessName) == 0) return;

    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        cout << "创建进程快照失败，错误码：" << GetLastError() << endl;
        ShowSystemNotification(TOOL_NAME, "创建进程快照失败");
        return;
    }

    PROCESSENTRY32 pe32 = {0};
    pe32.dwSize = sizeof(PROCESSENTRY32);

    vector<DWORD> vecTargetPIDs;
    if (Process32First(hSnapshot, &pe32)) {
        do {
            if (_stricmp(pe32.szExeFile, szProcessName) == 0) {
                vecTargetPIDs.push_back(pe32.th32ProcessID);
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
    CloseHandle(hSnapshot);

    for (vector<DWORD>::iterator it = vecTargetPIDs.begin(); it != vecTargetPIDs.end(); ++it) {
        DWORD pid = *it;
        KillChildProcesses(pid);
        
        HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
        if (hProcess) {
            TerminateProcess(hProcess, 0);
            CloseHandle(hProcess);
            cout << "  已终止主进程：" << szProcessName << " (PID: " << pid << ")" << endl;
            g_killCount++;
        } else {
            cout << "  无法打开进程(PID: " << pid << ")，错误码：" << GetLastError() << endl;
        }
    }

    if (vecTargetPIDs.empty()) {
        cout << "  未找到进程：" << szProcessName << endl;
        ShowSystemNotification(TOOL_NAME, "未找到进程");
    } else {
        ShowSystemNotification(TOOL_NAME, "已终止进程树");
    }
}

bool IsRealScreenBroadcasting() {
    for (int i = 0; i < CAST_WND_COUNT; i++) {
        HWND hCastWnd = FindWindowA(CAST_WND_CLASSES[i], NULL);
        if (hCastWnd != NULL && IsWindowVisible(hCastWnd)) {
            cout << "  检测到广播窗口：" << CAST_WND_CLASSES[i] << endl;
            return true;
        }
    }
    return false;
}

bool IsRemoteControlActive() {
    HWND hWnd = NULL;
    do {
        hWnd = FindWindowExA(NULL, hWnd, NULL, NULL);
        if (hWnd == NULL) break;
        
        if (!IsWindowVisible(hWnd)) continue;
        
        char szTitle[256] = {0};
        GetWindowTextA(hWnd, szTitle, sizeof(szTitle) - 1);
        
        if (strstr(szTitle, "遥控辅导") != NULL) {
            DWORD dwProcessId = 0;
            GetWindowThreadProcessId(hWnd, &dwProcessId);
            if (dwProcessId == 0) continue;
            
            HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (hProcessSnap == INVALID_HANDLE_VALUE) continue;
            
            PROCESSENTRY32 pe32 = {0};
            pe32.dwSize = sizeof(PROCESSENTRY32);
            
            if (Process32First(hProcessSnap, &pe32)) {
                do {
                    if (_stricmp(pe32.szExeFile, "StudentMain.exe") == 0 && pe32.th32ProcessID == dwProcessId) {
                        CloseHandle(hProcessSnap);
                        cout << "  检测到遥控控制窗口：" << szTitle << endl;
                        return true;
                    }
                } while (Process32Next(hProcessSnap, &pe32));
            }
            CloseHandle(hProcessSnap);
        }
    } while (hWnd != NULL);
    
    return false;
}

DWORD WINAPI RemoteControlDetectThread(LPVOID lpParam) {
    cout << "\n【F1】精准遥控控制检测已启动！仅当老师控屏时自动终止StudentMain.exe！" << endl;
    cout << "【提示】再次按F1键可关闭检测\n" << endl;
    ShowSystemNotification(TOOL_NAME, "【F1】精准遥控控制检测已启动！");

    while (g_bDetectingRemoteControl) {
        if (IsRemoteControlActive()) {
            cout << "\n[" << __TIME__ << "] 检测到老师正在遥控控制本电脑！立即终止StudentMain.exe..." << endl;
            system("taskkill /F /IM StudentMain.exe > nul 2>&1");
            ShowSystemNotification(TOOL_NAME, "检测到老师正在遥控控制！已自动解除！");
            g_killCount++;
            cout << "[" << __TIME__ << "] 已终止控屏进程，累计操作：" << g_killCount << "次\n" << endl;
            Sleep(1000);
        }
        Sleep(500);
    }

    cout << "\n【F1】精准遥控控制检测已关闭！\n" << endl;
    ShowSystemNotification(TOOL_NAME, "【F1】精准遥控控制检测已关闭！");
    return 0;
}

void ToggleRemoteControlDetection() {
    g_bDetectingRemoteControl = !g_bDetectingRemoteControl;

    if (g_bDetectingRemoteControl) {
        if (g_hRemoteControlDetectThread == NULL) {
            g_hRemoteControlDetectThread = CreateThread(NULL, 0, RemoteControlDetectThread, NULL, 0, NULL);
            if (g_hRemoteControlDetectThread == NULL) {
                DWORD errCode = GetLastError();
                cout << "错误：创建遥控控制检测线程失败！错误码：" << errCode << endl;
                ShowSystemNotification(TOOL_NAME, "创建遥控控制检测线程失败！");
                g_bDetectingRemoteControl = false;
            } else {
                ShowSystemNotification(TOOL_NAME, "精准控屏检测已开启");
            }
        }
    } else {
        if (g_hRemoteControlDetectThread != NULL) {
            WaitForSingleObject(g_hRemoteControlDetectThread, 1000);
            CloseHandle(g_hRemoteControlDetectThread);
            g_hRemoteControlDetectThread = NULL;
            cout << "正在关闭【F1】精准遥控控制检测..." << endl;
            ShowSystemNotification(TOOL_NAME, "精准控屏检测已关闭");
        }
    }
}

DWORD WINAPI ScreenCastDetectThread(LPVOID lpParam) {
    cout << "\n【F2】精准广播检测已启动！仅当老师广播时自动终止StudentMain.exe！" << endl;
    cout << "【提示】再次按F2键可关闭检测\n" << endl;
    ShowSystemNotification(TOOL_NAME, "【F2】精准广播检测已启动！");

    while (g_bDetectingCast) {
        if (IsRealScreenBroadcasting()) {
            cout << "\n[" << __TIME__ << "] 检测到老师正在屏幕广播！立即终止StudentMain.exe..." << endl;
            system("taskkill /F /IM StudentMain.exe > nul 2>&1");
            ShowSystemNotification(TOOL_NAME, "检测到老师屏幕广播！已自动解除！");
            g_killCount++;
            cout << "[" << __TIME__ << "] 已终止广播进程，累计操作：" << g_killCount << "次\n" << endl;
            Sleep(1000);
        }
        Sleep(500);
    }

    cout << "\n【F2】精准广播检测已关闭！\n" << endl;
    ShowSystemNotification(TOOL_NAME, "【F2】精准广播检测已关闭！");
    return 0;
}

void ToggleScreenCastDetection() {
    g_bDetectingCast = !g_bDetectingCast;

    if (g_bDetectingCast) {
        if (g_hCastDetectThread == NULL) {
            g_hCastDetectThread = CreateThread(NULL, 0, ScreenCastDetectThread, NULL, 0, NULL);
            if (g_hCastDetectThread == NULL) {
                cout << "错误：创建检测线程失败！错误码：" << GetLastError() << endl;
                ShowSystemNotification(TOOL_NAME, "创建检测线程失败！");
                g_bDetectingCast = false;
            } else {
                ShowSystemNotification(TOOL_NAME, "精准广播检测已开启");
            }
        }
    } else {
        if (g_hCastDetectThread != NULL) {
            WaitForSingleObject(g_hCastDetectThread, 1000);
            CloseHandle(g_hCastDetectThread);
            g_hCastDetectThread = NULL;
            ShowSystemNotification(TOOL_NAME, "精准广播检测已关闭");
        }
    }
}

void CleanupGDIResources() {
    EnterCriticalSection(&g_csGlobal);
    if (g_hScreenBmp != NULL) {
        DeleteObject(g_hScreenBmp);
        g_hScreenBmp = NULL;
    }
    
    if (g_hFrozenWnd != NULL) {
        DestroyWindow(g_hFrozenWnd);
        g_hFrozenWnd = NULL;
    }
    g_nScreenW = 0;
    g_nScreenH = 0;
    g_isScreenFrozen = false;
    LeaveCriticalSection(&g_csGlobal);
}

LRESULT CALLBACK FrozenWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);
            EnterCriticalSection(&g_csGlobal);
            if (g_hScreenBmp != NULL) {
                HDC hMemDC = CreateCompatibleDC(hdc);
                if (hMemDC != NULL) {
                    HBITMAP hOldBmp = (HBITMAP)SelectObject(hMemDC, g_hScreenBmp);
                    BitBlt(hdc, 0, 0, g_nScreenW, g_nScreenH, hMemDC, 0, 0, SRCCOPY);
                    SelectObject(hMemDC, hOldBmp);
                    DeleteDC(hMemDC);
                }
            }
            LeaveCriticalSection(&g_csGlobal);
            EndPaint(hWnd, &ps);
            return 0;
        }
        case WM_ERASEBKGND: return 1;
        case WM_DESTROY:
        case WM_CLOSE:
            return 0;
        
        case WM_DISPLAYCHANGE:
            EnterCriticalSection(&g_csGlobal);
            g_nScreenW = LOWORD(lParam);
            g_nScreenH = HIWORD(lParam);
            if (g_hFrozenWnd != NULL) {
                SetWindowPos(g_hFrozenWnd, HWND_TOPMOST, 0, 0, g_nScreenW, g_nScreenH, SWP_NOACTIVATE);
                InvalidateRect(g_hFrozenWnd, NULL, TRUE);
            }
            LeaveCriticalSection(&g_csGlobal);
            return 0;
        default: return DefWindowProcA(hWnd, uMsg, wParam, lParam);
    }
}

void UnlockUSBStorage() {
    system("color 0A");
    cout<<endl<<"正在解禁……"; 
	system("sc stop TDFileFilter");
	cout <<endl;
	system("sc delete TDFileFilter");
	cout <<endl<<"解禁完成!"<<endl; 
	system("color 0F");
    system("pause >nul");
}

void SetCustomMythwarePassword() {
    cout << endl;
    cout << "==============================================" << endl;
    cout << "         极域电子教室2016密码修改工具" << endl;
    cout << "        请确保已【管理员权限】运行本程序！" << endl;
    cout << "==============================================" << endl;
    cout << endl;

    char customPassword[100] = {0};
    cout << " 请输入你想要设置的极域新密码：";
    cin.getline(customPassword, sizeof(customPassword) - 1);
    cin.clear();
    if (strlen(customPassword) == 0) {
        cout << "  错误：密码不能为空！" << endl;
        cout << "==============================================" << endl << endl;
        ShowSystemNotification(TOOL_NAME, "密码修改失败：不能为空");
        system("pause >nul");
        return;
    }

    char regValue[120] = "Passwd";
    strcat_s(regValue, _countof(regValue), customPassword, _TRUNCATE);

    char regCmd1[512] = {0};
    char regCmd2[512] = {0};
    sprintf(regCmd1, 
        "reg add \"HKEY_LOCAL_MACHINE\\SOFTWARE\\TopDomain\\e-learning Class Standard\\1.00\" /v UninstallPasswd /t REG_SZ /d %s /f >nul 2>&1", 
        regValue);
    sprintf(regCmd2, 
        "reg add \"HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\TopDomain\\e-learning Class Standard\\1.00\" /v UninstallPasswd /t REG_SZ /d %s /f >nul 2>&1", 
        regValue);

    system(regCmd1);
    system(regCmd2);

    cout << endl;
    cout << "  密码修改完成！新密码：" << customPassword << endl;
    cout << "  若提示拒绝访问 → 请右键以管理员身份运行本程序" << endl;
    cout << "==============================================" << endl << endl;
    ShowSystemNotification(TOOL_NAME, "极域密码修改完成！");
    system("pause >nul");
}

bool IsRunAsAdmin() {
    BOOL bIsAdmin = FALSE;
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    PSID pAdministratorSid = NULL;
    
    if (AllocateAndInitializeSid(&NtAuthority, 2,
        SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
        0, 0, 0, 0, 0, 0, &pAdministratorSid)) {
        CheckTokenMembership(NULL, pAdministratorSid, &bIsAdmin);
        FreeSid(pAdministratorSid);
    }
    
    return bIsAdmin != FALSE;
}

void RequestAdminPrivileges() {
    char szPath[MAX_PATH] = {0};
    if (GetModuleFileNameA(NULL, szPath, MAX_PATH)) {
        HINSTANCE hResult = ShellExecuteA(NULL, "runas", szPath, NULL, NULL, SW_SHOWNORMAL);
        if ((INT_PTR)hResult <= SHELLEXECUTE_FAILURE_THRESHOLD) {
            DWORD err = GetLastError();
            if (err == ERROR_CANCELLED) {
                cout << "用户拒绝管理员权限，部分功能失效！" << endl;
                ShowSystemNotification(TOOL_NAME, "未获得管理员权限，功能受限");
                system("pause >nul");
            }
        } else {
            exit(0);
        }
    }
}

void SafeShowConsole(bool show) {
    HWND hwnd = GetConsoleWindow();
    if (hwnd != NULL) {
        ShowWindow(hwnd, show ? SW_SHOW : SW_HIDE);
        ShowSystemNotification(TOOL_NAME, show ? "控制台已显示！" : "控制台已隐藏！");
    }
}

void SetConsoleWindowTopMost(bool topMost) {
    HWND hConsoleWnd = GetConsoleWindow();
    if (hConsoleWnd != NULL) {
        SetWindowPos(
            hConsoleWnd, 
            topMost ? HWND_TOPMOST : HWND_NOTOPMOST,
            0, 0, 0, 0, 
            SWP_NOMOVE | SWP_NOSIZE
        );
        cout << (topMost ? "控制台已置顶！" : "控制台取消置顶！") << endl;
        ShowSystemNotification(TOOL_NAME, topMost ? "控制台已置顶！" : "控制台取消置顶！");
    } else {
        cout << "错误：获取控制台窗口句柄失败！" << endl;
        ShowSystemNotification(TOOL_NAME, "获取控制台窗口句柄失败！");
    }
}

bool SystemCaptureScreenToMem() {
    EnterCriticalSection(&g_csGlobal);
    if (g_hScreenBmp != NULL) {
        DeleteObject(g_hScreenBmp);
        g_hScreenBmp = NULL;
    }
    LeaveCriticalSection(&g_csGlobal);

    HDC hScreenDC = GetDC(NULL);
    if (hScreenDC == NULL) {
        cout << "错误：获取屏幕DC失败！错误码：" << GetLastError() << endl;
        ShowSystemNotification(TOOL_NAME, "获取屏幕DC失败！");
        return false;
    }

    g_nScreenW = GetDeviceCaps(hScreenDC, HORZRES);
    g_nScreenH = GetDeviceCaps(hScreenDC, VERTRES);

    HDC hMemDC = CreateCompatibleDC(hScreenDC);
    if (hMemDC == NULL) {
        ReleaseDC(NULL, hScreenDC);
        cout << "错误：创建内存DC失败！错误码：" << GetLastError() << endl;
        ShowSystemNotification(TOOL_NAME, "创建内存DC失败！");
        return false;
    }

    BITMAPINFO bmi = {0};
    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth = g_nScreenW;
    bmi.bmiHeader.biHeight = -g_nScreenH;
    bmi.bmiHeader.biPlanes = 1;
    bmi.bmiHeader.biBitCount = 32;
    bmi.bmiHeader.biCompression = BI_RGB;

    void* pBits = NULL;
    HBITMAP hBmp = CreateDIBSection(hScreenDC, &bmi, DIB_RGB_COLORS, &pBits, NULL, 0);
    if (hBmp == NULL) {
        DeleteDC(hMemDC);
        ReleaseDC(NULL, hScreenDC);
        cout << "错误：创建DIB位图失败！错误码：" << GetLastError() << endl;
        ShowSystemNotification(TOOL_NAME, "创建DIB位图失败！");
        return false;
    }

    HBITMAP hOldBmp = (HBITMAP)SelectObject(hMemDC, hBmp);
    BitBlt(hMemDC, 0, 0, g_nScreenW, g_nScreenH, hScreenDC, 0, 0, SRCCOPY);
    SelectObject(hMemDC, hOldBmp);
    DeleteDC(hMemDC);
    ReleaseDC(NULL, hScreenDC);

    EnterCriticalSection(&g_csGlobal);
    g_hScreenBmp = hBmp;
    LeaveCriticalSection(&g_csGlobal);

    cout << "截屏成功！分辨率：" << g_nScreenW << "x" << g_nScreenH << endl;
    ShowSystemNotification(TOOL_NAME, "截屏成功！");
    return true;
}

DWORD WINAPI AsyncCaptureScreen(LPVOID lpParam) {
    g_bCapturing = true;
    for (int i = 3; i > 0 && g_bCapturing; i--) {
        cout << "\r 即将截屏定格，倒计时：" << i << "秒" << flush;
        Sleep(1000);
    }

    if (g_bCapturing) {
        cout << "\r 开始截屏！" << endl;
        ShowSystemNotification(TOOL_NAME, "开始截屏定格！");
        
        if (SystemCaptureScreenToMem()) {
            EnterCriticalSection(&g_csGlobal);
            
            WNDCLASSEXA wc = {0};
            wc.cbSize = sizeof(WNDCLASSEXA);
            wc.lpfnWndProc = FrozenWndProc;
            wc.hInstance = g_hInstance;
            wc.lpszClassName = FROZEN_WND_CLASS;
            wc.style = CS_HREDRAW | CS_VREDRAW;
            
            if (!RegisterClassExA(&wc)) {
                cout << "注册窗口类失败，错误码：" << GetLastError() << endl;
                LeaveCriticalSection(&g_csGlobal);
                CleanupGDIResources();
                g_bCapturing = false;
                return 1;
            }

            g_hFrozenWnd = CreateWindowExA(
                WS_EX_TOPMOST | WS_EX_NOACTIVATE,
                FROZEN_WND_CLASS,
                "ScreenFrozen",
                WS_POPUP | WS_VISIBLE,
                0, 0, g_nScreenW, g_nScreenH,
                NULL, NULL, g_hInstance, NULL
            );
            
            LeaveCriticalSection(&g_csGlobal);

            if (g_hFrozenWnd != NULL) {
                g_isScreenFrozen = true;
                cout << "成功！画面已定格，按R键恢复！" << endl;
                ShowSystemNotification(TOOL_NAME, "画面已定格，按R键恢复！");
            } else {
                cout << "错误：定格窗口创建失败！错误码：" << GetLastError() << endl;
                ShowSystemNotification(TOOL_NAME, "定格窗口创建失败！");
                UnregisterClassA(FROZEN_WND_CLASS, g_hInstance);
                CleanupGDIResources();
            }
        } else {
            cout << "错误：截屏失败！" << endl;
            ShowSystemNotification(TOOL_NAME, "截屏失败！");
        }
    }
    
    g_bCapturing = false;
    return 0;
}

void FreezeTeacherScreen() {
    EnterCriticalSection(&g_csGlobal);
    if (g_isScreenFrozen) {
        LeaveCriticalSection(&g_csGlobal);
        cout << "提示：画面已定格！" << endl;
        ShowSystemNotification(TOOL_NAME, "画面已定格！");
        return;
    }
    LeaveCriticalSection(&g_csGlobal);

    if (g_bCapturing) {
        cout << "提示：截屏中，请稍候！" << endl;
        ShowSystemNotification(TOOL_NAME, "截屏中，请稍候！");
        return;
    }

    if (g_hCaptureThread != NULL) {
        CloseHandle(g_hCaptureThread);
        g_hCaptureThread = NULL;
    }
    g_hCaptureThread = CreateThread(NULL, 0, AsyncCaptureScreen, NULL, 0, NULL);
    
    if (g_hCaptureThread == NULL) {
        cout << "错误：创建截屏线程失败！错误码：" << GetLastError() << endl;
        ShowSystemNotification(TOOL_NAME, "创建截屏线程失败！");
    }
}

void RestoreTeacherScreen() {
    EnterCriticalSection(&g_csGlobal);
    if (g_bCapturing) {
        g_bCapturing = false;
        LeaveCriticalSection(&g_csGlobal);
        cout << "截屏已取消！" << endl;
        ShowSystemNotification(TOOL_NAME, "截屏已取消！");
        return;
    }

    if (!g_isScreenFrozen) {
        LeaveCriticalSection(&g_csGlobal);
        cout << "提示：画面未定格！" << endl;
        ShowSystemNotification(TOOL_NAME, "画面未定格！");
        return;
    }
    LeaveCriticalSection(&g_csGlobal);

    CleanupGDIResources();
    UnregisterClassA(FROZEN_WND_CLASS, g_hInstance);
    cout << "成功！画面已恢复！" << endl;
    ShowSystemNotification(TOOL_NAME, "画面已恢复！");
}

void StartTaskManager() {
    ShowSystemNotification(TOOL_NAME, "任务管理器已启动！");
    system("taskmgr");
    cout << "任务管理器已启动！" << endl;
}

void OpenCustomUrlWithFake() {
    char customUrl[512] = {0};
    cout << "\n=====================================" << endl;
    cout << "请输入要访问的网址：" << endl;
    cout << "输入后按回车，将伪装为访问" << ALLOWED_DOMAIN << endl;
    cout << "例如以下网址:"<<endl;
    cout << "https://play.mc.js.cool/1.8/"<<endl;
    cout << "https://www.dogod.io"<<endl;
    cout << "https://slowroads.io/"<<endl;
    cout << "https://xg9.cn/my/4qVWxG"<<endl;
    cout << "=====================================\n输入：";
    cin.getline(customUrl, sizeof(customUrl) - 1);
    cin.clear();

    if (strlen(customUrl) == 0) {
        cout << "错误：未输入任何网址！" << endl;
        ShowSystemNotification(TOOL_NAME, "未输入任何网址！");
        return;
    }

    cout << "\n正在伪装访问... 目标：" << customUrl << endl;
    cout << "校园网检测：" << ALLOWED_DOMAIN << "（合法）" << endl;

    ShellExecuteA(NULL, "open", ALLOWED_DOMAIN, NULL, NULL, SW_SHOWNORMAL);
    Sleep(500);

    ShellExecuteA(NULL, "open", customUrl, NULL, NULL, SW_SHOWNORMAL);
    cout << "访问成功！若未打开，请检查网址格式（需带https/http）！" << endl;
    ShowSystemNotification(TOOL_NAME, "伪装访问成功！");
}

void ShowHelpInfo() {
	bool isAdmin = IsRunAsAdmin();
	cout << TOOL_TITLE << "已启动！" << endl<<endl;
    cout <<"当前状态:"<< (isAdmin ? "[+] 管理员权限" : "[-] 普通权限")<<endl;
    cout << "==================================================================================================================" << endl;
    cout << "后台全局监听中，按以下按键执行操作：\n\n";
    cout << "F1: 启停精准控屏检测       | F2: 启停精准广播检测| F3: 启停关机/关闭拦截       | M: 修改极域密码" <<endl << endl;
    cout << "F4: 启停双进程守护         | F5: 启停临时自启动  | E: 定格屏幕                 | R: 恢复屏幕" <<endl<< endl;
    cout << "K: 切换控制台置顶/取消置顶 | B: 结束极域(仅控屏) | V: 结束极域(全部+禁用服务)  | X: 恢复极域 | P: 隐藏/显示控制台"<<endl << endl;
    cout << "1-9: 打开对应网页/程序     | 按ESC退出程序       | Y: 自定义伪装访问网址       | Q: 删除极域 | D: 任务管理器" <<endl<< endl;
    cout<<"1.打开bcoi                    7.Kirka枪战"<<endl<<endl;
    cout<<"2.显示当前系统时间            8.gf25152鼠鼠主页"<<endl<<endl;
    cout<<"3.我的世界                    9.游戏总结"<<endl<<endl;
    cout<<"4.抡棒作战                    H: 显示按键说明"<<endl<<endl;
    cout<<"5.Slowroads                   T:解除U盘禁用"<<endl<<endl;
    cout<<"6.打开CMD命令提示符           ESC:退出极域工具箱"<<endl<<endl;
    cout<<"C:回到桌面                    Shift:进入安全桌面(金山政府版不支持)"<<endl; 
    cout << "==================================================================================================================" << endl;
}

void StartStudentMain() {
    ShellExecuteA(NULL, "open", STUDENT_MAIN_PATH, NULL, NULL, SW_SHOW);
    cout << "正在启动极域客户端..." << endl;
    ShowSystemNotification(TOOL_NAME, "正在启动极域客户端...");
}

void OpenWebPage(const char* url) {
    if (!url || strlen(url) == 0) return;
    
    ShellExecuteA(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL);
    ShowSystemNotification(TOOL_NAME, "已打开网页！");
    cout << "打开网页：" << url << endl;
}

void ShowDesktop()
{
    keybd_event(VK_LWIN, 0, 0, 0);
    keybd_event('D', 0, 0, 0);
    keybd_event('D', 0, KEYEVENTF_KEYUP, 0);
    keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
}

void OpenSecureDesktop()
{
    system("rundll32.exe shell32.dll,LockWorkStation");
}

void CheckGlobalKeys() {
    for (int i = 0; i < 256; i++) {
        if (GetAsyncKeyState(i) & KEY_STATE_PRESSED) {
            if (!g_keyStates[i]) {
                g_keyStates[i] = true;
                
                switch (i) {
                	case 'C':
                		ShowDesktop();
                		Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_SHIFT:
                    	OpenSecureDesktop();
                    	Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_F1:
                        ToggleRemoteControlDetection();
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_F2:
                        ToggleScreenCastDetection();
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_F3:
                        g_bAntiCloseEnabled = !g_bAntiCloseEnabled;
                        ToggleAntiCloseWndProc(g_bAntiCloseEnabled);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_F4:
                        g_bDoubleGuardEnabled = !g_bDoubleGuardEnabled;
                        ToggleDoubleGuard(g_bDoubleGuardEnabled);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case VK_F5:
                        g_bAutoRunEnabled = !g_bAutoRunEnabled;
                        ToggleAutoRun(g_bAutoRunEnabled);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    
                    case 'E': 
                        FreezeTeacherScreen(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'R': 
                        RestoreTeacherScreen(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'M': 
                        SetCustomMythwarePassword(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'B':
                        system("taskkill /F /IM StudentMain.exe");
                        g_killCount++;
                        cout << "B键操作完成！仅终止了StudentMain.exe进程" << endl;
                        ShowSystemNotification(TOOL_NAME, "已终止StudentMain.exe"); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'V':
                        cout << endl << "正在终止所有极域相关进程树并禁用服务..." << endl;
                        ShowSystemNotification(TOOL_NAME, "正在终止所有极域相关进程...");
                        system("sc stop JYService > nul 2>&1");
                        system("sc config JYService start= disabled > nul 2>&1");
                        
                        cout << "1. 终止MythwareService.exe进程树：" << endl;
                        KillProcessTreeByName("MythwareService.exe");
                        
                        cout << "2. 终止StudentMain.exe进程树：" << endl;
                        KillProcessTreeByName("StudentMain.exe");
                        
                        cout << "3. 终止XStudent.exe进程树：" << endl;
                        KillProcessTreeByName("XStudent.exe");
                        
                        cout << "4. 终止JYService.exe进程树：" << endl;
                        KillProcessTreeByName("JYService.exe");
                        
                        cout << endl << "C键操作完成！（进程树终止+服务禁用）" << endl;
                        ShowSystemNotification(TOOL_NAME, "极域已完全禁用"); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'Q':
                        cout << "正在删除极域相关文件和服务..." << endl;
                        ShowSystemNotification(TOOL_NAME, "正在删除极域...");
                        system("sc stop JYService > nul 2>&1 && sc delete JYService > nul 2>&1");
                        system("taskkill /f /im MythwareService.exe /im StudentMain.exe > nul 2>&1");
                        system("rmdir /s /q \"C:\\Program Files (x86)\\Mythware\" > nul 2>&1");
                        cout << "Q键操作完成！" << endl;
                        ShowSystemNotification(TOOL_NAME, "极域已彻底删除"); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'K': {
                        static bool consoleTopMost = true;
                        consoleTopMost = !consoleTopMost;
                        SetConsoleWindowTopMost(consoleTopMost);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    }
                    case 'D': 
                        StartTaskManager(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'H': 
                        ShowHelpInfo(); 
                        break;
                    case 'P': {
                        static bool consoleVisible = true;
                        consoleVisible = !consoleVisible;
                        SafeShowConsole(consoleVisible);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    } 
                    case 'X': 
                        StartStudentMain(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'T':
                        cout << "正在执行U盘解禁..." << endl;
                        ShowSystemNotification(TOOL_NAME, "正在执行U盘解禁...");
                        UnlockUSBStorage();
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case 'Y': 
                        OpenCustomUrlWithFake(); 
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case '2': {
                        time_t tNow = time(NULL);
                        tm* pLocalTm = localtime(&tNow);
                        char szTime[64] = {0};
                        sprintf(szTime, "%04d-%02d-%02d %02d:%02d:%02d",
                                pLocalTm->tm_year + 1900, pLocalTm->tm_mon + 1, pLocalTm->tm_mday,
                                pLocalTm->tm_hour, pLocalTm->tm_min, pLocalTm->tm_sec);
                        cout << "当前时间：" << szTime << endl;
                        ShowSystemNotification(TOOL_NAME, szTime);
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    }
                    case '6':
                        ShellExecuteA(NULL, "open", "cmd.exe", NULL, NULL, SW_SHOWNORMAL);
                        cout << "已打开CMD！" << endl;
                        ShowSystemNotification(TOOL_NAME, "已打开CMD命令提示符！");
                        Sleep(2000);
                        system("cls");
                        ShowHelpInfo();
                        break;
                    case '1': OpenWebPage("http://www.bcoi.com"); break;
                    case '3': OpenWebPage("https://play.mcjs.cc/1.8.8/"); break;
                    case '4': OpenWebPage("https://www.dogod.io"); break;
                    case '5': OpenWebPage("https://slowroads.io/"); break;
                    case '7': OpenWebPage("https://kirka.io/games/ASIA~6l73mx3lD"); break;
                    case '8': OpenWebPage("https://www.bcoi.cn/d/gfhd/user/616"); break;
                    case '9': OpenWebPage("https://xg9.cn/my/4qVWxG"); break;
                    default: break;
                }
            }
        } else {
            g_keyStates[i] = false;
        }
    }
}


int main() {
	MessageBox(NULL,"这个版本可能是最终版了\n感谢您使用极域工具箱","感谢使用",MB_OK);
    //InitializeCriticalSection(&g_csGlobal);
    ios::sync_with_stdio(false);
    SetConsoleCP(CONSOLE_CODE_PAGE);

    g_hInstance = GetModuleHandleA(NULL);
    memset(g_keyStates, 0, sizeof(g_keyStates));
    g_originalWndProc = NULL;
    
    GetModuleFileNameA(NULL, g_SelfPath, MAX_PATH);
    
    DisableConsoleClose();
    
    //ToggleAntiCloseWndProc(g_bAntiCloseEnabled);
    //ToggleDoubleGuard(g_bDoubleGuardEnabled);
    //ToggleAutoRun(g_bAutoRunEnabled);
    //ToggleRemoteControlDetection();
    //ToggleScreenCastDetection();

    bool isAdmin = IsRunAsAdmin();
    if (!isAdmin) {
        cout << "检测到非管理员权限，正在请求..."<<endl;
        ShowSystemNotification(TOOL_NAME, "正在请求管理员权限...");
        Sleep(1000);
        RequestAdminPrivileges();
        system("cls");
    }
    
    system("title 极域V6.0 2016豪华版工具v20.0Pro");
    system("cls");

    //cout << TOOL_TITLE << "已启动！" << endl<<endl;
    //cout <<"当前状态:"<< (isAdmin ? "[+] 管理员权限" : "[-] 普通权限");
    //cout << "[+] U盘解禁功能已修复！" << endl;
    //cout << "[+] 注意：程序启动时默认置顶窗口！" << endl;
    HWND hConsoleWnd = GetConsoleWindow();
    SetWindowPos(
            hConsoleWnd, 
            HWND_TOPMOST,
            0, 0, 0, 0, 
            SWP_NOMOVE | SWP_NOSIZE
        );
    cout<<endl; 
    ShowHelpInfo();

    MSG msg = {0};
    bool running = true;
    while (running) {
        while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) running = false;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        
        CheckGlobalKeys();
        
        if (GetAsyncKeyState(VK_ESCAPE) & KEY_STATE_PRESSED) running = false;
        
        Sleep(10);
    }

    g_AllowExit = true;
    
    if (g_bDetectingRemoteControl) {
        g_bDetectingRemoteControl = false;
        if (g_hRemoteControlDetectThread != NULL) {
            CloseHandle(g_hRemoteControlDetectThread);
            g_hRemoteControlDetectThread = NULL;
        }
    }

    if (g_bDetectingCast) {
        g_bDetectingCast = false;
        if (g_hCastDetectThread != NULL) {
            CloseHandle(g_hCastDetectThread);
            g_hCastDetectThread = NULL;
        }
    }

    if (g_originalWndProc != NULL) {
        HWND hConsole = GetConsoleWindow();
        if (hConsole != NULL) {
            SetWindowLongPtrA(hConsole, GWLP_WNDPROC, (LONG_PTR)g_originalWndProc);
        }
    }

    if (g_hDoubleGuardThread != NULL) {
        CloseHandle(g_hDoubleGuardThread);
        g_hDoubleGuardThread = NULL;
    }

    if (g_bAutoRunEnabled) {
        ToggleAutoRun(false);
    }

    RestoreTeacherScreen();
    UnregisterClassA(FROZEN_WND_CLASS, g_hInstance);
    UnregisterClassA(ANTI_CLOSE_WND_CLASS, g_hInstance);

    if (g_hCaptureThread != NULL) {
        CloseHandle(g_hCaptureThread);
        g_hCaptureThread = NULL;
    }

    DeleteCriticalSection(&g_csGlobal);

    cout << "\n程序即将退出，共肘击极域 " << g_killCount << " 次！" << endl;
    ShowSystemNotification(TOOL_NAME, "工具已退出");
    DeleteCriticalSection(&g_csGlobal);
    system("pause > nul");
    
    return 0;
}