
L1: 6a 54 ?? push 0x54<84>
 68 88 32 43 00 ?? push 0x00433288
 e8 90 03 00 00 ?? call function 0x0040da10

L2: 33 ff ?? xor edi, edi
 89 7d fc ?? mov dword ss:[ebp + 0xfc<252,-4>], edi
 8d 45 9c ?? lea eax, ss:[ebp + 0x9c<156,-100>]
 50 ?? push eax
 ff 15 9c 82 43 00 ?? call dword ds:[0x0043829c]

L3: c7 45 fc fe ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xfffffffe<4294967294,-2>
 6a 40 ?? push 0x40<64>
 6a 20 ?? push 0x20<32>
 5e ?? pop esi
 56 ?? push esi
 e8 a4 c9 ff ff ?? call function 0x0040a045

L4: 59 ?? pop ecx
 59 ?? pop ecx
 3b c7 ?? cmp eax, edi
 0f 84 14 02 00 00 ?? je basic block L58

L5: a3 c0 66 43 00 ?? mov dword ds:[0x004366c0], eax
 89 35 6c 66 43 00 ?? mov dword ds:[0x0043666c], esi
 8d 88 00 08 00 00 ?? lea ecx, ds:[eax + 0x00000800<2048>]
 eb 30 ?? jmp basic block L7

L6: c6 40 04 00 ?? mov byte ds:[eax + 4], 0
 83 08 ff ?? or dword ds:[eax], 0xff<255,-1>
 c6 40 05 0a ?? mov byte ds:[eax + 5], 10
 89 78 08 ?? mov dword ds:[eax + 8], edi
 c6 40 24 00 ?? mov byte ds:[eax + 0x24<36>], 0
 c6 40 25 0a ?? mov byte ds:[eax + 0x25<37>], 10
 c6 40 26 0a ?? mov byte ds:[eax + 0x26<38>], 10
 89 78 38 ?? mov dword ds:[eax + 0x38<56>], edi
 c6 40 34 00 ?? mov byte ds:[eax + 0x34<52>], 0
 83 c0 40 ?? add eax, 0x40<64>
 8b 0d c0 66 43 00 ?? mov ecx, dword ds:[0x004366c0]
 81 c1 00 08 00 00 ?? add ecx, 0x00000800<2048>

L7: 3b c1 ?? cmp eax, ecx
 72 cc ?? jb basic block L6

L8: 66 39 7d ce ?? cmp word ss:[ebp + 0xce<206,-50>], di
 0f 84 0a 01 00 00 ?? je basic block L33

L9: 8b 45 d0 ?? mov eax, dword ss:[ebp + 0xd0<208,-48>]
 3b c7 ?? cmp eax, edi
 0f 84 ff 00 00 00 ?? je basic block L33

L10: 8b 38 ?? mov edi, dword ds:[eax]
 8d 58 04 ?? lea ebx, ds:[eax + 4]
 8d 04 3b ?? lea eax, ds:[ebx + edi]
 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
 be 00 08 00 00 ?? mov esi, 0x00000800<2048>
 3b fe ?? cmp edi, esi
 7c 02 ?? jl basic block L12

L11: 8b fe ?? mov edi, esi

L12: c7 45 e0 01 00 00 00 ?? mov dword ss:[ebp + 0xe0<224,-32>], 1
 eb 5b ?? jmp basic block L19

L13: 6a 40 ?? push 0x40<64>
 6a 20 ?? push 0x20<32>
 e8 16 c9 ff ff ?? call function 0x0040a045

L14: 59 ?? pop ecx
 59 ?? pop ecx
 85 c0 ?? test eax, eax
 74 56 ?? je basic block L21

L15: 8b 4d e0 ?? mov ecx, dword ss:[ebp + 0xe0<224,-32>]
 8d 0c 8d c0 66 43 00 ?? lea ecx, ds:[0x004366c0 + ecx * 4]
 89 01 ?? mov dword ds:[ecx], eax
 83 05 6c 66 43 00 20 ?? add dword ds:[0x0043666c], 0x20<32>
 8d 90 00 08 00 00 ?? lea edx, ds:[eax + 0x00000800<2048>]
 eb 2a ?? jmp basic block L17

L16: c6 40 04 00 ?? mov byte ds:[eax + 4], 0
 83 08 ff ?? or dword ds:[eax], 0xff<255,-1>
 c6 40 05 0a ?? mov byte ds:[eax + 5], 10
 83 60 08 00 ?? and dword ds:[eax + 8], 0
 80 60 24 80 ?? and byte ds:[eax + 0x24<36>], 0x80<128,-128>
 c6 40 25 0a ?? mov byte ds:[eax + 0x25<37>], 10
 c6 40 26 0a ?? mov byte ds:[eax + 0x26<38>], 10
 83 60 38 00 ?? and dword ds:[eax + 0x38<56>], 0
 c6 40 34 00 ?? mov byte ds:[eax + 0x34<52>], 0
 83 c0 40 ?? add eax, 0x40<64>
 8b 11 ?? mov edx, dword ds:[ecx]
 03 d6 ?? add edx, esi

L17: 3b c2 ?? cmp eax, edx
 72 d2 ?? jb basic block L16

L18: ff 45 e0 ?? inc dword ss:[ebp + 0xe0<224,-32>]

L19: 39 3d 6c 66 43 00 ?? cmp dword ds:[0x0043666c], edi
 7c 9d ?? jl basic block L13

L20: eb 06 ?? jmp basic block L22

L21: 8b 3d 6c 66 43 00 ?? mov edi, dword ds:[0x0043666c]

L22: 83 65 e0 00 ?? and dword ss:[ebp + 0xe0<224,-32>], 0
 85 ff ?? test edi, edi
 7e 6d ?? jle basic block L33

L23: 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
 8b 08 ?? mov ecx, dword ds:[eax]
 83 f9 ff ?? cmp ecx, 0xff<255,-1>
 74 56 ?? je basic block L32

L24: 83 f9 fe ?? cmp ecx, 0xfe<254,-2>
 74 51 ?? je basic block L32

L25: 8a 03 ?? mov al, byte ds:[ebx]
 a8 01 ?? test al, 1
 74 4b ?? je basic block L32

L26: a8 08 ?? test al, 8
 75 0b ?? jne basic block L29

L27: 51 ?? push ecx
 ff 15 98 82 43 00 ?? call dword ds:[0x00438298]

L28: 85 c0 ?? test eax, eax
 74 3c ?? je basic block L32

L29: 8b 75 e0 ?? mov esi, dword ss:[ebp + 0xe0<224,-32>]
 8b c6 ?? mov eax, esi
 c1 f8 05 ?? sar eax, 5
 83 e6 1f ?? and esi, 0x1f<31>
 c1 e6 06 ?? shl esi, 6
 03 34 85 c0 66 43 00 ?? add esi, dword ds:[0x004366c0 + eax * 4]
 8b 45 e4 ?? mov eax, dword ss:[ebp + 0xe4<228,-28>]
 8b 00 ?? mov eax, dword ds:[eax]
 89 06 ?? mov dword ds:[esi], eax
 8a 03 ?? mov al, byte ds:[ebx]
 88 46 04 ?? mov byte ds:[esi + 4], al
 68 a0 0f 00 00 ?? push 0x00000fa0<4000>
 8d 46 0c ?? lea eax, ds:[esi + 12]
 50 ?? push eax
 e8 d7 f4 00 00 ?? call function 0x0041ccc3

L30: 59 ?? pop ecx
 59 ?? pop ecx
 85 c0 ?? test eax, eax
 0f 84 c9 00 00 00 ?? je basic block L58

L31: ff 46 08 ?? inc dword ds:[esi + 8]

L32: ff 45 e0 ?? inc dword ss:[ebp + 0xe0<224,-32>]
 43 ?? inc ebx
 83 45 e4 04 ?? add dword ss:[ebp + 0xe4<228,-28>], 4
 39 7d e0 ?? cmp dword ss:[ebp + 0xe0<224,-32>], edi
 7c 93 ?? jl basic block L23

L33: 33 db ?? xor ebx, ebx

L34: 8b f3 ?? mov esi, ebx
 c1 e6 06 ?? shl esi, 6
 03 35 c0 66 43 00 ?? add esi, dword ds:[0x004366c0]
 8b 06 ?? mov eax, dword ds:[esi]
 83 f8 ff ?? cmp eax, 0xff<255,-1>
 74 0b ?? je basic block L37

L35: 83 f8 fe ?? cmp eax, 0xfe<254,-2>
 74 06 ?? je basic block L37

L36: 80 4e 04 80 ?? or byte ds:[esi + 4], 0x80<128,-128>
 eb 72 ?? jmp basic block L53

L37: c6 46 04 81 ?? mov byte ds:[esi + 4], 0x81<129,-127>
 85 db ?? test ebx, ebx
 75 05 ?? jne basic block L39

L38: 6a f6 ?? push 0xf6<246,-10>
 58 ?? pop eax
 eb 0a ?? jmp basic block L40

L39: 8b c3 ?? mov eax, ebx
 48 ?? dec eax
 f7 d8 ?? neg eax
 1b c0 ?? sbb eax, eax
 83 c0 f5 ?? add eax, 0xf5<245,-11>

L40: 50 ?? push eax
 ff 15 54 82 43 00 ?? call dword ds:[0x00438254]

L41: 8b f8 ?? mov edi, eax
 83 ff ff ?? cmp edi, 0xff<255,-1>
 74 43 ?? je basic block L52

L42: 85 ff ?? test edi, edi
 74 3f ?? je basic block L52

L43: 57 ?? push edi
 ff 15 98 82 43 00 ?? call dword ds:[0x00438298]

L44: 85 c0 ?? test eax, eax
 74 34 ?? je basic block L52

L45: 89 3e ?? mov dword ds:[esi], edi
 25 ff 00 00 00 ?? and eax, 0x000000ff<255>
 83 f8 02 ?? cmp eax, 2
 75 06 ?? jne basic block L47

L46: 80 4e 04 40 ?? or byte ds:[esi + 4], 0x40<64>
 eb 09 ?? jmp basic block L49

L47: 83 f8 03 ?? cmp eax, 3
 75 04 ?? jne basic block L49

L48: 80 4e 04 08 ?? or byte ds:[esi + 4], 8

L49: 68 a0 0f 00 00 ?? push 0x00000fa0<4000>
 8d 46 0c ?? lea eax, ds:[esi + 12]
 50 ?? push eax
 e8 41 f4 00 00 ?? call function 0x0041ccc3

L50: 59 ?? pop ecx
 59 ?? pop ecx
 85 c0 ?? test eax, eax
 74 37 ?? je basic block L58

L51: ff 46 08 ?? inc dword ds:[esi + 8]
 eb 0a ?? jmp basic block L53

L52: 80 4e 04 40 ?? or byte ds:[esi + 4], 0x40<64>
 c7 06 fe ff ff ff ?? mov dword ds:[esi], 0xfffffffe<4294967294,-2>

L53: 43 ?? inc ebx
 83 fb 03 ?? cmp ebx, 3
 0f 8c 67 ff ff ff ?? jl basic block L34

L54: ff 35 6c 66 43 00 ?? push dword ds:[0x0043666c]
 ff 15 94 82 43 00 ?? call dword ds:[0x00438294]

L55: 33 c0 ?? xor eax, eax
 eb 11 ?? jmp basic block L59

L56: 33 c0 ?? xor eax, eax
 40 ?? inc eax
 c3 ?? ret

L57: 8b 65 e8 ?? mov esp, dword ss:[ebp + 0xe8<232,-24>]
 c7 45 fc fe ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xfffffffe<4294967294,-2>

L58: 83 c8 ff ?? or eax, 0xff<255,-1>

L59: e8 8e 01 00 00 ?? call function 0x0040da55

L60: c3 ?? ret

