
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 81 ec 1c 05 00 00 ?? sub esp, 0x0000051c<1308>
 a1 10 33 42 00 ?? mov eax, dword ds:[0x00423310]
 33 c5 ?? xor eax, ebp
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 53 ?? push ebx
 57 ?? push edi
 8d 85 e8 fa ff ff ?? lea eax, ss:[ebp + 0xfffffae8<4294965992,-1304>]
 50 ?? push eax
 ff 76 04 ?? push dword ds:[esi + 4]
 ff 15 78 52 42 00 ?? call dword ds:[0x00425278]

L2: bf 00 01 00 00 ?? mov edi, 0x00000100<256>
 85 c0 ?? test eax, eax
 0f 84 fb 00 00 00 ?? je basic block L24

L3: 33 c0 ?? xor eax, eax

L4: 88 84 05 fc fe ff ff ?? mov byte ss:[ebp + eax + 0xfffffefc<4294967036,-260>], al
 40 ?? inc eax
 3b c7 ?? cmp eax, edi

L5: 72 f4 ?? jb basic block L4

L6: 8a 85 ee fa ff ff ?? mov al, byte ss:[ebp + 0xfffffaee<4294965998,-1298>]
 c6 85 fc fe ff ff 20 ?? mov byte ss:[ebp + 0xfffffefc<4294967036,-260>], 0x20<32>
 84 c0 ?? test al, al
 74 2e ?? je basic block L12

L7: 8d 9d ef fa ff ff ?? lea ebx, ss:[ebp + 0xfffffaef<4294965999,-1297>]

L8: 0f b6 c8 ?? movzx ecx, al
 0f b6 03 ?? movzx eax, byte ds:[ebx]
 3b c8 ?? cmp ecx, eax
 77 16 ?? ja basic block L11

L9: 2b c1 ?? sub eax, ecx
 40 ?? inc eax
 50 ?? push eax
 8d 94 0d fc fe ff ff ?? lea edx, ss:[ebp + ecx + 0xfffffefc<4294967036,-260>]
 6a 20 ?? push 0x20<32>
 52 ?? push edx
 e8 b8 2f 00 00 ?? call function 0x0040d050

L10: 83 c4 0c ?? add esp, 12

L11: 43 ?? inc ebx
 8a 03 ?? mov al, byte ds:[ebx]
 43 ?? inc ebx
 84 c0 ?? test al, al
 75 d8 ?? jne basic block L8

L12: 6a 00 ?? push 0
 ff 76 0c ?? push dword ds:[esi + 12]
 8d 85 fc fa ff ff ?? lea eax, ss:[ebp + 0xfffffafc<4294966012,-1284>]
 ff 76 04 ?? push dword ds:[esi + 4]
 50 ?? push eax
 57 ?? push edi
 8d 85 fc fe ff ff ?? lea eax, ss:[ebp + 0xfffffefc<4294967036,-260>]
 50 ?? push eax
 6a 01 ?? push 1
 6a 00 ?? push 0
 e8 82 46 00 00 ?? call function 0x0040e745

L13: 33 db ?? xor ebx, ebx
 53 ?? push ebx
 ff 76 04 ?? push dword ds:[esi + 4]
 8d 85 fc fd ff ff ?? lea eax, ss:[ebp + 0xfffffdfc<4294966780,-516>]
 57 ?? push edi
 50 ?? push eax
 57 ?? push edi
 8d 85 fc fe ff ff ?? lea eax, ss:[ebp + 0xfffffefc<4294967036,-260>]
 50 ?? push eax
 57 ?? push edi
 ff 76 0c ?? push dword ds:[esi + 12]
 53 ?? push ebx
 e8 63 44 00 00 ?? call function 0x0040e546

L14: 83 c4 44 ?? add esp, 0x44<68>
 53 ?? push ebx
 ff 76 04 ?? push dword ds:[esi + 4]
 8d 85 fc fc ff ff ?? lea eax, ss:[ebp + 0xfffffcfc<4294966524,-772>]
 57 ?? push edi
 50 ?? push eax
 57 ?? push edi
 8d 85 fc fe ff ff ?? lea eax, ss:[ebp + 0xfffffefc<4294967036,-260>]
 50 ?? push eax
 68 00 02 00 00 ?? push 0x00000200<512>
 ff 76 0c ?? push dword ds:[esi + 12]
 53 ?? push ebx
 e8 3e 44 00 00 ?? call function 0x0040e546

L15: 83 c4 24 ?? add esp, 0x24<36>
 33 c0 ?? xor eax, eax

L16: 0f b7 8c 45 fc fa ff ff ?? movzx ecx, word ss:[ebp + 0xfffffafc<4294966012,-1284> + eax * 2]
 f6 c1 01 ?? test cl, 1
 74 0e ?? je basic block L18

L17: 80 4c 06 1d 10 ?? or byte ds:[esi + eax + 0x1d<29>], 0x10<16>
 8a 8c 05 fc fd ff ff ?? mov cl, byte ss:[ebp + eax + 0xfffffdfc<4294966780,-516>]
 eb 11 ?? jmp basic block L20

L18: f6 c1 02 ?? test cl, 2
 74 15 ?? je basic block L21

L19: 80 4c 06 1d 20 ?? or byte ds:[esi + eax + 0x1d<29>], 0x20<32>
 8a 8c 05 fc fc ff ff ?? mov cl, byte ss:[ebp + eax + 0xfffffcfc<4294966524,-772>]

L20: 88 8c 06 1d 01 00 00 ?? mov byte ds:[esi + eax + 0x0000011d<285>], cl
 eb 08 ?? jmp basic block L22

L21: c6 84 06 1d 01 00 00 00 ?? mov byte ds:[esi + eax + 0x0000011d<285>], 0

L22: 40 ?? inc eax
 3b c7 ?? cmp eax, edi
 72 be ?? jb basic block L16

L23: eb 56 ?? jmp basic block L32

L24: 8d 86 1d 01 00 00 ?? lea eax, ds:[esi + 0x0000011d<285>]
 c7 85 e4 fa ff ff 9f ff ?? mov dword ss:[ebp + 0xfffffae4<4294965988,-1308>], 0xffffff9f<4294967199,-97>
 ff ff
 33 c9 ?? xor ecx, ecx
 29 85 e4 fa ff ff ?? sub dword ss:[ebp + 0xfffffae4<4294965988,-1308>], eax

L25: 8b 95 e4 fa ff ff ?? mov edx, dword ss:[ebp + 0xfffffae4<4294965988,-1308>]
 8d 84 0e 1d 01 00 00 ?? lea eax, ds:[esi + ecx + 0x0000011d<285>]
 03 d0 ?? add edx, eax
 8d 5a 20 ?? lea ebx, ds:[edx + 0x20<32>]
 83 fb 19 ?? cmp ebx, 0x19<25>
 77 0c ?? ja basic block L27

L26: 80 4c 0e 1d 10 ?? or byte ds:[esi + ecx + 0x1d<29>], 0x10<16>
 8a d1 ?? mov dl, cl
 80 c2 20 ?? add dl, 0x20<32>
 eb 0f ?? jmp basic block L29

L27: 83 fa 19 ?? cmp edx, 0x19<25>
 77 0e ?? ja basic block L30

L28: 80 4c 0e 1d 20 ?? or byte ds:[esi + ecx + 0x1d<29>], 0x20<32>
 8a d1 ?? mov dl, cl
 80 ea 20 ?? sub dl, 0x20<32>

L29: 88 10 ?? mov byte ds:[eax], dl
 eb 03 ?? jmp basic block L31

L30: c6 00 00 ?? mov byte ds:[eax], 0

L31: 41 ?? inc ecx
 3b cf ?? cmp ecx, edi
 72 c2 ?? jb basic block L25

L32: 8b 4d fc ?? mov ecx, dword ss:[ebp + 0xfc<252,-4>]
 5f ?? pop edi
 33 cd ?? xor ecx, ebp
 5b ?? pop ebx
 e8 7a 2e 00 00 ?? call function 0x0040d02d

L33: c9 ?? leave
 c3 ?? ret

