Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 c8 21 40 00 ?? push 0x004021c8
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   51 ?? push ecx
   83 ec 60 ?? sub esp, 0x60<96>
   53 ?? push ebx
   56 ?? push esi
   57 ?? push edi
   a1 78 40 40 00 ?? mov eax, dword ds:[0x00404078]
   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
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
   8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   50 ?? push eax
   ff 15 48 30 40 00 ?? call dword ds:[0x00403048<"H:@">]
  
  L2: 83 c4 04 ?? add esp, 4
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 54 30 40 00 ?? call dword ds:[function 0x00403054<"*:@">]
  
  L3: 85 c0 ?? test eax, eax
   7e 33 ?? jle basic block L8
  
  L4: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   ff 15 54 30 40 00 ?? call dword ds:[function 0x00403054<"*:@">]
  
  L5: 3b 45 e8 ?? cmp eax, dword ss:[ebp + 0xe8<232,-24>]
   7e 1b ?? jle basic block L8
  
  L6: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   ff 15 54 30 40 00 ?? call dword ds:[function 0x00403054<"*:@">]
  
  L7: 2b 45 e8 ?? sub eax, dword ss:[ebp + 0xe8<232,-24>]
   89 45 c4 ?? mov dword ss:[ebp + 0xc4<196,-60>], eax
   eb 07 ?? jmp basic block L9
  
  L8: c7 45 c4 00 00 00 00 ?? mov dword ss:[ebp + 0xc4<196,-60>], 0
  
  L9: 8b 45 c4 ?? mov eax, dword ss:[ebp + 0xc4<196,-60>]
   89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   8d 4d dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 3c 02 00 00 ?? call function 0x004014f0
  
  L10: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8d 4d dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 5d 03 00 00 ?? call function 0x00401620
  
  L11: 0f b6 d0 ?? movzx edx, al
   85 d2 ?? test edx, edx
   75 0e ?? jne basic block L13
  
  L12: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   e9 c8 01 00 00 ?? jmp basic block L45
  
  L13: c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 58 30 40 00 ?? call dword ds:[function 0x00403058<"\f:@">]
  
  L14: 89 45 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], eax
   8b 45 c0 ?? mov eax, dword ss:[ebp + 0xc0<192,-64>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   0f 84 8b 00 00 00 ?? je basic block L25
  
  L15: eb 09 ?? jmp basic block L16
  
  L16: 83 7d e4 00 ?? cmp dword ss:[ebp + 0xe4<228,-28>], 0
   7e 7a ?? jle basic block L25
  
  L17: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   8b 02 ?? mov eax, dword ds:[edx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 48 04 ?? add ecx, dword ds:[eax + 4]
   ff 15 5c 30 40 00 ?? call dword ds:[function 0x0040305c]
  
  L18: 88 45 bf ?? mov byte ss:[ebp + 0xbf<191,-65>], al
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 60 30 40 00 ?? call dword ds:[function 0x00403060<"l9@">]
  
  L19: 89 45 b8 ?? mov dword ss:[ebp + 0xb8<184,-72>], eax
   0f b6 45 bf ?? movzx eax, byte ss:[ebp + 0xbf<191,-65>]
   50 ?? push eax
   8b 4d b8 ?? mov ecx, dword ss:[ebp + 0xb8<184,-72>]
   ff 15 64 30 40 00 ?? call dword ds:[function 0x00403064<",9@">]
  
  L20: 89 45 b4 ?? mov dword ss:[ebp + 0xb4<180,-76>], eax
   8b 4d b4 ?? mov ecx, dword ss:[ebp + 0xb4<180,-76>]
   89 4d d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], ecx
   ff 15 68 30 40 00 ?? call dword ds:[0x00403068<"\n9@">]
  
  L21: 89 45 b0 ?? mov dword ss:[ebp + 0xb0<176,-80>], eax
   8b 55 b0 ?? mov edx, dword ss:[ebp + 0xb0<176,-80>]
   89 55 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], edx
   8d 45 d8 ?? lea eax, ss:[ebp + 0xd8<216,-40>]
   50 ?? push eax
   8d 4d d4 ?? lea ecx, ss:[ebp + 0xd4<212,-44>]
   51 ?? push ecx
   ff 15 6c 30 40 00 ?? call dword ds:[0x0040306c]
  
  L22: 83 c4 08 ?? add esp, 8
   88 45 af ?? mov byte ss:[ebp + 0xaf<175,-81>], al
   0f b6 55 af ?? movzx edx, byte ss:[ebp + 0xaf<175,-81>]
   85 d2 ?? test edx, edx
   74 0b ?? je basic block L24
  
  L23: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   eb 05 ?? jmp basic block L25
  
  L24: e9 77 ff ff ff ?? jmp 0x00401303
   8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
   83 e9 01 ?? sub ecx, 1
   89 4d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ecx
  
  L25: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   75 39 ?? jne basic block L30
  
  L26: 8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 60 30 40 00 ?? call dword ds:[function 0x00403060<"l9@">]
  
  L27: 89 45 a8 ?? mov dword ss:[ebp + 0xa8<168,-88>], eax
   8b 45 e8 ?? mov eax, dword ss:[ebp + 0xe8<232,-24>]
   50 ?? push eax
   8b 4d 0c ?? mov ecx, dword ss:[ebp + 12]
   51 ?? push ecx
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   ff 15 70 30 40 00 ?? call dword ds:[function 0x00403070]
  
  L28: 89 45 a4 ?? mov dword ss:[ebp + 0xa4<164,-92>], eax
   8b 55 a4 ?? mov edx, dword ss:[ebp + 0xa4<164,-92>]
   3b 55 e8 ?? cmp edx, dword ss:[ebp + 0xe8<232,-24>]
   74 09 ?? je basic block L30
  
  L29: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
  
  L30: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   0f 85 8b 00 00 00 ?? jne basic block L41
  
  L31: eb 09 ?? jmp basic block L32
  
  L32: 83 7d e4 00 ?? cmp dword ss:[ebp + 0xe4<228,-28>], 0
   7e 7a ?? jle basic block L41
  
  L33: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   8b 02 ?? mov eax, dword ds:[edx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 48 04 ?? add ecx, dword ds:[eax + 4]
   ff 15 5c 30 40 00 ?? call dword ds:[function 0x0040305c]
  
  L34: 88 45 a3 ?? mov byte ss:[ebp + 0xa3<163,-93>], al
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 60 30 40 00 ?? call dword ds:[function 0x00403060<"l9@">]
  
  L35: 89 45 9c ?? mov dword ss:[ebp + 0x9c<156,-100>], eax
   0f b6 45 a3 ?? movzx eax, byte ss:[ebp + 0xa3<163,-93>]
   50 ?? push eax
   8b 4d 9c ?? mov ecx, dword ss:[ebp + 0x9c<156,-100>]
   ff 15 64 30 40 00 ?? call dword ds:[function 0x00403064<",9@">]
  
  L36: 89 45 98 ?? mov dword ss:[ebp + 0x98<152,-104>], eax
   8b 4d 98 ?? mov ecx, dword ss:[ebp + 0x98<152,-104>]
   89 4d d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], ecx
   ff 15 68 30 40 00 ?? call dword ds:[0x00403068<"\n9@">]
  
  L37: 89 45 94 ?? mov dword ss:[ebp + 0x94<148,-108>], eax
   8b 55 94 ?? mov edx, dword ss:[ebp + 0x94<148,-108>]
   89 55 cc ?? mov dword ss:[ebp + 0xcc<204,-52>], edx
   8d 45 d0 ?? lea eax, ss:[ebp + 0xd0<208,-48>]
   50 ?? push eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   51 ?? push ecx
   ff 15 6c 30 40 00 ?? call dword ds:[0x0040306c]
  
  L38: 83 c4 08 ?? add esp, 8
   88 45 93 ?? mov byte ss:[ebp + 0x93<147,-109>], al
   0f b6 55 93 ?? movzx edx, byte ss:[ebp + 0x93<147,-109>]
   85 d2 ?? test edx, edx
   74 0b ?? je basic block L40
  
  L39: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   eb 05 ?? jmp basic block L41
  
  L40: e9 77 ff ff ff ?? jmp 0x004013d7
   8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
   83 e9 01 ?? sub ecx, 1
   89 4d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ecx
  
  L41: 6a 00 ?? push 0
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 74 30 40 00 ?? call dword ds:[function 0x00403074<"v8@">]
  
  L42: eb 24 ?? jmp 0x00401499
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
  
  L43: 6a 01 ?? push 1
   6a 04 ?? push 4
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   ff 15 78 30 40 00 ?? call dword ds:[function 0x00403078<"68@">]
  
  L44: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   b8 a0 14 40 00 ?? mov eax, basic block L45
   c3 ?? ret
  
  L45: 6a 00 ?? push 0
   8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   ff 15 78 30 40 00 ?? call dword ds:[function 0x00403078<"68@">]
  
  L46: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   89 45 c8 ?? mov dword ss:[ebp + 0xc8<200,-56>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 e4 00 00 00 ?? call function 0x004015b0
  
  L47: 8b 45 c8 ?? mov eax, dword ss:[ebp + 0xc8<200,-56>]
   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
  
  