Disassembly: 
  L1: 8b ff ?? mov edi, edi
   55 ?? push ebp
   8b ec ?? mov ebp, esp
   81 ec 78 02 00 00 ?? sub esp, 0x00000278<632>
   a1 44 44 44 00 ?? mov eax, dword ds:[0x00444444]
   33 c5 ?? xor eax, ebp
   89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
   53 ?? push ebx
   8b 5d 0c ?? mov ebx, dword ss:[ebp + 12]
   56 ?? push esi
   8b 75 08 ?? mov esi, dword ss:[ebp + 8]
   33 c0 ?? xor eax, eax
   57 ?? push edi
   8b 7d 14 ?? mov edi, dword ss:[ebp + 0x14<20>]
   ff 75 10 ?? push dword ss:[ebp + 0x10<16>]
   8d 8d a4 fd ff ff ?? lea ecx, ss:[ebp + 0xfffffda4<4294966692,-604>]
   89 b5 b4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdb4<4294966708,-588>], esi
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   89 85 b8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdb8<4294966712,-584>], eax
   89 85 f0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdf0<4294966768,-528>], eax
   89 85 cc fd ff ff ?? mov dword ss:[ebp + 0xfffffdcc<4294966732,-564>], eax
   89 85 e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
   89 85 d0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdd0<4294966736,-560>], eax
   89 85 c0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc0<4294966720,-576>], eax
   89 85 c8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], eax
   e8 06 dc ff ff ?? call function 0x0040e60f
  
  L2: 85 f6 ?? test esi, esi
   75 35 ?? jne basic block L8
  
  L3: e8 85 d6 ff ff ?? call function 0x0040e097
  
  L4: c7 00 16 00 00 00 ?? mov dword ds:[eax], 0x00000016<22>
   33 c0 ?? xor eax, eax
   50 ?? push eax
   50 ?? push eax
   50 ?? push eax
   50 ?? push eax
   50 ?? push eax
   e8 b3 97 ff ff ?? call function 0x0040a1d7
  
  L5: 83 c4 14 ?? add esp, 0x14<20>
   80 bd b0 fd ff ff 00 ?? cmp byte ss:[ebp + 0xfffffdb0<4294966704,-592>], 0
   74 0a ?? je basic block L7
  
  L6: 8b 85 ac fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdac<4294966700,-596>]
   83 60 70 fd ?? and dword ds:[eax + 0x70<112>], 0xfd<253,-3>
  
  L7: 83 c8 ff ?? or eax, 0xff<255,-1>
   e9 c8 0a 00 00 ?? jmp basic block L255
  
  L8: f6 46 0c 40 ?? test byte ds:[esi + 12], 0x40<64>
   75 5e ?? jne basic block L20
  
  L9: 56 ?? push esi
   e8 25 46 00 00 ?? call function 0x00415073
  
  L10: 59 ?? pop ecx
   ba 50 4b 44 00 ?? mov edx, 0x00444b50
   83 f8 ff ?? cmp eax, 0xff<255,-1>
   74 1b ?? je basic block L13
  
  L11: 83 f8 fe ?? cmp eax, 0xfe<254,-2>
   74 16 ?? je basic block L13
  
  L12: 8b c8 ?? mov ecx, eax
   83 e1 1f ?? and ecx, 0x1f<31>
   8b f0 ?? mov esi, eax
   c1 fe 05 ?? sar esi, 5
   c1 e1 06 ?? shl ecx, 6
   03 0c b5 c0 6b 44 00 ?? add ecx, dword ds:[0x00446bc0 + esi * 4]
   eb 02 ?? jmp basic block L14
  
  L13: 8b ca ?? mov ecx, edx
  
  L14: f6 41 24 7f ?? test byte ds:[ecx + 0x24<36>], 0x7f<127>
   75 91 ?? jne basic block L3
  
  L15: 83 f8 ff ?? cmp eax, 0xff<255,-1>
   74 19 ?? je basic block L18
  
  L16: 83 f8 fe ?? cmp eax, 0xfe<254,-2>
   74 14 ?? je basic block L18
  
  L17: 8b c8 ?? mov ecx, eax
   83 e0 1f ?? and eax, 0x1f<31>
   c1 f9 05 ?? sar ecx, 5
   c1 e0 06 ?? shl eax, 6
   03 04 8d c0 6b 44 00 ?? add eax, dword ds:[0x00446bc0 + ecx * 4]
   eb 02 ?? jmp basic block L19
  
  L18: 8b c2 ?? mov eax, edx
  
  L19: f6 40 24 80 ?? test byte ds:[eax + 0x24<36>], 0x80<128,-128>
   0f 85 67 ff ff ff ?? jne basic block L3
  
  L20: 33 c9 ?? xor ecx, ecx
   3b d9 ?? cmp ebx, ecx
   0f 84 5d ff ff ff ?? je basic block L3
  
  L21: 8a 13 ?? mov dl, byte ds:[ebx]
   89 8d d8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdd8<4294966744,-552>], ecx
   89 8d e0 fd ff ff ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], ecx
   89 8d bc fd ff ff ?? mov dword ss:[ebp + 0xfffffdbc<4294966716,-580>], ecx
   88 95 ef fd ff ff ?? mov byte ss:[ebp + 0xfffffdef<4294966767,-529>], dl
   84 d2 ?? test dl, dl
   0f 84 1f 0a 00 00 ?? je basic block L252
  
  L22: 43 ?? inc ebx
   83 bd d8 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffdd8<4294966744,-552>], 0
   89 9d c4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc4<4294966724,-572>], ebx
   0f 8c 0b 0a 00 00 ?? jl basic block L252
  
  L23: 8a c2 ?? mov al, dl
   2c 20 ?? sub al, 0x20<32>
   3c 58 ?? cmp al, 0x58<88>
   77 11 ?? ja basic block L25
  
  L24: 0f be c2 ?? movsx eax, dl
   0f be 80 c0 dd 43 00 ?? movsx eax, byte ds:[eax + 0x0043ddc0]
   83 e0 0f ?? and eax, 15
   33 f6 ?? xor esi, esi
   eb 04 ?? jmp basic block L26
  
  L25: 33 f6 ?? xor esi, esi
   33 c0 ?? xor eax, eax
  
  L26: 0f be 84 c1 e0 dd 43 00 ?? movsx eax, byte ds:[ecx + eax * 8 + 0x0043dde0]
   6a 07 ?? push 7
   c1 f8 04 ?? sar eax, 4
   59 ?? pop ecx
   89 85 94 fd ff ff ?? mov dword ss:[ebp + 0xfffffd94<4294966676,-620>], eax
   3b c1 ?? cmp eax, ecx
   0f 87 ad 09 00 00 ?? ja basic block L250
  
  L27: ff 24 85 1a 15 41 00 ?? jmp dword ds:[0x0041151a<"%\rA"> + eax * 4]
  
  L28: 83 8d e8 fd ff ff ff ?? or dword ss:[ebp + 0xfffffde8<4294966760,-536>], 0xff<255,-1>
   89 b5 90 fd ff ff ?? mov dword ss:[ebp + 0xfffffd90<4294966672,-624>], esi
   89 b5 c0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc0<4294966720,-576>], esi
   89 b5 cc fd ff ff ?? mov dword ss:[ebp + 0xfffffdcc<4294966732,-564>], esi
   89 b5 d0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdd0<4294966736,-560>], esi
   89 b5 f0 fd ff ff ?? mov dword ss:[ebp + 0xfffffdf0<4294966768,-528>], esi
   89 b5 c8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], esi
   e9 76 09 00 00 ?? jmp basic block L250
  
  L29: 0f be c2 ?? movsx eax, dl
   83 e8 20 ?? sub eax, 0x20<32>
   74 4a ?? je basic block L38
  
  L30: 83 e8 03 ?? sub eax, 3
   74 36 ?? je basic block L37
  
  L31: 83 e8 08 ?? sub eax, 8
   74 25 ?? je basic block L36
  
  L32: 48 ?? dec eax
   48 ?? dec eax
   74 15 ?? je basic block L35
  
  L33: 83 e8 03 ?? sub eax, 3
   0f 85 57 09 00 00 ?? jne basic block L250
  
  L34: 83 8d f0 fd ff ff 08 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 8
   e9 4b 09 00 00 ?? jmp basic block L250
  
  L35: 83 8d f0 fd ff ff 04 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 4
   e9 3f 09 00 00 ?? jmp basic block L250
  
  L36: 83 8d f0 fd ff ff 01 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 1
   e9 33 09 00 00 ?? jmp basic block L250
  
  L37: 81 8d f0 fd ff ff 80 00 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000080<128>
   00 00
   e9 24 09 00 00 ?? jmp basic block L250
  
  L38: 83 8d f0 fd ff ff 02 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 2
   e9 18 09 00 00 ?? jmp basic block L250
  
  L39: 80 fa 2a ?? cmp dl, 0x2a<42>
   75 2c ?? jne basic block L42
  
  L40: 83 c7 04 ?? add edi, 4
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   8b 7f fc ?? mov edi, dword ds:[edi + 0xfc<252,-4>]
   3b fe ?? cmp edi, esi
   89 bd cc fd ff ff ?? mov dword ss:[ebp + 0xfffffdcc<4294966732,-564>], edi
   0f 8d f9 08 00 00 ?? jge basic block L250
  
  L41: 83 8d f0 fd ff ff 04 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 4
   f7 9d cc fd ff ff ?? neg dword ss:[ebp + 0xfffffdcc<4294966732,-564>]
   e9 e7 08 00 00 ?? jmp basic block L250
  
  L42: 8b 85 cc fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdcc<4294966732,-564>]
   6b c0 0a ?? imul eax, eax, 10
   0f be ca ?? movsx ecx, dl
   8d 44 08 d0 ?? lea eax, ds:[eax + ecx + 0xd0<208,-48>]
   89 85 cc fd ff ff ?? mov dword ss:[ebp + 0xfffffdcc<4294966732,-564>], eax
   e9 cc 08 00 00 ?? jmp basic block L250
  
  L43: 89 b5 e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], esi
   e9 c1 08 00 00 ?? jmp basic block L250
  
  L44: 80 fa 2a ?? cmp dl, 0x2a<42>
   75 26 ?? jne basic block L47
  
  L45: 83 c7 04 ?? add edi, 4
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   8b 7f fc ?? mov edi, dword ds:[edi + 0xfc<252,-4>]
   3b fe ?? cmp edi, esi
   89 bd e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], edi
   0f 8d a2 08 00 00 ?? jge basic block L250
  
  L46: 83 8d e8 fd ff ff ff ?? or dword ss:[ebp + 0xfffffde8<4294966760,-536>], 0xff<255,-1>
   e9 96 08 00 00 ?? jmp basic block L250
  
  L47: 8b 85 e8 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   6b c0 0a ?? imul eax, eax, 10
   0f be ca ?? movsx ecx, dl
   8d 44 08 d0 ?? lea eax, ds:[eax + ecx + 0xd0<208,-48>]
   89 85 e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
   e9 7b 08 00 00 ?? jmp basic block L250
  
  L48: 80 fa 49 ?? cmp dl, 0x49<73>
   74 55 ?? je basic block L57
  
  L49: 80 fa 68 ?? cmp dl, 0x68<104>
   74 44 ?? je basic block L56
  
  L50: 80 fa 6c ?? cmp dl, 0x6c<108>
   74 18 ?? je basic block L53
  
  L51: 80 fa 77 ?? cmp dl, 0x77<119>
   0f 85 63 08 00 00 ?? jne basic block L250
  
  L52: 81 8d f0 fd ff ff 00 08 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000800<2048>
   00 00
   e9 54 08 00 00 ?? jmp basic block L250
  
  L53: 80 3b 6c ?? cmp byte ds:[ebx], 0x6c<108>
   75 16 ?? jne basic block L55
  
  L54: 43 ?? inc ebx
   81 8d f0 fd ff ff 00 10 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00001000<4096>
   00 00
   89 9d c4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc4<4294966724,-572>], ebx
   e9 39 08 00 00 ?? jmp basic block L250
  
  L55: 83 8d f0 fd ff ff 10 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x10<16>
   e9 2d 08 00 00 ?? jmp basic block L250
  
  L56: 83 8d f0 fd ff ff 20 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x20<32>
   e9 21 08 00 00 ?? jmp basic block L250
  
  L57: 8a 03 ?? mov al, byte ds:[ebx]
   3c 36 ?? cmp al, 0x36<54>
   75 1d ?? jne basic block L60
  
  L58: 80 7b 01 34 ?? cmp byte ds:[ebx + 1], 0x34<52>
   75 17 ?? jne basic block L60
  
  L59: 43 ?? inc ebx
   43 ?? inc ebx
   81 8d f0 fd ff ff 00 80 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00008000<32768>
   00 00
   89 9d c4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc4<4294966724,-572>], ebx
   e9 fe 07 00 00 ?? jmp basic block L250
  
  L60: 3c 33 ?? cmp al, 0x33<51>
   75 1d ?? jne basic block L63
  
  L61: 80 7b 01 32 ?? cmp byte ds:[ebx + 1], 0x32<50>
   75 17 ?? jne basic block L63
  
  L62: 43 ?? inc ebx
   43 ?? inc ebx
   81 a5 f0 fd ff ff ff 7f ?? and dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0xffff7fff<4294934527,-32769>
   ff ff
   89 9d c4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc4<4294966724,-572>], ebx
   e9 dd 07 00 00 ?? jmp basic block L250
  
  L63: 3c 64 ?? cmp al, 0x64<100>
   0f 84 d5 07 00 00 ?? je basic block L250
  
  L64: 3c 69 ?? cmp al, 0x69<105>
   0f 84 cd 07 00 00 ?? je basic block L250
  
  L65: 3c 6f ?? cmp al, 0x6f<111>
   0f 84 c5 07 00 00 ?? je basic block L250
  
  L66: 3c 75 ?? cmp al, 0x75<117>
   0f 84 bd 07 00 00 ?? je basic block L250
  
  L67: 3c 78 ?? cmp al, 0x78<120>
   0f 84 b5 07 00 00 ?? je basic block L250
  
  L68: 3c 58 ?? cmp al, 0x58<88>
   0f 84 ad 07 00 00 ?? je basic block L250
  
  L69: 89 b5 94 fd ff ff ?? mov dword ss:[ebp + 0xfffffd94<4294966676,-620>], esi
  
  L70: 8d 85 a4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffda4<4294966692,-604>]
   50 ?? push eax
   0f b6 c2 ?? movzx eax, dl
   50 ?? push eax
   89 b5 c8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], esi
   e8 24 1e 01 00 ?? call function 0x00422b5f
  
  L71: 59 ?? pop ecx
   85 c0 ?? test eax, eax
   8a 85 ef fd ff ff ?? mov al, byte ss:[ebp + 0xfffffdef<4294966767,-529>]
   59 ?? pop ecx
   74 22 ?? je basic block L74
  
  L72: 8b 8d b4 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffdb4<4294966708,-588>]
   8d b5 d8 fd ff ff ?? lea esi, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   e8 6a fb ff ff ?? call function 0x004108c2
  
  L73: 8a 03 ?? mov al, byte ds:[ebx]
   43 ?? inc ebx
   89 9d c4 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc4<4294966724,-572>], ebx
   84 c0 ?? test al, al
   0f 84 a4 fc ff ff ?? je basic block L3
  
  L74: 8b 8d b4 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffdb4<4294966708,-588>]
   8d b5 d8 fd ff ff ?? lea esi, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   e8 48 fb ff ff ?? call function 0x004108c2
  
  L75: e9 4d 07 00 00 ?? jmp basic block L250
  
  L76: 0f be c2 ?? movsx eax, dl
   83 f8 64 ?? cmp eax, 0x64<100>
   0f 8f e8 01 00 00 ?? jg basic block L115
  
  L77: 0f 84 79 02 00 00 ?? je basic block L130
  
  L78: 83 f8 53 ?? cmp eax, 0x53<83>
   0f 8f f2 00 00 00 ?? jg basic block L97
  
  L79: 0f 84 80 00 00 00 ?? je basic block L89
  
  L80: 83 e8 41 ?? sub eax, 0x41<65>
   74 10 ?? je basic block L84
  
  L81: 48 ?? dec eax
   48 ?? dec eax
   74 58 ?? je basic block L87
  
  L82: 48 ?? dec eax
   48 ?? dec eax
   74 08 ?? je basic block L84
  
  L83: 48 ?? dec eax
   48 ?? dec eax
   0f 85 92 05 00 00 ?? jne basic block L214
  
  L84: 80 c2 20 ?? add dl, 0x20<32>
   c7 85 90 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffd90<4294966672,-624>], 1
   00 00
   88 95 ef fd ff ff ?? mov byte ss:[ebp + 0xfffffdef<4294966767,-529>], dl
  
  L85: 83 8d f0 fd ff ff 40 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x40<64>
   39 b5 e8 fd ff ff ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], esi
   8d 9d f4 fd ff ff ?? lea ebx, ss:[ebp + 0xfffffdf4<4294966772,-524>]
   b8 00 02 00 00 ?? mov eax, 0x00000200<512>
   89 9d e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], ebx
   89 85 a0 fd ff ff ?? mov dword ss:[ebp + 0xfffffda0<4294966688,-608>], eax
   0f 8d 48 02 00 00 ?? jge basic block L134
  
  L86: c7 85 e8 fd ff ff 06 00 ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], 6
   00 00
   e9 a5 02 00 00 ?? jmp basic block L145
  
  L87: f7 85 f0 fd ff ff 30 08 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000830<2096>
   00 00
   0f 85 98 00 00 00 ?? jne basic block L101
  
  L88: 81 8d f0 fd ff ff 00 08 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000800<2048>
   00 00
   e9 89 00 00 00 ?? jmp basic block L101
  
  L89: f7 85 f0 fd ff ff 30 08 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000830<2096>
   00 00
   75 0a ?? jne basic block L91
  
  L90: 81 8d f0 fd ff ff 00 08 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000800<2048>
   00 00
  
  L91: 8b 8d e8 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   83 f9 ff ?? cmp ecx, 0xff<255,-1>
   75 05 ?? jne basic block L93
  
  L92: b9 ff ff ff 7f ?? mov ecx, 0x7fffffff
  
  L93: 83 c7 04 ?? add edi, 4
   f7 85 f0 fd ff ff 10 08 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000810<2064>
   00 00
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   8b 7f fc ?? mov edi, dword ds:[edi + 0xfc<252,-4>]
   89 bd e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], edi
   0f 84 b1 04 00 00 ?? je basic block L206
  
  L94: 3b fe ?? cmp edi, esi
   75 0b ?? jne basic block L96
  
  L95: a1 54 49 44 00 ?? mov eax, dword ds:[0x00444954]
   89 85 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], eax
  
  L96: 8b 85 e4 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   c7 85 c8 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], 1
   00 00
   e9 7f 04 00 00 ?? jmp basic block L204
  
  L97: 83 e8 58 ?? sub eax, 0x58<88>
   0f 84 da 02 00 00 ?? je basic block L161
  
  L98: 48 ?? dec eax
   48 ?? dec eax
   74 79 ?? je basic block L107
  
  L99: 2b c1 ?? sub eax, ecx
   0f 84 27 ff ff ff ?? je basic block L85
  
  L100: 48 ?? dec eax
   48 ?? dec eax
   0f 85 9e 04 00 00 ?? jne basic block L214
  
  L101: 83 c7 04 ?? add edi, 4
   f7 85 f0 fd ff ff 10 08 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000810<2064>
   00 00
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   74 30 ?? je basic block L105
  
  L102: 0f b7 47 fc ?? movzx eax, word ds:[edi + 0xfc<252,-4>]
   50 ?? push eax
   68 00 02 00 00 ?? push 0x00000200<512>
   8d 85 f4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdf4<4294966772,-524>]
   50 ?? push eax
   8d 85 e0 fd ff ff ?? lea eax, ss:[ebp + 0xfffffde0<4294966752,-544>]
   50 ?? push eax
   e8 e4 1b 01 00 ?? call function 0x00422abf
  
  L103: 83 c4 10 ?? add esp, 0x10<16>
   85 c0 ?? test eax, eax
   74 1f ?? je basic block L106
  
  L104: c7 85 c0 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffdc0<4294966720,-576>], 1
   00 00
   eb 13 ?? jmp basic block L106
  
  L105: 8a 47 fc ?? mov al, byte ds:[edi + 0xfc<252,-4>]
   88 85 f4 fd ff ff ?? mov byte ss:[ebp + 0xfffffdf4<4294966772,-524>], al
   c7 85 e0 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], 1
   00 00
  
  L106: 8d 85 f4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdf4<4294966772,-524>]
   89 85 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], eax
   e9 35 04 00 00 ?? jmp basic block L214
  
  L107: 8b 07 ?? mov eax, dword ds:[edi]
   83 c7 04 ?? add edi, 4
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   3b c6 ?? cmp eax, esi
   74 3b ?? je basic block L112
  
  L108: 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   3b ce ?? cmp ecx, esi
   74 34 ?? je basic block L112
  
  L109: f7 85 f0 fd ff ff 00 08 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000800<2048>
   00 00
   0f bf 00 ?? movsx eax, word ds:[eax]
   89 8d e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], ecx
   74 14 ?? je basic block L111
  
  L110: 99 ?? cdq
   2b c2 ?? sub eax, edx
   d1 f8 ?? sar eax, 1
   c7 85 c8 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], 1
   00 00
   e9 f0 03 00 00 ?? jmp basic block L213
  
  L111: 89 b5 c8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdc8<4294966728,-568>], esi
   e9 e5 03 00 00 ?? jmp basic block L213
  
  L112: a1 50 49 44 00 ?? mov eax, dword ds:[0x00444950]
   89 85 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], eax
   50 ?? push eax
  
  L113: e8 f3 8b ff ff ?? call function 0x00409b60
  
  L114: 59 ?? pop ecx
   e9 ce 03 00 00 ?? jmp basic block L213
  
  L115: 83 f8 70 ?? cmp eax, 0x70<112>
   0f 8f fb 01 00 00 ?? jg basic block L162
  
  L116: 0f 84 e3 01 00 00 ?? je basic block L160
  
  L117: 83 f8 65 ?? cmp eax, 0x65<101>
   0f 8c bc 03 00 00 ?? jl basic block L214
  
  L118: 83 f8 67 ?? cmp eax, 0x67<103>
   0f 8e 34 fe ff ff ?? jle basic block L85
  
  L119: 83 f8 69 ?? cmp eax, 0x69<105>
   74 71 ?? je basic block L130
  
  L120: 83 f8 6e ?? cmp eax, 0x6e<110>
   74 28 ?? je basic block L124
  
  L121: 83 f8 6f ?? cmp eax, 0x6f<111>
   0f 85 a0 03 00 00 ?? jne basic block L214
  
  L122: f6 85 f0 fd ff ff 80 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x80<128,-128>
   c7 85 e0 fd ff ff 08 00 ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], 8
   00 00
   74 61 ?? je basic block L132
  
  L123: 81 8d f0 fd ff ff 00 02 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000200<512>
   00 00
   eb 55 ?? jmp basic block L132
  
  L124: 8b 37 ?? mov esi, dword ds:[edi]
   83 c7 04 ?? add edi, 4
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   e8 67 19 01 00 ?? call function 0x0042293d
  
  L125: 85 c0 ?? test eax, eax
   0f 84 2f fa ff ff ?? je basic block L3
  
  L126: f6 85 f0 fd ff ff 20 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x20<32>
   74 0c ?? je basic block L128
  
  L127: 66 8b 85 d8 fd ff ff ?? mov ax, word ss:[ebp + 0xfffffdd8<4294966744,-552>]
   66 89 06 ?? mov word ds:[esi], ax
   eb 08 ?? jmp basic block L129
  
  L128: 8b 85 d8 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdd8<4294966744,-552>]
   89 06 ?? mov dword ds:[esi], eax
  
  L129: c7 85 c0 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffdc0<4294966720,-576>], 1
   00 00
   e9 a6 04 00 00 ?? jmp basic block L247
  
  L130: 83 8d f0 fd ff ff 40 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x40<64>
  
  L131: c7 85 e0 fd ff ff 0a 00 ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], 10
   00 00
  
  L132: 8b 8d f0 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffdf0<4294966768,-528>]
   f7 c1 00 80 00 00 ?? test ecx, 0x00008000<32768>
   0f 84 a9 01 00 00 ?? je basic block L168
  
  L133: 8b 07 ?? mov eax, dword ds:[edi]
   8b 57 04 ?? mov edx, dword ds:[edi + 4]
   83 c7 08 ?? add edi, 8
   e9 d5 01 00 00 ?? jmp basic block L177
  
  L134: 75 11 ?? jne basic block L137
  
  L135: 80 fa 67 ?? cmp dl, 0x67<103>
   75 65 ?? jne basic block L145
  
  L136: c7 85 e8 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], 1
   00 00
   eb 59 ?? jmp basic block L145
  
  L137: 39 85 e8 fd ff ff ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
   7e 06 ?? jle basic block L139
  
  L138: 89 85 e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
  
  L139: 81 bd e8 fd ff ff a3 00 ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], 0x000000a3<163>
   00 00
   7e 3f ?? jle basic block L145
  
  L140: 8b b5 e8 fd ff ff ?? mov esi, dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   81 c6 5d 01 00 00 ?? add esi, 0x0000015d<349>
   56 ?? push esi
   e8 47 e4 ff ff ?? call function 0x0040f4c0
  
  L141: 8a 95 ef fd ff ff ?? mov dl, byte ss:[ebp + 0xfffffdef<4294966767,-529>]
   59 ?? pop ecx
   89 85 bc fd ff ff ?? mov dword ss:[ebp + 0xfffffdbc<4294966716,-580>], eax
   85 c0 ?? test eax, eax
   74 10 ?? je basic block L143
  
  L142: 89 85 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], eax
   89 b5 a0 fd ff ff ?? mov dword ss:[ebp + 0xfffffda0<4294966688,-608>], esi
   8b d8 ?? mov ebx, eax
   eb 0a ?? jmp basic block L144
  
  L143: c7 85 e8 fd ff ff a3 00 ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], 0x000000a3<163>
   00 00
  
  L144: 33 f6 ?? xor esi, esi
  
  L145: 8b 07 ?? mov eax, dword ds:[edi]
   83 c7 08 ?? add edi, 8
   89 85 88 fd ff ff ?? mov dword ss:[ebp + 0xfffffd88<4294966664,-632>], eax
   8b 47 fc ?? mov eax, dword ds:[edi + 0xfc<252,-4>]
   89 85 8c fd ff ff ?? mov dword ss:[ebp + 0xfffffd8c<4294966668,-628>], eax
   8d 85 a4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffda4<4294966692,-604>]
   50 ?? push eax
   ff b5 90 fd ff ff ?? push dword ss:[ebp + 0xfffffd90<4294966672,-624>]
   0f be c2 ?? movsx eax, dl
   ff b5 e8 fd ff ff ?? push dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   50 ?? push eax
   ff b5 a0 fd ff ff ?? push dword ss:[ebp + 0xfffffda0<4294966688,-608>]
   8d 85 88 fd ff ff ?? lea eax, ss:[ebp + 0xfffffd88<4294966664,-632>]
   53 ?? push ebx
   50 ?? push eax
   ff 35 70 49 44 00 ?? push dword ds:[0x00444970]
   e8 2a e8 ff ff ?? call function 0x0040f91a
  
  L146: 59 ?? pop ecx
   ff d0 ?? call eax
  
  L147: 8b bd f0 fd ff ff ?? mov edi, dword ss:[ebp + 0xfffffdf0<4294966768,-528>]
   83 c4 1c ?? add esp, 0x1c<28>
   81 e7 80 00 00 00 ?? and edi, 0x00000080<128>
   74 20 ?? je basic block L152
  
  L148: 39 b5 e8 fd ff ff ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], esi
   75 18 ?? jne basic block L152
  
  L149: 8d 85 a4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffda4<4294966692,-604>]
   50 ?? push eax
   53 ?? push ebx
   ff 35 7c 49 44 00 ?? push dword ds:[0x0044497c]
   e8 fb e7 ff ff ?? call function 0x0040f91a
  
  L150: 59 ?? pop ecx
   ff d0 ?? call eax
  
  L151: 59 ?? pop ecx
   59 ?? pop ecx
  
  L152: 80 bd ef fd ff ff 67 ?? cmp byte ss:[ebp + 0xfffffdef<4294966767,-529>], 0x67<103>
   75 1c ?? jne basic block L157
  
  L153: 3b fe ?? cmp edi, esi
   75 18 ?? jne basic block L157
  
  L154: 8d 85 a4 fd ff ff ?? lea eax, ss:[ebp + 0xfffffda4<4294966692,-604>]
   50 ?? push eax
   53 ?? push ebx
   ff 35 78 49 44 00 ?? push dword ds:[0x00444978]
   e8 d6 e7 ff ff ?? call function 0x0040f91a
  
  L155: 59 ?? pop ecx
   ff d0 ?? call eax
  
  L156: 59 ?? pop ecx
   59 ?? pop ecx
  
  L157: 80 3b 2d ?? cmp byte ds:[ebx], 0x2d<45>
   75 11 ?? jne basic block L159
  
  L158: 81 8d f0 fd ff ff 00 01 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000100<256>
   00 00
   43 ?? inc ebx
   89 9d e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], ebx
  
  L159: 53 ?? push ebx
   e9 03 fe ff ff ?? jmp basic block L113
  
  L160: c7 85 e8 fd ff ff 08 00 ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], 8
   00 00
  
  L161: 89 8d b8 fd ff ff ?? mov dword ss:[ebp + 0xfffffdb8<4294966712,-584>], ecx
   eb 24 ?? jmp basic block L166
  
  L162: 83 e8 73 ?? sub eax, 0x73<115>
   0f 84 b6 fc ff ff ?? je basic block L91
  
  L163: 48 ?? dec eax
   48 ?? dec eax
   0f 84 89 fe ff ff ?? je basic block L131
  
  L164: 83 e8 03 ?? sub eax, 3
   0f 85 b6 01 00 00 ?? jne basic block L214
  
  L165: c7 85 b8 fd ff ff 27 00 ?? mov dword ss:[ebp + 0xfffffdb8<4294966712,-584>], 0x00000027<39>
   00 00
  
  L166: f6 85 f0 fd ff ff 80 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x80<128,-128>
   c7 85 e0 fd ff ff 10 00 ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], 0x00000010<16>
   00 00
   0f 84 69 fe ff ff ?? je basic block L132
  
  L167: 8a 85 b8 fd ff ff ?? mov al, byte ss:[ebp + 0xfffffdb8<4294966712,-584>]
   04 51 ?? add al, 0x51<81>
   c6 85 d4 fd ff ff 30 ?? mov byte ss:[ebp + 0xfffffdd4<4294966740,-556>], 0x30<48>
   88 85 d5 fd ff ff ?? mov byte ss:[ebp + 0xfffffdd5<4294966741,-555>], al
   c7 85 d0 fd ff ff 02 00 ?? mov dword ss:[ebp + 0xfffffdd0<4294966736,-560>], 2
   00 00
   e9 45 fe ff ff ?? jmp basic block L132
  
  L168: f7 c1 00 10 00 00 ?? test ecx, 0x00001000<4096>
   0f 85 4b fe ff ff ?? jne basic block L133
  
  L169: 83 c7 04 ?? add edi, 4
   f6 c1 20 ?? test cl, 0x20<32>
   74 18 ?? je basic block L174
  
  L170: 89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
   f6 c1 40 ?? test cl, 0x40<64>
   74 06 ?? je basic block L172
  
  L171: 0f bf 47 fc ?? movsx eax, word ds:[edi + 0xfc<252,-4>]
   eb 04 ?? jmp basic block L173
  
  L172: 0f b7 47 fc ?? movzx eax, word ds:[edi + 0xfc<252,-4>]
  
  L173: 99 ?? cdq
   eb 13 ?? jmp basic block L178
  
  L174: 8b 47 fc ?? mov eax, dword ds:[edi + 0xfc<252,-4>]
   f6 c1 40 ?? test cl, 0x40<64>
   74 03 ?? je basic block L176
  
  L175: 99 ?? cdq
   eb 02 ?? jmp basic block L177
  
  L176: 33 d2 ?? xor edx, edx
  
  L177: 89 bd dc fd ff ff ?? mov dword ss:[ebp + 0xfffffddc<4294966748,-548>], edi
  
  L178: f6 c1 40 ?? test cl, 0x40<64>
   74 1b ?? je basic block L183
  
  L179: 3b d6 ?? cmp edx, esi
   7f 17 ?? jg basic block L183
  
  L180: 7c 04 ?? jl basic block L182
  
  L181: 3b c6 ?? cmp eax, esi
   73 11 ?? jae basic block L183
  
  L182: f7 d8 ?? neg eax
   83 d2 00 ?? adc edx, 0
   f7 da ?? neg edx
   81 8d f0 fd ff ff 00 01 ?? or dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000100<256>
   00 00
  
  L183: f7 85 f0 fd ff ff 00 90 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00009000<36864>
   00 00
   8b da ?? mov ebx, edx
   8b f8 ?? mov edi, eax
   75 02 ?? jne basic block L185
  
  L184: 33 db ?? xor ebx, ebx
  
  L185: 83 bd e8 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], 0
   7d 0c ?? jge basic block L187
  
  L186: c7 85 e8 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], 1
   00 00
   eb 1a ?? jmp basic block L189
  
  L187: 83 a5 f0 fd ff ff f7 ?? and dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0xf7<247,-9>
   b8 00 02 00 00 ?? mov eax, 0x00000200<512>
   39 85 e8 fd ff ff ?? cmp dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
   7e 06 ?? jle basic block L189
  
  L188: 89 85 e8 fd ff ff ?? mov dword ss:[ebp + 0xfffffde8<4294966760,-536>], eax
  
  L189: 8b c7 ?? mov eax, edi
   0b c3 ?? or eax, ebx
   75 06 ?? jne basic block L191
  
  L190: 21 85 d0 fd ff ff ?? and dword ss:[ebp + 0xfffffdd0<4294966736,-560>], eax
  
  L191: 8d 75 f3 ?? lea esi, ss:[ebp + 0xf3<243,-13>]
  
  L192: 8b 85 e8 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   ff 8d e8 fd ff ff ?? dec dword ss:[ebp + 0xfffffde8<4294966760,-536>]
   85 c0 ?? test eax, eax
   7f 06 ?? jg basic block L194
  
  L193: 8b c7 ?? mov eax, edi
   0b c3 ?? or eax, ebx
   74 2d ?? je basic block L198
  
  L194: 8b 85 e0 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde0<4294966752,-544>]
   99 ?? cdq
   52 ?? push edx
   50 ?? push eax
   53 ?? push ebx
   57 ?? push edi
   e8 a5 bc 00 00 ?? call function 0x0041cf50
  
  L195: 83 c1 30 ?? add ecx, 0x30<48>
   83 f9 39 ?? cmp ecx, 0x39<57>
   89 9d a0 fd ff ff ?? mov dword ss:[ebp + 0xfffffda0<4294966688,-608>], ebx
   8b f8 ?? mov edi, eax
   8b da ?? mov ebx, edx
   7e 06 ?? jle basic block L197
  
  L196: 03 8d b8 fd ff ff ?? add ecx, dword ss:[ebp + 0xfffffdb8<4294966712,-584>]
  
  L197: 88 0e ?? mov byte ds:[esi], cl
   4e ?? dec esi
   eb bd ?? jmp basic block L192
  
  L198: 8d 45 f3 ?? lea eax, ss:[ebp + 0xf3<243,-13>]
   2b c6 ?? sub eax, esi
   46 ?? inc esi
   f7 85 f0 fd ff ff 00 02 ?? test dword ss:[ebp + 0xfffffdf0<4294966768,-528>], 0x00000200<512>
   00 00
   89 85 e0 fd ff ff ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], eax
   89 b5 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], esi
   74 61 ?? je basic block L214
  
  L199: 85 c0 ?? test eax, eax
   74 07 ?? je basic block L201
  
  L200: 8b ce ?? mov ecx, esi
   80 39 30 ?? cmp byte ds:[ecx], 0x30<48>
   74 56 ?? je basic block L214
  
  L201: ff 8d e4 fd ff ff ?? dec dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   8b 8d e4 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   c6 01 30 ?? mov byte ds:[ecx], 0x30<48>
   40 ?? inc eax
   eb 3e ?? jmp basic block L213
  
  L202: 49 ?? dec ecx
   66 39 30 ?? cmp word ds:[eax], si
   74 06 ?? je basic block L205
  
  L203: 40 ?? inc eax
   40 ?? inc eax
  
  L204: 3b ce ?? cmp ecx, esi
   75 f4 ?? jne basic block L202
  
  L205: 2b 85 e4 fd ff ff ?? sub eax, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   d1 f8 ?? sar eax, 1
   eb 28 ?? jmp basic block L213
  
  L206: 3b fe ?? cmp edi, esi
   75 0b ?? jne basic block L208
  
  L207: a1 50 49 44 00 ?? mov eax, dword ds:[0x00444950]
   89 85 e4 fd ff ff ?? mov dword ss:[ebp + 0xfffffde4<4294966756,-540>], eax
  
  L208: 8b 85 e4 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   eb 07 ?? jmp basic block L211
  
  L209: 49 ?? dec ecx
   80 38 00 ?? cmp byte ds:[eax], 0
   74 05 ?? je basic block L212
  
  L210: 40 ?? inc eax
  
  L211: 3b ce ?? cmp ecx, esi
   75 f5 ?? jne basic block L209
  
  L212: 2b 85 e4 fd ff ff ?? sub eax, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
  
  L213: 89 85 e0 fd ff ff ?? mov dword ss:[ebp + 0xfffffde0<4294966752,-544>], eax
  
  L214: 83 bd c0 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffdc0<4294966720,-576>], 0
   0f 85 5c 01 00 00 ?? jne basic block L247
  
  L215: 8b 85 f0 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdf0<4294966768,-528>]
   a8 40 ?? test al, 0x40<64>
   74 32 ?? je basic block L223
  
  L216: a9 00 01 00 00 ?? test eax, 0x00000100<256>
   74 09 ?? je basic block L218
  
  L217: c6 85 d4 fd ff ff 2d ?? mov byte ss:[ebp + 0xfffffdd4<4294966740,-556>], 0x2d<45>
   eb 18 ?? jmp basic block L222
  
  L218: a8 01 ?? test al, 1
   74 09 ?? je basic block L220
  
  L219: c6 85 d4 fd ff ff 2b ?? mov byte ss:[ebp + 0xfffffdd4<4294966740,-556>], 0x2b<43>
   eb 0b ?? jmp basic block L222
  
  L220: a8 02 ?? test al, 2
   74 11 ?? je basic block L223
  
  L221: c6 85 d4 fd ff ff 20 ?? mov byte ss:[ebp + 0xfffffdd4<4294966740,-556>], 0x20<32>
  
  L222: c7 85 d0 fd ff ff 01 00 ?? mov dword ss:[ebp + 0xfffffdd0<4294966736,-560>], 1
   00 00
  
  L223: 8b 9d cc fd ff ff ?? mov ebx, dword ss:[ebp + 0xfffffdcc<4294966732,-564>]
   2b 9d e0 fd ff ff ?? sub ebx, dword ss:[ebp + 0xfffffde0<4294966752,-544>]
   2b 9d d0 fd ff ff ?? sub ebx, dword ss:[ebp + 0xfffffdd0<4294966736,-560>]
   f6 85 f0 fd ff ff 0c ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 12
   75 17 ?? jne basic block L226
  
  L224: ff b5 b4 fd ff ff ?? push dword ss:[ebp + 0xfffffdb4<4294966708,-588>]
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   53 ?? push ebx
   6a 20 ?? push 0x20<32>
   e8 36 f5 ff ff ?? call function 0x004108f5
  
  L225: 83 c4 0c ?? add esp, 12
  
  L226: ff b5 d0 fd ff ff ?? push dword ss:[ebp + 0xfffffdd0<4294966736,-560>]
   8b bd b4 fd ff ff ?? mov edi, dword ss:[ebp + 0xfffffdb4<4294966708,-588>]
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   8d 8d d4 fd ff ff ?? lea ecx, ss:[ebp + 0xfffffdd4<4294966740,-556>]
   e8 3c f5 ff ff ?? call function 0x0041091b
  
  L227: f6 85 f0 fd ff ff 08 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 8
   59 ?? pop ecx
   74 1b ?? je basic block L231
  
  L228: f6 85 f0 fd ff ff 04 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 4
   75 12 ?? jne basic block L231
  
  L229: 57 ?? push edi
   53 ?? push ebx
   6a 30 ?? push 0x30<48>
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   e8 f4 f4 ff ff ?? call function 0x004108f5
  
  L230: 83 c4 0c ?? add esp, 12
  
  L231: 83 bd c8 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffdc8<4294966728,-568>], 0
   8b 85 e0 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffde0<4294966752,-544>]
   74 66 ?? je basic block L241
  
  L232: 85 c0 ?? test eax, eax
   7e 62 ?? jle basic block L241
  
  L233: 8b b5 e4 fd ff ff ?? mov esi, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   89 85 a0 fd ff ff ?? mov dword ss:[ebp + 0xfffffda0<4294966688,-608>], eax
  
  L234: 0f b7 06 ?? movzx eax, word ds:[esi]
   ff 8d a0 fd ff ff ?? dec dword ss:[ebp + 0xfffffda0<4294966688,-608>]
   50 ?? push eax
   6a 06 ?? push 6
   8d 45 f4 ?? lea eax, ss:[ebp + 0xf4<244,-12>]
   50 ?? push eax
   8d 85 98 fd ff ff ?? lea eax, ss:[ebp + 0xfffffd98<4294966680,-616>]
   46 ?? inc esi
   50 ?? push eax
   46 ?? inc esi
   e8 7e 16 01 00 ?? call function 0x00422abf
  
  L235: 83 c4 10 ?? add esp, 0x10<16>
   85 c0 ?? test eax, eax
   75 28 ?? jne basic block L240
  
  L236: 39 85 98 fd ff ff ?? cmp dword ss:[ebp + 0xfffffd98<4294966680,-616>], eax
   74 20 ?? je basic block L240
  
  L237: ff b5 98 fd ff ff ?? push dword ss:[ebp + 0xfffffd98<4294966680,-616>]
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   8d 4d f4 ?? lea ecx, ss:[ebp + 0xf4<244,-12>]
   e8 b7 f4 ff ff ?? call function 0x0041091b
  
  L238: 83 bd a0 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffda0<4294966688,-608>], 0
   59 ?? pop ecx
   75 b5 ?? jne basic block L234
  
  L239: eb 1c ?? jmp basic block L243
  
  L240: 83 8d d8 fd ff ff ff ?? or dword ss:[ebp + 0xfffffdd8<4294966744,-552>], 0xff<255,-1>
   eb 13 ?? jmp basic block L243
  
  L241: 8b 8d e4 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffde4<4294966756,-540>]
   50 ?? push eax
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   e8 90 f4 ff ff ?? call function 0x0041091b
  
  L242: 59 ?? pop ecx
  
  L243: 83 bd d8 fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffdd8<4294966744,-552>], 0
   7c 1b ?? jl basic block L247
  
  L244: f6 85 f0 fd ff ff 04 ?? test byte ss:[ebp + 0xfffffdf0<4294966768,-528>], 4
   74 12 ?? je basic block L247
  
  L245: 57 ?? push edi
   53 ?? push ebx
   6a 20 ?? push 0x20<32>
   8d 85 d8 fd ff ff ?? lea eax, ss:[ebp + 0xfffffdd8<4294966744,-552>]
   e8 48 f4 ff ff ?? call function 0x004108f5
  
  L246: 83 c4 0c ?? add esp, 12
  
  L247: 83 bd bc fd ff ff 00 ?? cmp dword ss:[ebp + 0xfffffdbc<4294966716,-580>], 0
   74 13 ?? je basic block L250
  
  L248: ff b5 bc fd ff ff ?? push dword ss:[ebp + 0xfffffdbc<4294966716,-580>]
   e8 fa 93 ff ff ?? call function 0x0040a8be
  
  L249: 83 a5 bc fd ff ff 00 ?? and dword ss:[ebp + 0xfffffdbc<4294966716,-580>], 0
   59 ?? pop ecx
  
  L250: 8b 9d c4 fd ff ff ?? mov ebx, dword ss:[ebp + 0xfffffdc4<4294966724,-572>]
   8a 03 ?? mov al, byte ds:[ebx]
   88 85 ef fd ff ff ?? mov byte ss:[ebp + 0xfffffdef<4294966767,-529>], al
   84 c0 ?? test al, al
   74 13 ?? je basic block L252
  
  L251: 8b 8d 94 fd ff ff ?? mov ecx, dword ss:[ebp + 0xfffffd94<4294966676,-620>]
   8b bd dc fd ff ff ?? mov edi, dword ss:[ebp + 0xfffffddc<4294966748,-548>]
   8a d0 ?? mov dl, al
   e9 e1 f5 ff ff ?? jmp basic block L22
  
  L252: 80 bd b0 fd ff ff 00 ?? cmp byte ss:[ebp + 0xfffffdb0<4294966704,-592>], 0
   74 0a ?? je basic block L254
  
  L253: 8b 85 ac fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdac<4294966700,-596>]
   83 60 70 fd ?? and dword ds:[eax + 0x70<112>], 0xfd<253,-3>
  
  L254: 8b 85 d8 fd ff ff ?? mov eax, dword ss:[ebp + 0xfffffdd8<4294966744,-552>]
  
  L255: 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 35 86 ff ff ?? call function 0x00409b4c
  
  L256: c9 ?? leave
   c3 ?? ret
  
  0x0041151a: 25 0d 41 00 26 0b 41 00 56 0b 41 00 b4 0b 41 00 |%.A.&.A.V.A...A.|
  0x0041152a: 00 0c 41 00 0b 0c 41 00 51 0c 41 00 7f 0d 41 00 |..A...A.Q.A...A.|
  
  