Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 b0 45 40 00 ?? push 0x004045b0
   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 04 80 40 00 ?? mov eax, dword ds:[0x00408004]
   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 5d 08 ?? mov ebx, dword ss:[ebp + 8]
   33 ff ?? xor edi, edi
   89 7d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], edi
   8b 0b ?? mov ecx, dword ds:[ebx]
   8b 51 04 ?? mov edx, dword ds:[ecx + 4]
   8b 74 1a 20 ?? mov esi, dword ds:[edx + ebx + 0x20<32>]
   39 7c 1a 24 ?? cmp dword ds:[edx + ebx + 0x24<36>], edi
   7c 11 ?? jl basic block L6
  
  L2: 7f 04 ?? jg basic block L4
  
  L3: 85 f6 ?? test esi, esi
   74 0b ?? je basic block L6
  
  L4: 8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   3b f0 ?? cmp esi, eax
   76 04 ?? jbe basic block L6
  
  L5: 2b f0 ?? sub esi, eax
   eb 02 ?? jmp basic block L7
  
  L6: 33 f6 ?? xor esi, esi
  
  L7: 8b 44 1a 38 ?? mov eax, dword ds:[edx + ebx + 0x38<56>]
   8b d1 ?? mov edx, ecx
   89 5d dc ?? mov dword ss:[ebp + 0xdc<220,-36>], ebx
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   89 55 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edx
   85 c0 ?? test eax, eax
   74 0f ?? je basic block L10
  
  L8: 8b 00 ?? mov eax, dword ds:[eax]
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   ff 50 04 ?? call dword ds:[eax + 4]
  
  L9: 8b 0b ?? mov ecx, dword ds:[ebx]
   8b d1 ?? mov edx, ecx
   89 4d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], ecx
  
  L10: 8b 41 04 ?? mov eax, dword ds:[ecx + 4]
   03 c3 ?? add eax, ebx
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   8b c1 ?? mov eax, ecx
   8b 5d ec ?? mov ebx, dword ss:[ebp + 0xec<236,-20>]
   83 7b 0c 00 ?? cmp dword ds:[ebx + 12], 0
   8b 5d 08 ?? mov ebx, dword ss:[ebp + 8]
   75 2a ?? jne basic block L15
  
  L11: 8b 5d ec ?? mov ebx, dword ss:[ebp + 0xec<236,-20>]
   8b d1 ?? mov edx, ecx
   83 7b 3c 00 ?? cmp dword ds:[ebx + 0x3c<60>], 0
   8b 5d 08 ?? mov ebx, dword ss:[ebp + 8]
   74 1c ?? je basic block L15
  
  L12: 8b 7d ec ?? mov edi, dword ss:[ebp + 0xec<236,-20>]
   8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
   8b 4f 3c ?? mov ecx, dword ds:[edi + 0x3c<60>]
   bf 00 00 00 00 ?? mov edi, 0
   3b cb ?? cmp ecx, ebx
   74 0a ?? je basic block L15
  
  L13: ff 15 68 90 40 00 ?? call dword ds:[function 0x00409068]
  
  L14: 8b 03 ?? mov eax, dword ds:[ebx]
   8b d0 ?? mov edx, eax
  
  L15: 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8b 44 19 0c ?? mov eax, dword ds:[ecx + ebx + 12]
   85 c0 ?? test eax, eax
   0f 94 45 e0 ?? sete byte ss:[ebp + 0xe0<224,-32>]
   c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   85 c0 ?? test eax, eax
   74 0a ?? je basic block L17
  
  L16: bf 04 00 00 00 ?? mov edi, 4
   e9 ce 00 00 00 ?? jmp basic block L38
  
  L17: 8b 44 19 14 ?? mov eax, dword ds:[ecx + ebx + 0x14<20>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   83 f8 40 ?? cmp eax, 0x40<64>
   74 31 ?? je basic block L24
  
  L18: 85 f6 ?? test esi, esi
   74 2b ?? je basic block L23
  
  L19: 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 e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], al
   ff 75 e8 ?? push dword ss:[ebp + 0xe8<232,-24>]
   ff 15 88 90 40 00 ?? call dword ds:[function 0x00409088]
  
  L20: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 0a ?? jne basic block L22
  
  L21: bf 04 00 00 00 ?? mov edi, 4
   89 7d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], edi
   eb 23 ?? jmp basic block L27
  
  L22: 4e ?? dec esi
   eb d1 ?? jmp basic block L18
  
  L23: 8b 13 ?? mov edx, dword ds:[ebx]
  
  L24: 8b 42 04 ?? mov eax, dword ds:[edx + 4]
   6a 00 ?? push 0
   ff 75 10 ?? push dword ss:[ebp + 0x10<16>]
   ff 75 0c ?? push dword ss:[ebp + 12]
   8b 4c 18 38 ?? mov ecx, dword ds:[eax + ebx + 0x38<56>]
   ff 15 84 90 40 00 ?? call dword ds:[function 0x00409084]
  
  L25: 3b 45 10 ?? cmp eax, dword ss:[ebp + 0x10<16>]
   75 2e ?? jne basic block L32
  
  L26: 85 d2 ?? test edx, edx
   75 2a ?? jne basic block L32
  
  L27: 85 f6 ?? test esi, esi
   74 2b ?? je basic block L33
  
  L28: 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 e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], al
   ff 75 e8 ?? push dword ss:[ebp + 0xe8<232,-24>]
   ff 15 88 90 40 00 ?? call dword ds:[function 0x00409088]
  
  L29: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 05 ?? jne basic block L31
  
  L30: 83 cf 04 ?? or edi, 4
   eb 08 ?? jmp basic block L33
  
  L31: 4e ?? dec esi
   eb d6 ?? jmp basic block L27
  
  L32: bf 04 00 00 00 ?? mov edi, 4
  
  L33: 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 L37
  
  L34: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   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 80 90 40 00 ?? call dword ds:[function 0x00409080]
  
  L35: b8 81 16 40 00 ?? mov eax, basic block L36
   c3 ?? ret
  
  L36: 8b 5d 08 ?? mov ebx, dword ss:[ebp + 8]
   8b 7d e4 ?? mov edi, dword ss:[ebp + 0xe4<228,-28>]
  
  L37: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
  
  L38: 8b 03 ?? mov eax, dword ds:[ebx]
   6a 00 ?? push 0
   57 ?? push edi
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   03 cb ?? add ecx, ebx
   ff 15 80 90 40 00 ?? call dword ds:[function 0x00409080]
  
  L39: c7 45 fc 04 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 4
   e8 7d 05 00 00 ?? call function 0x00401c27
  
  L40: 8b 75 dc ?? mov esi, dword ss:[ebp + 0xdc<220,-36>]
   84 c0 ?? test al, al
   75 08 ?? jne basic block L42
  
  L41: 8b ce ?? mov ecx, esi
   ff 15 78 90 40 00 ?? call dword ds:[function 0x00409078]
  
  L42: 8b 0e ?? mov ecx, dword ds:[esi]
   c6 45 fc 05 ?? mov byte ss:[ebp + 0xfc<252,-4>], 5
   8b 49 04 ?? mov ecx, dword ds:[ecx + 4]
   8b 4c 31 38 ?? mov ecx, dword ds:[ecx + esi + 0x38<56>]
   85 c9 ?? test ecx, ecx
   74 05 ?? je basic block L44
  
  L43: 8b 11 ?? mov edx, dword ds:[ecx]
   ff 52 08 ?? call dword ds:[edx + 8]
  
  L44: 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
  
  