
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 83 ec 20 ?? sub esp, 0x20<32>
 a1 70 80 42 00 ?? mov eax, dword ds:[0x00428070]
 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]
 57 ?? push edi
 e8 64 ff ff ff ?? call function 0x004086e0

L2: 8b f8 ?? mov edi, eax
 33 f6 ?? xor esi, esi
 89 7d 08 ?? mov dword ss:[ebp + 8], edi
 3b fe ?? cmp edi, esi
 75 0e ?? jne basic block L5

L3: 8b c3 ?? mov eax, ebx
 e8 30 fc ff ff ?? call function 0x004083be

L4: 33 c0 ?? xor eax, eax
 e9 9d 01 00 00 ?? jmp basic block L47

L5: 89 75 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], esi
 33 c0 ?? xor eax, eax

L6: 39 b8 18 8a 42 00 ?? cmp dword ds:[eax + 0x00428a18], edi
 0f 84 91 00 00 00 ?? je basic block L20

L7: ff 45 e4 ?? inc dword ss:[ebp + 0xe4<228,-28>]
 83 c0 30 ?? add eax, 0x30<48>
 3d f0 00 00 00 ?? cmp eax, 0x000000f0<240>
 72 e7 ?? jb basic block L6

L8: 81 ff e8 fd 00 00 ?? cmp edi, 0x0000fde8<65000>
 0f 84 70 01 00 00 ?? je basic block L46

L9: 81 ff e9 fd 00 00 ?? cmp edi, 0x0000fde9<65001>
 0f 84 64 01 00 00 ?? je basic block L46

L10: 0f b7 c7 ?? movzx eax, di
 50 ?? push eax
 ff 15 84 a2 42 00 ?? call dword ds:[0x0042a284]

L11: 85 c0 ?? test eax, eax
 0f 84 52 01 00 00 ?? je basic block L46

L12: 8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
 50 ?? push eax
 57 ?? push edi
 ff 15 78 a2 42 00 ?? call dword ds:[0x0042a278]

L13: 85 c0 ?? test eax, eax
 0f 84 33 01 00 00 ?? je basic block L45

L14: 68 01 01 00 00 ?? push 0x00000101<257>
 8d 43 1c ?? lea eax, ds:[ebx + 0x1c<28>]
 56 ?? push esi
 50 ?? push eax
 e8 01 5b 00 00 ?? call function 0x0040e300

L15: 33 d2 ?? xor edx, edx
 42 ?? inc edx
 83 c4 0c ?? add esp, 12
 89 7b 04 ?? mov dword ds:[ebx + 4], edi
 89 73 0c ?? mov dword ds:[ebx + 12], esi
 39 55 e8 ?? cmp dword ss:[ebp + 0xe8<232,-24>], edx
 0f 86 f8 00 00 00 ?? jbe basic block L43

L16: 80 7d ee 00 ?? cmp byte ss:[ebp + 0xee<238,-18>], 0
 0f 84 cf 00 00 00 ?? je basic block L38

L17: 8d 75 ef ?? lea esi, ss:[ebp + 0xef<239,-17>]

L18: 8a 0e ?? mov cl, byte ds:[esi]
 84 c9 ?? test cl, cl
 0f 84 c2 00 00 00 ?? je basic block L38

L19: 0f b6 46 ff ?? movzx eax, byte ds:[esi + 0xff<255,-1>]
 0f b6 c9 ?? movzx ecx, cl
 e9 a6 00 00 00 ?? jmp basic block L36

L20: 68 01 01 00 00 ?? push 0x00000101<257>
 8d 43 1c ?? lea eax, ds:[ebx + 0x1c<28>]
 56 ?? push esi
 50 ?? push eax
 e8 ba 5a 00 00 ?? call function 0x0040e300

L21: 8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
 83 c4 0c ?? add esp, 12
 6b c9 30 ?? imul ecx, ecx, 0x30<48>
 89 75 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], esi
 8d b1 28 8a 42 00 ?? lea esi, ds:[ecx + 0x00428a28]
 89 75 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], esi
 eb 2a ?? jmp basic block L27

L22: 8a 46 01 ?? mov al, byte ds:[esi + 1]
 84 c0 ?? test al, al
 74 28 ?? je basic block L28

L23: 0f b6 3e ?? movzx edi, byte ds:[esi]
 0f b6 c0 ?? movzx eax, al
 eb 12 ?? jmp basic block L25

L24: 8b 45 e0 ?? mov eax, dword ss:[ebp + 0xe0<224,-32>]
 8a 80 14 8a 42 00 ?? mov al, byte ds:[eax + 0x00428a14]
 08 44 3b 1d ?? or byte ds:[ebx + edi + 0x1d<29>], al
 0f b6 46 01 ?? movzx eax, byte ds:[esi + 1]
 47 ?? inc edi

L25: 3b f8 ?? cmp edi, eax
 76 ea ?? jbe basic block L24

L26: 8b 7d 08 ?? mov edi, dword ss:[ebp + 8]
 46 ?? inc esi
 46 ?? inc esi

L27: 80 3e 00 ?? cmp byte ds:[esi], 0
 75 d1 ?? jne basic block L22

L28: 8b 75 e4 ?? mov esi, dword ss:[ebp + 0xe4<228,-28>]
 ff 45 e0 ?? inc dword ss:[ebp + 0xe0<224,-32>]
 83 c6 08 ?? add esi, 8
 83 7d e0 04 ?? cmp dword ss:[ebp + 0xe0<224,-32>], 4
 89 75 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], esi
 72 e9 ?? jb basic block L27

L29: 8b c7 ?? mov eax, edi
 89 7b 04 ?? mov dword ds:[ebx + 4], edi
 c7 43 08 01 00 00 00 ?? mov dword ds:[ebx + 8], 1
 e8 e0 fa ff ff ?? call function 0x0040838f

L30: 6a 06 ?? push 6
 89 43 0c ?? mov dword ds:[ebx + 12], eax
 8d 43 10 ?? lea eax, ds:[ebx + 0x10<16>]
 8d 89 1c 8a 42 00 ?? lea ecx, ds:[ecx + 0x00428a1c]
 5a ?? pop edx

L31: 66 8b 31 ?? mov si, word ds:[ecx]
 41 ?? inc ecx
 66 89 30 ?? mov word ds:[eax], si
 41 ?? inc ecx
 40 ?? inc eax
 40 ?? inc eax
 4a ?? dec edx

L32: 75 f3 ?? jne basic block L31

L33: 8b f3 ?? mov esi, ebx
 e8 50 fb ff ff ?? call function 0x00408422

L34: e9 b7 fe ff ff ?? jmp basic block L4

L35: 80 4c 03 1d 04 ?? or byte ds:[ebx + eax + 0x1d<29>], 4
 40 ?? inc eax

L36: 3b c1 ?? cmp eax, ecx
 76 f6 ?? jbe basic block L35

L37: 46 ?? inc esi
 46 ?? inc esi
 80 7e ff 00 ?? cmp byte ds:[esi + 0xff<255,-1>], 0
 0f 85 34 ff ff ff ?? jne basic block L18

L38: 8d 43 1e ?? lea eax, ds:[ebx + 0x1e<30>]
 b9 fe 00 00 00 ?? mov ecx, 0x000000fe<254>

L39: 80 08 08 ?? or byte ds:[eax], 8
 40 ?? inc eax
 49 ?? dec ecx

L40: 75 f9 ?? jne basic block L39

L41: 8b 43 04 ?? mov eax, dword ds:[ebx + 4]
 e8 8b fa ff ff ?? call function 0x0040838f

L42: 89 43 0c ?? mov dword ds:[ebx + 12], eax
 89 53 08 ?? mov dword ds:[ebx + 8], edx
 eb 03 ?? jmp basic block L44

L43: 89 73 08 ?? mov dword ds:[ebx + 8], esi

L44: 33 c0 ?? xor eax, eax
 0f b7 c8 ?? movzx ecx, ax
 8b c1 ?? mov eax, ecx
 c1 e1 10 ?? shl ecx, 0x10<16>
 0b c1 ?? or eax, ecx
 8d 7b 10 ?? lea edi, ds:[ebx + 0x10<16>]
 ab ?? stosd
 ab ?? stosd
 ab ?? stosd
 eb a8 ?? jmp basic block L33

L45: 39 35 90 9a 42 00 ?? cmp dword ds:[0x00429a90], esi
 0f 85 58 fe ff ff ?? jne basic block L3

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

L47: 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 ef 8e ff ff ?? call function 0x0040182e

L48: c9 ?? leave
 c3 ?? ret

