
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 b8 20 10 00 00 ?? mov eax, 0x00001020<4128>
 e8 91 e1 00 00 ?? call function 0x0041dd60

L2: a1 f0 43 43 00 ?? mov eax, dword ds:[0x004343f0]
 33 c5 ?? xor eax, ebp
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 53 ?? push ebx
 56 ?? push esi
 8b 75 08 ?? mov esi, dword ss:[ebp + 8]
 57 ?? push edi
 56 ?? push esi
 e8 db f4 ff ff ?? call function 0x0040f0c0

L3: 8b d8 ?? mov ebx, eax
 33 c0 ?? xor eax, eax
 39 46 04 ?? cmp dword ds:[esi + 4], eax
 59 ?? pop ecx
 89 9d e8 ef ff ff ?? mov dword ss:[ebp + 0xffffefe8<4294963176,-4120>], ebx
 7d 03 ?? jge basic block L5

L4: 89 46 04 ?? mov dword ds:[esi + 4], eax

L5: 6a 01 ?? push 1
 50 ?? push eax
 50 ?? push eax
 53 ?? push ebx
 e8 1b da 00 00 ?? call function 0x0041d61d

L6: 83 c4 10 ?? add esp, 0x10<16>
 8b f8 ?? mov edi, eax
 89 bd ec ef ff ff ?? mov dword ss:[ebp + 0xffffefec<4294963180,-4116>], edi
 89 95 f0 ef ff ff ?? mov dword ss:[ebp + 0xffffeff0<4294963184,-4112>], edx
 85 d2 ?? test edx, edx
 7f 10 ?? jg basic block L10

L7: 7c 04 ?? jl basic block L9

L8: 85 ff ?? test edi, edi
 73 0a ?? jae basic block L10

L9: 83 c8 ff ?? or eax, 0xff<255,-1>
 0b d0 ?? or edx, eax
 e9 d6 02 00 00 ?? jmp basic block L78

L10: 8b c3 ?? mov eax, ebx
 c1 f8 05 ?? sar eax, 5
 8d 04 85 a0 66 43 00 ?? lea eax, ds:[0x004366a0 + eax * 4]
 83 e3 1f ?? and ebx, 0x1f<31>
 89 85 e4 ef ff ff ?? mov dword ss:[ebp + 0xffffefe4<4294963172,-4124>], eax
 8b 00 ?? mov eax, dword ds:[eax]
 c1 e3 06 ?? shl ebx, 6
 03 c3 ?? add eax, ebx
 8a 48 24 ?? mov cl, byte ds:[eax + 0x24<36>]
 02 c9 ?? add cl, cl
 d0 f9 ?? sar cl, 1
 f7 46 0c 08 01 00 00 ?? test dword ds:[esi + 12], 0x00000108<264>
 88 8d fb ef ff ff ?? mov byte ss:[ebp + 0xffffeffb<4294963195,-4101>], cl
 75 17 ?? jne basic block L12

L11: 8b 46 04 ?? mov eax, dword ds:[esi + 4]
 8b 8d f0 ef ff ff ?? mov ecx, dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 99 ?? cdq
 2b f8 ?? sub edi, eax
 1b ca ?? sbb ecx, edx
 8b c7 ?? mov eax, edi
 8b d1 ?? mov edx, ecx
 e9 8d 02 00 00 ?? jmp basic block L78

L12: 8b 0e ?? mov ecx, dword ds:[esi]
 8b 56 08 ?? mov edx, dword ds:[esi + 8]
 8b f9 ?? mov edi, ecx
 2b fa ?? sub edi, edx
 8b 56 0c ?? mov edx, dword ds:[esi + 12]
 89 bd f4 ef ff ff ?? mov dword ss:[ebp + 0xffffeff4<4294963188,-4108>], edi
 f6 c2 03 ?? test dl, 3
 0f 84 5a 01 00 00 ?? je basic block L45

L13: 80 bd fb ef ff ff 01 ?? cmp byte ss:[ebp + 0xffffeffb<4294963195,-4101>], 1
 0f 85 19 01 00 00 ?? jne basic block L37

L14: 33 d2 ?? xor edx, edx
 39 50 30 ?? cmp dword ds:[eax + 0x30<48>], edx
 0f 84 0e 01 00 00 ?? je basic block L37

L15: d1 ef ?? shr edi, 1
 89 bd e0 ef ff ff ?? mov dword ss:[ebp + 0xffffefe0<4294963168,-4128>], edi
 39 56 04 ?? cmp dword ds:[esi + 4], edx
 75 11 ?? jne basic block L17

L16: 8b 85 ec ef ff ff ?? mov eax, dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 8b 95 f0 ef ff ff ?? mov edx, dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 e9 3c 02 00 00 ?? jmp basic block L78

L17: 52 ?? push edx
 ff 70 2c ?? push dword ds:[eax + 0x2c<44>]
 ff 70 28 ?? push dword ds:[eax + 0x28<40>]
 ff b5 e8 ef ff ff ?? push dword ss:[ebp + 0xffffefe8<4294963176,-4120>]
 e8 4a d9 00 00 ?? call function 0x0041d61d

L18: 8b f0 ?? mov esi, eax
 8b 85 e4 ef ff ff ?? mov eax, dword ss:[ebp + 0xffffefe4<4294963172,-4124>]
 8b 00 ?? mov eax, dword ds:[eax]
 03 c3 ?? add eax, ebx
 83 c4 10 ?? add esp, 0x10<16>
 8b fa ?? mov edi, edx
 3b 70 28 ?? cmp esi, dword ds:[eax + 0x28<40>]
 0f 85 30 ff ff ff ?? jne basic block L9

L19: 3b 78 2c ?? cmp edi, dword ds:[eax + 0x2c<44>]
 0f 85 27 ff ff ff ?? jne basic block L9

L20: 6a 00 ?? push 0
 8d 8d f4 ef ff ff ?? lea ecx, ss:[ebp + 0xffffeff4<4294963188,-4108>]
 51 ?? push ecx
 68 00 10 00 00 ?? push 0x00001000<4096>
 8d 8d fc ef ff ff ?? lea ecx, ss:[ebp + 0xffffeffc<4294963196,-4100>]
 51 ?? push ecx
 ff 30 ?? push dword ds:[eax]
 ff 15 d4 82 43 00 ?? call dword ds:[0x004382d4]

L21: 85 c0 ?? test eax, eax
 0f 84 02 ff ff ff ?? je basic block L9

L22: 6a 00 ?? push 0
 ff b5 f0 ef ff ff ?? push dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 ff b5 ec ef ff ff ?? push dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 ff b5 e8 ef ff ff ?? push dword ss:[ebp + 0xffffefe8<4294963176,-4120>]
 e8 e9 d8 00 00 ?? call function 0x0041d61d

L23: 83 c4 10 ?? add esp, 0x10<16>
 85 d2 ?? test edx, edx
 7f 0e ?? jg basic block L26

L24: 0f 8c dc fe ff ff ?? jl basic block L9

L25: 85 c0 ?? test eax, eax
 0f 82 d4 fe ff ff ?? jb basic block L9

L26: 8b 8d f4 ef ff ff ?? mov ecx, dword ss:[ebp + 0xffffeff4<4294963188,-4108>]
 8b 9d e0 ef ff ff ?? mov ebx, dword ss:[ebp + 0xffffefe0<4294963168,-4128>]
 3b d9 ?? cmp ebx, ecx
 0f 87 c0 fe ff ff ?? ja basic block L9

L27: 8d 85 fc ef ff ff ?? lea eax, ss:[ebp + 0xffffeffc<4294963196,-4100>]
 85 db ?? test ebx, ebx
 74 37 ?? je basic block L36

L28: 8d 94 0d fc ef ff ff ?? lea edx, ss:[ebp + ecx + 0xffffeffc<4294963196,-4100>]

L29: 4b ?? dec ebx
 3b c2 ?? cmp eax, edx
 73 2b ?? jae basic block L36

L30: 8a 08 ?? mov cl, byte ds:[eax]
 80 f9 0d ?? cmp cl, 13
 75 13 ?? jne basic block L34

L31: 8d 4a ff ?? lea ecx, ds:[edx + 0xff<255,-1>]
 3b c1 ?? cmp eax, ecx
 73 18 ?? jae basic block L35

L32: 8d 48 01 ?? lea ecx, ds:[eax + 1]
 80 39 0a ?? cmp byte ds:[ecx], 10
 75 10 ?? jne basic block L35

L33: 8b c1 ?? mov eax, ecx
 eb 0c ?? jmp basic block L35

L34: 0f b6 c9 ?? movzx ecx, cl
 0f be 89 38 52 43 00 ?? movsx ecx, byte ds:[ecx + 0x00435238]
 03 c1 ?? add eax, ecx

L35: 40 ?? inc eax
 85 db ?? test ebx, ebx
 75 d0 ?? jne basic block L29

L36: 8d 8d fc ef ff ff ?? lea ecx, ss:[ebp + 0xffffeffc<4294963196,-4100>]
 2b c1 ?? sub eax, ecx
 33 d2 ?? xor edx, edx
 03 c6 ?? add eax, esi
 13 d7 ?? adc edx, edi
 e9 4c 01 00 00 ?? jmp basic block L78

L37: f6 40 04 80 ?? test byte ds:[eax + 4], 0x80<128,-128>
 74 15 ?? je basic block L43

L38: 8b 56 08 ?? mov edx, dword ds:[esi + 8]
 eb 0c ?? jmp basic block L42

L39: 80 3a 0a ?? cmp byte ds:[edx], 10
 75 06 ?? jne basic block L41

L40: ff 85 f4 ef ff ff ?? inc dword ss:[ebp + 0xffffeff4<4294963188,-4108>]

L41: 42 ?? inc edx

L42: 3b d1 ?? cmp edx, ecx
 72 f0 ?? jb basic block L39

L43: 8b 95 ec ef ff ff ?? mov edx, dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 0b 95 f0 ef ff ff ?? or edx, dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 75 1f ?? jne basic block L48

L44: 8b 85 f4 ef ff ff ?? mov eax, dword ss:[ebp + 0xffffeff4<4294963188,-4108>]
 e9 18 01 00 00 ?? jmp basic block L78

L45: 84 d2 ?? test dl, dl
 78 e3 ?? js basic block L43

L46: e8 34 c7 ff ff ?? call function 0x0040c522

L47: c7 00 16 00 00 00 ?? mov dword ds:[eax], 0x00000016<22>
 e9 24 fe ff ff ?? jmp basic block L9

L48: f6 46 0c 01 ?? test byte ds:[esi + 12], 1
 0f 84 d7 00 00 00 ?? je basic block L75

L49: 8b 56 04 ?? mov edx, dword ds:[esi + 4]
 85 d2 ?? test edx, edx
 75 0b ?? jne basic block L51

L50: 21 95 f4 ef ff ff ?? and dword ss:[ebp + 0xffffeff4<4294963188,-4108>], edx
 e9 c5 00 00 00 ?? jmp basic block L75

L51: 2b 4e 08 ?? sub ecx, dword ds:[esi + 8]
 03 ca ?? add ecx, edx
 f6 40 04 80 ?? test byte ds:[eax + 4], 0x80<128,-128>
 8b f9 ?? mov edi, ecx
 0f 84 9c 00 00 00 ?? je basic block L72

L52: 6a 02 ?? push 2
 6a 00 ?? push 0
 6a 00 ?? push 0
 ff b5 e8 ef ff ff ?? push dword ss:[ebp + 0xffffefe8<4294963176,-4120>]
 e8 e6 d7 00 00 ?? call function 0x0041d61d

L53: 83 c4 10 ?? add esp, 0x10<16>
 3b 85 ec ef ff ff ?? cmp eax, dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 75 24 ?? jne basic block L61

L54: 3b 95 f0 ef ff ff ?? cmp edx, dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 75 1c ?? jne basic block L61

L55: 8b 46 08 ?? mov eax, dword ds:[esi + 8]
 8d 0c 38 ?? lea ecx, ds:[eax + edi]
 eb 07 ?? jmp basic block L59

L56: 80 38 0a ?? cmp byte ds:[eax], 10
 75 01 ?? jne basic block L58

L57: 47 ?? inc edi

L58: 40 ?? inc eax

L59: 3b c1 ?? cmp eax, ecx
 72 f5 ?? jb basic block L56

L60: f7 46 0c 00 20 00 00 ?? test dword ds:[esi + 12], 0x00002000<8192>
 eb 59 ?? jmp basic block L70

L61: 6a 00 ?? push 0
 ff b5 f0 ef ff ff ?? push dword ss:[ebp + 0xffffeff0<4294963184,-4112>]
 ff b5 ec ef ff ff ?? push dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 ff b5 e8 ef ff ff ?? push dword ss:[ebp + 0xffffefe8<4294963176,-4120>]
 e8 9e d7 00 00 ?? call function 0x0041d61d

L62: 83 c4 10 ?? add esp, 0x10<16>
 85 d2 ?? test edx, edx
 7f 0e ?? jg basic block L65

L63: 0f 8c 91 fd ff ff ?? jl basic block L9

L64: 85 c0 ?? test eax, eax
 0f 82 89 fd ff ff ?? jb basic block L9

L65: b8 00 02 00 00 ?? mov eax, 0x00000200<512>
 3b f8 ?? cmp edi, eax
 77 12 ?? ja basic block L68

L66: 8b 4e 0c ?? mov ecx, dword ds:[esi + 12]
 f6 c1 08 ?? test cl, 8
 74 0a ?? je basic block L68

L67: 8b f8 ?? mov edi, eax
 f7 c1 00 04 00 00 ?? test ecx, 0x00000400<1024>
 74 03 ?? je basic block L69

L68: 8b 7e 18 ?? mov edi, dword ds:[esi + 0x18<24>]

L69: 8b 85 e4 ef ff ff ?? mov eax, dword ss:[ebp + 0xffffefe4<4294963172,-4124>]
 8b 00 ?? mov eax, dword ds:[eax]
 f6 44 18 04 04 ?? test byte ds:[eax + ebx + 4], 4

L70: 74 01 ?? je basic block L72

L71: 47 ?? inc edi

L72: 80 bd fb ef ff ff 01 ?? cmp byte ss:[ebp + 0xffffeffb<4294963195,-4101>], 1
 75 02 ?? jne basic block L74

L73: d1 ef ?? shr edi, 1

L74: 29 bd ec ef ff ff ?? sub dword ss:[ebp + 0xffffefec<4294963180,-4116>], edi
 83 9d f0 ef ff ff 00 ?? sbb dword ss:[ebp + 0xffffeff0<4294963184,-4112>], 0

L75: 80 bd fb ef ff ff 01 ?? cmp byte ss:[ebp + 0xffffeffb<4294963195,-4101>], 1
 75 06 ?? jne basic block L77

L76: d1 ad f4 ef ff ff ?? shr dword ss:[ebp + 0xffffeff4<4294963188,-4108>], 1

L77: 8b 85 f4 ef ff ff ?? mov eax, dword ss:[ebp + 0xffffeff4<4294963188,-4108>]
 33 d2 ?? xor edx, edx
 03 85 ec ef ff ff ?? add eax, dword ss:[ebp + 0xffffefec<4294963180,-4116>]
 13 95 f0 ef ff ff ?? adc edx, dword ss:[ebp + 0xffffeff0<4294963184,-4112>]

L78: 8b 4d fc ?? mov ecx, dword ss:[ebp + 0xfc<252,-4>]
 5f ?? pop edi
 5e ?? pop esi
 33 cd ?? xor ecx, ebp
 5b ?? pop ebx
 e8 84 61 ff ff ?? call function 0x0040608e

L79: c9 ?? leave
 c3 ?? ret

