Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 80 2e 40 00 ?? push 0x00402e80
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   83 ec 14 ?? sub esp, 0x14<20>
   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 55 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edx
   8b f1 ?? mov esi, ecx
   8b 06 ?? mov eax, dword ds:[esi]
   8b 52 10 ?? mov edx, dword ds:[edx + 0x10<16>]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   33 db ?? xor ebx, ebx
   8b 44 31 24 ?? mov eax, dword ds:[ecx + esi + 0x24<36>]
   8b 7c 31 20 ?? mov edi, dword ds:[ecx + esi + 0x20<32>]
   89 55 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], edx
   85 c0 ?? test eax, eax
   7c 14 ?? jl basic block L6
  
  L2: 7f 04 ?? jg basic block L4
  
  L3: 85 ff ?? test edi, edi
   74 0e ?? je basic block L6
  
  L4: 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   3b fa ?? cmp edi, edx
   76 07 ?? jbe basic block L6
  
  L5: 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   2b fa ?? sub edi, edx
   eb 02 ?? jmp basic block L7
  
  L6: 33 ff ?? xor edi, edi
  
  L7: 8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
   89 75 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], esi
   85 c9 ?? test ecx, ecx
   74 05 ?? je basic block L9
  
  L8: 8b 01 ?? mov eax, dword ds:[ecx]
   ff 50 04 ?? call dword ds:[eax + 4]
  
  L9: 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 0e ?? jne basic block L12
  
  L10: 8b 4c 30 3c ?? mov ecx, dword ds:[eax + esi + 0x3c<60>]
   85 c9 ?? test ecx, ecx
   74 06 ?? je basic block L12
  
  L11: ff 15 30 30 40 00 ?? call dword ds:[function 0x00403030]
  
  L12: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   83 7c 31 0c 00 ?? cmp dword ds:[ecx + esi + 12], 0
   0f 94 c0 ?? sete al
   88 45 e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], 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 L14
  
  L13: bb 04 00 00 00 ?? mov ebx, 4
   e9 be 00 00 00 ?? jmp basic block L36
  
  L14: c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   8b 44 31 14 ?? mov eax, dword ds:[ecx + esi + 0x14<20>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   74 2d ?? je basic block L21
  
  L15: 85 ff ?? test edi, edi
   74 29 ?? je basic block L21
  
  L16: eb 06 ?? jmp basic block L18
  
  L17: 8d 9b 00 00 00 00 ?? lea ebx, ds:[ebx + 0]
  
  L18: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8a 44 31 40 ?? mov al, byte ds:[ecx + esi + 0x40<64>]
   8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 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 30 40 00 ?? call dword ds:[function 0x0040302c<"l<@">]
  
  L19: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   74 55 ?? je basic block L32
  
  L20: 4f ?? dec edi
   75 df ?? jne basic block L18
  
  L21: 8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   83 79 14 10 ?? cmp dword ds:[ecx + 0x14<20>], 0x10<16>
   72 02 ?? jb basic block L23
  
  L22: 8b 09 ?? mov ecx, dword ds:[ecx]
  
  L23: 8b 06 ?? mov eax, dword ds:[esi]
   6a 00 ?? push 0
   ff 75 f0 ?? push dword ss:[ebp + 0xf0<240,-16>]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   51 ?? push ecx
   8b 4c 30 38 ?? mov ecx, dword ds:[eax + esi + 0x38<56>]
   ff 15 60 30 40 00 ?? call dword ds:[function 0x00403060<"L;@">]
  
  L24: 3b 45 f0 ?? cmp eax, dword ss:[ebp + 0xf0<240,-16>]
   75 39 ?? jne basic block L34
  
  L25: 85 d2 ?? test edx, edx
   75 35 ?? jne basic block L34
  
  L26: 85 ff ?? test edi, edi
   74 36 ?? je basic block L35
  
  L27: 8b ff ?? mov edi, edi
  
  L28: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8a 44 31 40 ?? mov al, byte ds:[ecx + esi + 0x40<64>]
   8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
   88 45 e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], al
   ff 75 e8 ?? push dword ss:[ebp + 0xe8<232,-24>]
   ff 15 2c 30 40 00 ?? call dword ds:[function 0x0040302c<"l<@">]
  
  L29: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   74 0c ?? je basic block L33
  
  L30: 4f ?? dec edi
   75 df ?? jne basic block L28
  
  L31: eb 11 ?? jmp basic block L35
  
  L32: bb 04 00 00 00 ?? mov ebx, 4
   eb d0 ?? jmp basic block L26
  
  L33: 83 cb 04 ?? or ebx, 4
   eb 05 ?? jmp basic block L35
  
  L34: bb 04 00 00 00 ?? mov ebx, 4
  
  L35: 8b 06 ?? mov eax, dword ds:[esi]
   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 30 20 00 00 00 00 ?? mov dword ds:[eax + esi + 0x20<32>], 0
   c7 44 30 24 00 00 00 00 ?? mov dword ds:[eax + esi + 0x24<36>], 0
  
  L36: 8b 06 ?? mov eax, dword ds:[esi]
   6a 00 ?? push 0
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   53 ?? push ebx
   03 ce ?? add ecx, esi
   ff 15 7c 30 40 00 ?? call dword ds:[function 0x0040307c]
  
  L37: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   ff 15 64 30 40 00 ?? call dword ds:[0x00403064<"*;@">]
  
  L38: 84 c0 ?? test al, al
   75 08 ?? jne basic block L40
  
  L39: 8b ce ?? mov ecx, esi
   ff 15 40 30 40 00 ?? call dword ds:[function 0x00403040]
  
  L40: 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 L42
  
  L41: 8b 01 ?? mov eax, dword ds:[ecx]
   ff 50 08 ?? call dword ds:[eax + 8]
  
  L42: 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
  
  