Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 40 30 40 00 ?? push 0x00403040
   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 00 60 40 00 ?? mov eax, dword ds:[0x00406000]
   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 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   8b d1 ?? mov edx, ecx
   89 55 ec ?? mov dword ss:[ebp + 0xec<236,-20>], edx
   33 ff ?? xor edi, edi
   80 38 00 ?? cmp byte ds:[eax], 0
   89 7d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], edi
   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 71 01 ?? lea esi, 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 ce ?? sub ecx, esi
  
  L7: 8b 02 ?? mov eax, dword ds:[edx]
   89 4d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], ecx
   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 d4 ?? movlpd double ss:[ebp + 0xd4<212,-44>], xmm0
   8b 5d d8 ?? mov ebx, dword ss:[ebp + 0xd8<216,-40>]
   8b 75 d4 ?? mov esi, dword ss:[ebp + 0xd4<212,-44>]
  
  L15: 8b 4c 10 38 ?? mov ecx, dword ds:[eax + edx + 0x38<56>]
   89 55 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], 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 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
  
  L18: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8b 02 ?? mov eax, dword ds:[edx]
   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 34 40 40 00 ?? call dword ds:[function 0x00404034<"TN@">]
  
  L22: 8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
  
  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 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 L25
  
  L24: bf 04 00 00 00 ?? mov edi, 4
   e9 f5 00 00 00 ?? jmp basic block L53
  
  L25: c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   8b 44 11 14 ?? mov eax, dword ds:[ecx + edx + 0x14<20>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   74 3a ?? je basic block L35
  
  L26: eb 03 ?? jmp basic block L28
  
  L27: 8d 49 00 ?? lea ecx, ds:[ecx + 0]
  
  L28: 85 db ?? test ebx, ebx
   7c 2d ?? jl basic block L34
  
  L29: 7f 04 ?? jg basic block L31
  
  L30: 85 f6 ?? test esi, esi
   74 27 ?? je basic block L34
  
  L31: 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 e0 ?? mov byte ss:[ebp + 0xe0<224,-32>], al
   ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
   ff 15 30 40 40 00 ?? call dword ds:[function 0x00404030]
  
  L32: 8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
   83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 5a ?? jne basic block L44
  
  L33: 83 cf 04 ?? or edi, 4
   89 7d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], edi
  
  L34: 85 ff ?? test edi, edi
   75 6b ?? jne basic block L48
  
  L35: 8b 02 ?? mov eax, dword ds:[edx]
   6a 00 ?? push 0
   ff 75 e8 ?? push dword ss:[ebp + 0xe8<232,-24>]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   ff 75 dc ?? push dword ss:[ebp + 0xdc<220,-36>]
   8b 4c 10 38 ?? mov ecx, dword ds:[eax + edx + 0x38<56>]
   ff 15 28 40 40 00 ?? call dword ds:[function 0x00404028]
  
  L36: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
   75 47 ?? jne basic block L46
  
  L37: 85 d2 ?? test edx, edx
   75 43 ?? jne basic block L46
  
  L38: 85 db ?? test ebx, ebx
   7c 44 ?? jl basic block L47
  
  L39: 7f 04 ?? jg basic block L41
  
  L40: 85 f6 ?? test esi, esi
   74 3e ?? je basic block L47
  
  L41: 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   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 dc ?? mov byte ss:[ebp + 0xdc<220,-36>], al
   ff 75 dc ?? push dword ss:[ebp + 0xdc<220,-36>]
   ff 15 30 40 40 00 ?? call dword ds:[function 0x00404030]
  
  L42: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 10 ?? jne basic block L45
  
  L43: 83 cf 04 ?? or edi, 4
   eb 18 ?? jmp basic block L47
  
  L44: 83 c6 ff ?? add esi, 0xff<255,-1>
   83 d3 ff ?? adc ebx, 0xff<255,-1>
   e9 70 ff ff ff ?? jmp basic block L28
  
  L45: 83 c6 ff ?? add esi, 0xff<255,-1>
   83 d3 ff ?? adc ebx, 0xff<255,-1>
   eb bd ?? jmp basic block L38
  
  L46: bf 04 00 00 00 ?? mov edi, 4
  
  L47: 8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
  
  L48: 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 L52
  
  L49: 8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
   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 44 40 40 00 ?? call dword ds:[function 0x00404044]
  
  L50: b8 91 21 40 00 ?? mov eax, basic block L51
   c3 ?? ret
  
  L51: 8b 7d e4 ?? mov edi, dword ss:[ebp + 0xe4<228,-28>]
   8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
  
  L52: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
  
  L53: 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 44 40 40 00 ?? call dword ds:[function 0x00404044]
  
  L54: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   ff 15 60 40 40 00 ?? call dword ds:[0x00404060]
  
  L55: 8b 75 d4 ?? mov esi, dword ss:[ebp + 0xd4<212,-44>]
   84 c0 ?? test al, al
   75 08 ?? jne basic block L57
  
  L56: 8b ce ?? mov ecx, esi
   ff 15 2c 40 40 00 ?? call dword ds:[function 0x0040402c]
  
  L57: 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 L59
  
  L58: 8b 01 ?? mov eax, dword ds:[ecx]
   ff 50 08 ?? call dword ds:[eax + 8]
  
  L59: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   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
  
  