Disassembly: 
  L1: 8b ff ?? mov edi, edi
   55 ?? push ebp
   8b ec ?? mov ebp, esp
   83 ec 1c ?? sub esp, 0x1c<28>
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   56 ?? push esi
   8b 75 08 ?? mov esi, dword ss:[ebp + 8]
   6a fe ?? push 0xfe<254,-2>
   58 ?? pop eax
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   89 55 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], edx
   3b f0 ?? cmp esi, eax
   75 1b ?? jne basic block L5
  
  L2: e8 3b f6 fe ff ?? call function 0x0040c535
  
  L3: 83 20 00 ?? and dword ds:[eax], 0
   e8 20 f6 fe ff ?? call function 0x0040c522
  
  L4: c7 00 09 00 00 00 ?? mov dword ds:[eax], 9
   83 c8 ff ?? or eax, 0xff<255,-1>
   e9 88 05 00 00 ?? jmp basic block L166
  
  L5: 53 ?? push ebx
   33 db ?? xor ebx, ebx
   3b f3 ?? cmp esi, ebx
   7c 08 ?? jl basic block L7
  
  L6: 3b 35 54 66 43 00 ?? cmp esi, dword ds:[0x00436654]
   72 27 ?? jb basic block L11
  
  L7: e8 11 f6 fe ff ?? call function 0x0040c535
  
  L8: 89 18 ?? mov dword ds:[eax], ebx
   e8 f7 f5 fe ff ?? call function 0x0040c522
  
  L9: 53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   c7 00 09 00 00 00 ?? mov dword ds:[eax], 9
   e8 85 9a fe ff ?? call function 0x004069c0
  
  L10: 83 c4 14 ?? add esp, 0x14<20>
   83 c8 ff ?? or eax, 0xff<255,-1>
   e9 51 05 00 00 ?? jmp basic block L165
  
  L11: 8b c6 ?? mov eax, esi
   c1 f8 05 ?? sar eax, 5
   57 ?? push edi
   8d 3c 85 a0 66 43 00 ?? lea edi, ds:[0x004366a0 + eax * 4]
   8b 07 ?? mov eax, dword ds:[edi]
   83 e6 1f ?? and esi, 0x1f<31>
   c1 e6 06 ?? shl esi, 6
   03 c6 ?? add eax, esi
   8a 48 04 ?? mov cl, byte ds:[eax + 4]
   f6 c1 01 ?? test cl, 1
   75 14 ?? jne basic block L15
  
  L12: e8 cb f5 fe ff ?? call function 0x0040c535
  
  L13: 89 18 ?? mov dword ds:[eax], ebx
   e8 b1 f5 fe ff ?? call function 0x0040c522
  
  L14: c7 00 09 00 00 00 ?? mov dword ds:[eax], 9
   eb 6a ?? jmp basic block L28
  
  L15: 81 fa ff ff ff 7f ?? cmp edx, 0x7fffffff
   77 50 ?? ja basic block L25
  
  L16: 89 5d f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], ebx
   3b d3 ?? cmp edx, ebx
   0f 84 08 05 00 00 ?? je basic block L163
  
  L17: f6 c1 02 ?? test cl, 2
   0f 85 ff 04 00 00 ?? jne basic block L163
  
  L18: 39 5d 0c ?? cmp dword ss:[ebp + 12], ebx
   74 37 ?? je basic block L25
  
  L19: 8a 40 24 ?? mov al, byte ds:[eax + 0x24<36>]
   02 c0 ?? add al, al
   d0 f8 ?? sar al, 1
   88 45 fe ?? mov byte ss:[ebp + 0xfe<254,-2>], al
   0f be c0 ?? movsx eax, al
   48 ?? dec eax
   6a 04 ?? push 4
   59 ?? pop ecx
   74 1c ?? je basic block L24
  
  L20: 48 ?? dec eax
   75 0e ?? jne basic block L23
  
  L21: 8b c2 ?? mov eax, edx
   f7 d0 ?? not eax
   a8 01 ?? test al, 1
   74 19 ?? je basic block L25
  
  L22: 83 e2 fe ?? and edx, 0xfe<254,-2>
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
  
  L23: 8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   89 45 f4 ?? mov dword ss:[ebp + 0xf4<244,-12>], eax
   e9 81 00 00 00 ?? jmp basic block L40
  
  L24: 8b c2 ?? mov eax, edx
   f7 d0 ?? not eax
   a8 01 ?? test al, 1
   75 21 ?? jne basic block L30
  
  L25: e8 5f f5 fe ff ?? call function 0x0040c535
  
  L26: 89 18 ?? mov dword ds:[eax], ebx
   e8 45 f5 fe ff ?? call function 0x0040c522
  
  L27: c7 00 16 00 00 00 ?? mov dword ds:[eax], 0x00000016<22>
  
  L28: 53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   e8 d3 99 fe ff ?? call function 0x004069c0
  
  L29: 83 c4 14 ?? add esp, 0x14<20>
   eb 34 ?? jmp basic block L37
  
  L30: 8b c2 ?? mov eax, edx
   d1 e8 ?? shr eax, 1
   89 4d 10 ?? mov dword ss:[ebp + 0x10<16>], ecx
   3b c1 ?? cmp eax, ecx
   72 03 ?? jb basic block L32
  
  L31: 89 45 10 ?? mov dword ss:[ebp + 0x10<16>], eax
  
  L32: ff 75 10 ?? push dword ss:[ebp + 0x10<16>]
   e8 d8 d0 fe ff ?? call function 0x0040a0e0
  
  L33: 59 ?? pop ecx
   89 45 f4 ?? mov dword ss:[ebp + 0xf4<244,-12>], eax
   3b c3 ?? cmp eax, ebx
   75 1e ?? jne basic block L38
  
  L34: e8 0d f5 fe ff ?? call function 0x0040c522
  
  L35: c7 00 0c 00 00 00 ?? mov dword ds:[eax], 12
   e8 15 f5 fe ff ?? call function 0x0040c535
  
  L36: c7 00 08 00 00 00 ?? mov dword ds:[eax], 8
  
  L37: 83 c8 ff ?? or eax, 0xff<255,-1>
   e9 68 04 00 00 ?? jmp basic block L164
  
  L38: 6a 01 ?? push 1
   53 ?? push ebx
   53 ?? push ebx
   ff 75 08 ?? push dword ss:[ebp + 8]
   e8 5e 05 00 00 ?? call function 0x0041d598
  
  L39: 8b 0f ?? mov ecx, dword ds:[edi]
   89 44 0e 28 ?? mov dword ds:[esi + ecx + 0x28<40>], eax
   8b 45 f4 ?? mov eax, dword ss:[ebp + 0xf4<244,-12>]
   83 c4 10 ?? add esp, 0x10<16>
   89 54 0e 2c ?? mov dword ds:[esi + ecx + 0x2c<44>], edx
  
  L40: 8b 0f ?? mov ecx, dword ds:[edi]
   03 ce ?? add ecx, esi
   f6 41 04 48 ?? test byte ds:[ecx + 4], 0x48<72>
   74 74 ?? je basic block L50
  
  L41: 8a 49 05 ?? mov cl, byte ds:[ecx + 5]
   80 f9 0a ?? cmp cl, 10
   74 6c ?? je basic block L50
  
  L42: 39 5d 10 ?? cmp dword ss:[ebp + 0x10<16>], ebx
   74 67 ?? je basic block L50
  
  L43: 88 08 ?? mov byte ds:[eax], cl
   8b 0f ?? mov ecx, dword ds:[edi]
   40 ?? inc eax
   ff 4d 10 ?? dec dword ss:[ebp + 0x10<16>]
   c7 45 f0 01 00 00 00 ?? mov dword ss:[ebp + 0xf0<240,-16>], 1
   c6 44 0e 05 0a ?? mov byte ds:[esi + ecx + 5], 10
   38 5d fe ?? cmp byte ss:[ebp + 0xfe<254,-2>], bl
   74 4e ?? je basic block L50
  
  L44: 8b 0f ?? mov ecx, dword ds:[edi]
   8a 4c 0e 25 ?? mov cl, byte ds:[esi + ecx + 0x25<37>]
   80 f9 0a ?? cmp cl, 10
   74 43 ?? je basic block L50
  
  L45: 39 5d 10 ?? cmp dword ss:[ebp + 0x10<16>], ebx
   74 3e ?? je basic block L50
  
  L46: 88 08 ?? mov byte ds:[eax], cl
   8b 0f ?? mov ecx, dword ds:[edi]
   40 ?? inc eax
   ff 4d 10 ?? dec dword ss:[ebp + 0x10<16>]
   80 7d fe 01 ?? cmp byte ss:[ebp + 0xfe<254,-2>], 1
   c7 45 f0 02 00 00 00 ?? mov dword ss:[ebp + 0xf0<240,-16>], 2
   c6 44 0e 25 0a ?? mov byte ds:[esi + ecx + 0x25<37>], 10
   75 24 ?? jne basic block L50
  
  L47: 8b 0f ?? mov ecx, dword ds:[edi]
   8a 4c 0e 26 ?? mov cl, byte ds:[esi + ecx + 0x26<38>]
   80 f9 0a ?? cmp cl, 10
   74 19 ?? je basic block L50
  
  L48: 39 5d 10 ?? cmp dword ss:[ebp + 0x10<16>], ebx
   74 14 ?? je basic block L50
  
  L49: 88 08 ?? mov byte ds:[eax], cl
   8b 0f ?? mov ecx, dword ds:[edi]
   40 ?? inc eax
   ff 4d 10 ?? dec dword ss:[ebp + 0x10<16>]
   c7 45 f0 03 00 00 00 ?? mov dword ss:[ebp + 0xf0<240,-16>], 3
   c6 44 0e 26 0a ?? mov byte ds:[esi + ecx + 0x26<38>], 10
  
  L50: 53 ?? push ebx
   8d 4d e8 ?? lea ecx, ss:[ebp + 0xe8<232,-24>]
   51 ?? push ecx
   ff 75 10 ?? push dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8b 07 ?? mov eax, dword ds:[edi]
   ff 34 06 ?? push dword ds:[esi + eax]
   ff 15 d4 82 43 00 ?? call dword ds:[0x004382d4]
  
  L51: 85 c0 ?? test eax, eax
   0f 84 7b 03 00 00 ?? je basic block L156
  
  L52: 8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   3b cb ?? cmp ecx, ebx
   0f 8c 70 03 00 00 ?? jl basic block L156
  
  L53: 3b 4d 10 ?? cmp ecx, dword ss:[ebp + 0x10<16>]
   0f 87 67 03 00 00 ?? ja basic block L156
  
  L54: 8b 07 ?? mov eax, dword ds:[edi]
   01 4d f0 ?? add dword ss:[ebp + 0xf0<240,-16>], ecx
   8d 44 06 04 ?? lea eax, ds:[esi + eax + 4]
   f6 00 80 ?? test byte ds:[eax], 0x80<128,-128>
   0f 84 e6 01 00 00 ?? je basic block L116
  
  L55: 80 7d fe 02 ?? cmp byte ss:[ebp + 0xfe<254,-2>], 2
   0f 84 16 02 00 00 ?? je basic block L122
  
  L56: 3b cb ?? cmp ecx, ebx
   74 0d ?? je basic block L59
  
  L57: 8b 4d f4 ?? mov ecx, dword ss:[ebp + 0xf4<244,-12>]
   80 39 0a ?? cmp byte ds:[ecx], 10
   75 05 ?? jne basic block L59
  
  L58: 80 08 04 ?? or byte ds:[eax], 4
   eb 03 ?? jmp basic block L60
  
  L59: 80 20 fb ?? and byte ds:[eax], 0xfb<251,-5>
  
  L60: 8b 5d f4 ?? mov ebx, dword ss:[ebp + 0xf4<244,-12>]
   8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   03 c3 ?? add eax, ebx
   89 5d 10 ?? mov dword ss:[ebp + 0x10<16>], ebx
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   3b d8 ?? cmp ebx, eax
   0f 83 d0 00 00 00 ?? jae basic block L88
  
  L61: 8b 4d 10 ?? mov ecx, dword ss:[ebp + 0x10<16>]
   8a 01 ?? mov al, byte ds:[ecx]
   3c 1a ?? cmp al, 0x1a<26>
   0f 84 ae 00 00 00 ?? je basic block L85
  
  L62: 3c 0d ?? cmp al, 13
   74 0c ?? je basic block L64
  
  L63: 88 03 ?? mov byte ds:[ebx], al
   43 ?? inc ebx
   41 ?? inc ecx
   89 4d 10 ?? mov dword ss:[ebp + 0x10<16>], ecx
   e9 90 00 00 00 ?? jmp basic block L83
  
  L64: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   48 ?? dec eax
   3b c8 ?? cmp ecx, eax
   73 17 ?? jae basic block L69
  
  L65: 8d 41 01 ?? lea eax, ds:[ecx + 1]
   80 38 0a ?? cmp byte ds:[eax], 10
   75 0a ?? jne basic block L68
  
  L66: 41 ?? inc ecx
   41 ?? inc ecx
   89 4d 10 ?? mov dword ss:[ebp + 0x10<16>], ecx
  
  L67: c6 03 0a ?? mov byte ds:[ebx], 10
   eb 75 ?? jmp basic block L82
  
  L68: 89 45 10 ?? mov dword ss:[ebp + 0x10<16>], eax
   eb 6d ?? jmp basic block L81
  
  L69: ff 45 10 ?? inc dword ss:[ebp + 0x10<16>]
   6a 00 ?? push 0
   8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
   50 ?? push eax
   6a 01 ?? push 1
   8d 45 ff ?? lea eax, ss:[ebp + 0xff<255,-1>]
   50 ?? push eax
   8b 07 ?? mov eax, dword ds:[edi]
   ff 34 06 ?? push dword ds:[esi + eax]
   ff 15 d4 82 43 00 ?? call dword ds:[0x004382d4]
  
  L70: 85 c0 ?? test eax, eax
   75 0a ?? jne basic block L73
  
  L71: ff 15 30 82 43 00 ?? call dword ds:[0x00438230]
  
  L72: 85 c0 ?? test eax, eax
   75 45 ?? jne basic block L81
  
  L73: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   74 3f ?? je basic block L81
  
  L74: 8b 07 ?? mov eax, dword ds:[edi]
   f6 44 06 04 48 ?? test byte ds:[esi + eax + 4], 0x48<72>
   74 14 ?? je basic block L77
  
  L75: 80 7d ff 0a ?? cmp byte ss:[ebp + 0xff<255,-1>], 10
   74 b9 ?? je basic block L67
  
  L76: c6 03 0d ?? mov byte ds:[ebx], 13
   8b 07 ?? mov eax, dword ds:[edi]
   8a 4d ff ?? mov cl, byte ss:[ebp + 0xff<255,-1>]
   88 4c 06 05 ?? mov byte ds:[esi + eax + 5], cl
   eb 25 ?? jmp basic block L82
  
  L77: 3b 5d f4 ?? cmp ebx, dword ss:[ebp + 0xf4<244,-12>]
   75 06 ?? jne basic block L79
  
  L78: 80 7d ff 0a ?? cmp byte ss:[ebp + 0xff<255,-1>], 10
   74 a0 ?? je basic block L67
  
  L79: 6a 01 ?? push 1
   6a ff ?? push 0xff<255,-1>
   6a ff ?? push 0xff<255,-1>
   ff 75 08 ?? push dword ss:[ebp + 8]
   e8 ba 03 00 00 ?? call function 0x0041d598
  
  L80: 83 c4 10 ?? add esp, 0x10<16>
   80 7d ff 0a ?? cmp byte ss:[ebp + 0xff<255,-1>], 10
   74 04 ?? je basic block L83
  
  L81: c6 03 0d ?? mov byte ds:[ebx], 13
  
  L82: 43 ?? inc ebx
  
  L83: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   39 45 10 ?? cmp dword ss:[ebp + 0x10<16>], eax
   0f 82 47 ff ff ff ?? jb basic block L61
  
  L84: eb 15 ?? jmp basic block L88
  
  L85: 8b 07 ?? mov eax, dword ds:[edi]
   8d 44 06 04 ?? lea eax, ds:[esi + eax + 4]
   f6 00 40 ?? test byte ds:[eax], 0x40<64>
   75 05 ?? jne basic block L87
  
  L86: 80 08 02 ?? or byte ds:[eax], 2
   eb 05 ?? jmp basic block L88
  
  L87: 8a 01 ?? mov al, byte ds:[ecx]
   88 03 ?? mov byte ds:[ebx], al
   43 ?? inc ebx
  
  L88: 8b c3 ?? mov eax, ebx
   2b 45 f4 ?? sub eax, dword ss:[ebp + 0xf4<244,-12>]
   80 7d fe 01 ?? cmp byte ss:[ebp + 0xfe<254,-2>], 1
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   0f 85 d0 00 00 00 ?? jne basic block L116
  
  L89: 85 c0 ?? test eax, eax
   0f 84 c8 00 00 00 ?? je basic block L116
  
  L90: 4b ?? dec ebx
   8a 0b ?? mov cl, byte ds:[ebx]
   84 c9 ?? test cl, cl
   78 06 ?? js basic block L92
  
  L91: 43 ?? inc ebx
   e9 86 00 00 00 ?? jmp basic block L110
  
  L92: 33 c0 ?? xor eax, eax
   40 ?? inc eax
   0f b6 c9 ?? movzx ecx, cl
   eb 0f ?? jmp basic block L96
  
  L93: 83 f8 04 ?? cmp eax, 4
   7f 13 ?? jg basic block L97
  
  L94: 3b 5d f4 ?? cmp ebx, dword ss:[ebp + 0xf4<244,-12>]
   72 0e ?? jb basic block L97
  
  L95: 4b ?? dec ebx
   0f b6 0b ?? movzx ecx, byte ds:[ebx]
   40 ?? inc eax
  
  L96: 80 b9 38 52 43 00 00 ?? cmp byte ds:[ecx + 0x00435238], 0
   74 e8 ?? je basic block L93
  
  L97: 8a 13 ?? mov dl, byte ds:[ebx]
   0f b6 ca ?? movzx ecx, dl
   0f be 89 38 52 43 00 ?? movsx ecx, byte ds:[ecx + 0x00435238]
   85 c9 ?? test ecx, ecx
   75 0d ?? jne basic block L100
  
  L98: e8 b8 f2 fe ff ?? call function 0x0040c522
  
  L99: c7 00 2a 00 00 00 ?? mov dword ds:[eax], 0x0000002a<42>
   eb 7a ?? jmp basic block L115
  
  L100: 41 ?? inc ecx
   3b c8 ?? cmp ecx, eax
   75 04 ?? jne basic block L102
  
  L101: 03 d8 ?? add ebx, eax
   eb 40 ?? jmp basic block L110
  
  L102: 8b 0f ?? mov ecx, dword ds:[edi]
   03 ce ?? add ecx, esi
   f6 41 04 48 ?? test byte ds:[ecx + 4], 0x48<72>
   74 24 ?? je basic block L108
  
  L103: 43 ?? inc ebx
   83 f8 02 ?? cmp eax, 2
   88 51 05 ?? mov byte ds:[ecx + 5], dl
   7c 09 ?? jl basic block L105
  
  L104: 8a 13 ?? mov dl, byte ds:[ebx]
   8b 0f ?? mov ecx, dword ds:[edi]
   88 54 0e 25 ?? mov byte ds:[esi + ecx + 0x25<37>], dl
   43 ?? inc ebx
  
  L105: 83 f8 03 ?? cmp eax, 3
   75 09 ?? jne basic block L107
  
  L106: 8a 13 ?? mov dl, byte ds:[ebx]
   8b 0f ?? mov ecx, dword ds:[edi]
   88 54 0e 26 ?? mov byte ds:[esi + ecx + 0x26<38>], dl
   43 ?? inc ebx
  
  L107: 2b d8 ?? sub ebx, eax
   eb 12 ?? jmp basic block L110
  
  L108: f7 d8 ?? neg eax
   99 ?? cdq
   6a 01 ?? push 1
   52 ?? push edx
   50 ?? push eax
   ff 75 08 ?? push dword ss:[ebp + 8]
   e8 e0 02 00 00 ?? call function 0x0041d598
  
  L109: 83 c4 10 ?? add esp, 0x10<16>
  
  L110: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
   2b 5d f4 ?? sub ebx, dword ss:[ebp + 0xf4<244,-12>]
   d1 e8 ?? shr eax, 1
   50 ?? push eax
   ff 75 0c ?? push dword ss:[ebp + 12]
   53 ?? push ebx
   ff 75 f4 ?? push dword ss:[ebp + 0xf4<244,-12>]
   6a 00 ?? push 0
   68 e9 fd 00 00 ?? push 0x0000fde9<65001>
   ff 15 40 82 43 00 ?? call dword ds:[0x00438240]
  
  L111: 89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   85 c0 ?? test eax, eax
   75 34 ?? jne basic block L121
  
  L112: ff 15 30 82 43 00 ?? call dword ds:[0x00438230]
  
  L113: 50 ?? push eax
   e8 5d f2 fe ff ?? call function 0x0040c548
  
  L114: 59 ?? pop ecx
  
  L115: 83 4d ec ff ?? or dword ss:[ebp + 0xec<236,-20>], 0xff<255,-1>
  
  L116: 8b 45 f4 ?? mov eax, dword ss:[ebp + 0xf4<244,-12>]
   3b 45 0c ?? cmp eax, dword ss:[ebp + 12]
   74 07 ?? je basic block L119
  
  L117: 50 ?? push eax
   e8 0e 97 fe ff ?? call function 0x00406a0c
  
  L118: 59 ?? pop ecx
  
  L119: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 f8 fe ?? cmp eax, 0xfe<254,-2>
   0f 85 8b 01 00 00 ?? jne basic block L164
  
  L120: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   e9 83 01 00 00 ?? jmp basic block L164
  
  L121: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   8b 17 ?? mov edx, dword ds:[edi]
   33 c9 ?? xor ecx, ecx
   3b c3 ?? cmp eax, ebx
   0f 95 c1 ?? setne cl
   03 c0 ?? add eax, eax
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   89 4c 16 30 ?? mov dword ds:[esi + edx + 0x30<48>], ecx
   eb c6 ?? jmp basic block L116
  
  L122: 3b cb ?? cmp ecx, ebx
   74 0e ?? je basic block L125
  
  L123: 8b 4d f4 ?? mov ecx, dword ss:[ebp + 0xf4<244,-12>]
   66 83 39 0a ?? cmp word ds:[ecx], 10
   75 05 ?? jne basic block L125
  
  L124: 80 08 04 ?? or byte ds:[eax], 4
   eb 03 ?? jmp basic block L126
  
  L125: 80 20 fb ?? and byte ds:[eax], 0xfb<251,-5>
  
  L126: 8b 5d f4 ?? mov ebx, dword ss:[ebp + 0xf4<244,-12>]
   8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   03 c3 ?? add eax, ebx
   89 5d 10 ?? mov dword ss:[ebp + 0x10<16>], ebx
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   3b d8 ?? cmp ebx, eax
   0f 83 ff 00 00 00 ?? jae basic block L155
  
  L127: 8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   0f b7 08 ?? movzx ecx, word ds:[eax]
   66 83 f9 1a ?? cmp cx, 0x1a<26>
   0f 84 d7 00 00 00 ?? je basic block L152
  
  L128: 66 83 f9 0d ?? cmp cx, 13
   74 0f ?? je basic block L130
  
  L129: 66 89 0b ?? mov word ds:[ebx], cx
   43 ?? inc ebx
   43 ?? inc ebx
   40 ?? inc eax
   40 ?? inc eax
   89 45 10 ?? mov dword ss:[ebp + 0x10<16>], eax
   e9 b4 00 00 00 ?? jmp basic block L150
  
  L130: 8b 4d f0 ?? mov ecx, dword ss:[ebp + 0xf0<240,-16>]
   83 c1 fe ?? add ecx, 0xfe<254,-2>
   3b c1 ?? cmp eax, ecx
   73 1e ?? jae basic block L135
  
  L131: 8d 48 02 ?? lea ecx, ds:[eax + 2]
   66 83 39 0a ?? cmp word ds:[ecx], 10
   75 0d ?? jne basic block L134
  
  L132: 83 c0 04 ?? add eax, 4
   89 45 10 ?? mov dword ss:[ebp + 0x10<16>], eax
  
  L133: 6a 0a ?? push 10
   e9 8e 00 00 00 ?? jmp basic block L148
  
  L134: 89 4d 10 ?? mov dword ss:[ebp + 0x10<16>], ecx
   e9 84 00 00 00 ?? jmp basic block L147
  
  L135: 83 45 10 02 ?? add dword ss:[ebp + 0x10<16>], 2
   6a 00 ?? push 0
   8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
   50 ?? push eax
   6a 02 ?? push 2
   8d 45 f8 ?? lea eax, ss:[ebp + 0xf8<248,-8>]
   50 ?? push eax
   8b 07 ?? mov eax, dword ds:[edi]
   ff 34 06 ?? push dword ds:[esi + eax]
   ff 15 d4 82 43 00 ?? call dword ds:[0x004382d4]
  
  L136: 85 c0 ?? test eax, eax
   75 0a ?? jne basic block L139
  
  L137: ff 15 30 82 43 00 ?? call dword ds:[0x00438230]
  
  L138: 85 c0 ?? test eax, eax
   75 5b ?? jne basic block L147
  
  L139: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   74 55 ?? je basic block L147
  
  L140: 8b 07 ?? mov eax, dword ds:[edi]
   f6 44 06 04 48 ?? test byte ds:[esi + eax + 4], 0x48<72>
   74 28 ?? je basic block L143
  
  L141: 66 83 7d f8 0a ?? cmp word ss:[ebp + 0xf8<248,-8>], 10
   74 b2 ?? je basic block L133
  
  L142: 6a 0d ?? push 13
   58 ?? pop eax
   66 89 03 ?? mov word ds:[ebx], ax
   8b 07 ?? mov eax, dword ds:[edi]
   8a 4d f8 ?? mov cl, byte ss:[ebp + 0xf8<248,-8>]
   88 4c 06 05 ?? mov byte ds:[esi + eax + 5], cl
   8b 07 ?? mov eax, dword ds:[edi]
   8a 4d f9 ?? mov cl, byte ss:[ebp + 0xf9<249,-7>]
   88 4c 06 25 ?? mov byte ds:[esi + eax + 0x25<37>], cl
   8b 07 ?? mov eax, dword ds:[edi]
   c6 44 06 26 0a ?? mov byte ds:[esi + eax + 0x26<38>], 10
   eb 2a ?? jmp basic block L149
  
  L143: 3b 5d f4 ?? cmp ebx, dword ss:[ebp + 0xf4<244,-12>]
   75 07 ?? jne basic block L145
  
  L144: 66 83 7d f8 0a ?? cmp word ss:[ebp + 0xf8<248,-8>], 10
   74 85 ?? je basic block L133
  
  L145: 6a 01 ?? push 1
   6a ff ?? push 0xff<255,-1>
   6a fe ?? push 0xfe<254,-2>
   ff 75 08 ?? push dword ss:[ebp + 8]
   e8 7c 01 00 00 ?? call function 0x0041d598
  
  L146: 83 c4 10 ?? add esp, 0x10<16>
   66 83 7d f8 0a ?? cmp word ss:[ebp + 0xf8<248,-8>], 10
   74 08 ?? je basic block L150
  
  L147: 6a 0d ?? push 13
  
  L148: 58 ?? pop eax
   66 89 03 ?? mov word ds:[ebx], ax
  
  L149: 43 ?? inc ebx
   43 ?? inc ebx
  
  L150: 8b 45 f0 ?? mov eax, dword ss:[ebp + 0xf0<240,-16>]
   39 45 10 ?? cmp dword ss:[ebp + 0x10<16>], eax
   0f 82 1b ff ff ff ?? jb basic block L127
  
  L151: eb 18 ?? jmp basic block L155
  
  L152: 8b 0f ?? mov ecx, dword ds:[edi]
   8d 74 0e 04 ?? lea esi, ds:[esi + ecx + 4]
   f6 06 40 ?? test byte ds:[esi], 0x40<64>
   75 05 ?? jne basic block L154
  
  L153: 80 0e 02 ?? or byte ds:[esi], 2
   eb 08 ?? jmp basic block L155
  
  L154: 66 8b 00 ?? mov ax, word ds:[eax]
   66 89 03 ?? mov word ds:[ebx], ax
   43 ?? inc ebx
   43 ?? inc ebx
  
  L155: 2b 5d f4 ?? sub ebx, dword ss:[ebp + 0xf4<244,-12>]
   89 5d f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], ebx
   e9 91 fe ff ff ?? jmp basic block L116
  
  L156: ff 15 30 82 43 00 ?? call dword ds:[0x00438230]
  
  L157: 6a 05 ?? push 5
   5e ?? pop esi
   3b c6 ?? cmp eax, esi
   75 17 ?? jne basic block L161
  
  L158: e8 b1 f0 fe ff ?? call function 0x0040c522
  
  L159: c7 00 09 00 00 00 ?? mov dword ds:[eax], 9
   e8 b9 f0 fe ff ?? call function 0x0040c535
  
  L160: 89 30 ?? mov dword ds:[eax], esi
   e9 69 fe ff ff ?? jmp basic block L115
  
  L161: 83 f8 6d ?? cmp eax, 0x6d<109>
   0f 85 59 fe ff ff ?? jne basic block L113
  
  L162: 89 5d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ebx
   e9 5c fe ff ff ?? jmp basic block L116
  
  L163: 33 c0 ?? xor eax, eax
  
  L164: 5f ?? pop edi
  
  L165: 5b ?? pop ebx
  
  L166: 5e ?? pop esi
   c9 ?? leave
   c3 ?? ret
  
  