
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 20 31 40 00 ?? push 0x00403120
 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 18 60 40 00 ?? mov eax, dword ds:[0x00406018]
 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
 8b c2 ?? mov eax, edx
 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
 8b d9 ?? mov ebx, ecx
 80 38 00 ?? cmp byte ds:[eax], 0
 75 04 ?? jne basic block L3

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

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

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 03 ?? mov eax, dword ds:[ebx]
 89 4d f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], ecx
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 8b 7c 18 24 ?? mov edi, dword ds:[eax + ebx + 0x24<36>]
 8b 74 18 20 ?? mov esi, dword ds:[eax + ebx + 0x20<32>]
 85 ff ?? test edi, edi
 7c 17 ?? jl basic block L14

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

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

L10: 85 ff ?? test edi, edi
 7c 0d ?? jl basic block L14

L11: 7f 04 ?? jg basic block L13

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

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

L14: 0f 57 c0 ?? xorps xmm0, xmm0
 66 0f 13 45 e8 ?? movlpd double ss:[ebp + 0xe8<232,-24>], xmm0
 8b 7d ec ?? mov edi, dword ss:[ebp + 0xec<236,-20>]
 8b 75 e8 ?? mov esi, dword ss:[ebp + 0xe8<232,-24>]

L15: 8b 4c 18 38 ?? mov ecx, dword ds:[eax + ebx + 0x38<56>]
 89 5d dc ?? mov dword ss:[ebp + 0xdc<220,-36>], ebx
 85 c9 ?? test ecx, ecx
 74 05 ?? je basic block L17

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

L17: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
 8b 03 ?? mov eax, dword ds:[ebx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 83 7c 18 0c 00 ?? cmp dword ds:[eax + ebx + 12], 0
 75 0e ?? jne basic block L20

L18: 8b 4c 18 3c ?? mov ecx, dword ds:[eax + ebx + 0x3c<60>]
 85 c9 ?? test ecx, ecx
 74 06 ?? je basic block L20

L19: ff 15 30 40 40 00 ?? call dword ds:[function 0x00404030]

L20: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 83 7c 19 0c 00 ?? cmp dword ds:[ecx + ebx + 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 L22

L21: b9 04 00 00 00 ?? mov ecx, 4
 e9 d4 00 00 00 ?? jmp basic block L46

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

L23: 85 ff ?? test edi, edi
 7c 38 ?? jl basic block L31

L24: 7f 04 ?? jg basic block L26

L25: 85 f6 ?? test esi, esi
 74 32 ?? je basic block L31

L26: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8a 44 19 40 ?? mov al, byte ds:[ecx + ebx + 0x40<64>]
 8b 4c 19 38 ?? mov ecx, dword ds:[ecx + ebx + 0x38<56>]
 88 45 ec ?? mov byte ss:[ebp + 0xec<236,-20>], al
 ff 75 ec ?? push dword ss:[ebp + 0xec<236,-20>]
 ff 15 2c 40 40 00 ?? call dword ds:[function 0x0040402c]

L27: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 0f 84 e5 00 00 00 ?? je basic block L53

L28: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d7 ff ?? adc edi, 0xff<255,-1>
 85 ff ?? test edi, edi
 7f d4 ?? jg basic block L26

L29: 7c 04 ?? jl basic block L31

L30: 85 f6 ?? test esi, esi
 75 ce ?? jne basic block L26

L31: 8b 03 ?? mov eax, dword ds:[ebx]
 6a 00 ?? push 0
 ff 75 f0 ?? push dword ss:[ebp + 0xf0<240,-16>]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 ff 75 e4 ?? push dword ss:[ebp + 0xe4<228,-28>]
 8b 4c 18 38 ?? mov ecx, dword ds:[eax + ebx + 0x38<56>]
 ff 15 3c 40 40 00 ?? call dword ds:[function 0x0040403c]

L32: 3b 45 f0 ?? cmp eax, dword ss:[ebp + 0xf0<240,-16>]
 0f 85 b5 00 00 00 ?? jne basic block L53

L33: 85 d2 ?? test edx, edx
 0f 85 ad 00 00 00 ?? jne basic block L53

L34: 85 ff ?? test edi, edi
 7c 3c ?? jl basic block L44

L35: 7f 0c ?? jg basic block L39

L36: 85 f6 ?? test esi, esi
 74 36 ?? je basic block L44

L37: eb 06 ?? jmp basic block L39

L38: 8d 9b 00 00 00 00 ?? lea ebx, ds:[ebx + 0]

L39: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 8a 44 19 40 ?? mov al, byte ds:[ecx + ebx + 0x40<64>]
 8b 4c 19 38 ?? mov ecx, dword ds:[ecx + ebx + 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 2c 40 40 00 ?? call dword ds:[function 0x0040402c]

L40: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 74 7d ?? je basic block L53

L41: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d7 ff ?? adc edi, 0xff<255,-1>
 85 ff ?? test edi, edi
 7f d8 ?? jg basic block L39

L42: 7c 04 ?? jl basic block L44

L43: 85 f6 ?? test esi, esi
 75 d2 ?? jne basic block L39

L44: 33 c9 ?? xor ecx, ecx

L45: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
 c7 44 18 20 00 00 00 00 ?? mov dword ds:[eax + ebx + 0x20<32>], 0
 c7 44 18 24 00 00 00 00 ?? mov dword ds:[eax + ebx + 0x24<36>], 0

L46: 8b 03 ?? mov eax, dword ds:[ebx]
 6a 00 ?? push 0
 51 ?? push ecx
 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
 03 cb ?? add ecx, ebx
 ff 15 74 40 40 00 ?? call dword ds:[function 0x00404074]

L47: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
 ff 15 5c 40 40 00 ?? call dword ds:[0x0040405c<"~N@">]

L48: 84 c0 ?? test al, al
 75 08 ?? jne basic block L50

L49: 8b cb ?? mov ecx, ebx
 ff 15 24 40 40 00 ?? call dword ds:[function 0x00404024]

L50: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 8b 4c 18 38 ?? mov ecx, dword ds:[eax + ebx + 0x38<56>]
 85 c9 ?? test ecx, ecx
 74 05 ?? je basic block L52

L51: 8b 01 ?? mov eax, dword ds:[ecx]
 ff 50 08 ?? call dword ds:[eax + 8]

L52: 8b c3 ?? mov eax, ebx
 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

L53: b9 04 00 00 00 ?? mov ecx, 4
 eb 8e ?? jmp basic block L45

