Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 68 34 40 00 ?? push 0x00403468
   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 64 70 40 00 ?? mov eax, dword ds:[0x00407064]
   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 45 0c ?? mov eax, dword ss:[ebp + 12]
   33 db ?? xor ebx, ebx
   89 5d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ebx
   8d 50 01 ?? lea edx, ds:[eax + 1]
  
  L2: 8a 08 ?? mov cl, byte ds:[eax]
   40 ?? inc eax
   84 c9 ?? test cl, cl
  
  L3: 75 f9 ?? jne basic block L2
  
  L4: 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
   2b c2 ?? sub eax, edx
   8b f8 ?? mov edi, eax
   8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8b 44 31 18 ?? mov eax, dword ds:[ecx + esi + 0x18<24>]
   3b c3 ?? cmp eax, ebx
   7e 08 ?? jle basic block L7
  
  L5: 3b c7 ?? cmp eax, edi
   7e 04 ?? jle basic block L7
  
  L6: 2b c7 ?? sub eax, edi
   8b d8 ?? mov ebx, eax
  
  L7: 56 ?? push esi
   8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
   e8 39 fd ff ff ?? call function 0x0040104b
  
  L8: 80 7d e4 00 ?? cmp byte ss:[ebp + 0xe4<228,-28>], 0
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   75 09 ?? jne basic block L10
  
  L9: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
   eb 77 ?? jmp basic block L21
  
  L10: 8b 16 ?? mov edx, dword ds:[esi]
   8b 42 04 ?? mov eax, dword ds:[edx + 4]
   8b 44 30 10 ?? mov eax, dword ds:[eax + esi + 0x10<16>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   83 f8 40 ?? cmp eax, 0x40<64>
   74 32 ?? je basic block L17
  
  L11: 90 ?? nop
  
  L12: 85 db ?? test ebx, ebx
   7e 27 ?? jle basic block L16
  
  L13: 8b 0e ?? mov ecx, dword ds:[esi]
   8b 51 04 ?? mov edx, dword ds:[ecx + 4]
   8a 4c 32 30 ?? mov cl, byte ds:[edx + esi + 0x30<48>]
   8d 04 32 ?? lea eax, ds:[edx + esi]
   8b 40 28 ?? mov eax, dword ds:[eax + 0x28<40>]
   88 4d e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], cl
   8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
   52 ?? push edx
   8b c8 ?? mov ecx, eax
   ff 15 48 82 40 00 ?? call dword ds:[function 0x00408248]
  
  L14: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 6e ?? jne basic block L24
  
  L15: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
  
  L16: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   75 1f ?? jne basic block L20
  
  L17: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8b 55 0c ?? mov edx, dword ss:[ebp + 12]
   8b 4c 31 28 ?? mov ecx, dword ds:[ecx + esi + 0x28<40>]
   57 ?? push edi
   52 ?? push edx
   ff 15 4c 82 40 00 ?? call dword ds:[function 0x0040824c]
  
  L18: 3b c7 ?? cmp eax, edi
   74 57 ?? je basic block L27
  
  L19: c7 45 ec 04 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 4
  
  L20: 8b 06 ?? mov eax, dword ds:[esi]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   03 c6 ?? add eax, esi
   33 c9 ?? xor ecx, ecx
   89 48 18 ?? mov dword ds:[eax + 0x18<24>], ecx
   89 4d fc ?? mov dword ss:[ebp + 0xfc<252,-4>], ecx
  
  L21: 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 50 82 40 00 ?? call dword ds:[function 0x00408250]
  
  L22: 8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   e8 71 fc ff ff ?? call function 0x00401032
  
  L23: 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
  
  L24: 4b ?? dec ebx
   e9 65 ff ff ff ?? jmp basic block L12
  
  L25: eb 03 ?? jmp basic block L27
  
  L26: 8d 49 00 ?? lea ecx, ds:[ecx + 0]
  
  L27: 85 db ?? test ebx, ebx
   7e ac ?? jle basic block L20
  
  L28: 8b 06 ?? mov eax, dword ds:[esi]
   8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   8a 54 31 30 ?? mov dl, byte ds:[ecx + esi + 0x30<48>]
   8d 04 31 ?? lea eax, ds:[ecx + esi]
   8b 40 28 ?? mov eax, dword ds:[eax + 0x28<40>]
   88 55 e8 ?? mov byte ss:[ebp + 0xe8<232,-24>], dl
   8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   51 ?? push ecx
   8b c8 ?? mov ecx, eax
   ff 15 48 82 40 00 ?? call dword ds:[function 0x00408248]
  
  L29: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   75 06 ?? jne basic block L31
  
  L30: 83 4d ec 04 ?? or dword ss:[ebp + 0xec<236,-20>], 4
   eb 83 ?? jmp basic block L20
  
  L31: 4b ?? dec ebx
   eb d0 ?? jmp basic block L27
  
  