
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 83 ec 18 ?? sub esp, 0x18<24>
 8b 45 fc ?? mov eax, dword ss:[ebp + 0xfc<252,-4>]
 ba 00 00 ff ff ?? mov edx, 0xffff0000<4294901760,-65536>
 21 55 fc ?? and dword ss:[ebp + 0xfc<252,-4>], edx
 33 c9 ?? xor ecx, ecx
 21 4d f8 ?? and dword ss:[ebp + 0xf8<248,-8>], ecx
 23 c2 ?? and eax, edx
 8b 15 e4 9a 42 00 ?? mov edx, dword ds:[0x00429ae4]
 85 d2 ?? test edx, edx
 74 63 ?? je basic block L14

L2: 80 3a 3f ?? cmp byte ds:[edx], 0x3f<63>
 75 4f ?? jne basic block L11

L3: 8a 42 01 ?? mov al, byte ds:[edx + 1]
 3c 40 ?? cmp al, 0x40<64>
 75 24 ?? jne basic block L7

L4: 83 05 e0 9a 42 00 02 ?? add dword ds:[0x00429ae0], 2
 8d 45 f0 ?? lea eax, ss:[ebp + 0xf0<240,-16>]
 50 ?? push eax
 e8 1d f3 ff ff ?? call function 0x0040ea6b

L5: 50 ?? push eax
 8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
 68 68 4e 42 00 ?? push 0x00424e68<"CV: ">
 50 ?? push eax
 e8 c0 cc ff ff ?? call function 0x0040c41d

L6: 83 c4 10 ?? add esp, 0x10<16>
 eb 2e ?? jmp basic block L13

L7: 3c 24 ?? cmp al, 0x24<36>
 75 20 ?? jne basic block L11

L8: 8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
 6a 00 ?? push 0
 50 ?? push eax
 e8 55 e1 ff ff ?? call function 0x0040d8c6

L9: 59 ?? pop ecx
 59 ?? pop ecx
 8b 08 ?? mov ecx, dword ds:[eax]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]
 3c 02 ?? cmp al, 2
 75 19 ?? jne basic block L14

L10: a1 e4 9a 42 00 ?? mov eax, dword ds:[0x00429ae4]
 a3 e0 9a 42 00 ?? mov dword ds:[0x00429ae0], eax

L11: 8d 45 e8 ?? lea eax, ss:[ebp + 0xe8<232,-24>]
 50 ?? push eax
 e8 dc f2 ff ff ?? call function 0x0040ea6b

L12: 59 ?? pop ecx

L13: 8b 08 ?? mov ecx, dword ds:[eax]
 8b 40 04 ?? mov eax, dword ds:[eax + 4]

L14: 3c 03 ?? cmp al, 3
 75 04 ?? jne basic block L16

L15: 33 c0 ?? xor eax, eax
 c9 ?? leave
 c3 ?? ret

L16: 3c 02 ?? cmp al, 2
 74 1f ?? je basic block L20

L17: f7 05 f0 9a 42 00 00 10 ?? test dword ds:[0x00429af0], 0x00001000<4096>
 00 00
 75 0b ?? jne basic block L19

L18: 8b 15 e0 9a 42 00 ?? mov edx, dword ds:[0x00429ae0]
 80 3a 00 ?? cmp byte ds:[edx], 0
 75 08 ?? jne basic block L20

L19: 89 4d f8 ?? mov dword ss:[ebp + 0xf8<248,-8>], ecx
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 eb 0e ?? jmp basic block L21

L20: ff 35 e4 9a 42 00 ?? push dword ds:[0x00429ae4]
 8d 4d f8 ?? lea ecx, ss:[ebp + 0xf8<248,-8>]
 e8 9b c8 ff ff ?? call function 0x0040c069

L21: a1 e8 9a 42 00 ?? mov eax, dword ds:[0x00429ae8]
 85 c0 ?? test eax, eax
 75 28 ?? jne basic block L26

L22: 8b 4d f8 ?? mov ecx, dword ss:[ebp + 0xf8<248,-8>]
 85 c9 ?? test ecx, ecx
 74 04 ?? je basic block L24

L23: 8b 01 ?? mov eax, dword ds:[ecx]
 ff 10 ?? call dword ds:[eax]

L24: 40 ?? inc eax
 a3 ec 9a 42 00 ?? mov dword ds:[0x00429aec], eax
 83 c0 07 ?? add eax, 7
 83 e0 f8 ?? and eax, 0xf8<248,-8>
 50 ?? push eax
 ff 15 c0 9a 42 00 ?? call dword ds:[0x00429ac0]

L25: 59 ?? pop ecx
 a3 e8 9a 42 00 ?? mov dword ds:[0x00429ae8], eax
 85 c0 ?? test eax, eax
 74 3e ?? je basic block L36

L26: ff 35 ec 9a 42 00 ?? push dword ds:[0x00429aec]
 8d 4d f8 ?? lea ecx, ss:[ebp + 0xf8<248,-8>]
 50 ?? push eax
 e8 d8 c1 ff ff ?? call function 0x0040b9e6

L27: a1 e8 9a 42 00 ?? mov eax, dword ds:[0x00429ae8]
 8b d0 ?? mov edx, eax
 eb 17 ?? jmp basic block L34

L28: 80 f9 20 ?? cmp cl, 0x20<32>
 75 0e ?? jne basic block L33

L29: 40 ?? inc eax
 88 0a ?? mov byte ds:[edx], cl
 42 ?? inc edx
 eb 01 ?? jmp basic block L31

L30: 40 ?? inc eax

L31: 80 38 20 ?? cmp byte ds:[eax], 0x20<32>
 74 fa ?? je basic block L30

L32: eb 04 ?? jmp basic block L34

L33: 88 0a ?? mov byte ds:[edx], cl
 42 ?? inc edx
 40 ?? inc eax

L34: 8a 08 ?? mov cl, byte ds:[eax]
 84 c9 ?? test cl, cl
 75 e3 ?? jne basic block L28

L35: 8a c1 ?? mov al, cl
 88 02 ?? mov byte ds:[edx], al
 a1 e8 9a 42 00 ?? mov eax, dword ds:[0x00429ae8]

L36: c9 ?? leave
 c3 ?? ret

