Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 f8 3f 40 00 ?? push 0x00403ff8
   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 60 80 40 00 ?? mov eax, dword ds:[0x00408060]
   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]
   8b 0e ?? mov ecx, dword ds:[esi]
   8b 58 10 ?? mov ebx, dword ds:[eax + 0x10<16>]
   8b 41 04 ?? mov eax, dword ds:[ecx + 4]
   8b 54 30 24 ?? mov edx, dword ds:[eax + esi + 0x24<36>]
   8b 4c 30 20 ?? mov ecx, dword ds:[eax + esi + 0x20<32>]
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
   85 d2 ?? test edx, edx
   7c 1c ?? jl basic block L6
  
  L2: 7f 04 ?? jg basic block L4
  
  L3: 85 c9 ?? test ecx, ecx
   74 16 ?? je basic block L6
  
  L4: 89 4d dc ?? mov dword ss:[ebp + 0xdc<220,-36>], ecx
   89 55 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edx
   3b cb ?? cmp ecx, ebx
   76 0c ?? jbe basic block L6
  
  L5: 2b cb ?? sub ecx, ebx
   8b f9 ?? mov edi, ecx
   89 55 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], edx
   89 7d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edi
   eb 0a ?? jmp basic block L7
  
  L6: c7 45 e8 00 00 00 00 ?? mov dword ss:[ebp + 0xe8<232,-24>], 0
   8b 7d e8 ?? mov edi, dword ss:[ebp + 0xe8<232,-24>]
  
  L7: 8b 44 30 38 ?? mov eax, dword ds:[eax + esi + 0x38<56>]
   89 75 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], esi
   85 c0 ?? test eax, eax
   74 09 ?? je basic block L9
  
  L8: 8b 10 ?? mov edx, dword ds:[eax]
   8b c8 ?? mov ecx, eax
   8b 42 04 ?? mov eax, dword ds:[edx + 4]
   ff d0 ?? call eax
  
  L9: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 41 04 ?? mov eax, dword ds:[ecx + 4]
   83 7c 30 0c 00 ?? cmp dword ds:[eax + esi + 12], 0
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   75 10 ?? jne basic block L12
  
  L10: 8b 44 30 3c ?? mov eax, dword ds:[eax + esi + 0x3c<60>]
   85 c0 ?? test eax, eax
   74 08 ?? je basic block L12
  
  L11: 8b c8 ?? mov ecx, eax
   ff 15 94 92 40 00 ?? call dword ds:[function 0x00409294]
  
  L12: 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
   0f 94 c1 ?? sete cl
   88 4d e0 ?? mov byte ss:[ebp + 0xe0<224,-32>], 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 L14
  
  L13: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
   e9 8f 00 00 00 ?? jmp basic block L27
  
  L14: 8b 44 30 14 ?? mov eax, dword ds:[eax + esi + 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 35 ?? je basic block L20
  
  L15: 85 ff ?? test edi, edi
   74 27 ?? je basic block L19
  
  L16: 8b 16 ?? mov edx, dword ds:[esi]
   8b 42 04 ?? mov eax, dword ds:[edx + 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 80 92 40 00 ?? call dword ds:[function 0x00409280]
  
  L17: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   0f 85 b4 00 00 00 ?? jne basic block L34
  
  L18: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
  
  L19: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   0f 85 b9 00 00 00 ?? jne basic block L36
  
  L20: 8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   83 78 14 10 ?? cmp dword ds:[eax + 0x14<20>], 0x10<16>
   72 02 ?? jb basic block L22
  
  L21: 8b 00 ?? mov eax, dword ds:[eax]
  
  L22: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 51 04 ?? mov edx, dword ds:[ecx + 4]
   8b 4c 32 38 ?? mov ecx, dword ds:[edx + esi + 0x38<56>]
   33 ff ?? xor edi, edi
   57 ?? push edi
   53 ?? push ebx
   50 ?? push eax
   ff 15 84 92 40 00 ?? call dword ds:[function 0x00409284]
  
  L23: 3b c3 ?? cmp eax, ebx
   75 08 ?? jne basic block L25
  
  L24: 3b d7 ?? cmp edx, edi
   0f 84 84 00 00 00 ?? je basic block L35
  
  L25: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
  
  L26: 8b 06 ?? mov eax, dword ds:[esi]
   8b 40 04 ?? mov eax, dword ds:[eax + 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
  
  L27: 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   8b 16 ?? mov edx, dword ds:[esi]
   6a 00 ?? push 0
   51 ?? push ecx
   8b 4a 04 ?? mov ecx, dword ds:[edx + 4]
   03 ce ?? add ecx, esi
   ff 15 88 92 40 00 ?? call dword ds:[function 0x00409288]
  
  L28: c7 45 fc 04 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 4
   ff 15 8c 92 40 00 ?? call dword ds:[0x0040928c]
  
  L29: 8b 7d dc ?? mov edi, dword ss:[ebp + 0xdc<220,-36>]
   84 c0 ?? test al, al
   75 08 ?? jne basic block L31
  
  L30: 8b cf ?? mov ecx, edi
   ff 15 90 92 40 00 ?? call dword ds:[function 0x00409290]
  
  L31: 8b 07 ?? mov eax, dword ds:[edi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8b 4c 39 38 ?? mov ecx, dword ds:[ecx + edi + 0x38<56>]
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   85 c9 ?? test ecx, ecx
   74 07 ?? je basic block L33
  
  L32: 8b 11 ?? mov edx, dword ds:[ecx]
   8b 42 08 ?? mov eax, dword ds:[edx + 8]
   ff d0 ?? call eax
  
  L33: 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
  
  L34: 4f ?? dec edi
   89 7d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edi
   e9 1c ff ff ff ?? jmp basic block L15
  
  L35: 8b 7d e8 ?? mov edi, dword ss:[ebp + 0xe8<232,-24>]
   8d a4 24 00 00 00 00 ?? lea esp, ss:[esp + 0]
  
  L36: 85 ff ?? test edi, edi
   0f 84 71 ff ff ff ?? je basic block L26
  
  L37: 8b 06 ?? mov eax, dword ds:[esi]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   8a 54 30 40 ?? mov dl, byte ds:[eax + esi + 0x40<64>]
   8b 44 30 38 ?? mov eax, dword ds:[eax + esi + 0x38<56>]
   88 55 0c ?? mov byte ss:[ebp + 12], dl
   8b 4d 0c ?? mov ecx, dword ss:[ebp + 12]
   51 ?? push ecx
   8b c8 ?? mov ecx, eax
   ff 15 80 92 40 00 ?? call dword ds:[function 0x00409280]
  
  L38: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 09 ?? jne basic block L40
  
  L39: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
   e9 47 ff ff ff ?? jmp basic block L26
  
  L40: 4f ?? dec edi
   eb cb ?? jmp basic block L36
  
  