
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 89 81 ff ff ?? call function 0x0040e097

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 b9 42 ff ff ?? call function 0x0040a1d7

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 44 f1 ff ff ?? call function 0x00415073

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 0x00415e1a

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 6b 44 00 ?? mov edx, dword ds:[0x00446bc0 + 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 da 80 ff ff ?? call function 0x0040e097

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 6b 44 00 ?? lea ebx, ds:[0x00446bc0 + 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 0x00415e1a

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 0x00415e1a

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

