Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 9c 42 40 00 ?? push 0x0040429c
   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
   6a 20 ?? push 0x20<32>
   e8 ba fa ff ff ?? call function 0x004011a9
  
  L2: 8b f0 ?? mov esi, eax
   83 c4 04 ?? add esp, 4
   85 f6 ?? test esi, esi
   74 1e ?? je basic block L6
  
  L3: 8d 4e 08 ?? lea ecx, ds:[esi + 8]
   c7 41 14 0f 00 00 00 ?? mov dword ds:[ecx + 0x14<20>], 15
   c7 41 10 00 00 00 00 ?? mov dword ds:[ecx + 0x10<16>], 0
   83 79 14 10 ?? cmp dword ds:[ecx + 0x14<20>], 0x10<16>
   72 02 ?? jb basic block L5
  
  L4: 8b 09 ?? mov ecx, dword ds:[ecx]
  
  L5: c6 01 00 ?? mov byte ds:[ecx], 0
   eb 02 ?? jmp basic block L7
  
  L6: 33 f6 ?? xor esi, esi
  
  L7: 68 44 05 00 00 ?? push 0x00000544<1348>
   e8 d2 fa ff ff ?? call function 0x004011f4
  
  L8: 83 c4 04 ?? add esp, 4
   85 c0 ?? test eax, eax
   74 1f ?? je basic block L11
  
  L9: 68 49 12 40 00 ?? push 0x00401249
   68 13 11 40 00 ?? push 0x00401113
   6a 2a ?? push 0x2a<42>
   8d 78 04 ?? lea edi, ds:[eax + 4]
   c7 00 2a 00 00 00 ?? mov dword ds:[eax], 0x0000002a<42>
   6a 20 ?? push 0x20<32>
   57 ?? push edi
   e8 64 f9 ff ff ?? call function 0x004010aa
  
  L10: eb 02 ?? jmp basic block L12
  
  L11: 33 ff ?? xor edi, edi
  
  L12: 6a 18 ?? push 0x18<24>
   e8 58 fa ff ff ?? call function 0x004011a9
  
  L13: 68 f0 00 00 00 ?? push 0x000000f0<240>
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   e8 96 fa ff ff ?? call function 0x004011f4
  
  L14: 68 c0 82 40 00 ?? push 0x004082c0
   6a 20 ?? push 0x20<32>
   89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   e8 ba f9 ff ff ?? call function 0x00401127
  
  L15: 8b d8 ?? mov ebx, eax
   83 c4 10 ?? add esp, 0x10<16>
   89 5d f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], ebx
   85 db ?? test ebx, ebx
   74 1e ?? je basic block L19
  
  L16: 8d 4b 08 ?? lea ecx, ds:[ebx + 8]
   c7 41 14 0f 00 00 00 ?? mov dword ds:[ecx + 0x14<20>], 15
   c7 41 10 00 00 00 00 ?? mov dword ds:[ecx + 0x10<16>], 0
   83 79 14 10 ?? cmp dword ds:[ecx + 0x14<20>], 0x10<16>
   72 02 ?? jb basic block L18
  
  L17: 8b 09 ?? mov ecx, dword ds:[ecx]
  
  L18: c6 01 00 ?? mov byte ds:[ecx], 0
   eb 07 ?? jmp basic block L20
  
  L19: c7 45 f0 00 00 00 00 ?? mov dword ss:[ebp + 0xf0<240,-16>], 0
  
  L20: 68 c0 82 40 00 ?? push 0x004082c0
   68 44 05 00 00 ?? push 0x00000544<1348>
   e8 bb f9 ff ff ?? call function 0x00401168
  
  L21: 83 c4 08 ?? add esp, 8
   85 c0 ?? test eax, eax
   74 22 ?? je basic block L24
  
  L22: 68 49 12 40 00 ?? push 0x00401249
   68 13 11 40 00 ?? push 0x00401113
   6a 2a ?? push 0x2a<42>
   8d 58 04 ?? lea ebx, ds:[eax + 4]
   c7 00 2a 00 00 00 ?? mov dword ds:[eax], 0x0000002a<42>
   6a 20 ?? push 0x20<32>
   53 ?? push ebx
   89 5d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ebx
   e8 d6 f8 ff ff ?? call function 0x004010aa
  
  L23: eb 07 ?? jmp basic block L25
  
  L24: c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
  
  L25: 68 c0 82 40 00 ?? push 0x004082c0
   6a 18 ?? push 0x18<24>
   e8 3e f9 ff ff ?? call function 0x00401127
  
  L26: 68 c0 82 40 00 ?? push 0x004082c0
   68 f0 00 00 00 ?? push 0x000000f0<240>
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   e8 6d f9 ff ff ?? call function 0x00401168
  
  L27: 83 c4 10 ?? add esp, 0x10<16>
   89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   85 f6 ?? test esi, esi
   74 1e ?? je basic block L31
  
  L28: 8d 4e 08 ?? lea ecx, ds:[esi + 8]
   c7 41 14 0f 00 00 00 ?? mov dword ds:[ecx + 0x14<20>], 15
   c7 41 10 00 00 00 00 ?? mov dword ds:[ecx + 0x10<16>], 0
   83 79 14 10 ?? cmp dword ds:[ecx + 0x14<20>], 0x10<16>
   72 02 ?? jb basic block L30
  
  L29: 8b 09 ?? mov ecx, dword ds:[ecx]
  
  L30: c6 01 00 ?? mov byte ds:[ecx], 0
   eb 02 ?? jmp basic block L32
  
  L31: 33 f6 ?? xor esi, esi
  
  L32: 85 ff ?? test edi, edi
   74 1f ?? je basic block L35
  
  L33: 68 49 12 40 00 ?? push 0x00401249
   68 13 11 40 00 ?? push 0x00401113
   6a 2a ?? push 0x2a<42>
   6a 20 ?? push 0x20<32>
   8d 5f 04 ?? lea ebx, ds:[edi + 4]
   c7 07 2a 00 00 00 ?? mov dword ds:[edi], 0x0000002a<42>
   53 ?? push ebx
   e8 64 f8 ff ff ?? call function 0x004010aa
  
  L34: eb 02 ?? jmp basic block L36
  
  L35: 33 db ?? xor ebx, ebx
  
  L36: 85 f6 ?? test esi, esi
   74 3d ?? je basic block L44
  
  L37: 8b 46 1c ?? mov eax, dword ds:[esi + 0x1c<28>]
   8d 7e 08 ?? lea edi, ds:[esi + 8]
   83 f8 10 ?? cmp eax, 0x10<16>
   72 0e ?? jb basic block L40
  
  L38: 40 ?? inc eax
   6a 01 ?? push 1
   50 ?? push eax
   ff 37 ?? push dword ds:[edi]
   e8 8b f9 ff ff ?? call function 0x004011ef
  
  L39: 83 c4 0c ?? add esp, 12
  
  L40: c7 47 14 0f 00 00 00 ?? mov dword ds:[edi + 0x14<20>], 15
   83 7f 14 10 ?? cmp dword ds:[edi + 0x14<20>], 0x10<16>
   c7 47 10 00 00 00 00 ?? mov dword ds:[edi + 0x10<16>], 0
   72 02 ?? jb basic block L42
  
  L41: 8b 3f ?? mov edi, dword ds:[edi]
  
  L42: 6a 20 ?? push 0x20<32>
   56 ?? push esi
   c6 07 00 ?? mov byte ds:[edi], 0
   e8 aa f7 ff ff ?? call function 0x00401032
  
  L43: 83 c4 08 ?? add esp, 8
  
  L44: 85 db ?? test ebx, ebx
   74 33 ?? je basic block L48
  
  L45: 68 49 12 40 00 ?? push 0x00401249
   ff 73 fc ?? push dword ds:[ebx + 0xfc<252,-4>]
   8d 73 fc ?? lea esi, ds:[ebx + 0xfc<252,-4>]
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   6a 20 ?? push 0x20<32>
   53 ?? push ebx
   e8 a6 f8 ff ff ?? call function 0x0040114f
  
  L46: 8b 06 ?? mov eax, dword ds:[esi]
   c1 e0 05 ?? shl eax, 5
   83 c0 04 ?? add eax, 4
   50 ?? push eax
   56 ?? push esi
   e8 5c f7 ff ff ?? call function 0x00401014
  
  L47: 83 c4 08 ?? add esp, 8
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
  
  L48: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   85 c0 ?? test eax, eax
   74 42 ?? je basic block L56
  
  L49: 8b 48 1c ?? mov ecx, dword ds:[eax + 0x1c<28>]
   8d 70 08 ?? lea esi, ds:[eax + 8]
   83 f9 10 ?? cmp ecx, 0x10<16>
   72 13 ?? jb basic block L52
  
  L50: 8d 41 01 ?? lea eax, ds:[ecx + 1]
   6a 01 ?? push 1
   50 ?? push eax
   ff 36 ?? push dword ds:[esi]
   e8 0e f9 ff ff ?? call function 0x004011ef
  
  L51: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   83 c4 0c ?? add esp, 12
  
  L52: c7 46 14 0f 00 00 00 ?? mov dword ds:[esi + 0x14<20>], 15
   83 7e 14 10 ?? cmp dword ds:[esi + 0x14<20>], 0x10<16>
   c7 46 10 00 00 00 00 ?? mov dword ds:[esi + 0x10<16>], 0
   72 02 ?? jb basic block L54
  
  L53: 8b 36 ?? mov esi, dword ds:[esi]
  
  L54: 6a 20 ?? push 0x20<32>
   50 ?? push eax
   c6 06 00 ?? mov byte ds:[esi], 0
   e8 2a f7 ff ff ?? call function 0x00401032
  
  L55: 83 c4 08 ?? add esp, 8
  
  L56: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   85 c0 ?? test eax, eax
   74 2c ?? je basic block L60
  
  L57: 68 49 12 40 00 ?? push 0x00401249
   ff 70 fc ?? push dword ds:[eax + 0xfc<252,-4>]
   8d 70 fc ?? lea esi, ds:[eax + 0xfc<252,-4>]
   c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   6a 20 ?? push 0x20<32>
   50 ?? push eax
   e8 23 f8 ff ff ?? call function 0x0040114f
  
  L58: 8b 06 ?? mov eax, dword ds:[esi]
   c1 e0 05 ?? shl eax, 5
   83 c0 04 ?? add eax, 4
   50 ?? push eax
   56 ?? push esi
   e8 d9 f6 ff ff ?? call function 0x00401014
  
  L59: 83 c4 08 ?? add esp, 8
  
  L60: 8b 45 e8 ?? mov eax, dword ss:[ebp + 0xe8<232,-24>]
   85 c0 ?? test eax, eax
   74 0b ?? je basic block L63
  
  L61: 6a 18 ?? push 0x18<24>
   50 ?? push eax
   e8 e5 f6 ff ff ?? call function 0x00401032
  
  L62: 83 c4 08 ?? add esp, 8
  
  L63: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
   85 c0 ?? test eax, eax
   74 09 ?? je basic block L66
  
  L64: 50 ?? push eax
   e8 d3 f8 ff ff ?? call function 0x00401230
  
  L65: 83 c4 04 ?? add esp, 4
  
  L66: 6a 18 ?? push 0x18<24>
   ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
   e8 c8 f6 ff ff ?? call function 0x00401032
  
  L67: ff 75 dc ?? push dword ss:[ebp + 0xdc<220,-36>]
   e8 be f8 ff ff ?? call function 0x00401230
  
  L68: 83 c4 0c ?? add esp, 12
   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
  
  