
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 0x0040c935

L3: 83 20 00 ?? and dword ds:[eax], 0
 e8 20 f6 fe ff ?? call function 0x0040c922

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 94 76 43 00 ?? cmp esi, dword ds:[0x00437694]
 72 27 ?? jb basic block L11

L7: e8 11 f6 fe ff ?? call function 0x0040c935

L8: 89 18 ?? mov dword ds:[eax], ebx
 e8 f7 f5 fe ff ?? call function 0x0040c922

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 0x00406dc0

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 e0 76 43 00 ?? lea edi, ds:[0x004376e0 + 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 0x0040c935

L13: 89 18 ?? mov dword ds:[eax], ebx
 e8 b1 f5 fe ff ?? call function 0x0040c922

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 0x0040c935

L26: 89 18 ?? mov dword ds:[eax], ebx
 e8 45 f5 fe ff ?? call function 0x0040c922

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 0x00406dc0

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 0x0040a4e0

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 0x0040c922

L35: c7 00 0c 00 00 00 ?? mov dword ds:[eax], 12
 e8 15 f5 fe ff ?? call function 0x0040c935

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 0x0041d998

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 92 43 00 ?? call dword ds:[0x004392d4]

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 92 43 00 ?? call dword ds:[0x004392d4]

L70: 85 c0 ?? test eax, eax
 75 0a ?? jne basic block L73

L71: ff 15 30 92 43 00 ?? call dword ds:[0x00439230]

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 0x0041d998

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 78 62 43 00 00 ?? cmp byte ds:[ecx + 0x00436278], 0
 74 e8 ?? je basic block L93

L97: 8a 13 ?? mov dl, byte ds:[ebx]
 0f b6 ca ?? movzx ecx, dl
 0f be 89 78 62 43 00 ?? movsx ecx, byte ds:[ecx + 0x00436278]
 85 c9 ?? test ecx, ecx
 75 0d ?? jne basic block L100

L98: e8 b8 f2 fe ff ?? call function 0x0040c922

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 0x0041d998

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 92 43 00 ?? call dword ds:[0x00439240]

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 92 43 00 ?? call dword ds:[0x00439230]

L113: 50 ?? push eax
 e8 5d f2 fe ff ?? call function 0x0040c948

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 0x00406e0c

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 92 43 00 ?? call dword ds:[0x004392d4]

L136: 85 c0 ?? test eax, eax
 75 0a ?? jne basic block L139

L137: ff 15 30 92 43 00 ?? call dword ds:[0x00439230]

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 0x0041d998

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 92 43 00 ?? call dword ds:[0x00439230]

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 0x0040c922

L159: c7 00 09 00 00 00 ?? mov dword ds:[eax], 9
 e8 b9 f0 fe ff ?? call function 0x0040c935

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

