
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 10 5a 40 00 ?? push 0x00405a10
 64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
 50 ?? push eax
 83 ec 18 ?? sub esp, 0x18<24>
 53 ?? push ebx
 56 ?? push esi
 57 ?? push edi
 a1 0c a0 40 00 ?? mov eax, dword ds:[0x0040a00c]
 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 ff ?? xor edi, edi
 89 7d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edi
 80 38 00 ?? cmp byte ds:[eax], 0
 75 04 ?? jne basic block L3

L2: 33 c9 ?? xor ecx, ecx
 eb 0e ?? jmp basic block L7

L3: 8b c8 ?? mov ecx, eax
 8d 51 01 ?? lea edx, ds:[ecx + 1]

L4: 8a 01 ?? mov al, byte ds:[ecx]
 41 ?? inc ecx
 84 c0 ?? test al, al

L5: 75 f9 ?? jne basic block L4

L6: 2b ca ?? sub ecx, edx

L7: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
 89 4d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ecx
 8b 02 ?? mov eax, dword ds:[edx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 8b 5c 10 24 ?? mov ebx, dword ds:[eax + edx + 0x24<36>]
 8b 74 10 20 ?? mov esi, dword ds:[eax + edx + 0x20<32>]
 85 db ?? test ebx, ebx
 7c 16 ?? jl basic block L14

L8: 7f 0e ?? jg basic block L13

L9: 85 f6 ?? test esi, esi
 74 10 ?? je basic block L14

L10: 85 db ?? test ebx, ebx
 7c 0c ?? jl basic block L14

L11: 7f 04 ?? jg basic block L13

L12: 3b f1 ?? cmp esi, ecx
 76 06 ?? jbe basic block L14

L13: 2b f1 ?? sub esi, ecx
 1b df ?? sbb ebx, edi
 eb 0e ?? jmp basic block L15

L14: 0f 57 c0 ?? xorps xmm0, xmm0
 66 0f 13 45 dc ?? movlpd double ss:[ebp + 0xdc<220,-36>], xmm0
 8b 5d e0 ?? mov ebx, dword ss:[ebp + 0xe0<224,-32>]
 8b 75 dc ?? mov esi, dword ss:[ebp + 0xdc<220,-36>]

L15: 8b 4c 10 38 ?? mov ecx, dword ds:[eax + edx + 0x38<56>]
 89 55 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], edx
 85 c9 ?? test ecx, ecx
 74 08 ?? je basic block L18

L16: 8b 01 ?? mov eax, dword ds:[ecx]
 ff 50 04 ?? call dword ds:[eax + 4]

L17: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]

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

L19: 8b 4c 10 3c ?? mov ecx, dword ds:[eax + edx + 0x3c<60>]
 85 c9 ?? test ecx, ecx
 74 0d ?? je basic block L23

L20: 3b ca ?? cmp ecx, edx
 74 09 ?? je basic block L23

L21: ff 15 60 b0 40 00 ?? call dword ds:[function 0x0040b060]

L22: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]

L23: 8b 02 ?? mov eax, dword ds:[edx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 83 7c 11 0c 00 ?? cmp dword ds:[ecx + edx + 12], 0
 0f 94 c0 ?? sete al
 88 45 e0 ?? mov byte ss:[ebp + 0xe0<224,-32>], al
 c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
 84 c0 ?? test al, al
 75 0a ?? jne basic block L25

L24: bf 04 00 00 00 ?? mov edi, 4
 e9 f4 00 00 00 ?? jmp basic block L52

L25: 8b 44 11 14 ?? mov eax, dword ds:[ecx + edx + 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 35 ?? je basic block L33

L26: 85 db ?? test ebx, ebx
 7c 2d ?? jl basic block L32

L27: 7f 04 ?? jg basic block L29

L28: 85 f6 ?? test esi, esi
 74 27 ?? je basic block L32

L29: 8b 02 ?? mov eax, dword ds:[edx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8a 44 11 40 ?? mov al, byte ds:[ecx + edx + 0x40<64>]
 8b 4c 11 38 ?? mov ecx, dword ds:[ecx + edx + 0x38<56>]
 88 45 e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], al
 ff 75 e4 ?? push dword ss:[ebp + 0xe4<228,-28>]
 ff 15 6c b0 40 00 ?? call dword ds:[function 0x0040b06c]

L30: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
 83 f8 ff ?? cmp eax, 0xff<255,-1>
 75 5e ?? jne basic block L43

L31: 83 cf 04 ?? or edi, 4
 89 7d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edi

L32: 85 ff ?? test edi, edi
 75 6f ?? jne basic block L47

L33: 8b 02 ?? mov eax, dword ds:[edx]
 6a 00 ?? push 0
 ff 75 ec ?? push dword ss:[ebp + 0xec<236,-20>]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 ff 75 0c ?? push dword ss:[ebp + 12]
 8b 4c 10 38 ?? mov ecx, dword ds:[eax + edx + 0x38<56>]
 ff 15 68 b0 40 00 ?? call dword ds:[function 0x0040b068]

L34: 3b 45 ec ?? cmp eax, dword ss:[ebp + 0xec<236,-20>]
 75 4b ?? jne basic block L45

L35: 85 d2 ?? test edx, edx
 75 47 ?? jne basic block L45

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

L37: 85 db ?? test ebx, ebx
 7c 44 ?? jl basic block L46

L38: 7f 04 ?? jg basic block L40

L39: 85 f6 ?? test esi, esi
 74 3e ?? je basic block L46

L40: 8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
 8b 01 ?? mov eax, dword ds:[ecx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 03 c8 ?? add ecx, eax
 8a 41 40 ?? mov al, byte ds:[ecx + 0x40<64>]
 8b 49 38 ?? mov ecx, dword ds:[ecx + 0x38<56>]
 88 45 0c ?? mov byte ss:[ebp + 12], al
 ff 75 0c ?? push dword ss:[ebp + 12]
 ff 15 6c b0 40 00 ?? call dword ds:[function 0x0040b06c]

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

L42: 83 cf 04 ?? or edi, 4
 eb 18 ?? jmp basic block L46

L43: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d3 ff ?? adc ebx, 0xff<255,-1>
 e9 6c ff ff ff ?? jmp basic block L26

L44: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d3 ff ?? adc ebx, 0xff<255,-1>
 eb bd ?? jmp basic block L37

L45: bf 04 00 00 00 ?? mov edi, 4

L46: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]

L47: 8b 02 ?? mov eax, dword ds:[edx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 c7 44 10 20 00 00 00 00 ?? mov dword ds:[eax + edx + 0x20<32>], 0
 c7 44 10 24 00 00 00 00 ?? mov dword ds:[eax + edx + 0x24<36>], 0
 eb 20 ?? jmp basic block L51

L48: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
 6a 01 ?? push 1
 6a 04 ?? push 4
 8b 02 ?? mov eax, dword ds:[edx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 03 ca ?? add ecx, edx
 ff 15 5c b0 40 00 ?? call dword ds:[function 0x0040b05c]

L49: b8 7c 24 40 00 ?? mov eax, basic block L50
 c3 ?? ret

L50: 8b 7d e8 ?? mov edi, dword ss:[ebp + 0xe8<232,-24>]
 8b 55 08 ?? mov edx, dword ss:[ebp + 8]

L51: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1

L52: 8b 02 ?? mov eax, dword ds:[edx]
 6a 00 ?? push 0
 57 ?? push edi
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 03 ca ?? add ecx, edx
 ff 15 5c b0 40 00 ?? call dword ds:[function 0x0040b05c]

L53: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
 ff 15 88 b0 40 00 ?? call dword ds:[0x0040b088]

L54: 8b 75 dc ?? mov esi, dword ss:[ebp + 0xdc<220,-36>]
 84 c0 ?? test al, al
 75 08 ?? jne basic block L56

L55: 8b ce ?? mov ecx, esi
 ff 15 54 b0 40 00 ?? call dword ds:[function 0x0040b054]

L56: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 49 04 ?? mov ecx, dword ds:[ecx + 4]
 8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
 85 c9 ?? test ecx, ecx
 74 05 ?? je basic block L58

L57: 8b 11 ?? mov edx, dword ds:[ecx]
 ff 52 08 ?? call dword ds:[edx + 8]

L58: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 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

