[原创]华琦库管精灵注册分析--VB与函数的嵌套附算法程序代码-软件逆向-看雪-安全社区|安全招聘|kanxue.com

[原创]华琦库管精灵注册分析--VB与函数的嵌套附算法程序代码

发表于: 2005-4-7 14:14 8523

[原创]华琦库管精灵注册分析--VB与函数的嵌套附算法程序代码

liyangsj

2005-4-7 14:14

8523

华琦库管精灵注册分析--VB与函数的嵌套附算法程序代码
【破解作者】 jsliyangsj
【作者邮箱】 sjcrack@yahoo.com.cn
【使用工具】 peid OllyDbg1.10
【破解平台】 Winxp
【软件名称】华琦库管精灵
【软件地址】 http://www.focosoft.com/download.htm
【编写语言】 VB
【软件介绍】：库管精灵是我们推出的一款构思奇巧、结构严谨的实用精品软件。该软件具有独到的数据分段检索、自定义特殊处理、智能辅助输入、智能成本核算、分级+分组权限控制、外部数据导入、多种数据格式转换等神奇功能，并采用了数据批量传送、多重数据加密、强力数据压缩、并发冲突降解等多种先进技术。界面简洁、功能强大，是典型的傻瓜+实用型的进销存一体化设计的仓储及营销管理工具！软件中全面集成了库存物资的入库、出库、调拨、处理、利润核算、盘库、盘库盈亏核算等数据的录入、维护、汇总、统计、查询、过滤、报表打印及数据格式转换（支持Microsoft Excel、Microsoft Access、Dbase、Foxpro、HTML、纯文本等格式）等系列功能。因界面简介而貌似\\\"迷你\\\"，实际上功能相当全面--甚至集成了大型进销存软件都不敢随意问津的任意组合查询，并进而独创了强大的直接SQL查询！内嵌了自主开发的HK Script脚本语言解释器！
过程:
用暂停法，在堆栈中找到返回主程序的地址堆栈，直接返回即可到达主程序的错误窗口点。
005DEB58 .  E>call <jmp.&MSVBVM60.__vbaStrMove>
005DEB5D .  F>push dword ptr ss:[ebp-28]
005DEB60 .  E>call <jmp.&MSVBVM60.__vbaLenBstr>       ;  得到注册码的长度
005DEB65 .  8>test eax,eax                            ;  测试是否输入了注册码
005DEB67 .  0>jnz stmagic.005DEC1D
005DEB6D .  E>call <jmp.&MSVBVM60.#685>
005DEB72 .  5>push eax
005DEB73 .  8>lea eax,dword ptr ss:[ebp-48]

…………省略………………
005DEC1D > \F>push dword ptr ss:[ebp-28]
005DEC20 .  E>call stmagic.004F307B                   ;  关键点，进入！！  计算和比较都在里面
005DEC25 .  6>test ax,ax
005DEC28 .  8>mov dword ptr ss:[ebp-8C],edi
005DEC2E .  8>mov dword ptr ss:[ebp-94],esi
005DEC34 .  8>mov dword ptr ss:[ebp-7C],edi
005DEC37 .  8>mov dword ptr ss:[ebp-84],esi
005DEC3D .  8>mov dword ptr ss:[ebp-6C],edi
005DEC40 .  8>mov dword ptr ss:[ebp-74],esi
005DEC43 .  7>jnz short stmagic.005DEC85             ;  如果比较不相等，错误
005DEC45 .  C>mov dword ptr ss:[ebp-BC],stmagic.0043CDE>
005DEC4F .  8>mov dword ptr ss:[ebp-C4],ebx
005DEC55 .  8>lea edx,dword ptr ss:[ebp-C4]
005DEC5B .  8>lea ecx,dword ptr ss:[ebp-64]
005DEC5E .  E>call <jmp.&MSVBVM60.__vbaVarDup>
005DEC63 .  8>lea eax,dword ptr ss:[ebp-94]
005DEC69 .  5>push eax
005DEC6A .  8>lea eax,dword ptr ss:[ebp-84]
005DEC70 .  5>push eax
005DEC71 .  8>lea eax,dword ptr ss:[ebp-74]
005DEC74 .  5>push eax
005DEC75 .  6>push 40
005DEC77 .  8>lea eax,dword ptr ss:[ebp-64]
005DEC7A .  5>push eax
005DEC7B .  E>call <jmp.&MSVBVM60.#595>                ;  错误窗口！！！
…………………………………………………………………………………………………………………………
进入call stmagic.004F307B
…………………………………………………………………………………………………………………………
004F30E8 .  E>call <jmp.&MSVBVM60.__vbaLenBstr>       ;  得到输入码的长度
004F30ED .  8>cmp eax,21                               ;  输入码是否位33位，不是就完
004F30F0 .  0>jnz stmagic.004F32C3
004F30F6 .  C>mov dword ptr ss:[ebp-6C],stmagic.0043CE8>
004F30FD .  C>mov dword ptr ss:[ebp-74],8
004F3104 .  8>lea edx,dword ptr ss:[ebp-74]
004F3107 .  8>lea ecx,dword ptr ss:[ebp-54]
004F310A .  E>call <jmp.&MSVBVM60.__vbaVarDup>
004F310F .  6>push 1
004F3111 .  6>push -1
004F3113 .  8>lea eax,dword ptr ss:[ebp-54]
004F3116 .  5>push eax
004F3117 .  F>push dword ptr ss:[ebp-24]
004F311A .  8>lea eax,dword ptr ss:[ebp-64]
004F311D .  5>push eax
004F311E .  E>call <jmp.&MSVBVM60.#711>
004F3123 .  8>lea eax,dword ptr ss:[ebp-64]
004F3126 .  5>push eax
004F3127 .  6>push 2008
004F312C .  E>call <jmp.&MSVBVM60.__vbaAryVar>
004F3131 .  8>mov dword ptr ss:[ebp-78],eax
004F3134 .  8>lea eax,dword ptr ss:[ebp-78]
004F3137 .  5>push eax
004F3138 .  8>lea eax,dword ptr ss:[ebp-28]
004F313B .  5>push eax
004F313C .  E>call <jmp.&MSVBVM60.__vbaAryCopy>
004F3141 .  8>lea eax,dword ptr ss:[ebp-64]
004F3144 .  5>push eax
004F3145 .  8>lea eax,dword ptr ss:[ebp-54]
004F3148 .  5>push eax
004F3149 .  6>push 2
004F314B .  E>call <jmp.&MSVBVM60.__vbaFreeVarList>
004F3150 .  8>add esp,0C
004F3153 .  F>push dword ptr ss:[ebp-28]
004F3156 .  6>push 1
004F3158 .  E>call <jmp.&MSVBVM60.__vbaUbound>
004F315D .  8>cmp eax,5                               ;  上面是检查输入码中是否有5个“－”
004F3160 .  0>jnz stmagic.004F32C3                   ;  不等于就完

…………………………………………………………………………………………
004F3168 > /6>push 4
004F316A . |5>pop eax
004F316B . |3>cmp esi,eax
004F316D . |F>push dword ptr ss:[ebp-34]
004F3170 . |0>jg stmagic.004F322B
004F3176 . |6>push 1
004F3178 . |5>push esi
004F3179 . |F>push dword ptr ss:[ebp-28]
004F317C . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
004F3181 . |F>push dword ptr ds:[eax]                ;  看到第一段
004F3183 . |E>call <jmp.&MSVBVM60.#616>                ;  从左边取第一位
004F3188 . |8>mov edx,eax
004F318A . |8>lea ecx,dword ptr ss:[ebp-3C]
004F318D . |E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3192 . |5>push eax
004F3193 . |E>call <jmp.&MSVBVM60.__vbaStrCat>       ;  把每段的第一位及最后一段的全部组合在一起用于计算出注册码
004F3198 . |8>mov edx,eax
004F319A . |8>lea ecx,dword ptr ss:[ebp-34]
004F319D . |E>call <jmp.&MSVBVM60.__vbaStrMove>
004F31A2 . |8>lea ecx,dword ptr ss:[ebp-3C]
004F31A5 . |E>call <jmp.&MSVBVM60.__vbaFreeStr>
004F31AA . |C>mov dword ptr ss:[ebp-4C],80020004
004F31B1 . |C>mov dword ptr ss:[ebp-54],0A
004F31B8 . |8>lea eax,dword ptr ss:[ebp-54]
004F31BB . |5>push eax
004F31BC . |6>push 2
004F31BE . |5>push esi
004F31BF . |F>push dword ptr ss:[ebp-28]
004F31C2 . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
004F31C7 . |F>push dword ptr ds:[eax]
004F31C9 . |E>call <jmp.&MSVBVM60.#631>
004F31CE . |8>mov edx,eax
004F31D0 . |8>lea ecx,dword ptr ss:[ebp-3C]
004F31D3 . |E>call <jmp.&MSVBVM60.__vbaStrMove>
004F31D8 . |8>mov ebx,eax
004F31DA . |5>push esi
004F31DB . |F>push dword ptr ss:[ebp-28]
004F31DE . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
004F31E3 . |8>mov ecx,eax
004F31E5 . |8>mov edx,ebx
004F31E7 . |E>call <jmp.&MSVBVM60.__vbaStrCopy>
004F31EC . |8>lea ecx,dword ptr ss:[ebp-3C]
004F31EF . |E>call <jmp.&MSVBVM60.__vbaFreeStr>
004F31F4 . |8>lea ecx,dword ptr ss:[ebp-54]
004F31F7 . |E>call <jmp.&MSVBVM60.__vbaFreeVar>
004F31FC . |F>push dword ptr ss:[ebp-38]
004F31FF . |5>push esi
004F3200 . |F>push dword ptr ss:[ebp-28]
004F3203 . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
004F3208 . |F>push dword ptr ds:[eax]
004F320A . |E>call <jmp.&MSVBVM60.__vbaStrCat>       ;  把去掉每段第一位和“－”的输入码重新组合0015eeec中
004F320F . |8>mov edx,eax
004F3211 . |8>lea ecx,dword ptr ss:[ebp-38]
004F3214 . |E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3219 . |6>push 1
004F321B . |5>pop eax
004F321C . |0>add eax,esi
004F321E . |0>jo stmagic.004F333D
004F3224 . |8>mov esi,eax
004F3226 .^\E>jmp stmagic.004F3168
004F322B >  6>push 5                                  ;  上面一段是把各个段的第一个输入码组合在一起
004F322D .  F>push dword ptr ss:[ebp-28]
004F3230 .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>
004F3235 .  F>push dword ptr ds:[eax]
004F3237 .  E>call <jmp.&MSVBVM60.__vbaStrCat>       ;  把最后一段的输入码与刚才的组合
004F323C .  8>mov edx,eax
004F323E .  8>lea ecx,dword ptr ss:[ebp-34]
004F3241 .  E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3246 .  F>push dword ptr ss:[ebp-34]
此段是：输入码应该写成：输入码1-输入码2-输入码3-输入码4-输入码5-输入码6；总长度为33
并把输入码1、输入码2、输入码3、输入码4、输入码5的第一个字符，及输入码6的全部字符组合为一组参与运算其他的注册码。
也把去掉上面组合起来的字符，及5个“-”，在组合为另一组用与比较参与计算的输入码计算出来的字符。
输入码有要求：实际上，最后一段输入码6只能是三位，因为：
004F3246 .  F>push dword ptr ss:[ebp-34]
004F3249 .  E>call stmagic.004F2F98                   ;  把参与计算的输入码压入，计算注册码
004F324E .  8>mov edx,eax
004F3250 .  8>lea ecx,dword ptr ss:[ebp-40]
004F3253 .  E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3258 .  8>mov edx,dword ptr ss:[ebp-40]
004F325B .  8>mov dword ptr ss:[ebp-40],edi
004F325E .  6>push 14                                  ;  20
004F3260 .  8>lea ecx,dword ptr ss:[ebp-3C]
004F3263 .  E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3268 .  5>push eax
004F3269 .  E>call <jmp.&MSVBVM60.#616>                ;  计算出来的字符串的前20位
004F326E .  8>mov edx,eax
004F3270 .  8>lea ecx,dword ptr ss:[ebp-2C]
004F3273 .  E>call <jmp.&MSVBVM60.__vbaStrMove>
004F3278 .  8>lea eax,dword ptr ss:[ebp-40]
004F327B .  5>push eax
004F327C .  8>lea eax,dword ptr ss:[ebp-3C]
004F327F .  5>push eax
004F3280 .  6>push 2
004F3282 .  E>call <jmp.&MSVBVM60.__vbaFreeStrList>
004F3287 .  8>add esp,0C
004F328A .  F>push dword ptr ss:[ebp-38]
004F328D .  F>push dword ptr ss:[ebp-2C]
004F3290 .  6>push 1
004F3292 .  E>call <jmp.&MSVBVM60.__vbaStrComp>       ;  用去掉组合好的与“-”的输入码与计算出来的比较了！
…………………………………………………………………………………………………………………………
进入call stmagic.004F2F98
…………………………………………………………………………………………………………………………
006CD2BC .  8>mov eax,dword ptr ss:[ebp-70]
006CD2BF .  C>mov dword ptr ds:[eax],6A09E667    ;  固定值用于起始就算和最后计算注册码的
006CD2C5 .  8>mov eax,dword ptr ss:[ebp-70]
006CD2C8 .  8>lea ecx,dword ptr ss:[ebp-3D0]
006CD2CE .  C>mov dword ptr ds:[eax+4],BB67AE85 ;  固定值用于起始就算和最后计算注册码的
006CD2D5 .  8>mov eax,dword ptr ss:[ebp-70]
006CD2D8 .  5>push ecx
006CD2D9 .  C>mov dword ptr ds:[eax+8],3C6EF372 ;  固定值用于起始就算和最后计算注册码的
006CD2E0 .  8>mov eax,dword ptr ss:[ebp-70]
006CD2E3 .  F>push dword ptr ss:[ebp+C]
006CD2E6 .  C>mov dword ptr ds:[eax+C],A54FF53A ;  固定值用于起始就算和最后计算注册码的
006CD2ED .  8>mov eax,dword ptr ss:[ebp-70]
006CD2F0 .  5>push esi
006CD2F1 .  C>mov dword ptr ds:[eax+10],510E527F ;  固定值用于起始就算和最后计算注册码的
006CD2F8 .  8>mov eax,dword ptr ss:[ebp-70]
006CD2FB .  C>mov dword ptr ds:[eax+14],9B05688C ;  固定值用于起始就算和最后计算注册码的
006CD302 .  8>mov eax,dword ptr ss:[ebp-70]
006CD305 .  C>mov dword ptr ds:[eax+18],1F83D9AB ;  固定值用于起始就算和最后计算注册码的
006CD30C .  8>mov eax,dword ptr ss:[ebp-70]
006CD30F .  C>mov dword ptr ds:[eax+1C],5BE0CD19 ;  固定值用于起始就算和最后计算注册码的
006CD316 .  8>mov eax,dword ptr ds:[esi]
006CD318 .  F>call dword ptr ds:[eax+50]          ;  计算与输入码一起的固定值
006CD31B .  8>lea eax,dword ptr ss:[ebp-3D0]    ;  出来后只是把每段开头组合
……………………………………………………………………………………………………………………
call dword ptr ds:[eax+50]          ;  计算与输入码一起的固定值
……………………………………………………………………………………………………………………
006CCF19 > /3>cmp ecx,dword ptr ss:[ebp-20]
006CCF1C . |8>mov eax,ecx
006CCF1E . |6>push 4                            ;  固定值4
006CCF20 . |9>cdq
006CCF21 . |5>pop edi
006CCF22 . |0>jge stmagic.006CD001
006CCF28 . |F>idiv edi
006CCF2A . |6>push 3
006CCF2C . |C>mov dword ptr ss:[ebp-48],2
006CCF33 . |C>mov dword ptr ss:[ebp-68],4008
006CCF3A . |8>mov dword ptr ss:[ebp-28],eax
006CCF3D . |8>mov eax,ecx
006CCF3F . |9>cdq
006CCF40 . |F>idiv edi
006CCF42 . |5>pop edi
006CCF43 . |6>push 1
006CCF45 . |5>pop eax
006CCF46 . |8>mov dword ptr ss:[ebp-40],eax
006CCF49 . |2>sub edi,edx
006CCF4B . |8>mov edx,dword ptr ss:[ebp+C]
006CCF4E . |0>jo stmagic.006CD105
006CCF54 . |6>imul edi,edi,8
006CCF57 . |0>jo stmagic.006CD105
006CCF5D . |8>mov dword ptr ss:[ebp-60],edx
006CCF60 . |8>lea edx,dword ptr ss:[ebp-48]
006CCF63 . |0>add ecx,eax
006CCF65 . |5>push edx
006CCF66 . |0>jo stmagic.006CD105
006CCF6C . |8>lea eax,dword ptr ss:[ebp-68]
006CCF6F . |5>push ecx
006CCF70 . |5>push eax
006CCF71 . |8>lea eax,dword ptr ss:[ebp-58]
006CCF74 . |5>push eax
006CCF75 . |E>call <jmp.&MSVBVM60.#632>
006CCF7A . |8>lea eax,dword ptr ss:[ebp-58]
006CCF7D . |5>push eax
006CCF7E . |8>lea eax,dword ptr ss:[ebp-38]
006CCF81 . |5>push eax
006CCF82 . |E>call <jmp.&MSVBVM60.__vbaStrVarVal>  ;  得到各个组合的头输入码
006CCF87 . |5>push eax
006CCF88 . |E>call <jmp.&MSVBVM60.#693>          ;  得到各个头输入码的ASCII码
006CCF8D . |0>movzx eax,al
006CCF90 . |8>lea ecx,dword ptr ss:[ebp-38]
006CCF93 . |8>mov dword ptr ss:[ebp-24],eax
006CCF96 . |E>call <jmp.&MSVBVM60.__vbaFreeStr>
006CCF9B . |8>lea eax,dword ptr ss:[ebp-58]
006CCF9E . |5>push eax
006CCF9F . |8>lea eax,dword ptr ss:[ebp-48]
006CCFA2 . |5>push eax
006CCFA3 . |6>push 2
006CCFA5 . |E>call <jmp.&MSVBVM60.__vbaFreeVarList>
006CCFAA . |8>mov edx,dword ptr ds:[ebx]
006CCFAC . |8>add esp,0C
006CCFAF . |8>lea eax,dword ptr ss:[ebp-7C]
006CCFB2 . |8>mov ecx,edi
006CCFB4 . |5>push eax
006CCFB5 . |8>mov dword ptr ss:[ebp-88],edx
006CCFBB . |E>call <jmp.&MSVBVM60.__vbaI2I4>
006CCFC0 . |5>push eax
006CCFC1 . |8>mov eax,dword ptr ss:[ebp-88]
006CCFC7 . |F>push dword ptr ss:[ebp-24]          ;  压入各个头输入吗的ASCII
006CCFCA . |5>push ebx
006CCFCB . |F>call dword ptr ds:[eax+24]
006CCFCE . |F>push dword ptr ss:[ebp-28]
006CCFD1 . |F>push dword ptr ss:[ebp-30]
006CCFD4 . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CCFD9 . |F>push dword ptr ss:[ebp-28]
006CCFDC . |8>mov edi,dword ptr ds:[eax]
006CCFDE . |0>or edi,dword ptr ss:[ebp-7C]
006CCFE1 . |F>push dword ptr ss:[ebp-30]
006CCFE4 . |E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CCFE9 . |8>mov dword ptr ds:[eax],edi
006CCFEB . |8>mov eax,dword ptr ss:[ebp-34]
006CCFEE . |8>add eax,1
006CCFF1 . |0>jo stmagic.006CD105
006CCFF7 . |8>mov dword ptr ss:[ebp-34],eax
006CCFFA . |8>mov ecx,eax
006CCFFC .^\E>jmp stmagic.006CCF19                ;  上面有输入码取一部分的个数次循环为的是把取出的注册码组合起来
006CD001 >  F>idiv edi                            ;  用取出的输入码个数除以4
006CD003 .  6>push 4
006CD005 .  8>mov edi,dword ptr ds:[ebx]
006CD007 .  8>mov dword ptr ss:[ebp-28],eax       ;  得到的商储存在EBP-28
006CD00A .  8>mov eax,ecx                         ;  得到次数
006CD00C .  9>cdq
006CD00D .  5>pop ecx
006CD00E .  F>idiv ecx                            ;  用取出的输入码个数除以4 为了得到余数
006CD010 .  6>push 3                            ;  固定值3
006CD012 .  8>lea eax,dword ptr ss:[ebp-7C]       ;  存储地址
006CD015 .  5>pop ecx                            ;  得到固定值3
006CD016 .  5>push eax
006CD017 .  2>sub ecx,edx                         ;  固定值3减去次数除以的4的余数
006CD019 .  0>jo stmagic.006CD105
006CD01F .  6>imul ecx,ecx,8                      ;  被减数乘以8
006CD022 .  0>jo stmagic.006CD105
006CD028 .  E>call <jmp.&MSVBVM60.__vbaI2I4>
006CD02D .  5>push eax                            ;  得到刚计算的乘积作为固定值取值！！！
006CD02E .  6>push 80                            ;  函数中被处理的数！
006CD033 .  5>push ebx
006CD034 .  F>call dword ptr ds:[edi+24]          ;  计算函数
006CD037 .  F>push dword ptr ss:[ebp-28]
006CD03A .  F>push dword ptr ss:[ebp-30]
006CD03D .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CD042 .  F>push dword ptr ss:[ebp-28]          ;  个数除以4的商
006CD045 .  8>mov edi,dword ptr ds:[eax]          ;  得到输入码段数据，没有满4个的ASCII码
006CD047 .  0>or edi,dword ptr ss:[ebp-7C]       ;  与刚才得到的数据进行OR运算
006CD04A .  F>push dword ptr ss:[ebp-30]
006CD04D .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CD052 .  8>lea ecx,dword ptr ss:[ebp-7C]       ;  下面函数存储地址
006CD055 .  8>mov dword ptr ds:[eax],edi          ;  储存在与输入码一起的地方
006CD057 .  8>mov eax,dword ptr ds:[ebx]
006CD059 .  5>push ecx                            ;  得到存放地址
006CD05A .  6>push 3                            ;  固定值产生了与输入码一起的固定值
006CD05C .  F>push dword ptr ss:[ebp-20]          ;  得到参与运算输入码的个数
006CD05F .  5>push ebx
006CD060 .  F>call dword ptr ds:[eax+24]          ;  参与运算输入吗的个数与1FFFFFFF  AND运算，并乘以00000008 作为输入吗的第15个（从0开始）倒数第1个
006CD063 .  8>mov eax,esi
006CD065 .  8>sub eax,1
006CD068 .  0>jo stmagic.006CD105
006CD06E .  5>push eax
006CD06F .  F>push dword ptr ss:[ebp-30]
006CD072 .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CD077 .  8>mov ecx,dword ptr ss:[ebp-7C]       ;  得到计算出来的值
006CD07A .  8>mov dword ptr ds:[eax],ecx          ;  储存了为输入码前16个的（倒数第1个）
006CD07C .  8>mov eax,dword ptr ds:[ebx]
006CD07E .  8>lea ecx,dword ptr ss:[ebp-7C]       ;  下一个函数的储存地址
006CD081 .  5>push ecx
006CD082 .  6>push 1D                            ;  固定值1D
006CD084 .  F>push dword ptr ss:[ebp-20]          ;  得到参与运算输入码的个数
006CD087 .  5>push ebx
006CD088 .  F>call dword ptr ds:[eax+28]          ;  参与运算输入吗的个数与7FFFFFFE  AND运算，并除以固定值20000000，作为输入吗的第14个（从0开始）倒数第2个必为0
006CD08B .  8>sub esi,2
006CD08E .  7>jo short stmagic.006CD105
006CD090 .  5>push esi
006CD091 .  F>push dword ptr ss:[ebp-30]
006CD094 .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>
006CD099 .  8>mov ecx,dword ptr ss:[ebp-7C]       ;  得到计算好的值
006CD09C .  8>mov dword ptr ds:[eax],ecx          ;  储存了为输入码前16个的（倒数第2个）
……………………………………………………………………………………………………………………
把参与运算的输入码的ASCII码分成四个字符，就是8个ASCII码一段，把参与运算的输入码进行计算，得到和参与运算一起的
，就是在所有参与运算的输入码的ASCII码的下一位，加一个Ox80000000这个（因为是参与运算的输入码必须8位，可以自己跟一下）
再在
参与运算输入吗的个数与1FFFFFFF  AND运算，并乘以00000008 作为输入吗的第15个（从0开始）倒数第1个
（必为40）

参与运算输入吗的个数与7FFFFFFE  AND运算，并除以固定值20000000，作为输入吗的第14个（从0开始）倒数第2个
（必为0）
这样就有一共有16个输入码表了！
…………………………………………………………………………………………………………………………
006CD350 .  8>mov ecx,dword ptr ds:[eax]          ;  到这里已经计算好了内存的数据
006CD352 .  3>xor ebx,ebx
006CD354 .  8>mov dword ptr ss:[ebp-24],ecx       ;  把内存中的固定值放入EBP-24 6A09E667
006CD357 .  8>mov ecx,dword ptr ds:[eax+4]
006CD35A .  8>mov dword ptr ss:[ebp-28],ecx       ;  把内存中的固定值放入EBP-28 BB67AE85
006CD35D .  8>mov ecx,dword ptr ds:[eax+8]
006CD360 .  8>mov dword ptr ss:[ebp-30],ecx       ;  把内存中的固定值放入EBP-30跳了一个3C6EF372
006CD363 .  8>mov ecx,dword ptr ds:[eax+C]
006CD366 .  8>mov dword ptr ss:[ebp-38],ecx       ;  把内存中的固定值放入EBP-38跳过一个A54FF53A
006CD369 .  8>mov ecx,dword ptr ds:[eax+10]
006CD36C .  8>mov dword ptr ss:[ebp-3C],ecx       ;  把内存中的固定值放入EBP-3C没有跳510E527F
006CD36F .  8>mov ecx,dword ptr ds:[eax+14]
006CD372 .  8>mov dword ptr ss:[ebp-40],ecx       ;  把内存中的固定值放入EBP-40没有跳9B05688C
006CD375 .  8>mov ecx,dword ptr ds:[eax+18]
006CD378 .  8>mov dword ptr ss:[ebp-60],ecx       ;  把内存中的固定值放入EBP-60 1F83D9AB
006CD37B .  8>mov ecx,dword ptr ds:[eax+1C]
006CD37E .  8>mov dword ptr ss:[ebp-64],ecx       ;  把内存中的固定值放入EBP-64 5BE0CD19
006CD381 >  6>push 3F                            ;  上面一共八个
006CD383 .  5>pop ecx
006CD384 .  3>cmp ebx,ecx                         ;  次数与3F比较
006CD386 .  0>jg stmagic.006CD61E                ;  大于就跳出
006CD38C .  8>cmp ebx,10                         ;  与10比较，大于等于就进行另一种运算
006CD38F .  7>jge short stmagic.006CD3B6
006CD391 .  8>cmp ebx,40
006CD394 .  7>jb short stmagic.006CD39B
006CD396 .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD39B >  8>mov eax,ebx
006CD39D .  0>add eax,dword ptr ss:[ebp-18]
006CD3A0 .  0>jo stmagic.006CDD28
006CD3A6 .  5>push eax
006CD3A7 .  F>push dword ptr ss:[ebp-20]
006CD3AA .  E>call <jmp.&MSVBVM60.__vbaDerefAry1>  ;  出现反着的输入头组合
006CD3AF .  8>mov eax,dword ptr ds:[eax]          ;  变成ASCII又正过来了31373339 第2次是后4位ASCII，第3位80000000，第F位00000040
006CD3B1 .  E>jmp stmagic.006CD4BB
006CD3B6 >  8>mov eax,ebx                         ;  得到次数
006CD3B8 .  8>sub eax,2                         ;  次数减2
006CD3BB .  0>jo stmagic.006CDD28
006CD3C1 .  8>cmp eax,40
006CD3C4 .  8>mov dword ptr ss:[ebp-3A0],eax    ;  存储在EBP-3A0
006CD3CA .  7>jb short stmagic.006CD3D7
006CD3CC .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD3D1 .  8>mov eax,dword ptr ss:[ebp-3A0]
006CD3D7 >  8>mov ecx,dword ptr ds:[esi]
006CD3D9 .  8>lea edx,dword ptr ss:[ebp-388]    ;  得到EBP-388地址  也就保存地址
006CD3DF .  5>push edx
006CD3E0 .  8>mov edx,dword ptr ss:[ebp-4C]       ;  得到输入码地址
006CD3E3 .  F>push dword ptr ds:[edx+eax*4]       ;  得到从输入码地址向下的第次数减2的单元格数据第1次为0 第2次为00000040以后都是0
006CD3E6 .  5>push esi
006CD3E7 .  F>call dword ptr ds:[ecx+4C]          ;  存储在EBP-388第依次固定为0
006CD3EA .  8>mov eax,ebx
006CD3EC .  8>sub eax,7                         ;  次数减7
006CD3EF .  0>jo stmagic.006CDD28
006CD3F5 .  8>cmp eax,40
006CD3F8 .  8>mov dword ptr ss:[ebp-3A4],eax
006CD3FE .  7>jb short stmagic.006CD40B
006CD400 .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD405 .  8>mov eax,dword ptr ss:[ebp-3A4]
006CD40B >  8>lea edx,dword ptr ss:[ebp-38C]    ;  将改变EBP-38C的数据
006CD411 .  8>mov ecx,dword ptr ds:[esi]
006CD413 .  5>push edx
006CD414 .  8>mov edx,dword ptr ss:[ebp-4C]       ;  得到输入码的首地址
006CD417 .  F>push dword ptr ds:[edx+eax*4]       ;  得到从输入码地址向下的第次数减7的单元格数据第17次为40其余都为0
006CD41A    F>push dword ptr ss:[ebp-388]       ;  得到EBP-388的数据
006CD420 .  5>push esi
006CD421 .  F>call dword ptr ds:[ecx+2C]          ;  存储在EBP-38C
006CD424 .  8>mov eax,ebx
006CD426 .  8>sub eax,0F                         ;  次数减F
006CD429 .  0>jo stmagic.006CDD28
006CD42F .  8>cmp eax,40
006CD432 .  8>mov dword ptr ss:[ebp-3A8],eax
006CD438 .  7>jb short stmagic.006CD445
006CD43A .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD43F .  8>mov eax,dword ptr ss:[ebp-3A8]
006CD445 >  8>mov ecx,dword ptr ds:[esi]
006CD447 .  8>lea edx,dword ptr ss:[ebp-390]
006CD44D .  5>push edx
006CD44E .  8>mov edx,dword ptr ss:[ebp-4C]
006CD451 .  F>push dword ptr ds:[edx+eax*4]       ;  得到从输入码地址向下的第次数减F的单元格数据
006CD454 .  5>push esi
006CD455 .  F>call dword ptr ds:[ecx+48]          ;  这里！！！！！！！！！！！！！！！存储在EBP-390
006CD458 .  8>lea ecx,dword ptr ss:[ebp-394]
006CD45E .  8>mov eax,dword ptr ds:[esi]
006CD460 .  5>push ecx
006CD461 .  F>push dword ptr ss:[ebp-390]       ;  取刚得到的EBP-390
006CD467 .  F>push dword ptr ss:[ebp-38C]       ;  取EBP-38C
006CD46D .  5>push esi
006CD46E .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-394
006CD471 .  8>mov eax,ebx
006CD473 .  8>sub eax,10                         ;  次数减10
006CD476 .  0>jo stmagic.006CDD28
006CD47C .  8>cmp eax,40
006CD47F .  8>mov dword ptr ss:[ebp-3B0],eax
006CD485 .  7>jb short stmagic.006CD492
006CD487 .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD48C .  8>mov eax,dword ptr ss:[ebp-3B0]
006CD492 >  8>lea edx,dword ptr ss:[ebp-398]
006CD498 .  8>mov ecx,dword ptr ds:[esi]
006CD49A .  5>push edx
006CD49B .  8>mov edx,dword ptr ss:[ebp-4C]
006CD49E .  F>push dword ptr ds:[edx+eax*4]       ;  得到从输入码地址向下的第次数减10的单元格数据
006CD4A1 .  F>push dword ptr ss:[ebp-394]       ;  取刚计算的EBP-394数据
006CD4A7 .  5>push esi
006CD4A8 .  F>call dword ptr ds:[ecx+2C]          ;  存储在EBP-398
006CD4AB .  8>cmp ebx,40
006CD4AE .  7>jb short stmagic.006CD4B5
006CD4B0 .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD4B5 >  8>mov eax,dword ptr ss:[ebp-398]    ;  这里是循环16次之后的    取刚计算好的EBP-398数据
006CD4BB >  8>mov ecx,dword ptr ss:[ebp-4C]
006CD4BE .  8>mov dword ptr ds:[ecx+ebx*4],eax    ;  把31373339储存在EBP-4C段处显示为ASCII“9371”
006CD4C1 .  8>mov eax,dword ptr ds:[esi]          ;  函数指针006D2A84
006CD4C3 .  8>lea ecx,dword ptr ss:[ebp-388]    ;  准备储存在EBP-388
006CD4C9 .  5>push ecx
006CD4CA .  F>push dword ptr ss:[ebp-3C]          ;  取EBP-3C的值
006CD4CD .  5>push esi
006CD4CE .  F>call dword ptr ds:[eax+44]          ;  结果储存在EBP-388中  三次一样的函数只是参数不同处理EBP-3C的数据最后三次异或运算保存在EBP-388中
006CD4D1 .  8>lea ecx,dword ptr ss:[ebp-38C]    ;  准备储存在EBP-38C
006CD4D7 .  8>mov eax,dword ptr ds:[esi]
006CD4D9 .  5>push ecx
006CD4DA .  F>push dword ptr ss:[ebp-388]       ;  取出EBP-388的数据也就是刚才计算出来的
006CD4E0 .  F>push dword ptr ss:[ebp-64]          ;  取EBP-64的值
006CD4E3 .  5>push esi
006CD4E4 .  F>call dword ptr ds:[eax+2C]          ;  储存在EBP-38C中
006CD4E7 .  8>lea ecx,dword ptr ss:[ebp-390]    ;  准备计算结果储存在EBP-390中
006CD4ED .  8>mov eax,dword ptr ds:[esi]
006CD4EF .  5>push ecx
006CD4F0 .  F>push dword ptr ss:[ebp-60]          ;  得到EBP-60的数据
006CD4F3 .  F>push dword ptr ss:[ebp-40]          ;  得到EBP-40的数据
006CD4F6 .  F>push dword ptr ss:[ebp-3C]          ;  得到EBP-3C的数据
006CD4F9 .  5>push esi
006CD4FA .  F>call dword ptr ds:[eax+30]          ;  最后结果保存在EBP-390  若EBP-3C的值与EBP-40的值进行AND运算结果为A若把EBP-3C取反的值与EBP-60的值进行AND运算结果为B最后结果为A XOR B
006CD4FD .  8>lea ecx,dword ptr ss:[ebp-394]    ;  准备计算结果储存在EBP-394中
006CD503 .  8>mov eax,dword ptr ds:[esi]
006CD505 .  5>push ecx
006CD506 .  F>push dword ptr ss:[ebp-390]       ;  取上面刚计算好的EBP-390数据
006CD50C .  F>push dword ptr ss:[ebp-38C]       ;  取上面计算好的EBP-38C数据
006CD512 .  5>push esi
006CD513 .  F>call dword ptr ds:[eax+2C]          ;  结果储存在EBP-394中
006CD516 .  8>cmp ebx,40
006CD519 .  7>jb short stmagic.006CD520
006CD51B .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD520 >  8>lea ecx,dword ptr ss:[ebp-398]    ;  准备储存在EBP-398中
006CD526 .  8>mov eax,dword ptr ds:[esi]
006CD528 .  5>push ecx
006CD529 .  8>mov ecx,dword ptr ds:[esi+7C]       ;  此处得到一个密码表放入ECX中
006CD52C .  F>push dword ptr ds:[ecx+ebx*4]       ;  依次向下取值与趟数有关，第一次取428A2F98，第二次取71374491
006CD52F .  F>push dword ptr ss:[ebp-394]       ;  得到上一次计算处来的值EBP-394的值
006CD535 .  5>push esi
006CD536 .  F>call dword ptr ds:[eax+2C]          ;  储存在EBP-398中
006CD539 .  8>cmp ebx,40
006CD53C .  7>jb short stmagic.006CD543
006CD53E .  E>call <jmp.&MSVBVM60.__vbaGenerateBou>
006CD543 >  8>lea ecx,dword ptr ss:[ebp-39C]    ;  准备储存在EBP-39C中
006CD549 .  8>mov eax,dword ptr ds:[esi]
006CD54B .  5>push ecx
006CD54C .  8>mov ecx,dword ptr ss:[ebp-4C]       ;  得到存放前4位头输入码的ASCII码的地址
006CD54F .  F>push dword ptr ds:[ecx+ebx*4]       ;  第一次就取了前4位头输入码的ASCII码
006CD552 .  F>push dword ptr ss:[ebp-398]       ;  刚计算好的EBP-398的值
006CD558 .  5>push esi
006CD559 .  F>call dword ptr ds:[eax+2C]          ;  储存在EBP-39C中
006CD55C .  8>mov eax,dword ptr ss:[ebp-39C]    ;  得到刚计算好的EBP-39C数据
006CD562 .  8>lea ecx,dword ptr ss:[ebp-388]    ;  得到EBP-388的地址  储存覆盖EBP-388
006CD568 .  5>push ecx
006CD569 .  8>mov dword ptr ss:[ebp-2C],eax       ;  把EBP-39C数据放在EBP-24段的空挡－－EBP-2C处
006CD56C .  F>push dword ptr ss:[ebp-24]          ;  得到EBP-24的值
006CD56F .  8>mov eax,dword ptr ds:[esi]
006CD571 .  5>push esi
006CD572 .  F>call dword ptr ds:[eax+40]          ;  储存覆盖EBP-388
006CD575 .  8>lea ecx,dword ptr ss:[ebp-38C]    ;  得到EBP-38C的地址，准备覆盖EBP-38C
006CD57B .  8>mov eax,dword ptr ds:[esi]
006CD57D .  5>push ecx
006CD57E .  F>push dword ptr ss:[ebp-30]          ;  得到EBP-30的数据
006CD581 .  F>push dword ptr ss:[ebp-28]          ;  得到EBP-28的数据
006CD584 .  F>push dword ptr ss:[ebp-24]          ;  得到EBP-24的数据
006CD587 .  5>push esi
006CD588 .  F>call dword ptr ds:[eax+34]          ;  储存在EBP-38C中
006CD58B .  8>lea ecx,dword ptr ss:[ebp-390]    ;  准备保存在EBP-390
006CD591 .  8>mov eax,dword ptr ds:[esi]
006CD593 .  5>push ecx
006CD594 .  F>push dword ptr ss:[ebp-38C]       ;  取EBP-38C的数据
006CD59A .  F>push dword ptr ss:[ebp-388]       ;  取EBP-388的数据
006CD5A0 .  5>push esi
006CD5A1 .  F>call dword ptr ds:[eax+2C]          ;  储存在EBP-390中  到这里为止还没改变EBP-24段的数据
006CD5A4 .  8>mov eax,dword ptr ss:[ebp-390]    ;  得到刚算好的EBP-390的数据
006CD5AA .  8>lea ecx,dword ptr ss:[ebp-388]    ;  又得到EBP-388地址又要改变EBP-388数据？
006CD5B0 .  8>mov dword ptr ss:[ebp-34],eax       ;  把EBP-390数据放在EBP-24段的空挡－－EBP-34处
006CD5B3 .  8>mov eax,dword ptr ss:[ebp-60]
006CD5B6 .  8>mov dword ptr ss:[ebp-64],eax       ;  开始改变EBP-24段了！！把EBP-60数据给了EBP-64倒数第2个数据给了倒数第一个数据
006CD5B9 .  8>mov eax,dword ptr ss:[ebp-40]
006CD5BC .  5>push ecx
006CD5BD .  8>mov dword ptr ss:[ebp-60],eax       ;  又改变EBP-24段了，EBP-40的数据给了EBP-60倒数第3个数据给了倒数第2个数据
006CD5C0 .  F>push dword ptr ss:[ebp-2C]          ;  取EBP-2C的数据也就是第一次EBP-39C
006CD5C3 .  8>mov eax,dword ptr ss:[ebp-3C]
006CD5C6 .  8>mov dword ptr ss:[ebp-40],eax       ;  又改变EBP-24段了，EBP-3C的数据给了EBP-40倒数第4个数据给了倒数第3个数据
006CD5C9 .  8>mov eax,dword ptr ds:[esi]
006CD5CB .  F>push dword ptr ss:[ebp-38]          ;  取EBP-38的数据
006CD5CE .  5>push esi
006CD5CF .  F>call dword ptr ds:[eax+2C]
006CD5D2 .  8>mov eax,dword ptr ss:[ebp-388]    ;  取刚才计算出来的值EBP-388
006CD5D8 .  8>lea ecx,dword ptr ss:[ebp-388]    ;  又得到EBP-388地址又要改变EBP-388数据？
006CD5DE .  8>mov dword ptr ss:[ebp-3C],eax       ;  又改变EBP-24段了  EBP-388的数据给了EBP-3C
006CD5E1 .  8>mov eax,dword ptr ss:[ebp-30]
006CD5E4 .  8>mov dword ptr ss:[ebp-38],eax       ;  又改变EBP-24段了  EBP-30的数据给了EBP-38
006CD5E7 .  8>mov eax,dword ptr ss:[ebp-28]
006CD5EA .  5>push ecx
006CD5EB .  8>mov dword ptr ss:[ebp-30],eax       ;  又改变EBP-24段了  EBP-28的数据给了EBP-30
006CD5EE .  F>push dword ptr ss:[ebp-34]          ;  得到EBP-34的值，这个是原来EBP-390
006CD5F1 .  8>mov eax,dword ptr ss:[ebp-24]
006CD5F4 .  8>mov dword ptr ss:[ebp-28],eax       ;  又改变EBP-24段了  EBP-24的数据给了EBP-28
006CD5F7 .  8>mov eax,dword ptr ds:[esi]
006CD5F9 .  F>push dword ptr ss:[ebp-2C]          ;  得到EBP-2C的数据就是EBP-39C
006CD5FC .  5>push esi
006CD5FD .  F>call dword ptr ds:[eax+2C]
006CD600 .  8>mov eax,dword ptr ss:[ebp-388]    ;  得到刚计算好的EBP-388的数据
006CD606 .  6>push 1
006CD608 .  8>mov dword ptr ss:[ebp-24],eax       ;  又改变EBP-24段了  EBP-388的数据给了EBP-24
006CD60B .  5>pop eax
006CD60C .  0>add eax,ebx                         ;  次数的累加
006CD60E .  0>jo stmagic.006CDD28
006CD614 .  8>mov ebx,eax                         ;  让EBX存放次数
006CD616 .  8>mov eax,dword ptr ss:[ebp-70]
006CD619 .^ E>jmp stmagic.006CD381
006CD61E >  8>lea edx,dword ptr ss:[ebp-388]    ;  上面计算好的中间伪注册码
006CD624 .  8>mov ecx,dword ptr ds:[esi]
006CD626 .  5>push edx
006CD627 .  F>push dword ptr ds:[eax]             ;  出现固定值表地址，也就是给上面用于开始计算的取第一值
006CD629 .  F>push dword ptr ss:[ebp-24]          ;  取刚计算好EBP-24段的值第0位
006CD62C .  5>push esi
006CD62D .  F>call dword ptr ds:[ecx+2C]          ;  运算后保存在EBP-388处
006CD630 .  8>mov eax,dword ptr ss:[ebp-70]
006CD633 .  8>mov ecx,dword ptr ss:[ebp-388]    ;  取出来刚计算好的储存在，用于开始上计算的固定值处注册码
006CD639 .  8>mov dword ptr ds:[eax],ecx          ;  存储注册码
006CD63B .  8>lea ecx,dword ptr ss:[ebp-388]
006CD641 .  5>push ecx
006CD642 .  8>mov ecx,dword ptr ss:[ebp-70]
006CD645 .  8>mov eax,dword ptr ds:[esi]
006CD647 .  F>push dword ptr ds:[ecx+4]          ;  取，初始循环值的下一位
006CD64A .  F>push dword ptr ss:[ebp-28]          ;  取计算好的EBP-28  第1位
006CD64D .  5>push esi
006CD64E .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD651 .  8>mov eax,dword ptr ss:[ebp-70]
006CD654 .  8>mov ecx,dword ptr ss:[ebp-388]    ;  计算好的
006CD65A .  8>mov dword ptr ds:[eax+4],ecx       ;  存储注册码
006CD65D .  8>lea ecx,dword ptr ss:[ebp-388]
006CD663 .  5>push ecx
006CD664 .  8>mov ecx,dword ptr ss:[ebp-70]
006CD667 .  8>mov eax,dword ptr ds:[esi]
006CD669 .  F>push dword ptr ds:[ecx+8]          ;  依次取，初始循环值的下一位
006CD66C .  F>push dword ptr ss:[ebp-30]          ;  取计算好的EBP-30  第3位
006CD66F .  5>push esi
006CD670 .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD673 .  8>mov eax,dword ptr ss:[ebp-70]
006CD676 .  8>mov ecx,dword ptr ss:[ebp-388]
006CD67C .  8>mov dword ptr ds:[eax+8],ecx       ;  存储注册码
006CD67F .  8>lea ecx,dword ptr ss:[ebp-388]
006CD685 .  5>push ecx
006CD686 .  8>mov ecx,dword ptr ss:[ebp-70]
006CD689 .  8>mov eax,dword ptr ds:[esi]
006CD68B .  F>push dword ptr ds:[ecx+C]          ;  依次取，初始循环值的下一位
006CD68E .  F>push dword ptr ss:[ebp-38]          ;  取计算好的EBP-38  第5位
006CD691 .  5>push esi
006CD692 .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD695 .  8>mov eax,dword ptr ss:[ebp-70]
006CD698 .  8>mov ecx,dword ptr ss:[ebp-388]
006CD69E .  8>mov dword ptr ds:[eax+C],ecx       ;  存储注册码
006CD6A1 .  8>lea ecx,dword ptr ss:[ebp-388]
006CD6A7 .  5>push ecx
006CD6A8 .  8>mov ecx,dword ptr ss:[ebp-70]
006CD6AB .  8>mov eax,dword ptr ds:[esi]
006CD6AD .  F>push dword ptr ds:[ecx+10]          ;  依次取，初始循环值的下一位
006CD6B0 .  F>push dword ptr ss:[ebp-3C]          ;  取计算好的EBP-3C  第6位
006CD6B3 .  5>push esi
006CD6B4 .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD6B7 .  8>mov eax,dword ptr ss:[ebp-70]
006CD6BA .  8>mov ecx,dword ptr ss:[ebp-388]
006CD6C0 .  8>mov dword ptr ds:[eax+10],ecx       ;  存储注册码
006CD6C3 .  8>lea ecx,dword ptr ss:[ebp-388]
006CD6C9 .  5>push ecx
006CD6CA .  8>mov ecx,dword ptr ss:[ebp-70]
006CD6CD .  8>mov eax,dword ptr ds:[esi]
006CD6CF .  F>push dword ptr ds:[ecx+14]          ;  依次取，初始循环值的下一位
006CD6D2 .  F>push dword ptr ss:[ebp-40]          ;  取计算好的EBP-40  第7位
006CD6D5 .  5>push esi
006CD6D6 .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD6D9 .  8>mov eax,dword ptr ss:[ebp-70]
006CD6DC .  8>mov ecx,dword ptr ss:[ebp-388]
006CD6E2 .  8>mov dword ptr ds:[eax+14],ecx       ;  存储注册码
006CD6E5 .  8>lea ecx,dword ptr ss:[ebp-388]
006CD6EB .  5>push ecx
006CD6EC .  8>mov ecx,dword ptr ss:[ebp-70]
006CD6EF .  8>mov eax,dword ptr ds:[esi]
006CD6F1 .  F>push dword ptr ds:[ecx+18]          ;  依次取，初始循环值的下一位
006CD6F4 .  F>push dword ptr ss:[ebp-60]          ;  取计算好的EBP-60  第8位
006CD6F7 .  5>push esi
006CD6F8 .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD6FB .  8>mov eax,dword ptr ss:[ebp-70]
006CD6FE .  8>mov ecx,dword ptr ss:[ebp-388]
006CD704 .  8>mov dword ptr ds:[eax+18],ecx       ;  存储注册码
006CD707 .  8>mov eax,dword ptr ds:[esi]
006CD709 .  8>lea ecx,dword ptr ss:[ebp-388]
006CD70F .  5>push ecx
006CD710 .  8>mov ecx,dword ptr ss:[ebp-70]
006CD713 .  F>push dword ptr ds:[ecx+1C]          ;  依次取，初始循环值的下一位
006CD716 .  F>push dword ptr ss:[ebp-64]          ;  取计算好的EBP-64  第9位
006CD719 .  5>push esi
006CD71A .  F>call dword ptr ds:[eax+2C]          ;  存储在EBP-388
006CD71D .  8>mov ecx,dword ptr ss:[ebp-70]
006CD720 .  8>mov eax,dword ptr ss:[ebp-388]
006CD726 .  6>push 10
006CD728 .  8>mov dword ptr ds:[ecx+1C],eax       ;  存储注册码
………………………………………………………………………………………………………………………………
第1次函数参数1＝EBP-3C 储存在：EBP-388
第一次：将EBP-3C的值进行与3FFFFFFE进行与允许后除以固定值40，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果02000000与上面算出来的进行OR运算
第二次：EBP-3C的整个值与固定值第一次是20测试若不为0：用固定值第一次1F与EBP-3C的值进行AND运算，这个结果再与第一次固定值04000000进行IMUL运算，结果再与80000000进行或运算。
      EBP-3C的整个值与固定值第一次是20测试若为0 ：用固定值第一次3F与EBP-3C的值进行AND运算，这个结果再与第一次固定值04000000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将EBP-3C的值进行与3FFFFFFE进行与允许后除以固定值800，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00100000与上面算出来的进行OR运算
第二次：EBP-3C的整个值与固定值第二次是400测试若不为0：用固定值第二次3FF与EBP-3C的值进行AND运算，这个结果再与第二次固定值00200000进行IMUL运算，结果再与80000000进行或运算。
      EBP-3C的整个值与固定值第二次是400测试若为0  ：用固定值第二次7FF与EBP-3C的值进行AND运算，这个结果再与第二次固定值00200000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将EBP-3C的值进行与3FFFFFFE进行与允许后除以固定值02000000，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00000040与上面算出来的进行OR运算
第二次：EBP-3C的整个值与固定值第三次是01000000测试若不为0：用固定值第三次00FFFFFF与EBP-3C的值进行AND运算，这个结果再与第三次固定值00000080进行IMUL运算，结果再与80000000进行或运算。
      EBP-3C的整个值与固定值第三次是01000000测试若为0  ：用固定值第三次01FFFFFF与EBP-3C的值进行AND运算，这个结果再与第二次固定值00000080进行IMUL运算，
两次得到的结果进行OR运算。
最后三次异或运算。

第2个函数：参数1＝EBP-64    参数2＝EBP-388 储存在EBP-38C
若EBP-64的值与80000000进行与运算的结果为A
若EBP-388的值与80000000进行与运算的结果为B
若EBP-64的值与3FFFFFFF与运算加上EBP-388的值与3FFFFFFF与运算的结果为C
若EBP-64的值与40000000与运算的结果D
若EBP-388的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第3个函数：参数1＝EBP-3C    参数2＝EBP-40  参数2＝EBP-60 储存在EBP-390
若EBP-3C的值与EBP-40的值进行AND运算结果为A
若把EBP-3C取反的值与EBP-60的值进行AND运算结果为B
最后结果为A XOR B

第4个函数：参数1＝EBP-38C    参数2＝EBP-390 储存在EBP-394
若EBP-38C的值与80000000进行与运算的结果为A
若EBP-390的值与80000000进行与运算的结果为B
若EBP-38C的值与3FFFFFFF与运算加上EBP-390的值与3FFFFFFF与运算的结果为C
若EBP-38C的值与40000000与运算的结果D
若EBP-390的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第5个函数：参数1＝趟数取值参数2＝EBP-394的值储存在EBP-398
若趟数取值的值与80000000进行与运算的结果为A
若EBP-394的值与80000000进行与运算的结果为B
若趟数取值的值与3FFFFFFF与运算加上EBP-394的值与3FFFFFFF与运算的结果为C
若趟数取值的值与40000000与运算的结果D
若EBP-394的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第6个函数：参数1＝输入码地址向下次数个单元格内数据参数2＝EBP-398的值储存在EBP-39C
若前4位头输入码的值与80000000进行与运算的结果为A
若EBP-398的值与80000000进行与运算的结果为B
若前4位头输入码的值与3FFFFFFF与运算加上EBP-398的值与3FFFFFFF与运算的结果为C
若前4位头输入码的值与40000000与运算的结果D
若EBP-398的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第7次函数参数1＝EBP-24 储存在：EBP-388
第一次：将EBP-24的值进行与3FFFFFFE进行与允许后除以固定值4，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果20000000与上面算出来的进行OR运算
第二次：EBP-24的整个值与固定值第一次是00000002测试若不为0：用固定值第一次00000001与EBP-24的值进行AND运算，这个结果再与第一次固定值40000000进行IMUL运算，结果再与80000000进行或运算。
      EBP-24的整个值与固定值第一次是00000002测试若为0 ：用固定值第一次00000003与EBP-24的值进行AND运算，这个结果再与第一次固定值40000000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将EBP-24的值进行与3FFFFFFE进行与允许后除以固定值00002000，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00040000与上面算出来的进行OR运算
第二次：EBP-24的整个值与固定值第二次是00001000测试若不为0：用固定值第二次00000FFF与EBP-24的值进行AND运算，这个结果再与第二次固定值00080000进行IMUL运算，结果再与80000000进行或运算。
      EBP-24的整个值与固定值第二次是00001000测试若为0  ：用固定值第二次00001FFF与EBP-24的值进行AND运算，这个结果再与第二次固定值00080000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将EBP-24的值进行与3FFFFFFE进行与允许后除以固定值00400000，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00000200与上面算出来的进行OR运算
第二次：EBP-24的整个值与固定值第三次是00200000测试若不为0：用固定值第三次001FFFFF与EBP-24的值进行AND运算，这个结果再与第三次固定值00000400进行IMUL运算，结果再与80000000进行或运算。
      EBP-24的整个值与固定值第三次是00200000测试若为0  ：用固定值第三次003FFFFF与EBP-24的值进行AND运算，这个结果再与第二次固定值00000400进行IMUL运算，
两次得到的结果进行OR运算。
最后三次异或运算。

第8个函数：参数1＝EBP-30 参数2＝EBP-28 参数3＝EBP-24 储存在EBP-38C中
若得到EBP-28的值与EBP-30的值AND运算的结果为A
若得到EBP-28的值与EBP-30的值XOR运算的结果为B
B与EBP-24的值进行AND运算结果为C
最后结果为:C与A进行XOR运算

第9个函数：参数1＝EBP-38C 参数2＝EBP-388 储存在EBP-390
若EBP-388的值与80000000进行与运算的结果为A
若EBP-38C的值与80000000进行与运算的结果为B
若EBP-388的值与3FFFFFFF与运算加上EBP-38C的值与3FFFFFFF与运算的结果为C
若EBP-388的值与40000000与运算的结果D
若EBP-38C的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第10个函数：参数1＝EBP-2C也就是EBP-39C 参数2＝EBP-38 储存在EBP-388 ?????
若EBP-38的值与80000000进行与运算的结果为A
若EBP-2C的值与80000000进行与运算的结果为B
若EBP-38的值与3FFFFFFF与运算加上EBP-2C的值与3FFFFFFF与运算的结果为C
若EBP-38的值与40000000与运算的结果D
若EBP-2C的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第11个函数：参数1＝EBP-2C也就是EBP-39C 参数2＝EBP-34 储存在EBP-388
若EBP-2C的值与80000000进行与运算的结果为A
若EBP-34的值与80000000进行与运算的结果为B
若EBP-2C的值与3FFFFFFF与运算加上EBP-34的值与3FFFFFFF与运算的结果为C
若EBP-2C的值与40000000与运算的结果D
若EBP-34的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

10次循环以后的函数加在上面函数的前面！！！
第1个函数：
参数＝取输入码向下加次数-2单元格的数据若地址为DIZHI，    存储在EBP-388
第一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00020000，如果DIZHI的开头两位数与80与运算不为0得到固定的结果00004000与上面算出来的进行OR运算
第二次：DIZHI的整个值与固定值第一次是00010000测试若不为0：用固定值第一次0000FFFF与DIZHI的值进行AND运算，这个结果再与第一次固定值00008000进行IMUL运算，结果再与80000000进行或运算。
      DIZHI的整个值与固定值第一次是00010000测试若为0：用固定值第一次0001FFFF与DIZHI的值进行AND运算，这个结果再与第一次固定值00008000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00080000，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00001000与上面算出来的进行OR运算
第二次：DIZHI的整个值与固定值第二次是00040000测试若不为0：用固定值第二次0003FFFF与DIZHI的值进行AND运算，这个结果再与第二次固定值00002000进行IMUL运算，结果再与80000000进行或运算。
      DIZHI的整个值与固定值第二次是00040000测试若为0  ：用固定值第二次0007FFFF与DIZHI的值进行AND运算，这个结果再与第二次固定值00002000进行IMUL运算
两次得到的结果进行OR运算。

第三次：只有一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00000400，如果DIZHI的开头两位数与80与运算不为0得到固定的结果00200000与上面算出来的进行OR运算

最后三次异或运算。

函数的最后结果为0  所以EBP-388结果为0 只有第2次有结果，

第2个函数：
参数1＝取输入码向下加次数-7单元格的数据若地址为A，
参数2＝EBP-388
保存在EBP-38C中
若A的值与80000000进行与运算的结果为A
若EBP-388的值与80000000进行与运算的结果为B
若A的值与3FFFFFFF与运算加上EBP-388的值与3FFFFFFF与运算的结果为C
若A的值与40000000与运算的结果D
若EBP-388的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第3个函数：
参数＝取输入码向下加次数-F单元格的数据若地址为DIZHI，    存储在EBP-390
第一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00000080，如果DIZHI的开头两位数与80与运算不为0得到固定的结果01000000与上面算出来的进行OR运算
第二次：DIZHI的整个值与固定值第一次是00000040测试若不为0：用固定值第一次0000003F与DIZHI的值进行AND运算，这个结果再与第一次固定值02000000进行IMUL运算，结果再与80000000进行或运算。
      DIZHI的整个值与固定值第一次是00000040测试若为0：用固定值第一次0000007F与DIZHI的值进行AND运算，这个结果再与第一次固定值02000000进行IMUL运算
两次得到的结果进行OR运算。

第一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00040000，如果EBP-3C的开头两位数与80与运算不为0得到固定的结果00002000与上面算出来的进行OR运算
第二次：DIZHI的整个值与固定值第二次是00020000测试若不为0：用固定值第二次0001FFFF与DIZHI的值进行AND运算，这个结果再与第二次固定值00004000进行IMUL运算，结果再与80000000进行或运算。
      DIZHI的整个值与固定值第二次是00020000测试若为0  ：用固定值第二次0003FFFF与DIZHI的值进行AND运算，这个结果再与第二次固定值00004000进行IMUL运算
两次得到的结果进行OR运算。

第三次：只有一次：将DIZHI的值进行与3FFFFFFE进行与允许后除以固定值00000008，如果DIZHI的开头两位数与80与运算不为0得到固定的结果10000000与上面算出来的进行OR运算

最后三次异或运算。

第4个函数：
参数1＝EBP-390 参数2＝EBP-38C    存储在EBP-394
若EBP-390的值与80000000进行与运算的结果为A
若EBP-38C的值与80000000进行与运算的结果为B
若EBP-390的值与3FFFFFFF与运算加上EBP-38C的值与3FFFFFFF与运算的结果为C
若EBP-390的值与40000000与运算的结果D
若EBP-38C的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

第5个函数：
参数1＝从输入码地址向下的第次数减10的单元格数据  若这个为DIZHI
参数2＝EBP-394
存储地址：EBP-398
若DIZHI的值与80000000进行与运算的结果为A
若EBP-394的值与80000000进行与运算的结果为B
若EBP-DIZHI的值与3FFFFFFF与运算加上EBP-394的值与3FFFFFFF与运算的结果为C
若EBP-DIZHI的值与40000000与运算的结果D
若EBP-394的值与40000000与运算的结果为E
D与E进行AND运算，若结果不等于0 ：则最后结果为C XOR B XOR A XOR 80000000
D与E进行OR运算，若结果等于0 ：则最后结果为C XOR B XOR A
若C与40000000 AND运算结果为F
若F等于0：                      则最后结果为C XOR B XOR A XOR 40000000
若F不等于0：                   则最后结果为C XOR B XOR A XOR C0000000

最后把得到的最终结果EBP-398的值放入存放输入码地址向下第次数个单元格内！！！
用于上面第6个函数调用！！

………………………………………………………………………………………………………………………………

附：
main (  )
{long int zhjian[6];
int len,shang,j,i,k;
long int l;
static long int jisuan[30];
static long int shuruma[30];
char jianpan[30];
static long int zuizong[10]={0x6A09E667,0xBB67AE85,0x0,0x3C6EF372,0x0,0xA54FF53A,0x510E527F,0x9B05688C,0x1F83D9AB,0x5BE0CD19};
static long int zhucema[8]={0x6A09E667,0xBB67AE85,0x3C6EF372,0xA54FF53A,0x510E527F,0x9B05688C,0x1F83D9AB,0x5BE0CD19};
static long int mimabiao[64]={
0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,
0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,
0xE49B69C1,0xEFBE4786,0x0FC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,
0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x06CA6351,0x14292967,
0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,
0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,
0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,
0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2
};

scanf("%s",jianpan);
len=strlen(jianpan);
shang=len/4;
for(i=0;i<shang;i++)
{
for(j=0;j<4;j++)
{
k=j+i*4;
jisuan[k]=jisuan[k]|jianpan[k];
jisuan[k]=jisuan[k]<<(24-j*8);
shuruma[i]=shuruma[i]|jisuan[k];
}
}

shuruma[shang]=0x80000000;

shuruma[15]=0x40;

for(i=0;i<0x40;i++)
{
if(i>=0x10)
{
fun21(shuruma[i-2],zhjian);
fun(shuruma[i-7],zhjian[0],zhjian+1);
fun23(shuruma[i-0xf],zhjian+2);
fun(zhjian[2],zhjian[1],zhjian+3);
fun(shuruma[i-0x10],zhjian[3],zhjian+4);
shuruma[i]=zhjian[4];
}

fun1(zuizong[6],zhjian);
fun(zuizong[9],zhjian[0],zhjian+1);
fun3(zuizong[6],zuizong[7],zuizong[8],zhjian+2);
fun(zhjian[1],zhjian[2],zhjian+3);
fun(mimabiao[i],zhjian[3],zhjian+4);
fun(shuruma[i],zhjian[4],zhjian+5);
zuizong[2]=zhjian[5];
fun7(zuizong[0],zhjian);
fun8(zuizong[3],zuizong[1],zuizong[0],zhjian+1);
fun(zhjian[1],zhjian[0],zhjian+2);
zuizong[4]=zhjian[2];
zuizong[9]=zuizong[8];
zuizong[8]=zuizong[7];
zuizong[7]=zuizong[6];
fun(zuizong[2],zuizong[5],zhjian);
zuizong[6]=zhjian[0];
zuizong[5]=zuizong[3];
zuizong[3]=zuizong[1];
zuizong[1]=zuizong[0];
fun(zuizong[2],zuizong[4],zhjian);
zuizong[0]=zhjian[0];
}
fun(zuizong[0],zhucema[0],zhucema);
fun(zuizong[1],zhucema[1],zhucema+1);
fun(zuizong[3],zhucema[2],zhucema+2);
fun(zuizong[5],zhucema[3],zhucema+3);
fun(zuizong[6],zhucema[4],zhucema+4);
fun(zuizong[7],zhucema[5],zhucema+5);
fun(zuizong[8],zhucema[6],zhucema+6);
fun(zuizong[9],zhucema[7],zhucema+7);
zhucema[2]=zhucema[2]>>16;
l=0x0000ffff;
zhucema[2]=zhucema[2]&l;
printf("%c%lx-%c%lx-%c%lx-%c-%c-%c%c%c",jianpan[0],zhucema[0],jianpan[1],zhucema[1],
jianpan[2],zhucema[2],jianpan[3],jianpan[4],jianpan[5],jianpan[6],jianpan[7]);

}

fun1 (x,p)
long int x,*p;
{long int bian1,bian2,bian3,biana;
bian1=(x&0x7ffffffe)/0x40;
if((x&0xff000000)&0x80000000)
{bian1=bian1|0x02000000;}
if(x&0x20)
{biana=((x&0x1f)*0x04000000)|0x80000000;}
else
{biana=(x&0x3f)*0x04000000;}
bian1=bian1|biana;

bian2=(x&0x7ffffffe)/0x800;
if((x&0xff000000)&0x80000000)
{bian2=bian2|0x00100000;}
if(x&0x400)
{biana=((x&0x3ff)*0x00200000)|0x80000000;}
else
{biana=(x&0x7ff)*0x00200000;}
bian2=bian2|biana;

bian3=(x&0x7ffffffe)/0x02000000;
if((x&0xff000000)&0x80000000)
{bian3=bian3|0x40;}
if(x&0x01000000)
{biana=((x&0x00ffffff)*0x80)|0x80000000;}
else
{biana=(x&0x01ffffff)*0x80;}
bian3=bian3|biana;

*p=bian1^bian2^bian3;
}

fun (x,y,p)
long int x,y,*p;
{long int a,b,c,d,e;
a=x&0x80000000;
b=y&0x80000000;
c=(x&0x3fffffff)+(y&0x3fffffff);
d=x&0x40000000;
e=y&0x40000000;
if(d&e)
{*p=c^b^a^0x80000000;return;}
if(!(d|e))
{*p=c^b^a;return;}
if(c&0x40000000)
{*p=c^b^a^0xc0000000;return;}
else
{*p=c^b^a^0x40000000;return;}
}

fun3 (x,y,z,p)
long int x,y,z,*p;
{long int a,b;
a=x&y;
b=(~x)&z;
*p=a^b;
}

fun7 (x,p)
long int x,*p;
{long int bian1,bian2,bian3,biana;
bian1=(x&0x7ffffffe)/0x4;
if((x&0xff000000)&0x80000000)
{bian1=bian1|0x20000000;}
if(x&0x2)
{biana=((x&0x1)*0x40000000)|0x80000000;}
else
{biana=(x&0x3)*0x40000000;}
bian1=bian1|biana;

bian2=(x&0x7ffffffe)/0x00002000;
if((x&0xff000000)&0x80000000)
{bian2=bian2|0x00040000;}
if(x&0x00001000)
{biana=((x&0xfff)*0x00080000)|0x80000000;}
else
{biana=(x&0x1fff)*0x00080000;}
bian2=bian2|biana;

bian3=(x&0x7ffffffe)/0x00400000;
if((x&0xff000000)&0x80000000)
{bian3=bian3|0x200;}
if(x&0x00200000)
{biana=((x&0x001fffff)*0x400)|0x80000000;}
else
{biana=(x&0x003fffff)*0x400;}
bian3=bian3|biana;

*p=bian1^bian2^bian3;
}

fun8 (x,y,z,p)
long int x,y,z,*p;
{long int a,b,c;
a=y&x;
b=y^x;
c=b&z;
*p=c^a;
}

fun21 (x,p)
long int x,*p;
{long int bian1,bian2,bian3,biana;
bian1=(x&0x7ffffffe)/0x00020000;
if((x&0xff000000)&0x80000000)
{bian1=bian1|0x00004000;}
if(x&0x00010000)
{biana=((x&0x0000ffff)*0x00008000)|0x80000000;}
else
{biana=(x&0x0001ffff)*0x00008000;}
bian1=bian1|biana;

bian2=(x&0x7ffffffe)/0x00080000;
if((x&0xff000000)&0x80000000)
{bian2=bian2|0x00001000;}
if(x&0x00040000)
{biana=((x&0x0003ffff)*0x00002000)|0x80000000;}
else
{biana=(x&0x0007ffff)*0x00002000;}
bian2=bian2|biana;

bian3=(x&0x7ffffffe)/0x400;
if((x&0xff000000)&0x80000000)
{bian3=bian3|0x00200000;}

*p=bian1^bian2^bian3;
}

fun23 (x,p)
long int x,*p;
{long int bian1,bian2,bian3,biana;
bian1=(x&0x7ffffffe)/0x80;
if((x&0xff000000)&0x80000000)
{bian1=bian1|0x01000000;}
if(x&0x40)
{biana=((x&0x3f)*0x02000000)|0x80000000;}
else
{biana=(x&0x7f)*0x02000000;}
bian1=bian1|biana;

bian2=(x&0x7ffffffe)/0x00040000;
if((x&0xff000000)&0x80000000)
{bian2=bian2|0x00002000;}
if(x&0x00020000)
{biana=((x&0x0001ffff)*0x00004000)|0x80000000;}
else
{biana=(x&0x0003ffff)*0x00004000;}
bian2=bian2|biana;

bian3=(x&0x7ffffffe)/0x8;
if((x&0xff000000)&0x80000000)
{bian3=bian3|0x10000000;}

*p=bian1^bian2^bian3;
}

请输入8位！！

登录后可查看完整内容

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课

收藏・0

免费・7

支持

最新回复 (6)
shuair 雪币： 151 活跃值： (66) 能力值： ( LV6，RANK：90 ) 在线值：发帖 14 回帖 220 粉丝 0 关注私信	shuair 2 2 楼强!~~~~~~~ 高手!~~~~~~~~` 看的出来功底好强~~ 羡慕%%有机会教我两手!~ 2005-4-7 14:37 0
liyangsj 雪币： 328 活跃值： (925) 能力值： ( LV9，RANK：1010 ) 在线值：发帖 34 回帖 195 粉丝 0 关注私信	liyangsj 25 3 楼过奖，互相学习！ 2005-4-7 16:34 0
ljy3282393 雪币： 214 活跃值： (15) 能力值： ( LV4，RANK：50 ) 在线值：发帖 2 回帖 426 粉丝 1 关注私信	ljy3282393 1 4 楼楼主：什么是暂停法?能否详细讲解一下?谢谢！ 2005-4-7 21:37 0
萝卜雪币： 260 活跃值： (81) 能力值： ( LV4，RANK：50 ) 在线值：发帖 48 回帖 833 粉丝 2 关注私信	萝卜 1 5 楼支持！！ 2005-4-7 21:50 0
zmw1224 雪币： 244 活跃值： (265) 能力值： ( LV9，RANK：250 ) 在线值：发帖 8 回帖 86 粉丝 0 关注私信	zmw1224 6 6 楼晕啊，天大的算法 2005-4-7 22:42 0
snow 雪币： 200 活跃值： (29) 能力值： ( LV2，RANK：10 ) 在线值：发帖 8 回帖 52 粉丝 0 关注私信	snow 7 楼好。。。这个软件。俺去半年前就开始分析他。只可惜。俺没有搞定他。现有终于有人有那成果。。俺得好好的分析。学习一下。。。俺也得谢谢这位老兄了。。 2005-4-18 03:51 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

liyangsj

发帖

195

回帖

1010

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (6)
shuair 雪币： 151 活跃值： (66) 能力值： ( LV6，RANK：90 ) 在线值：发帖 14 回帖 220 粉丝 0 关注私信	shuair 2 2 楼强!~~~~~~~ 高手!~~~~~~~~` 看的出来功底好强~~ 羡慕%%有机会教我两手!~ 2005-4-7 14:37 0
liyangsj 雪币： 328 活跃值： (925) 能力值： ( LV9，RANK：1010 ) 在线值：发帖 34 回帖 195 粉丝 0 关注私信	liyangsj 25 3 楼过奖，互相学习！ 2005-4-7 16:34 0
ljy3282393 雪币： 214 活跃值： (15) 能力值： ( LV4，RANK：50 ) 在线值：发帖 2 回帖 426 粉丝 1 关注私信	ljy3282393 1 4 楼楼主：什么是暂停法?能否详细讲解一下?谢谢！ 2005-4-7 21:37 0
萝卜雪币： 260 活跃值： (81) 能力值： ( LV4，RANK：50 ) 在线值：发帖 48 回帖 833 粉丝 2 关注私信	萝卜 1 5 楼支持！！ 2005-4-7 21:50 0
zmw1224 雪币： 244 活跃值： (265) 能力值： ( LV9，RANK：250 ) 在线值：发帖 8 回帖 86 粉丝 0 关注私信	zmw1224 6 6 楼晕啊，天大的算法 2005-4-7 22:42 0
snow 雪币： 200 活跃值： (29) 能力值： ( LV2，RANK：10 ) 在线值：发帖 8 回帖 52 粉丝 0 关注私信	snow 7 楼好。。。这个软件。俺去半年前就开始分析他。只可惜。俺没有搞定他。现有终于有人有那成果。。俺得好好的分析。学习一下。。。俺也得谢谢这位老兄了。。 2005-4-18 03:51 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复