Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 9e 35 40 00 ?? push 0x0040359e
   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 00 70 40 00 ?? mov eax, dword ds:[0x00407000]
   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
   6a 24 ?? push 0x24<36>
   e8 a5 04 00 00 ?? call function 0x004018a4
  
  L2: 33 f6 ?? xor esi, esi
   83 c4 04 ?? add esp, 4
   3b c6 ?? cmp eax, esi
   74 12 ?? je basic block L4
  
  L3: c7 40 1c 0f 00 00 00 ?? mov dword ds:[eax + 0x1c<28>], 15
   89 70 18 ?? mov dword ds:[eax + 0x18<24>], esi
   c6 40 08 00 ?? mov byte ds:[eax + 8], 0
   8b d8 ?? mov ebx, eax
   eb 02 ?? jmp basic block L5
  
  L4: 33 db ?? xor ebx, ebx
  
  L5: 68 ec 05 00 00 ?? push 0x000005ec<1516>
   e8 de 02 00 00 ?? call function 0x00401704
  
  L6: 83 c4 04 ?? add esp, 4
   89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   89 75 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], esi
   3b c6 ?? cmp eax, esi
   74 1f ?? je basic block L9
  
  L7: 68 5a 10 40 00 ?? push 0x0040105a
   68 0f 10 40 00 ?? push 0x0040100f
   6a 2a ?? push 0x2a<42>
   8d 78 04 ?? lea edi, ds:[eax + 4]
   6a 24 ?? push 0x24<36>
   57 ?? push edi
   c7 00 2a 00 00 00 ?? mov dword ds:[eax], 0x0000002a<42>
   e8 ef 03 00 00 ?? call function 0x0040183f
  
  L8: eb 02 ?? jmp basic block L10
  
  L9: 33 ff ?? xor edi, edi
  
  L10: 6a 18 ?? push 0x18<24>
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   89 7d d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], edi
   e8 3f 04 00 00 ?? call function 0x004018a4
  
  L11: 68 f0 00 00 00 ?? push 0x000000f0<240>
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   e8 92 02 00 00 ?? call function 0x00401704
  
  L12: 68 28 71 40 00 ?? push 0x00407128
   6a 24 ?? push 0x24<36>
   89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   e8 8f 03 00 00 ?? call function 0x00401810
  
  L13: 83 c4 10 ?? add esp, 0x10<16>
   3b c6 ?? cmp eax, esi
   74 13 ?? je basic block L15
  
  L14: c7 40 1c 0f 00 00 00 ?? mov dword ds:[eax + 0x1c<28>], 15
   89 70 18 ?? mov dword ds:[eax + 0x18<24>], esi
   c6 40 08 00 ?? mov byte ds:[eax + 8], 0
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   eb 03 ?? jmp basic block L16
  
  L15: 89 75 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esi
  
  L16: 68 28 71 40 00 ?? push 0x00407128
   68 ec 05 00 00 ?? push 0x000005ec<1516>
   e8 58 03 00 00 ?? call function 0x00401805
  
  L17: 83 c4 08 ?? add esp, 8
   89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   3b c6 ?? cmp eax, esi
   74 24 ?? je basic block L20
  
  L18: 68 5a 10 40 00 ?? push 0x0040105a
   68 0f 10 40 00 ?? push 0x0040100f
   6a 2a ?? push 0x2a<42>
   8d 70 04 ?? lea esi, ds:[eax + 4]
   6a 24 ?? push 0x24<36>
   56 ?? push esi
   c7 00 2a 00 00 00 ?? mov dword ds:[eax], 0x0000002a<42>
   e8 64 03 00 00 ?? call function 0x0040183f
  
  L19: 89 75 ec ?? mov dword ss:[ebp + 0xec<236,-20>], esi
   33 f6 ?? xor esi, esi
   eb 03 ?? jmp basic block L21
  
  L20: 89 75 ec ?? mov dword ss:[ebp + 0xec<236,-20>], esi
  
  L21: 68 28 71 40 00 ?? push 0x00407128
   6a 18 ?? push 0x18<24>
   e8 1f 03 00 00 ?? call function 0x00401810
  
  L22: 68 28 71 40 00 ?? push 0x00407128
   68 f0 00 00 00 ?? push 0x000000f0<240>
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   e8 02 03 00 00 ?? call function 0x00401805
  
  L23: 83 c4 10 ?? add esp, 0x10<16>
   89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   3b de ?? cmp ebx, esi
   74 10 ?? je basic block L25
  
  L24: c7 43 1c 0f 00 00 00 ?? mov dword ds:[ebx + 0x1c<28>], 15
   89 73 18 ?? mov dword ds:[ebx + 0x18<24>], esi
   c6 43 08 00 ?? mov byte ds:[ebx + 8], 0
   eb 02 ?? jmp basic block L26
  
  L25: 33 db ?? xor ebx, ebx
  
  L26: 89 7d d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], edi
   c7 45 fc 02 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 2
   85 ff ?? test edi, edi
   74 21 ?? je basic block L29
  
  L27: 68 5a 10 40 00 ?? push 0x0040105a
   68 0f 10 40 00 ?? push 0x0040100f
   6a 2a ?? push 0x2a<42>
   6a 24 ?? push 0x24<36>
   8d 77 04 ?? lea esi, ds:[edi + 4]
   56 ?? push esi
   c7 07 2a 00 00 00 ?? mov dword ds:[edi], 0x0000002a<42>
   e8 f5 02 00 00 ?? call function 0x0040183f
  
  L28: 8b fe ?? mov edi, esi
   eb 02 ?? jmp basic block L30
  
  L29: 33 ff ?? xor edi, edi
  
  L30: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   be 10 00 00 00 ?? mov esi, 0x00000010<16>
   85 db ?? test ebx, ebx
   74 2c ?? je basic block L36
  
  L31: 39 73 1c ?? cmp dword ds:[ebx + 0x1c<28>], esi
   72 0c ?? jb basic block L34
  
  L32: 8b 43 08 ?? mov eax, dword ds:[ebx + 8]
   50 ?? push eax
   e8 a8 01 00 00 ?? call function 0x00401716
  
  L33: 83 c4 04 ?? add esp, 4
  
  L34: c7 43 1c 0f 00 00 00 ?? mov dword ds:[ebx + 0x1c<28>], 15
   c7 43 18 00 00 00 00 ?? mov dword ds:[ebx + 0x18<24>], 0
   53 ?? push ebx
   c6 43 08 00 ?? mov byte ds:[ebx + 8], 0
   e8 8d 01 00 00 ?? call function 0x00401716
  
  L35: 83 c4 04 ?? add esp, 4
  
  L36: 85 ff ?? test edi, edi
   74 1d ?? je basic block L40
  
  L37: 8b 4f fc ?? mov ecx, dword ds:[edi + 0xfc<252,-4>]
   68 5a 10 40 00 ?? push 0x0040105a
   8d 5f fc ?? lea ebx, ds:[edi + 0xfc<252,-4>]
   51 ?? push ecx
   6a 24 ?? push 0x24<36>
   57 ?? push edi
   e8 ee 01 00 00 ?? call function 0x00401792
  
  L38: 53 ?? push ebx
   e8 72 01 00 00 ?? call function 0x0040171c
  
  L39: 83 c4 04 ?? add esp, 4
  
  L40: 8b 7d f0 ?? mov edi, dword ss:[ebp + 0xf0<240,-16>]
   85 ff ?? test edi, edi
   74 2c ?? je basic block L46
  
  L41: 39 77 1c ?? cmp dword ds:[edi + 0x1c<28>], esi
   72 0c ?? jb basic block L44
  
  L42: 8b 57 08 ?? mov edx, dword ds:[edi + 8]
   52 ?? push edx
   e8 54 01 00 00 ?? call function 0x00401716
  
  L43: 83 c4 04 ?? add esp, 4
  
  L44: c7 47 1c 0f 00 00 00 ?? mov dword ds:[edi + 0x1c<28>], 15
   c7 47 18 00 00 00 00 ?? mov dword ds:[edi + 0x18<24>], 0
   57 ?? push edi
   c6 47 08 00 ?? mov byte ds:[edi + 8], 0
   e8 39 01 00 00 ?? call function 0x00401716
  
  L45: 83 c4 04 ?? add esp, 4
  
  L46: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   85 c0 ?? test eax, eax
   74 1d ?? je basic block L50
  
  L47: 8b 48 fc ?? mov ecx, dword ds:[eax + 0xfc<252,-4>]
   8d 78 fc ?? lea edi, ds:[eax + 0xfc<252,-4>]
   68 5a 10 40 00 ?? push 0x0040105a
   51 ?? push ecx
   6a 24 ?? push 0x24<36>
   50 ?? push eax
   e8 97 01 00 00 ?? call function 0x00401792
  
  L48: 57 ?? push edi
   e8 1b 01 00 00 ?? call function 0x0040171c
  
  L49: 83 c4 04 ?? add esp, 4
  
  L50: 8b 45 e8 ?? mov eax, dword ss:[ebp + 0xe8<232,-24>]
   85 c0 ?? test eax, eax
   74 09 ?? je basic block L53
  
  L51: 50 ?? push eax
   e8 05 01 00 00 ?? call function 0x00401716
  
  L52: 83 c4 04 ?? add esp, 4
  
  L53: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
   85 c0 ?? test eax, eax
   74 09 ?? je basic block L56
  
  L54: 50 ?? push eax
   e8 fb 00 00 00 ?? call function 0x0040171c
  
  L55: 83 c4 04 ?? add esp, 4
  
  L56: 8b 55 e0 ?? mov edx, dword ss:[ebp + 0xe0<224,-32>]
   52 ?? push edx
   e8 e9 00 00 00 ?? call function 0x00401716
  
  L57: 8b 45 dc ?? mov eax, dword ss:[ebp + 0xdc<220,-36>]
   50 ?? push eax
   e8 e6 00 00 00 ?? call function 0x0040171c
  
  L58: 83 c4 08 ?? add esp, 8
   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
  
  