Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 ca 23 40 00 ?? push 0x004023ca
   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 18 50 40 00 ?? mov eax, dword ds:[0x00405018]
   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 75 08 ?? mov esi, dword ss:[ebp + 8]
   8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
   8d 48 01 ?? lea ecx, ds:[eax + 1]
   eb 03 ?? jmp basic block L3
  
  L2: 8d 49 00 ?? lea ecx, ds:[ecx + 0]
  
  L3: 8a 10 ?? mov dl, byte ds:[eax]
   40 ?? inc eax
   84 d2 ?? test dl, dl
  
  L4: 75 f9 ?? jne basic block L3
  
  L5: 2b c1 ?? sub eax, ecx
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   8b 06 ?? mov eax, dword ds:[esi]
   8b 50 04 ?? mov edx, dword ds:[eax + 4]
   8b 4c 32 24 ?? mov ecx, dword ds:[edx + esi + 0x24<36>]
   8b 44 32 20 ?? mov eax, dword ds:[edx + esi + 0x20<32>]
   33 ff ?? xor edi, edi
   85 c9 ?? test ecx, ecx
   7c 1f ?? jl basic block L12
  
  L6: 7f 04 ?? jg basic block L8
  
  L7: 85 c0 ?? test eax, eax
   74 19 ?? je basic block L12
  
  L8: 3b cf ?? cmp ecx, edi
   7c 15 ?? jl basic block L12
  
  L9: 7f 05 ?? jg basic block L11
  
  L10: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
   76 0e ?? jbe basic block L12
  
  L11: 2b 45 e8 ?? sub eax, dword ss:[ebp + 0xe8<232,-24>]
   1b cf ?? sbb ecx, edi
   8b f9 ?? mov edi, ecx
   8b d8 ?? mov ebx, eax
   89 7d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edi
   eb 07 ?? jmp basic block L13
  
  L12: 33 db ?? xor ebx, ebx
   89 5d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], ebx
   8b fb ?? mov edi, ebx
  
  L13: 8b 54 32 38 ?? mov edx, dword ds:[edx + esi + 0x38<56>]
   89 75 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], esi
   85 d2 ?? test edx, edx
   74 09 ?? je basic block L15
  
  L14: 8b 02 ?? mov eax, dword ds:[edx]
   8b ca ?? mov ecx, edx
   8b 50 04 ?? mov edx, dword ds:[eax + 4]
   ff d2 ?? call edx
  
  L15: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8b 06 ?? mov eax, dword ds:[esi]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   83 7c 30 0c 00 ?? cmp dword ds:[eax + esi + 12], 0
   75 10 ?? jne basic block L18
  
  L16: 8b 44 30 3c ?? mov eax, dword ds:[eax + esi + 0x3c<60>]
   85 c0 ?? test eax, eax
   74 08 ?? je basic block L18
  
  L17: 8b c8 ?? mov ecx, eax
   ff 15 68 30 40 00 ?? call dword ds:[function 0x00403068<"n;@">]
  
  L18: 8b 16 ?? mov edx, dword ds:[esi]
   8b 42 04 ?? mov eax, dword ds:[edx + 4]
   83 7c 30 0c 00 ?? cmp dword ds:[eax + esi + 12], 0
   0f 94 c1 ?? sete cl
   88 4d d8 ?? mov byte ss:[ebp + 0xd8<216,-40>], cl
   c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   84 c9 ?? test cl, cl
   75 0c ?? jne basic block L20
  
  L19: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
   e9 8d 00 00 00 ?? jmp basic block L33
  
  L20: c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   8b 44 30 14 ?? mov eax, dword ds:[eax + esi + 0x14<20>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   74 37 ?? je basic block L28
  
  L21: 85 ff ?? test edi, edi
   7c 2d ?? jl basic block L27
  
  L22: 7f 04 ?? jg basic block L24
  
  L23: 85 db ?? test ebx, ebx
   74 27 ?? je basic block L27
  
  L24: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 41 04 ?? mov eax, dword ds:[ecx + 4]
   8a 4c 30 40 ?? mov cl, byte ds:[eax + esi + 0x40<64>]
   88 4d e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], cl
   8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
   8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
   52 ?? push edx
   ff 15 6c 30 40 00 ?? call dword ds:[function 0x0040306c<".;@">]
  
  L25: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   0f 85 ac 00 00 00 ?? jne basic block L40
  
  L26: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
  
  L27: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   75 2e ?? jne basic block L32
  
  L28: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
   8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
   33 ff ?? xor edi, edi
   57 ?? push edi
   52 ?? push edx
   50 ?? push eax
   ff 15 78 30 40 00 ?? call dword ds:[function 0x00403078<"F:@">]
  
  L29: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
   75 08 ?? jne basic block L31
  
  L30: 3b d7 ?? cmp edx, edi
   0f 84 8d 00 00 00 ?? je basic block L42
  
  L31: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
  
  L32: 8b 16 ?? mov edx, dword ds:[esi]
   8b 42 04 ?? mov eax, dword ds:[edx + 4]
   33 c9 ?? xor ecx, ecx
   89 4c 30 20 ?? mov dword ds:[eax + esi + 0x20<32>], ecx
   89 4c 30 24 ?? mov dword ds:[eax + esi + 0x24<36>], ecx
   c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
  
  L33: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   8b 49 04 ?? mov ecx, dword ds:[ecx + 4]
   6a 00 ?? push 0
   50 ?? push eax
   03 ce ?? add ecx, esi
   ff 15 5c 30 40 00 ?? call dword ds:[function 0x0040305c<"h<@">]
  
  L34: c7 45 fc 04 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 4
   ff 15 84 30 40 00 ?? call dword ds:[0x00403084]
  
  L35: 8b 7d d4 ?? mov edi, dword ss:[ebp + 0xd4<212,-44>]
   84 c0 ?? test al, al
   75 08 ?? jne basic block L37
  
  L36: 8b cf ?? mov ecx, edi
   ff 15 74 30 40 00 ?? call dword ds:[function 0x00403074]
  
  L37: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8b 17 ?? mov edx, dword ds:[edi]
   8b 42 04 ?? mov eax, dword ds:[edx + 4]
   8b 4c 38 38 ?? mov ecx, dword ds:[eax + edi + 0x38<56>]
   85 c9 ?? test ecx, ecx
   74 07 ?? je basic block L39
  
  L38: 8b 11 ?? mov edx, dword ds:[ecx]
   8b 42 08 ?? mov eax, dword ds:[edx + 8]
   ff d0 ?? call eax
  
  L39: 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
  
  L40: 83 c3 ff ?? add ebx, 0xff<255,-1>
   83 d7 ff ?? adc edi, 0xff<255,-1>
   89 7d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edi
   e9 19 ff ff ff ?? jmp basic block L21
  
  L41: 8d 64 24 00 ?? lea esp, ss:[esp + 0]
  
  L42: 39 7d e0 ?? cmp dword ss:[ebp + 0xe0<224,-32>], edi
   0f 8c 71 ff ff ff ?? jl basic block L32
  
  L43: 7f 08 ?? jg basic block L45
  
  L44: 85 db ?? test ebx, ebx
   0f 84 67 ff ff ff ?? je basic block L32
  
  L45: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 41 04 ?? mov eax, dword ds:[ecx + 4]
   8a 4c 30 40 ?? mov cl, byte ds:[eax + esi + 0x40<64>]
   88 4d e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], cl
   8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
   8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
   52 ?? push edx
   ff 15 6c 30 40 00 ?? call dword ds:[function 0x0040306c<".;@">]
  
  L46: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 09 ?? jne basic block L48
  
  L47: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
   e9 3f ff ff ff ?? jmp basic block L32
  
  L48: 83 c3 ff ?? add ebx, 0xff<255,-1>
   83 55 e0 ff ?? adc dword ss:[ebp + 0xe0<224,-32>], 0xff<255,-1>
   eb bc ?? jmp basic block L42
  
  