
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 68 34 40 00 ?? push 0x00403468
 64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
 50 ?? push eax
 83 ec 14 ?? sub esp, 0x14<20>
 53 ?? push ebx
 56 ?? push esi
 57 ?? push edi
 a1 64 70 40 00 ?? mov eax, dword ds:[0x00407064]
 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]
 33 db ?? xor ebx, ebx
 89 5d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ebx
 8d 50 01 ?? lea edx, ds:[eax + 1]

L2: 8a 08 ?? mov cl, byte ds:[eax]
 40 ?? inc eax
 84 c9 ?? test cl, cl

L3: 75 f9 ?? jne basic block L2

L4: 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
 2b c2 ?? sub eax, edx
 8b f8 ?? mov edi, eax
 8b 06 ?? mov eax, dword ds:[esi]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8b 44 31 18 ?? mov eax, dword ds:[ecx + esi + 0x18<24>]
 3b c3 ?? cmp eax, ebx
 7e 08 ?? jle basic block L7

L5: 3b c7 ?? cmp eax, edi
 7e 04 ?? jle basic block L7

L6: 2b c7 ?? sub eax, edi
 8b d8 ?? mov ebx, eax

L7: 56 ?? push esi
 8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
 e8 39 fd ff ff ?? call function 0x0040104b

L8: 80 7d e4 00 ?? cmp byte ss:[ebp + 0xe4<228,-28>], 0
 c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
 75 09 ?? jne basic block L10

L9: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
 eb 77 ?? jmp basic block L21

L10: 8b 16 ?? mov edx, dword ds:[esi]
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 8b 44 30 10 ?? mov eax, dword ds:[eax + esi + 0x10<16>]
 25 c0 01 00 00 ?? and eax, 0x000001c0<448>
 c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
 83 f8 40 ?? cmp eax, 0x40<64>
 74 32 ?? je basic block L17

L11: 90 ?? nop

L12: 85 db ?? test ebx, ebx
 7e 27 ?? jle basic block L16

L13: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 51 04 ?? mov edx, dword ds:[ecx + 4]
 8a 4c 32 30 ?? mov cl, byte ds:[edx + esi + 0x30<48>]
 8d 04 32 ?? lea eax, ds:[edx + esi]
 8b 40 28 ?? mov eax, dword ds:[eax + 0x28<40>]
 88 4d e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], cl
 8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
 52 ?? push edx
 8b c8 ?? mov ecx, eax
 ff 15 48 82 40 00 ?? call dword ds:[function 0x00408248]

L14: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 75 6e ?? jne basic block L24

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

L16: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
 75 1f ?? jne basic block L20

L17: 8b 06 ?? mov eax, dword ds:[esi]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8b 55 0c ?? mov edx, dword ss:[ebp + 12]
 8b 4c 31 28 ?? mov ecx, dword ds:[ecx + esi + 0x28<40>]
 57 ?? push edi
 52 ?? push edx
 ff 15 4c 82 40 00 ?? call dword ds:[function 0x0040824c]

L18: 3b c7 ?? cmp eax, edi
 74 57 ?? je basic block L27

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

L20: 8b 06 ?? mov eax, dword ds:[esi]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 03 c6 ?? add eax, esi
 33 c9 ?? xor ecx, ecx
 89 48 18 ?? mov dword ds:[eax + 0x18<24>], ecx
 89 4d fc ?? mov dword ss:[ebp + 0xfc<252,-4>], ecx

L21: 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
 8b 16 ?? mov edx, dword ds:[esi]
 6a 00 ?? push 0
 51 ?? push ecx
 8b 4a 04 ?? mov ecx, dword ds:[edx + 4]
 03 ce ?? add ecx, esi
 ff 15 50 82 40 00 ?? call dword ds:[function 0x00408250]

L22: 8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
 c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
 e8 71 fc ff ff ?? call function 0x00401032

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

L24: 4b ?? dec ebx
 e9 65 ff ff ff ?? jmp basic block L12

L25: eb 03 ?? jmp basic block L27

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

L27: 85 db ?? test ebx, ebx
 7e ac ?? jle basic block L20

L28: 8b 06 ?? mov eax, dword ds:[esi]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8a 54 31 30 ?? mov dl, byte ds:[ecx + esi + 0x30<48>]
 8d 04 31 ?? lea eax, ds:[ecx + esi]
 8b 40 28 ?? mov eax, dword ds:[eax + 0x28<40>]
 88 55 e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], dl
 8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
 51 ?? push ecx
 8b c8 ?? mov ecx, eax
 ff 15 48 82 40 00 ?? call dword ds:[function 0x00408248]

L29: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 75 06 ?? jne basic block L31

L30: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
 eb 83 ?? jmp basic block L20

L31: 4b ?? dec ebx
 eb d0 ?? jmp basic block L27

