
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 ca 23 40 00 ?? push 0x004023ca
 64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
 50 ?? push eax
 83 ec 20 ?? sub esp, 0x20<32>
 53 ?? push ebx
 56 ?? push esi
 57 ?? push edi
 a1 18 50 40 00 ?? mov eax, dword ds:[0x00405018]
 33 c5 ?? xor eax, ebp
 50 ?? push eax
 8d 45 f4 ?? lea eax, ss:[ebp + 0xf4<244,-12>]
 64 a3 00 00 00 00 ?? mov dword fs:[0], eax
 89 65 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esp
 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
 8b 45 0c ?? mov eax, dword ss:[ebp + 12]
 c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
 8d 48 01 ?? lea ecx, ds:[eax + 1]
 eb 03 ?? jmp basic block L3

L2: 8d 49 00 ?? lea ecx, ds:[ecx + 0]

L3: 8a 10 ?? mov dl, byte ds:[eax]
 40 ?? inc eax
 84 d2 ?? test dl, dl

L4: 75 f9 ?? jne basic block L3

L5: 2b c1 ?? sub eax, ecx
 89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
 8b 06 ?? mov eax, dword ds:[esi]
 8b 50 04 ?? mov edx, dword ds:[eax + 4]
 8b 4c 32 24 ?? mov ecx, dword ds:[edx + esi + 0x24<36>]
 8b 44 32 20 ?? mov eax, dword ds:[edx + esi + 0x20<32>]
 33 ff ?? xor edi, edi
 85 c9 ?? test ecx, ecx
 7c 1f ?? jl basic block L12

L6: 7f 04 ?? jg basic block L8

L7: 85 c0 ?? test eax, eax
 74 19 ?? je basic block L12

L8: 3b cf ?? cmp ecx, edi
 7c 15 ?? jl basic block L12

L9: 7f 05 ?? jg basic block L11

L10: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
 76 0e ?? jbe basic block L12

L11: 2b 45 e8 ?? sub eax, dword ss:[ebp + 0xe8<232,-24>]
 1b cf ?? sbb ecx, edi
 8b f9 ?? mov edi, ecx
 8b d8 ?? mov ebx, eax
 89 7d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edi
 eb 07 ?? jmp basic block L13

L12: 33 db ?? xor ebx, ebx
 89 5d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], ebx
 8b fb ?? mov edi, ebx

L13: 8b 54 32 38 ?? mov edx, dword ds:[edx + esi + 0x38<56>]
 89 75 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], esi
 85 d2 ?? test edx, edx
 74 09 ?? je basic block L15

L14: 8b 02 ?? mov eax, dword ds:[edx]
 8b ca ?? mov ecx, edx
 8b 50 04 ?? mov edx, dword ds:[eax + 4]
 ff d2 ?? call edx

L15: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
 8b 06 ?? mov eax, dword ds:[esi]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 83 7c 30 0c 00 ?? cmp dword ds:[eax + esi + 12], 0
 75 10 ?? jne basic block L18

L16: 8b 44 30 3c ?? mov eax, dword ds:[eax + esi + 0x3c<60>]
 85 c0 ?? test eax, eax
 74 08 ?? je basic block L18

L17: 8b c8 ?? mov ecx, eax
 ff 15 68 30 40 00 ?? call dword ds:[function 0x00403068<"n;@">]

L18: 8b 16 ?? mov edx, dword ds:[esi]
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 83 7c 30 0c 00 ?? cmp dword ds:[eax + esi + 12], 0
 0f 94 c1 ?? sete cl
 88 4d d8 ?? mov byte ss:[ebp + 0xd8<216,-40>], cl
 c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
 84 c9 ?? test cl, cl
 75 0c ?? jne basic block L20

L19: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
 e9 8d 00 00 00 ?? jmp basic block L33

L20: c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
 8b 44 30 14 ?? mov eax, dword ds:[eax + esi + 0x14<20>]
 25 c0 01 00 00 ?? and eax, 0x000001c0<448>
 83 f8 40 ?? cmp eax, 0x40<64>
 74 37 ?? je basic block L28

L21: 85 ff ?? test edi, edi
 7c 2d ?? jl basic block L27

L22: 7f 04 ?? jg basic block L24

L23: 85 db ?? test ebx, ebx
 74 27 ?? je basic block L27

L24: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 41 04 ?? mov eax, dword ds:[ecx + 4]
 8a 4c 30 40 ?? mov cl, byte ds:[eax + esi + 0x40<64>]
 88 4d e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], cl
 8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
 8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
 52 ?? push edx
 ff 15 6c 30 40 00 ?? call dword ds:[function 0x0040306c<".;@">]

L25: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 0f 85 ac 00 00 00 ?? jne basic block L40

L26: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4

L27: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
 75 2e ?? jne basic block L32

L28: 8b 06 ?? mov eax, dword ds:[esi]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
 8b 45 0c ?? mov eax, dword ss:[ebp + 12]
 8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
 33 ff ?? xor edi, edi
 57 ?? push edi
 52 ?? push edx
 50 ?? push eax
 ff 15 78 30 40 00 ?? call dword ds:[function 0x00403078<"F:@">]

L29: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
 75 08 ?? jne basic block L31

L30: 3b d7 ?? cmp edx, edi
 0f 84 8d 00 00 00 ?? je basic block L42

L31: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4

L32: 8b 16 ?? mov edx, dword ds:[esi]
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 33 c9 ?? xor ecx, ecx
 89 4c 30 20 ?? mov dword ds:[eax + esi + 0x20<32>], ecx
 89 4c 30 24 ?? mov dword ds:[eax + esi + 0x24<36>], ecx
 c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1

L33: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
 8b 49 04 ?? mov ecx, dword ds:[ecx + 4]
 6a 00 ?? push 0
 50 ?? push eax
 03 ce ?? add ecx, esi
 ff 15 5c 30 40 00 ?? call dword ds:[function 0x0040305c<"h<@">]

L34: c7 45 fc 04 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 4
 ff 15 84 30 40 00 ?? call dword ds:[0x00403084]

L35: 8b 7d d4 ?? mov edi, dword ss:[ebp + 0xd4<212,-44>]
 84 c0 ?? test al, al
 75 08 ?? jne basic block L37

L36: 8b cf ?? mov ecx, edi
 ff 15 74 30 40 00 ?? call dword ds:[function 0x00403074]

L37: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
 8b 17 ?? mov edx, dword ds:[edi]
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 8b 4c 38 38 ?? mov ecx, dword ds:[eax + edi + 0x38<56>]
 85 c9 ?? test ecx, ecx
 74 07 ?? je basic block L39

L38: 8b 11 ?? mov edx, dword ds:[ecx]
 8b 42 08 ?? mov eax, dword ds:[edx + 8]
 ff d0 ?? call eax

L39: 8b c6 ?? mov eax, esi
 8b 4d f4 ?? mov ecx, dword ss:[ebp + 0xf4<244,-12>]
 64 89 0d 00 00 00 00 ?? mov dword fs:[0], ecx
 59 ?? pop ecx
 5f ?? pop edi
 5e ?? pop esi
 5b ?? pop ebx
 8b e5 ?? mov esp, ebp
 5d ?? pop ebp
 c3 ?? ret

L40: 83 c3 ff ?? add ebx, 0xff<255,-1>
 83 d7 ff ?? adc edi, 0xff<255,-1>
 89 7d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edi
 e9 19 ff ff ff ?? jmp basic block L21

L41: 8d 64 24 00 ?? lea esp, ss:[esp + 0]

L42: 39 7d e0 ?? cmp dword ss:[ebp + 0xe0<224,-32>], edi
 0f 8c 71 ff ff ff ?? jl basic block L32

L43: 7f 08 ?? jg basic block L45

L44: 85 db ?? test ebx, ebx
 0f 84 67 ff ff ff ?? je basic block L32

L45: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 41 04 ?? mov eax, dword ds:[ecx + 4]
 8a 4c 30 40 ?? mov cl, byte ds:[eax + esi + 0x40<64>]
 88 4d e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], cl
 8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
 8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
 52 ?? push edx
 ff 15 6c 30 40 00 ?? call dword ds:[function 0x0040306c<".;@">]

L46: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 75 09 ?? jne basic block L48

L47: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
 e9 3f ff ff ff ?? jmp basic block L32

L48: 83 c3 ff ?? add ebx, 0xff<255,-1>
 83 55 e0 ff ?? adc dword ss:[ebp + 0xe0<224,-32>], 0xff<255,-1>
 eb bc ?? jmp basic block L42

