Disassembly: 
  L1: 8b ff ?? mov edi, edi
   55 ?? push ebp
   8b ec ?? mov ebp, esp
   83 ec 0c ?? sub esp, 12
   53 ?? push ebx
   57 ?? push edi
   8b 7d 08 ?? mov edi, dword ss:[ebp + 8]
   33 db ?? xor ebx, ebx
   3b fb ?? cmp edi, ebx
   75 20 ?? jne basic block L6
  
  L2: e8 6d c6 ff ff ?? call function 0x0040c7ec
  
  L3: 53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   53 ?? push ebx
   c7 00 16 00 00 00 ?? mov dword ds:[eax], 0x00000016<22>
   e8 51 67 ff ff ?? call function 0x004068e0
  
  L4: 83 c4 14 ?? add esp, 0x14<20>
  
  L5: 83 c8 ff ?? or eax, 0xff<255,-1>
   e9 66 01 00 00 ?? jmp basic block L50
  
  L6: 57 ?? push edi
   e8 e0 ef ff ff ?? call function 0x0040f180
  
  L7: 39 5f 04 ?? cmp dword ds:[edi + 4], ebx
   59 ?? pop ecx
   89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
   7d 03 ?? jge basic block L9
  
  L8: 89 5f 04 ?? mov dword ds:[edi + 4], ebx
  
  L9: 6a 01 ?? push 1
   53 ?? push ebx
   50 ?? push eax
   e8 d6 fe ff ff ?? call function 0x0041008b
  
  L10: 83 c4 0c ?? add esp, 12
   3b c3 ?? cmp eax, ebx
   89 45 f8 ?? mov dword ss:[ebp + 0xf8<248,-8>], eax
   7c d3 ?? jl basic block L5
  
  L11: 8b 57 0c ?? mov edx, dword ds:[edi + 12]
   f7 c2 08 01 00 00 ?? test edx, 0x00000108<264>
   75 08 ?? jne basic block L13
  
  L12: 2b 47 04 ?? sub eax, dword ds:[edi + 4]
   e9 2e 01 00 00 ?? jmp basic block L50
  
  L13: 8b 07 ?? mov eax, dword ds:[edi]
   8b 4f 08 ?? mov ecx, dword ds:[edi + 8]
   56 ?? push esi
   8b f0 ?? mov esi, eax
   2b f1 ?? sub esi, ecx
   89 75 f4 ?? mov dword ss:[ebp + 0xf4<244,-12>], esi
   f6 c2 03 ?? test dl, 3
   74 41 ?? je basic block L22
  
  L14: 8b 55 fc ?? mov edx, dword ss:[ebp + 0xfc<252,-4>]
   8b 75 fc ?? mov esi, dword ss:[ebp + 0xfc<252,-4>]
   c1 fa 05 ?? sar edx, 5
   8b 14 95 c0 66 43 00 ?? mov edx, dword ds:[0x004366c0 + edx * 4]
   83 e6 1f ?? and esi, 0x1f<31>
   c1 e6 06 ?? shl esi, 6
   f6 44 32 04 80 ?? test byte ds:[edx + esi + 4], 0x80<128,-128>
   74 17 ?? je basic block L20
  
  L15: 8b d1 ?? mov edx, ecx
   3b d0 ?? cmp edx, eax
   73 11 ?? jae basic block L20
  
  L16: 8b f0 ?? mov esi, eax
  
  L17: 80 3a 0a ?? cmp byte ds:[edx], 10
   75 05 ?? jne basic block L19
  
  L18: ff 45 f4 ?? inc dword ss:[ebp + 0xf4<244,-12>]
   33 db ?? xor ebx, ebx
  
  L19: 42 ?? inc edx
   3b d6 ?? cmp edx, esi
   72 f1 ?? jb basic block L17
  
  L20: 39 5d f8 ?? cmp dword ss:[ebp + 0xf8<248,-8>], ebx
   75 1c ?? jne basic block L25
  
  L21: 8b 45 f4 ?? mov eax, dword ss:[ebp + 0xf4<244,-12>]
   e9 da 00 00 00 ?? jmp basic block L49
  
  L22: 84 d2 ?? test dl, dl
   78 ef ?? js basic block L20
  
  L23: e8 be c5 ff ff ?? call function 0x0040c7ec
  
  L24: c7 00 16 00 00 00 ?? mov dword ds:[eax], 0x00000016<22>
   e9 87 00 00 00 ?? jmp basic block L39
  
  L25: f6 47 0c 01 ?? test byte ds:[edi + 12], 1
   0f 84 b4 00 00 00 ?? je basic block L48
  
  L26: 8b 57 04 ?? mov edx, dword ds:[edi + 4]
   3b d3 ?? cmp edx, ebx
   75 08 ?? jne basic block L28
  
  L27: 89 5d f4 ?? mov dword ss:[ebp + 0xf4<244,-12>], ebx
   e9 a5 00 00 00 ?? jmp basic block L48
  
  L28: 8b 5d fc ?? mov ebx, dword ss:[ebp + 0xfc<252,-4>]
   8b 75 fc ?? mov esi, dword ss:[ebp + 0xfc<252,-4>]
   2b c1 ?? sub eax, ecx
   03 c2 ?? add eax, edx
   c1 fb 05 ?? sar ebx, 5
   83 e6 1f ?? and esi, 0x1f<31>
   8d 1c 9d c0 66 43 00 ?? lea ebx, ds:[0x004366c0 + ebx * 4]
   89 45 08 ?? mov dword ss:[ebp + 8], eax
   8b 03 ?? mov eax, dword ds:[ebx]
   c1 e6 06 ?? shl esi, 6
   f6 44 30 04 80 ?? test byte ds:[eax + esi + 4], 0x80<128,-128>
   74 79 ?? je basic block L47
  
  L29: 6a 02 ?? push 2
   6a 00 ?? push 0
   ff 75 fc ?? push dword ss:[ebp + 0xfc<252,-4>]
   e8 07 fe ff ff ?? call function 0x0041008b
  
  L30: 83 c4 0c ?? add esp, 12
   3b 45 f8 ?? cmp eax, dword ss:[ebp + 0xf8<248,-8>]
   75 20 ?? jne basic block L37
  
  L31: 8b 47 08 ?? mov eax, dword ds:[edi + 8]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 c8 ?? add ecx, eax
   eb 09 ?? jmp basic block L35
  
  L32: 80 38 0a ?? cmp byte ds:[eax], 10
   75 03 ?? jne basic block L34
  
  L33: ff 45 08 ?? inc dword ss:[ebp + 8]
  
  L34: 40 ?? inc eax
  
  L35: 3b c1 ?? cmp eax, ecx
   72 f3 ?? jb basic block L32
  
  L36: f7 47 0c 00 20 00 00 ?? test dword ds:[edi + 12], 0x00002000<8192>
   eb 40 ?? jmp basic block L45
  
  L37: 6a 00 ?? push 0
   ff 75 f8 ?? push dword ss:[ebp + 0xf8<248,-8>]
   ff 75 fc ?? push dword ss:[ebp + 0xfc<252,-4>]
   e8 d2 fd ff ff ?? call function 0x0041008b
  
  L38: 83 c4 0c ?? add esp, 12
   85 c0 ?? test eax, eax
   7d 05 ?? jge basic block L40
  
  L39: 83 c8 ff ?? or eax, 0xff<255,-1>
   eb 3a ?? jmp basic block L49
  
  L40: b8 00 02 00 00 ?? mov eax, 0x00000200<512>
   39 45 08 ?? cmp dword ss:[ebp + 8], eax
   77 10 ?? ja basic block L43
  
  L41: 8b 4f 0c ?? mov ecx, dword ds:[edi + 12]
   f6 c1 08 ?? test cl, 8
   74 08 ?? je basic block L43
  
  L42: f7 c1 00 04 00 00 ?? test ecx, 0x00000400<1024>
   74 03 ?? je basic block L44
  
  L43: 8b 47 18 ?? mov eax, dword ds:[edi + 0x18<24>]
  
  L44: 89 45 08 ?? mov dword ss:[ebp + 8], eax
   8b 03 ?? mov eax, dword ds:[ebx]
   f6 44 30 04 04 ?? test byte ds:[eax + esi + 4], 4
  
  L45: 74 03 ?? je basic block L47
  
  L46: ff 45 08 ?? inc dword ss:[ebp + 8]
  
  L47: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   29 45 f8 ?? sub dword ss:[ebp + 0xf8<248,-8>], eax
  
  L48: 8b 45 f4 ?? mov eax, dword ss:[ebp + 0xf4<244,-12>]
   8b 4d f8 ?? mov ecx, dword ss:[ebp + 0xf8<248,-8>]
   03 c1 ?? add eax, ecx
  
  L49: 5e ?? pop esi
  
  L50: 5f ?? pop edi
   5b ?? pop ebx
   c9 ?? leave
   c3 ?? ret
  
  