
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 85 2b 40 00 ?? push 0x00402b85
 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 04 50 40 00 ?? mov eax, dword ds:[0x00405004]
 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 c2 ?? mov eax, edx
 89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
 8b d9 ?? mov ebx, ecx
 89 5d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], ebx
 8b c8 ?? mov ecx, eax
 c7 45 dc 00 00 00 00 ?? mov dword ss:[ebp + 0xdc<220,-36>], 0
 8d 71 01 ?? lea esi, ds:[ecx + 1]

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

L3: 75 f9 ?? jne basic block L2

L4: 8b 13 ?? mov edx, dword ds:[ebx]
 2b ce ?? sub ecx, esi
 89 4d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ecx
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 03 c3 ?? add eax, ebx
 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
 8b 78 24 ?? mov edi, dword ds:[eax + 0x24<36>]
 8b 70 20 ?? mov esi, dword ds:[eax + 0x20<32>]
 85 ff ?? test edi, edi
 7c 17 ?? jl basic block L11

L5: 7f 0e ?? jg basic block L10

L6: 85 f6 ?? test esi, esi
 74 11 ?? je basic block L11

L7: 85 ff ?? test edi, edi
 7c 0d ?? jl basic block L11

L8: 7f 04 ?? jg basic block L10

L9: 3b f1 ?? cmp esi, ecx
 76 07 ?? jbe basic block L11

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

L11: 0f 57 c0 ?? xorps xmm0, xmm0
 66 0f 13 45 d4 ?? movlpd double ss:[ebp + 0xd4<212,-44>], xmm0
 8b 7d d8 ?? mov edi, dword ss:[ebp + 0xd8<216,-40>]
 8b 75 d4 ?? mov esi, dword ss:[ebp + 0xd4<212,-44>]

L12: 8b 40 38 ?? mov eax, dword ds:[eax + 0x38<56>]
 8b ca ?? mov ecx, edx
 89 5d d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], ebx
 85 c0 ?? test eax, eax
 74 0f ?? je basic block L15

L13: 8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
 8b 00 ?? mov eax, dword ds:[eax]
 8b 49 38 ?? mov ecx, dword ds:[ecx + 0x38<56>]
 ff 50 04 ?? call dword ds:[eax + 4]

L14: 8b 13 ?? mov edx, dword ds:[ebx]
 8b ca ?? mov ecx, edx

L15: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 03 c3 ?? add eax, ebx
 83 78 0c 00 ?? cmp dword ds:[eax + 12], 0
 74 04 ?? je basic block L17

L16: 32 c0 ?? xor al, al
 eb 26 ?? jmp basic block L22

L17: 8b 40 3c ?? mov eax, dword ds:[eax + 0x3c<60>]
 85 c0 ?? test eax, eax
 74 1d ?? je basic block L21

L18: 3b c3 ?? cmp eax, ebx
 74 19 ?? je basic block L21

L19: 8b c8 ?? mov ecx, eax
 ff 15 50 30 40 00 ?? call dword ds:[function 0x00403050]

L20: 8b 13 ?? mov edx, dword ds:[ebx]
 8b ca ?? mov ecx, edx
 8b 42 04 ?? mov eax, dword ds:[edx + 4]
 83 7c 18 0c 00 ?? cmp dword ds:[eax + ebx + 12], 0
 0f 94 c0 ?? sete al
 eb 02 ?? jmp basic block L22

L21: b0 01 ?? mov al, 1

L22: 88 45 d8 ?? mov byte ss:[ebp + 0xd8<216,-40>], 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 L24

L23: b9 04 00 00 00 ?? mov ecx, 4
 e9 e7 00 00 00 ?? jmp basic block L50

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

L25: 66 0f 1f 44 00 00 ?? nop word ds:[eax + eax + 0]

L26: 85 ff ?? test edi, edi
 7c 31 ?? jl basic block L33

L27: 7f 04 ?? jg basic block L29

L28: 85 f6 ?? test esi, esi
 74 2b ?? je basic block L33

L29: 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 4c 30 40 00 ?? call dword ds:[function 0x0040304c<"8@@">]

L30: 83 f8 ff ?? cmp eax, 0xff<255,-1>
 75 05 ?? jne basic block L32

L31: 8d 48 05 ?? lea ecx, ds:[eax + 5]
 eb 61 ?? jmp basic block L45

L32: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d7 ff ?? adc edi, 0xff<255,-1>
 eb cb ?? jmp basic block L26

L33: 8b 0b ?? mov ecx, dword ds:[ebx]

L34: 8b 41 04 ?? mov eax, dword ds:[ecx + 4]
 6a 00 ?? push 0
 ff 75 ec ?? push dword ss:[ebp + 0xec<236,-20>]
 ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
 8b 4c 18 38 ?? mov ecx, dword ds:[eax + ebx + 0x38<56>]
 ff 15 68 30 40 00 ?? call dword ds:[function 0x00403068<"T>@">]

L35: 3b 45 ec ?? cmp eax, dword ss:[ebp + 0xec<236,-20>]
 75 2c ?? jne basic block L42

L36: 85 d2 ?? test edx, edx
 75 28 ?? jne basic block L42

L37: 85 ff ?? test edi, edi
 7c 33 ?? jl basic block L44

L38: 7f 04 ?? jg basic block L40

L39: 85 f6 ?? test esi, esi
 74 2d ?? je basic block L44

L40: 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 e0 ?? mov byte ss:[ebp + 0xe0<224,-32>], al
 ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
 ff 15 4c 30 40 00 ?? call dword ds:[function 0x0040304c<"8@@">]

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

L42: b9 04 00 00 00 ?? mov ecx, 4
 eb 0a ?? jmp basic block L45

L43: 83 c6 ff ?? add esi, 0xff<255,-1>
 83 d7 ff ?? adc edi, 0xff<255,-1>
 eb c9 ?? jmp basic block L37

L44: 33 c9 ?? xor ecx, ecx

L45: 8b 03 ?? mov eax, dword ds:[ebx]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 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
 eb 20 ?? jmp basic block L49

L46: 8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
 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 64 30 40 00 ?? call dword ds:[function 0x00403064]

L47: b8 ef 13 40 00 ?? mov eax, basic block L48
 c3 ?? ret

L48: 8b 5d e8 ?? mov ebx, dword ss:[ebp + 0xe8<232,-24>]
 8b 4d dc ?? mov ecx, dword ss:[ebp + 0xdc<220,-36>]

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

L50: 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 64 30 40 00 ?? call dword ds:[function 0x00403064]

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

L52: 8b 75 d4 ?? mov esi, dword ss:[ebp + 0xd4<212,-44>]
 84 c0 ?? test al, al
 75 08 ?? jne basic block L54

L53: 8b ce ?? mov ecx, esi
 ff 15 6c 30 40 00 ?? call dword ds:[function 0x0040306c]

L54: c6 45 fc 05 ?? mov byte ss:[ebp + 0xfc<252,-4>], 5
 8b 06 ?? mov eax, dword ds:[esi]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
 85 c9 ?? test ecx, ecx
 74 05 ?? je basic block L56

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

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

