
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 83 ec 4c ?? sub esp, 0x4c<76>
 a1 3c 80 42 00 ?? mov eax, dword ds:[0x0042803c]
 33 c5 ?? xor eax, ebp
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 53 ?? push ebx
 33 db ?? xor ebx, ebx
 56 ?? push esi
 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
 57 ?? push edi
 89 5d d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], ebx
 89 5d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ebx
 89 5d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], ebx
 89 5d d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], ebx
 89 5d dc ?? mov dword ss:[ebp + 0xdc<220,-36>], ebx
 89 75 b4 ?? mov dword ss:[ebp + 0xb4<180,-76>], esi
 89 5d b8 ?? mov dword ss:[ebp + 0xb8<184,-72>], ebx
 39 5e 14 ?? cmp dword ds:[esi + 0x14<20>], ebx
 0f 84 16 03 00 00 ?? je basic block L63

L2: 8d 46 04 ?? lea eax, ds:[esi + 4]
 39 18 ?? cmp dword ds:[eax], ebx
 75 20 ?? jne basic block L5

L3: 50 ?? push eax
 0f b7 46 30 ?? movzx eax, word ds:[esi + 0x30<48>]
 68 04 10 00 00 ?? push 0x00001004<4100>
 50 ?? push eax
 8d 45 b4 ?? lea eax, ss:[ebp + 0xb4<180,-76>]
 53 ?? push ebx
 50 ?? push eax
 e8 d1 8d ff ff ?? call function 0x00409490

L4: 83 c4 14 ?? add esp, 0x14<20>
 85 c0 ?? test eax, eax
 0f 85 c7 02 00 00 ?? jne basic block L58

L5: 6a 04 ?? push 4
 e8 22 61 ff ff ?? call function 0x004067f3

L6: 6a 02 ?? push 2
 bf 80 01 00 00 ?? mov edi, 0x00000180<384>
 57 ?? push edi
 89 45 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], eax
 e8 57 61 ff ff ?? call function 0x00406838

L7: 6a 01 ?? push 1
 57 ?? push edi
 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
 e8 4c 61 ff ff ?? call function 0x00406838

L8: 6a 01 ?? push 1
 57 ?? push edi
 89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
 e8 41 61 ff ff ?? call function 0x00406838

L9: 6a 01 ?? push 1
 68 01 01 00 00 ?? push 0x00000101<257>
 89 45 d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], eax
 e8 32 61 ff ff ?? call function 0x00406838

L10: 83 c4 24 ?? add esp, 0x24<36>
 89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
 39 5d d4 ?? cmp dword ss:[ebp + 0xd4<212,-44>], ebx
 0f 84 7c 02 00 00 ?? je basic block L58

L11: 39 5d e4 ?? cmp dword ss:[ebp + 0xe4<228,-28>], ebx
 0f 84 73 02 00 00 ?? je basic block L58

L12: 3b c3 ?? cmp eax, ebx
 0f 84 6b 02 00 00 ?? je basic block L58

L13: 39 5d e0 ?? cmp dword ss:[ebp + 0xe0<224,-32>], ebx
 0f 84 62 02 00 00 ?? je basic block L58

L14: 39 5d d8 ?? cmp dword ss:[ebp + 0xd8<216,-40>], ebx
 0f 84 59 02 00 00 ?? je basic block L58

L15: 8b 45 d4 ?? mov eax, dword ss:[ebp + 0xd4<212,-44>]
 89 18 ?? mov dword ds:[eax], ebx
 33 c0 ?? xor eax, eax

L16: 8b 4d dc ?? mov ecx, dword ss:[ebp + 0xdc<220,-36>]
 88 04 08 ?? mov byte ds:[eax + ecx], al
 40 ?? inc eax
 3d 00 01 00 00 ?? cmp eax, 0x00000100<256>

L17: 7c f2 ?? jl basic block L16

L18: 8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
 50 ?? push eax
 ff 76 04 ?? push dword ds:[esi + 4]
 ff 15 78 a2 42 00 ?? call dword ds:[0x0042a278]

L19: 85 c0 ?? test eax, eax
 0f 84 2f 02 00 00 ?? je basic block L58

L20: 83 7d e8 05 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 5
 0f 87 25 02 00 00 ?? ja basic block L58

L21: 0f b7 45 e8 ?? movzx eax, word ss:[ebp + 0xe8<232,-24>]
 83 f8 01 ?? cmp eax, 1
 89 45 d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], eax
 7e 2d ?? jle basic block L29

L22: 38 5d ee ?? cmp byte ss:[ebp + 0xee<238,-18>], bl
 74 28 ?? je basic block L29

L23: 8d 45 ef ?? lea eax, ss:[ebp + 0xef<239,-17>]

L24: 8a 08 ?? mov cl, byte ds:[eax]
 3a cb ?? cmp cl, bl
 74 1f ?? je basic block L29

L25: 0f b6 78 ff ?? movzx edi, byte ds:[eax + 0xff<255,-1>]
 0f b6 c9 ?? movzx ecx, cl
 eb 0b ?? jmp basic block L27

L26: 8b 4d dc ?? mov ecx, dword ss:[ebp + 0xdc<220,-36>]
 c6 04 0f 20 ?? mov byte ds:[edi + ecx], 0x20<32>
 0f b6 08 ?? movzx ecx, byte ds:[eax]
 47 ?? inc edi

L27: 3b f9 ?? cmp edi, ecx
 7e f1 ?? jle basic block L26

L28: 40 ?? inc eax
 40 ?? inc eax
 38 58 ff ?? cmp byte ds:[eax + 0xff<255,-1>], bl
 75 db ?? jne basic block L24

L29: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
 53 ?? push ebx
 53 ?? push ebx
 ff 76 04 ?? push dword ds:[esi + 4]
 05 00 01 00 00 ?? add eax, 0x00000100<256>
 50 ?? push eax
 68 00 01 00 00 ?? push 0x00000100<256>
 ff 75 dc ?? push dword ss:[ebp + 0xdc<220,-36>]
 89 45 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], eax
 6a 01 ?? push 1
 53 ?? push ebx
 e8 60 4a 00 00 ?? call function 0x00415226

L30: 83 c4 20 ?? add esp, 0x20<32>
 85 c0 ?? test eax, eax
 0f 84 c0 01 00 00 ?? je basic block L58

L31: 8b 4d e0 ?? mov ecx, dword ss:[ebp + 0xe0<224,-32>]
 8b 45 dc ?? mov eax, dword ss:[ebp + 0xdc<220,-36>]
 53 ?? push ebx
 ff 76 04 ?? push dword ds:[esi + 4]
 bf ff 00 00 00 ?? mov edi, 0x000000ff<255>
 57 ?? push edi
 81 c1 81 00 00 00 ?? add ecx, 0x00000081<129>
 51 ?? push ecx
 57 ?? push edi
 40 ?? inc eax
 50 ?? push eax
 68 00 01 00 00 ?? push 0x00000100<256>
 ff 76 14 ?? push dword ds:[esi + 0x14<20>]
 53 ?? push ebx
 e8 3a 4f 00 00 ?? call function 0x00415733

L32: 83 c4 24 ?? add esp, 0x24<36>
 85 c0 ?? test eax, eax
 0f 84 8d 01 00 00 ?? je basic block L58

L33: 8b 45 d8 ?? mov eax, dword ss:[ebp + 0xd8<216,-40>]
 53 ?? push ebx
 ff 76 04 ?? push dword ds:[esi + 4]
 05 81 00 00 00 ?? add eax, 0x00000081<129>
 57 ?? push edi
 50 ?? push eax
 8b 45 dc ?? mov eax, dword ss:[ebp + 0xdc<220,-36>]
 57 ?? push edi
 40 ?? inc eax
 50 ?? push eax
 68 00 02 00 00 ?? push 0x00000200<512>
 ff 76 14 ?? push dword ds:[esi + 0x14<20>]
 53 ?? push ebx
 e8 0d 4f 00 00 ?? call function 0x00415733

L34: 83 c4 24 ?? add esp, 0x24<36>
 85 c0 ?? test eax, eax
 0f 84 60 01 00 00 ?? je basic block L58

L35: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
 8b 7d e0 ?? mov edi, dword ss:[ebp + 0xe0<224,-32>]
 8d 88 fe 00 00 00 ?? lea ecx, ds:[eax + 0x000000fe<254>]
 33 d2 ?? xor edx, edx
 83 7d d0 01 ?? cmp dword ss:[ebp + 0xd0<208,-48>], 1
 66 89 11 ?? mov word ds:[ecx], dx
 8b 55 d8 ?? mov edx, dword ss:[ebp + 0xd8<216,-40>]
 89 4d c4 ?? mov dword ss:[ebp + 0xc4<196,-60>], ecx
 8d 8f 80 00 00 00 ?? lea ecx, ds:[edi + 0x00000080<128>]
 88 5f 7f ?? mov byte ds:[edi + 0x7f<127>], bl
 88 5a 7f ?? mov byte ds:[edx + 0x7f<127>], bl
 88 19 ?? mov byte ds:[ecx], bl
 89 4d bc ?? mov dword ss:[ebp + 0xbc<188,-68>], ecx
 8d 8a 80 00 00 00 ?? lea ecx, ds:[edx + 0x00000080<128>]
 89 4d c8 ?? mov dword ss:[ebp + 0xc8<200,-56>], ecx
 88 19 ?? mov byte ds:[ecx], bl
 7e 53 ?? jle basic block L44

L36: 38 5d ee ?? cmp byte ss:[ebp + 0xee<238,-18>], bl
 74 4e ?? je basic block L44

L37: 8d 4d ef ?? lea ecx, ss:[ebp + 0xef<239,-17>]
 89 4d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ecx

L38: 8a 11 ?? mov dl, byte ds:[ecx]
 3a d3 ?? cmp dl, bl
 74 42 ?? je basic block L44

L39: 0f b6 49 ff ?? movzx ecx, byte ds:[ecx + 0xff<255,-1>]
 0f b6 d2 ?? movzx edx, dl
 3b ca ?? cmp ecx, edx
 89 4d e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], ecx
 7f 27 ?? jg basic block L43

L40: 8d 8c 48 00 01 00 00 ?? lea ecx, ds:[eax + ecx * 2 + 0x00000100<256>]
 eb 03 ?? jmp basic block L42

L41: 8b 4d cc ?? mov ecx, dword ss:[ebp + 0xcc<204,-52>]

L42: ff 45 e0 ?? inc dword ss:[ebp + 0xe0<224,-32>]
 ba 00 80 00 00 ?? mov edx, 0x00008000<32768>
 66 89 11 ?? mov word ds:[ecx], dx
 41 ?? inc ecx
 41 ?? inc ecx
 89 4d cc ?? mov dword ss:[ebp + 0xcc<204,-52>], ecx
 8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
 0f b6 09 ?? movzx ecx, byte ds:[ecx]
 39 4d e0 ?? cmp dword ss:[ebp + 0xe0<224,-32>], ecx
 7e e2 ?? jle basic block L41

L43: 8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
 41 ?? inc ecx
 41 ?? inc ecx
 89 4d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ecx
 38 59 ff ?? cmp byte ds:[ecx + 0xff<255,-1>], bl
 75 b8 ?? jne basic block L38

L44: 68 fe 00 00 00 ?? push 0x000000fe<254>
 8d 88 00 02 00 00 ?? lea ecx, ds:[eax + 0x00000200<512>]
 51 ?? push ecx
 50 ?? push eax
 e8 71 93 ff ff ?? call function 0x00409c40

L45: 6a 7f ?? push 0x7f<127>
 8d 87 00 01 00 00 ?? lea eax, ds:[edi + 0x00000100<256>]
 50 ?? push eax
 57 ?? push edi
 e8 62 93 ff ff ?? call function 0x00409c40

L46: 8b 45 d8 ?? mov eax, dword ss:[ebp + 0xd8<216,-40>]
 6a 7f ?? push 0x7f<127>
 8d 88 00 01 00 00 ?? lea ecx, ds:[eax + 0x00000100<256>]
 51 ?? push ecx
 50 ?? push eax
 e8 50 93 ff ff ?? call function 0x00409c40

L47: 8b 86 c0 00 00 00 ?? mov eax, dword ds:[esi + 0x000000c0<192>]
 83 c4 24 ?? add esp, 0x24<36>
 3b c3 ?? cmp eax, ebx
 74 4b ?? je basic block L55

L48: 50 ?? push eax
 ff 15 f0 a1 42 00 ?? call dword ds:[0x0042a1f0]

L49: 85 c0 ?? test eax, eax
 75 40 ?? jne basic block L55

L50: 8b 86 c4 00 00 00 ?? mov eax, dword ds:[esi + 0x000000c4<196>]
 2d fe 00 00 00 ?? sub eax, 0x000000fe<254>
 50 ?? push eax
 e8 d4 11 ff ff ?? call function 0x00401aed

L51: 8b 86 cc 00 00 00 ?? mov eax, dword ds:[esi + 0x000000cc<204>]
 bf 80 00 00 00 ?? mov edi, 0x00000080<128>
 2b c7 ?? sub eax, edi
 50 ?? push eax
 e8 c1 11 ff ff ?? call function 0x00401aed

L52: 8b 86 d0 00 00 00 ?? mov eax, dword ds:[esi + 0x000000d0<208>]
 2b c7 ?? sub eax, edi
 50 ?? push eax
 e8 b3 11 ff ff ?? call function 0x00401aed

L53: ff b6 c0 00 00 00 ?? push dword ds:[esi + 0x000000c0<192>]
 e8 a8 11 ff ff ?? call function 0x00401aed

L54: 83 c4 10 ?? add esp, 0x10<16>

L55: 8b 45 d4 ?? mov eax, dword ss:[ebp + 0xd4<212,-44>]
 c7 00 01 00 00 00 ?? mov dword ds:[eax], 1
 89 86 c0 00 00 00 ?? mov dword ds:[esi + 0x000000c0<192>], eax
 8b 45 c0 ?? mov eax, dword ss:[ebp + 0xc0<192,-64>]
 89 86 c8 00 00 00 ?? mov dword ds:[esi + 0x000000c8<200>], eax
 8b 45 c4 ?? mov eax, dword ss:[ebp + 0xc4<196,-60>]
 89 86 c4 00 00 00 ?? mov dword ds:[esi + 0x000000c4<196>], eax
 8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
 89 86 cc 00 00 00 ?? mov dword ds:[esi + 0x000000cc<204>], eax
 8b 45 c8 ?? mov eax, dword ss:[ebp + 0xc8<200,-56>]
 89 86 d0 00 00 00 ?? mov dword ds:[esi + 0x000000d0<208>], eax
 8b 45 d0 ?? mov eax, dword ss:[ebp + 0xd0<208,-48>]
 89 86 ac 00 00 00 ?? mov dword ds:[esi + 0x000000ac<172>], eax

L56: ff 75 dc ?? push dword ss:[ebp + 0xdc<220,-36>]
 e8 61 11 ff ff ?? call function 0x00401aed

L57: 59 ?? pop ecx
 8b c3 ?? mov eax, ebx
 eb 6d ?? jmp basic block L66

L58: ff 75 d4 ?? push dword ss:[ebp + 0xd4<212,-44>]
 e8 54 11 ff ff ?? call function 0x00401aed

L59: ff 75 e4 ?? push dword ss:[ebp + 0xe4<228,-28>]
 e8 4c 11 ff ff ?? call function 0x00401aed

L60: ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
 e8 44 11 ff ff ?? call function 0x00401aed

L61: ff 75 d8 ?? push dword ss:[ebp + 0xd8<216,-40>]
 e8 3c 11 ff ff ?? call function 0x00401aed

L62: 33 db ?? xor ebx, ebx
 83 c4 10 ?? add esp, 0x10<16>
 43 ?? inc ebx
 eb cb ?? jmp basic block L56

L63: 8d be c0 00 00 00 ?? lea edi, ds:[esi + 0x000000c0<192>]
 8b 07 ?? mov eax, dword ds:[edi]
 3b c3 ?? cmp eax, ebx
 74 07 ?? je basic block L65

L64: 50 ?? push eax
 ff 15 f0 a1 42 00 ?? call dword ds:[0x0042a1f0]

L65: 89 1f ?? mov dword ds:[edi], ebx
 89 9e c4 00 00 00 ?? mov dword ds:[esi + 0x000000c4<196>], ebx
 c7 86 c8 00 00 00 48 4f ?? mov dword ds:[esi + 0x000000c8<200>], 0x00424f48<" ((((( H">
 42 00
 c7 86 cc 00 00 00 d0 53 ?? mov dword ds:[esi + 0x000000cc<204>], 0x004253d0
 42 00
 c7 86 d0 00 00 00 50 55 ?? mov dword ds:[esi + 0x000000d0<208>], 0x00425550
 42 00
 c7 86 ac 00 00 00 01 00 ?? mov dword ds:[esi + 0x000000ac<172>], 1
 00 00
 33 c0 ?? xor eax, eax

L66: 8b 4d fc ?? mov ecx, dword ss:[ebp + 0xfc<252,-4>]
 5f ?? pop edi
 5e ?? pop esi
 33 cd ?? xor ecx, ebp
 5b ?? pop ebx
 e8 d3 0e ff ff ?? call function 0x004018de

L67: c9 ?? leave
 c3 ?? ret

