AI_Generic proc sub esp, 50h ; Integer Subtraction push ebx mov ebx, [esp+5Ch] push ebp mov ebp, 1 cmp ebx, ebp ; Compare Two Operands push esi mov esi, ecx jnz loc_409626 ; Jump if Not Zero (ZF=0) cmp dword ptr DS:[450BACh], ebp ; Compare Two Operands jnz loc_409626 ; Jump if Not Zero (ZF=0) mov eax, [esp+60h] mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0CDh] ; Move with Zero-Extend mov [ecx+0C6h], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0CEh] ; Move with Zero-Extend mov [ecx+0C7h], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0CFh] ; Move with Zero-Extend mov [ecx+0C8h], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0D0h] ; Move with Zero-Extend mov [ecx+0C9h], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0D1h] ; Move with Zero-Extend mov [ecx+0CAh], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0D2h] ; Move with Zero-Extend mov [ecx+0CBh], dl mov ecx, [esi+eax*4+194h] movzx edx, byte ptr [ecx+0D3h] ; Move with Zero-Extend mov [ecx+0CCh], dl mov ecx, [esi+eax*4+194h] mov byte ptr [ecx+0D3h], 0 mov edx, [esi+eax*4+194h] mov byte ptr [edx+0D2h], 0 mov ecx, [esi+eax*4+194h] mov byte ptr [ecx+0D1h], 0 mov edx, [esi+eax*4+194h] mov byte ptr [edx+0CEh], 0 mov ecx, [esi+eax*4+194h] mov byte ptr [ecx+0CDh], 0 mov edx, [esi+eax*4+194h] mov byte ptr [edx+0CFh], 0 mov ecx, [esi+eax*4+194h] mov byte ptr [ecx+0D0h], 0 mov edx, [esi+eax*4+194h] mov byte ptr [edx+0D0h], 1 mov ecx, [esi+eax*4+194h] mov byte ptr [ecx+0C9h], 0 mov edx, [esi+eax*4+194h] cmp [edx+3F4h], ebp ; Compare Two Operands jnz loc_40BBEA ; Jump if Not Zero (ZF=0) mov ecx, edx mov byte ptr [ecx+0CAh], 0 mov edx, [esi+eax*4+194h] pop esi pop ebp mov byte ptr [edx+0D1h], 1 pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_409626: ; CODE XREF: sub_4094C0+13j ; sub_4094C0+1Fj push edi mov edi, [esp+64h] mov eax, [esi+edi*4+194h] cmp dword ptr [eax+3FCh], 0FFFFFC18h ; Compare Two Operands jle loc_409938 ; Jump if Less or Equal (ZF=1 | SF!=OF) movzx ecx, byte ptr [eax+0CDh] ; Move with Zero-Extend mov [eax+0C6h], cl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0CEh] ; Move with Zero-Extend mov [eax+0C7h], dl mov eax, [esi+edi*4+194h] movzx ecx, byte ptr [eax+0CFh] ; Move with Zero-Extend mov [eax+0C8h], cl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D0h] ; Move with Zero-Extend mov [eax+0C9h], dl mov eax, [esi+edi*4+194h] movzx ecx, byte ptr [eax+0D1h] ; Move with Zero-Extend mov [eax+0CAh], cl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D2h] ; Move with Zero-Extend mov [eax+0CBh], dl mov eax, [esi+edi*4+194h] movzx ecx, byte ptr [eax+0D3h] ; Move with Zero-Extend mov [eax+0CCh], cl mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D3h], 0 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0D2h], 0 mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0D1h], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CEh], 0 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0CDh], 0 mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0CFh], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D0h], 0 mov eax, [esi+edi*4+194h] mov ecx, [eax+70h] mov edx, [eax+368h] imul ecx, 178h ; Signed Multiply mov ebx, [ecx+edx+7ACh] mov ecx, [eax+3FCh] add ecx, 6 ; Add cmp [eax+10h], ecx ; Compare Two Operands jle loc_4097DA ; Jump if Less or Equal (ZF=1 | SF!=OF) mov edx, eax mov byte ptr [edx+0CFh], 1 mov eax, [esi+edi*4+194h] mov ecx, [eax+3FCh] add ecx, 0FAh ; Add cmp [eax+10h], ecx ; Compare Two Operands jle short loc_40979F ; Jump if Less or Equal (ZF=1 | SF!=OF) mov edx, dword ptr ds:[44F61Ch] add edx, 3 ; Add push edx push 11h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40979F ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C8h], 0 loc_40979F: ; CODE XREF: sub_4094C0+2B7j ; sub_4094C0+2CFj mov eax, [esi+edi*4+194h] mov ecx, [eax+3FCh] add ecx, 64h ; Add cmp [eax+10h], ecx ; Compare Two Operands jge loc_40985E ; Jump if Greater or Equal (SF=OF) cmp ebx, 2 ; Compare Two Operands jnz loc_40985E ; Jump if Not Zero (ZF=0) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz loc_40985E ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 jmp loc_40985E ; Jump ; --------------------------------------------------------------------------- loc_4097DA: ; CODE XREF: sub_4094C0+292j mov eax, [esi+edi*4+194h] mov edx, [eax+3FCh] sub edx, 6 ; Integer Subtraction cmp [eax+10h], edx ; Compare Two Operands jge short loc_40985E ; Jump if Greater or Equal (SF=OF) mov byte ptr [eax+0D0h], 1 mov eax, [esi+edi*4+194h] mov ecx, [eax+3FCh] sub ecx, 0FAh ; Integer Subtraction cmp [eax+10h], ecx ; Compare Two Operands jge short loc_409834 ; Jump if Greater or Equal (SF=OF) mov edx, dword ptr ds:[44F61Ch] add edx, 3 ; Add push edx push 12h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_409834 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C9h], 0 loc_409834: ; CODE XREF: sub_4094C0+34Cj ; sub_4094C0+364j mov eax, [esi+edi*4+194h] mov ecx, [eax+3FCh] sub ecx, 64h ; Integer Subtraction cmp [eax+10h], ecx ; Compare Two Operands jle short loc_40985E ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp ebx, 2 ; Compare Two Operands jnz short loc_40985E ; Jump if Not Zero (ZF=0) cmp byte ptr [eax+80h], 0 ; Compare Two Operands jnz short loc_40985E ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0CFh], 1 loc_40985E: ; CODE XREF: sub_4094C0+2F2j ; sub_4094C0+2FBj ... mov eax, [esi+edi*4+194h] mov edx, [eax+400h] sub edx, 3 ; Integer Subtraction cmp [eax+18h], edx ; Compare Two Operands jge short loc_40987C ; Jump if Greater or Equal (SF=OF) mov byte ptr [eax+0CEh], 1 jmp short loc_409898 ; Jump ; --------------------------------------------------------------------------- loc_40987C: ; CODE XREF: sub_4094C0+3B1j mov ecx, [eax+400h] add ecx, 3 ; Add cmp [eax+18h], ecx ; Compare Two Operands jle short loc_409898 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CDh], 1 loc_409898: ; CODE XREF: sub_4094C0+3BAj ; sub_4094C0+3C8j mov eax, [esi+edi*4+194h] cmp [eax+3F4h], ebp ; Compare Two Operands jz short loc_4098AF ; Jump if Zero (ZF=1) cmp [eax+3F0h], ebp ; Compare Two Operands jnz short loc_4098CB ; Jump if Not Zero (ZF=0) loc_4098AF: ; CODE XREF: sub_4094C0+3E5j mov eax, [esi+edi*4+194h] mov byte ptr [eax+0CAh], 0 mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0D1h], 1 loc_4098CB: ; CODE XREF: sub_4094C0+3EDj mov eax, [esi+edi*4+194h] mov edx, [eax+400h] sub edx, [eax+18h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [esi+edi*4+194h] mov ecx, [eax+3FCh] sub ecx, [eax+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) mov edx, [esi+edi*4+194h] mov eax, 0FFFFFC18h mov [edx+3FCh], eax mov ecx, [esi+edi*4+194h] pop edi pop esi pop ebp mov [ecx+400h], eax pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_409938: ; CODE XREF: sub_4094C0+17Cj mov eax, dword ptr ds:[450BB4h] mov ecx, dword ptr ds:[44D024h] xor edx, edx ; Logical Exclusive OR cmp eax, edx ; Compare Two Operands jg short loc_409963 ; Jump if Greater (ZF=0 & SF=OF) mov ebp, [esi+7D4h] mov eax, ecx imul eax, 990h ; Signed Multiply mov eax, [eax+ebp+4D45DB0h] mov ebp, 1 loc_409963: ; CODE XREF: sub_4094C0+487j cmp dword ptr ds:[450c2ch], ebp ; Compare Two Operands mov dword ptr ds:[44F604h], eax jz short loc_4099A6 ; Jump if Zero (ZF=1) cmp ebx, ebp ; Compare Two Operands jnz short loc_409998 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] cmp dword ptr [eax+364h], 5 ; Compare Two Operands jz short loc_409998 ; Jump if Zero (ZF=1) cmp edi, 14h ; Compare Two Operands jl short loc_4099A6 ; Jump if Less (SF!=OF) mov eax, [eax+368h] cmp dword ptr [eax+6F4h], 1Eh ; Compare Two Operands jl short loc_4099A6 ; Jump if Less (SF!=OF) loc_409998: ; CODE XREF: sub_4094C0+4B2j ; sub_4094C0+4C2j mov eax, dword ptr ds:[450C30h] cmp eax, edx ; Compare Two Operands mov dword ptr ds:[44F60Ch], eax jge short loc_4099AD ; Jump if Greater or Equal (SF=OF) loc_4099A6: ; CODE XREF: sub_4094C0+4AEj ; sub_4094C0+4C7j ... xor eax, eax ; Logical Exclusive OR mov dword ptr ds:[44F60Ch], eax loc_4099AD: ; CODE XREF: sub_4094C0+4E4j lea ebp, [eax+eax*2] ; Load Effective Address mov dword ptr ds:[44F61Ch], ebp lea ebp, [eax+eax*4] ; Load Effective Address mov dword ptr ds:[44F618h], ebp mov ebp, eax shl ebp, 4 ; Shift Logical Left sub ebp, eax ; Integer Subtraction lea eax, [eax+eax*4] ; Load Effective Address add eax, eax ; Add add eax, eax ; Add cmp ebx, 1 ; Compare Two Operands mov dword ptr ds:[44F610h], eax mov eax, 2710h mov dword ptr ds:[44F614h], ebp mov [esp+60h+var_28], eax mov [esp+60h+var_18], eax mov [esp+60h+var_10], eax mov [esp+60h+arg_0], 0FFFFFFFFh mov [esp+60h+var_4], ecx mov [esp+60h+var_2C], edx mov [esp+60h+var_50], edx mov [esp+60h+var_44], edx mov [esp+60h+var_48], edx mov [esp+60h+var_34], edx mov dword ptr ds:[44F608h], edx jz short loc_409A1D ; Jump if Zero (ZF=1) cmp ebx, 4 ; Compare Two Operands jnz loc_409FB5 ; Jump if Not Zero (ZF=0) loc_409A1D: ; CODE XREF: sub_4094C0+552j mov eax, [esi+edi*4+194h] mov eax, [eax+364h] cmp eax, 5 ; Compare Two Operands mov [esp+60h+var_4C], eax jz loc_409FB5 ; Jump if Zero (ZF=1) mov ebp, [esi+edi*4+194h] mov ecx, [ebp+304h] add ecx, ecx ; Add add ecx, ecx ; Add mov eax, 66666667h imul ecx ; Signed Multiply sar edx, 1 ; Shift Arithmetic Right mov ecx, edx shr ecx, 1Fh ; Shift Logical Right add ecx, edx ; Add cmp [ebp+2FCh], ecx ; Compare Two Operands mov [esp+60h+var_44], 1 jg short loc_409A7E ; Jump if Greater (ZF=0 & SF=OF) mov eax, ebp mov edx, [eax+304h] sub edx, 82h ; Integer Subtraction cmp [eax+2FCh], edx ; Compare Two Operands jle short loc_409A86 ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_409A7E: ; CODE XREF: sub_4094C0+5A6j mov [esp+60h+var_44], 0 loc_409A86: ; CODE XREF: sub_4094C0+5BCj xor ebp, ebp ; Logical Exclusive OR lea eax, [esi+198h] ; Load Effective Address mov edi, edi loc_409A90: ; CODE XREF: sub_4094C0+772j cmp ebp, edi ; Compare Two Operands jz short loc_409ADF ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+4], 0 ; Compare Two Operands jz short loc_409ADF ; Jump if Zero (ZF=1) mov ecx, [eax-4] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409ADF ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409ADF ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409ADF ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp edx, [ecx+2FCh] ; Compare Two Operands jge short loc_409ADA ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_44], 0 loc_409ADA: ; CODE XREF: sub_4094C0+610j add [esp+60h+var_50], 1 ; Add loc_409ADF: ; CODE XREF: sub_4094C0+5D2j ; sub_4094C0+5D9j ... lea ecx, [ebp+1] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409B30 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+5], 0 ; Compare Two Operands jz short loc_409B30 ; Jump if Zero (ZF=1) mov ecx, [eax] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409B30 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409B30 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409B30 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp edx, [ecx+2FCh] ; Compare Two Operands jge short loc_409B2B ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_44], 0 loc_409B2B: ; CODE XREF: sub_4094C0+661j add [esp+60h+var_50], 1 ; Add loc_409B30: ; CODE XREF: sub_4094C0+624j ; sub_4094C0+62Bj ... lea ecx, [ebp+2] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409B82 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+6], 0 ; Compare Two Operands jz short loc_409B82 ; Jump if Zero (ZF=1) mov ecx, [eax+4] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409B82 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409B82 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409B82 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp edx, [ecx+2FCh] ; Compare Two Operands jge short loc_409B7D ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_44], 0 loc_409B7D: ; CODE XREF: sub_4094C0+6B3j add [esp+60h+var_50], 1 ; Add loc_409B82: ; CODE XREF: sub_4094C0+675j ; sub_4094C0+67Cj ... lea edx, [ebp+3] ; Load Effective Address cmp edx, edi ; Compare Two Operands jz short loc_409BD4 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+7], 0 ; Compare Two Operands jz short loc_409BD4 ; Jump if Zero (ZF=1) mov ecx, [eax+8] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409BD4 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409BD4 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409BD4 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp edx, [ecx+2FCh] ; Compare Two Operands jge short loc_409BCF ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_44], 0 loc_409BCF: ; CODE XREF: sub_4094C0+705j add [esp+60h+var_50], 1 ; Add loc_409BD4: ; CODE XREF: sub_4094C0+6C7j ; sub_4094C0+6CEj ... lea ecx, [ebp+4] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409C26 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+8], 0 ; Compare Two Operands jz short loc_409C26 ; Jump if Zero (ZF=1) mov ecx, [eax+0Ch] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409C26 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409C26 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409C26 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp edx, [ecx+2FCh] ; Compare Two Operands jge short loc_409C21 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_44], 0 loc_409C21: ; CODE XREF: sub_4094C0+757j add [esp+60h+var_50], 1 ; Add loc_409C26: ; CODE XREF: sub_4094C0+719j ; sub_4094C0+720j ... add ebp, 5 ; Add add eax, 14h ; Add cmp ebp, 190h ; Compare Two Operands jl loc_409A90 ; Jump if Less (SF!=OF) mov ecx, [esi+edi*4+194h] mov ecx, [ecx+2FCh] xor ebp, ebp ; Logical Exclusive OR cmp ecx, 1AEh ; Compare Two Operands mov [esp+60h+var_48], ebp mov [esp+60h+var_38], ecx jg short loc_409C72 ; Jump if Greater (ZF=0 & SF=OF) mov ecx, [esi+edi*4+194h] mov edx, [ecx+304h] sub edx, 82h ; Integer Subtraction cmp [ecx+2FCh], edx ; Compare Two Operands jle short loc_409C7A ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_409C72: ; CODE XREF: sub_4094C0+795j mov [esp+60h+var_48], 1 loc_409C7A: ; CODE XREF: sub_4094C0+7B0j lea eax, [esi+198h] ; Load Effective Address loc_409C80: ; CODE XREF: sub_4094C0+944j cmp ebp, edi ; Compare Two Operands jz short loc_409CC9 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+4], 0 ; Compare Two Operands jz short loc_409CC9 ; Jump if Zero (ZF=1) mov ecx, [eax-4] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409CC9 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409CC9 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409CC9 ; Jump if Not Zero (ZF=0) mov ecx, [esp+60h+var_38] add ecx, 0FFFFFF38h ; Add cmp edx, ecx ; Compare Two Operands jge short loc_409CC9 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_48], 1 loc_409CC9: ; CODE XREF: sub_4094C0+7C2j ; sub_4094C0+7C9j ... lea edx, [ebp+1] ; Load Effective Address cmp edx, edi ; Compare Two Operands jz short loc_409D14 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+5], 0 ; Compare Two Operands jz short loc_409D14 ; Jump if Zero (ZF=1) mov ecx, [eax] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409D14 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409D14 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409D14 ; Jump if Not Zero (ZF=0) mov ecx, [esp+60h+var_38] add ecx, 0FFFFFF38h ; Add cmp edx, ecx ; Compare Two Operands jge short loc_409D14 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_48], 1 loc_409D14: ; CODE XREF: sub_4094C0+80Ej ; sub_4094C0+815j ... lea ecx, [ebp+2] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409D60 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+6], 0 ; Compare Two Operands jz short loc_409D60 ; Jump if Zero (ZF=1) mov ecx, [eax+4] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409D60 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409D60 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409D60 ; Jump if Not Zero (ZF=0) mov ecx, [esp+60h+var_38] add ecx, 0FFFFFF38h ; Add cmp edx, ecx ; Compare Two Operands jge short loc_409D60 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_48], 1 loc_409D60: ; CODE XREF: sub_4094C0+859j ; sub_4094C0+860j ... lea edx, [ebp+3] ; Load Effective Address cmp edx, edi ; Compare Two Operands jz short loc_409DAC ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+7], 0 ; Compare Two Operands jz short loc_409DAC ; Jump if Zero (ZF=1) mov ecx, [eax+8] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409DAC ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409DAC ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409DAC ; Jump if Not Zero (ZF=0) mov ecx, [esp+60h+var_38] add ecx, 0FFFFFF38h ; Add cmp edx, ecx ; Compare Two Operands jge short loc_409DAC ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_48], 1 loc_409DAC: ; CODE XREF: sub_4094C0+8A5j ; sub_4094C0+8ACj ... lea edx, [ebp+4] ; Load Effective Address cmp edx, edi ; Compare Two Operands jz short loc_409DF8 ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+8], 0 ; Compare Two Operands jz short loc_409DF8 ; Jump if Zero (ZF=1) mov ecx, [eax+0Ch] mov edx, [ecx+2FCh] test edx, edx ; Logical Compare jle short loc_409DF8 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ebx, [ecx+368h] cmp dword ptr [ebx+6F8h], 0 ; Compare Two Operands jnz short loc_409DF8 ; Jump if Not Zero (ZF=0) mov ebx, [esp+60h+var_4C] cmp [ecx+364h], ebx ; Compare Two Operands jnz short loc_409DF8 ; Jump if Not Zero (ZF=0) mov ecx, [esp+60h+var_38] add ecx, 0FFFFFF38h ; Add cmp edx, ecx ; Compare Two Operands jge short loc_409DF8 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_48], 1 loc_409DF8: ; CODE XREF: sub_4094C0+8F1j ; sub_4094C0+8F8j ... add ebp, 5 ; Add add eax, 14h ; Add cmp ebp, 190h ; Compare Two Operands jl loc_409C80 ; Jump if Less (SF!=OF) cmp [esp+60h+arg_4], 1 ; Compare Two Operands jnz loc_409FA6 ; Jump if Not Zero (ZF=0) or ebp, 0FFFFFFFFh ; Logical Inclusive OR xor ebx, ebx ; Logical Exclusive OR lea eax, [esi+198h] ; Load Effective Address loc_409E20: ; CODE XREF: sub_4094C0+A87j cmp ebx, edi ; Compare Two Operands jz short loc_409E57 ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+4], 0 ; Compare Two Operands jz short loc_409E57 ; Jump if Zero (ZF=1) mov edx, [eax-4] cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_409E57 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_409E57 ; Jump if Not Zero (ZF=0) cmp [edx+10h], ebp ; Compare Two Operands jle short loc_409E57 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, edx mov edx, [ecx+18h] mov ebp, [ecx+10h] mov [esp+60h+var_38], edx loc_409E57: ; CODE XREF: sub_4094C0+962j ; sub_4094C0+969j ... lea ecx, [ebx+1] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409E90 ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+5], 0 ; Compare Two Operands jz short loc_409E90 ; Jump if Zero (ZF=1) mov edx, [eax] cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_409E90 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_409E90 ; Jump if Not Zero (ZF=0) cmp [edx+10h], ebp ; Compare Two Operands jle short loc_409E90 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, edx mov edx, [ecx+18h] mov ebp, [ecx+10h] mov [esp+60h+var_38], edx loc_409E90: ; CODE XREF: sub_4094C0+99Cj ; sub_4094C0+9A3j ... lea ecx, [ebx+2] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409ECA ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+6], 0 ; Compare Two Operands jz short loc_409ECA ; Jump if Zero (ZF=1) mov edx, [eax+4] cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_409ECA ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_409ECA ; Jump if Not Zero (ZF=0) cmp [edx+10h], ebp ; Compare Two Operands jle short loc_409ECA ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, edx mov edx, [ecx+18h] mov ebp, [ecx+10h] mov [esp+60h+var_38], edx loc_409ECA: ; CODE XREF: sub_4094C0+9D5j ; sub_4094C0+9DCj ... lea ecx, [ebx+3] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409F04 ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+7], 0 ; Compare Two Operands jz short loc_409F04 ; Jump if Zero (ZF=1) mov edx, [eax+8] cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_409F04 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_409F04 ; Jump if Not Zero (ZF=0) cmp [edx+10h], ebp ; Compare Two Operands jle short loc_409F04 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, edx mov edx, [ecx+18h] mov ebp, [ecx+10h] mov [esp+60h+var_38], edx loc_409F04: ; CODE XREF: sub_4094C0+A0Fj ; sub_4094C0+A16j ... lea ecx, [ebx+4] ; Load Effective Address cmp ecx, edi ; Compare Two Operands jz short loc_409F3E ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+8], 0 ; Compare Two Operands jz short loc_409F3E ; Jump if Zero (ZF=1) mov edx, [eax+0Ch] cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_409F3E ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_409F3E ; Jump if Not Zero (ZF=0) cmp [edx+10h], ebp ; Compare Two Operands jle short loc_409F3E ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, edx mov edx, [ecx+18h] mov ebp, [ecx+10h] mov [esp+60h+var_38], edx loc_409F3E: ; CODE XREF: sub_4094C0+A49j ; sub_4094C0+A50j ... add ebx, 5 ; Add add eax, 14h ; Add cmp ebx, 0Ah ; Compare Two Operands jl loc_409E20 ; Jump if Less (SF!=OF) cmp ebp, 0FFFFFFFFh ; Compare Two Operands jle short loc_409FA6 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [esi+edi*4+194h] mov ecx, [eax+10h] cmp ecx, ebp ; Compare Two Operands jle short loc_409F8A ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [eax+18h] sub eax, [esp+60h+var_38] ; Integer Subtraction push eax call sub_403270 ; Call Procedure cdq ; EAX -> EDX:EAX (with sign) sub eax, edx ; Integer Subtraction sar eax, 1 ; Shift Arithmetic Right sub eax, ebp ; Integer Subtraction add eax, ecx ; Add add esp, 4 ; Add cmp eax, 0C8h ; Compare Two Operands jle short loc_409F8A ; Jump if Less or Equal (ZF=1 | SF!=OF) mov dword ptr ds:[44F608h], 1 loc_409F8A: ; CODE XREF: sub_4094C0+A9Ej ; sub_4094C0+ABEj mov ecx, [esi+edi*4+194h] add ebp, 190h ; Add cmp [ecx+10h], ebp ; Compare Two Operands jle short loc_409FA6 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov dword ptr ds:[44F608h], 2 loc_409FA6: ; CODE XREF: sub_4094C0+94Fj ; sub_4094C0+A90j ... cmp [esp+60h+var_50], 0 ; Compare Two Operands jnz short loc_409FB5 ; Jump if Not Zero (ZF=0) mov [esp+60h+var_44], 0 loc_409FB5: ; CODE XREF: sub_4094C0+557j ; sub_4094C0+571j ... mov eax, [esi+edi*4+194h] cmp dword ptr [eax+2F4h], 0FFFFFFFFh ; Compare Two Operands mov ecx, 1 jle short loc_409FD2 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_48], ecx mov [esp+60h+var_34], ecx loc_409FD2: ; CODE XREF: sub_4094C0+B08j cmp dword ptr [eax+308h], 0FAh ; Compare Two Operands jle short loc_409FE2 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_34], ecx loc_409FE2: ; CODE XREF: sub_4094C0+B1Cj mov ebp, [esp+60h+arg_4] cmp ebp, ecx ; Compare Two Operands jnz short loc_409FF6 ; Jump if Not Zero (ZF=0) cmp [eax+364h], ecx ; Compare Two Operands jnz short loc_409FF6 ; Jump if Not Zero (ZF=0) mov [esp+60h+var_34], ecx loc_409FF6: ; CODE XREF: sub_4094C0+B28j ; sub_4094C0+B30j cmp edi, 14h ; Compare Two Operands jl short loc_40A004 ; Jump if Less (SF!=OF) cmp ebp, 4 ; Compare Two Operands jnz short loc_40A004 ; Jump if Not Zero (ZF=0) mov [esp+60h+var_34], ecx loc_40A004: ; CODE XREF: sub_4094C0+B39j ; sub_4094C0+B3Ej fldz ; Load +0.0 lea eax, [esi+194h] ; Load Effective Address xor ebx, ebx ; Logical Exclusive OR mov [esp+60h+var_30], eax loc_40A012: ; CODE XREF: sub_4094C0+C90j cmp ebx, edi ; Compare Two Operands jz loc_40A142 ; Jump if Zero (ZF=1) cmp byte ptr [ebx+esi+4], 0 ; Compare Two Operands jz loc_40A142 ; Jump if Zero (ZF=1) mov eax, [esp+60h+var_30] mov edx, [eax] mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jz short loc_40A091 ; Jump if Zero (ZF=1) mov eax, edx mov ecx, [eax+70h] mov eax, [eax+368h] imul ecx, 178h ; Signed Multiply cmp dword ptr [ecx+eax+7ACh], 0BB8h ; Compare Two Operands jnz loc_40A142 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov ecx, [edx+10h] mov ebp, [eax+10h] cmp ecx, ebp ; Compare Two Operands jle short loc_40A079 ; Jump if Less or Equal (ZF=1 | SF!=OF) fcom qword ptr [edx+40h] ; Compare Real fnstsw ax ; Store Status Word (no wait) test ah, 41h ; Logical Compare jz short loc_40A08D ; Jump if Zero (ZF=1) cmp ecx, ebp ; Compare Two Operands loc_40A079: ; CODE XREF: sub_4094C0+BABj jge loc_40A13E ; Jump if Greater or Equal (SF=OF) fcom qword ptr [edx+40h] ; Compare Real fnstsw ax ; Store Status Word (no wait) test ah, 5 ; Logical Compare jp loc_40A13E ; Jump if Parity (PF=1) loc_40A08D: ; CODE XREF: sub_4094C0+BB5j mov ebp, [esp+60h+arg_4] loc_40A091: ; CODE XREF: sub_4094C0+B78j mov ecx, [esi+edi*4+194h] mov eax, [edx+364h] mov ecx, [ecx+364h] cmp eax, ecx ; Compare Two Operands jz short loc_40A0B2 ; Jump if Zero (ZF=1) cmp ebp, 1 ; Compare Two Operands jnz short loc_40A0C8 ; Jump if Not Zero (ZF=0) cmp ecx, 5 ; Compare Two Operands jz short loc_40A0C8 ; Jump if Zero (ZF=1) loc_40A0B2: ; CODE XREF: sub_4094C0+BE6j cmp eax, 5 ; Compare Two Operands jnz loc_40A142 ; Jump if Not Zero (ZF=0) cmp ebp, 1 ; Compare Two Operands jnz loc_40A142 ; Jump if Not Zero (ZF=0) cmp eax, ecx ; Compare Two Operands jz short loc_40A142 ; Jump if Zero (ZF=1) loc_40A0C8: ; CODE XREF: sub_4094C0+BEBj ; sub_4094C0+BF0j cmp dword ptr [edx+2FCh], 0 ; Compare Two Operands jle short loc_40A142 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [esp+60h+var_30] mov eax, [eax] mov ecx, [eax+70h] mov eax, [eax+368h] imul ecx, 178h ; Signed Multiply cmp dword ptr [ecx+eax+7ACh], 0Eh ; Compare Two Operands jz short loc_40A142 ; Jump if Zero (ZF=1) mov ecx, [edx+8] push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 2 ; Compare Two Operands jg short loc_40A142 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [edx+18h] mov ecx, [esi+edi*4+194h] sub eax, [ecx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure mov edx, [edx+10h] mov ecx, eax mov eax, [esi+edi*4+194h] sub edx, [eax+10h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add ecx, eax ; Add add esp, 8 ; Add cmp ecx, [esp+60h+var_28] ; Compare Two Operands jge short loc_40A142 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+arg_0], ebx mov [esp+60h+var_28], ecx jmp short loc_40A142 ; Jump ; --------------------------------------------------------------------------- loc_40A13E: ; CODE XREF: sub_4094C0:loc_40A079j ; sub_4094C0+BC7j mov ebp, [esp+60h+arg_4] loc_40A142: ; CODE XREF: sub_4094C0+B54j ; sub_4094C0+B5Fj ... add [esp+60h+var_30], 4 ; Add add ebx, 1 ; Add cmp ebx, 190h ; Compare Two Operands jl loc_40A012 ; Jump if Less (SF!=OF) mov ebp, [esp+60h+arg_0] fstp st ; Store Real and Pop xor ecx, ecx ; Logical Exclusive OR cmp ebp, ecx ; Compare Two Operands mov [esp+60h+var_14], ebx jl short loc_40A190 ; Jump if Less (SF!=OF) mov edx, [esi+ebp*4+194h] mov eax, [edx+18h] mov edx, [esi+edi*4+194h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0Fh ; Compare Two Operands jge short loc_40A190 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_2C], 1 loc_40A190: ; CODE XREF: sub_4094C0+CA4j ; sub_4094C0+CC6j mov eax, [esi+edi*4+194h] mov edx, [eax+70h] mov eax, [eax+368h] imul edx, 178h ; Signed Multiply cmp dword ptr [edx+eax+7ACh], 9 ; Compare Two Operands jz loc_40A2AE ; Jump if Zero (ZF=1) lea eax, [esi+194h] ; Load Effective Address xor ebp, ebp ; Logical Exclusive OR mov [esp+60h+var_20], eax loc_40A1C0: ; CODE XREF: sub_4094C0+DDEj cmp ebp, edi ; Compare Two Operands jz loc_40A28A ; Jump if Zero (ZF=1) cmp byte ptr [esi+ebp+4], 0 ; Compare Two Operands jz loc_40A28A ; Jump if Zero (ZF=1) mov ecx, [eax] mov edx, [esi+edi*4+194h] mov eax, [ecx+364h] mov edx, [edx+364h] cmp eax, edx ; Compare Two Operands jz short loc_40A1F8 ; Jump if Zero (ZF=1) cmp [esp+60h+arg_4], 1 ; Compare Two Operands jnz short loc_40A210 ; Jump if Not Zero (ZF=0) cmp edx, 5 ; Compare Two Operands jz short loc_40A210 ; Jump if Zero (ZF=1) loc_40A1F8: ; CODE XREF: sub_4094C0+D2Aj cmp eax, 5 ; Compare Two Operands jnz loc_40A28A ; Jump if Not Zero (ZF=0) cmp [esp+60h+arg_4], 1 ; Compare Two Operands jnz loc_40A28A ; Jump if Not Zero (ZF=0) cmp eax, edx ; Compare Two Operands jz short loc_40A28A ; Jump if Zero (ZF=1) loc_40A210: ; CODE XREF: sub_4094C0+D31j ; sub_4094C0+D36j cmp dword ptr [ecx+2FCh], 0 ; Compare Two Operands jle short loc_40A28A ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [esp+60h+var_20] mov eax, [eax] mov edx, [eax+70h] mov eax, [eax+368h] imul edx, 178h ; Signed Multiply cmp dword ptr [edx+eax+7ACh], 0Eh ; Compare Two Operands jz short loc_40A249 ; Jump if Zero (ZF=1) mov edx, [ecx+8] push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 2 ; Compare Two Operands jle short loc_40A28A ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40A249: ; CODE XREF: sub_4094C0+D76j mov eax, [ecx+18h] mov ebx, [esi+edi*4+194h] sub eax, [ebx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure mov ecx, [ecx+10h] sub ecx, [ebx+10h] ; Integer Subtraction mov edx, eax push ecx call sub_403270 ; Call Procedure lea ecx, [eax+edx] ; Load Effective Address add esp, 8 ; Add cmp ecx, [esp+60h+var_18] ; Compare Two Operands jge short loc_40A28A ; Jump if Greater or Equal (SF=OF) cmp edx, 28h ; Compare Two Operands jge short loc_40A28A ; Jump if Greater or Equal (SF=OF) cmp eax, 0FAh ; Compare Two Operands jge short loc_40A28A ; Jump if Greater or Equal (SF=OF) mov [esp+60h+arg_0], ebp mov [esp+60h+var_18], ecx loc_40A28A: ; CODE XREF: sub_4094C0+D02j ; sub_4094C0+D0Dj ... mov eax, [esp+60h+var_20] add ebp, 1 ; Add add eax, 4 ; Add cmp ebp, 190h ; Compare Two Operands mov [esp+60h+var_20], eax jl loc_40A1C0 ; Jump if Less (SF!=OF) mov [esp+60h+var_14], ebp mov ebp, [esp+60h+arg_0] xor ecx, ecx ; Logical Exclusive OR loc_40A2AE: ; CODE XREF: sub_4094C0+CEEj mov edx, [esi+edi*4+194h] mov eax, [edx+360h] cmp eax, 0FFFFFFFFh ; Compare Two Operands jle short loc_40A32F ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp eax, 190h ; Compare Two Operands jge short loc_40A32F ; Jump if Greater or Equal (SF=OF) cmp byte ptr [eax+esi+4], 1 ; Compare Two Operands jnz short loc_40A31A ; Jump if Not Zero (ZF=0) mov edx, [esi+eax*4+194h] cmp [edx+2FCh], ecx ; Compare Two Operands jle short loc_40A31A ; Jump if Less or Equal (ZF=1 | SF!=OF) push 1Eh push 13h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jle short loc_40A31A ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [esi+edi*4+194h] mov eax, [eax+360h] mov ecx, [esi+eax*4+194h] mov edx, [ecx+368h] cmp dword ptr [edx+6F8h], 0 ; Compare Two Operands jnz short loc_40A31A ; Jump if Not Zero (ZF=0) mov [esp+60h+arg_0], eax mov ebp, eax xor ecx, ecx ; Logical Exclusive OR jmp short loc_40A335 ; Jump ; --------------------------------------------------------------------------- loc_40A31A: ; CODE XREF: sub_4094C0+E0Cj ; sub_4094C0+E1Bj ... mov eax, [esi+edi*4+194h] mov ebp, [esp+60h+arg_0] mov [eax+360h], ebp xor ecx, ecx ; Logical Exclusive OR jmp short loc_40A335 ; Jump ; --------------------------------------------------------------------------- loc_40A32F: ; CODE XREF: sub_4094C0+DFEj ; sub_4094C0+E05j mov [edx+360h], ebp loc_40A335: ; CODE XREF: sub_4094C0+E58j ; sub_4094C0+E6Dj cmp ebp, ecx ; Compare Two Operands mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0CDh] ; Move with Zero-Extend mov [eax+0C6h], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0CEh] ; Move with Zero-Extend mov [eax+0C7h], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0CFh] ; Move with Zero-Extend mov [eax+0C8h], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D0h] ; Move with Zero-Extend mov [eax+0C9h], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D1h] ; Move with Zero-Extend mov [eax+0CAh], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D2h] ; Move with Zero-Extend mov [eax+0CBh], dl mov eax, [esi+edi*4+194h] movzx edx, byte ptr [eax+0D3h] ; Move with Zero-Extend mov [eax+0CCh], dl mov eax, [esi+edi*4+194h] mov byte ptr [eax+0D3h], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D2h], 0 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0D1h], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CEh], 0 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0CDh], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CFh], 0 mov eax, [esi+edi*4+194h] mov [esp+60h+var_8], ebp mov byte ptr [eax+0D0h], 0 mov [esp+60h+var_20], ecx mov [esp+60h+var_4C], ecx mov [esp+60h+var_40], ecx mov [esp+60h+var_24], ecx mov [esp+60h+var_30], ecx mov [esp+60h+var_18], ecx mov [esp+60h+var_1C], ecx jl loc_40B7C5 ; Jump if Less (SF!=OF) lea ecx, [esi+1E4h] ; Load Effective Address mov [esp+60h+var_38], 14h mov [esp+60h+var_3C], ecx lea ecx, [ecx+0] ; Load Effective Address loc_40A460: ; CODE XREF: sub_4094C0+145Aj mov edx, [esp+60h+var_38] cmp byte ptr [esi+edx+4], 0 ; Compare Two Operands jz loc_40A905 ; Jump if Zero (ZF=1) mov eax, [esp+60h+var_3C] mov ecx, [eax] mov edx, [ecx+368h] mov eax, [edx+6F4h] cmp eax, 0C8h ; Compare Two Operands mov [esp+60h+var_50], eax jnz loc_40A5F1 ; Jump if Not Zero (ZF=0) mov edx, [ecx+70h] mov eax, 66666667h imul edx ; Signed Multiply sar edx, 2 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp eax, 6 ; Compare Two Operands jnz short loc_40A4C2 ; Jump if Not Zero (ZF=0) mov ebp, [esi+edi*4+194h] mov edx, [ecx+364h] cmp edx, [ebp+364h] ; Compare Two Operands jnz loc_40A570 ; Jump if Not Zero (ZF=0) loc_40A4C2: ; CODE XREF: sub_4094C0+FE7j cmp eax, 5 ; Compare Two Operands jnz loc_40A5F1 ; Jump if Not Zero (ZF=0) mov ebp, [esi+edi*4+194h] mov eax, [ebp+368h] mov eax, [eax+6F4h] cmp eax, 2 ; Compare Two Operands jz short loc_40A4EC ; Jump if Zero (ZF=1) cmp eax, 22h ; Compare Two Operands jnz loc_40A5F1 ; Jump if Not Zero (ZF=0) loc_40A4EC: ; CODE XREF: sub_4094C0+1021j mov eax, [esi+edi*4+194h] mov edx, [eax+304h] sub edx, 46h ; Integer Subtraction cmp [eax+2FCh], edx ; Compare Two Operands jge short loc_40A51C ; Jump if Greater or Equal (SF=OF) mov edx, [eax+304h] sub edx, 0C8h ; Integer Subtraction cmp [eax+2FCh], edx ; Compare Two Operands jl loc_40A5F1 ; Jump if Less (SF!=OF) loc_40A51C: ; CODE XREF: sub_4094C0+1042j mov ebx, [esi+edi*4+194h] mov eax, [ebx+304h] lea edx, [eax+eax*2] ; Load Effective Address mov eax, 66666667h imul edx ; Signed Multiply sar edx, 1 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp [ebx+2FCh], eax ; Compare Two Operands jge short loc_40A55E ; Jump if Greater or Equal (SF=OF) mov eax, ebx mov edx, [eax+304h] sub edx, 0C8h ; Integer Subtraction cmp [eax+2FCh], edx ; Compare Two Operands jge loc_40A5F1 ; Jump if Greater or Equal (SF=OF) loc_40A55E: ; CODE XREF: sub_4094C0+1082j mov eax, [ecx+364h] cmp eax, [ebp+364h] ; Compare Two Operands jnz loc_40A5F1 ; Jump if Not Zero (ZF=0) loc_40A570: ; CODE XREF: sub_4094C0+FFCj mov ebx, [ecx+18h] mov eax, [ebp+18h] mov edx, ebx sub edx, eax ; Integer Subtraction push edx mov [esp+64h+var_18], 1 mov [esp+64h+var_C], eax call sub_403270 ; Call Procedure mov edx, eax add esp, 4 ; Add cmp edx, 19h ; Compare Two Operands jge short loc_40A5F1 ; Jump if Greater or Equal (SF=OF) mov eax, [ecx+10h] mov ebp, [ebp+10h] sub eax, ebp ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jge short loc_40A5F1 ; Jump if Greater or Equal (SF=OF) cmp edx, 14h ; Compare Two Operands mov [esp+60h+var_30], 1 jge short loc_40A5F1 ; Jump if Greater or Equal (SF=OF) cmp eax, 0B4h ; Compare Two Operands jge short loc_40A5DA ; Jump if Greater or Equal (SF=OF) cmp ebx, [esp+60h+var_C] ; Compare Two Operands jle short loc_40A5D2 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_24], 1 jmp short loc_40A5DA ; Jump ; --------------------------------------------------------------------------- loc_40A5D2: ; CODE XREF: sub_4094C0+1106j mov [esp+60h+var_20], 1 loc_40A5DA: ; CODE XREF: sub_4094C0+1100j ; sub_4094C0+1110j cmp [ecx+10h], ebp ; Compare Two Operands jle short loc_40A5E9 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_40], 1 jmp short loc_40A5F1 ; Jump ; --------------------------------------------------------------------------- loc_40A5E9: ; CODE XREF: sub_4094C0+111Dj mov [esp+60h+var_4C], 1 loc_40A5F1: ; CODE XREF: sub_4094C0+FCAj ; sub_4094C0+1005j ... mov edx, [esp+60h+var_50] cmp edx, 0D3h ; Compare Two Operands jnz short loc_40A61C ; Jump if Not Zero (ZF=0) mov eax, [esp+60h+var_3C] mov eax, [eax] mov ebx, [eax+70h] mov eax, [eax+368h] imul ebx, 178h ; Signed Multiply cmp dword ptr [ebx+eax+7ACh], 12h ; Compare Two Operands jz short loc_40A641 ; Jump if Zero (ZF=1) loc_40A61C: ; CODE XREF: sub_4094C0+113Bj cmp edx, 0D4h ; Compare Two Operands jnz loc_40A6C0 ; Jump if Not Zero (ZF=0) mov eax, [ecx+70h] cmp eax, 96h ; Compare Two Operands jl loc_40A6C0 ; Jump if Less (SF!=OF) cmp eax, 0AAh ; Compare Two Operands jg loc_40A6C0 ; Jump if Greater (ZF=0 & SF=OF) loc_40A641: ; CODE XREF: sub_4094C0+115Aj mov ebx, [ecx+10h] mov edx, [esi+edi*4+194h] mov eax, [edx+10h] mov ebp, ebx sub ebp, eax ; Integer Subtraction push ebp call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 50h ; Compare Two Operands jge short loc_40A689 ; Jump if Greater or Equal (SF=OF) mov ebp, [edx+18h] mov eax, [ecx+18h] add ebp, 14h ; Add cmp eax, ebp ; Compare Two Operands jle short loc_40A677 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_24], 1 jmp short loc_40A689 ; Jump ; --------------------------------------------------------------------------- loc_40A677: ; CODE XREF: sub_4094C0+11ABj mov ebp, [edx+18h] add ebp, 0FFFFFFECh ; Add cmp eax, ebp ; Compare Two Operands jge short loc_40A689 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_20], 1 loc_40A689: ; CODE XREF: sub_4094C0+119Ej ; sub_4094C0+11B5j ... mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 14h ; Compare Two Operands jge short loc_40A6C0 ; Jump if Greater or Equal (SF=OF) mov eax, [edx+10h] lea edx, [eax+64h] ; Load Effective Address cmp ebx, edx ; Compare Two Operands jle short loc_40A6B1 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov [esp+60h+var_40], 1 jmp short loc_40A6C0 ; Jump ; --------------------------------------------------------------------------- loc_40A6B1: ; CODE XREF: sub_4094C0+11E5j add eax, 0FFFFFF9Ch ; Add cmp ebx, eax ; Compare Two Operands jge short loc_40A6C0 ; Jump if Greater or Equal (SF=OF) mov [esp+60h+var_4C], 1 loc_40A6C0: ; CODE XREF: sub_4094C0+1162j ; sub_4094C0+1170j ... mov eax, [esp+60h+var_1C] test eax, eax ; Logical Compare jnz loc_40A7DB ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_2C], eax ; Compare Two Operands jnz loc_40A7E4 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_18], eax ; Compare Two Operands jnz loc_40A7E4 ; Jump if Not Zero (ZF=0) mov ebp, [esi+edi*4+194h] mov eax, [ecx+18h] sub eax, [ebp+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure mov edx, [ecx+10h] sub edx, [ebp+10h] ; Integer Subtraction mov ebx, eax push edx call sub_403270 ; Call Procedure add esp, 8 ; Add add ebx, eax ; Add cmp dword ptr [ebp+98h], 0 ; Compare Two Operands jnz loc_40A7E4 ; Jump if Not Zero (ZF=0) mov eax, [esp+60h+var_28] lea edx, [eax+eax] ; Load Effective Address cmp ebx, edx ; Compare Two Operands jge loc_40A7E4 ; Jump if Greater or Equal (SF=OF) cmp ebx, [esp+60h+var_10] ; Compare Two Operands jge loc_40A7E4 ; Jump if Greater or Equal (SF=OF) mov eax, 51EB851Fh imul [esp+60h+var_50] ; Signed Multiply sar edx, 5 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp eax, 1 ; Compare Two Operands jz short loc_40A752 ; Jump if Zero (ZF=1) cmp [esp+60h+var_50], 0D5h ; Compare Two Operands jnz loc_40A7E4 ; Jump if Not Zero (ZF=0) loc_40A752: ; CODE XREF: sub_4094C0+1282j cmp dword ptr [ecx+98h], 0 ; Compare Two Operands jnz loc_40A7E4 ; Jump if Not Zero (ZF=0) mov edx, [esp+60h+var_3C] mov eax, [edx] mov edx, [eax+70h] mov eax, [eax+368h] imul edx, 178h ; Signed Multiply cmp dword ptr [edx+eax+7ACh], 3ECh ; Compare Two Operands jz short loc_40A7A3 ; Jump if Zero (ZF=1) mov edx, [esp+60h+var_3C] mov eax, [edx] mov edx, [eax+70h] mov eax, [eax+368h] imul edx, 178h ; Signed Multiply cmp dword ptr [edx+eax+7ACh], 7D4h ; Compare Two Operands jnz short loc_40A7E4 ; Jump if Not Zero (ZF=0) loc_40A7A3: ; CODE XREF: sub_4094C0+12BFj cmp [esp+60h+var_48], 0 ; Compare Two Operands mov eax, [esp+60h+var_50] jz short loc_40A7B3 ; Jump if Zero (ZF=1) cmp eax, 7Ah ; Compare Two Operands jz short loc_40A7E4 ; Jump if Zero (ZF=1) loc_40A7B3: ; CODE XREF: sub_4094C0+12ECj cmp [esp+60h+var_34], 0 ; Compare Two Operands jz short loc_40A7BF ; Jump if Zero (ZF=1) cmp eax, 7Bh ; Compare Two Operands jz short loc_40A7E4 ; Jump if Zero (ZF=1) loc_40A7BF: ; CODE XREF: sub_4094C0+12F8j cmp dword ptr [ebp+404h], 1 ; Compare Two Operands jnz short loc_40A7CD ; Jump if Not Zero (ZF=0) cmp eax, 7Ah ; Compare Two Operands jnz short loc_40A7E4 ; Jump if Not Zero (ZF=0) loc_40A7CD: ; CODE XREF: sub_4094C0+1306j mov edx, [esp+60h+var_38] mov [esp+60h+arg_0], edx mov [esp+60h+var_10], ebx jmp short loc_40A7E4 ; Jump ; --------------------------------------------------------------------------- loc_40A7DB: ; CODE XREF: sub_4094C0+1206j cmp eax, 1 ; Compare Two Operands jg loc_40A905 ; Jump if Greater (ZF=0 & SF=OF) loc_40A7E4: ; CODE XREF: sub_4094C0+1210j ; sub_4094C0+121Aj ... cmp [esp+60h+var_50], 0C8h ; Compare Two Operands jnz loc_40A8B5 ; Jump if Not Zero (ZF=0) mov edx, [ecx+70h] mov eax, 66666667h imul edx ; Signed Multiply sar edx, 2 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp eax, 5 ; Compare Two Operands jnz loc_40A8B5 ; Jump if Not Zero (ZF=0) mov ebp, [esi+edi*4+194h] mov edx, [ecx+10h] sub edx, [ebp+10h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 12Ch ; Compare Two Operands jge loc_40A8B5 ; Jump if Greater or Equal (SF=OF) mov eax, [ecx+18h] sub eax, [ebp+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jge short loc_40A8B5 ; Jump if Greater or Equal (SF=OF) mov ecx, [ecx+364h] cmp ecx, [ebp+364h] ; Compare Two Operands jnz short loc_40A8B5 ; Jump if Not Zero (ZF=0) mov eax, ebp mov edx, [eax+300h] sub edx, 46h ; Integer Subtraction cmp [eax+2FCh], edx ; Compare Two Operands jge short loc_40A871 ; Jump if Greater or Equal (SF=OF) cmp dword ptr [ebp+2FCh], 8Ch ; Compare Two Operands jl short loc_40A8A5 ; Jump if Less (SF!=OF) loc_40A871: ; CODE XREF: sub_4094C0+13A3j mov ecx, [esi+edi*4+194h] mov eax, [ecx+300h] lea edx, [eax+eax*2] ; Load Effective Address mov eax, 66666667h imul edx ; Signed Multiply sar edx, 1 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp [ecx+2FCh], eax ; Compare Two Operands jge short loc_40A8AD ; Jump if Greater or Equal (SF=OF) cmp dword ptr [ebp+2FCh], 8Ch ; Compare Two Operands jl short loc_40A8AD ; Jump if Less (SF!=OF) loc_40A8A5: ; CODE XREF: sub_4094C0+13AFj mov ecx, [esp+60h+var_38] mov [esp+60h+arg_0], ecx loc_40A8AD: ; CODE XREF: sub_4094C0+13D7j ; sub_4094C0+13E3j mov [esp+60h+var_1C], 1 loc_40A8B5: ; CODE XREF: sub_4094C0+132Cj ; sub_4094C0+1349j ... mov ecx, 1 cmp [esp+60h+var_44], ecx ; Compare Two Operands jnz short loc_40A905 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_50], 7Ah ; Compare Two Operands jnz short loc_40A905 ; Jump if Not Zero (ZF=0) mov edx, [esp+60h+var_3C] mov eax, [edx] mov edx, [eax+70h] mov eax, [eax+368h] imul edx, 178h ; Signed Multiply cmp dword ptr [edx+eax+7ACh], 3ECh ; Compare Two Operands jnz short loc_40A905 ; Jump if Not Zero (ZF=0) mov edx, [esi+edi*4+194h] cmp dword ptr [edx+98h], 0 ; Compare Two Operands jnz short loc_40A905 ; Jump if Not Zero (ZF=0) mov eax, [esp+60h+var_38] mov [esp+60h+arg_0], eax mov [esp+60h+var_1C], ecx loc_40A905: ; CODE XREF: sub_4094C0+FA9j ; sub_4094C0+131Ej ... mov eax, [esp+60h+var_38] add [esp+60h+var_3C], 4 ; Add add eax, 1 ; Add cmp eax, 190h ; Compare Two Operands mov [esp+60h+var_38], eax jl loc_40A460 ; Jump if Less (SF!=OF) cmp [esp+60h+var_18], 1 ; Compare Two Operands jnz short loc_40A931 ; Jump if Not Zero (ZF=0) mov ebp, [esp+60h+var_8] mov [esp+60h+arg_0], ebp jmp short loc_40A935 ; Jump ; --------------------------------------------------------------------------- loc_40A931: ; CODE XREF: sub_4094C0+1465j mov ebp, [esp+60h+arg_0] loc_40A935: ; CODE XREF: sub_4094C0+146Fj test ebp, ebp ; Logical Compare jl loc_40B7C5 ; Jump if Less (SF!=OF) mov eax, [esi+ebp*4+194h] mov ecx, [eax+70h] mov edx, [eax+368h] imul ecx, 178h ; Signed Multiply mov ebx, [ecx+edx+7ACh] mov eax, [esi+edi*4+194h] mov ecx, [eax+70h] mov edx, [eax+368h] imul ecx, 178h ; Signed Multiply mov eax, [ecx+edx+7ACh] mov ecx, dword ptr ds:[44F618h] add ecx, 8 ; Add push ecx push 14h mov [esp+68h+var_14], ebp mov [esp+68h+var_44], ebx mov [esp+68h+var_50], eax call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare mov ecx, 1 jnz short loc_40A9E2 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] cmp [eax+3E8h], ecx ; Compare Two Operands jz short loc_40A9C7 ; Jump if Zero (ZF=1) cmp [eax+3ECh], ecx ; Compare Two Operands jz short loc_40A9C7 ; Jump if Zero (ZF=1) cmp [eax+3F0h], ecx ; Compare Two Operands jz short loc_40A9C7 ; Jump if Zero (ZF=1) cmp [eax+3F4h], ecx ; Compare Two Operands jnz short loc_40A9E2 ; Jump if Not Zero (ZF=0) loc_40A9C7: ; CODE XREF: sub_4094C0+14EDj ; sub_4094C0+14F5j ... mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CAh], 0 mov eax, [esi+edi*4+194h] mov [eax+0D1h], cl loc_40A9E2: ; CODE XREF: sub_4094C0+14DEj ; sub_4094C0+1505j cmp ebx, 0BB8h ; Compare Two Operands jnz loc_40AACC ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_50], 7 ; Compare Two Operands jz short loc_40AA6E ; Jump if Zero (ZF=1) mov ecx, dword ptr ds:[44F61Ch] push ecx push 15h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40AA6E ; Jump if Not Zero (ZF=0) mov ebx, [esi+ebp*4+194h] mov edx, [esi+edi*4+194h] mov ecx, [ebx+10h] mov edx, [edx+10h] cmp ecx, edx ; Compare Two Operands jle short loc_40AA3A ; Jump if Less or Equal (ZF=1 | SF!=OF) lea eax, [edx+0C8h] ; Load Effective Address cmp ecx, eax ; Compare Two Operands jge short loc_40AA38 ; Jump if Greater or Equal (SF=OF) fldz ; Load +0.0 fcomp qword ptr [ebx+40h] ; Compare Real and Pop fnstsw ax ; Store Status Word (no wait) test ah, 41h ; Logical Compare jz short loc_40AA52 ; Jump if Zero (ZF=1) loc_40AA38: ; CODE XREF: sub_4094C0+156Aj cmp ecx, edx ; Compare Two Operands loc_40AA3A: ; CODE XREF: sub_4094C0+1560j jge short loc_40AA6E ; Jump if Greater or Equal (SF=OF) add edx, 0FFFFFF38h ; Add cmp ecx, edx ; Compare Two Operands jle short loc_40AA6E ; Jump if Less or Equal (ZF=1 | SF!=OF) fldz ; Load +0.0 fcomp qword ptr [ebx+40h] ; Compare Real and Pop fnstsw ax ; Store Status Word (no wait) test ah, 5 ; Logical Compare jp short loc_40AA6E ; Jump if Parity (PF=1) loc_40AA52: ; CODE XREF: sub_4094C0+1576j mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0CCh], 0 mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D3h], 1 loc_40AA6E: ; CODE XREF: sub_4094C0+1533j ; sub_4094C0+1548j ... mov ecx, [esi+ebp*4+194h] mov eax, [esi+edi*4+194h] mov edx, [ecx+10h] cmp edx, [eax+10h] ; Compare Two Operands jle short loc_40AA94 ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AA94 ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 loc_40AA94: ; CODE XREF: sub_4094C0+15C2j ; sub_4094C0+15CBj mov eax, [esi+ebp*4+194h] mov edi, [esi+edi*4+194h] mov ecx, [eax+10h] cmp ecx, [edi+10h] ; Compare Two Operands jge loc_40BBE9 ; Jump if Greater or Equal (SF=OF) cmp byte ptr [edi+80h], 0 ; Compare Two Operands jnz loc_40BBE9 ; Jump if Not Zero (ZF=0) mov byte ptr [edi+0CFh], 1 pop edi pop esi pop ebp pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40AACC: ; CODE XREF: sub_4094C0+1528j mov eax, [esi+edi*4+194h] cmp [eax+404h], ecx ; Compare Two Operands jnz loc_40AC59 ; Jump if Not Zero (ZF=0) cmp dword ptr [eax+98h], 0 ; Compare Two Operands jle short loc_40AB31 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov edx, [eax+9Ch] mov ecx, [esi+edx*4+194h] mov edx, [ecx+368h] mov ecx, [edx+6F4h] cmp ecx, 7Ah ; Compare Two Operands jz short loc_40AB0B ; Jump if Zero (ZF=1) cmp ecx, 7Bh ; Compare Two Operands jnz short loc_40AB31 ; Jump if Not Zero (ZF=0) loc_40AB0B: ; CODE XREF: sub_4094C0+1644j mov eax, [esi+edi*4+194h] mov byte ptr [eax+0CAh], 0 mov ecx, [esi+edi*4+194h] pop edi pop esi pop ebp mov byte ptr [ecx+0D1h], 1 pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40AB31: ; CODE XREF: sub_4094C0+1626j ; sub_4094C0+1649j mov ecx, 0FFFFFC18h cmp [eax+3FCh], ecx ; Compare Two Operands jz short loc_40AB82 ; Jump if Zero (ZF=1) mov eax, [esi+edi*4+194h] mov edx, [eax+400h] sub edx, [eax+18h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg loc_40AC59 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [esi+edi*4+194h] mov edx, [eax+3FCh] sub edx, [eax+10h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg loc_40AC59 ; Jump if Greater (ZF=0 & SF=OF) loc_40AB82: ; CODE XREF: sub_4094C0+167Cj mov eax, [esi+edi*4+194h] mov edx, [eax+400h] sub edx, [eax+18h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg short loc_40ABD8 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [esi+edi*4+194h] mov edx, [eax+3FCh] sub edx, [eax+10h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5Ah ; Compare Two Operands jg short loc_40ABD8 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [esi+edi*4+194h] mov [eax+3FCh], ecx mov edx, [esi+edi*4+194h] mov [edx+400h], ecx loc_40ABD8: ; CODE XREF: sub_4094C0+16DEj ; sub_4094C0+16FCj mov ecx, [esi+ebp*4+194h] mov eax, [esi+edi*4+194h] mov edx, [ecx+10h] cmp edx, [eax+10h] ; Compare Two Operands jle short loc_40ABFE ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40ABFE ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 loc_40ABFE: ; CODE XREF: sub_4094C0+172Cj ; sub_4094C0+1735j mov ecx, [esi+ebp*4+194h] mov eax, [esi+edi*4+194h] mov edx, [ecx+10h] cmp edx, [eax+10h] ; Compare Two Operands jge short loc_40AC24 ; Jump if Greater or Equal (SF=OF) cmp byte ptr [eax+80h], 0 ; Compare Two Operands jnz short loc_40AC24 ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0CFh], 1 loc_40AC24: ; CODE XREF: sub_4094C0+1752j ; sub_4094C0+175Bj cmp [esp+60h+var_50], 2 ; Compare Two Operands jnz short loc_40AC59 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AC42 ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 loc_40AC42: ; CODE XREF: sub_4094C0+1779j mov eax, [esi+edi*4+194h] cmp byte ptr [eax+80h], 0 ; Compare Two Operands jnz short loc_40AC59 ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0CFh], 1 loc_40AC59: ; CODE XREF: sub_4094C0+1619j ; sub_4094C0+169Aj ... cmp ebx, 3ECh ; Compare Two Operands jz loc_40B997 ; Jump if Zero (ZF=1) cmp ebx, 7D4h ; Compare Two Operands jz loc_40B997 ; Jump if Zero (ZF=1) mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40ACB4 ; Jump if Zero (ZF=1) mov edx, [esi+ebp*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40ACD9 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40ACD9 ; Jump if Greater (ZF=0 & SF=OF) loc_40ACB4: ; CODE XREF: sub_4094C0+17BFj cmp ebx, 0Eh ; Compare Two Operands jz loc_40B85B ; Jump if Zero (ZF=1) mov edx, [esi+ebp*4+194h] mov eax, [edx+8] push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 2 ; Compare Two Operands jg loc_40B85B ; Jump if Greater (ZF=0 & SF=OF) loc_40ACD9: ; CODE XREF: sub_4094C0+17DCj ; sub_4094C0+17F2j mov eax, [edx+368h] cmp dword ptr [eax+6F4h], 0C8h ; Compare Two Operands jnz short loc_40AD4A ; Jump if Not Zero (ZF=0) mov eax, [ecx+10h] mov edx, [edx+10h] lea ebx, [eax+7] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jle short loc_40AD01 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov byte ptr [ecx+0D0h], 1 jmp short loc_40AD0F ; Jump ; --------------------------------------------------------------------------- loc_40AD01: ; CODE XREF: sub_4094C0+1836j add eax, 0FFFFFFF9h ; Add cmp edx, eax ; Compare Two Operands jge short loc_40AD0F ; Jump if Greater or Equal (SF=OF) mov byte ptr [ecx+0CFh], 1 loc_40AD0F: ; CODE XREF: sub_4094C0+183Fj ; sub_4094C0+1846j mov edi, [esi+edi*4+194h] mov eax, [edi+18h] mov ecx, [esi+ebp*4+194h] mov ecx, [ecx+18h] lea edx, [eax+2] ; Load Effective Address cmp ecx, edx ; Compare Two Operands jg loc_40B986 ; Jump if Greater (ZF=0 & SF=OF) add eax, 0FFFFFFFEh ; Add cmp ecx, eax ; Compare Two Operands jge loc_40BBE9 ; Jump if Greater or Equal (SF=OF) loc_40AD39: ; CODE XREF: sub_4094C0+24C0j mov byte ptr [edi+0CDh], 1 pop edi pop esi pop ebp pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40AD4A: ; CODE XREF: sub_4094C0+1829j mov eax, [esp+60h+var_2C] mov ecx, [esp+60h+var_28] mov edx, [esp+60h+var_30] push eax mov eax, [esp+64h+var_50] push ecx push edx push ebx push eax push edi push ebp mov ecx, esi call sub_403A40 ; Call Procedure test eax, eax ; Logical Compare jnz loc_40BBE9 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp [ecx+404h], eax ; Compare Two Operands jz short loc_40ADBA ; Jump if Zero (ZF=1) mov edx, [esi+ebp*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg loc_40B0DB ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg loc_40B0DB ; Jump if Greater (ZF=0 & SF=OF) loc_40ADBA: ; CODE XREF: sub_4094C0+18BDj mov eax, 1 cmp [esp+60h+var_40], eax ; Compare Two Operands jz short loc_40ADCD ; Jump if Zero (ZF=1) cmp dword ptr ds:[44F608h], eax ; Compare Two Operands jnz short loc_40ADE3 ; Jump if Not Zero (ZF=0) loc_40ADCD: ; CODE XREF: sub_4094C0+1903j cmp [esp+60h+var_50], 2 ; Compare Two Operands jnz short loc_40ADE3 ; Jump if Not Zero (ZF=0) cmp byte ptr [ecx+80h], 0 ; Compare Two Operands jnz short loc_40ADE3 ; Jump if Not Zero (ZF=0) mov [ecx+0CFh], al loc_40ADE3: ; CODE XREF: sub_4094C0+190Bj ; sub_4094C0+1912j ... cmp [esp+60h+var_4C], eax ; Compare Two Operands jnz short loc_40AE07 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_50], 2 ; Compare Two Operands jnz short loc_40AE07 ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AE07 ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 loc_40AE07: ; CODE XREF: sub_4094C0+1927j ; sub_4094C0+192Ej ... mov eax, [esi+edi*4+194h] mov ecx, [eax+368h] mov ecx, [ecx+6F4h] cmp ecx, 4 ; Compare Two Operands jz loc_40AF5D ; Jump if Zero (ZF=1) cmp ecx, 5 ; Compare Two Operands jz loc_40AF5D ; Jump if Zero (ZF=1) cmp ecx, 1Fh ; Compare Two Operands jz loc_40AF5D ; Jump if Zero (ZF=1) mov ecx, [eax+2FCh] mov edx, [esi+ebp*4+194h] lea ebx, [ecx+ecx] ; Load Effective Address cmp [edx+2FCh], ebx ; Compare Two Operands jg short loc_40AE5B ; Jump if Greater (ZF=0 & SF=OF) cmp ecx, 64h ; Compare Two Operands jg short loc_40AE83 ; Jump if Greater (ZF=0 & SF=OF) cmp dword ptr [eax+304h], 64h ; Compare Two Operands jle short loc_40AE83 ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40AE5B: ; CODE XREF: sub_4094C0+198Bj cmp [esp+60h+arg_4], 1 ; Compare Two Operands jnz short loc_40AE83 ; Jump if Not Zero (ZF=0) mov ecx, [edx+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz short loc_40AE83 ; Jump if Not Zero (ZF=0) cmp edi, 14h ; Compare Two Operands jl short loc_40AE83 ; Jump if Less (SF!=OF) cmp dword ptr [eax+364h], 5 ; Compare Two Operands jnz loc_40AF5D ; Jump if Not Zero (ZF=0) loc_40AE83: ; CODE XREF: sub_4094C0+1990j ; sub_4094C0+1999j ... cmp [esp+60h+var_50], 13h ; Compare Two Operands jz loc_40B03D ; Jump if Zero (ZF=1) mov ecx, [eax+10h] mov edx, [edx+10h] lea ebx, [ecx+3Ch] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jg short loc_40AEA8 ; Jump if Greater (ZF=0 & SF=OF) cmp edx, ecx ; Compare Two Operands jle short loc_40AEEE ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AEEE ; Jump if Not Zero (ZF=0) loc_40AEA8: ; CODE XREF: sub_4094C0+19D9j cmp [esp+60h+var_40], 0 ; Compare Two Operands jnz short loc_40AEEE ; Jump if Not Zero (ZF=0) cmp dword ptr ds:[44F608h], 0 ; Compare Two Operands jz short loc_40AEC1 ; Jump if Zero (ZF=1) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AEEE ; Jump if Not Zero (ZF=0) loc_40AEC1: ; CODE XREF: sub_4094C0+19F6j mov byte ptr [eax+0D0h], 1 mov edx, dword ptr ds:[44F610h] add edx, 23h ; Add push edx push 1Ch call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40AEEE ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C9h], 0 loc_40AEEE: ; CODE XREF: sub_4094C0+19DDj ; sub_4094C0+19E6j ... mov eax, [esi+edi*4+194h] mov ecx, [eax+10h] mov edx, [esi+ebp*4+194h] mov edx, [edx+10h] lea ebx, [ecx-3Ch] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jl short loc_40AF1E ; Jump if Less (SF!=OF) cmp edx, ecx ; Compare Two Operands jge loc_40B03D ; Jump if Greater or Equal (SF=OF) cmp byte ptr [eax+80h], 0 ; Compare Two Operands jnz loc_40B03D ; Jump if Not Zero (ZF=0) loc_40AF1E: ; CODE XREF: sub_4094C0+1A47j cmp [esp+60h+var_4C], 0 ; Compare Two Operands jnz loc_40B03D ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0CFh], 1 mov eax, dword ptr ds:[44F610h] add eax, 23h ; Add push eax push 1Dh call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz loc_40B03D ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] mov [ecx+0C8h], al jmp loc_40B03D ; Jump ; --------------------------------------------------------------------------- loc_40AF5D: ; CODE XREF: sub_4094C0+195Dj ; sub_4094C0+1966j ... mov ecx, [eax+10h] mov edx, [esi+ebp*4+194h] mov edx, [edx+10h] lea ebx, [ecx+0AAh] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jg short loc_40AF92 ; Jump if Greater (ZF=0 & SF=OF) lea ebx, [ecx+96h] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jg short loc_40AF89 ; Jump if Greater (ZF=0 & SF=OF) cmp [esp+60h+var_50], 7 ; Compare Two Operands jnz short loc_40AFCD ; Jump if Not Zero (ZF=0) cmp edx, ecx ; Compare Two Operands jle short loc_40AFCD ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40AF89: ; CODE XREF: sub_4094C0+1ABCj cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz short loc_40AFCD ; Jump if Not Zero (ZF=0) loc_40AF92: ; CODE XREF: sub_4094C0+1AB2j cmp [esp+60h+var_40], 0 ; Compare Two Operands jnz short loc_40AFCD ; Jump if Not Zero (ZF=0) cmp dword ptr ds:[44F608h], 0 ; Compare Two Operands jnz short loc_40AFCD ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 mov eax, dword ptr ds:[44F610h] add eax, 23h ; Add push eax push 1Ah call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40AFCD ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] mov [ecx+0C9h], al loc_40AFCD: ; CODE XREF: sub_4094C0+1AC3j ; sub_4094C0+1AC7j ... mov edx, [esi+edi*4+194h] mov eax, [edx+10h] mov ecx, [esi+ebp*4+194h] mov ecx, [ecx+10h] lea ebx, [eax-0AAh] ; Load Effective Address cmp ecx, ebx ; Compare Two Operands jl short loc_40B009 ; Jump if Less (SF!=OF) lea ebx, [eax-96h] ; Load Effective Address cmp ecx, ebx ; Compare Two Operands jl short loc_40B000 ; Jump if Less (SF!=OF) cmp [esp+60h+var_50], 7 ; Compare Two Operands jnz short loc_40B03D ; Jump if Not Zero (ZF=0) cmp ecx, eax ; Compare Two Operands jge short loc_40B03D ; Jump if Greater or Equal (SF=OF) loc_40B000: ; CODE XREF: sub_4094C0+1B33j cmp byte ptr [edx+80h], 0 ; Compare Two Operands jnz short loc_40B03D ; Jump if Not Zero (ZF=0) loc_40B009: ; CODE XREF: sub_4094C0+1B29j cmp [esp+60h+var_4C], 0 ; Compare Two Operands jnz short loc_40B03D ; Jump if Not Zero (ZF=0) mov byte ptr [edx+0CFh], 1 mov edx, dword ptr ds:[44F610h] add edx, 23h ; Add push edx push 1Bh call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B03D ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C8h], 0 loc_40B03D: ; CODE XREF: sub_4094C0+19C8j ; sub_4094C0+1A4Bj ... mov eax, [esi+edi*4+194h] mov ecx, [eax+18h] mov edx, [esi+ebp*4+194h] add ecx, 3 ; Add cmp [edx+18h], ecx ; Compare Two Operands jle short loc_40B05D ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp [esp+60h+var_30], 0 ; Compare Two Operands jz short loc_40B076 ; Jump if Zero (ZF=1) loc_40B05D: ; CODE XREF: sub_4094C0+1B94j mov ecx, 1 cmp [esp+60h+var_40], ecx ; Compare Two Operands jz short loc_40B06E ; Jump if Zero (ZF=1) cmp [esp+60h+var_4C], ecx ; Compare Two Operands jnz short loc_40B090 ; Jump if Not Zero (ZF=0) loc_40B06E: ; CODE XREF: sub_4094C0+1BA6j cmp [esp+60h+var_20], ecx ; Compare Two Operands jnz short loc_40B090 ; Jump if Not Zero (ZF=0) jmp short loc_40B07B ; Jump ; --------------------------------------------------------------------------- loc_40B076: ; CODE XREF: sub_4094C0+1B9Bj mov ecx, 1 loc_40B07B: ; CODE XREF: sub_4094C0+1BB4j cmp [esp+60h+var_24], 0 ; Compare Two Operands jnz short loc_40B090 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_50], 13h ; Compare Two Operands jz short loc_40B090 ; Jump if Zero (ZF=1) mov byte ptr [eax+0CEh], 1 loc_40B090: ; CODE XREF: sub_4094C0+1BACj ; sub_4094C0+1BB2j ... mov eax, [esi+edi*4+194h] mov edx, [eax+18h] mov ebx, [esi+ebp*4+194h] sub edx, 3 ; Integer Subtraction cmp [ebx+18h], edx ; Compare Two Operands jge short loc_40B0B0 ; Jump if Greater or Equal (SF=OF) cmp [esp+60h+var_30], 0 ; Compare Two Operands jz short loc_40B0C2 ; Jump if Zero (ZF=1) loc_40B0B0: ; CODE XREF: sub_4094C0+1BE7j cmp [esp+60h+var_40], ecx ; Compare Two Operands jz short loc_40B0BC ; Jump if Zero (ZF=1) cmp [esp+60h+var_4C], ecx ; Compare Two Operands jnz short loc_40B0D7 ; Jump if Not Zero (ZF=0) loc_40B0BC: ; CODE XREF: sub_4094C0+1BF4j cmp [esp+60h+var_24], ecx ; Compare Two Operands jnz short loc_40B0D7 ; Jump if Not Zero (ZF=0) loc_40B0C2: ; CODE XREF: sub_4094C0+1BEEj cmp [esp+60h+var_20], 0 ; Compare Two Operands jnz short loc_40B0D7 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_50], 13h ; Compare Two Operands jz short loc_40B0D7 ; Jump if Zero (ZF=1) mov byte ptr [eax+0CDh], 1 loc_40B0D7: ; CODE XREF: sub_4094C0+1BFAj ; sub_4094C0+1C00j ... mov ebx, [esp+60h+var_44] loc_40B0DB: ; CODE XREF: sub_4094C0+18DAj ; sub_4094C0+18F4j mov eax, [esi+edi*4+194h] cmp dword ptr [eax+98h], 0 ; Compare Two Operands jle short loc_40B10C ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [esp+60h+var_30] mov edx, [esp+60h+var_2C] mov eax, [esp+60h+var_50] push ecx push edx push ebx push eax push edi push ebp mov ecx, esi call sub_408CC0 ; Call Procedure test eax, eax ; Logical Compare jz loc_40BBE9 ; Jump if Zero (ZF=1) loc_40B10C: ; CODE XREF: sub_4094C0+1C29j mov eax, dword ptr ds:[44F60Ch] lea ecx, ds:0[eax*8] ; Load Effective Address sub ecx, eax ; Integer Subtraction add ecx, 0Ah ; Add push ecx push 1Eh call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B192 ; Jump if Not Zero (ZF=0) cmp ebx, 3 ; Compare Two Operands jz short loc_40B147 ; Jump if Zero (ZF=1) mov eax, 51EB851Fh imul ebx ; Signed Multiply sar edx, 5 ; Shift Arithmetic Right mov eax, edx shr eax, 1Fh ; Shift Logical Right add eax, edx ; Add cmp eax, 3 ; Compare Two Operands jnz short loc_40B192 ; Jump if Not Zero (ZF=0) loc_40B147: ; CODE XREF: sub_4094C0+1C6Fj mov ecx, [esi+ebp*4+194h] mov edx, [esi+edi*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 9 ; Compare Two Operands jge short loc_40B192 ; Jump if Greater or Equal (SF=OF) mov al, [ecx+80h] test al, al ; Logical Compare jnz short loc_40B17F ; Jump if Not Zero (ZF=0) mov ebx, [ecx+10h] cmp ebx, [edx+10h] ; Compare Two Operands mov ebx, [esp+60h+var_44] jl short loc_40B18B ; Jump if Less (SF!=OF) loc_40B17F: ; CODE XREF: sub_4094C0+1CB1j cmp al, 1 ; Compare Two Operands jnz short loc_40B192 ; Jump if Not Zero (ZF=0) mov ecx, [ecx+10h] cmp ecx, [edx+10h] ; Compare Two Operands jle short loc_40B192 ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40B18B: ; CODE XREF: sub_4094C0+1CBDj mov byte ptr [edx+0D3h], 1 loc_40B192: ; CODE XREF: sub_4094C0+1C6Aj ; sub_4094C0+1C85j ... mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B1D5 ; Jump if Zero (ZF=1) mov edx, [esi+ebp*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40B214 ; Jump if Greater (ZF=0 & SF=OF) mov ecx, [ecx+10h] sub ecx, [edx+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40B214 ; Jump if Greater (ZF=0 & SF=OF) loc_40B1D5: ; CODE XREF: sub_4094C0+1CE0j mov eax, dword ptr ds:[44F60Ch] lea edx, [eax+eax*4+0Ah] ; Load Effective Address add edx, edx ; Add push edx push 1Fh call sub_417190 ; Call Procedure add esp, 8 ; Add cmp eax, 3 ; Compare Two Operands jge short loc_40B214 ; Jump if Greater or Equal (SF=OF) push 14h push 20h call sub_417190 ; Call Procedure add esp, 8 ; Add cmp eax, 3 ; Compare Two Operands jge short loc_40B214 ; Jump if Greater or Equal (SF=OF) cmp ebx, 0Eh ; Compare Two Operands jz short loc_40B214 ; Jump if Zero (ZF=1) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0D2h], 1 loc_40B214: ; CODE XREF: sub_4094C0+1CFDj ; sub_4094C0+1D13j ... mov eax, [esi+edi*4+194h] mov ecx, [eax+368h] mov eax, [ecx+6F4h] cmp eax, 4 ; Compare Two Operands jz short loc_40B236 ; Jump if Zero (ZF=1) cmp eax, 5 ; Compare Two Operands jz short loc_40B236 ; Jump if Zero (ZF=1) cmp eax, 1Fh ; Compare Two Operands jnz short loc_40B23B ; Jump if Not Zero (ZF=0) loc_40B236: ; CODE XREF: sub_4094C0+1D6Aj ; sub_4094C0+1D6Fj cmp ebx, 10h ; Compare Two Operands jnz short loc_40B2AF ; Jump if Not Zero (ZF=0) loc_40B23B: ; CODE XREF: sub_4094C0+1D74j mov ebp, [esi+edi*4+194h] mov edx, [esp+60h+arg_0] fld qword ptr [ebp+40h] ; Load Real mov ebx, [esi+edx*4+194h] call sub_4451C0 ; Call Procedure mov ecx, [ebx+10h] add eax, eax ; Add sub ecx, eax ; Integer Subtraction sub ecx, [ebp+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 50h ; Compare Two Operands jge short loc_40B2AF ; Jump if Greater or Equal (SF=OF) mov edx, [ebx+18h] mov eax, ebp sub edx, [eax+18h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5 ; Compare Two Operands jge short loc_40B2AF ; Jump if Greater or Equal (SF=OF) mov eax, dword ptr ds:[44F61Ch] add eax, 3 ; Add push eax push 21h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B2AF ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_44], 0Eh ; Compare Two Operands jz short loc_40B2AF ; Jump if Zero (ZF=1) mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0D1h], 1 loc_40B2AF: ; CODE XREF: sub_4094C0+1D79j ; sub_4094C0+1DABj ... mov ebp, [esi+edi*4+194h] mov ecx, [ebp+98h] test ecx, ecx ; Logical Compare jnz loc_40B5D8 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_44], 10h ; Compare Two Operands jnz loc_40B374 ; Jump if Not Zero (ZF=0) mov edx, [ebp+368h] mov eax, [edx+6F4h] cmp eax, 4 ; Compare Two Operands jz short loc_40B2EE ; Jump if Zero (ZF=1) cmp eax, 5 ; Compare Two Operands jz short loc_40B2EE ; Jump if Zero (ZF=1) cmp eax, 1Fh ; Compare Two Operands jnz loc_40B374 ; Jump if Not Zero (ZF=0) loc_40B2EE: ; CODE XREF: sub_4094C0+1E1Ej ; sub_4094C0+1E23j mov ebx, [esi+edi*4+194h] fld qword ptr [ebx+40h] ; Load Real call sub_4451C0 ; Call Procedure mov edx, [esp+60h+arg_0] add eax, eax ; Add mov ecx, eax mov eax, [esi+edx*4+194h] mov eax, [eax+10h] sub eax, ecx ; Integer Subtraction sub eax, [ebx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 15Eh ; Compare Two Operands jge loc_40B79F ; Jump if Greater or Equal (SF=OF) mov ebx, edx mov eax, [esi+ebx*4+194h] mov ecx, [eax+18h] sub ecx, [ebp+18h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5 ; Compare Two Operands jge loc_40B79F ; Jump if Greater or Equal (SF=OF) mov edx, dword ptr ds:[44F61Ch] add edx, 3 ; Add push edx push 22h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz loc_40B79F ; Jump if Not Zero (ZF=0) mov eax, [esi+ebx*4+194h] mov ecx, [eax+10h] jmp loc_40B5A0 ; Jump ; --------------------------------------------------------------------------- loc_40B374: ; CODE XREF: sub_4094C0+1E09j ; sub_4094C0+1E28j test ecx, ecx ; Logical Compare jnz loc_40B5D8 ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_44], 10h ; Compare Two Operands jz loc_40B5D8 ; Jump if Zero (ZF=1) mov ecx, [ebp+368h] mov eax, [ecx+6F4h] cmp eax, 4 ; Compare Two Operands jz short loc_40B3AB ; Jump if Zero (ZF=1) cmp eax, 5 ; Compare Two Operands jz short loc_40B3AB ; Jump if Zero (ZF=1) cmp eax, 1Fh ; Compare Two Operands jz short loc_40B3AB ; Jump if Zero (ZF=1) cmp eax, 24h ; Compare Two Operands jnz loc_40B5D8 ; Jump if Not Zero (ZF=0) loc_40B3AB: ; CODE XREF: sub_4094C0+1ED6j ; sub_4094C0+1EDBj ... mov ebx, [esp+60h+arg_0] mov eax, [esi+ebx*4+194h] mov edx, [eax+10h] sub edx, [ebp+10h] ; Integer Subtraction cmp edx, 64h ; Compare Two Operands jge short loc_40B3F4 ; Jump if Greater or Equal (SF=OF) mov eax, [eax+18h] sub eax, [ebp+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 50h ; Compare Two Operands jge short loc_40B3F4 ; Jump if Greater or Equal (SF=OF) mov ecx, dword ptr ds:[44F61Ch] add ecx, 2 ; Add push ecx push 23h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B3F4 ; Jump if Not Zero (ZF=0) mov eax, 1 jmp short loc_40B3F6 ; Jump ; --------------------------------------------------------------------------- loc_40B3F4: ; CODE XREF: sub_4094C0+1EFFj ; sub_4094C0+1F13j ... xor eax, eax ; Logical Exclusive OR loc_40B3F6: ; CODE XREF: sub_4094C0+1F32j push eax call sub_403270 ; Call Procedure add esp, 4 ; Add test eax, eax ; Logical Compare jz loc_40B51C ; Jump if Zero (ZF=1) cmp [esp+60h+var_50], 7 ; Compare Two Operands jz loc_40B51C ; Jump if Zero (ZF=1) mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B459 ; Jump if Zero (ZF=1) mov edx, [esi+ebx*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg loc_40B4C8 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40B4C8 ; Jump if Greater (ZF=0 & SF=OF) loc_40B459: ; CODE XREF: sub_4094C0+1F60j mov edx, [esi+ebx*4+194h] mov eax, [edx+10h] cmp eax, 0FAh ; Compare Two Operands mov edx, dword ptr ds:[44F604h] jl short loc_40B475 ; Jump if Less (SF!=OF) cmp eax, [ecx+10h] ; Compare Two Operands jge short loc_40B49D ; Jump if Greater or Equal (SF=OF) loc_40B475: ; CODE XREF: sub_4094C0+1FAEj lea ebp, [edx-0FAh] ; Load Effective Address cmp eax, ebp ; Compare Two Operands jg short loc_40B49D ; Jump if Greater (ZF=0 & SF=OF) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0D0h], 1 mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0C9h], 0 jmp short loc_40B4C8 ; Jump ; --------------------------------------------------------------------------- loc_40B49D: ; CODE XREF: sub_4094C0+1FB3j ; sub_4094C0+1FBDj add edx, 0FFFFFF06h ; Add cmp eax, edx ; Compare Two Operands jg short loc_40B4AC ; Jump if Greater (ZF=0 & SF=OF) cmp eax, [ecx+10h] ; Compare Two Operands jle short loc_40B4C8 ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40B4AC: ; CODE XREF: sub_4094C0+1FE5j mov edx, [esi+edi*4+194h] mov byte ptr [edx+0CFh], 1 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C8h], 0 loc_40B4C8: ; CODE XREF: sub_4094C0+1F7Dj ; sub_4094C0+1F97j ... mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B513 ; Jump if Zero (ZF=1) mov edx, [esi+ebx*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) mov ecx, [ecx+10h] sub ecx, [edx+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) loc_40B513: ; CODE XREF: sub_4094C0+2016j push 11h push 24h jmp loc_40B785 ; Jump ; --------------------------------------------------------------------------- loc_40B51C: ; CODE XREF: sub_4094C0+1F41j ; sub_4094C0+1F4Cj mov ebp, [esi+edi*4+194h] mov eax, [esp+60h+arg_0] fld qword ptr [ebp+40h] ; Load Real mov ebx, [esi+eax*4+194h] call sub_4451C0 ; Call Procedure mov ecx, [ebx+10h] add eax, eax ; Add sub ecx, eax ; Integer Subtraction sub ecx, [ebp+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 12Ch ; Compare Two Operands jge loc_40B79F ; Jump if Greater or Equal (SF=OF) mov edx, [ebx+18h] sub edx, [ebp+18h] ; Integer Subtraction push edx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 5 ; Compare Two Operands jge loc_40B79F ; Jump if Greater or Equal (SF=OF) mov eax, dword ptr ds:[44F61Ch] add eax, 3 ; Add push eax push 25h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz loc_40B79F ; Jump if Not Zero (ZF=0) cmp [esp+60h+var_44], 0Eh ; Compare Two Operands jz loc_40B79F ; Jump if Zero (ZF=1) mov ecx, [esp+60h+arg_0] mov edx, [esi+ecx*4+194h] mov ecx, [edx+10h] loc_40B5A0: ; CODE XREF: sub_4094C0+1EAFj mov eax, [esi+edi*4+194h] mov edx, [eax+10h] cmp ecx, edx ; Compare Two Operands jle short loc_40B5BF ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp byte ptr [eax+80h], 0 ; Compare Two Operands jz short loc_40B5CC ; Jump if Zero (ZF=1) cmp ecx, edx ; Compare Two Operands jg loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) loc_40B5BF: ; CODE XREF: sub_4094C0+20ECj cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz loc_40B79F ; Jump if Not Zero (ZF=0) loc_40B5CC: ; CODE XREF: sub_4094C0+20F5j mov byte ptr [eax+0D1h], 1 jmp loc_40B79F ; Jump ; --------------------------------------------------------------------------- loc_40B5D8: ; CODE XREF: sub_4094C0+1DFEj ; sub_4094C0+1EB6j ... mov ecx, [ebp+2FCh] mov ebx, [esp+60h+arg_0] mov eax, [esi+ebx*4+194h] lea edx, [ecx+ecx] ; Load Effective Address cmp [eax+2FCh], edx ; Compare Two Operands jg short loc_40B60A ; Jump if Greater (ZF=0 & SF=OF) cmp ecx, 64h ; Compare Two Operands jg loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) cmp dword ptr [ebp+304h], 64h ; Compare Two Operands jle loc_40B79F ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40B60A: ; CODE XREF: sub_4094C0+2132j cmp [esp+60h+arg_4], 1 ; Compare Two Operands jnz loc_40B79F ; Jump if Not Zero (ZF=0) mov ecx, [eax+368h] cmp dword ptr [ecx+6F8h], 0 ; Compare Two Operands jnz loc_40B79F ; Jump if Not Zero (ZF=0) cmp edi, 14h ; Compare Two Operands jl loc_40B79F ; Jump if Less (SF!=OF) cmp dword ptr [ebp+364h], 5 ; Compare Two Operands jz loc_40B79F ; Jump if Zero (ZF=1) mov edx, [eax+10h] sub edx, [ebp+10h] ; Integer Subtraction cmp edx, 64h ; Compare Two Operands jge short loc_40B67C ; Jump if Greater or Equal (SF=OF) mov eax, [eax+18h] sub eax, [ebp+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 50h ; Compare Two Operands jge short loc_40B67C ; Jump if Greater or Equal (SF=OF) mov ecx, dword ptr ds:[44F61Ch] add ecx, 2 ; Add push ecx push 26h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B67C ; Jump if Not Zero (ZF=0) mov eax, 1 jmp short loc_40B67E ; Jump ; --------------------------------------------------------------------------- loc_40B67C: ; CODE XREF: sub_4094C0+2187j ; sub_4094C0+219Bj ... xor eax, eax ; Logical Exclusive OR loc_40B67E: ; CODE XREF: sub_4094C0+21BAj push eax call sub_403270 ; Call Procedure add esp, 4 ; Add test eax, eax ; Logical Compare jz loc_40B79F ; Jump if Zero (ZF=1) cmp [esp+60h+var_50], 7 ; Compare Two Operands jz loc_40B79F ; Jump if Zero (ZF=1) mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B6DD ; Jump if Zero (ZF=1) mov edx, [esi+ebx*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40B73E ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40B73E ; Jump if Greater (ZF=0 & SF=OF) loc_40B6DD: ; CODE XREF: sub_4094C0+21E8j mov edx, [esi+ebx*4+194h] mov eax, [edx+10h] cmp eax, 0FAh ; Compare Two Operands mov edx, dword ptr ds:[44F604h] jl short loc_40B6F9 ; Jump if Less (SF!=OF) cmp eax, [ecx+10h] ; Compare Two Operands jge short loc_40B71A ; Jump if Greater or Equal (SF=OF) loc_40B6F9: ; CODE XREF: sub_4094C0+2232j lea ebp, [edx-0FAh] ; Load Effective Address cmp eax, ebp ; Compare Two Operands jg short loc_40B71A ; Jump if Greater (ZF=0 & SF=OF) mov byte ptr [ecx+0D0h], 1 mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C9h], 0 jmp short loc_40B73E ; Jump ; --------------------------------------------------------------------------- loc_40B71A: ; CODE XREF: sub_4094C0+2237j ; sub_4094C0+2241j add edx, 0FFFFFF06h ; Add cmp eax, edx ; Compare Two Operands jg short loc_40B729 ; Jump if Greater (ZF=0 & SF=OF) cmp eax, [ecx+10h] ; Compare Two Operands jle short loc_40B73E ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40B729: ; CODE XREF: sub_4094C0+2262j mov byte ptr [ecx+0CFh], 1 mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0C8h], 0 loc_40B73E: ; CODE XREF: sub_4094C0+2205j ; sub_4094C0+221Bj ... mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B781 ; Jump if Zero (ZF=1) mov edx, [esi+ebx*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) mov ecx, [ecx+10h] sub ecx, [edx+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40B79F ; Jump if Greater (ZF=0 & SF=OF) loc_40B781: ; CODE XREF: sub_4094C0+228Cj push 11h push 27h loc_40B785: ; CODE XREF: sub_4094C0+2057j call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B79F ; Jump if Not Zero (ZF=0) mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D2h], 1 loc_40B79F: ; CODE XREF: sub_4094C0+1E62j ; sub_4094C0+1E83j ... mov eax, [esp+60h+var_4C] mov ecx, [esp+60h+var_40] mov edx, [esp+60h+var_2C] push eax mov eax, [esp+64h+var_44] push ecx mov ecx, [esp+68h+var_50] push edx mov edx, [esp+6Ch+arg_0] push eax push ecx push edi push edx mov ecx, esi call sub_4034F0 ; Call Procedure loc_40B7C5: ; CODE XREF: sub_4094C0+F85j ; sub_4094C0+1477j cmp [esp+60h+arg_0], 0FFFFFFFFh ; Compare Two Operands jnz loc_40BBE9 ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B817 ; Jump if Zero (ZF=1) mov edx, [esp+60h+var_14] mov edx, [esi+edx*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40B827 ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jg short loc_40B827 ; Jump if Greater (ZF=0 & SF=OF) loc_40B817: ; CODE XREF: sub_4094C0+231Ej cmp dword ptr ds:[44F608h], 1 ; Compare Two Operands jnz short loc_40B827 ; Jump if Not Zero (ZF=0) mov byte ptr [ecx+0CFh], 1 loc_40B827: ; CODE XREF: sub_4094C0+233Fj ; sub_4094C0+2355j ... mov esi, [esi+edi*4+194h] mov ecx, [esi+368h] mov eax, [ecx+6F4h] cmp eax, 7 ; Compare Two Operands jnz loc_40BBB6 ; Jump if Not Zero (ZF=0) mov eax, [esi+70h] cmp eax, 0FFh ; Compare Two Operands jl loc_40BBE9 ; Jump if Less (SF!=OF) cmp eax, 105h ; Compare Two Operands jmp loc_40BBE0 ; Jump ; --------------------------------------------------------------------------- loc_40B85B: ; CODE XREF: sub_4094C0+17F7j ; sub_4094C0+1813j mov eax, [esi+ebp*4+194h] mov ebx, dword ptr ds:[44F604h] mov edx, [eax+10h] add ebx, 0FFFFFFE2h ; Add cmp edx, ebx ; Compare Two Operands jle short loc_40B898 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0CFh], 1 mov ecx, [esi+edi*4+194h] pop edi pop esi pop ebp mov byte ptr [ecx+0C8h], 0 pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40B898: ; CODE XREF: sub_4094C0+23B0j cmp edx, 1Eh ; Compare Two Operands jge short loc_40B8C3 ; Jump if Greater or Equal (SF=OF) mov edx, [esi+edi*4+194h] mov byte ptr [edx+0D0h], 1 mov eax, [esi+edi*4+194h] pop edi pop esi pop ebp mov byte ptr [eax+0C9h], 0 pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40B8C3: ; CODE XREF: sub_4094C0+23DBj mov eax, [eax+18h] sub eax, [ecx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 2Dh ; Compare Two Operands jle short loc_40B8F0 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov eax, edx sub eax, [ecx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 15Eh ; Compare Two Operands jg loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) loc_40B8F0: ; CODE XREF: sub_4094C0+2415j cmp edx, [ecx+10h] ; Compare Two Operands jle short loc_40B923 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov byte ptr [ecx+0CFh], 1 mov ecx, dword ptr ds:[44F610h] add ecx, 23h ; Add push ecx push 18h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B94E ; Jump if Not Zero (ZF=0) mov edx, [esi+edi*4+194h] mov [edx+0C8h], al jmp short loc_40B94E ; Jump ; --------------------------------------------------------------------------- loc_40B923: ; CODE XREF: sub_4094C0+2433j mov byte ptr [ecx+0D0h], 1 mov eax, dword ptr ds:[44F610h] add eax, 23h ; Add push eax push 19h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40B94E ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] mov [ecx+0C9h], al loc_40B94E: ; CODE XREF: sub_4094C0+2452j ; sub_4094C0+2461j ... mov edx, [esi+ebp*4+194h] mov eax, [edx+18h] mov edi, [esi+edi*4+194h] cmp eax, [edi+18h] ; Compare Two Operands jl short loc_40B986 ; Jump if Less (SF!=OF) mov ecx, [esp+60h+var_4] mov edx, [esi+7D4h] imul ecx, 990h ; Signed Multiply mov ecx, [ecx+edx+4D45DB4h] add ecx, 0Ah ; Add cmp eax, ecx ; Compare Two Operands jge loc_40AD39 ; Jump if Greater or Equal (SF=OF) loc_40B986: ; CODE XREF: sub_4094C0+1868j ; sub_4094C0+24A2j mov byte ptr [edi+0CEh], 1 pop edi pop esi pop ebp pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40B997: ; CODE XREF: sub_4094C0+179Fj ; sub_4094C0+17ABj mov ecx, [esi+edi*4+194h] cmp dword ptr [ecx+404h], 0 ; Compare Two Operands jz short loc_40B9F4 ; Jump if Zero (ZF=1) mov edx, [esi+ebp*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 96h ; Compare Two Operands jg short loc_40B9DA ; Jump if Greater (ZF=0 & SF=OF) mov eax, [ecx+10h] sub eax, [edx+10h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 0F0h ; Compare Two Operands jle short loc_40B9F4 ; Jump if Less or Equal (ZF=1 | SF!=OF) loc_40B9DA: ; CODE XREF: sub_4094C0+2502j mov edx, [edx+368h] mov eax, [edx+6F4h] cmp eax, 7Ah ; Compare Two Operands jz short loc_40B9F4 ; Jump if Zero (ZF=1) cmp eax, 7Bh ; Compare Two Operands jnz loc_40BB61 ; Jump if Not Zero (ZF=0) loc_40B9F4: ; CODE XREF: sub_4094C0+24E5j ; sub_4094C0+2518j ... mov eax, [esi+ebp*4+194h] mov eax, [eax+10h] mov edx, [ecx+10h] lea ebx, [eax+6] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jle loc_40BA9C ; Jump if Less or Equal (ZF=1 | SF!=OF) mov ecx, [esi+edi*4+194h] mov byte ptr [ecx+0CFh], 1 mov edx, [esi+ebp*4+194h] mov eax, [edx+10h] mov ecx, [esi+edi*4+194h] add eax, 0FAh ; Add cmp [ecx+10h], eax ; Compare Two Operands jle short loc_40BA5B ; Jump if Less or Equal (ZF=1 | SF!=OF) mov edx, dword ptr ds:[44F61Ch] add edx, 3 ; Add push edx push 16h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40BA5B ; Jump if Not Zero (ZF=0) mov eax, [esi+edi*4+194h] mov byte ptr [eax+0C8h], 0 loc_40BA5B: ; CODE XREF: sub_4094C0+2573j ; sub_4094C0+258Bj mov ecx, [esi+ebp*4+194h] mov edx, [ecx+10h] mov eax, [esi+edi*4+194h] add edx, 64h ; Add cmp [eax+10h], edx ; Compare Two Operands jge loc_40BB2F ; Jump if Greater or Equal (SF=OF) cmp [esp+60h+var_50], 2 ; Compare Two Operands jnz loc_40BB2F ; Jump if Not Zero (ZF=0) cmp byte ptr [eax+80h], 1 ; Compare Two Operands jnz loc_40BB2F ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0D0h], 1 jmp loc_40BB2F ; Jump ; --------------------------------------------------------------------------- loc_40BA9C: ; CODE XREF: sub_4094C0+2546j add eax, 0FFFFFFFAh ; Add cmp edx, eax ; Compare Two Operands jge loc_40BB2F ; Jump if Greater or Equal (SF=OF) cmp dword ptr ds:[44F608h], 0 ; Compare Two Operands jnz short loc_40BAB7 ; Jump if Not Zero (ZF=0) mov byte ptr [ecx+0D0h], 1 loc_40BAB7: ; CODE XREF: sub_4094C0+25EEj mov eax, [esi+ebp*4+194h] mov ecx, [eax+10h] mov edx, [esi+edi*4+194h] sub ecx, 0FAh ; Integer Subtraction cmp [edx+10h], ecx ; Compare Two Operands jge short loc_40BAFF ; Jump if Greater or Equal (SF=OF) mov eax, dword ptr ds:[44F61Ch] add eax, 3 ; Add push eax push 17h call sub_417190 ; Call Procedure add esp, 8 ; Add test eax, eax ; Logical Compare jnz short loc_40BAFF ; Jump if Not Zero (ZF=0) cmp dword ptr ds:[44F608h], eax ; Compare Two Operands jnz short loc_40BAFF ; Jump if Not Zero (ZF=0) mov ecx, [esi+edi*4+194h] mov [ecx+0C9h], al loc_40BAFF: ; CODE XREF: sub_4094C0+2611j ; sub_4094C0+2628j ... mov edx, [esi+ebp*4+194h] mov ecx, [edx+10h] mov eax, [esi+edi*4+194h] sub ecx, 64h ; Integer Subtraction cmp [eax+10h], ecx ; Compare Two Operands jle short loc_40BB2F ; Jump if Less or Equal (ZF=1 | SF!=OF) cmp [esp+60h+var_50], 2 ; Compare Two Operands jnz short loc_40BB2F ; Jump if Not Zero (ZF=0) cmp byte ptr [eax+80h], 0 ; Compare Two Operands jnz short loc_40BB2F ; Jump if Not Zero (ZF=0) mov byte ptr [eax+0CFh], 1 loc_40BB2F: ; CODE XREF: sub_4094C0+25B2j ; sub_4094C0+25BDj ... mov edx, [esi+ebp*4+194h] mov ecx, [edx+18h] mov eax, [esi+edi*4+194h] mov edx, [eax+18h] lea ebx, [ecx-3] ; Load Effective Address cmp edx, ebx ; Compare Two Operands jge short loc_40BB53 ; Jump if Greater or Equal (SF=OF) mov byte ptr [eax+0CEh], 1 jmp short loc_40BB61 ; Jump ; --------------------------------------------------------------------------- loc_40BB53: ; CODE XREF: sub_4094C0+2688j add ecx, 3 ; Add cmp edx, ecx ; Compare Two Operands jle short loc_40BB61 ; Jump if Less or Equal (ZF=1 | SF!=OF) mov byte ptr [eax+0CDh], 1 loc_40BB61: ; CODE XREF: sub_4094C0+252Ej ; sub_4094C0+2691j ... mov ecx, [esi+ebp*4+194h] mov edx, [esi+edi*4+194h] mov eax, [ecx+18h] sub eax, [edx+18h] ; Integer Subtraction push eax call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 3 ; Compare Two Operands jg short loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) mov ecx, [ecx+10h] sub ecx, [edx+10h] ; Integer Subtraction push ecx call sub_403270 ; Call Procedure add esp, 4 ; Add cmp eax, 6 ; Compare Two Operands jg short loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) mov byte ptr [edx+0CAh], 0 mov eax, [esi+edi*4+194h] pop edi pop esi pop ebp mov byte ptr [eax+0D1h], 1 pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure ; --------------------------------------------------------------------------- loc_40BBB6: ; CODE XREF: sub_4094C0+237Dj cmp eax, 9 ; Compare Two Operands jnz short loc_40BBCC ; Jump if Not Zero (ZF=0) mov eax, [esi+70h] cmp eax, 118h ; Compare Two Operands jl short loc_40BBE9 ; Jump if Less (SF!=OF) cmp eax, 122h ; Compare Two Operands jmp short loc_40BBE0 ; Jump ; --------------------------------------------------------------------------- loc_40BBCC: ; CODE XREF: sub_4094C0+26F9j cmp eax, 20h ; Compare Two Operands jnz short loc_40BBE9 ; Jump if Not Zero (ZF=0) mov eax, [esi+70h] cmp eax, 0F0h ; Compare Two Operands jl short loc_40BBE9 ; Jump if Less (SF!=OF) cmp eax, 0F5h ; Compare Two Operands loc_40BBE0: ; CODE XREF: sub_4094C0+2396j ; sub_4094C0+270Aj jg short loc_40BBE9 ; Jump if Greater (ZF=0 & SF=OF) mov byte ptr [esi+0D3h], 1 loc_40BBE9: ; CODE XREF: sub_4094C0+427j ; sub_4094C0+449j ... pop edi loc_40BBEA: ; CODE XREF: sub_4094C0+140j pop esi pop ebp pop ebx add esp, 50h ; Add retn 8 ; Return Near from Procedure AI_Generic endp