
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

