Disassembly: 
  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 3c 70 42 00 ?? mov eax, dword ds:[0x0042703c]
   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 92 42 00 ?? call dword ds:[0x00429278]
  
  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 d8 99 00 00 ?? call function 0x00411a50
  
  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 c3 cf 00 00 ?? call function 0x00415066
  
  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 b0 d4 00 00 ?? call function 0x00415573
  
  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 8b d4 00 00 ?? call function 0x00415573
  
  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 91 95 ff ff ?? call function 0x00401724
  
  L33: c9 ?? leave
   c3 ?? ret
  
  