.版本 2 .程序集 窗口程序集_启动窗口 .子程序 __启动窗口_创建完毕 .子程序 取长整数型指针_asm, 整数型, 公开 .参数 长整数变量, 长整数型, 参考 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 取长整数型数组指针_asm, 整数型, 公开 .参数 长整数型数组变量, 长整数型, 参考 数组 置入代码 ({ 139, 69, 8, 139, 0, 139, 8, 107, 201, 4, 131, 193, 4, 3, 193, 201, 194, 4, 0 }) 返回 (0) .子程序 取小数型指针_asm, 整数型, 公开 .参数 小数型变量, 小数型, 参考 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 取小数型数组指针_asm, 整数型, 公开 .参数 小数型数组变量, 小数型, 参考 数组 置入代码 ({ 139, 69, 8, 139, 0, 80, 139, 0, 107, 192, 4, 131, 192, 4, 1, 4, 36, 88, 201, 194, 4, 0 }) 返回 (0) .子程序 取双精度小数型指针_asm, 整数型, 公开 .参数 双精度小数型变量, 双精度小数型, 参考 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 取双精度小数型数组指针_asm, 整数型, 公开 .参数 双精度小数型数组变量, 双精度小数型, 参考 数组 置入代码 ({ 139, 69, 8, 139, 0, 80, 139, 0, 107, 192, 4, 131, 192, 4, 1, 4, 36, 88, 201, 194, 4, 0 }) 返回 (0) .子程序 取文本型指针_asm, 整数型, 公开 .参数 文本型变量, 文本型 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 }) 返回 (0) .子程序 取字节集指针_asm, 整数型, 公开 .参数 字节集变量, 字节集, 参考 置入代码 ({ 139, 69, 8, 139, 0, 131, 248, 0, 116, 3, 131, 192, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 取变体型指针_asm, 整数型, 公开, 返回此变体类型所在的内存指针 数据类型/0/数值或指针/ 4字节/4字节/8字节[4字节/4字节] .参数 变体型变量, 变体型, 参考 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 }) 返回 (0) .子程序 取日期时间型指针_asm, 整数型, 公开 .参数 日期时间型变量, 日期时间型, 参考 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 取日期时间型数组指针_asm, 整数型, 公开, 返回此数组所在的内存指针 .参数 日期时间型数组变量, 日期时间型, 参考 数组 置入代码 ({ 139, 69, 8, 139, 0, 80, 139, 0, 107, 192, 4, 131, 192, 4, 1, 4, 36, 88, 201, 194, 4, 0 }) 返回 (0) .子程序 取子程序数组指针_asm, 整数型, 公开 .参数 匿名局部变量_子程序指针_64539, 子程序指针, 参考 数组 置入代码 ({ 139, 69, 8, 139, 0, 80, 139, 0, 107, 192, 4, 131, 192, 4, 1, 4, 36, 88, 201, 194, 4, 0 }) 返回 (0) .子程序 取子程序指针_asm, 整数型, 公开, 取易子程序内部指针 .参数 子程序指针, 子程序指针 置入代码 ({ 139, 69, 8, 129, 56, 86, 87, 83, 232, 117, 10, 3, 64, 4, 131, 192, 8, 201, 194, 4, 0 }) ' 置入代码 ({ 235, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }) 返回 (0) .子程序 匿名子程序_整数型_1EA7E, 整数型 .参数 匿名局部变量_子程序指针_60031, 子程序指针 .如果真 (到整数 (匿名局部变量_子程序指针_60031) ＞ 65536) 返回 (0) .如果真结束 置入代码 ({ 139, 69, 8, 129, 56, 86, 87, 83, 232, 117, 10, 3, 64, 4, 131, 192, 8, 201, 194, 4, 0 }) .子程序 到子程序指针_asm, 子程序指针, 公开 .参数 子程指针, 整数型 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (&到子程序指针_asm) .子程序 到逻辑型_asm, 逻辑型, 公开 .参数 数值, 整数型 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (真) .子程序 调用子程序_asm, 整数型, 公开 .参数 回调子程序, 子程序指针, , <整数型> 易子程序 (回调参数1,回调参数2,回调参数3,回调参数4) .参数 回调参数1, 整数型, 可空, 自定义值,将被传递给回调子程序 .参数 回调参数2, 整数型, 可空, 自定义值,将被传递给回调子程序 .参数 回调参数3, 整数型, 可空, 自定义值,将被传递给回调子程序 .参数 回调参数4, 整数型, 可空, 自定义值,将被传递给回调子程序.注意:最多只支持四个回调参数 置入代码 ({ 96, 156, 131, 236, 64, 255, 117, 36, 255, 117, 28, 255, 117, 20, 255, 117, 12, 255, 85, 8, 137, 69, 12, 131, 196, 64, 157, 97 }) 返回 (回调参数1) .子程序 到整数型_asm, 整数型, 公开, 把原小数型值转为按整数型格式的值 与 转为小数型() 可进行相互转换,该功能主要用于 调用函数() 时需要小数型参数或寄存器或返回值时进行转换 .参数 小数型值, 小数型 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 到小数型_asm, 小数型, 公开, 把原以整数型格式值还原回小数型格式值 与 转为整数型() 可进行相互转换,该功能主要用于 调用函数() 时需要小数型参数或寄存器或返回值时进行转换 .参数 整数型值, 整数型 置入代码 ({ 139, 69, 8, 201, 194, 4, 0 }) 返回 (0) .子程序 内存_读字节型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读字节型 .参数 读取地址, 整数型 .参数 保存数据, 字节型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 82, 51, 192, 135, 69, 8, 138, 0, 139, 85, 12, 136, 2, 255, 69, 8, 90 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写字节型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写字节型 .参数 写入地址, 整数型 .参数 写出数据, 字节型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11405, 整数型 .局部变量 匿名局部变量_逻辑型_3192, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11405 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11405, 1, 64, 0) .如果真结束 置入代码 ({ 82, 51, 192, 135, 69, 8, 138, 85, 12, 136, 16, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3192 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3192) .子程序 内存_读字节型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读字节型数组 .参数 读取地址, 整数型 .参数 保存数据, 字节型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=读到遇{0}返回.或指定读取数目 1=1字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部变量_成员数量, 整数型 .局部变量 局部变量_返回, 逻辑型 局部变量_成员数量 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 内存_取窄文本长度_asm (读取地址) .判断 (读取数目 ＝ 0 且 局部变量_成员数量 ＞ 0) 读取数目 ＝ 局部变量_成员数量 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 局部变量_成员数量) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 243, 164, 255, 69, 8, 157, 95, 94, 89 }) 局部变量_返回 ＝ 读取地址 ≠ 0 返回 (局部变量_返回) .子程序 内存_写字节型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写字节型数组 .参数 写入地址, 整数型 .参数 写出数据, 字节型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11692, 整数型 .局部变量 匿名局部变量_逻辑型_3196, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11692 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11692, 取数组成员数 (写出数据), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 243, 164, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3196 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3196) .子程序 内存_读短整数型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读短整数型 .参数 读取地址, 整数型 .参数 保存数据, 短整数型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 82, 51, 192, 135, 69, 8, 102, 139, 0, 139, 85, 12, 102, 137, 2, 255, 69, 8, 90 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写短整数型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写短整型 .参数 写入地址, 整数型 .参数 写出数据, 短整数型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 局部变量_11418, 整数型 .局部变量 匿名局部变量_逻辑型_3198, 逻辑型 .如果真 (置为可写) 局部变量_11418 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 局部变量_11418, 2, 64, 0) .如果真结束 置入代码 ({ 82, 51, 192, 135, 69, 8, 102, 139, 85, 12, 102, 137, 16, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3198 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3198) .子程序 内存_读短整数型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读短整数型数组 .参数 读取地址, 整数型 .参数 保存数据, 短整数型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=读到遇{0,0}返回.指定读取数目 1=2字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 成员数, 整数型 .局部变量 局部_返回, 逻辑型 成员数 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 内存_取宽文本长度_asm (读取地址) ÷ 2 .判断 (读取数目 ＝ 0 且 成员数 ＞ 0) 读取数目 ＝ 成员数 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 成员数) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 102, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写短整数型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写短整数型数组 .参数 写入地址, 整数型 .参数 写出数据, 短整数型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11632, 整数型 .局部变量 匿名局部变量_逻辑型_3202, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11632 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11632, 2 × 取数组成员数 (写出数据), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 102, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3202 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3202) .子程序 内存_读整数型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读整数型 .参数 读取地址, 整数型 .参数 保存数据, 整数型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 0, 139, 85, 12, 137, 2, 255, 69, 8, 90 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_读逻辑型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读逻辑型 .参数 读取地址, 整数型 .参数 保存数据, 逻辑型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 0, 139, 85, 12, 137, 2, 255, 69, 8, 90 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_读小数型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读小数型 .参数 读取地址, 整数型 .参数 保存数据, 小数型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 0, 139, 85, 12, 137, 2, 255, 69, 8, 90 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) ' 本源码来自三叶资源网(www.sanye.cx) .子程序 内存_写整数型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写整数型 .参数 写入地址, 整数型 .参数 写出数据, 整数型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11429, 整数型 .局部变量 匿名局部变量_逻辑型_3212, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11429 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11429, 4, 64, 0) .如果真结束 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 85, 12, 137, 16, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3212 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3212) .子程序 内存_写逻辑型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写逻辑型 .参数 写入地址, 整数型 .参数 写出数据, 逻辑型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_331, 整数型 .局部变量 匿名局部变量_逻辑型_3213, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_331 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_331, 4, 64, 0) .如果真结束 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 85, 12, 137, 16, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3213 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3213) .子程序 内存_写小数型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写小数型 .参数 写入地址, 整数型 .参数 写出数据, 小数型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_304, 整数型 .局部变量 匿名局部变量_逻辑型_3216, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_304 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_304, 4, 64, 0) .如果真结束 置入代码 ({ 82, 51, 192, 135, 69, 8, 139, 85, 12, 137, 16, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3216 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3216) .子程序 内存_读整数型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读整数型数组 .参数 读取地址, 整数型 .参数 保存数据, 整数型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=读到遇{0,0,0,0}返回.指定读取数目 1=4字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 成员数, 整数型 .局部变量 局部_返回, 逻辑型 成员数 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 匿名子程序_整数型_42F80 (读取地址) ÷ 4 .判断 (读取数目 ＝ 0 且 成员数 ＞ 0) 读取数目 ＝ 成员数 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 成员数) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 匿名子程序_整数型_42F80, 整数型 .参数 内存地址, 整数型 置入代码 ({ 87, 156, 252, 51, 192, 51, 255, 135, 125, 8, 129, 255, 255, 255, 0, 0, 126, 9, 235, 4, 131, 69, 8, 4, 175, 117, 249, 157, 95 }) 返回 (内存地址) .子程序 匿名子程序_整数型_42F84, 整数型 .参数 内存地址, 整数型 置入代码 ({ 87, 156, 252, 51, 192, 51, 255, 135, 125, 8, 129, 255, 255, 255, 0, 0, 126, 15, 235, 4, 131, 69, 8, 8, 175, 117, 3, 175, 116, 3, 175, 235, 243, 157, 95 }) 返回 (内存地址) .子程序 内存_取宽文本长度_asm, 整数型, 公开, 在内存里递增判断数据,遇到 {0,0} 时返回字节长度..字数=内存长度/2 .参数 内存地址, 整数型, , 宽文本内存地址 置入代码 ({ 87, 156, 252, 51, 192, 51, 255, 135, 125, 8, 129, 255, 255, 255, 0, 0, 126, 10, 235, 4, 131, 69, 8, 2, 102, 175, 117, 248, 157, 95 }) 返回 (内存地址) .子程序 内存_取窄文本长度_asm, 整数型, 公开, 在内存里递增判断数据,遇到 {0} 时返回字节长度 .参数 内存地址, 整数型, , 窄文本内存地址 置入代码 ({ 87, 156, 252, 51, 192, 51, 255, 135, 125, 8, 129, 255, 255, 255, 0, 0, 126, 8, 235, 3, 255, 69, 8, 174, 117, 250, 157, 95 }) 返回 (内存地址) .子程序 内存_读小数型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读小数型数组 .参数 读取地址, 整数型 .参数 保存数据, 小数型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=读到遇{0,0,0,0}返回.指定读取数目 1=4字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 成员数, 整数型 .局部变量 局部_返回, 逻辑型 成员数 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 匿名子程序_整数型_42F80 (读取地址) ÷ 4 .判断 (读取数目 ＝ 0 且 成员数 ＞ 0) 读取数目 ＝ 成员数 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 成员数) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写整数型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写整数型数组 .参数 写入地址, 整数型 .参数 写出数据, 整数型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11644, 整数型 .局部变量 匿名局部变量_逻辑型_3223, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11644 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11644, 相乘 (4, 取数组成员数 (写出数据)), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3223 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3223) .子程序 内存_写小数型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写小数型数组 .参数 写入地址, 整数型 .参数 写出数据, 小数型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11656, 整数型 .局部变量 匿名局部变量_逻辑型_3224, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11656 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11656, 相乘 (4, 取数组成员数 (写出数据)), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3224 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3224) .子程序 内存_读长整数型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读长整数型 .参数 读取地址, 整数型 .参数 保存数据, 长整数型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 置入代码 ({ 83, 82, 51, 219, 135, 93, 8, 139, 85, 12, 139, 3, 137, 2, 139, 67, 4, 137, 66, 4, 255, 69, 8, 90, 91 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_读双精度小数型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读双精度小数型 .参数 读取地址, 整数型 .参数 保存数据, 双精度小数型, 参考 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部变量_返回, 逻辑型 置入代码 ({ 83, 82, 51, 219, 135, 93, 8, 139, 85, 12, 139, 3, 137, 2, 139, 67, 4, 137, 66, 4, 255, 69, 8, 90, 91 }) 局部变量_返回 ＝ 读取地址 ≠ 0 返回 (局部变量_返回) .子程序 内存_写长整数型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写长整数型 .参数 写入地址, 整数型 .参数 写出数据, 长整数型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11451, 整数型 .局部变量 匿名局部变量_逻辑型_3232, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11451 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11451, 8, 64, 0) .如果真结束 置入代码 ({ 82, 51, 210, 135, 85, 8, 139, 69, 12, 137, 2, 139, 69, 16, 137, 66, 4, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3232 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3232) .子程序 内存_写双精度小数型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写双精度小数型 .参数 写入地址, 整数型 .参数 写出数据, 双精度小数型 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_449, 整数型 .局部变量 匿名局部变量_逻辑型_3235, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_449 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_449, 8, 64, 0) .如果真结束 置入代码 ({ 82, 51, 210, 135, 85, 8, 139, 69, 12, 137, 2, 139, 69, 16, 137, 66, 4, 255, 69, 8, 90 }) 匿名局部变量_逻辑型_3235 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3235) .子程序 内存_读长整数型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读长整数型数组 .参数 读取地址, 整数型 .参数 保存数据, 长整数型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=遇到{0,0,0,0,0,0,0,0}返回.数目1=8字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部变量_成员数量, 整数型 .局部变量 局部变量_返回, 逻辑型 局部变量_成员数量 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 匿名子程序_整数型_42F84 (读取地址) ÷ 8 .判断 (读取数目 ＝ 0 且 局部变量_成员数量 ＞ 0) 读取数目 ＝ 局部变量_成员数量 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 局部变量_成员数量) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 107, 201, 2, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 局部变量_返回 ＝ 读取地址 ≠ 0 返回 (局部变量_返回) .子程序 内存_读双精度小数型数组_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读双精度小数型数组 .参数 读取地址, 整数型 .参数 保存数据, 双精度小数型, 参考 数组 .参数 读取数目, 整数型, 可空, 0=读取保存数据数组成员数目,-1=遇到{0,0,0,0,0,0,0,0}返回.数目1=8字节 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部变量_成员数量, 整数型 .局部变量 局部变量_返回, 逻辑型 局部变量_成员数量 ＝ 取数组成员数 (保存数据) .判断开始 (读取数目 ＝ -1) 读取数目 ＝ 匿名子程序_整数型_42F84 (读取地址) ÷ 8 .判断 (读取数目 ＝ 0 且 局部变量_成员数量 ＞ 0) 读取数目 ＝ 局部变量_成员数量 重定义数组 (保存数据, 假, 读取数目) .默认 .判断结束 .如果真 (读取数目 ≠ 局部变量_成员数量) 重定义数组 (保存数据, 假, 读取数目) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 7, 64, 107, 192, 4, 3, 248, 139, 77, 16, 107, 201, 2, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 局部变量_返回 ＝ 读取地址 ≠ 0 返回 (局部变量_返回) .子程序 内存_写长整数型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写长整数型数组 .参数 写入地址, 整数型 .参数 写出数据, 长整数型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_474, 整数型 .局部变量 匿名局部变量_逻辑型_3244, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_474 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_474, 相乘 (8, 取数组成员数 (写出数据)), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 107, 201, 2, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3244 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3244) .子程序 内存_写双精度小数型数组_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写双精度小数型数组 .参数 写入地址, 整数型 .参数 写出数据, 双精度小数型, 参考 数组 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11680, 整数型 .局部变量 匿名局部变量_逻辑型_3254, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11680 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11680, 8 × 取数组成员数 (写出数据), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 51, 201, 139, 117, 12, 139, 54, 139, 6, 131, 198, 4, 3, 14, 131, 198, 4, 72, 117, 248, 107, 201, 2, 243, 165, 255, 69, 8, 157, 95, 94, 89 }) 匿名局部变量_逻辑型_3254 ＝ 写入地址 ≠ 0 返回 (匿名局部变量_逻辑型_3254) .子程序 内存_读文本型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读文本型 .参数 读取地址, 整数型 .参数 保存数据, 文本型, 参考 .参数 读取长度, 整数型, 可空, 指定要读取文本数据的长度.空=-1=读取至{0}终止符为止 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 .如果真 (读取长度 ＜ 0 或 是否为空 (读取长度)) 读取长度 ＝ 内存_取窄文本长度_asm (读取地址) .如果真结束 保存数据 ＝ 取空白文本 (读取长度) 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 139, 77, 16, 243, 164, 198, 7, 0, 255, 69, 8, 157, 95, 94, 89 }) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写文本型_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写文本型 .参数 写到地址, 整数型, , 将把文本数据写入到此参数指定的内存里去 .参数 写出数据, 文本型, , 把此参数里的数据写出到参数1指定的内存里去 .参数 无终止符, 逻辑型, 可空, 默认=假=添加{0}终止符,真=不添加{0}终止符 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_546, 整数型 .局部变量 匿名局部变量_整数型_11839, 整数型 .局部变量 匿名局部变量_逻辑型_543, 逻辑型 ' 匿名局部变量_整数型_546 ＝ 取文本型指针 (写出数据) ' 赋值 (匿名局部变量_整数型_11839, 匿名子程序_整数型_4FF4A (写出数据)) ' 如果 (无终止符)如果 ()如果 () ' 匿名局部变量_整数型_11839 ＝ 匿名子程序_整数型_42CE2 (匿名局部变量_整数型_11839, 1) ' 赋值 (匿名局部变量_逻辑型_543, 匿名子程序_逻辑型_42D10 (写到地址, 匿名局部变量_整数型_546, 匿名局部变量_整数型_11839, 置为可写)) ' 返回 (匿名局部变量_逻辑型_543) .子程序 内存_读宽文本型_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读宽文本 .参数 读取地址, 整数型 .参数 保存文本, 文本型, 参考 可空, 把读取来的宽文本转换成窄文本保存到此参数变量中 .参数 读取长度, 整数型, 可空, 要读取宽文本字节长度.空=-1=读至{0,0}终止符为止 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 整数型 .如果真 (读取长度 ＜ 0 或 是否为空 (读取长度)) 读取长度 ＝ 内存_取宽文本长度_asm (读取地址) .如果真结束 局部_返回 ＝ _WideCharToMultiByte (0, 0, 读取地址, 读取长度 ＼ 2, 保存文本, 0, 0, 假) 保存文本 ＝ 取空白文本 (局部_返回) 局部_返回 ＝ _WideCharToMultiByte (0, 0, 读取地址, 读取长度 ＼ 2, 保存文本, 局部_返回, 0, 假) 返回 (局部_返回 ＞ 0) .子程序 内存_读字节集_asm, 逻辑型, 公开, 读取地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 读字节集 .参数 读取地址, 整数型 .参数 保存数据, 字节集, 参考 .参数 读取长度, 整数型, , 指定要读取字节集数据的长度 .参数 偏移数组, 整数型, 可空 数组 .局部变量 局部_返回, 逻辑型 .如果真 (读取长度 ≠ 取字节集长度 (保存数据)) 保存数据 ＝ 取空白字节集 (读取长度) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 246, 135, 117, 8, 139, 125, 12, 139, 63, 131, 63, 1, 117, 11, 139, 79, 4, 131, 199, 8, 243, 164, 255, 69, 8, 157, 95, 94, 89 }) ' 本源码来自三叶资源网(www.sanye.cx) 局部_返回 ＝ 读取地址 ≠ 0 返回 (局部_返回) .子程序 内存_写字节集_asm, 逻辑型, 公开, 写入地址 -> 父址+偏移量[1] -> 父址+偏移量[2] -> 父址+偏移量[N] -> 写字节集 .参数 写入地址, 整数型 .参数 写出数据, 字节集 .参数 偏移数组, 整数型, 可空 数组 .参数 置为可写, 逻辑型, 可空, 在写内存数据之前,先把目标虚拟内存保护属性设置为64可读写运行属性 .局部变量 匿名局部变量_整数型_11764, 整数型 .局部变量 局部_返回, 逻辑型 .如果真 (置为可写) 匿名局部变量_整数型_11764 ＝ 写入地址 ' 匿名子程序_逻辑型_38B67 (-1, 匿名局部变量_整数型_11764, 取字节集长度 (写出数据), 64, 0) .如果真结束 置入代码 ({ 81, 86, 87, 156, 252, 51, 255, 135, 125, 8, 139, 117, 12, 139, 54, 131, 62, 1, 117, 11, 139, 78, 4, 131, 198, 8, 243, 164, 255, 69, 8, 157, 95, 94, 89 }) 局部_返回 ＝ 写入地址 ≠ 0 返回 (局部_返回)