
L1: 55 ?? push ebp
 8b ec ?? mov ebp, esp
 6a ff ?? push 0xff<255,-1>
 68 20 40 40 00 ?? push 0x00404020
 64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
 50 ?? push eax
 83 ec 1c ?? sub esp, 0x1c<28>
 53 ?? push ebx
 56 ?? push esi
 57 ?? push edi
 a1 60 80 40 00 ?? mov eax, dword ds:[0x00408060]
 33 c5 ?? xor eax, ebp
 50 ?? push eax
 8d 45 f4 ?? lea eax, ss:[ebp + 0xf4<244,-12>]
 64 a3 00 00 00 00 ?? mov dword fs:[0], eax
 89 65 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esp
 8b f9 ?? mov edi, ecx
 89 7d ec ?? mov dword ss:[ebp + 0xec<236,-20>], edi
 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 8b f0 ?? mov esi, eax
 83 ce 0f ?? or esi, 15
 83 fe fe ?? cmp esi, 0xfe<254,-2>
 76 04 ?? jbe basic block L3

L2: 8b f0 ?? mov esi, eax
 eb 27 ?? jmp basic block L6

L3: 8b 5f 14 ?? mov ebx, dword ds:[edi + 0x14<20>]
 b8 ab aa aa aa ?? mov eax, 0xaaaaaaab
 f7 e6 ?? mul esi
 8b cb ?? mov ecx, ebx
 d1 e9 ?? shr ecx, 1
 d1 ea ?? shr edx, 1
 3b ca ?? cmp ecx, edx
 76 13 ?? jbe basic block L6

L4: b8 fe ff ff ff ?? mov eax, 0xfffffffe<4294967294,-2>
 2b c1 ?? sub eax, ecx
 8d 34 19 ?? lea esi, ds:[ecx + ebx]
 3b d8 ?? cmp ebx, eax
 76 05 ?? jbe basic block L6

L5: be fe ff ff ff ?? mov esi, 0xfffffffe<4294967294,-2>

L6: 33 c0 ?? xor eax, eax
 8d 4e 01 ?? lea ecx, ds:[esi + 1]
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 3b c8 ?? cmp ecx, eax
 76 12 ?? jbe basic block L10

L7: 83 f9 ff ?? cmp ecx, 0xff<255,-1>
 77 12 ?? ja basic block L11

L8: 51 ?? push ecx
 e8 a5 07 00 00 ?? call function 0x00402334

L9: 83 c4 04 ?? add esp, 4
 85 c0 ?? test eax, eax
 74 05 ?? je basic block L11

L10: 89 45 08 ?? mov dword ss:[ebp + 8], eax
 eb 52 ?? jmp basic block L16

L11: 8d 4d e8 ?? lea ecx, ss:[ebp + 0xe8<232,-24>]
 51 ?? push ecx
 8d 4d d8 ?? lea ecx, ss:[ebp + 0xd8<216,-40>]
 c7 45 e8 00 00 00 00 ?? mov dword ss:[ebp + 0xe8<232,-24>], 0
 ff 15 54 93 40 00 ?? call dword ds:[function 0x00409354]

L12: 68 c0 72 40 00 ?? push 0x004072c0
 8d 55 d8 ?? lea edx, ss:[ebp + 0xd8<216,-40>]
 52 ?? push edx
 c7 45 d8 34 68 40 00 ?? mov dword ss:[ebp + 0xd8<216,-40>], 0x00406834
 e8 76 07 00 00 ?? call function 0x0040233a

L13: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
 89 45 e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], eax
 40 ?? inc eax
 89 65 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esp
 50 ?? push eax
 83 c1 18 ?? add ecx, 0x18<24>
 c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
 e8 40 f4 ff ff ?? call function 0x0040101e

L14: 89 45 08 ?? mov dword ss:[ebp + 8], eax
 b8 e7 1b 40 00 ?? mov eax, basic block L15
 c3 ?? ret

L15: 8b 7d ec ?? mov edi, dword ss:[ebp + 0xec<236,-20>]
 8b 75 e4 ?? mov esi, dword ss:[ebp + 0xe4<228,-28>]

L16: 8b 5d 0c ?? mov ebx, dword ss:[ebp + 12]
 85 db ?? test ebx, ebx
 74 1a ?? je basic block L22

L17: 83 7f 14 10 ?? cmp dword ds:[edi + 0x14<20>], 0x10<16>
 72 04 ?? jb basic block L19

L18: 8b 07 ?? mov eax, dword ds:[edi]
 eb 02 ?? jmp basic block L20

L19: 8b c7 ?? mov eax, edi

L20: 53 ?? push ebx
 50 ?? push eax
 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 50 ?? push eax
 e8 1d 07 00 00 ?? call function 0x00402328

L21: 83 c4 0c ?? add esp, 12

L22: 83 7f 14 10 ?? cmp dword ds:[edi + 0x14<20>], 0x10<16>
 72 0b ?? jb basic block L25

L23: 8b 0f ?? mov ecx, dword ds:[edi]
 51 ?? push ecx
 e8 06 07 00 00 ?? call function 0x00402322

L24: 83 c4 04 ?? add esp, 4

L25: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 c6 07 00 ?? mov byte ds:[edi], 0
 89 07 ?? mov dword ds:[edi], eax
 89 77 14 ?? mov dword ds:[edi + 0x14<20>], esi
 89 5f 10 ?? mov dword ds:[edi + 0x10<16>], ebx
 83 fe 10 ?? cmp esi, 0x10<16>
 72 02 ?? jb basic block L27

L26: 8b f8 ?? mov edi, eax

L27: c6 04 1f 00 ?? mov byte ds:[edi + ebx], 0
 8b 4d f4 ?? mov ecx, dword ss:[ebp + 0xf4<244,-12>]
 64 89 0d 00 00 00 00 ?? mov dword fs:[0], ecx
 59 ?? pop ecx
 5f ?? pop edi
 5e ?? pop esi
 5b ?? pop ebx
 8b e5 ?? mov esp, ebp
 5d ?? pop ebp
 c2 08 00 ?? ret 8

