Disassembly: 
  L1: 6a 54 ?? push 0x54<84>
   68 30 66 42 00 ?? push 0x00426630
   e8 91 03 00 00 ?? call function 0x00404b3c
  
  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 3c 92 42 00 ?? call dword ds:[0x0042923c]
  
  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 ac 1e 00 00 ?? call function 0x00406678
  
  L4: 59 ?? pop ecx
   59 ?? pop ecx
   3b c7 ?? cmp eax, edi
   0f 84 14 02 00 00 ?? je basic block L58
  
  L5: a3 80 8c 42 00 ?? mov dword ds:[0x00428c80], eax
   89 35 40 8c 42 00 ?? mov dword ds:[0x00428c40], 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 80 8c 42 00 ?? mov ecx, dword ds:[0x00428c80]
   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 1e 1e 00 00 ?? call function 0x00406678
  
  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 80 8c 42 00 ?? lea ecx, ds:[0x00428c80 + ecx * 4]
   89 01 ?? mov dword ds:[ecx], eax
   83 05 40 8c 42 00 20 ?? add dword ds:[0x00428c40], 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 40 8c 42 00 ?? cmp dword ds:[0x00428c40], edi
   7c 9d ?? jl basic block L13
  
  L20: eb 06 ?? jmp basic block L22
  
  L21: 8b 3d 40 8c 42 00 ?? mov edi, dword ds:[0x00428c40]
  
  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 38 92 42 00 ?? call dword ds:[0x00429238]
  
  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 80 8c 42 00 ?? add esi, dword ds:[0x00428c80 + 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 56 4b 00 00 ?? call function 0x0040946d
  
  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 80 8c 42 00 ?? add esi, dword ds:[0x00428c80]
   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 18 92 42 00 ?? call dword ds:[0x00429218]
  
  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 38 92 42 00 ?? call dword ds:[0x00429238]
  
  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 c0 4a 00 00 ?? call function 0x0040946d
  
  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 40 8c 42 00 ?? push dword ds:[0x00428c40]
   ff 15 34 92 42 00 ?? call dword ds:[0x00429234]
  
  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 8f 01 00 00 ?? call function 0x00404b81
  
  L60: c3 ?? ret
  
  