
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 c8 38 40 00 ?? push 0x004038c8
 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 9c 70 40 00 ?? mov eax, dword ds:[0x0040709c]
 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 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]

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

L3: 75 f9 ?? jne basic block L2

L4: 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
 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 L11

L5: 7f 04 ?? jg basic block L7

L6: 85 c0 ?? test eax, eax
 74 19 ?? je basic block L11

L7: 3b cf ?? cmp ecx, edi
 7c 15 ?? jl basic block L11

L8: 7f 05 ?? jg basic block L10

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

L10: 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 L12

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

L12: 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 L14

L13: 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

L14: 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
 c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
 75 10 ?? jne basic block L17

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

L16: 8b c8 ?? mov ecx, eax
 ff 15 60 82 40 00 ?? call dword ds:[function 0x00408260]

L17: 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 L19

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

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

L20: 85 ff ?? test edi, edi
 7c 2d ?? jl basic block L26

L21: 7f 04 ?? jg basic block L23

L22: 85 db ?? test ebx, ebx
 74 27 ?? je basic block L26

L23: 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 4c 82 40 00 ?? call dword ds:[function 0x0040824c]

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

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

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

L27: 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 50 82 40 00 ?? call dword ds:[function 0x00408250]

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

L29: 3b d7 ?? cmp edx, edi
 0f 84 89 00 00 00 ?? je basic block L40

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

L31: 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

L32: 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 54 82 40 00 ?? call dword ds:[function 0x00408254]

L33: c7 45 fc 04 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 4
 ff 15 58 82 40 00 ?? call dword ds:[0x00408258]

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

L35: 8b cf ?? mov ecx, edi
 ff 15 5c 82 40 00 ?? call dword ds:[function 0x0040825c]

L36: 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>]
 c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
 85 c9 ?? test ecx, ecx
 74 07 ?? je basic block L38

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

L38: 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

L39: 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 L20

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

L41: 7f 08 ?? jg basic block L43

L42: 85 db ?? test ebx, ebx
 0f 84 6b ff ff ff ?? je basic block L31

L43: 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 4c 82 40 00 ?? call dword ds:[function 0x0040824c]

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

L45: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
 e9 43 ff ff ff ?? jmp basic block L31

L46: 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 L40

