Disassembly: 
  L1: 8b ff ?? mov edi, edi
   55 ?? push ebp
   8b ec ?? mov ebp, esp
   83 ec 4c ?? sub esp, 0x4c<76>
   a1 34 44 43 00 ?? mov eax, dword ds:[0x00434434]
   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 6c 2b 00 00 ?? call function 0x0040c3c0
  
  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 9a 07 00 00 ?? call function 0x0040a000
  
  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 cf 07 00 00 ?? call function 0x0040a045
  
  L7: 6a 01 ?? push 1
   57 ?? push edi
   89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
   e8 c4 07 00 00 ?? call function 0x0040a045
  
  L8: 6a 01 ?? push 1
   57 ?? push edi
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   e8 b9 07 00 00 ?? call function 0x0040a045
  
  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 aa 07 00 00 ?? call function 0x0040a045
  
  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 48 82 43 00 ?? call dword ds:[0x00438248]
  
  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 d5 79 00 00 ?? call function 0x00411330
  
  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 c1 f7 ff ff ?? call function 0x0040914f
  
  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 94 f7 ff ff ?? call function 0x0040914f
  
  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 fc 01 00 00 ?? call function 0x00409c60
  
  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 ed 01 00 00 ?? call function 0x00409c60
  
  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 db 01 00 00 ?? call function 0x00409c60
  
  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 f4 81 43 00 ?? call dword ds:[0x004381f4]
  
  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 7e ce ff ff ?? call function 0x0040692c
  
  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 6b ce ff ff ?? call function 0x0040692c
  
  L52: 8b 86 d0 00 00 00 ?? mov eax, dword ds:[esi + 0x000000d0<208>]
   2b c7 ?? sub eax, edi
   50 ?? push eax
   e8 5d ce ff ff ?? call function 0x0040692c
  
  L53: ff b6 c0 00 00 00 ?? push dword ds:[esi + 0x000000c0<192>]
   e8 52 ce ff ff ?? call function 0x0040692c
  
  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 0b ce ff ff ?? call function 0x0040692c
  
  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 fe cd ff ff ?? call function 0x0040692c
  
  L59: ff 75 e4 ?? push dword ss:[ebp + 0xe4<228,-28>]
   e8 f6 cd ff ff ?? call function 0x0040692c
  
  L60: ff 75 e0 ?? push dword ss:[ebp + 0xe0<224,-32>]
   e8 ee cd ff ff ?? call function 0x0040692c
  
  L61: ff 75 d8 ?? push dword ss:[ebp + 0xd8<216,-40>]
   e8 e6 cd ff ff ?? call function 0x0040692c
  
  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 f4 81 43 00 ?? call dword ds:[0x004381f4]
  
  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 a0 e3 ?? mov dword ds:[esi + 0x000000c8<200>], 0x0042e3a0<" ((((( H">
   42 00
   c7 86 cc 00 00 00 28 e8 ?? mov dword ds:[esi + 0x000000cc<204>], 0x0042e828
   42 00
   c7 86 d0 00 00 00 a8 e9 ?? mov dword ds:[esi + 0x000000d0<208>], 0x0042e9a8
   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 e8 c4 ff ff ?? call function 0x00406088
  
  L67: c9 ?? leave
   c3 ?? ret
  
  