Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 00 2f 40 00 ?? push 0x00402f00
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   83 ec 0c ?? sub esp, 12
   53 ?? push ebx
   56 ?? push esi
   57 ?? push edi
   a1 18 40 40 00 ?? mov eax, dword ds:[0x00404018]
   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 f1 ?? mov esi, ecx
   89 75 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], esi
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b f8 ?? mov edi, eax
   83 cf 0f ?? or edi, 15
   83 ff fe ?? cmp edi, 0xfe<254,-2>
   76 04 ?? jbe basic block L3
  
  L2: 8b f8 ?? mov edi, eax
   eb 27 ?? jmp basic block L6
  
  L3: 8b 5e 14 ?? mov ebx, dword ds:[esi + 0x14<20>]
   b8 ab aa aa aa ?? mov eax, 0xaaaaaaab
   f7 e7 ?? mul edi
   8b cb ?? mov ecx, ebx
   d1 e9 ?? shr ecx, 1
   d1 ea ?? shr edx, 1
   3b ca ?? cmp ecx, edx
   76 13 ?? jbe basic block L6
  
  L4: b8 fe ff ff ff ?? mov eax, 0xfffffffe<4294967294,-2>
   2b c1 ?? sub eax, ecx
   8d 3c 19 ?? lea edi, ds:[ecx + ebx]
   3b d8 ?? cmp ebx, eax
   76 05 ?? jbe basic block L6
  
  L5: bf fe ff ff ff ?? mov edi, 0xfffffffe<4294967294,-2>
  
  L6: 8d 4f 01 ?? lea ecx, ds:[edi + 1]
   33 c0 ?? xor eax, eax
   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
   85 c9 ?? test ecx, ecx
   74 45 ?? je basic block L14
  
  L7: 83 f9 ff ?? cmp ecx, 0xff<255,-1>
   77 11 ?? ja basic block L10
  
  L8: 51 ?? push ecx
   ff 15 b0 30 40 00 ?? call dword ds:[0x004030b0]
  
  L9: 83 c4 04 ?? add esp, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   85 c0 ?? test eax, eax
   75 2f ?? jne basic block L14
  
  L10: ff 15 2c 30 40 00 ?? call dword ds:[0x0040302c<" :@">]
  
  L11: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   89 45 08 ?? mov dword ss:[ebp + 8], eax
   40 ?? inc eax
   89 65 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esp
   50 ?? push eax
   c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   e8 a5 00 00 00 ?? call function 0x00401f40
  
  L12: 89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   b8 a4 1e 40 00 ?? mov eax, basic block L13
   c3 ?? ret
  
  L13: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   8b 75 e8 ?? mov esi, dword ss:[ebp + 0xe8<232,-24>]
   8b 7d 08 ?? mov edi, dword ss:[ebp + 8]
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
  
  L14: 8b 5d 0c ?? mov ebx, dword ss:[ebp + 12]
   85 db ?? test ebx, ebx
   74 49 ?? je basic block L25
  
  L15: 83 7e 14 10 ?? cmp dword ds:[esi + 0x14<20>], 0x10<16>
   72 32 ?? jb basic block L21
  
  L16: 8b 0e ?? mov ecx, dword ds:[esi]
   eb 30 ?? jmp basic block L22
  
  L17: 8b 75 e8 ?? mov esi, dword ss:[ebp + 0xe8<232,-24>]
   83 7e 14 10 ?? cmp dword ds:[esi + 0x14<20>], 0x10<16>
   72 0b ?? jb basic block L20
  
  L18: ff 36 ?? push dword ds:[esi]
   ff 15 b4 30 40 00 ?? call dword ds:[0x004030b4]
  
  L19: 83 c4 04 ?? add esp, 4
  
  L20: 6a 00 ?? push 0
   c7 46 14 0f 00 00 00 ?? mov dword ds:[esi + 0x14<20>], 15
   c7 46 10 00 00 00 00 ?? mov dword ds:[esi + 0x10<16>], 0
   6a 00 ?? push 0
   c6 06 00 ?? mov byte ds:[esi], 0
   e8 dd 0f 00 00 ?? call function 0x00402ecc
  
  L21: 8b ce ?? mov ecx, esi
  
  L22: 85 db ?? test ebx, ebx
   74 0b ?? je basic block L25
  
  L23: 53 ?? push ebx
   51 ?? push ecx
   50 ?? push eax
   e8 d5 0f 00 00 ?? call function 0x00402ed2
  
  L24: 83 c4 0c ?? add esp, 12
  
  L25: 83 7e 14 10 ?? cmp dword ds:[esi + 0x14<20>], 0x10<16>
   72 0b ?? jb basic block L28
  
  L26: ff 36 ?? push dword ds:[esi]
   ff 15 b4 30 40 00 ?? call dword ds:[0x004030b4]
  
  L27: 83 c4 04 ?? add esp, 4
  
  L28: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   c6 06 00 ?? mov byte ds:[esi], 0
   89 06 ?? mov dword ds:[esi], eax
   89 7e 14 ?? mov dword ds:[esi + 0x14<20>], edi
   89 5e 10 ?? mov dword ds:[esi + 0x10<16>], ebx
   83 ff 10 ?? cmp edi, 0x10<16>
   72 02 ?? jb basic block L30
  
  L29: 8b f0 ?? mov esi, eax
  
  L30: c6 04 1e 00 ?? mov byte ds:[esi + ebx], 0
   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
   c2 08 00 ?? ret 8
  
  