/*gf25051小黄原创代码专属水印*/
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <shellapi.h>
#include <tlhelp32.h>
#include <ctime>
using namespace std;

const char* STUDENT_MAIN_PATH = "C:\\Program Files (x86)\\Mythware\\极域课堂管理系统软件V6.0 2016 豪华版\\StudentMain.exe";
const char* FROZEN_WND_CLASS = "ClassScreenFrozenWnd";

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

int killCount = 0;
bool keyStates[256];
bool 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;

void UnlockUSBStorage() {
    HKEY hKey;
	system("taskkill /im StudentMain.exe /f"); 
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\USBSTOR", 
                      0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
        DWORD startType = 3;
        RegSetValueExA(hKey, "Start", 0, REG_DWORD, (LPBYTE)&startType, sizeof(DWORD));
        RegCloseKey(hKey);
        system("sc start USBSTOR > nul 2>&1");
    }

    RegDeleteKeyA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MountPoints2");

    if (RegOpenKeyExA(HKEY_CURRENT_USER, 
                      "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", 
                      0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
        RegDeleteValueA(hKey, "NoDrives");
        RegDeleteValueA(hKey, "NoViewOnDrive");
        RegCloseKey(hKey);
    }

    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, 
                      "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", 
                      0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
        RegDeleteValueA(hKey, "NoDrives");
        RegDeleteValueA(hKey, "NoViewOnDrive");
        RegCloseKey(hKey);
    }

    system("dism /online /enable-feature /featurename:exfat /all > nul 2>&1");

    system("taskkill /f /im explorer.exe > nul 2>&1 && start explorer.exe > nul 2>&1");

    system("devcon rescan > nul 2>&1");
	killCount++; 
    cout << endl << "T键 机房U盘全局解禁完成！" << endl;
    cout << "支持格式：FAT32 / NTFS / exFAT 全部通用" << endl;
    cout << "操作建议：拔插一次U盘，即可正常使用" << endl;
}

bool IsRunAsAdmin();
void show();
void RequestAdminPrivileges();
void SafeShowConsole(bool show);
DWORD WINAPI AsyncCaptureScreen(LPVOID lpParam);
bool SystemCaptureScreenToMem();
LRESULT CALLBACK FrozenWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
bool RegisterFrozenWndClass();
HWND CreateFullScreenFrozenWnd();
void FreezeTeacherScreen();
void RestoreTeacherScreen();
void checkGlobalKeys();
void StartTaskManager();
void StartStudentMain();
void OpenWebPage(const char* url);

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 <= 32) {
            DWORD err = GetLastError();
            if (err == ERROR_CANCELLED) {
                cout << "用户拒绝管理员权限，部分功能可能失效！" << endl;
                cout << "按任意键继续..." << endl;
                system("pause >nul");
            }
        } else {
            exit(0);
        }
    }
}

void SafeShowConsole(bool show) {
    HWND hwnd = GetConsoleWindow();
    if (hwnd != NULL) {
        ShowWindow(hwnd, show ? SW_SHOW : SW_HIDE);
    }
}

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 <<endl<< "错误：获取屏幕DC失败！" << endl;
        return false;
    }
    
    g_nScreenW = GetDeviceCaps(hScreenDC, HORZRES);
    g_nScreenH = GetDeviceCaps(hScreenDC, VERTRES);
    
    HDC hMemDC = CreateCompatibleDC(hScreenDC);
    if (hMemDC == NULL) {
        ReleaseDC(NULL, hScreenDC);
        cout <<endl<< "错误：创建内存DC失败！" << endl;
        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 <<endl<< "错误：创建DIB位图失败！" << endl;
        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 <<endl<< "截屏成功！内存位图分辨率：" << g_nScreenW << "x" << g_nScreenH << endl;
    return true;
}

DWORD WINAPI AsyncCaptureScreen(LPVOID lpParam) {
    g_bCapturing = true;
    
    for (int i = 3; i > 0 && g_bCapturing; i--) {
        cout <<endl<< "\r 即将截屏定格，倒计时：" << i << "秒" << flush;
        Sleep(1000);
    }
    
    if (g_bCapturing) {
        cout <<endl<< "\r 开始截屏！" << endl;
        if (SystemCaptureScreenToMem()) {
            EnterCriticalSection(&g_csGlobal);
            g_hFrozenWnd = CreateFullScreenFrozenWnd();
            LeaveCriticalSection(&g_csGlobal);
            
            if (g_hFrozenWnd != NULL) {
                isScreenFrozen = true;
                cout <<endl<< "成功！画面已定格，按R键恢复！" << endl;
            } else {
                cout <<endl<< "错误：定格窗口创建失败！" << endl;
                EnterCriticalSection(&g_csGlobal);
                if (g_hScreenBmp != NULL) {
                    DeleteObject(g_hScreenBmp);
                    g_hScreenBmp = NULL;
                }
                LeaveCriticalSection(&g_csGlobal);
            }
        } else {
            cout <<endl<< "错误：截屏失败，无法定格！" << endl;
        }
    }
    
    g_bCapturing = false;
    g_hCaptureThread = NULL;
    return 0;
}

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 && g_nScreenW > 0 && g_nScreenH > 0) {
                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_NCHITTEST:
            return HTCLIENT;
        default:
            return DefWindowProcA(hWnd, uMsg, wParam, lParam);
    }
}

bool RegisterFrozenWndClass() {
    WNDCLASSEXA wc;
    memset(&wc, 0, sizeof(WNDCLASSEXA));
    wc.cbSize = sizeof(WNDCLASSEXA);
    wc.lpfnWndProc = FrozenWndProc;
    wc.hInstance = g_hInstance;
    wc.lpszClassName = FROZEN_WND_CLASS;
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    ATOM atom = RegisterClassExA(&wc);
    return atom != 0;
}

HWND CreateFullScreenFrozenWnd() {
    if (g_nScreenW <= 0 || g_nScreenH <= 0) {
        cout <<endl<<"错误：屏幕分辨率无效！" << endl;
        return NULL;
    }
    
    DWORD dwExStyle = WS_EX_TOPMOST | WS_EX_NOACTIVATE | WS_EX_LAYERED;
    DWORD dwStyle = WS_POPUP | WS_VISIBLE;
    
    HWND hWnd = CreateWindowExA(
        dwExStyle,
        FROZEN_WND_CLASS,
        "ScreenFrozen",
        dwStyle,
        0, 0, g_nScreenW, g_nScreenH,
        NULL, NULL, g_hInstance, NULL
    );
    
    if (hWnd != NULL) {
        SetLayeredWindowAttributes(hWnd, 0, 255, LWA_ALPHA);
        SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
        InvalidateRect(hWnd, NULL, FALSE);
        UpdateWindow(hWnd);
        ShowWindow(hWnd, SW_SHOWMAXIMIZED);
    }
    return hWnd;
}

void FreezeTeacherScreen() {
    EnterCriticalSection(&g_csGlobal);
    if (isScreenFrozen) {
        LeaveCriticalSection(&g_csGlobal);
        cout <<endl<< "提示：画面已定格，无需重复操作！" << endl;
        return;
    }
    LeaveCriticalSection(&g_csGlobal);
    
    if (g_bCapturing) {
        cout <<endl<< "提示：截屏操作正在进行中，请稍候！" << endl;
        return;
    }
    
    g_hCaptureThread = CreateThread(NULL, 0, AsyncCaptureScreen, NULL, 0, NULL);
    if (g_hCaptureThread == NULL) {
        cout <<endl<< "错误：创建截屏线程失败！" << endl;
        return;
    }
    CloseHandle(g_hCaptureThread);
}

void RestoreTeacherScreen() {
    EnterCriticalSection(&g_csGlobal);
    if (g_bCapturing) {
        g_bCapturing = false;
        LeaveCriticalSection(&g_csGlobal);
        cout <<endl<< "截屏操作已取消！" << endl;
        return;
    }
    
    if (!isScreenFrozen) {
        LeaveCriticalSection(&g_csGlobal);
        cout <<endl<< "提示：画面未定格，无需恢复！" << endl;
        return;
    }
    
    if (g_hFrozenWnd != NULL) {
        DestroyWindow(g_hFrozenWnd);
        g_hFrozenWnd = NULL;
    }
    if (g_hScreenBmp != NULL) {
        DeleteObject(g_hScreenBmp);
        g_hScreenBmp = NULL;
    }
    g_nScreenW = 0;
    g_nScreenH = 0;
    isScreenFrozen = false;
    LeaveCriticalSection(&g_csGlobal);
    
    cout <<endl<< "成功！画面已恢复实时显示！" << endl;
}

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

void show() {
    cout << "=========================================================================================================" << endl;
    cout << "后台全局监听中，按以下按键执行操作：\n\n";
    cout << "B: 结束极域（仅控屏） | C: 结束极域（全部+禁用服务） | X: 恢复极域(已修复) | T: 解除U盘禁用"<<endl << endl;
    cout << "1-9: 打开对应网页/程序 | 按ESC退出程序 | 按E定格教师端此电脑的屏幕" <<endl<< endl;
    cout<<"1.打开bcoi                    7.gf25051小黄主页"<<endl<<endl;
    cout<<"2.显示当前系统时间            8.gf25152鼠鼠主页"<<endl<<endl;
    cout<<"3.我的世界                    9.游戏总结"<<endl<<endl;
    cout<<"4.抡棒作战                    Q.删掉极域!!!!!!!!!!! （需要管理员权限）"<<endl<<endl;
    cout<<"5.Slowroads                   P:后台运行杀手（后台运行更隐蔽） | 再次按P:恢复控制台显示"<<endl<<endl;
    cout<<"6.打开CMD命令提示符           ESC:退出杀手"<<endl<<endl;
	cout<<"D:任务管理器                  H:显示对应网页/程序"<<endl;
    cout << "=========================================================================================================" << endl << endl;
}

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

void OpenWebPage(const char* url) {
    ShellExecuteA(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL);
}

void checkGlobalKeys() {
    for (int i = 0; i < 256; i++) {
        if (GetAsyncKeyState(i) & 0x8000) {
            if (!keyStates[i]) {
                keyStates[i] = true;
                switch (i) {
                    case 'E': FreezeTeacherScreen(); break;
                    case 'R': RestoreTeacherScreen(); break;
                    case 'B': 
                        cout <<endl<< "正在强制终止StudentMain.exe..." << endl;
                        system("taskkill /F /IM StudentMain.exe");
                        killCount++;
                        cout <<endl<< "B键操作完成！" << endl;
                        break;
                    case 'C': 
                        cout <<endl<< "正在终止所有极域相关进程并禁用服务..." << endl;
                        system("sc stop JYService > nul 2>&1");
                        system("sc config JYService start= disabled > nul 2>&1");
                        system("taskkill /im MythwareService.exe /f > nul 2>&1");
                        system("taskkill /im StudentService_Proxy.exe /f > nul 2>&1");
                        system("taskkill /im StudentMain.exe /f > nul 2>&1");
                        system("taskkill /im XStudent.exe /f > nul 2>&1");
                        system("taskkill /im XTRudent.exe /f > nul 2>&1");
                        system("taskkill /im GATESRV.exe /f > nul 2>&1");
                        system("taskkill /im DispcapHelper.exe /f > nul 2>&1");
                        system("taskkill /im MasterHelper.exe /f > nul 2>&1");
                        system("taskkill /im ProcHelper64.exe /f > nul 2>&1");
                        system("taskkill /im Student.exe /f > nul 2>&1");
                        system("taskkill /im JYService.exe /f > nul 2>&1");
                        system("taskkill /im jyclass.exe /f > nul 2>&1");
                        cout <<endl<< "C键操作完成！（进程终止+服务禁用）" << endl;
                        break;
                    case 'Q': 
                        cout << "正在清理极域所有进程、服务及文件夹..." << endl;
                        system("sc stop JYService > nul 2>&1");
                        system("sc config JYService start= disabled > nul 2>&1");
                        system("taskkill /im MythwareService.exe /f > nul 2>&1");
                        system("taskkill /im StudentService_Proxy.exe /f > nul 2>&1");
                        system("taskkill /im StudentMain.exe /f > nul 2>&1");
                        system("taskkill /im XStudent.exe /f > nul 2>&1");
                        system("taskkill /im XTRudent.exe /f > nul 2>&1");
                        system("taskkill /im GATESRV.exe /f > nul 2>&1");
                        system("taskkill /im DispcapHelper.exe /f > nul 2>&1");
                        system("taskkill /im MasterHelper.exe /f > nul 2>&1");
                        system("taskkill /im ProcHelper64.exe /f > nul 2>&1");
                        system("taskkill /im Student.exe /f > nul 2>&1");
                        system("taskkill /im JYService.exe /f > nul 2>&1");
                        system("taskkill /im jyclass.exe /f > nul 2>&1");
                        system("rmdir /s /q /y \"C:\\Program Files (x86)\\Mythware\" > nul 2>&1");
                        system("del /f /s /q /y \"C:\\Program Files (x86)\\Mythware\\*.*\" > nul 2>&1");
                        cout <<endl<< "Q键操作完成！（全量清理：进程+服务+文件夹）" << endl;
                        break;
                    case 'D': StartTaskManager(); break;
                    case 'H': show(); break;
                    case 'P': {
                        static bool consoleVisible = true;
                        consoleVisible = !consoleVisible;
                        SafeShowConsole(consoleVisible);
                    } break;
                    case 'X': StartStudentMain(); break;
                    case 'T':
                        cout << endl << "正在执行机房U盘全局解禁(管理员权限)..." << endl;
                        UnlockUSBStorage(); 
                        break;
                    case '2': {
                        cout << endl << "-----------------------------------" << endl;
                        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;
                        cout << "-----------------------------------" << endl;
                        break;
                    }
                    case '6': {
                        ShellExecuteA(NULL, "open", "cmd.exe", NULL, NULL, SW_SHOW);
                        cout << endl << "     已打开CMD命令提示符窗口！" << endl;
                        break;
                    }
                    case '1': case '3': case '4': case '5': case '7': case '8': case '9': {
                        const char* urls[] = {
                            "http://www.bcoi.com", "https://play.mc.js.cool/1.8/",
                            "https://www.dogod.io", "https://slowroads.io/",
                            "https://www.bcoi.cn/d/gfhd/user/507",
                            "https://www.bcoi.cn/d/gfhd/user/616",
                            "https://xg9.cn/my/4qVWxG"
                        };
                        int idx = -1;
                        if (i == '1') idx = 0;
                        else if (i == '3') idx = 1;
                        else if (i == '4') idx = 2;
                        else if (i == '5') idx = 3;
                        else if (i == '7') idx = 4;
                        else if (i == '8') idx = 5;
                        else if (i == '9') idx = 6;
                        if (idx >= 0) {
                            OpenWebPage(urls[idx]);
                            cout <<endl<< "正在打开网页：" << urls[idx] << endl;
                        }
                        break;
                    }
                    default: break;
                }
            }
        } else {
            keyStates[i] = false;
        }
    }
}

int main() {
    InitializeCriticalSection(&g_csGlobal);
    g_hInstance = GetModuleHandleA(NULL);
    memset(keyStates, 0, sizeof(keyStates));
    
    if (!RegisterFrozenWndClass()) {
        MessageBoxA(NULL, "窗口类注册失败！", "错误", MB_OK | MB_ICONERROR);
        DeleteCriticalSection(&g_csGlobal);
        return 1;
    }
    
    bool isAdmin = IsRunAsAdmin();
    if (!isAdmin) {
        cout << "=====================================" << endl;
        cout << "  极域工具箱V12.5Pro - DEV-C++专用版" << endl;
        cout << "=====================================" << endl << endl;
        cout << "检测到非管理员权限，部分功能可能受限！" << endl;
        cout << "正在请求管理员权限，请在弹窗中点击【是】！" << endl << endl;
        Sleep(2000);
        RequestAdminPrivileges();
        system("cls");
    }
    
    system("title 极域全能工具箱v12.5Pro（万能版） - 全局监听中");
    system("chcp 936 > nul");
    system("cls");
    
    cout << "极域全能工具箱V12.5Pro（万能版）" << endl<<endl;
    cout << "运行环境：DEV-C++5.11 | 适配Windows7/10/11" << endl << endl;
    cout << (isAdmin ? "[+] 当前权限：管理员（所有功能可用）" : "[-] 当前权限：标准用户（部分功能受限）") << endl<<endl;
    cout << "=========================================================================================================" << endl;
    cout << "后台全局监听中，按以下按键执行操作：\n\n";
    cout << "B: 结束极域（仅控屏） | C: 结束极域（全部+禁用服务） | X: 恢复极域(已修复) | T: 解除U盘禁用"<<endl << endl;
    cout << "1-9: 打开对应网页/程序 | 按ESC退出程序 | 按E定格教师端此电脑的屏幕" <<endl<< endl;
    cout<<"1.打开bcoi                    7.gf25051小黄主页"<<endl<<endl;
    cout<<"2.显示当前系统时间            8.gf25152鼠鼠主页"<<endl<<endl;
    cout<<"3.我的世界                    9.游戏总结"<<endl<<endl;
    cout<<"4.抡棒作战                    Q.删掉极域!!!!!!!!!!! （需要管理员权限）"<<endl<<endl;
    cout<<"5.Slowroads                   P:后台运行杀手（后台运行更隐蔽） | 再次按P:恢复控制台显示"<<endl<<endl;
    cout<<"6.打开CMD命令提示符           ESC:退出杀手"<<endl<<endl;
	cout<<"D:任务管理器                  H:显示对应网页/程序"<<endl;
    cout << "=========================================================================================================" << endl;
    
    MSG msg;
    bool running = true;
    while (running) {
        while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) {
                running = false;
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        checkGlobalKeys();
        if (GetAsyncKeyState(VK_ESCAPE) & 0x8000) running = false;
        Sleep(10);
    }
    
    RestoreTeacherScreen();
    UnregisterClassA(FROZEN_WND_CLASS, g_hInstance);
    DeleteCriticalSection(&g_csGlobal);
    
    cout << endl << endl;
    cout <<endl<< "程序即将退出，共操作极域 " << killCount << " 次！" << endl;
    cout <<endl<< "按任意键关闭窗口..." << endl;
    system("pause > nul");
    return 0;
}
/*gf25051小黄原创代码专属水印*/