说好的开源来了，Nuke 2015 1月9日更新 LOL 无限视距 过TP源码来了

lovemf

刚回家，看到游戏又更新了，所以来再次更新下，自己小号人机测试无碍，不过不排除，建议小号测试下再用，最好能反馈下。

1月9日更新过TP部分代码，新增多种过检测方式，源码中有说明。



搞LOL辅助，只钦佩几个人，真正为大家提供帮助的，为大家贡献了很多好东西

cmc5410
易模板先生
China Ren
小小视距
小蛮视距

我知道发布这个，会影响部分收费辅助的作者，但是大家想想，无限视距现在日益封闭严重，搞这个真没什么搞，很多玩家也开始渐渐习惯了没有视距了，既然如此，不如发布出来，让大家共同研究进步，人多力量才大，至于那些说自己防封技术如何如何的，我只能呵呵，别的不说，你敢像我这样开源么？至少我现在是不封号的。最后一次发布更新，已开始习惯正常视距。

无限视距EC.ec   驱动模板，不设主页，不报毒，纯绿色模板，有人问既然提供源码了，为何模板不开源，其实我想说，对于现在这种情况发了模板其实已经相当于开源了，至于是为什么自己研究吧，不能说的太明了。
无限视距单独版.e   源码，配合模板使用，内带许多实用功能。

吾爱扣扣

是因为模块能逆出源码吗？呵呵，支持楼主开源！

幻影

奉上模块源码！！！！
' 文件类型：未知类型

' 程序名称：无限视距专用 Nuke V1.1
' 程序描述：不异常、过TP、不报病毒、不追封！
@备注:
不异常、过TP、不报病毒、不追封！
' 程序作者：Nuke
' 邮政编码：
' 联系地址：
' 联系电话：
' 传真号码：
' 电子信箱：
' 主页地址：
' 版权声明：不异常、过TP、不报病毒、不追封！
' 版本号：1.0
' 创建号：0.0



.常量 匿名常量_2578, "5", ,
.常量 匿名常量_2590, "2", ,
.常量 匿名常量_2628, "2", ,
.常量 匿名常量_2675, "3", ,
.常量 匿名常量_2979, "2", ,
.常量 匿名常量_2980, "8", ,
.常量 匿名常量_2981, "16", ,
.常量 匿名常量_3138, "2", ,
.图片 匿名图片_463, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_463", ,
.图片 匿名图片_689, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_689", ,
.常量 匿名常量_3267, "34", ,
.常量 匿名常量_3268, "0", ,
.常量 匿名常量_3269, "3", ,
.图片 匿名图片_3270, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_3270", ,
.图片 匿名图片_3271, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_3271", ,
.图片 匿名图片_3272, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_3272", ,
.图片 匿名图片_3273, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_3273", ,
.图片 匿名图片_3274, " ' 已保存到：E:\电脑编程软件\易语言文件分析软件及源码 2014年11月5日\data\匿名图片_3274", ,


' 所需要的支持库：
' krnln d09f2340818511d396f6aaf844c7e325 5 3 系统核心支持库
' internet 707ca37322474f6ca841f0e224f4b620 2 0 互联网支持库




数据类型 匿名数据类型_108, ,
    .成员 匿名成员109, 整数型, , ,
    .成员 匿名成员110, 整数型, , ,
    .成员 匿名成员111, 整数型, , ,
    .成员 匿名成员112, 整数型, , ,

数据类型 匿名数据类型_1206, ,
    .成员 匿名成员1207, 整数型, , ,
    .成员 匿名成员1208, 整数型, , ,
    .成员 匿名成员1209, 整数型, , ,
    .成员 匿名成员1210, 整数型, , ,
    .成员 匿名成员1211, 整数型, , ,

数据类型 匿名数据类型_693, ,
    .成员 匿名成员694, 整数型, , ,
    .成员 匿名成员695, 长整数型, , ,
    .成员 匿名成员696, 整数型, , ,
    .成员 匿名成员697, 整数型, , ,

数据类型 匿名数据类型_2304, ,
    .成员 匿名成员2305, 整数型, , ,
    .成员 匿名成员2306, 长整数型, , ,
    .成员 匿名成员2307, 整数型, , ,
    .成员 匿名成员2308, 整数型, , ,
    .成员 匿名成员2309, 整数型, , ,

数据类型 窗口信息型, 公开, 枚举窗口信息
    .成员 窗口句柄, 整数型, , ,
    .成员 进程ID, 整数型, , ,
    .成员 线程ID, 整数型, , ,
    .成员 窗口类名, 文本型, , ,
    .成员 窗口标题, 文本型, , ,

数据类型 进程信息型, 公开,
    .成员 父进程ID, 整数型, , ,
    .成员 进程ID, 整数型, , ,
    .成员 进程名称, 文本型, , ,
    .成员 进程路径, 文本型, , ,

数据类型 匿名数据类型_2456, ,
    .成员 匿名成员2516, 整数型, , ,
    .成员 匿名成员2517, 整数型, , ,
    .成员 匿名成员2518, 整数型, , ,
    .成员 匿名成员2519, 整数型, , ,
    .成员 匿名成员2520, 整数型, , ,
    .成员 匿名成员2521, 整数型, , ,
    .成员 匿名成员2522, 整数型, , ,
    .成员 匿名成员2523, 整数型, , ,
    .成员 匿名成员2524, 整数型, , ,
    .成员 匿名成员2525, 字节型, , "256",

数据类型 匿名数据类型_2530, ,
    .成员 匿名成员2531, 整数型, , ,
    .成员 匿名成员2532, 整数型, , ,
    .成员 匿名成员2533, 整数型, , ,
    .成员 匿名成员2534, 整数型, , ,
    .成员 匿名成员2535, 整数型, , ,
    .成员 匿名成员2536, 整数型, , ,
    .成员 匿名成员2537, 整数型, , ,
    .成员 匿名成员2538, 整数型, , ,
    .成员 匿名成员2539, 整数型, , ,
    .成员 匿名成员2540, 字节型, , "256",

数据类型 匿名数据类型_2552, ,
    .成员 匿名成员2553, 整数型, , ,
    .成员 匿名成员2554, 整数型, , ,
    .成员 匿名成员2555, 整数型, , ,
    .成员 匿名成员2556, 整数型, , ,
    .成员 匿名成员2557, 整数型, , ,
    .成员 匿名成员2558, 整数型, , ,
    .成员 匿名成员2559, 整数型, , ,
    .成员 匿名成员2560, 整数型, , ,
    .成员 匿名成员2561, 字节型, , "256",
    .成员 匿名成员2562, 字节型, , "256",

数据类型 匿名数据类型_2614, ,
    .成员 匿名成员2615, 整数型, , ,
    .成员 匿名成员2616, 整数型, , ,
    .成员 匿名成员2617, 整数型, , ,
    .成员 匿名成员2618, 整数型, , ,
    .成员 匿名成员2619, 整数型, , ,
    .成员 匿名成员2620, 整数型, , ,
    .成员 匿名成员2621, 整数型, , ,
    .成员 匿名成员2622, 整数型, , ,
    .成员 匿名成员2623, 整数型, , ,
    .成员 匿名成员2624, 字节型, , "256",

数据类型 匿名数据类型_2756, ,
    .成员 匿名成员2757, 整数型, , ,
    .成员 匿名成员2758, 子程序指针, , ,
    .成员 匿名成员2759, 整数型, , ,
    .成员 匿名成员2760, 整数型, , ,
    .成员 匿名成员2761, 整数型, , ,
    .成员 匿名成员2762, 字节型, , ,
    .成员 匿名成员2763, 逻辑型, , ,
    .成员 匿名成员2764, 逻辑型, , ,

数据类型 匿名数据类型_2774, ,
    .成员 匿名成员2775, 整数型, , ,
    .成员 匿名成员2776, 整数型, , ,
    .成员 匿名成员2777, 整数型, , ,
    .成员 匿名成员2778, 整数型, , ,
    .成员 匿名成员2779, 整数型, , ,
    .成员 匿名成员2780, 整数型, , ,
    .成员 匿名成员2781, 整数型, , ,
    .成员 匿名成员2782, 整数型, , ,
    .成员 匿名成员2783, 字节型, , "256",
    .成员 匿名成员2784, 字节型, , "256",

数据类型 匿名数据类型_2915, ,
    .成员 匿名成员2916, 整数型, , ,
    .成员 匿名成员2917, 整数型, , ,
    .成员 匿名成员2918, 文本型, , ,
    .成员 匿名成员2919, 文本型, , ,

数据类型 匿名数据类型_3155, ,
    .成员 匿名成员3156, 整数型, , ,
    .成员 匿名成员3157, 整数型, , ,
    .成员 匿名成员3158, 整数型, , ,
    .成员 匿名成员3159, 整数型, , ,
    .成员 匿名成员3160, 整数型, , ,
    .成员 匿名成员3161, 整数型, , ,
    .成员 匿名成员3162, 整数型, , ,
    .成员 匿名成员3163, 整数型, , ,
    .成员 匿名成员3164, 整数型, , ,
    .成员 匿名成员3165, 字节型, , "256",

数据类型 匿名数据类型_3122, ,
    .成员 匿名成员3123, 整数型, , ,
    .成员 匿名成员3124, 整数型, , ,
    .成员 匿名成员3125, 整数型, , ,
    .成员 匿名成员3126, 整数型, , ,
    .成员 匿名成员3127, 整数型, , ,
    .成员 匿名成员3128, 整数型, , ,
    .成员 匿名成员3129, 整数型, , ,
    .成员 匿名成员3130, 整数型, , ,
    .成员 匿名成员3131, 整数型, , ,
    .成员 匿名成员3132, 字节型, , "256",

数据类型 匿名数据类型_3210, ,
    .成员 匿名成员3275, 整数型, , ,
    .成员 匿名成员3276, 整数型, , ,
    .成员 匿名成员3277, 整数型, , ,
    .成员 匿名成员3278, 整数型, , ,
    .成员 匿名成员3279, 整数型, , ,
    .成员 匿名成员3280, 整数型, , ,
    .成员 匿名成员3281, 整数型, , ,

数据类型 匿名数据类型_3211, ,
    .成员 匿名成员3282, 整数型, , ,
    .成员 匿名成员3283, 整数型, , ,
    .成员 匿名成员3284, 整数型, , ,
    .成员 匿名成员3285, 整数型, , ,
    .成员 匿名成员3286, 整数型, , ,

.全局变量 匿名全局变量_1636, 匿名类模块_3, , ,
.全局变量 匿名全局变量_1637, 匿名类模块_8, , ,
.全局变量 x32v64, 驱动读写, 公开, ,
.全局变量 匿名全局变量_2754, 匿名数据类型_2756, , "0",
.全局变量 匿名全局变量_2940, 整数型, , ,

.DLL命令 lstrcpyn_104, 整数型, "kernel32.dll", "lstrcpyn", ,
    .参数 匿名参数_105, 整数型, 传址,
    .参数 匿名参数_106, 整数型, 传址,
    .参数 匿名参数_107, 整数型, ,

.DLL命令 lstrcpyn_121, 整数型, "kernel32.dll", "lstrcpyn", ,
    .参数 匿名参数_122, 字节集, 传址,
    .参数 匿名参数_123, 字节集, 传址,
    .参数 匿名参数_124, 整数型, ,

.DLL命令 GetTempPathA_470, 整数型, "kernel32.dll", "GetTempPathA", ,
    .参数 匿名参数_471, 整数型, ,
    .参数 匿名参数_472, 文本型, ,

.DLL命令 @wsprintfA_1114, 整数型, "", "@wsprintfA", ,
    .参数 匿名参数_1115, 文本型, 传址,
    .参数 匿名参数_1116, 文本型, ,
    .参数 匿名参数_1117, 整数型, ,

.DLL命令 StrToIntExA_1136, 整数型, "shlwapi.dll", "StrToIntExA", ,
    .参数 匿名参数_1137, 文本型, ,
    .参数 匿名参数_1138, 整数型, ,
    .参数 匿名参数_1139, 长整数型, 传址,

.DLL命令 CreateSemaphoreA_1838, 整数型, "kernel32.dll", "CreateSemaphoreA", ,
    .参数 匿名参数_1842, 整数型, ,
    .参数 匿名参数_1843, 整数型, ,
    .参数 匿名参数_1844, 整数型, ,
    .参数 匿名参数_1845, 文本型, ,

.DLL命令 ReleaseSemaphore_1855, 整数型, "kernel32.dll", "ReleaseSemaphore", ,
    .参数 匿名参数_1857, 整数型, ,
    .参数 匿名参数_1858, 整数型, ,
    .参数 匿名参数_1859, 整数型, 传址,

.DLL命令 WaitForSingleObject_1867, 整数型, "kernel32.dll", "WaitForSingleObject", ,
    .参数 匿名参数_1868, 整数型, ,
    .参数 匿名参数_1869, 整数型, ,

.DLL命令 ZwAllocateVirtualMemory_2334, 整数型, "ntdll.dll", "ZwAllocateVirtualMemory", ,
    .参数 匿名参数_2335, 整数型, ,
    .参数 匿名参数_2336, 整数型, 传址,
    .参数 匿名参数_2337, 整数型, ,
    .参数 匿名参数_2338, 整数型, 传址,
    .参数 匿名参数_2339, 整数型, ,
    .参数 匿名参数_2340, 整数型, ,

.DLL命令 EnumWindows_2488, 逻辑型, "", "EnumWindows", ,
    .参数 匿名参数_2489, 子程序指针, ,
    .参数 匿名参数_2490, 整数型, ,

.DLL命令 ZwFreeVirtualMemory_2353, 整数型, "ntdll.dll", "ZwFreeVirtualMemory", ,
    .参数 匿名参数_2354, 整数型, ,
    .参数 匿名参数_2355, 整数型, 传址,
    .参数 匿名参数_2356, 整数型, 传址,
    .参数 匿名参数_2357, 整数型, ,

.DLL命令 CreateToolhelp32Snapshot_2513, 整数型, "", "CreateToolhelp32Snapshot", ,
    .参数 匿名参数_2514, 整数型, ,
    .参数 匿名参数_2515, 整数型, ,

.DLL命令 Process32First_2526, 整数型, "", "Process32First", ,
    .参数 匿名参数_2527, 整数型, ,
    .参数 匿名参数_2528, 匿名数据类型_2530, ,

.DLL命令 Process32Next_2563, 整数型, "", "Process32Next", ,
    .参数 匿名参数_2564, 整数型, ,
    .参数 匿名参数_2565, 匿名数据类型_2530, ,

.DLL命令 _关闭对象, 整数型, "", "CloseHandle", 公开, 公开, kernel32.dll
    .参数 对象句柄, 整数型, ,

.DLL命令 GetWindow_2569, 整数型, "", "GetWindow", ,
    .参数 匿名参数_2570, 整数型, ,
    .参数 匿名参数_2571, 整数型, ,

.DLL命令 _窗口是否可见, 逻辑型, "", "IsWindowVisible", 公开, 公开, 判断窗口是否可见  如窗口可见则返回TRUE（非零）
    .参数 窗口句柄, 整数型, , 要测试的那个窗口的句柄

.DLL命令 _取屏幕句柄, 整数型, "", "GetDesktopWindow", 公开,  user32.dll返回屏幕的句柄

.DLL命令 GetWindowTextA_2579, 整数型, "", "GetWindowTextA", ,
    .参数 匿名参数_2580, 整数型, ,
    .参数 匿名参数_2581, 文本型, ,
    .参数 匿名参数_2582, 整数型, ,

.DLL命令 GetClassNameA_2583, 整数型, "", "GetClassNameA", ,
    .参数 匿名参数_2584, 整数型, ,
    .参数 匿名参数_2585, 文本型, ,
    .参数 匿名参数_2586, 整数型, ,

.DLL命令 GetWindowThreadProcessId_2587, 整数型, "", "GetWindowThreadProcessId", ,
    .参数 匿名参数_2588, 整数型, ,
    .参数 匿名参数_2589, 整数型, 传址,

.DLL命令 Module32First_2593, 整数型, "", "Module32First", ,
    .参数 匿名参数_2594, 整数型, ,
    .参数 匿名参数_2595, 匿名数据类型_2552, ,

.DLL命令 CreateToolhelp32Snapshot_2625, 整数型, "", "CreateToolhelp32Snapshot", ,
    .参数 匿名参数_2626, 整数型, ,
    .参数 匿名参数_2627, 整数型, ,

.DLL命令 Process32First_2629, 整数型, "", "Process32First", ,
    .参数 匿名参数_2630, 整数型, ,
    .参数 匿名参数_2631, 匿名数据类型_2614, ,

.DLL命令 StrCmpNIA_2633, 整数型, "", "StrCmpNIA", ,
    .参数 匿名参数_2634, 文本型, ,
    .参数 匿名参数_2635, 字节型, 传址 数组,
    .参数 匿名参数_2636, 整数型, ,

.DLL命令 lstrlenA_2637, 整数型, "", "lstrlenA", ,
    .参数 匿名参数_2638, 文本型, ,

.DLL命令 CloseHandle_2639, 整数型, "", "CloseHandle", ,
    .参数 匿名参数_2640, 整数型, ,

.DLL命令 Process32Next_2641, 整数型, "", "Process32Next", ,
    .参数 匿名参数_2642, 整数型, ,
    .参数 匿名参数_2643, 匿名数据类型_2614, ,

.DLL命令 EnumWindows_2659, 整数型, "user32.dll", "EnumWindows", ,
    .参数 匿名参数_2660, 子程序指针, ,
    .参数 匿名参数_2661, 整数型, 传址,

.DLL命令 GetWindowThreadProcessId_2669, 整数型, "user32.dll", "GetWindowThreadProcessId", ,
    .参数 匿名参数_2670, 整数型, ,
    .参数 匿名参数_2671, 整数型, 传址,

.DLL命令 GetAncestor_2672, 整数型, "user32.dll", "GetAncestor", ,
    .参数 匿名参数_2673, 整数型, ,
    .参数 匿名参数_2674, 整数型, ,

.DLL命令 SetTimer_2700, 整数型, "", "SetTimer", ,
    .参数 匿名参数_2701, 整数型, ,
    .参数 匿名参数_2702, 整数型, ,
    .参数 匿名参数_2703, 整数型, ,
    .参数 匿名参数_2704, 子程序指针, ,

.DLL命令 _判断按键状态, 整数型, "", "GetAsyncKeyState", 公开, 公开, 判断函数调用时指定虚拟键的状态 (非按住状态返回0)
    .参数 键代码, 整数型, , 欲测试的虚拟键的键码

.DLL命令 _回调钩子, 整数型, "", "CallWindowProcA", 公开, 公开,
    .参数 窗口程序程序指针, 子程序指针, ,
    .参数 窗口句柄, 整数型, ,
    .参数 消息, 整数型, ,
    .参数 参数1, 整数型, ,
    .参数 参数2, 整数型, ,

.DLL命令 CreateThread_2720, 整数型, "", "CreateThread", ,
    .参数 匿名参数_2721, 整数型, ,
    .参数 匿名参数_2722, 整数型, ,
    .参数 匿名参数_2723, 子程序指针, ,
    .参数 匿名参数_2724, 整数型, ,
    .参数 匿名参数_2725, 整数型, ,
    .参数 匿名参数_2726, 整数型, 传址,

.DLL命令 Module32First_2785, 整数型, "", "Module32First", ,
    .参数 匿名参数_2786, 整数型, ,
    .参数 匿名参数_2787, 匿名数据类型_2774, ,

.DLL命令 CreateToolhelp32Snapshot_3134, 整数型, "", "CreateToolhelp32Snapshot", ,
    .参数 匿名参数_3135, 整数型, ,
    .参数 匿名参数_3136, 整数型, ,

.DLL命令 Process32First_3139, 整数型, "", "Process32First", ,
    .参数 匿名参数_3140, 整数型, ,
    .参数 匿名参数_3141, 匿名数据类型_3122, ,

.DLL命令 StrCmpNIA_3143, 整数型, "", "StrCmpNIA", ,
    .参数 匿名参数_3144, 文本型, ,
    .参数 匿名参数_3145, 字节型, 传址 数组,
    .参数 匿名参数_3146, 整数型, ,

.DLL命令 lstrlenA_3147, 整数型, "", "lstrlenA", ,
    .参数 匿名参数_3148, 文本型, ,

.DLL命令 CloseHandle_3149, 整数型, "", "CloseHandle", ,
    .参数 匿名参数_3150, 整数型, ,

.DLL命令 Process32Next_3151, 整数型, "", "Process32Next", ,
    .参数 匿名参数_3152, 整数型, ,
    .参数 匿名参数_3153, 匿名数据类型_3122, ,

.DLL命令 Process32First_3177, 整数型, "", "Process32First", ,
    .参数 匿名参数_3178, 整数型, ,
    .参数 匿名参数_3179, 匿名数据类型_3155, ,

.DLL命令 CreateToolhelp32Snapshot_3166, 整数型, "", "CreateToolhelp32Snapshot", ,
    .参数 匿名参数_3167, 整数型, ,
    .参数 匿名参数_3168, 整数型, ,

.DLL命令 CloseHandle_3181, 整数型, "", "CloseHandle", ,
    .参数 匿名参数_3182, 整数型, ,

.DLL命令 Process32Next_3183, 整数型, "", "Process32Next", ,
    .参数 匿名参数_3184, 整数型, ,
    .参数 匿名参数_3185, 匿名数据类型_3155, ,

.DLL命令 OpenProcess_3187, 整数型, "", "OpenProcess", ,
    .参数 匿名参数_3188, 整数型, ,
    .参数 匿名参数_3189, 整数型, ,
    .参数 匿名参数_3190, 整数型, ,

.DLL命令 TerminateProcess_3191, 整数型, "", "TerminateProcess", ,
    .参数 匿名参数_3192, 整数型, ,
    .参数 匿名参数_3193, 整数型, ,

.DLL命令 lstrcpyn_3265, 整数型, "", "lstrcpyn", ,
    .参数 匿名参数_3500, 匿名数据类型_3210, ,
    .参数 匿名参数_3501, 匿名数据类型_3210, ,
    .参数 匿名参数_3502, 整数型, ,

.DLL命令 lstrcpyn_3266, 整数型, "", "lstrcpyn", ,
    .参数 匿名参数_3503, 匿名数据类型_3211, ,
    .参数 匿名参数_3504, 匿名数据类型_3211, ,
    .参数 匿名参数_3505, 整数型, ,

.程序集 匿名程序集_0, , ,

.程序集变量 匿名程序集变量_2509, 窗口信息型, , "0",
.程序集变量 匿名程序集变量_2591, 窗口信息型, , "0",
.程序集变量 匿名程序集变量_3072, 文本型, , "0",
.子程序 匿名子程序_1, 整数型, ,
输出调试文本 (“*********************************************”)
输出调试文本 (“LOL专供模板 不异常，不非法，不追封，不报毒!”)
输出调试文本 (“*********************************************”)
输出调试文本 (“”)
输出调试文本 (“LOL专供模板当前为调试状态运行! V1.1，大家共同研究进步无限视距修改！”)
输出调试文本 (“”)
输出调试文本 (“END BY Nuke 无限视距作者!”)
输出调试文本 (“”)
输出调试文本 (“”)

.如果真 (等于 (取执行文件名 (), “cmd.exe”))
    返回 (0)
.如果真结束

.判断开始 (是否为调试版 ())
   
.默认
    置随机数种子 ()
    信息框 (相加 (匿名子程序_2962 (“44,54,AA,66,AC,13,B9,35,6B,EE,76,9A,AC,6F,C2,A5,0C,D2,19,D4,2E,DC,0F,BE,52,BF,FA,31,76,AB,50,52,AD,”, “3C”), #换行符, #换行符, #换行符, 匿名子程序_2962 (“4E,5E,A0,6C,A6,19,B3,3F,61,E4,7C,FE,F3,2E,8D,AF,7C,97,5C,93,24,B2,49,F8,58,DC,BE,71,39,E2,0E,1D,E3,21,CE,8D,F9,D2,C2,33,FB,52,A2,BA,DA,DA,E1,7B,A3,B9,4F,55,A4,D3,”, “3C”), #换行符, #换行符, 匿名子程序_2962 (“28,3B,C6,91,24,8A,30,D1,E8,7E,B3,F4,6B,BF,75,69,E5,1E,D5,15,BC,23,D4,15,C5,5E,37,F7,A1,73,F3,80,7E,E9,47,0B,61,43,59,B1,67,C6,A9,”, “3C”), #换行符, #换行符, 匿名子程序_2962 (“4E,5E,A0,6C,A6,19,B3,3F,61,E4,7C,FE,F3,2E,8D,AF,7C,97,5C,93,24,B2,49,F8,58,DC,BE,71,39,E2,0E,1D,E3,21,CE,8D,F9,D2,C2,33,FB,52,A2,BA,DA,DA,E1,7B,A3,B9,4F,55,A4,D3,”, “3C”)), 64, 到文本 (取随机数 (1, 1000)), 取窗口句柄1_ (取自进程ID_ ()))
   
.判断结束



返回 (0)





.子程序 开启无限视距, , 公开,
输出调试文本 (“开启成功”)

.子程序 TP注入, , 公开,
.参数 进程ID, 整数型, ,


x32v64.写整数 (0, 十六到十_ (“32654DF”), 451)
x32v64.写整数 (0, 十六到十_ (“3D2A3D”), 451)
x32v64.写整数 (0, 十六到十_ (“326DD9”), 451)
x32v64.写整数 (0, 十六到十_ (“3065CF4”), 451)
x32v64.写整数 (0, 十六到十_ (“3266444”), 451)
x32v64.写整数 (0, 十六到十_ (“3270E77”), 451)
x32v64.写整数 (0, 十六到十_ (“326F9FE”), 451)
x32v64.写整数 (0, 十六到十_ (“3267FEE”), 451)
x32v64.写整数 (0, 十六到十_ (“327069F”), 451)
x32v64.写整数 (0, 十六到十_ (“3270DD5”), 451)
x32v64.写整数 (0, 十六到十_ (“3263F4A”), 451)

匿名子程序_3203 (进程ID)

.子程序 匿名子程序_3203, , ,
.参数 匿名参数_3208, 整数型, ,

x32v64.写整数 (匿名参数_3208, 十六到十_ (“4EB0000”), 1699182426)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326A899”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“327B1F7”), -1869574000)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326DDDF”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3270A3D”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326CB29”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3062CF4”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3267444”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3270E87”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326F9FE”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3267CEE”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“327069F”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3270DD5”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3269F4A”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326848F”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3268E5F”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326B5E3”), 451)


x32v64.写整数 (匿名参数_3208, 十六到十_ (“326612D”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326A678”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3266E1C”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326BC5F”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326BDEE”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3271992”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3062540”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“326E1CC”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“3264A42”), 451)
x32v64.写整数 (匿名参数_3208, 十六到十_ (“110857C”), 1165623296)


.子程序 取自进程ID_, 整数型, ,
置入代码 ({ 100, 161, 24, 0, 0, 0, 139, 64, 32, 201, 195 })
返回 (0)

.子程序 是否为64位_, 逻辑型, ,
返回 (匿名子程序_3236 ())

.子程序 异位或_, 整数型, , 异位或精确版
.参数 数值一, 整数型, ,
.参数 数值二, 整数型, ,

置入代码 ({ 139, 69, 8, 139, 77, 12, 51, 193, 201, 194, 8, 0 })
返回 (0)

.子程序 异位与_, 整数型, , 异位与精确版
.参数 数值一, 整数型, ,
.参数 数值二, 整数型, ,

置入代码 ({ 139, 69, 8, 139, 77, 12, 35, 193, 201, 194, 8, 0 })
返回 (0)

.子程序 十到十六_, 文本型, , 十到十六精确版 无负数
.参数 十进制, 长整数型, ,

.局部变量 匿名局部变量_1128, 文本型, , ,

赋值 (匿名局部变量_1128, 取空白文本 (255))
@wsprintfA_1114 (匿名局部变量_1128, “%X”, 十进制)
返回 (匿名局部变量_1128)

.子程序 十六到十_, 长整数型, , 十六到十精确版 无负数
.参数 十六进制, 文本型, ,

.局部变量 匿名局部变量_1140, 长整数型, , ,
.局部变量 匿名局部变量_1153, 文本型, , ,

赋值 (匿名局部变量_1153, 取空白文本 (255))
StrToIntExA_1136 (相加 (“0x”, 十六进制), 1, 匿名局部变量_1140)
@wsprintfA_1114 (匿名局部变量_1153, “%u”, 匿名局部变量_1140)
返回 (到数值 (匿名局部变量_1153))

.子程序 字节集查看_, 文本型, ,
.参数 字节集, 字节集, , 欲查看的字节集
.参数 起始位置, 整数型, 可空, 查看字节集的起始查看位置
.参数 查看长度, 整数型, 可空, 查看的长度,默认为查看全部

.局部变量 匿名局部变量_431, 文本型, , ,
.局部变量 匿名局部变量_432, 文本型, , "0",
.局部变量 匿名局部变量_433, 整数型, , ,
.局部变量 匿名局部变量_434, 整数型, , ,
.局部变量 匿名局部变量_435, 整数型, , ,
.局部变量 匿名局部变量_436, 整数型, , ,

赋值 (匿名局部变量_433, 取字节集长度 (字节集))
.如果真 (等于 (匿名局部变量_433, 0))
    返回 (“{}”)
.如果真结束

赋值 (匿名局部变量_435, 选择 (小于 (起始位置, 1), 1, 起始位置))
赋值 (匿名局部变量_436, 选择 (或者 (大于 (相加 (查看长度, 起始位置), 匿名局部变量_433), 小于 (查看长度, 1)), 匿名局部变量_433, 相减 (相加 (查看长度, 起始位置), 1)))
.如果真 (小于 (相减 (匿名局部变量_436, 匿名局部变量_435), 1))
    返回 (相加 (“{”, 到文本 (字节集 [匿名局部变量_435]), “}”))
.如果真结束
.变量循环首 (选择 (小于 (起始位置, 1), 1, 起始位置), 相减 (匿名局部变量_436, 1), 1, 匿名局部变量_434)
    赋值 (匿名局部变量_431, 相加 (匿名局部变量_431, 到文本 (字节集 [匿名局部变量_434]), “,”))
    处理事件 ()
.变量循环尾 ()
返回 (相加 (“{”, 匿名局部变量_431, 到文本 (字节集 [匿名局部变量_436]), “}”))

.子程序 还原字节集_, 字节集, ,
.参数 文本, 文本型, , 如: { 255,255,255,255 }

.局部变量 匿名局部变量_438, 文本型, , "0",
.局部变量 匿名局部变量_439, 字节型, , "0",
.局部变量 匿名局部变量_440, 整数型, , ,

.如果真 (不等于 (取文本左边 (文本, 1), “{”))
    返回 ({  })
.如果真结束
.如果真 (不等于 (取文本右边 (文本, 1), “}”))
    返回 ({  })
.如果真结束

赋值 (匿名局部变量_438, 分割文本 (取文本中间 (文本, 2, 相减 (取文本长度 (文本), 2)), “,”, ))
重定义数组 (匿名局部变量_439, 假, 取数组成员数 (匿名局部变量_438))
.计次循环首 (取数组成员数 (匿名局部变量_438), 匿名局部变量_440)
    赋值 (匿名局部变量_439 [匿名局部变量_440], 到字节 (匿名局部变量_438 [匿名局部变量_440]))
    处理事件 ()
.计次循环尾 ()
返回 (到字节集 (匿名局部变量_439))

.子程序 转十六到十_, 整数型, ,
.参数 十六进制, 文本型, , 待转换的十六进制文本
.参数 返回结果, 文本型, 参考 可空, 返回文本结果(如十进制数超出整数范围,可通过返回结果获得十进制文本)

.局部变量 匿名局部变量_423, 文本型, , ,
.局部变量 匿名局部变量_424, 长整数型, , ,
.局部变量 匿名局部变量_425, 整数型, , ,

赋值 (返回结果, “”)
.变量循环首 (1, 取文本长度 (十六进制), 1, 匿名局部变量_425)
    赋值 (匿名局部变量_423, 取文本中间 (十六进制, 匿名局部变量_425, 1))
    赋值 (匿名局部变量_424, 相加 (相乘 (相减 (寻找文本 (“0123456789ABCDEF”, 匿名局部变量_423, , 真), 1), 求次方 (16, 相减 (取文本长度 (十六进制), 匿名局部变量_425))), 匿名局部变量_424))
.变量循环尾 ()
.如果真 (等于 (是否为空 (返回结果), 假))
    赋值 (返回结果, 到文本 (匿名局部变量_424))
.如果真结束
返回 (匿名局部变量_424)

.子程序 转十到十六_, 文本型, ,
.参数 十进制, 长整数型, 可空,
.参数 保留头部零, 逻辑型, 可空,

.局部变量 匿名局部变量_444, 字节集, , ,
.局部变量 匿名局部变量_445, 整数型, , ,
.局部变量 匿名局部变量_446, 文本型, , ,
.局部变量 匿名局部变量_447, 文本型, , "6",
.局部变量 匿名局部变量_448, 文本型, , "0",

.如果真 (等于 (保留头部零, 真))
    赋值 (匿名局部变量_444, 到字节集 (十进制))
    .计次循环首 (整除 (相加 (取字节集长度 (匿名局部变量_444), 2), 3), 匿名局部变量_445)
        赋值 (匿名局部变量_446, 相加 (到十六进制文本 (匿名局部变量_444 [匿名局部变量_445]), 匿名局部变量_446))
    .计次循环尾 ()
    返回 (匿名局部变量_446)
.如果真结束
赋值 (匿名局部变量_447, { “A”, “B”, “C”, “D”, “E”, “F” })
.循环判断首 ()
    .判断开始 (小于 (求余数 (十进制, 16), 10))
        加入成员 (匿名局部变量_448, 到文本 (求余数 (十进制, 16)))
    .默认
        加入成员 (匿名局部变量_448, 匿名局部变量_447 [相减 (求余数 (十进制, 16), 9)])
    .判断结束
    赋值 (十进制, 相除 (十进制, 16))
    .如果真 (小于 (十进制, 16))
        .判断开始 (小于 (十进制, 10))
            加入成员 (匿名局部变量_448, 到文本 (取整 (十进制)))
        .默认
            加入成员 (匿名局部变量_448, 匿名局部变量_447 [相减 (十进制, 9)])
        .判断结束
        跳出循环 ()
    .如果真结束
   
.循环判断尾 (真)
.计次循环首 (取数组成员数 (匿名局部变量_448), 匿名局部变量_445)
    赋值 (匿名局部变量_446, 相加 (匿名局部变量_446, 到文本 (匿名局部变量_448 [相加 (相减 (取数组成员数 (匿名局部变量_448), 匿名局部变量_445), 1)])))
.计次循环尾 ()
.如果真 (等于 (取文本左边 (匿名局部变量_446, 1), “0”))
    赋值 (匿名局部变量_446, 除去头部零 (匿名局部变量_446))
.如果真结束
返回 (匿名局部变量_446)

.子程序 到十六进制文本, 文本型, ,
.参数 数值, 整数型, ,

返回 (相加 (多项选择 (相加 (右移 (数值, 4), 1), “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F”), 多项选择 (相加 (位与 (数值, 15), 1), “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F”)))

.子程序 除去头部零, 文本型, ,
.参数 文本, 文本型, ,

.局部变量 匿名局部变量_455, 整数型, , ,

.计次循环首 (取文本长度 (文本), 匿名局部变量_455)
    .如果真 (不等于 (取文本中间 (文本, 匿名局部变量_455, 1), “0”))
        跳出循环 ()
    .如果真结束
   
.计次循环尾 ()
返回 (取文本右边 (文本, 相加 (相减 (取文本长度 (文本), 匿名局部变量_455), 1)))

.子程序 取北京时间, 日期时间型, , 冷血封情取网络时间
.局部变量 匿名局部变量_2652, 文本型, , ,
.局部变量 匿名局部变量_2653, 整数型, , ,
.局部变量 匿名局部变量_2654, 整数型, , ,
.局部变量 匿名局部变量_2655, 文本型, , ,
.局部变量 匿名局部变量_2656, 整数型, , ,

赋值 (匿名局部变量_2652, 到文本 (未知支持库函数_7 (“http://open.baidu.com/special/time/”)))
赋值 (匿名局部变量_2653, 相加 (寻找文本 (匿名局部变量_2652, “window.baidu_time(”, , 假), 取文本长度 (“window.baidu_time(”)))
赋值 (匿名局部变量_2654, 寻找文本 (匿名局部变量_2652, “)”, 匿名局部变量_2653, 假))
赋值 (匿名局部变量_2656, 相减 (匿名局部变量_2654, 匿名局部变量_2653))
赋值 (匿名局部变量_2655, 取文本中间 (匿名局部变量_2652, 匿名局部变量_2653, 匿名局部变量_2656))
返回 ()

.子程序 取进程ID_, 整数型, , 取指定进程的进程ID(返回第一个进程ID,失败返回0)
.参数 进程名, 文本型, , 区分大小写

.局部变量 匿名局部变量_2836, 匿名数据类型_2614, , ,
.局部变量 匿名局部变量_2837, 整数型, , ,
.局部变量 匿名局部变量_2838, 整数型, , ,

赋值 (匿名局部变量_2838, CreateToolhelp32Snapshot_2625 (#匿名常量_2628, 0))
.如果真 (不等于 (匿名局部变量_2838, 0))
    赋值 (匿名局部变量_2836.匿名成员2615, 296)
    赋值 (匿名局部变量_2837, Process32First_2629 (匿名局部变量_2838, 匿名局部变量_2836))
    .判断循环首 (不等于 (匿名局部变量_2837, 0))
        .如果真 (等于 (StrCmpNIA_2633 (进程名, 匿名局部变量_2836.匿名成员2624, lstrlenA_2637 (进程名)), 0))
            CloseHandle_2639 (匿名局部变量_2838)
            返回 (匿名局部变量_2836.匿名成员2617)
        .如果真结束
        赋值 (匿名局部变量_2837, Process32Next_2641 (匿名局部变量_2838, 匿名局部变量_2836))
    .判断循环尾 ()
    CloseHandle_2639 (匿名局部变量_2838)
.如果真结束
返回 (0)


.子程序 取句柄_, 整数型, , 通过进程,类名或标题关键字来取窗口句柄(返回第一个符合条件的句柄,失败返回-1)
.参数 进程名, 文本型, 可空, 欲取窗口句柄的窗口程序进程名(不区分大小写)
.参数 类名, 文本型, 可空, 欲取窗口句柄的窗口类名
.参数 标题, 文本型, 可空, 欲取窗口句柄的窗口标题关键字,模糊匹配.精确标题可使用单引号将标题引用

.局部变量 匿名局部变量_2844, 窗口信息型, , "0",
.局部变量 匿名局部变量_2845, 整数型, , ,
.局部变量 匿名局部变量_2846, 整数型, , ,
.局部变量 匿名局部变量_2847, 进程信息型, , "0",
.局部变量 匿名局部变量_2848, 整数型, , ,
.局部变量 匿名局部变量_2849, 整数型, , ,
.局部变量 匿名局部变量_2850, 逻辑型, , ,

.如果真 (并且 (等于 (进程名, “”), 等于 (类名, “”), 等于 (标题, “”)))
    输出调试文本 (“开什么玩笑!一个条件都没有,怎么取句柄?”)
    返回 (0)
.如果真结束
赋值 (匿名局部变量_2848, 匿名子程序_2920 (匿名局部变量_2847))
.计次循环首 (匿名子程序_2883 (匿名局部变量_2844), 匿名局部变量_2845)
    .如果真 (不等于 (进程名, “”))
        赋值 (匿名局部变量_2850, 假)
        .计次循环首 (匿名局部变量_2848, 匿名局部变量_2849)
            .如果真 (并且 (等于 (到小写 (匿名局部变量_2847 [匿名局部变量_2849], 进程名称), 到小写 (进程名)), 等于 (匿名局部变量_2847 [匿名局部变量_2849], 进程ID, 匿名局部变量_2844 [匿名局部变量_2845], 进程ID)))
                赋值 (匿名局部变量_2850, 真)
                跳出循环 ()
            .如果真结束
            
        .计次循环尾 ()
        .如果真 (等于 (匿名局部变量_2850, 假))
            到循环尾 ()
        .如果真结束
        
    .如果真结束
    .如果真 (不等于 (类名, “”))
        .如果真 (不等于 (匿名局部变量_2844 [匿名局部变量_2845], 窗口类名, 类名))
            到循环尾 ()
        .如果真结束
        
    .如果真结束
    .如果真 (不等于 (标题, “”))
        .如果真 (等于 (寻找文本 (相加 (“'”, 匿名局部变量_2844 [匿名局部变量_2845], 窗口标题, “'”), 标题, , 假), -1))
            到循环尾 ()
        .如果真结束
        
    .如果真结束
    返回 (匿名局部变量_2844 [匿名局部变量_2845], 窗口句柄)
.计次循环尾 ()
返回 (-1)

.子程序 取进程路径_, 文本型, , 取指定进程的程序启动路径(成功返回路径,失败或进程不存在返回空),受360拦截
.参数 进程ID, 整数型, ,

.局部变量 匿名局部变量_2875, 整数型, , ,
.局部变量 匿名局部变量_2876, 匿名数据类型_2552, , ,
.局部变量 匿名局部变量_2877, 文本型, , ,

赋值 (匿名局部变量_2875, CreateToolhelp32Snapshot_2513 (8, 进程ID))
.如果真 (等于 (匿名局部变量_2875, -1))
    返回 (“”)
.如果真结束
赋值 (匿名局部变量_2876.匿名成员2553, 1024)
Module32First_2593 (匿名局部变量_2875, 匿名局部变量_2876)
赋值 (匿名局部变量_2877, 到文本 (匿名局部变量_2876.匿名成员2562))
_关闭对象 (匿名局部变量_2875)
返回 (匿名局部变量_2877)

.子程序 匿名子程序_2883, 整数型, ,
.参数 匿名参数_2885, 窗口信息型, 数组,

EnumWindows_2488 (&匿名子程序_2895, 0)
赋值 (匿名参数_2885, 匿名程序集变量_2591)
清除数组 (匿名程序集变量_2591)
返回 (取数组成员数 (匿名参数_2885))

.子程序 匿名子程序_2895, , ,
.参数 匿名参数_2896, 整数型, ,

.局部变量 匿名局部变量_2897, 文本型, , ,
.局部变量 匿名局部变量_2898, 文本型, , ,
.局部变量 匿名局部变量_2899, 整数型, , ,
.局部变量 匿名局部变量_2900, 整数型, , ,
.局部变量 匿名局部变量_2901, 窗口信息型, , ,

.如果真 (_窗口是否可见 (匿名参数_2896))
    赋值 (匿名局部变量_2897, 取空白文本 (256))
    赋值 (匿名局部变量_2898, 取空白文本 (256))
    GetWindowTextA_2579 (匿名参数_2896, 匿名局部变量_2897, 255)
    GetClassNameA_2583 (匿名参数_2896, 匿名局部变量_2898, 255)
    赋值 (匿名局部变量_2900, GetWindowThreadProcessId_2587 (匿名参数_2896, 匿名局部变量_2899))
    赋值 (匿名局部变量_2901.进程ID, 匿名局部变量_2899)
    赋值 (匿名局部变量_2901.线程ID, 匿名局部变量_2900)
    赋值 (匿名局部变量_2901.窗口句柄, 匿名参数_2896)
    赋值 (匿名局部变量_2901.窗口类名, 匿名局部变量_2898)
    赋值 (匿名局部变量_2901.窗口标题, 匿名局部变量_2897)
    加入成员 (匿名程序集变量_2591, 匿名局部变量_2901)
.如果真结束


.子程序 匿名子程序_2920, 整数型, ,
.参数 匿名参数_2921, 进程信息型, 可空 数组,
.参数 匿名参数_2922, 逻辑型, 可空,

.局部变量 匿名局部变量_2923, 匿名数据类型_2530, , ,
.局部变量 匿名局部变量_2924, 整数型, , ,
.局部变量 匿名局部变量_2925, 整数型, , ,
.局部变量 匿名局部变量_2926, 进程信息型, , ,
.局部变量 匿名局部变量_2927, 进程信息型, , "0",

赋值 (匿名局部变量_2924, CreateToolhelp32Snapshot_2513 (15, 0))
.如果真 (等于 (匿名局部变量_2924, 0))
    返回 (0)
.如果真结束
赋值 (匿名局部变量_2923.匿名成员2531, 1024)
赋值 (匿名局部变量_2925, Process32First_2526 (匿名局部变量_2924, 匿名局部变量_2923))
.判断循环首 (不等于 (匿名局部变量_2925, 0))
    .如果真 (不等于 (匿名局部变量_2923.匿名成员2533, 0))
        赋值 (匿名局部变量_2926.父进程ID, 匿名局部变量_2923.匿名成员2537)
        赋值 (匿名局部变量_2926.进程ID, 匿名局部变量_2923.匿名成员2533)
        赋值 (匿名局部变量_2926.进程名称, 到文本 (匿名局部变量_2923.匿名成员2540))
        .如果真 (匿名参数_2922)
            赋值 (匿名局部变量_2926.进程路径, 取进程路径_ (匿名局部变量_2923.匿名成员2533))
        .如果真结束
        加入成员 (匿名局部变量_2927, 匿名局部变量_2926)
    .如果真结束
    赋值 (匿名局部变量_2925, Process32Next_2563 (匿名局部变量_2924, 匿名局部变量_2923))
.判断循环尾 ()
_关闭对象 (匿名局部变量_2924)
赋值 (匿名参数_2921, 匿名局部变量_2927)
返回 (取数组成员数 (匿名参数_2921))

.子程序 取窗口句柄1_, 整数型, , 取指定进程的窗口句柄，进程ID为空则默认取自身窗口句柄。返回窗口句柄
.参数 进程ID, 整数型, 可空, 进程ID为空则默认取自身窗口句柄

.判断开始 (是否为空 (进程ID))
    赋值 (进程ID, 取自进程ID_ ())
.默认
   
.判断结束
EnumWindows_2659 (&匿名子程序_2935, 进程ID)
返回 (进程ID)

.子程序 匿名子程序_2935, 整数型, ,
.参数 匿名参数_2936, 整数型, ,
.参数 匿名参数_2937, 整数型, 参考,

.局部变量 匿名局部变量_2938, 整数型, , ,

.如果真 (不等于 (匿名参数_2937, 0))
    赋值 (匿名全局变量_2940, 0)
    赋值 (匿名全局变量_2940, 匿名参数_2937)
.如果真结束
GetWindowThreadProcessId_2669 (匿名参数_2936, 匿名局部变量_2938)
.如果 (等于 (匿名局部变量_2938, 匿名全局变量_2940))
    赋值 (匿名参数_2937, GetAncestor_2672 (匿名参数_2936, #匿名常量_2675))
   
    返回 (0)
.否则
    赋值 (匿名参数_2937, 0)
    返回 (1)
.如果结束


.子程序 撤消监视热键_, 逻辑型, , 撤消由监视热键注册的一个或全部热键(成功返回真,失败返回假)
.参数 热键标识, 整数型, 可空, 欲撤消的热键标识,如果留空则撤消全部热键

.局部变量 匿名局部变量_2945, 整数型, , ,

.计次循环首 (取数组成员数 (匿名全局变量_2754), 匿名局部变量_2945)
    .如果 (等于 (热键标识, 0))
        赋值 (匿名全局变量_2754 [匿名局部变量_2945], 匿名成员2757, 0)
    .否则
        .如果真 (等于 (热键标识, 匿名全局变量_2754 [匿名局部变量_2945], 匿名成员2757))
            赋值 (匿名全局变量_2754 [匿名局部变量_2945], 匿名成员2757, 0)
            返回 (真)
        .如果真结束
        
    .如果结束
   
.计次循环尾 ()
返回 (等于 (热键标识, 0))

.子程序 监视热键_, 整数型, , 监视一个热键,当热键被触发时激活响应事件.(成功返回热键标识,失败返回0).注:真实的按键才会触发热键
.参数 响应事件, 子程序指针, , 响应事件(热键标识,其它...),事件参数数目不限!如果再次监视热键将响应事件!
.参数 键代码, 整数型, , 触发事件的基本键,事件在基本键按下时触发,负数为放开时触发,1鼠标左键,2鼠标右键,更多查询相关帮助
.参数 功能键状态, 整数型, 可空, 1 Alt  2 Ctrl  4 Shift  8 Win 若要两个或以上的状态键,则把它们的值相加.
.参数 其它键, 整数型, 可空, 如果你需要注册由两个普通键组合的热键,可设置一个其它键代码.
.参数 周期, 整数型, 可空, 默认为10,监视热键的周期时间(建议5-200之间)
.参数 直接触发, 逻辑型, 可空, 默认为假:创建新的线程事件 真:直接调用事件等待返回

.局部变量 匿名局部变量_2952, 匿名数据类型_2756, , ,
.局部变量 匿名局部变量_2953, 整数型, , ,

.如果真 (小于或等于 (到字节 (取绝对值 (键代码)), 0))
    返回 (0)
.如果真结束
.计次循环首 (取数组成员数 (匿名全局变量_2754), 匿名局部变量_2953)
    .如果真 (并且 (等于 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2759, 键代码), 等于 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2760, 功能键状态), 等于 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2761, 其它键)))
        赋值 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2758, 响应事件)
        赋值 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2764, 直接触发)
        .如果真 (不等于 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2757, 0))
            返回 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2757)
        .如果真结束
        赋值 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2757, 相加 (匿名局部变量_2953, 1000000))
        返回 (匿名全局变量_2754 [匿名局部变量_2953], 匿名成员2757)
    .如果真结束
   
.计次循环尾 ()
赋值 (匿名局部变量_2952.匿名成员2758, 响应事件)
赋值 (匿名局部变量_2952.匿名成员2759, 键代码)
赋值 (匿名局部变量_2952.匿名成员2760, 功能键状态)
赋值 (匿名局部变量_2952.匿名成员2761, 其它键)
赋值 (匿名局部变量_2952.匿名成员2764, 直接触发)
赋值 (匿名局部变量_2952.匿名成员2757, 相加 (取数组成员数 (匿名全局变量_2754), 1000001))
加入成员 (匿名全局变量_2754, 匿名局部变量_2952)
.如果真 (等于 (匿名局部变量_2952.匿名成员2757, 1000001))
    SetTimer_2700 (0, 16661, 选择 (小于或等于 (周期, 0), 10, 周期), &匿名子程序_2955)
.如果真结束
返回 (匿名局部变量_2952.匿名成员2757)

.子程序 匿名子程序_2955, , ,
.局部变量 匿名局部变量_2956, 整数型, , ,
.局部变量 匿名局部变量_2957, 整数型, , ,
.局部变量 匿名局部变量_2958, 子程序指针, , ,
.局部变量 匿名局部变量_2959, 整数型, , ,
.局部变量 匿名局部变量_2960, 整数型, , ,
.局部变量 匿名局部变量_2961, 短整数型, , "256",

.计次循环首 (255, 匿名局部变量_2957)
    赋值 (匿名局部变量_2961 [匿名局部变量_2957], 251)
    赋值 (匿名局部变量_2961 [匿名局部变量_2957], _判断按键状态 (匿名局部变量_2957))
.计次循环尾 ()
.计次循环首 (取数组成员数 (匿名全局变量_2754), 匿名局部变量_2957)
    .如果真 (不等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2757, 0))
        赋值 (匿名局部变量_2960, 到字节 (取绝对值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2759)))
        赋值 (匿名局部变量_2960, 匿名局部变量_2961 [匿名局部变量_2960])
        .判断开始 (等于 (匿名局部变量_2960, 0))
            .如果 (等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 1))
                赋值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 2)
            .否则
                赋值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 0)
                到循环尾 ()
            .如果结束
            
        .判断 (小于 (匿名局部变量_2960, 0))
            .如果真 (等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 0))
                赋值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 1)
            .如果真结束
            .如果真 (小于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2759, 0))
                到循环尾 ()
            .如果真结束
            
        .默认
            
            
            
            
            
        .判断结束
        
        .如果真 (并且 (大于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 0), 不等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 88)))
            赋值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2762, 88)
            .如果真 (等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2760, 相加 (选择 (小于 (匿名局部变量_2961 [18], 0), 1, 0), 选择 (小于 (匿名局部变量_2961 [17], 0), 2, 0), 选择 (小于 (匿名局部变量_2961 [16], 0), 4, 0), 选择 (小于 (匿名局部变量_2961 [91], 0), 8, 0))))
                .如果真 (不等于 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2761, 0))
                    赋值 (匿名局部变量_2960, 到字节 (取绝对值 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2761)))
                    .如果真 (大于或等于 (匿名局部变量_2961 [匿名局部变量_2960], 0))
                        到循环尾 ()
                    .如果真结束
                    
                .如果真结束
                赋值 (匿名局部变量_2958, 匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2758)
                赋值 (匿名局部变量_2959, 匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2757)
                .如果 (匿名全局变量_2754 [匿名局部变量_2957], 匿名成员2764)
                    _回调钩子 (匿名局部变量_2958, 匿名局部变量_2959, 0, 0, 0)
                .否则
                    CloseHandle_2639 (CreateThread_2720 (0, 0, 匿名局部变量_2958, 匿名局部变量_2959, 0, 0))
                .如果结束
               
            .如果真结束
            
        .如果真结束
        
    .如果真结束
   
.计次循环尾 ()

.子程序 匿名子程序_2962, 文本型, ,
.参数 匿名参数_2963, 文本型, ,
.参数 匿名参数_2964, 文本型, ,

.局部变量 匿名局部变量_2965, 字节型, , "0",
.局部变量 匿名局部变量_2966, 字节型, , "256",
.局部变量 匿名局部变量_2967, 字节型, , "256",
.局部变量 匿名局部变量_2968, 整数型, , ,
.局部变量 匿名局部变量_2969, 整数型, , ,
.局部变量 匿名局部变量_2970, 整数型, , ,
.局部变量 匿名局部变量_2971, 字节型, , "0",
.局部变量 匿名局部变量_2972, 字节型, , ,
.局部变量 匿名局部变量_2973, 整数型, , ,
.局部变量 匿名局部变量_2974, 整数型, , ,
.局部变量 匿名局部变量_2975, 整数型, , ,


赋值 (匿名参数_2963, 子文本替换 (匿名参数_2963, “,”, , , , 真))
.变量循环首 (1, 取文本长度 (匿名参数_2963), 2, 匿名局部变量_2975)
    加入成员 (匿名局部变量_2965, 到字节 (转换为十进制 (取文本中间 (匿名参数_2963, 匿名局部变量_2975, 2), 16)))
.变量循环尾 ()

.计次循环首 (256, 匿名局部变量_2968)
    赋值 (匿名局部变量_2966 [匿名局部变量_2968], 相减 (匿名局部变量_2968, 1))
.计次循环尾 ()
赋值 (匿名局部变量_2969, 1)
.计次循环首 (256, 匿名局部变量_2968)
    .如果真 (大于 (匿名局部变量_2969, 取文本长度 (匿名参数_2964)))
        赋值 (匿名局部变量_2969, 1)
    .如果真结束
    赋值 (匿名局部变量_2967 [匿名局部变量_2968], 取代码 (取文本中间 (匿名参数_2964, 匿名局部变量_2969, 1), ))
    赋值 (匿名局部变量_2969, 相加 (匿名局部变量_2969, 1))
.计次循环尾 ()
赋值 (匿名局部变量_2969, 0)
.计次循环首 (256, 匿名局部变量_2968)
    赋值 (匿名局部变量_2969, 相加 (求余数 (相加 (匿名局部变量_2969, 匿名局部变量_2966 [匿名局部变量_2968], 匿名局部变量_2967 [匿名局部变量_2968]), 256), 1))
    赋值 (匿名局部变量_2972, 匿名局部变量_2966 [匿名局部变量_2968])
    赋值 (匿名局部变量_2966 [匿名局部变量_2968], 匿名局部变量_2966 [匿名局部变量_2969])
    赋值 (匿名局部变量_2966 [匿名局部变量_2969], 匿名局部变量_2972)
.计次循环尾 ()
赋值 (匿名局部变量_2968, 0)
赋值 (匿名局部变量_2969, 0)
.计次循环首 (取数组成员数 (匿名局部变量_2965), 匿名局部变量_2973)
    赋值 (匿名局部变量_2968, 相加 (求余数 (相加 (匿名局部变量_2968, 1), 256), 1))
    赋值 (匿名局部变量_2969, 相加 (求余数 (相加 (匿名局部变量_2969, 匿名局部变量_2966 [匿名局部变量_2968]), 256), 1))
    赋值 (匿名局部变量_2972, 匿名局部变量_2966 [匿名局部变量_2968])
    赋值 (匿名局部变量_2966 [匿名局部变量_2968], 匿名局部变量_2966 [匿名局部变量_2969])
    赋值 (匿名局部变量_2966 [匿名局部变量_2969], 匿名局部变量_2972)
    赋值 (匿名局部变量_2974, 相加 (求余数 (相加 (匿名局部变量_2966 [匿名局部变量_2968], 求余数 (匿名局部变量_2966 [匿名局部变量_2969], 256)), 256), 1))
    赋值 (匿名局部变量_2970, 匿名局部变量_2966 [匿名局部变量_2974])
    加入成员 (匿名局部变量_2971, 位异或 (匿名局部变量_2965 [匿名局部变量_2973], 匿名局部变量_2970))
.计次循环尾 ()
返回 (到文本 (匿名局部变量_2971))



.子程序 从十进制转换, 文本型, , 本函数把十进制数转换为其它进制文本
.参数 十进制数, 长整数型, ,
.参数 转换后进制, 字节型, , 2、#二进制  8、#八进制  16、#十六进制，否则默认为不转换，直接返回原来的十进制数文本。

.判断开始 (等于 (转换后进制, 2))
    返回 (匿名子程序_2990 (十进制数))
.判断 (等于 (转换后进制, 8))
    返回 (匿名子程序_2991 (十进制数))
.判断 (等于 (转换后进制, 16))
    返回 (匿名子程序_2992 (十进制数))
.默认
    返回 (到文本 (十进制数))
.判断结束


.子程序 转换为十进制, 文本型, , 本函数把其它进制数文本转换为十进制文本
.参数 数值文本, 文本型, ,
.参数 原来进制, 字节型, , 2、#二进制  8、#八进制  16、#十六进制，否则默认为不转换，直接返回原来的文本。

.判断开始 (等于 (原来进制, 2))
    返回 (匿名子程序_2993 (数值文本))
.判断 (等于 (原来进制, 8))
    返回 (匿名子程序_2994 (数值文本))
.判断 (等于 (原来进制, 16))
    返回 (匿名子程序_2995 (数值文本))
.默认
    返回 (数值文本)
.判断结束






.子程序 匿名子程序_2984, 整数型, ,
匿名子程序_2985 ()

.子程序 匿名子程序_2985, , ,


.子程序 匿名子程序_2986, , ,
赋值 (0, 匿名子程序_2990 (到数值 (0)))

.子程序 匿名子程序_2987, , ,
赋值 (0, 匿名子程序_2991 (到数值 (0)))

.子程序 匿名子程序_2988, , ,
赋值 (0, 匿名子程序_2992 (到数值 (0)))

.子程序 匿名子程序_2989, , ,
赋值 (0, 匿名子程序_2995 (0))

.子程序 匿名子程序_2990, 文本型, ,
.参数 匿名参数_3000, 长整数型, ,

.局部变量 匿名局部变量_3001, 文本型, , ,

.判断循环首 (大于 (匿名参数_3000, 1))
    赋值 (匿名局部变量_3001, 相加 (到文本 (求余数 (匿名参数_3000, 2)), 匿名局部变量_3001))
    赋值 (匿名参数_3000, 取整 (相除 (匿名参数_3000, 2)))
.判断循环尾 ()
赋值 (匿名局部变量_3001, 相加 (到文本 (匿名参数_3000), 匿名局部变量_3001))
返回 (匿名局部变量_3001)

.子程序 匿名子程序_2991, 文本型, ,
.参数 匿名参数_3002, 长整数型, ,

.局部变量 匿名局部变量_3003, 文本型, , ,

.判断循环首 (大于 (匿名参数_3002, 7))
    赋值 (匿名局部变量_3003, 相加 (到文本 (求余数 (匿名参数_3002, 8)), 匿名局部变量_3003))
    赋值 (匿名参数_3002, 取整 (相除 (匿名参数_3002, 8)))
.判断循环尾 ()
赋值 (匿名局部变量_3003, 相加 (到文本 (匿名参数_3002), 匿名局部变量_3003))
返回 (匿名局部变量_3003)

.子程序 匿名子程序_2992, 文本型, ,
.参数 匿名参数_3004, 长整数型, ,

.局部变量 匿名局部变量_3005, 文本型, , ,
.局部变量 匿名局部变量_3006, 文本型, , ,

.判断循环首 (大于 (匿名参数_3004, 15))
    赋值 (匿名局部变量_3006, 到文本 (求余数 (匿名参数_3004, 16)))
    赋值 (匿名局部变量_3006, 取文本中间 (“0123456789ABCDEF”, 相加 (到数值 (匿名局部变量_3006), 1), 1))
    赋值 (匿名局部变量_3005, 相加 (匿名局部变量_3006, 匿名局部变量_3005))
    赋值 (匿名参数_3004, 取整 (相除 (匿名参数_3004, 16)))
.判断循环尾 ()
赋值 (匿名局部变量_3006, 取文本中间 (“0123456789ABCDEF”, 相加 (匿名参数_3004, 1), 1))
赋值 (匿名局部变量_3005, 相加 (匿名局部变量_3006, 匿名局部变量_3005))
返回 (匿名局部变量_3005)

.子程序 匿名子程序_2993, 文本型, ,
.参数 匿名参数_3007, 文本型, ,

.局部变量 匿名局部变量_3008, 长整数型, , ,
.局部变量 匿名局部变量_3009, 整数型, , ,

.变量循环首 (1, 取文本长度 (匿名参数_3007), 1, 匿名局部变量_3009)
    赋值 (匿名局部变量_3008, 相加 (相乘 (到数值 (取文本中间 (匿名参数_3007, 匿名局部变量_3009, 1)), 求次方 (2, 相减 (取文本长度 (匿名参数_3007), 匿名局部变量_3009))), 匿名局部变量_3008))
.变量循环尾 ()
返回 (到文本 (匿名局部变量_3008))

.子程序 匿名子程序_2994, 文本型, ,
.参数 匿名参数_3010, 文本型, ,

.局部变量 匿名局部变量_3011, 长整数型, , ,
.局部变量 匿名局部变量_3012, 整数型, , ,

.变量循环首 (1, 取文本长度 (匿名参数_3010), 1, 匿名局部变量_3012)
    赋值 (匿名局部变量_3011, 相加 (相乘 (到数值 (取文本中间 (匿名参数_3010, 匿名局部变量_3012, 1)), 求次方 (8, 相减 (取文本长度 (匿名参数_3010), 匿名局部变量_3012))), 匿名局部变量_3011))
.变量循环尾 ()
返回 (到文本 (匿名局部变量_3011))

.子程序 匿名子程序_2995, 文本型, ,
.参数 匿名参数_3013, 文本型, ,

.局部变量 匿名局部变量_3014, 文本型, , ,
.局部变量 匿名局部变量_3015, 长整数型, , ,
.局部变量 匿名局部变量_3016, 整数型, , ,

.变量循环首 (1, 取文本长度 (匿名参数_3013), 1, 匿名局部变量_3016)
    赋值 (匿名局部变量_3014, 取文本中间 (匿名参数_3013, 匿名局部变量_3016, 1))
    赋值 (匿名局部变量_3015, 相加 (相乘 (相减 (寻找文本 (“0123456789ABCDEF”, 匿名局部变量_3014, , 真), 1), 求次方 (16, 相减 (取文本长度 (匿名参数_3013), 匿名局部变量_3016))), 匿名局部变量_3015))
.变量循环尾 ()
返回 (到文本 (匿名局部变量_3015))



.子程序 匿名子程序_3029, 文本型, ,
.参数 匿名参数_3033, 文本型, ,

.局部变量 匿名局部变量_3034, 整数型, , ,

赋值 (匿名局部变量_3034, 倒找文本 (匿名参数_3033, “.”, , 假))
.如果 (不等于 (匿名局部变量_3034, -1))
    返回 (取文本右边 (匿名参数_3033, 相加 (相减 (取文本长度 (匿名参数_3033), 匿名局部变量_3034), 1)))
.否则
    返回 (匿名参数_3033)
.如果结束


.子程序 随机自身文件名_, , , ***警告：如果您的程序中有 取命令行（）参数，请勿调用该函数,否则文件名更改会错误！*****      随机以另外一个文件名运行该程序，程序退出后自动还原！
.局部变量 匿名局部变量_3037, 文本型, , "0",
.局部变量 匿名局部变量_3038, 文本型, , ,
.局部变量 匿名局部变量_3039, 文本型, , ,
.局部变量 匿名局部变量_3040, 整数型, , ,
.局部变量 匿名局部变量_3041, 文本型, , ,

.判断开始 (是否为调试版 ())
    输出调试文本 (“调试版中 随机自身文件名_ 参数被禁用!”)
    返回 ()
.默认
    取命令行 (匿名局部变量_3037)
    .判断开始 (大于或等于 (取数组成员数 (匿名局部变量_3037), 1))
        .计次循环首 (取数组成员数 (匿名局部变量_3037), 匿名局部变量_3040)
            赋值 (匿名局部变量_3041, 相加 (匿名局部变量_3041, “ ”, 匿名局部变量_3037 [匿名局部变量_3040]))
        .计次循环尾 ()
        文件更名 (取执行文件名 (), 匿名局部变量_3041)
    .默认
        赋值 (匿名局部变量_3038, 取执行文件名 ())
        置随机数种子 ()
        赋值 (匿名局部变量_3039, 相加 (字符 (取随机数 (65, 90)), 字符 (取随机数 (65, 90)), 到文本 (取随机数 (100, 999)), 匿名子程序_3029 (匿名局部变量_3038)))
        文件更名 (匿名局部变量_3038, 匿名局部变量_3039)
        运行 (相加 (匿名局部变量_3039, “ ”, 匿名局部变量_3038), 假, )
        结束 ()
    .判断结束
   
.判断结束


.子程序 防封处理_干掉非法木马加载_环境异常, , , 请周期执行本子程序，建议周期为3000~6000毫秒。可解决“非法木马加载”“环境异常”等问题
.如果 (等于 (匿名子程序_3099 (到文本 ({ 76, 101, 97, 103, 117, 101, 32, 111, 102, 32, 76, 101, 103, 101, 110, 100, 115, 46, 101, 120, 101 })), 真))
   
   
   
   
   
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 95, 49, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 95, 50, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 88, 80, 108, 97, 116, 102, 111, 114, 109, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 67, 114, 111, 115, 115, 80, 114, 111, 120, 121, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 105, 111, 68, 76, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 81, 81, 69, 120, 116, 101, 114, 110, 97, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 67, 114, 111, 115, 115, 80, 114, 111, 120, 121, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101, 95, 49 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101, 95, 50 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101, 95, 49, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101, 95, 50, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 68, 78, 70, 99, 104, 105, 110, 97, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 65, 83, 76, 111, 103, 105, 110, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 105, 111, 68, 76, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 99, 108, 105, 101, 110, 116, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 95, 49, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 95, 50, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 88, 80, 108, 97, 116, 102, 111, 114, 109, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 81, 81, 68, 76, 83, 97, 102, 101, 46, 101, 120, 101 })))
   
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 95, 49, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 88, 80, 108, 97, 116, 102, 111, 114, 109, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 67, 114, 111, 115, 115, 80, 114, 111, 120, 121, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 105, 111, 68, 76, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 88, 80, 108, 97, 116, 102, 111, 114, 109, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 83, 97, 102, 101, 46, 101, 120, 101 })))
    进程结束 (匿名子程序_3093 (到文本 ({ 84, 101, 110, 99, 101, 110, 116, 100, 108, 46, 101, 120, 101 })))
   
.否则
   
.如果结束


.子程序 匿名子程序_3093, 整数型, ,
.参数 匿名参数_3094, 文本型, ,

.局部变量 匿名局部变量_3095, 匿名数据类型_3122, , ,
.局部变量 匿名局部变量_3096, 整数型, , ,
.局部变量 匿名局部变量_3097, 整数型, , ,

赋值 (匿名局部变量_3097, CreateToolhelp32Snapshot_3134 (#匿名常量_3138, 0))
.如果真 (不等于 (匿名局部变量_3097, 0))
    赋值 (匿名局部变量_3095.匿名成员3123, 296)
    赋值 (匿名局部变量_3096, Process32First_3139 (匿名局部变量_3097, 匿名局部变量_3095))
    .判断循环首 (不等于 (匿名局部变量_3096, 0))
        .如果真 (等于 (StrCmpNIA_3143 (匿名参数_3094, 匿名局部变量_3095.匿名成员3132, lstrlenA_3147 (匿名参数_3094)), 0))
            CloseHandle_3149 (匿名局部变量_3097)
            返回 (匿名局部变量_3095.匿名成员3125)
        .如果真结束
        赋值 (匿名局部变量_3096, Process32Next_3151 (匿名局部变量_3097, 匿名局部变量_3095))
    .判断循环尾 ()
    CloseHandle_3149 (匿名局部变量_3097)
.如果真结束
返回 (0)

.子程序 匿名子程序_3099, 逻辑型, ,
.参数 匿名参数_3100, 文本型, ,
.参数 匿名参数_3101, 逻辑型, 可空,

.局部变量 匿名局部变量_3102, 匿名数据类型_3155, , ,
.局部变量 匿名局部变量_3103, 整数型, , ,
.局部变量 匿名局部变量_3104, 整数型, , ,

赋值 (匿名局部变量_3103, CreateToolhelp32Snapshot_3166 (15, 0))
.如果真 (等于 (匿名局部变量_3103, 0))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_3102.匿名成员3156, 1024)
赋值 (匿名局部变量_3104, Process32First_3177 (匿名局部变量_3103, 匿名局部变量_3102))
.判断开始 (匿名参数_3101)
    .判断循环首 (不等于 (匿名局部变量_3104, 0))
        .判断开始 (等于 (匿名参数_3100, 到文本 (匿名局部变量_3102.匿名成员3165)))
            CloseHandle_3181 (匿名局部变量_3103)
            返回 (真)
        .默认
            赋值 (匿名局部变量_3104, Process32Next_3183 (匿名局部变量_3103, 匿名局部变量_3102))
        .判断结束
        
    .判断循环尾 ()
.默认
    赋值 (匿名参数_3100, 到小写 (匿名参数_3100))
    .判断循环首 (不等于 (匿名局部变量_3104, 0))
        .判断开始 (等于 (匿名参数_3100, 到小写 (到文本 (匿名局部变量_3102.匿名成员3165))))
            CloseHandle_3181 (匿名局部变量_3103)
            返回 (真)
        .默认
            赋值 (匿名局部变量_3104, Process32Next_3183 (匿名局部变量_3103, 匿名局部变量_3102))
        .判断结束
        
    .判断循环尾 ()
.判断结束
CloseHandle_3181 (匿名局部变量_3103)
返回 (假)

.子程序 进程结束, 逻辑型, , 终止一个进程(成功返回真,失败返回假)
.参数 进程ID, 整数型, , 欲结束的进程ID

.局部变量 匿名局部变量_3108, 整数型, , ,
.局部变量 匿名局部变量_3109, 逻辑型, , ,

赋值 (匿名局部变量_3108, OpenProcess_3187 (1, 0, 进程ID))
赋值 (匿名局部变量_3109, 等于 (TerminateProcess_3191 (匿名局部变量_3108, 0), 1))
CloseHandle_3149 (匿名局部变量_3108)
返回 (匿名局部变量_3109)

.类模块 匿名类模块_3, , ,

.程序集变量 匿名程序集变量_1961, 文本型, , ,
.程序集变量 匿名程序集变量_146, 文本型, , ,
.程序集变量 匿名程序集变量_148, 文本型, , ,
.程序集变量 匿名程序集变量_473, 整数型, , ,
.程序集变量 匿名程序集变量_102, 整数型, , ,
.程序集变量 匿名程序集变量_1035, 逻辑型, , ,
.程序集变量 匿名程序集变量_1971, 整数型, , ,
.程序集变量 匿名程序集变量_2030, 整数型, , ,
.子程序 _初始化, , ,


.子程序 _销毁, , ,


.子程序 安装, 逻辑型, 公开, 安装
.参数 X32驱动文件, 字节集, 可空, 可空 此处添加有签名的驱动文件
.参数 驱动名, 文本型, 可空, 新版支持自定义驱动名称啦

.如果 (等于 (驱动名, “”))
    赋值 (匿名程序集变量_1961, “uMcg_3.7”)
.否则
    赋值 (匿名程序集变量_1961, 驱动名)
.如果结束

赋值 (匿名程序集变量_146, “uMcg_3.7”)
赋值 (匿名程序集变量_148, 相加 (取Sys目录 (), “~uMcg”, getd (“0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ”, 5), “.sys”))
赋值 (匿名程序集变量_102, 匿名子程序_3229 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148))
.如果真 (小于或等于 (匿名程序集变量_102, 0))
    匿名子程序_3214 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148)
    .如果真 (等于 (文件是否存在 (匿名程序集变量_148), 假))
        .如果真 (等于 (X32驱动文件, {  }))
            赋值 (X32驱动文件, #匿名图片_463)
        .如果真结束
        
        写到文件 (匿名程序集变量_148, X32驱动文件)
        置文件属性 (匿名程序集变量_148, 6)
    .如果真结束
   
    .如果真 (不等于 (匿名子程序_3215 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148), 0))
        删除文件 (匿名程序集变量_148)
        赋值 (匿名程序集变量_102, 匿名子程序_3231 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148))
        .如果真 (小于或等于 (匿名程序集变量_102, 0))
            卸载 ()
            返回 (假)
        .如果真结束
        返回 (大于 (匿名程序集变量_102, 0))
    .如果真结束
    删除文件 (匿名程序集变量_148)
    卸载 ()
.如果真结束
返回 (真)

.子程序 getd, 文本型, ,
.参数 匿名参数_457, 文本型, ,
.参数 匿名参数_458, 整数型, 可空,

.局部变量 匿名局部变量_459, 文本型, , ,
.局部变量 匿名局部变量_460, 整数型, , ,
.局部变量 匿名局部变量_461, 整数型, , ,

赋值 (匿名局部变量_461, 取文本长度 (匿名参数_457))
.如果真 (等于 (匿名参数_458, 0))
    置随机数种子 ()
    赋值 (匿名参数_458, 取随机数 (1, 匿名局部变量_461))
.如果真结束
置随机数种子 ()
.计次循环首 (匿名参数_458, 匿名局部变量_460)
    赋值 (匿名局部变量_459, 相加 (匿名局部变量_459, 取文本中间 (匿名参数_457, 取随机数 (1, 匿名局部变量_461), 1)))
.计次循环尾 ()
返回 (匿名局部变量_459)

.子程序 取Sys目录, 文本型, ,
.局部变量 匿名局部变量_468, 文本型, , ,

赋值 (匿名局部变量_468, 取空白文本 (256))
GetTempPathA_470 (255, 匿名局部变量_468)
返回 (匿名局部变量_468)

.子程序 切换方式, 逻辑型, , x32位驱动有效
.参数 方式, 逻辑型, 可空, 真 = 使用稳定方式读写 不蓝屏但不一定过游戏检测

.如果真 (等于 (是否为空 (方式), 假))
    赋值 (匿名程序集变量_1035, 方式)
.如果真结束
返回 (匿名程序集变量_1035)

.子程序 是否安装成功, 逻辑型, , 是否安装成功
返回 (大于 (匿名程序集变量_102, 0))

.子程序 卸载, , , 卸载驱动
.如果真 (大于 (匿名程序集变量_102, 0))
    匿名子程序_3232 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148, 匿名程序集变量_102)
    赋值 (匿名程序集变量_102, 0)
.如果真结束
匿名子程序_3216 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148)
匿名子程序_3217 (匿名程序集变量_1961, 匿名程序集变量_146, 匿名程序集变量_146, 匿名程序集变量_148)

.子程序 取错误, 整数型, , 取错误
.参数 返回错误原因, 文本型, 参考 可空,

.局部变量 匿名局部变量_479, 整数型, , ,

赋值 (匿名局部变量_479, 匿名程序集变量_473)
赋值 (匿名程序集变量_473, 0)
.如果真 (等于 (匿名局部变量_479, -1))
    赋值 (返回错误原因, “进程打开失败!”)
.如果真结束
.如果真 (等于 (匿名局部变量_479, 0))
    赋值 (返回错误原因, “操作已经完成!”)
.如果真结束
.如果真 (等于 (匿名局部变量_479, 1))
    赋值 (返回错误原因, “内存读写失败!”)
.如果真结束
返回 (匿名局部变量_479)

.子程序 读内存, 逻辑型, ,
.参数 匿名参数_73, 整数型, ,
.参数 匿名参数_75, 整数型, ,
.参数 匿名参数_77, 整数型, ,
.参数 匿名参数_98, 字节集, 参考,
.参数 匿名参数_92, 整数型, 参考 可空,

.局部变量 匿名局部变量_113, 匿名数据类型_1206, , ,
.局部变量 匿名局部变量_2036, 整数型, , ,
.局部变量 匿名局部变量_119, 字节集, , ,

.如果真 (或者 (小于或等于 (匿名参数_75, 0), 等于 (匿名参数_77, 0), 小于或等于 (匿名程序集变量_102, 0)))
    赋值 (匿名程序集变量_473, 1)
    赋值 (匿名参数_92, 1)
    返回 (假)
.如果真结束
赋值 (匿名局部变量_119, 取空白字节集 (匿名参数_77))
赋值 (匿名局部变量_113.匿名成员1207, 匿名参数_73)
赋值 (匿名局部变量_113.匿名成员1208, 相减 (相加 (匿名参数_75, 匿名参数_73), 31))
赋值 (匿名局部变量_113.匿名成员1209, lstrcpyn_121 (匿名局部变量_119, 匿名局部变量_119, 0))
赋值 (匿名局部变量_113.匿名成员1210, 匿名参数_77)
.如果真 (并且 (大于 (匿名参数_75, 0), 小于或等于 (匿名参数_75, 2147483647)))
    .判断开始 (匿名程序集变量_1035)
        匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3079), lstrcpyn_104 (匿名局部变量_113.匿名成员1207, 匿名局部变量_113.匿名成员1207, 0), 16, lstrcpyn_104 (匿名参数_92, 匿名参数_92, 0), 4, 0)
    .默认
        匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3075), lstrcpyn_104 (匿名局部变量_113.匿名成员1207, 匿名局部变量_113.匿名成员1207, 0), 16, lstrcpyn_104 (匿名参数_92, 匿名参数_92, 0), 4, 0)
    .判断结束
   
.如果真结束

赋值 (匿名程序集变量_473, 匿名参数_92)
.如果真 (等于 (匿名参数_92, 0))
    赋值 (匿名参数_98, 匿名局部变量_119)
.如果真结束
返回 (等于 (匿名参数_92, 0))

.子程序 写内存, 逻辑型, ,
.参数 匿名参数_81, 整数型, ,
.参数 匿名参数_85, 整数型, ,
.参数 匿名参数_89, 整数型, ,
.参数 匿名参数_101, 字节集, ,
.参数 匿名参数_94, 整数型, 参考 可空,

.局部变量 匿名局部变量_2038, 整数型, , ,
.局部变量 匿名局部变量_126, 匿名数据类型_1206, , ,

.如果真 (或者 (小于或等于 (匿名参数_85, 0), 等于 (匿名参数_89, 0), 小于或等于 (匿名程序集变量_102, 0)))
    赋值 (匿名程序集变量_473, 1)
    赋值 (匿名参数_94, 1)
    返回 (假)
.如果真结束
赋值 (匿名局部变量_126.匿名成员1207, 匿名参数_81)
赋值 (匿名局部变量_126.匿名成员1208, 相减 (相加 (匿名参数_85, 匿名参数_81), 31))
赋值 (匿名局部变量_126.匿名成员1209, lstrcpyn_121 (匿名参数_101, 匿名参数_101, 0))
赋值 (匿名局部变量_126.匿名成员1210, 匿名参数_89)
.如果真 (并且 (大于 (匿名参数_85, 0), 小于或等于 (匿名参数_85, 2147483647)))
    .判断开始 (匿名程序集变量_1035)
        匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3071), lstrcpyn_104 (匿名局部变量_126.匿名成员1207, 匿名局部变量_126.匿名成员1207, 0), 16, lstrcpyn_104 (匿名参数_94, 匿名参数_94, 0), 4, 0)
    .默认
        匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3073), lstrcpyn_104 (匿名局部变量_126.匿名成员1207, 匿名局部变量_126.匿名成员1207, 0), 16, lstrcpyn_104 (匿名参数_94, 匿名参数_94, 0), 4, 0)
    .判断结束
   
.如果真结束

赋值 (匿名程序集变量_473, 匿名参数_94)
返回 (等于 (匿名参数_94, 0))

.子程序 申请内存, 整数型, , 申请内存
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 长度, 整数型, ,
.参数 类型, 整数型, ,
.参数 属性, 整数型, ,

.局部变量 匿名局部变量_1194, 匿名数据类型_1206, , ,
.局部变量 匿名局部变量_1195, 整数型, , ,
.局部变量 匿名局部变量_1187, 整数型, , ,

赋值 (匿名局部变量_1187, 打开进程 (进程ID))
.如果真 (不等于 (匿名局部变量_1187, 0))
    赋值 (匿名局部变量_1194.匿名成员1207, 匿名局部变量_1187)
    赋值 (匿名局部变量_1194.匿名成员1208, lstrcpyn_104 (地址, 地址, 0))
    赋值 (匿名局部变量_1194.匿名成员1209, lstrcpyn_104 (长度, 长度, 0))
    赋值 (匿名局部变量_1194.匿名成员1210, 类型)
    赋值 (匿名局部变量_1194.匿名成员1211, 属性)
    匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3076), lstrcpyn_104 (匿名局部变量_1194.匿名成员1207, 匿名局部变量_1194.匿名成员1207, 0), 20, lstrcpyn_104 (匿名局部变量_1195, 匿名局部变量_1195, 0), 4, 0)
    关闭进程 (匿名局部变量_1187)
.如果真结束
返回 (匿名局部变量_1195)

.子程序 释放内存, 逻辑型, , 释放内存
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 长度, 整数型, ,
.参数 类型, 整数型, ,

.局部变量 匿名局部变量_1231, 匿名数据类型_108, , ,
.局部变量 匿名局部变量_1232, 整数型, , ,
.局部变量 匿名局部变量_1233, 整数型, , ,

赋值 (匿名局部变量_1233, 打开进程 (进程ID))
.如果真 (不等于 (匿名局部变量_1233, 0))
    赋值 (匿名局部变量_1231.匿名成员109, 匿名局部变量_1233)
    赋值 (匿名局部变量_1231.匿名成员110, lstrcpyn_104 (地址, 地址, 0))
    赋值 (匿名局部变量_1231.匿名成员111, lstrcpyn_104 (长度, 长度, 0))
    赋值 (匿名局部变量_1231.匿名成员112, 类型)
    匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3078), lstrcpyn_104 (匿名局部变量_1231.匿名成员109, 匿名局部变量_1231.匿名成员109, 0), 16, lstrcpyn_104 (匿名局部变量_1232, 匿名局部变量_1232, 0), 4, 0)
    关闭进程 (匿名局部变量_1233)
.如果真结束
返回 (等于 (匿名局部变量_1232, 0))

.子程序 打开进程, 整数型, , 打开进程
.参数 进程ID, 整数型, ,

.局部变量 匿名局部变量_966, 匿名数据类型_108, , ,
.局部变量 匿名局部变量_967, 整数型, , ,

.如果真 (不等于 (进程ID, 0))
    赋值 (匿名局部变量_966.匿名成员109, 进程ID)
    赋值 (匿名局部变量_966.匿名成员110, 0)
    赋值 (匿名局部变量_966.匿名成员111, 0)
    赋值 (匿名局部变量_966.匿名成员112, 0)
    匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3074), lstrcpyn_104 (匿名局部变量_966.匿名成员109, 匿名局部变量_966.匿名成员109, 0), 16, lstrcpyn_104 (匿名局部变量_967, 匿名局部变量_967, 0), 4, 0)
.如果真结束
返回 (匿名局部变量_967)

.子程序 关闭进程, 整数型, , 关闭进程
.参数 进程句柄, 整数型, ,

.局部变量 匿名局部变量_969, 匿名数据类型_108, , ,
.局部变量 匿名局部变量_970, 整数型, , ,

.如果真 (不等于 (进程句柄, 0))
    赋值 (匿名局部变量_969.匿名成员109, 进程句柄)
    赋值 (匿名局部变量_969.匿名成员110, 0)
    赋值 (匿名局部变量_969.匿名成员111, 0)
    赋值 (匿名局部变量_969.匿名成员112, 0)
    匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3072), lstrcpyn_104 (匿名局部变量_969.匿名成员109, 匿名局部变量_969.匿名成员109, 0), 16, lstrcpyn_104 (匿名局部变量_970, 匿名局部变量_970, 0), 4, 0)
.如果真结束
返回 (匿名局部变量_970)

.子程序 执行代码, 整数型, , 执行代码
.参数 进程, 整数型, ,
.参数 数据, 字节集, ,
.参数 长度, 整数型, ,

.局部变量 匿名局部变量_941, 整数型, , ,
.局部变量 匿名局部变量_942, 匿名数据类型_108, , ,

.如果真 (或者 (等于 (长度, 0), 小于或等于 (匿名程序集变量_102, 0)))
    返回 (0)
.如果真结束
赋值 (匿名局部变量_942.匿名成员109, 进程)
赋值 (匿名局部变量_942.匿名成员110, 0)
赋值 (匿名局部变量_942.匿名成员111, lstrcpyn_121 (数据, 数据, 0))
赋值 (匿名局部变量_942.匿名成员112, 长度)
匿名子程序_3234 (匿名程序集变量_102, 匿名子程序_3233 (3077), lstrcpyn_104 (匿名局部变量_942.匿名成员109, 匿名局部变量_942.匿名成员109, 0), 16, lstrcpyn_104 (匿名局部变量_941, 匿名局部变量_941, 0), 4, 0)
返回 (匿名局部变量_941)

.子程序 读代码, 整数型, , 支持 读内存整数型 读内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_401, 整数型, , ,
.局部变量 匿名局部变量_402, 整数型, , ,
.局部变量 匿名局部变量_403, 文本型, , "0",

赋值 (匿名局部变量_403, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_403), 匿名局部变量_401)
    .判断开始 (等于 (匿名局部变量_401, 取数组成员数 (匿名局部变量_403)))
        赋值 (匿名局部变量_402, 相加 (转十六到十_ (匿名局部变量_403 [匿名局部变量_401]), 匿名局部变量_402))
    .默认
        赋值 (匿名局部变量_402, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_403 [匿名局部变量_401]), 匿名局部变量_402)))
    .判断结束
   
.计次循环尾 ()
.如果真 (等于 (是否为空 (取回字节集), 假))
    .如果真 (是否为空 (取回数据长度))
        赋值 (取回数据长度, 4)
    .如果真结束
    赋值 (取回字节集, 字节集查看_ (读字节集 (进程ID, 匿名局部变量_402, 取回数据长度)))
.如果真结束
返回 (读整数 (进程ID, 匿名局部变量_402))

.子程序 写代码, 逻辑型, , 支持 写内存整数型 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200=888” 或 “401000+10A0+200={90,90,90,90}”
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_407, 文本型, , ,
.局部变量 匿名局部变量_408, 文本型, , "0",
.局部变量 匿名局部变量_409, 文本型, , "0",
.局部变量 匿名局部变量_410, 整数型, , ,
.局部变量 匿名局部变量_411, 整数型, , ,

赋值 (匿名局部变量_408, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_408), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_407, 匿名局部变量_408 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_408), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_409, 分割文本 (匿名局部变量_408 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.判断开始 (等于 (取文本左边 (匿名局部变量_407, 1), “{”))
    .计次循环首 (取数组成员数 (匿名局部变量_409), 匿名局部变量_410)
        .判断开始 (等于 (匿名局部变量_410, 取数组成员数 (匿名局部变量_409)))
            赋值 (匿名局部变量_411, 相加 (转十六到十_ (匿名局部变量_409 [匿名局部变量_410]), 匿名局部变量_411))
        .默认
            赋值 (匿名局部变量_411, 到整数 (读字节集 (进程ID, 相加 (转十六到十_ (匿名局部变量_409 [匿名局部变量_410]), 匿名局部变量_411), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_411, 还原字节集_ (匿名局部变量_407)))
.默认
    .计次循环首 (取数组成员数 (匿名局部变量_409), 匿名局部变量_410)
        .判断开始 (等于 (匿名局部变量_410, 取数组成员数 (匿名局部变量_409)))
            赋值 (匿名局部变量_411, 相加 (转十六到十_ (匿名局部变量_409 [匿名局部变量_410]), 匿名局部变量_411))
        .默认
            赋值 (匿名局部变量_411, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_409 [匿名局部变量_410]), 匿名局部变量_411)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写整数 (进程ID, 匿名局部变量_411, 到整数 (匿名局部变量_407)))
.判断结束


.子程序 读文本代码, 文本型, , 支持 读内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200”
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_2067, 整数型, , ,
.局部变量 匿名局部变量_2068, 整数型, , ,
.局部变量 匿名局部变量_2069, 文本型, , "0",

赋值 (匿名局部变量_2069, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_2069), 匿名局部变量_2067)
    .判断开始 (等于 (匿名局部变量_2067, 取数组成员数 (匿名局部变量_2069)))
        赋值 (匿名局部变量_2068, 相加 (转十六到十_ (匿名局部变量_2069 [匿名局部变量_2067]), 匿名局部变量_2068))
    .默认
        赋值 (匿名局部变量_2068, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2069 [匿名局部变量_2067]), 匿名局部变量_2068)))
    .判断结束
   
.计次循环尾 ()
返回 (读文本 (进程ID, 匿名局部变量_2068, 取回数据长度))

.子程序 写文本代码, 逻辑型, , 支持 写内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200=你好!”
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_2080, 文本型, , ,
.局部变量 匿名局部变量_2081, 文本型, , "0",
.局部变量 匿名局部变量_2082, 文本型, , "0",
.局部变量 匿名局部变量_2083, 整数型, , ,
.局部变量 匿名局部变量_2084, 整数型, , ,
.局部变量 匿名局部变量_2120, 整数型, , ,

赋值 (匿名局部变量_2081, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_2081), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2080, 匿名局部变量_2081 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_2081), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2082, 分割文本 (匿名局部变量_2081 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.计次循环首 (取数组成员数 (匿名局部变量_2082), 匿名局部变量_2083)
    .判断开始 (等于 (匿名局部变量_2083, 取数组成员数 (匿名局部变量_2082)))
        赋值 (匿名局部变量_2084, 相加 (转十六到十_ (匿名局部变量_2082 [匿名局部变量_2083]), 匿名局部变量_2084))
    .默认
        赋值 (匿名局部变量_2084, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2082 [匿名局部变量_2083]), 匿名局部变量_2084)))
    .判断结束
   
.计次循环尾 ()
写内存 (进程ID, 匿名局部变量_2084, 选择 (是否为空 (长度), 相加 (取文本长度 (匿名局部变量_2080), 1), 长度), 相加 (到字节集 (匿名局部变量_2080), { 0 }), 匿名局部变量_2120)
返回 (等于 (匿名局部变量_2120, 0))

.子程序 读字节集代码, 字节集, , 支持 读内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_2097, 整数型, , ,
.局部变量 匿名局部变量_2098, 整数型, , ,
.局部变量 匿名局部变量_2099, 文本型, , "0",

赋值 (匿名局部变量_2099, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_2099), 匿名局部变量_2097)
    .判断开始 (等于 (匿名局部变量_2097, 取数组成员数 (匿名局部变量_2099)))
        赋值 (匿名局部变量_2098, 相加 (转十六到十_ (匿名局部变量_2099 [匿名局部变量_2097]), 匿名局部变量_2098))
    .默认
        赋值 (匿名局部变量_2098, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2099 [匿名局部变量_2097]), 匿名局部变量_2098)))
    .判断结束
   
.计次循环尾 ()
.如果真 (等于 (是否为空 (取回字节集), 假))
    .如果真 (是否为空 (取回数据长度))
        赋值 (取回数据长度, 4)
    .如果真结束
    赋值 (取回字节集, 字节集查看_ (读字节集 (进程ID, 匿名局部变量_2098, 取回数据长度)))
.如果真结束
返回 (读字节集 (进程ID, 匿名局部变量_2098, 取回数据长度))

.子程序 写字节集代码, 逻辑型, , 支持 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200={90,90,90,90}”
.参数 字节集, 字节集, 可空,
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_2103, 文本型, , ,
.局部变量 匿名局部变量_2104, 文本型, , "0",
.局部变量 匿名局部变量_2105, 文本型, , "0",
.局部变量 匿名局部变量_2106, 整数型, , ,
.局部变量 匿名局部变量_2107, 整数型, , ,

.如果真 (等于 (寻找文本 (地址表达式, “=”, , 假), -1))
    赋值 (地址表达式, 相加 (地址表达式, “=0”))
.如果真结束
赋值 (匿名局部变量_2104, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_2104), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2103, 匿名局部变量_2104 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_2104), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2105, 分割文本 (匿名局部变量_2104 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.判断开始 (或者 (等于 (取文本左边 (匿名局部变量_2103, 1), “{”), 是否为空 (字节集)))
    .计次循环首 (取数组成员数 (匿名局部变量_2105), 匿名局部变量_2106)
        .判断开始 (等于 (匿名局部变量_2106, 取数组成员数 (匿名局部变量_2105)))
            赋值 (匿名局部变量_2107, 相加 (转十六到十_ (匿名局部变量_2105 [匿名局部变量_2106]), 匿名局部变量_2107))
        .默认
            赋值 (匿名局部变量_2107, 到整数 (读字节集 (进程ID, 相加 (转十六到十_ (匿名局部变量_2105 [匿名局部变量_2106]), 匿名局部变量_2107), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_2107, 还原字节集_ (匿名局部变量_2103)))
.默认
    .计次循环首 (取数组成员数 (匿名局部变量_2105), 匿名局部变量_2106)
        .判断开始 (等于 (匿名局部变量_2106, 取数组成员数 (匿名局部变量_2105)))
            赋值 (匿名局部变量_2107, 相加 (转十六到十_ (匿名局部变量_2105 [匿名局部变量_2106]), 匿名局部变量_2107))
        .默认
            赋值 (匿名局部变量_2107, 到整数 (读字节集 (进程ID, 相加 (转十六到十_ (匿名局部变量_2105 [匿名局部变量_2106]), 匿名局部变量_2107), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_2107, 字节集))
.判断结束


.子程序 读字节, 字节型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 字节型, 可空,

.局部变量 匿名局部变量_250, 整数型, , ,
.局部变量 匿名局部变量_251, 字节集, , ,

读内存 (进程ID, 地址, 1, 匿名局部变量_251, 匿名局部变量_250)
.如果 (不等于 (匿名局部变量_250, 0))
    返回 (选择 (是否为空 (默认值), 0, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_251, 1, ))
.如果结束


.子程序 写字节, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 字节, 字节型, ,

.局部变量 匿名局部变量_255, 整数型, , ,
.局部变量 匿名局部变量_256, 整数型, , ,

写内存 (进程ID, 地址, 1, 到字节集 (到字节 (字节)), 匿名局部变量_255)
.如果 (不等于 (匿名局部变量_255, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读小数, 小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 小数型, 可空,

.局部变量 匿名局部变量_272, 整数型, , ,
.局部变量 匿名局部变量_273, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_273, 匿名局部变量_272)
.如果 (不等于 (匿名局部变量_272, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_273, 5, ))
.如果结束


.子程序 写小数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 小数, 小数型, ,

.局部变量 匿名局部变量_277, 整数型, , ,
.局部变量 匿名局部变量_278, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到小数 (小数)), 匿名局部变量_277)
.如果 (不等于 (匿名局部变量_277, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读短整数, 短整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 短整数型, 可空,

.局部变量 匿名局部变量_327, 整数型, , ,
.局部变量 匿名局部变量_328, 字节集, , ,

读内存 (进程ID, 地址, 2, 匿名局部变量_328, 匿名局部变量_327)
.如果 (不等于 (匿名局部变量_327, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_328, 2, ))
.如果结束


.子程序 写短整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 短整数, 短整数型, ,

.局部变量 匿名局部变量_332, 整数型, , ,
.局部变量 匿名局部变量_333, 整数型, , ,

写内存 (进程ID, 地址, 2, 到字节集 (到短整数 (短整数)), 匿名局部变量_332)
.如果 (不等于 (匿名局部变量_332, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读长整数, 长整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 长整数型, 可空,

.局部变量 匿名局部变量_342, 整数型, , ,
.局部变量 匿名局部变量_343, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_343, 匿名局部变量_342)
.如果 (不等于 (匿名局部变量_342, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_343, 4, ))
.如果结束


.子程序 写长整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 长整数, 长整数型, ,

.局部变量 匿名局部变量_347, 整数型, , ,
.局部变量 匿名局部变量_348, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到长整数 (长整数)), 匿名局部变量_347)
.如果 (不等于 (匿名局部变量_347, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读双精浮点数, 双精度小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 双精度小数型, 可空,

.局部变量 匿名局部变量_291, 整数型, , ,
.局部变量 匿名局部变量_292, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_292, 匿名局部变量_291)
.如果 (不等于 (匿名局部变量_291, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_292, 6, ))
.如果结束


.子程序 写双精浮点数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 双精度, 双精度小数型, ,

.局部变量 匿名局部变量_296, 整数型, , ,
.局部变量 匿名局部变量_297, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到数值 (双精度)), 匿名局部变量_296)
.如果 (不等于 (匿名局部变量_296, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 逻辑型, 可空,

.局部变量 匿名局部变量_309, 整数型, , ,
.局部变量 匿名局部变量_310, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_310, 匿名局部变量_309)
.如果 (不等于 (匿名局部变量_309, 0))
    返回 (选择 (是否为空 (默认值), 假, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_310, 7, ))
.如果结束


.子程序 写逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 逻辑, 逻辑型, ,

.局部变量 匿名局部变量_314, 整数型, , ,
.局部变量 匿名局部变量_315, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到整数 (选择 (逻辑, 1, 0))), 匿名局部变量_314)
.如果 (不等于 (匿名局部变量_314, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读整数, 整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 整数型, 可空,

.局部变量 匿名局部变量_181, 整数型, , ,
.局部变量 匿名局部变量_175, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_175, 匿名局部变量_181)
.如果 (不等于 (匿名局部变量_181, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_175, 3, ))
.如果结束


.子程序 写整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 整数, 整数型, ,

.局部变量 匿名局部变量_190, 整数型, , ,
.局部变量 匿名局部变量_191, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到整数 (整数)), 匿名局部变量_190)
.如果 (不等于 (匿名局部变量_190, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读文本, 文本型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 长度, 整数型, ,

.局部变量 匿名局部变量_203, 整数型, , ,
.局部变量 匿名局部变量_204, 字节集, , ,

读内存 (进程ID, 地址, 长度, 匿名局部变量_204, 匿名局部变量_203)
.如果 (不等于 (匿名局部变量_203, 0))
    返回 (“”)
.否则
    返回 (取字节集数据 (匿名局部变量_204, 10, ))
.如果结束


.子程序 写文本, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 文本, 文本型, ,

.局部变量 匿名局部变量_208, 整数型, , ,
.局部变量 匿名局部变量_209, 整数型, , ,

写内存 (进程ID, 地址, 相加 (取文本长度 (文本), 1), 相加 (到字节集 (文本), { 0 }), 匿名局部变量_208)
.如果 (不等于 (匿名局部变量_208, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读字节集, 字节集, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 长度, 整数型, ,

.局部变量 匿名局部变量_224, 整数型, , ,
.局部变量 匿名局部变量_225, 字节集, , ,

读内存 (进程ID, 地址, 长度, 匿名局部变量_225, 匿名局部变量_224)
.如果 (不等于 (匿名局部变量_224, 0))
    返回 ({  })
.否则
    返回 (匿名局部变量_225)
.如果结束


.子程序 写字节集, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 数据, 字节集, ,
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_229, 整数型, , ,
.局部变量 匿名局部变量_230, 整数型, , ,

写内存 (进程ID, 地址, 选择 (等于 (长度, 0), 取字节集长度 (数据), 长度), 数据, 匿名局部变量_229)
.如果 (不等于 (匿名局部变量_229, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读日期时间, 日期时间型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 日期时间型, 可空,

.局部变量 匿名局部变量_363, 整数型, , ,
.局部变量 匿名局部变量_364, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_364, 匿名局部变量_363)
.如果 (不等于 (匿名局部变量_363, 0))
    返回 (选择 (是否为空 (默认值), 到时间 (0), 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_364, 8, ))
.如果结束


.子程序 写日期时间, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 时间, 日期时间型, ,

.局部变量 匿名局部变量_368, 整数型, , ,
.局部变量 匿名局部变量_369, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到时间 (时间)), 匿名局部变量_368)
.如果 (不等于 (匿名局部变量_368, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读子程序指针, 子程序指针, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 默认值, 子程序指针, 可空,

.局部变量 匿名局部变量_381, 整数型, , ,
.局部变量 匿名局部变量_382, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_382, 匿名局部变量_381)
.如果 (不等于 (匿名局部变量_381, 0))
    返回 (选择 (是否为空 (默认值), 默认值, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_382, 9, ))
.如果结束


.子程序 写子程序指针, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 整数型, ,
.参数 指针, 子程序指针, ,

.局部变量 匿名局部变量_386, 整数型, , ,
.局部变量 匿名局部变量_387, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到数值 (指针)), 匿名局部变量_386)
.如果 (不等于 (匿名局部变量_386, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.类模块 匿名类模块_8, , ,

.程序集变量 匿名程序集变量_1965, 文本型, , ,
.程序集变量 匿名程序集变量_518, 文本型, , ,
.程序集变量 匿名程序集变量_519, 文本型, , ,
.程序集变量 匿名程序集变量_520, 整数型, , ,
.程序集变量 匿名程序集变量_1870, 整数型, , ,
.程序集变量 匿名程序集变量_521, 整数型, , ,
.子程序 _初始化, , ,


.子程序 _销毁, , ,


.子程序 打开句柄_并通讯, , ,
.参数 匿名参数_1883, 整数型, 可空,
.参数 匿名参数_1884, 整数型, 可空,
.参数 匿名参数_1885, 整数型, 可空,
.参数 匿名参数_1886, 整数型, 可空,
.参数 匿名参数_1887, 整数型, 可空,
.参数 匿名参数_1888, 整数型, 可空,

赋值 (匿名程序集变量_1870, CreateSemaphoreA_1838 (0, 1, 1, 匿名程序集变量_1965))
WaitForSingleObject_1867 (匿名程序集变量_1870, 100)
赋值 (匿名程序集变量_521, 匿名子程序_3229 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519))
.如果真 (等于 (是否为空 (匿名参数_1883), 假))
    匿名子程序_3234 (匿名程序集变量_521, 匿名参数_1883, 匿名参数_1884, 匿名参数_1885, 匿名参数_1886, 匿名参数_1887, 匿名参数_1888)
.如果真结束


.子程序 关闭句柄, , ,
.如果真 (大于 (匿名程序集变量_521, 0))
    匿名子程序_3232 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519, 匿名程序集变量_521)
    赋值 (匿名程序集变量_521, 0)
.如果真结束
ReleaseSemaphore_1855 (匿名程序集变量_1870, 1, 0)

.子程序 getd, 文本型, ,
.参数 匿名参数_522, 文本型, ,
.参数 匿名参数_523, 整数型, 可空,

.局部变量 匿名局部变量_524, 文本型, , ,
.局部变量 匿名局部变量_525, 整数型, , ,
.局部变量 匿名局部变量_526, 整数型, , ,

赋值 (匿名局部变量_526, 取文本长度 (匿名参数_522))
.如果真 (等于 (匿名参数_523, 0))
    置随机数种子 ()
    赋值 (匿名参数_523, 取随机数 (1, 匿名局部变量_526))
.如果真结束
置随机数种子 ()
.计次循环首 (匿名参数_523, 匿名局部变量_525)
    赋值 (匿名局部变量_524, 相加 (匿名局部变量_524, 取文本中间 (匿名参数_522, 取随机数 (1, 匿名局部变量_526), 1)))
.计次循环尾 ()
返回 (匿名局部变量_524)

.子程序 取Sys目录, 文本型, ,
.局部变量 匿名局部变量_527, 文本型, , ,

赋值 (匿名局部变量_527, 取空白文本 (256))
GetTempPathA_470 (255, 匿名局部变量_527)
返回 (匿名局部变量_527)

.子程序 安装, 逻辑型, 公开, 当无签名驱动没有加载时 可以使用此功能加载有签名的驱动
.参数 X64驱动文件, 字节集, 可空, 此处添加有签名的驱动文件
.参数 驱动名, 文本型, 可空,

.局部变量 匿名局部变量_1831, 整数型, , ,

.如果 (等于 (驱动名, “”))
    赋值 (匿名程序集变量_1965, “uMcg_x64”)
.否则
    赋值 (匿名程序集变量_1965, 驱动名)
.如果结束

赋值 (匿名程序集变量_518, “uMcg_x64”)
赋值 (匿名程序集变量_519, 相加 (取Sys目录 (), “~uMcg”, getd (“0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ”, 5), “.sys”))
打开句柄_并通讯 ()
.如果真 (小于或等于 (匿名程序集变量_521, 0))
    匿名子程序_3214 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519)
    .如果真 (等于 (文件是否存在 (匿名程序集变量_519), 假))
        .如果真 (等于 (X64驱动文件, {  }))
            赋值 (X64驱动文件, #匿名图片_689)
        .如果真结束
        
        写到文件 (匿名程序集变量_519, X64驱动文件)
        置文件属性 (匿名程序集变量_519, 6)
    .如果真结束
   
    .如果真 (不等于 (匿名子程序_3215 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519), 0))
        删除文件 (匿名程序集变量_519)
        打开句柄_并通讯 ()
        赋值 (匿名局部变量_1831, 匿名程序集变量_521)
        关闭句柄 ()
        .如果真 (小于或等于 (匿名局部变量_1831, 0))
            卸载 ()
            返回 (假)
        .如果真结束
        返回 (大于 (匿名局部变量_1831, 0))
    .如果真结束
    删除文件 (匿名程序集变量_519)
    卸载 ()
    返回 (假)
.如果真结束
关闭句柄 ()
返回 (真)

.子程序 是否安装成功, 逻辑型, , 是否安装成功
.局部变量 匿名局部变量_1829, 整数型, , ,

打开句柄_并通讯 ()
赋值 (匿名局部变量_1829, 匿名程序集变量_521)
关闭句柄 ()
返回 (大于 (匿名局部变量_1829, 0))

.子程序 卸载, , , 卸载
关闭句柄 ()
匿名子程序_3216 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519)
匿名子程序_3217 (匿名程序集变量_1965, 匿名程序集变量_518, 匿名程序集变量_518, 匿名程序集变量_519)

.子程序 取错误, 整数型, , 取错误
.参数 返回错误原因, 文本型, 参考 可空,

.局部变量 匿名局部变量_529, 整数型, , ,

赋值 (匿名局部变量_529, 匿名程序集变量_520)
赋值 (匿名程序集变量_520, 0)
.如果真 (等于 (匿名局部变量_529, -1))
    赋值 (返回错误原因, “进程打开失败!”)
.如果真结束
.如果真 (等于 (匿名局部变量_529, 0))
    赋值 (返回错误原因, “操作已经完成!”)
.如果真结束
.如果真 (等于 (匿名局部变量_529, 1))
    赋值 (返回错误原因, “内存读写失败!”)
.如果真结束
返回 (匿名局部变量_529)

.子程序 读内存, 逻辑型, ,
.参数 匿名参数_530, 整数型, ,
.参数 匿名参数_531, 长整数型, ,
.参数 匿名参数_532, 整数型, ,
.参数 匿名参数_533, 字节集, 参考,
.参数 匿名参数_534, 整数型, 参考 可空,

.局部变量 匿名局部变量_535, 匿名数据类型_693, , ,
.局部变量 匿名局部变量_536, 字节集, , ,

.如果真 (或者 (小于或等于 (匿名参数_531, 0), 等于 (匿名参数_532, 0)))
    赋值 (匿名程序集变量_520, 1)
    赋值 (匿名参数_534, 1)
    返回 (假)
.如果真结束
赋值 (匿名局部变量_536, 取空白字节集 (匿名参数_532))
赋值 (匿名局部变量_535.匿名成员694, 匿名参数_530)
赋值 (匿名局部变量_535.匿名成员695, 匿名参数_531)
赋值 (匿名局部变量_535.匿名成员696, lstrcpyn_121 (匿名局部变量_536, 匿名局部变量_536, 0))
赋值 (匿名局部变量_535.匿名成员697, 匿名参数_532)
打开句柄_并通讯 (匿名子程序_3233 (3073), lstrcpyn_104 (匿名局部变量_535.匿名成员694, 匿名局部变量_535.匿名成员694, 0), 20, lstrcpyn_104 (匿名参数_534, 匿名参数_534, 0), 4, 0)
关闭句柄 ()
赋值 (匿名程序集变量_520, 匿名参数_534)
.如果真 (等于 (匿名参数_534, 0))
    赋值 (匿名参数_533, 匿名局部变量_536)
.如果真结束
返回 (等于 (匿名参数_534, 0))

.子程序 写内存, 逻辑型, ,
.参数 匿名参数_537, 整数型, ,
.参数 匿名参数_538, 长整数型, ,
.参数 匿名参数_539, 整数型, ,
.参数 匿名参数_540, 字节集, ,
.参数 匿名参数_541, 整数型, 参考 可空,

.局部变量 匿名局部变量_542, 匿名数据类型_693, , ,

.如果真 (或者 (小于或等于 (匿名参数_538, 0), 等于 (匿名参数_539, 0)))
    赋值 (匿名程序集变量_520, 1)
    赋值 (匿名参数_541, 1)
    返回 (假)
.如果真结束
赋值 (匿名局部变量_542.匿名成员694, 匿名参数_537)
赋值 (匿名局部变量_542.匿名成员695, 匿名参数_538)
赋值 (匿名局部变量_542.匿名成员696, lstrcpyn_121 (匿名参数_540, 匿名参数_540, 0))
赋值 (匿名局部变量_542.匿名成员697, 匿名参数_539)
打开句柄_并通讯 (匿名子程序_3233 (3072), lstrcpyn_104 (匿名局部变量_542.匿名成员694, 匿名局部变量_542.匿名成员694, 0), 20, lstrcpyn_104 (匿名参数_541, 匿名参数_541, 0), 4, 0)
关闭句柄 ()
赋值 (匿名程序集变量_520, 匿名参数_541)
返回 (等于 (匿名参数_541, 0))

.子程序 打开进程, 整数型, , 打开进程
.参数 进程ID, 整数型, ,

.局部变量 匿名局部变量_1091, 匿名数据类型_693, , ,
.局部变量 匿名局部变量_1092, 整数型, , ,

.如果真 (不等于 (进程ID, 0))
    赋值 (匿名局部变量_1091.匿名成员694, 进程ID)
    赋值 (匿名局部变量_1091.匿名成员695, 0)
    赋值 (匿名局部变量_1091.匿名成员696, 0)
    赋值 (匿名局部变量_1091.匿名成员697, 0)
    打开句柄_并通讯 (匿名子程序_3233 (3074), lstrcpyn_104 (匿名局部变量_1091.匿名成员694, 匿名局部变量_1091.匿名成员694, 0), 20, lstrcpyn_104 (匿名局部变量_1092, 匿名局部变量_1092, 0), 4, 0)
    关闭句柄 ()
.如果真结束
返回 (匿名局部变量_1092)

.子程序 关闭进程, 整数型, , 关闭进程
.参数 进程句柄, 整数型, ,

.局部变量 匿名局部变量_1094, 匿名数据类型_693, , ,
.局部变量 匿名局部变量_1095, 整数型, , ,

.如果真 (不等于 (进程句柄, 0))
    赋值 (匿名局部变量_1094.匿名成员694, 进程句柄)
    赋值 (匿名局部变量_1094.匿名成员695, 0)
    赋值 (匿名局部变量_1094.匿名成员696, 0)
    赋值 (匿名局部变量_1094.匿名成员697, 0)
    打开句柄_并通讯 (匿名子程序_3233 (3075), lstrcpyn_104 (匿名局部变量_1094.匿名成员694, 匿名局部变量_1094.匿名成员694, 0), 20, lstrcpyn_104 (匿名局部变量_1095, 匿名局部变量_1095, 0), 4, 0)
    关闭句柄 ()
.如果真结束
返回 (匿名局部变量_1095)

.子程序 读代码, 长整数型, , 支持 读内存整数型 读内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_547, 整数型, , ,
.局部变量 匿名局部变量_548, 长整数型, , ,
.局部变量 匿名局部变量_549, 文本型, , "0",

赋值 (匿名局部变量_549, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_549), 匿名局部变量_547)
    .判断开始 (等于 (匿名局部变量_547, 取数组成员数 (匿名局部变量_549)))
        赋值 (匿名局部变量_548, 相加 (十六到十_ (匿名局部变量_549 [匿名局部变量_547]), 匿名局部变量_548))
    .默认
        赋值 (匿名局部变量_548, 读整数 (进程ID, 相加 (十六到十_ (匿名局部变量_549 [匿名局部变量_547]), 匿名局部变量_548)))
    .判断结束
   
.计次循环尾 ()
.如果真 (等于 (是否为空 (取回字节集), 假))
    .如果真 (是否为空 (取回数据长度))
        赋值 (取回数据长度, 8)
    .如果真结束
    赋值 (取回字节集, 字节集查看_ (读字节集 (进程ID, 匿名局部变量_548, 取回数据长度)))
.如果真结束
返回 (读整数 (进程ID, 匿名局部变量_548))

.子程序 写代码, 逻辑型, , 支持 写内存整数型 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200=888” 或 “0000000013480000+10A0+200={90,90,90,90}”
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_553, 文本型, , ,
.局部变量 匿名局部变量_554, 文本型, , "0",
.局部变量 匿名局部变量_555, 文本型, , "0",
.局部变量 匿名局部变量_556, 整数型, , ,
.局部变量 匿名局部变量_557, 长整数型, , ,

赋值 (匿名局部变量_554, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_554), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_553, 匿名局部变量_554 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_554), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_555, 分割文本 (匿名局部变量_554 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.判断开始 (等于 (取文本左边 (匿名局部变量_553, 1), “{”))
    .计次循环首 (取数组成员数 (匿名局部变量_555), 匿名局部变量_556)
        .判断开始 (等于 (匿名局部变量_556, 取数组成员数 (匿名局部变量_555)))
            赋值 (匿名局部变量_557, 相加 (十六到十_ (匿名局部变量_555 [匿名局部变量_556]), 匿名局部变量_557))
        .默认
            赋值 (匿名局部变量_557, 到整数 (读字节集 (进程ID, 相加 (十六到十_ (匿名局部变量_555 [匿名局部变量_556]), 匿名局部变量_557), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_557, 还原字节集_ (匿名局部变量_553)))
.默认
    .计次循环首 (取数组成员数 (匿名局部变量_555), 匿名局部变量_556)
        .判断开始 (等于 (匿名局部变量_556, 取数组成员数 (匿名局部变量_555)))
            赋值 (匿名局部变量_557, 相加 (十六到十_ (匿名局部变量_555 [匿名局部变量_556]), 匿名局部变量_557))
        .默认
            赋值 (匿名局部变量_557, 读整数 (进程ID, 相加 (十六到十_ (匿名局部变量_555 [匿名局部变量_556]), 匿名局部变量_557)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写整数 (进程ID, 匿名局部变量_557, 到整数 (匿名局部变量_553)))
.判断结束


.子程序 读文本代码, 文本型, , 支持 读内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200”
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_2140, 整数型, , ,
.局部变量 匿名局部变量_2141, 整数型, , ,
.局部变量 匿名局部变量_2142, 文本型, , "0",

赋值 (匿名局部变量_2142, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_2142), 匿名局部变量_2140)
    .判断开始 (等于 (匿名局部变量_2140, 取数组成员数 (匿名局部变量_2142)))
        赋值 (匿名局部变量_2141, 相加 (转十六到十_ (匿名局部变量_2142 [匿名局部变量_2140]), 匿名局部变量_2141))
    .默认
        赋值 (匿名局部变量_2141, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2142 [匿名局部变量_2140]), 匿名局部变量_2141)))
    .判断结束
   
.计次循环尾 ()
返回 (读文本 (进程ID, 匿名局部变量_2141, 取回数据长度))

.子程序 写文本代码, 逻辑型, , 支持 写内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200=你好”
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_2146, 文本型, , ,
.局部变量 匿名局部变量_2147, 文本型, , "0",
.局部变量 匿名局部变量_2148, 文本型, , "0",
.局部变量 匿名局部变量_2149, 整数型, , ,
.局部变量 匿名局部变量_2150, 整数型, , ,
.局部变量 匿名局部变量_2151, 整数型, , ,

赋值 (匿名局部变量_2147, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_2147), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2146, 匿名局部变量_2147 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_2147), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2148, 分割文本 (匿名局部变量_2147 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.计次循环首 (取数组成员数 (匿名局部变量_2148), 匿名局部变量_2149)
    .判断开始 (等于 (匿名局部变量_2149, 取数组成员数 (匿名局部变量_2148)))
        赋值 (匿名局部变量_2150, 相加 (转十六到十_ (匿名局部变量_2148 [匿名局部变量_2149]), 匿名局部变量_2150))
    .默认
        赋值 (匿名局部变量_2150, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2148 [匿名局部变量_2149]), 匿名局部变量_2150)))
    .判断结束
   
.计次循环尾 ()
写内存 (进程ID, 匿名局部变量_2150, 选择 (是否为空 (长度), 相加 (取文本长度 (匿名局部变量_2146), 1), 长度), 相加 (到字节集 (匿名局部变量_2146), { 0 }), 匿名局部变量_2151)
返回 (等于 (匿名局部变量_2151, 0))

.子程序 读字节集代码, 字节集, , 支持 读内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.局部变量 匿名局部变量_2156, 整数型, , ,
.局部变量 匿名局部变量_2157, 整数型, , ,
.局部变量 匿名局部变量_2158, 文本型, , "0",

赋值 (匿名局部变量_2158, 分割文本 (地址表达式, “+”, ))
.计次循环首 (取数组成员数 (匿名局部变量_2158), 匿名局部变量_2156)
    .判断开始 (等于 (匿名局部变量_2156, 取数组成员数 (匿名局部变量_2158)))
        赋值 (匿名局部变量_2157, 相加 (转十六到十_ (匿名局部变量_2158 [匿名局部变量_2156]), 匿名局部变量_2157))
    .默认
        赋值 (匿名局部变量_2157, 读整数 (进程ID, 相加 (转十六到十_ (匿名局部变量_2158 [匿名局部变量_2156]), 匿名局部变量_2157)))
    .判断结束
   
.计次循环尾 ()
.如果真 (等于 (是否为空 (取回字节集), 假))
    .如果真 (是否为空 (取回数据长度))
        赋值 (取回数据长度, 4)
    .如果真结束
    赋值 (取回字节集, 字节集查看_ (读字节集 (进程ID, 匿名局部变量_2157, 取回数据长度)))
.如果真结束
返回 (读字节集 (进程ID, 匿名局部变量_2157, 取回数据长度))

.子程序 写字节集代码, 逻辑型, , 支持 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200={90,90,90,90}”
.参数 字节集, 字节集, 可空, 可空 字节集数据
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_2163, 文本型, , ,
.局部变量 匿名局部变量_2164, 文本型, , "0",
.局部变量 匿名局部变量_2165, 文本型, , "0",
.局部变量 匿名局部变量_2166, 整数型, , ,
.局部变量 匿名局部变量_2167, 整数型, , ,

.如果真 (等于 (寻找文本 (地址表达式, “=”, , 假), -1))
    赋值 (地址表达式, 相加 (地址表达式, “=0”))
.如果真结束
赋值 (匿名局部变量_2164, 分割文本 (地址表达式, “=”, ))
.如果真 (小于 (取数组成员数 (匿名局部变量_2164), 2))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2163, 匿名局部变量_2164 [2])
.如果真 (小于 (取数组成员数 (匿名局部变量_2164), 1))
    返回 (假)
.如果真结束
赋值 (匿名局部变量_2165, 分割文本 (匿名局部变量_2164 [1], “+”, ))
.如果真 (是否为空 (长度))
    赋值 (长度, 4)
.如果真结束
.判断开始 (或者 (等于 (取文本左边 (匿名局部变量_2163, 1), “{”), 是否为空 (字节集)))
    .计次循环首 (取数组成员数 (匿名局部变量_2165), 匿名局部变量_2166)
        .判断开始 (等于 (匿名局部变量_2166, 取数组成员数 (匿名局部变量_2165)))
            赋值 (匿名局部变量_2167, 相加 (转十六到十_ (匿名局部变量_2165 [匿名局部变量_2166]), 匿名局部变量_2167))
        .默认
            赋值 (匿名局部变量_2167, 到整数 (读字节集 (进程ID, 相加 (转十六到十_ (匿名局部变量_2165 [匿名局部变量_2166]), 匿名局部变量_2167), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_2167, 还原字节集_ (匿名局部变量_2163)))
.默认
    .计次循环首 (取数组成员数 (匿名局部变量_2165), 匿名局部变量_2166)
        .判断开始 (等于 (匿名局部变量_2166, 取数组成员数 (匿名局部变量_2165)))
            赋值 (匿名局部变量_2167, 相加 (转十六到十_ (匿名局部变量_2165 [匿名局部变量_2166]), 匿名局部变量_2167))
        .默认
            赋值 (匿名局部变量_2167, 到整数 (读字节集 (进程ID, 相加 (转十六到十_ (匿名局部变量_2165 [匿名局部变量_2166]), 匿名局部变量_2167), 长度)))
        .判断结束
        
    .计次循环尾 ()
    返回 (写字节集 (进程ID, 匿名局部变量_2167, 字节集))
.判断结束


.子程序 读字节, 字节型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 字节型, 可空,

.局部变量 匿名局部变量_561, 整数型, , ,
.局部变量 匿名局部变量_562, 字节集, , ,

读内存 (进程ID, 地址, 1, 匿名局部变量_562, 匿名局部变量_561)
.如果 (不等于 (匿名局部变量_561, 0))
    返回 (选择 (是否为空 (默认值), 0, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_562, 1, ))
.如果结束


.子程序 写字节, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 字节, 字节型, ,

.局部变量 匿名局部变量_566, 整数型, , ,
.局部变量 匿名局部变量_567, 整数型, , ,

写内存 (进程ID, 地址, 1, 到字节集 (到字节 (字节)), 匿名局部变量_566)
.如果 (不等于 (匿名局部变量_566, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读小数, 小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 小数型, 可空,

.局部变量 匿名局部变量_571, 整数型, , ,
.局部变量 匿名局部变量_572, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_572, 匿名局部变量_571)
.如果 (不等于 (匿名局部变量_571, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_572, 5, ))
.如果结束


.子程序 写小数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 小数, 小数型, ,

.局部变量 匿名局部变量_576, 整数型, , ,
.局部变量 匿名局部变量_577, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到小数 (小数)), 匿名局部变量_576)
.如果 (不等于 (匿名局部变量_576, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读短整数, 短整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 短整数型, 可空,

.局部变量 匿名局部变量_581, 整数型, , ,
.局部变量 匿名局部变量_582, 字节集, , ,

读内存 (进程ID, 地址, 2, 匿名局部变量_582, 匿名局部变量_581)
.如果 (不等于 (匿名局部变量_581, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_582, 2, ))
.如果结束


.子程序 写短整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 短整数, 短整数型, ,

.局部变量 匿名局部变量_586, 整数型, , ,
.局部变量 匿名局部变量_587, 整数型, , ,

写内存 (进程ID, 地址, 2, 到字节集 (到短整数 (短整数)), 匿名局部变量_586)
.如果 (不等于 (匿名局部变量_586, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读长整数, 长整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 长整数型, 可空,

.局部变量 匿名局部变量_591, 整数型, , ,
.局部变量 匿名局部变量_592, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_592, 匿名局部变量_591)
.如果 (不等于 (匿名局部变量_591, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_592, 4, ))
.如果结束


.子程序 写长整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长整数, 长整数型, ,

.局部变量 匿名局部变量_596, 整数型, , ,
.局部变量 匿名局部变量_597, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到长整数 (长整数)), 匿名局部变量_596)
.如果 (不等于 (匿名局部变量_596, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读双精浮点数, 双精度小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 双精度小数型, 可空,

.局部变量 匿名局部变量_601, 整数型, , ,
.局部变量 匿名局部变量_602, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_602, 匿名局部变量_601)
.如果 (不等于 (匿名局部变量_601, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_602, 6, ))
.如果结束


.子程序 写双精浮点数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 双精度, 双精度小数型, ,

.局部变量 匿名局部变量_606, 整数型, , ,
.局部变量 匿名局部变量_607, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到数值 (双精度)), 匿名局部变量_606)
.如果 (不等于 (匿名局部变量_606, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 逻辑型, 可空,

.局部变量 匿名局部变量_611, 整数型, , ,
.局部变量 匿名局部变量_612, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_612, 匿名局部变量_611)
.如果 (不等于 (匿名局部变量_611, 0))
    返回 (选择 (是否为空 (默认值), 假, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_612, 7, ))
.如果结束


.子程序 写逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 逻辑, 逻辑型, ,

.局部变量 匿名局部变量_616, 整数型, , ,
.局部变量 匿名局部变量_617, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到整数 (选择 (逻辑, 1, 0))), 匿名局部变量_616)
.如果 (不等于 (匿名局部变量_616, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读整数, 整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 整数型, 可空,

.局部变量 匿名局部变量_621, 整数型, , ,
.局部变量 匿名局部变量_622, 字节集, , ,

读内存 (进程ID, 地址, 4, 匿名局部变量_622, 匿名局部变量_621)
.如果 (不等于 (匿名局部变量_621, 0))
    返回 (选择 (是否为空 (默认值), -1, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_622, 3, ))
.如果结束


.子程序 写整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 整数, 整数型, ,

.局部变量 匿名局部变量_626, 整数型, , ,
.局部变量 匿名局部变量_627, 整数型, , ,

写内存 (进程ID, 地址, 4, 到字节集 (到整数 (整数)), 匿名局部变量_626)
.如果 (不等于 (匿名局部变量_626, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读文本, 文本型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,

.局部变量 匿名局部变量_631, 整数型, , ,
.局部变量 匿名局部变量_632, 字节集, , ,

读内存 (进程ID, 地址, 长度, 匿名局部变量_632, 匿名局部变量_631)
.如果 (不等于 (匿名局部变量_631, 0))
    返回 (“”)
.否则
    返回 (取字节集数据 (匿名局部变量_632, 10, ))
.如果结束


.子程序 写文本, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 文本, 文本型, ,

.局部变量 匿名局部变量_636, 整数型, , ,
.局部变量 匿名局部变量_637, 整数型, , ,

写内存 (进程ID, 地址, 取文本长度 (文本), 到字节集 (文本), 匿名局部变量_636)
.如果 (不等于 (匿名局部变量_636, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读字节集, 字节集, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,

.局部变量 匿名局部变量_641, 整数型, , ,
.局部变量 匿名局部变量_642, 字节集, , ,

读内存 (进程ID, 地址, 长度, 匿名局部变量_642, 匿名局部变量_641)
.如果 (不等于 (匿名局部变量_641, 0))
    返回 ({  })
.否则
    返回 (匿名局部变量_642)
.如果结束


.子程序 写字节集, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 数据, 字节集, ,
.参数 长度, 整数型, 可空,

.局部变量 匿名局部变量_646, 整数型, , ,
.局部变量 匿名局部变量_647, 整数型, , ,

写内存 (进程ID, 地址, 选择 (等于 (长度, 0), 取字节集长度 (数据), 长度), 数据, 匿名局部变量_646)
.如果 (不等于 (匿名局部变量_646, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读日期时间, 日期时间型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 日期时间型, 可空,

.局部变量 匿名局部变量_651, 整数型, , ,
.局部变量 匿名局部变量_652, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_652, 匿名局部变量_651)
.如果 (不等于 (匿名局部变量_651, 0))
    返回 (选择 (是否为空 (默认值), 到时间 (0), 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_652, 8, ))
.如果结束


.子程序 写日期时间, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 时间, 日期时间型, ,

.局部变量 匿名局部变量_656, 整数型, , ,
.局部变量 匿名局部变量_657, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到时间 (时间)), 匿名局部变量_656)
.如果 (不等于 (匿名局部变量_656, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.子程序 读子程序指针, 子程序指针, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 子程序指针, 可空,

.局部变量 匿名局部变量_661, 整数型, , ,
.局部变量 匿名局部变量_662, 字节集, , ,

读内存 (进程ID, 地址, 8, 匿名局部变量_662, 匿名局部变量_661)
.如果 (不等于 (匿名局部变量_661, 0))
    返回 (选择 (是否为空 (默认值), 默认值, 默认值))
.否则
    返回 (取字节集数据 (匿名局部变量_662, 9, ))
.如果结束


.子程序 写子程序指针, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 指针, 子程序指针, ,

.局部变量 匿名局部变量_666, 整数型, , ,
.局部变量 匿名局部变量_667, 整数型, , ,

写内存 (进程ID, 地址, 8, 到字节集 (到数值 (指针)), 匿名局部变量_666)
.如果 (不等于 (匿名局部变量_666, 0))
    返回 (假)
.否则
    返回 (真)
.如果结束


.类模块 驱动读写, , , 支持32位和64位系统智能切换

.程序集变量 x32v, 匿名类模块_3, , ,
.程序集变量 x64v, 匿名类模块_8, , ,
.程序集变量 Is64, 逻辑型, , ,
.子程序 _初始化, , ,
.判断开始 (匿名子程序_3236 ())
    赋值 (Is64, 真)
.默认
    赋值 (Is64, 假)
.判断结束


.子程序 _销毁, , ,


.子程序 安装, 逻辑型, 公开, 当无签名驱动没有加载时 可以使用此功能加载有签名的驱动
.参数 x32通用驱动文件, 字节集, 可空, 可空 此处添加有签名的驱动文件
.参数 x64通用驱动文件, 字节集, 可空, 可空 此处添加有签名的驱动文件
.参数 驱动名, 文本型, 可空, 新版支持自定义驱动名称啦

.判断开始 (Is64)
    返回 (x64v.安装 (x64通用驱动文件))
.默认
    返回 (x32v.安装 (x32通用驱动文件))
.判断结束


.子程序 切换方式, 逻辑型, , x32位驱动有效 不支持x64位系统
.参数 方式, 逻辑型, 可空, 真 = 使用稳定方式读写 不蓝屏但不一定过游戏检测

.判断开始 (Is64)
    返回 (假)
.默认
    返回 (x32v.切换方式 (方式))
.判断结束


.子程序 是否安装成功, 逻辑型, , 是否安装成功
.判断开始 (Is64)
    返回 (x64v.是否安装成功 ())
.默认
    返回 (x32v.是否安装成功 ())
.判断结束


.子程序 卸载, , , 卸载驱动
.判断开始 (Is64)
    x64v.卸载 ()
.默认
    x32v.卸载 ()
.判断结束


.子程序 取错误, 整数型, ,
.参数 返回错误原因, 文本型, 参考 可空,

.判断开始 (Is64)
    返回 (x64v.取错误 (返回错误原因))
.默认
    返回 (x32v.取错误 (返回错误原因))
.判断结束


.子程序 打开进程, 整数型, , 打开进程
.参数 进程ID, 整数型, ,

.判断开始 (Is64)
    返回 (x64v.打开进程 (进程ID))
.默认
    返回 (x32v.打开进程 (进程ID))
.判断结束


.子程序 关闭进程, 整数型, , 关闭进程
.参数 进程句柄, 整数型, ,

.判断开始 (Is64)
    返回 (x64v.关闭进程 (进程句柄))
.默认
    返回 (x32v.关闭进程 (进程句柄))
.判断结束


.子程序 执行代码, 整数型, , x32位驱动有效 不支持x64位系统
.参数 进程, 整数型, ,
.参数 数据, 字节集, ,
.参数 长度, 整数型, ,

.判断开始 (Is64)
    返回 (0)
.默认
    返回 (x32v.执行代码 (进程, 数据, 长度))
.判断结束


.子程序 读代码, 长整数型, , 支持 读内存整数型 读内存字节集
.参数 进程ID, 整数型, , 进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.判断开始 (Is64)
    返回 (x64v.读代码 (进程ID, 地址表达式, 取回字节集, 取回数据长度))
.默认
    返回 (x32v.读代码 (进程ID, 地址表达式, 取回字节集, 取回数据长度))
.判断结束


.子程序 写代码, 逻辑型, , 支持 写内存整数型 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“0000000013480000+10A0+200=888” 或 “0000000013480000+10A0+200={90,90,90,90}”
.参数 长度, 整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.写代码 (进程ID, 地址表达式, 长度))
.默认
    返回 (x32v.写代码 (进程ID, 地址表达式, 长度))
.判断结束


.子程序 读文本代码, 文本型, , 支持 读内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200”
.参数 取回数据长度, 整数型, 参考 可空,

.判断开始 (Is64)
    返回 (x64v.读文本代码 (进程ID, 地址表达式, 取回数据长度))
.默认
    返回 (x32v.读文本代码 (进程ID, 地址表达式, 取回数据长度))
.判断结束


.子程序 写文本代码, 逻辑型, , 支持 写内存文本型
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200=你好!”
.参数 长度, 整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.写文本代码 (进程ID, 地址表达式, 长度))
.默认
    返回 (x32v.写文本代码 (进程ID, 地址表达式, 长度))
.判断结束


.子程序 读字节集代码, 字节集, , 支持 读内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200”
.参数 取回字节集, 文本型, 参考 可空,
.参数 取回数据长度, 整数型, 参考 可空,

.判断开始 (Is64)
    返回 (x64v.读字节集代码 (进程ID, 地址表达式, 取回字节集, 取回数据长度))
.默认
    返回 (x32v.读字节集代码 (进程ID, 地址表达式, 取回字节集, 取回数据长度))
.判断结束


.子程序 写字节集代码, 逻辑型, , 支持 写内存字节集
.参数 进程ID, 整数型, , 要操作的进程ID
.参数 地址表达式, 文本型, , 比如“401000+10A0+200={90,90,90,90}”
.参数 字节集, 字节集, 可空, 可空 字节集数据
.参数 长度, 整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.写字节集代码 (进程ID, 地址表达式, 字节集, 长度))
.默认
    返回 (x32v.写字节集代码 (进程ID, 地址表达式, 字节集, 长度))
.判断结束


.子程序 申请内存, 整数型, , x32位驱动有效 不支持x64位系统
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,
.参数 类型, 整数型, ,
.参数 属性, 整数型, ,

.判断开始 (Is64)
    返回 (0)
.默认
    返回 (x32v.申请内存 (进程ID, 地址, 长度, 类型, 属性))
.判断结束


.子程序 释放内存, 逻辑型, , x32位驱动有效 不支持x64位系统
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,
.参数 类型, 整数型, ,

.判断开始 (Is64)
    返回 (假)
.默认
    返回 (x32v.释放内存 (进程ID, 地址, 长度, 类型))
.判断结束


.子程序 读字节, 字节型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 字节型, 可空,

.判断开始 (Is64)
    返回 (x64v.读字节 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读字节 (进程ID, 地址, 默认值))
.判断结束


.子程序 写字节, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 字节, 字节型, ,

.判断开始 (Is64)
    返回 (x64v.写字节 (进程ID, 地址, 字节))
.默认
    返回 (x32v.写字节 (进程ID, 地址, 字节))
.判断结束


.子程序 读小数, 小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 小数型, 可空,

.判断开始 (Is64)
    返回 (x64v.读小数 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读小数 (进程ID, 地址, 默认值))
.判断结束


.子程序 写小数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 小数, 小数型, ,

.判断开始 (Is64)
    返回 (x64v.写小数 (进程ID, 地址, 小数))
.默认
    返回 (x32v.写小数 (进程ID, 地址, 小数))
.判断结束


.子程序 读短整数, 短整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 短整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.读短整数 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读短整数 (进程ID, 地址, 默认值))
.判断结束


.子程序 写短整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 短整数, 短整数型, ,

.判断开始 (Is64)
    返回 (x64v.写短整数 (进程ID, 地址, 短整数))
.默认
    返回 (x32v.写短整数 (进程ID, 地址, 短整数))
.判断结束


.子程序 读长整数, 长整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 长整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.读长整数 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读长整数 (进程ID, 地址, 默认值))
.判断结束


.子程序 写长整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长整数, 长整数型, ,

.判断开始 (Is64)
    返回 (x64v.写长整数 (进程ID, 地址, 长整数))
.默认
    返回 (x32v.写长整数 (进程ID, 地址, 长整数))
.判断结束


.子程序 读双精浮点数, 双精度小数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 双精度小数型, 可空,

.判断开始 (Is64)
    返回 (x64v.读双精浮点数 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读双精浮点数 (进程ID, 地址, 默认值))
.判断结束


.子程序 写双精浮点数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 双精度, 双精度小数型, ,

.判断开始 (Is64)
    返回 (x64v.写双精浮点数 (进程ID, 地址, 双精度))
.默认
    返回 (x32v.写双精浮点数 (进程ID, 地址, 双精度))
.判断结束


.子程序 读逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 逻辑型, 可空,

.判断开始 (Is64)
    返回 (x64v.读逻辑 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读逻辑 (进程ID, 地址, 默认值))
.判断结束


.子程序 写逻辑, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 逻辑, 逻辑型, ,

.判断开始 (Is64)
    返回 (x64v.写逻辑 (进程ID, 地址, 逻辑))
.默认
    返回 (x32v.写逻辑 (进程ID, 地址, 逻辑))
.判断结束


.子程序 读整数, 整数型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.读整数 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读整数 (进程ID, 地址, 默认值))
.判断结束


.子程序 写整数, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 整数, 整数型, ,

.判断开始 (Is64)
    返回 (x64v.写整数 (进程ID, 地址, 整数))
.默认
    返回 (x32v.写整数 (进程ID, 地址, 整数))
.判断结束


.子程序 读文本, 文本型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,

.判断开始 (Is64)
    返回 (x64v.读文本 (进程ID, 地址, 长度))
.默认
    返回 (x32v.读文本 (进程ID, 地址, 长度))
.判断结束


.子程序 写文本, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 文本, 文本型, ,

.判断开始 (Is64)
    返回 (x64v.写文本 (进程ID, 地址, 文本))
.默认
    返回 (x32v.写文本 (进程ID, 地址, 文本))
.判断结束


.子程序 读字节集, 字节集, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 长度, 整数型, ,

.判断开始 (Is64)
    返回 (x64v.读字节集 (进程ID, 地址, 长度))
.默认
    返回 (x32v.读字节集 (进程ID, 地址, 长度))
.判断结束


.子程序 写字节集, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 数据, 字节集, ,
.参数 长度, 整数型, 可空,

.判断开始 (Is64)
    返回 (x64v.写字节集 (进程ID, 地址, 数据, 长度))
.默认
    返回 (x32v.写字节集 (进程ID, 地址, 数据, 长度))
.判断结束


.子程序 读日期时间, 日期时间型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 日期时间型, 可空,

.判断开始 (Is64)
    返回 (x64v.读日期时间 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读日期时间 (进程ID, 地址, 默认值))
.判断结束


.子程序 写日期时间, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 时间, 日期时间型, ,

.判断开始 (Is64)
    返回 (x64v.写日期时间 (进程ID, 地址, 时间))
.默认
    返回 (x32v.写日期时间 (进程ID, 地址, 时间))
.判断结束


.子程序 读子程序指针, 子程序指针, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 默认值, 子程序指针, 可空,

.判断开始 (Is64)
    返回 (x64v.读子程序指针 (进程ID, 地址, 默认值))
.默认
    返回 (x32v.读子程序指针 (进程ID, 地址, 默认值))
.判断结束


.子程序 写子程序指针, 逻辑型, ,
.参数 进程ID, 整数型, ,
.参数 地址, 长整数型, ,
.参数 指针, 子程序指针, ,

.判断开始 (Is64)
    返回 (x64v.写子程序指针 (进程ID, 地址, 指针))
.默认
    返回 (x32v.写子程序指针 (进程ID, 地址, 指针))
.判断结束


.程序集 匿名程序集_3263, , ,

.程序集变量 匿名程序集变量_3499, 整数型, , ,
.子程序 匿名子程序_3212, 整数型, ,
返回 (0)

.子程序 匿名子程序_3233, 整数型, ,
.参数 匿名参数_3395, 整数型, ,
.参数 匿名参数_3396, 整数型, 可空,
.参数 匿名参数_3397, 整数型, 可空,
.参数 匿名参数_3398, 整数型, 可空,

.判断开始 (并且 (等于 (匿名参数_3396, 0), 等于 (匿名参数_3397, 0), 等于 (匿名参数_3398, 0)))
    返回 (相加 (左移 (#匿名常量_3267, 16), 左移 (#匿名常量_3269, 14), 左移 (匿名参数_3395, 2), #匿名常量_3268))
.默认
    返回 (相加 (左移 (匿名参数_3396, 16), 左移 (匿名参数_3398, 14), 左移 (匿名参数_3395, 2), 匿名参数_3397))
.判断结束


.子程序 匿名子程序_3214, 整数型, ,
.参数 匿名参数_3299, 文本型, ,
.参数 匿名参数_3300, 文本型, 可空,
.参数 匿名参数_3301, 文本型, 可空,
.参数 匿名参数_3302, 文本型, ,
.参数 匿名参数_3303, 整数型, 可空,

返回 (匿名子程序_3213 (匿名参数_3299, 匿名参数_3300, 匿名参数_3301, 匿名参数_3302, -2, 选择 (等于 (是否为空 (匿名参数_3303), 真), 3, 匿名参数_3303)))

.子程序 匿名子程序_3215, 整数型, ,
.参数 匿名参数_3304, 文本型, ,
.参数 匿名参数_3305, 文本型, 可空,
.参数 匿名参数_3306, 文本型, 可空,
.参数 匿名参数_3307, 文本型, 可空,

返回 (匿名子程序_3213 (匿名参数_3304, 匿名参数_3305, 匿名参数_3306, 匿名参数_3307, -3))

.子程序 匿名子程序_3216, 整数型, ,
.参数 匿名参数_3308, 文本型, ,
.参数 匿名参数_3309, 文本型, 可空,
.参数 匿名参数_3310, 文本型, 可空,
.参数 匿名参数_3311, 文本型, 可空,

返回 (匿名子程序_3213 (匿名参数_3308, 匿名参数_3309, 匿名参数_3310, 匿名参数_3311, -4))

.子程序 匿名子程序_3217, 整数型, ,
.参数 匿名参数_3312, 文本型, ,
.参数 匿名参数_3313, 文本型, 可空,
.参数 匿名参数_3314, 文本型, 可空,
.参数 匿名参数_3315, 文本型, 可空,

返回 (匿名子程序_3213 (匿名参数_3312, 匿名参数_3313, 匿名参数_3314, 匿名参数_3315, -5))

.子程序 匿名子程序_3231, 整数型, ,
.参数 匿名参数_3386, 文本型, 可空,
.参数 匿名参数_3387, 文本型, 可空,
.参数 匿名参数_3388, 文本型, 可空,
.参数 匿名参数_3389, 文本型, 可空,

返回 (匿名子程序_3213 (匿名参数_3386, 匿名参数_3387, 匿名参数_3388, 匿名参数_3389, -6))

.子程序 匿名子程序_3229, 整数型, ,
.参数 匿名参数_3378, 文本型, 可空,
.参数 匿名参数_3379, 文本型, 可空,
.参数 匿名参数_3380, 文本型, 可空,
.参数 匿名参数_3381, 文本型, 可空,

返回 (匿名子程序_3213 (匿名参数_3378, 匿名参数_3379, 匿名参数_3380, 匿名参数_3381, -7))

.子程序 匿名子程序_3232, 整数型, ,
.参数 匿名参数_3390, 文本型, 可空,
.参数 匿名参数_3391, 文本型, 可空,
.参数 匿名参数_3392, 文本型, 可空,
.参数 匿名参数_3393, 文本型, 可空,
.参数 匿名参数_3394, 整数型, ,

返回 (匿名子程序_3213 (匿名参数_3390, 匿名参数_3391, 匿名参数_3392, 匿名参数_3393, 匿名参数_3394))

.子程序 匿名子程序_3218, 整数型, ,
.参数 匿名参数_3316, 整数型, ,
.参数 匿名参数_3317, 整数型, ,
.参数 匿名参数_3318, 整数型, ,
.参数 匿名参数_3319, 整数型, ,
.参数 匿名参数_3320, 整数型, 参考,
.参数 匿名参数_3321, 整数型, ,
.参数 匿名参数_3322, 整数型, 参考,

.局部变量 匿名局部变量_3323, 匿名数据类型_3211, , ,
.局部变量 匿名局部变量_3324, 整数型, , ,

.如果真 (或者 (等于 (匿名参数_3316, -1), 等于 (匿名参数_3316, 0)))
    赋值 (匿名参数_3316, 匿名程序集变量_3499)
.如果真结束
赋值 (匿名局部变量_3324, 匿名子程序_3228 (匿名参数_3316, 匿名参数_3317, 匿名参数_3318, 匿名参数_3319, 匿名子程序_3248 (匿名参数_3320), 匿名参数_3321, 匿名子程序_3248 (匿名参数_3322), 匿名局部变量_3323))
.如果 (等于 (匿名局部变量_3324, 0))
    返回 (-1)
.否则
    返回 (匿名局部变量_3324)
.如果结束


.子程序 匿名子程序_3234, 整数型, ,
.参数 匿名参数_3399, 整数型, ,
.参数 匿名参数_3400, 整数型, ,
.参数 匿名参数_3401, 整数型, ,
.参数 匿名参数_3402, 整数型, ,
.参数 匿名参数_3403, 整数型, ,
.参数 匿名参数_3404, 整数型, ,
.参数 匿名参数_3405, 整数型, ,

.局部变量 匿名局部变量_3406, 匿名数据类型_3211, , ,
.局部变量 匿名局部变量_3407, 整数型, , ,

.如果真 (或者 (等于 (匿名参数_3399, -1), 等于 (匿名参数_3399, 0)))
    赋值 (匿名参数_3399, 匿名程序集变量_3499)
.如果真结束
赋值 (匿名局部变量_3407, 匿名子程序_3228 (匿名参数_3399, 匿名参数_3400, 匿名参数_3401, 匿名参数_3402, 匿名参数_3403, 匿名参数_3404, 匿名参数_3405, 匿名局部变量_3406))
.如果 (等于 (匿名局部变量_3407, 0))
    返回 (-1)
.否则
    返回 (匿名局部变量_3407)
.如果结束


.子程序 匿名子程序_3236, 逻辑型, ,
.局部变量 匿名局部变量_3409, 文本型, , ,
.局部变量 匿名局部变量_3410, 整数型, , ,
.局部变量 匿名局部变量_3411, 整数型, , "2",

赋值 (匿名局部变量_3409, 取空白文本 (255))
赋值 (匿名局部变量_3411 [1], 匿名子程序_3247 (匿名局部变量_3409))
赋值 (匿名局部变量_3411 [2], 255)
赋值 (匿名局部变量_3410, 匿名子程序_3238 (到文本 ({ 71, 101, 116, 83, 121, 115, 116, 101, 109, 87, 111, 119, 54, 52, 68, 105, 114, 101, 99, 116, 111, 114, 121, 65 }), 匿名局部变量_3411))
返回 (大于 (匿名局部变量_3410, 0))

.子程序 匿名子程序_3213, 整数型, ,
.参数 匿名参数_3287, 文本型, ,
.参数 匿名参数_3288, 文本型, ,
.参数 匿名参数_3289, 文本型, ,
.参数 匿名参数_3290, 文本型, ,
.参数 匿名参数_3291, 整数型, ,
.参数 匿名参数_3292, 整数型, 可空,

.局部变量 匿名局部变量_3293, 整数型, , ,
.局部变量 匿名局部变量_3294, 整数型, , ,
.局部变量 匿名局部变量_3295, 匿名数据类型_3210, , ,
.局部变量 匿名局部变量_3296, 文本型, , ,
.局部变量 匿名局部变量_3297, 小数型, , ,
.局部变量 匿名局部变量_3298, 整数型, , ,

赋值 (匿名局部变量_3297, 倒找文本 (匿名参数_3290, 到文本 ({ 92 }), , 假))
赋值 (匿名局部变量_3296, 取文本中间 (匿名参数_3290, 相加 (匿名局部变量_3297, 1), 相减 (取文本长度 (匿名参数_3290), 匿名局部变量_3297, 4)))
赋值 (匿名局部变量_3293, 匿名子程序_3220 (0, 0, 2))
.如果真 (等于 (匿名局部变量_3293, 0))
    返回 (匿名局部变量_3298)
.如果真结束

.如果真 (等于 (匿名参数_3291, -2))
    .如果真 (等于 (匿名参数_3292, 0))
        赋值 (匿名参数_3292, 3)
    .如果真结束
    赋值 (匿名局部变量_3294, 匿名子程序_3226 (匿名局部变量_3293, 匿名参数_3287, 匿名参数_3288, 16, 1, 匿名参数_3292, 0, 匿名参数_3290, 0, 0, 0, 0, 0))
    .如果真 (不等于 (匿名局部变量_3294, 0))
        赋值 (匿名局部变量_3298, 匿名局部变量_3294)
        匿名子程序_3221 (匿名局部变量_3294)
    .如果真结束
   
.如果真结束

.如果真 (等于 (匿名参数_3291, -3))
    赋值 (匿名局部变量_3294, 匿名子程序_3224 (匿名局部变量_3293, 匿名参数_3287, 16))
    .如果真 (不等于 (匿名局部变量_3294, 0))
        赋值 (匿名局部变量_3298, 匿名子程序_3223 (匿名局部变量_3294, 0, 0))
        匿名子程序_3221 (匿名局部变量_3294)
    .如果真结束
   
.如果真结束

.如果真 (等于 (匿名参数_3291, -4))
    赋值 (匿名局部变量_3294, 匿名子程序_3224 (匿名局部变量_3293, 匿名参数_3287, 65568))
    .如果真 (不等于 (匿名局部变量_3294, 0))
        赋值 (匿名局部变量_3298, 匿名子程序_3227 (匿名局部变量_3294, 1, 匿名局部变量_3295))
        匿名子程序_3221 (匿名局部变量_3294)
    .如果真结束
   
.如果真结束

.如果真 (等于 (匿名参数_3291, -5))
    赋值 (匿名局部变量_3294, 匿名子程序_3224 (匿名局部变量_3293, 匿名参数_3287, 65568))
    .如果真 (不等于 (匿名局部变量_3294, 0))
        匿名子程序_3227 (匿名局部变量_3294, 1, 匿名局部变量_3295)
        赋值 (匿名局部变量_3298, 匿名子程序_3222 (匿名局部变量_3294))
        匿名子程序_3221 (匿名局部变量_3294)
    .如果真结束
   
.如果真结束

.如果真 (等于 (匿名参数_3291, -6))
    赋值 (匿名局部变量_3298, 匿名子程序_3225 (相加 (到文本 ({ 92, 92, 46, 92 }), 匿名参数_3289), 3221225472, 0, 0, 3, 0, 0))
    返回 (匿名局部变量_3298)
.如果真结束

.如果真 (等于 (匿名参数_3291, -7))
    赋值 (匿名局部变量_3298, 匿名子程序_3230 (相加 (到文本 ({ 92, 92, 46, 92 }), 匿名参数_3289), 3))
    返回 (匿名局部变量_3298)
.如果真结束

.如果真 (大于 (匿名参数_3291, 0))
    赋值 (匿名局部变量_3298, 匿名子程序_3219 (匿名参数_3291))
    返回 (匿名局部变量_3298)
.如果真结束

匿名子程序_3221 (匿名局部变量_3293)
返回 (匿名局部变量_3298)

.子程序 匿名子程序_3220, 整数型, ,
.参数 匿名参数_3327, 整数型, ,
.参数 匿名参数_3328, 整数型, ,
.参数 匿名参数_3329, 整数型, ,

.局部变量 匿名局部变量_3330, 整数型, , "3",

赋值 (匿名局部变量_3330 [1], 匿名参数_3327)
赋值 (匿名局部变量_3330 [2], 匿名参数_3328)
赋值 (匿名局部变量_3330 [3], 匿名参数_3329)
返回 (匿名子程序_3238 (到文本 ({ 79, 112, 101, 110, 83, 67, 77, 97, 110, 97, 103, 101, 114, 65 }), 匿名局部变量_3330, ))

.子程序 匿名子程序_3224, 整数型, ,
.参数 匿名参数_3339, 整数型, ,
.参数 匿名参数_3340, 文本型, ,
.参数 匿名参数_3341, 整数型, ,

.局部变量 匿名局部变量_3342, 整数型, , "3",

赋值 (匿名局部变量_3342 [1], 匿名参数_3339)
赋值 (匿名局部变量_3342 [2], 匿名子程序_3247 (匿名参数_3340))
赋值 (匿名局部变量_3342 [3], 匿名参数_3341)
返回 (匿名子程序_3238 (到文本 ({ 79, 112, 101, 110, 83, 101, 114, 118, 105, 99, 101, 65 }), 匿名局部变量_3342, ))

.子程序 匿名子程序_3223, 整数型, ,
.参数 匿名参数_3335, 整数型, ,
.参数 匿名参数_3336, 整数型, ,
.参数 匿名参数_3337, 整数型, ,

.局部变量 匿名局部变量_3338, 整数型, , "3",

赋值 (匿名局部变量_3338 [1], 匿名参数_3335)
赋值 (匿名局部变量_3338 [2], 匿名参数_3336)
赋值 (匿名局部变量_3338 [3], 匿名参数_3337)
返回 (匿名子程序_3238 (到文本 ({ 83, 116, 97, 114, 116, 83, 101, 114, 118, 105, 99, 101, 65 }), 匿名局部变量_3338, ))

.子程序 匿名子程序_3227, 整数型, ,
.参数 匿名参数_3365, 整数型, ,
.参数 匿名参数_3366, 整数型, ,
.参数 匿名参数_3367, 匿名数据类型_3210, ,

.局部变量 匿名局部变量_3368, 整数型, , "3",

赋值 (匿名局部变量_3368 [1], 匿名参数_3365)
赋值 (匿名局部变量_3368 [2], 匿名参数_3366)
赋值 (匿名局部变量_3368 [3], lstrcpyn_3265 (匿名参数_3367, 匿名参数_3367, 0))
返回 (匿名子程序_3238 (到文本 ({ 67, 111, 110, 116, 114, 111, 108, 83, 101, 114, 118, 105, 99, 101 }), 匿名局部变量_3368, ))

.子程序 匿名子程序_3228, 整数型, ,
.参数 匿名参数_3369, 整数型, ,
.参数 匿名参数_3370, 整数型, ,
.参数 匿名参数_3371, 整数型, ,
.参数 匿名参数_3372, 整数型, ,
.参数 匿名参数_3373, 整数型, ,
.参数 匿名参数_3374, 整数型, ,
.参数 匿名参数_3375, 整数型, ,
.参数 匿名参数_3376, 匿名数据类型_3211, ,

.局部变量 匿名局部变量_3377, 整数型, , "8",

赋值 (匿名局部变量_3377 [1], 匿名参数_3369)
赋值 (匿名局部变量_3377 [2], 匿名参数_3370)
赋值 (匿名局部变量_3377 [3], 匿名参数_3371)
赋值 (匿名局部变量_3377 [4], 匿名参数_3372)
赋值 (匿名局部变量_3377 [5], 匿名参数_3373)
赋值 (匿名局部变量_3377 [6], 匿名参数_3374)
赋值 (匿名局部变量_3377 [7], 匿名参数_3375)
赋值 (匿名局部变量_3377 [8], lstrcpyn_3266 (匿名参数_3376, 匿名参数_3376, 0))
返回 (匿名子程序_3238 (到文本 ({ 68, 101, 118, 105, 99, 101, 73, 111, 67, 111, 110, 116, 114, 111, 108 }), 匿名局部变量_3377, ))

.子程序 匿名子程序_3222, 整数型, ,
.参数 匿名参数_3333, 整数型, ,

.局部变量 匿名局部变量_3334, 整数型, , "1",

赋值 (匿名局部变量_3334 [1], 匿名参数_3333)
返回 (匿名子程序_3238 (到文本 ({ 68, 101, 108, 101, 116, 101, 83, 101, 114, 118, 105, 99, 101 }), 匿名局部变量_3334, ))

.子程序 匿名子程序_3225, 整数型, ,
.参数 匿名参数_3343, 文本型, ,
.参数 匿名参数_3344, 整数型, ,
.参数 匿名参数_3345, 整数型, ,
.参数 匿名参数_3346, 整数型, ,
.参数 匿名参数_3347, 整数型, ,
.参数 匿名参数_3348, 整数型, ,
.参数 匿名参数_3349, 整数型, ,

.局部变量 匿名局部变量_3350, 整数型, , "7",

赋值 (匿名局部变量_3350 [1], 匿名子程序_3247 (匿名参数_3343))
赋值 (匿名局部变量_3350 [2], 匿名参数_3344)
赋值 (匿名局部变量_3350 [3], 匿名参数_3345)
赋值 (匿名局部变量_3350 [4], 匿名参数_3346)
赋值 (匿名局部变量_3350 [5], 匿名参数_3347)
赋值 (匿名局部变量_3350 [6], 匿名参数_3348)
赋值 (匿名局部变量_3350 [7], 匿名参数_3349)
返回 (匿名子程序_3238 (到文本 ({ 67, 114, 101, 97, 116, 101, 70, 105, 108, 101, 65 }), 匿名局部变量_3350, ))

.子程序 匿名子程序_3230, 整数型, ,
.参数 匿名参数_3382, 文本型, ,
.参数 匿名参数_3383, 整数型, ,

.局部变量 匿名局部变量_3384, 文本型, , ,
.局部变量 匿名局部变量_3385, 整数型, , "3",

赋值 (匿名局部变量_3384, 取空白文本 (142))
赋值 (匿名局部变量_3385 [1], 匿名子程序_3250 (匿名参数_3382))
赋值 (匿名局部变量_3385 [2], 匿名子程序_3235 (匿名局部变量_3384))
赋值 (匿名局部变量_3385 [3], 匿名参数_3383)
返回 (匿名子程序_3238 (到文本 ({ 79, 112, 101, 110, 70, 105, 108, 101 }), 匿名局部变量_3385))

.子程序 匿名子程序_3226, 整数型, ,
.参数 匿名参数_3351, 整数型, ,
.参数 匿名参数_3352, 文本型, ,
.参数 匿名参数_3353, 文本型, ,
.参数 匿名参数_3354, 整数型, ,
.参数 匿名参数_3355, 整数型, ,
.参数 匿名参数_3356, 整数型, ,
.参数 匿名参数_3357, 整数型, ,
.参数 匿名参数_3358, 文本型, ,
.参数 匿名参数_3359, 整数型, ,
.参数 匿名参数_3360, 整数型, ,
.参数 匿名参数_3361, 整数型, ,
.参数 匿名参数_3362, 整数型, ,
.参数 匿名参数_3363, 整数型, ,

.局部变量 匿名局部变量_3364, 整数型, , "13",

赋值 (匿名局部变量_3364 [1], 匿名参数_3351)
赋值 (匿名局部变量_3364 [2], 匿名子程序_3247 (匿名参数_3352))
赋值 (匿名局部变量_3364 [3], 匿名子程序_3247 (匿名参数_3353))
赋值 (匿名局部变量_3364 [4], 匿名参数_3354)
赋值 (匿名局部变量_3364 [5], 匿名参数_3355)
赋值 (匿名局部变量_3364 [6], 匿名参数_3356)
赋值 (匿名局部变量_3364 [7], 匿名参数_3357)
赋值 (匿名局部变量_3364 [8], 匿名子程序_3247 (匿名参数_3358))
赋值 (匿名局部变量_3364 [9], 匿名参数_3359)
赋值 (匿名局部变量_3364 [10], 匿名参数_3360)
赋值 (匿名局部变量_3364 [11], 匿名参数_3361)
赋值 (匿名局部变量_3364 [12], 匿名参数_3362)
赋值 (匿名局部变量_3364 [13], 匿名参数_3363)
返回 (匿名子程序_3238 (到文本 ({ 67, 114, 101, 97, 116, 101, 83, 101, 114, 118, 105, 99, 101, 65 }), 匿名局部变量_3364, ))

.子程序 匿名子程序_3221, 整数型, ,
.参数 匿名参数_3331, 整数型, ,

.局部变量 匿名局部变量_3332, 整数型, , "1",

赋值 (匿名局部变量_3332 [1], 匿名参数_3331)
返回 (匿名子程序_3238 (到文本 ({ 67, 108, 111, 115, 101, 83, 101, 114, 118, 105, 99, 101, 72, 97, 110, 100, 108, 101 }), 匿名局部变量_3332, ))

.子程序 匿名子程序_3219, 整数型, ,
.参数 匿名参数_3325, 整数型, ,

.局部变量 匿名局部变量_3326, 整数型, , "1",

赋值 (匿名局部变量_3326 [1], 匿名参数_3325)
返回 (匿名子程序_3238 (到文本 ({ 67, 108, 111, 115, 101, 72, 97, 110, 100, 108, 101 }), 匿名局部变量_3326, ))

.子程序 匿名子程序_3235, 整数型, ,
.参数 匿名参数_3408, 文本型, ,

置入代码 (#匿名图片_3271)
返回 (0)

.程序集 匿名程序集_3264, , ,

.子程序 匿名子程序_3237, 整数型, ,



返回 (0)

.子程序 匿名子程序_3238, 整数型, ,
.参数 匿名参数_3412, 文本型, ,
.参数 匿名参数_3413, 整数型, 参考 可空 数组,
.参数 匿名参数_3414, 文本型, 可空,
.参数 匿名参数_3415, 整数型, 可空,

.局部变量 匿名局部变量_3416, 文本型, , "0",
.局部变量 匿名局部变量_3417, 整数型, , ,
.局部变量 匿名局部变量_3418, 整数型, , ,
.局部变量 匿名局部变量_3419, 整数型, , ,
.局部变量 匿名局部变量_3420, 整数型, , ,

赋值 (匿名局部变量_3416, { “KERNEL32.DLL”, “GDI32.DLL”, “USER32.DLL”, “SHELL32.DLL”, “ADVAPI32.DLL”, “MPR.DLL”, “WINMM.DLL” })
.如果 (不等于 (匿名参数_3414, “”))
    赋值 (匿名局部变量_3417, 匿名子程序_3242 (匿名参数_3414))
    .如果真 (等于 (匿名局部变量_3417, 0))
        赋值 (匿名局部变量_3417, 匿名子程序_3242 (相加 (取运行目录 (), “\”, 匿名参数_3414)))
    .如果真结束
   
    .如果 (等于 (取文本左边 (匿名参数_3412, 1), “ ”))
        赋值 (匿名局部变量_3418, 匿名子程序_3255 (匿名局部变量_3417, 到数值 (取文本右边 (匿名参数_3412, 相减 (取文本长度 (匿名参数_3412), 1)))))
    .否则
        赋值 (匿名局部变量_3418, 匿名子程序_3243 (匿名局部变量_3417, 匿名参数_3412))
    .如果结束
   
.否则
    .计次循环首 (取数组成员数 (匿名局部变量_3416), 匿名局部变量_3420)
        赋值 (匿名局部变量_3418, 匿名子程序_3243 (匿名子程序_3244 (匿名局部变量_3416 [匿名局部变量_3420]), 匿名参数_3412))
        .如果真 (不等于 (匿名局部变量_3418, 0))
            跳出循环 ()
        .如果真结束
        
    .计次循环尾 ()
.如果结束
.如果真 (等于 (匿名参数_3415, -1))
    返回 (匿名局部变量_3418)
.如果真结束
赋值 (匿名局部变量_3419, 匿名子程序_3239 (匿名局部变量_3418, 匿名参数_3413))
.如果真 (不等于 (匿名参数_3414, “”))
    .如果真 (等于 (匿名参数_3415, 1))
        匿名子程序_3253 (匿名局部变量_3417)
    .如果真结束
   
.如果真结束
返回 (匿名局部变量_3419)

.子程序 匿名子程序_3241, 整数型, ,
.参数 匿名参数_3458, 整数型, ,
.参数 匿名参数_3459, 整数型, 参考 可空 数组,

返回 (匿名子程序_3239 (匿名参数_3458, 匿名参数_3459))

.子程序 匿名子程序_3248, 整数型, ,
.参数 匿名参数_3473, 整数型, 参考,

置入代码 (#匿名图片_3270)
返回 (0)

.子程序 匿名子程序_3247, 整数型, ,
.参数 匿名参数_3472, 文本型, 参考,

置入代码 (#匿名图片_3271)
返回 (0)

.子程序 匿名子程序_3249, 整数型, ,
.参数 匿名参数_3474, 字节集, 参考,

置入代码 (#匿名图片_3272)
返回 (0)

.子程序 匿名子程序_3256, 整数型, ,
.参数 匿名参数_3486, 子程序指针, 参考,

置入代码 (#匿名图片_3272)
返回 (0)

.子程序 匿名子程序_3252, 整数型, ,
.参数 匿名参数_3477, 整数型, ,

置入代码 (#匿名图片_3270)
返回 (0)

.子程序 匿名子程序_3250, 整数型, ,
.参数 匿名参数_3475, 文本型, ,

置入代码 (#匿名图片_3271)
返回 (0)

.子程序 匿名子程序_3251, 整数型, ,
.参数 匿名参数_3476, 字节集, ,

置入代码 (#匿名图片_3272)
返回 (0)

.子程序 匿名子程序_3257, 整数型, ,
.参数 匿名参数_3487, 子程序指针, ,

置入代码 (#匿名图片_3270)
返回 (0)

.子程序 匿名子程序_3258, 整数型, ,
.参数 匿名参数_3488, 整数型, ,
.参数 匿名参数_3489, 整数型, 参考,

置入代码 (#匿名图片_3273)
返回 (0)

.子程序 匿名子程序_3259, 整数型, ,
.参数 匿名参数_3490, 整数型, ,
.参数 匿名参数_3491, 文本型, 参考,

置入代码 (#匿名图片_3273)
返回 (0)

.子程序 匿名子程序_3260, 整数型, ,
.参数 匿名参数_3492, 整数型, ,
.参数 匿名参数_3493, 字节集, 参考,

置入代码 (#匿名图片_3273)
返回 (0)

.子程序 匿名子程序_3261, , ,
.参数 匿名参数_3494, 整数型, 参考,
.参数 匿名参数_3495, 整数型, ,

置入代码 (#匿名图片_3273)

.子程序 匿名子程序_3262, , ,
.参数 匿名参数_3496, 整数型, ,
.参数 匿名参数_3497, 整数型, ,
.参数 匿名参数_3498, 整数型, ,

置入代码 (#匿名图片_3274)

.子程序 匿名子程序_3242, 整数型, ,
.参数 匿名参数_3460, 文本型, ,

.局部变量 匿名局部变量_3461, 文本型, , ,
.局部变量 匿名局部变量_3462, 整数型, , ,

赋值 (匿名局部变量_3461, 匿名子程序_3254 ({ 76, 111, 97, 100, 76, 105, 98, 114, 97, 114, 121, 65 }))
匿名子程序_3240 (匿名子程序_3246 (匿名子程序_3245 (), 匿名子程序_3247 (匿名局部变量_3461)), 假, 匿名局部变量_3462, 匿名子程序_3247 (匿名参数_3460))
返回 (匿名局部变量_3462)

.子程序 匿名子程序_3253, 整数型, ,
.参数 匿名参数_3478, 整数型, ,

.局部变量 匿名局部变量_3479, 文本型, , ,
.局部变量 匿名局部变量_3480, 整数型, , "1",

赋值 (匿名局部变量_3479, 匿名子程序_3254 ({ 70, 114, 101, 101, 76, 105, 98, 114, 97, 114, 121 }))
赋值 (匿名局部变量_3480 [1], 匿名参数_3478)
返回 (匿名子程序_3238 (匿名局部变量_3479, 匿名局部变量_3480))

.子程序 匿名子程序_3255, 整数型, ,
.参数 匿名参数_3482, 整数型, ,
.参数 匿名参数_3483, 整数型, ,

.局部变量 匿名局部变量_3484, 文本型, , ,
.局部变量 匿名局部变量_3485, 整数型, , ,

赋值 (匿名局部变量_3484, 匿名子程序_3254 ({ 71, 101, 116, 80, 114, 111, 99, 65, 100, 100, 114, 101, 115, 115 }))
匿名子程序_3240 (匿名子程序_3246 (匿名子程序_3245 (), 匿名子程序_3247 (匿名局部变量_3484)), 假, 匿名局部变量_3485, 匿名参数_3482, 到数值 (匿名参数_3483))
返回 (匿名局部变量_3485)

.子程序 匿名子程序_3243, 整数型, ,
.参数 匿名参数_3463, 整数型, ,
.参数 匿名参数_3464, 文本型, ,

.局部变量 匿名局部变量_3465, 文本型, , ,
.局部变量 匿名局部变量_3466, 整数型, , ,

赋值 (匿名局部变量_3465, 匿名子程序_3254 ({ 71, 101, 116, 80, 114, 111, 99, 65, 100, 100, 114, 101, 115, 115 }))
匿名子程序_3240 (匿名子程序_3246 (匿名子程序_3245 (), 匿名子程序_3247 (匿名局部变量_3465)), 假, 匿名局部变量_3466, 匿名参数_3463, 匿名子程序_3247 (匿名参数_3464))
返回 (匿名局部变量_3466)

.子程序 匿名子程序_3245, 整数型, ,
置入代码 ({ 235, 20, 84, 104, 101, 67, 111, 100, 101, 77, 97, 100, 101, 66, 121, 90, 80, 67, 67, 90, 81, 0, 144, 252, 49, 210, 100, 139, 82, 48, 139, 82, 12, 139, 82, 20, 139, 114, 40, 106, 24, 89, 49, 255, 49, 192, 172, 60, 97, 124, 2, 44, 32, 193, 207, 13, 1, 199, 226, 240, 129, 255, 91, 188, 74, 106, 139, 90, 16, 139, 18, 117, 219, 139, 195, 201, 195 })
返回 (-1)

.子程序 匿名子程序_3246, 整数型, ,
.参数 匿名参数_3470, 整数型, ,
.参数 匿名参数_3471, 整数型, ,

置入代码 ({ 129, 196, 4, 0, 0, 0, 139, 229, 93 })
置入代码 ({ 235, 20, 84, 104, 101, 67, 111, 100, 101, 77, 97, 100, 101, 66, 121, 90, 80, 67, 67, 90, 81, 0, 144, 90, 88, 89, 82, 96, 137, 195, 137, 207, 48, 192, 174, 117, 253, 79, 41, 207, 135, 249, 139, 67, 60, 139, 116, 3, 120, 141, 116, 30, 24, 173, 146, 173, 80, 173, 149, 173, 149, 1, 216, 137, 124, 36, 24, 137, 76, 36, 20, 74, 116, 39, 139, 52, 144, 1, 222, 243, 166, 116, 10, 139, 124, 36, 24, 139, 76, 36, 20, 235, 234, 209, 226, 1, 213, 15, 183, 68, 29, 0, 193, 224, 2, 3, 4, 36, 139, 4, 3, 1, 216, 89, 137, 68, 36, 28, 97, 195 })
返回 (-1)

.子程序 匿名子程序_3244, 整数型, ,
.参数 匿名参数_3467, 文本型, ,

.局部变量 匿名局部变量_3468, 文本型, , ,
.局部变量 匿名局部变量_3469, 整数型, , ,

赋值 (匿名局部变量_3468, 匿名子程序_3254 ({ 71, 101, 116, 77, 111, 100, 117, 108, 101, 72, 97, 110, 100, 108, 101, 65 }))
匿名子程序_3240 (匿名子程序_3246 (匿名子程序_3245 (), 匿名子程序_3247 (匿名局部变量_3468)), 假, 匿名局部变量_3469, 匿名子程序_3247 (匿名参数_3467))
返回 (匿名局部变量_3469)

.子程序 匿名子程序_3239, 整数型, ,
.参数 匿名参数_3421, 整数型, ,
.参数 匿名参数_3422, 整数型, 参考 可空 数组,

.局部变量 匿名局部变量_3423, 整数型, , ,
.局部变量 匿名局部变量_3424, 整数型, , ,
.局部变量 匿名局部变量_3425, 整数型, , ,
.局部变量 匿名局部变量_3426, 整数型, , ,
.局部变量 匿名局部变量_3427, 整数型, , ,
.局部变量 匿名局部变量_3428, 整数型, , ,
.局部变量 匿名局部变量_3429, 整数型, , ,
.局部变量 匿名局部变量_3430, 整数型, , ,
.局部变量 匿名局部变量_3431, 整数型, , ,
.局部变量 匿名局部变量_3432, 整数型, , ,
.局部变量 匿名局部变量_3433, 整数型, , ,
.局部变量 匿名局部变量_3434, 整数型, , ,
.局部变量 匿名局部变量_3435, 整数型, , ,
.局部变量 匿名局部变量_3436, 整数型, , ,
.局部变量 匿名局部变量_3437, 整数型, , ,
.局部变量 匿名局部变量_3438, 整数型, , ,
.局部变量 匿名局部变量_3439, 整数型, , ,

赋值 (匿名局部变量_3424, 取数组成员数 (匿名参数_3422))
.如果真 (等于 (匿名参数_3421, 0))
    返回 (-1)
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 1))
    赋值 (匿名局部变量_3425, 匿名参数_3422 [1])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 2))
    赋值 (匿名局部变量_3426, 匿名参数_3422 [2])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 3))
    赋值 (匿名局部变量_3427, 匿名参数_3422 [3])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 4))
    赋值 (匿名局部变量_3428, 匿名参数_3422 [4])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 5))
    赋值 (匿名局部变量_3429, 匿名参数_3422 [5])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 6))
    赋值 (匿名局部变量_3430, 匿名参数_3422 [6])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 7))
    赋值 (匿名局部变量_3431, 匿名参数_3422 [7])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 8))
    赋值 (匿名局部变量_3432, 匿名参数_3422 [8])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 9))
    赋值 (匿名局部变量_3433, 匿名参数_3422 [9])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 10))
    赋值 (匿名局部变量_3434, 匿名参数_3422 [10])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 11))
    赋值 (匿名局部变量_3435, 匿名参数_3422 [11])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 12))
    赋值 (匿名局部变量_3436, 匿名参数_3422 [12])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 13))
    赋值 (匿名局部变量_3437, 匿名参数_3422 [13])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 14))
    赋值 (匿名局部变量_3438, 匿名参数_3422 [14])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 15))
    赋值 (匿名局部变量_3439, 匿名参数_3422 [15])
.如果真结束
.如果真 (大于或等于 (匿名局部变量_3424, 16))
    返回 (-1)
.如果真结束
匿名子程序_3240 (匿名参数_3421, 假, 匿名局部变量_3423, 匿名局部变量_3425, 匿名局部变量_3426, 匿名局部变量_3427, 匿名局部变量_3428, 匿名局部变量_3429, 匿名局部变量_3430, 匿名局部变量_3431, 匿名局部变量_3432, 匿名局部变量_3433, 匿名局部变量_3434, 匿名局部变量_3435, 匿名局部变量_3436, 匿名局部变量_3437, 匿名局部变量_3438, 匿名局部变量_3439)
返回 (匿名局部变量_3423)

.子程序 匿名子程序_3240, 逻辑型, ,
.参数 匿名参数_3440, 整数型, ,
.参数 匿名参数_3441, 逻辑型, 可空,
.参数 匿名参数_3442, 整数型, 参考 可空,
.参数 匿名参数_3443, 整数型, 参考 可空,
.参数 匿名参数_3444, 整数型, 参考 可空,
.参数 匿名参数_3445, 整数型, 参考 可空,
.参数 匿名参数_3446, 整数型, 参考 可空,
.参数 匿名参数_3447, 整数型, 参考 可空,
.参数 匿名参数_3448, 整数型, 参考 可空,
.参数 匿名参数_3449, 整数型, 参考 可空,
.参数 匿名参数_3450, 整数型, 参考 可空,
.参数 匿名参数_3451, 整数型, 参考 可空,
.参数 匿名参数_3452, 整数型, 参考 可空,
.参数 匿名参数_3453, 整数型, 参考 可空,
.参数 匿名参数_3454, 整数型, 参考 可空,
.参数 匿名参数_3455, 整数型, 参考 可空,
.参数 匿名参数_3456, 整数型, 参考 可空,
.参数 匿名参数_3457, 整数型, 参考 可空,

置入代码 ({ 86, 81, 185, 15, 0, 0, 0, 139, 245, 129, 198, 152, 0, 0, 0, 131, 238, 8, 139, 198, 139, 0, 131, 248, 0, 116, 18, 139, 70, 252, 139, 0, 80, 255, 69, 252, 255, 69, 252, 255, 69, 252, 255, 69, 252, 226, 224, 255, 85, 8, 139, 77, 20, 137, 1, 131, 125, 12, 0, 116, 3, 3, 101, 252, 89, 94 })
返回 (真)

.子程序 匿名子程序_3254, 文本型, ,
.参数 匿名参数_3481, 字节集, ,

返回 (到文本 (匿名参数_3481))


' 不属于任何一个程序集、类模块的函数：

年少亦多情丶

好人平安

f378694339

好东西 别沉了

wanmei

感谢楼主分享！！支持

JKD

真的没封过吗！！

@天打五雷轰

我好像已经习惯了。

dongfang155

早已习惯现在的视距

mmxy

楼主威武！感谢分享。

在现飞

为了玩 不得不习惯