Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 30 84 43 00 ?? push 0x00438430
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   83 ec 70 ?? sub esp, 0x70<112>
   a1 44 44 44 00 ?? mov eax, dword ds:[0x00444444]
   33 c5 ?? xor eax, ebp
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   50 ?? push eax
   8d 45 f4 ?? lea eax, ss:[ebp + 0xf4<244,-12>]
   64 a3 00 00 00 00 ?? mov dword fs:[0], eax
   8d 45 b8 ?? lea eax, ss:[ebp + 0xb8<184,-72>]
   50 ?? push eax
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 fa b7 ff ff ?? call function 0x004010be
  
  L2: 89 45 94 ?? mov dword ss:[ebp + 0x94<148,-108>], eax
   8b 4d 94 ?? mov ecx, dword ss:[ebp + 0x94<148,-108>]
   89 4d 90 ?? mov dword ss:[ebp + 0x90<144,-112>], ecx
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8b 55 90 ?? mov edx, dword ss:[ebp + 0x90<144,-112>]
   52 ?? push edx
   e8 8c b7 ff ff ?? call function 0x00401069
  
  L3: 83 c4 04 ?? add esp, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d b8 ?? lea ecx, ss:[ebp + 0xb8<184,-72>]
   e8 4f b7 ff ff ?? call function 0x00401041
  
  L4: 8d 45 c4 ?? lea eax, ss:[ebp + 0xc4<196,-60>]
   50 ?? push eax
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   e8 fb b8 ff ff ?? call function 0x004011f9
  
  L5: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   0f be 11 ?? movsx edx, byte ds:[ecx]
   83 fa 2b ?? cmp edx, 0x2b<43>
   74 46 ?? je basic block L13
  
  L6: 8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   0f be 08 ?? movsx ecx, byte ds:[eax]
   83 f9 2d ?? cmp ecx, 0x2d<45>
   74 3b ?? je basic block L13
  
  L7: 8b 55 20 ?? mov edx, dword ss:[ebp + 0x20<32>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   83 f8 30 ?? cmp eax, 0x30<48>
   75 21 ?? jne basic block L11
  
  L8: 8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   0f be 51 01 ?? movsx edx, byte ds:[ecx + 1]
   83 fa 78 ?? cmp edx, 0x78<120>
   74 0c ?? je basic block L10
  
  L9: 8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   0f be 48 01 ?? movsx ecx, byte ds:[eax + 1]
   83 f9 58 ?? cmp ecx, 0x58<88>
   75 09 ?? jne basic block L11
  
  L10: c7 45 8c 02 00 00 00 ?? mov dword ss:[ebp + 0x8c<140,-116>], 2
   eb 07 ?? jmp basic block L12
  
  L11: c7 45 8c 00 00 00 00 ?? mov dword ss:[ebp + 0x8c<140,-116>], 0
  
  L12: 8b 55 8c ?? mov edx, dword ss:[ebp + 0x8c<140,-116>]
   89 55 88 ?? mov dword ss:[ebp + 0x88<136,-120>], edx
   eb 07 ?? jmp basic block L14
  
  L13: c7 45 88 01 00 00 00 ?? mov dword ss:[ebp + 0x88<136,-120>], 1
  
  L14: 8b 45 88 ?? mov eax, dword ss:[ebp + 0x88<136,-120>]
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   8d 4d c4 ?? lea ecx, ss:[ebp + 0xc4<196,-60>]
   e8 70 b8 ff ff ?? call function 0x004011db
  
  L15: 0f be 08 ?? movsx ecx, byte ds:[eax]
   83 f9 7f ?? cmp ecx, 0x7f<127>
   0f 84 b4 00 00 00 ?? je basic block L27
  
  L16: 8d 4d c4 ?? lea ecx, ss:[ebp + 0xc4<196,-60>]
   e8 5c b8 ff ff ?? call function 0x004011db
  
  L17: 0f be 10 ?? movsx edx, byte ds:[eax]
   85 d2 ?? test edx, edx
   0f 8e a1 00 00 00 ?? jle basic block L27
  
  L18: 8d 4d c4 ?? lea ecx, ss:[ebp + 0xc4<196,-60>]
   e8 49 b8 ff ff ?? call function 0x004011db
  
  L19: 89 45 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], eax
   8b 45 24 ?? mov eax, dword ss:[ebp + 0x24<36>]
   89 45 bc ?? mov dword ss:[ebp + 0xbc<188,-68>], eax
  
  L20: 8b 4d c0 ?? mov ecx, dword ss:[ebp + 0xc0<192,-64>]
   0f be 11 ?? movsx edx, byte ds:[ecx]
   83 fa 7f ?? cmp edx, 0x7f<127>
   0f 84 81 00 00 00 ?? je basic block L27
  
  L21: 8b 45 c0 ?? mov eax, dword ss:[ebp + 0xc0<192,-64>]
   0f be 08 ?? movsx ecx, byte ds:[eax]
   85 c9 ?? test ecx, ecx
   7e 77 ?? jle basic block L27
  
  L22: 8b 55 c0 ?? mov edx, dword ss:[ebp + 0xc0<192,-64>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   2b 4d e8 ?? sub ecx, dword ss:[ebp + 0xe8<232,-24>]
   3b c1 ?? cmp eax, ecx
   73 67 ?? jae basic block L27
  
  L23: 8b 55 c0 ?? mov edx, dword ss:[ebp + 0xc0<192,-64>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   2b c8 ?? sub ecx, eax
   89 4d bc ?? mov dword ss:[ebp + 0xbc<188,-68>], ecx
   8b 55 24 ?? mov edx, dword ss:[ebp + 0x24<36>]
   83 c2 01 ?? add edx, 1
   2b 55 bc ?? sub edx, dword ss:[ebp + 0xbc<188,-68>]
   52 ?? push edx
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   03 45 bc ?? add eax, dword ss:[ebp + 0xbc<188,-68>]
   50 ?? push eax
   8b 4d 24 ?? mov ecx, dword ss:[ebp + 0x24<36>]
   83 c1 01 ?? add ecx, 1
   2b 4d bc ?? sub ecx, dword ss:[ebp + 0xbc<188,-68>]
   51 ?? push ecx
   8b 55 bc ?? mov edx, dword ss:[ebp + 0xbc<188,-68>]
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   8d 4c 10 01 ?? lea ecx, ds:[eax + edx + 1]
   51 ?? push ecx
   e8 96 4b 00 00 ?? call function 0x0040a593
  
  L24: 83 c4 10 ?? add esp, 0x10<16>
   8b 55 20 ?? mov edx, dword ss:[ebp + 0x20<32>]
   03 55 bc ?? add edx, dword ss:[ebp + 0xbc<188,-68>]
   c6 02 00 ?? mov byte ds:[edx], 0
   8b 45 24 ?? mov eax, dword ss:[ebp + 0x24<36>]
   83 c0 01 ?? add eax, 1
   89 45 24 ?? mov dword ss:[ebp + 0x24<36>], eax
   8b 4d c0 ?? mov ecx, dword ss:[ebp + 0xc0<192,-64>]
   0f be 51 01 ?? movsx edx, byte ds:[ecx + 1]
   85 d2 ?? test edx, edx
   7e 09 ?? jle basic block L26
  
  L25: 8b 45 c0 ?? mov eax, dword ss:[ebp + 0xc0<192,-64>]
   83 c0 01 ?? add eax, 1
   89 45 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], eax
  
  L26: e9 70 ff ff ff ?? jmp basic block L20
  
  L27: 8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 26 b7 ff ff ?? call function 0x00401159
  
  L28: 85 c0 ?? test eax, eax
   7e 1d ?? jle basic block L33
  
  L29: 8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 1a b7 ff ff ?? call function 0x00401159
  
  L30: 3b 45 24 ?? cmp eax, dword ss:[ebp + 0x24<36>]
   76 10 ?? jbe basic block L33
  
  L31: 8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 0d b7 ff ff ?? call function 0x00401159
  
  L32: 2b 45 24 ?? sub eax, dword ss:[ebp + 0x24<36>]
   89 45 84 ?? mov dword ss:[ebp + 0x84<132,-124>], eax
   eb 07 ?? jmp basic block L34
  
  L33: c7 45 84 00 00 00 00 ?? mov dword ss:[ebp + 0x84<132,-124>], 0
  
  L34: 8b 4d 84 ?? mov ecx, dword ss:[ebp + 0x84<132,-124>]
   89 4d e4 ?? mov dword ss:[ebp + 0xe4<228,-28>], ecx
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 b7 b8 ff ff ?? call function 0x00401320
  
  L35: 25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   83 7d f0 40 ?? cmp dword ss:[ebp + 0xf0<240,-16>], 0x40<64>
   74 3e ?? je basic block L39
  
  L36: 81 7d f0 00 01 00 00 ?? cmp dword ss:[ebp + 0xf0<240,-16>], 0x00000100<256>
   74 35 ?? je basic block L39
  
  L37: 8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
   52 ?? push edx
   0f b6 45 1c ?? movzx eax, byte ss:[ebp + 0x1c<28>]
   50 ?? push eax
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   51 ?? push ecx
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   52 ?? push edx
   8d 45 b0 ?? lea eax, ss:[ebp + 0xb0<176,-80>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 10 b7 ff ff ?? call function 0x004011ae
  
  L38: 83 c4 18 ?? add esp, 0x18<24>
   8b 10 ?? mov edx, dword ds:[eax]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
   89 45 14 ?? mov dword ss:[ebp + 0x14<20>], eax
   c7 45 e4 00 00 00 00 ?? mov dword ss:[ebp + 0xe4<228,-28>], 0
   eb 79 ?? jmp basic block L43
  
  L39: 81 7d f0 00 01 00 00 ?? cmp dword ss:[ebp + 0xf0<240,-16>], 0x00000100<256>
   75 70 ?? jne basic block L43
  
  L40: 8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   51 ?? push ecx
   8b 55 20 ?? mov edx, dword ss:[ebp + 0x20<32>]
   52 ?? push edx
   8b 45 14 ?? mov eax, dword ss:[ebp + 0x14<20>]
   50 ?? push eax
   8b 4d 10 ?? mov ecx, dword ss:[ebp + 0x10<16>]
   51 ?? push ecx
   8d 55 a8 ?? lea edx, ss:[ebp + 0xa8<168,-88>]
   52 ?? push edx
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   50 ?? push eax
   e8 32 b7 ff ff ?? call function 0x0040120d
  
  L41: 83 c4 18 ?? add esp, 0x18<24>
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 50 04 ?? mov edx, dword ds:[eax + 4]
   89 4d 10 ?? mov dword ss:[ebp + 0x10<16>], ecx
   89 55 14 ?? mov dword ss:[ebp + 0x14<20>], edx
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   03 45 e8 ?? add eax, dword ss:[ebp + 0xe8<232,-24>]
   89 45 20 ?? mov dword ss:[ebp + 0x20<32>], eax
   8b 4d 24 ?? mov ecx, dword ss:[ebp + 0x24<36>]
   2b 4d e8 ?? sub ecx, dword ss:[ebp + 0xe8<232,-24>]
   89 4d 24 ?? mov dword ss:[ebp + 0x24<36>], ecx
   8b 55 e4 ?? mov edx, dword ss:[ebp + 0xe4<228,-28>]
   52 ?? push edx
   0f b6 45 1c ?? movzx eax, byte ss:[ebp + 0x1c<28>]
   50 ?? push eax
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   51 ?? push ecx
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   52 ?? push edx
   8d 45 a0 ?? lea eax, ss:[ebp + 0xa0<160,-96>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 95 b6 ff ff ?? call function 0x004011ae
  
  L42: 83 c4 18 ?? add esp, 0x18<24>
   8b 10 ?? mov edx, dword ds:[eax]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
   89 45 14 ?? mov dword ss:[ebp + 0x14<20>], eax
   c7 45 e4 00 00 00 00 ?? mov dword ss:[ebp + 0xe4<228,-28>], 0
  
  L43: 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   e8 9b b6 ff ff ?? call function 0x004011d1
  
  L44: 0f b6 c8 ?? movzx ecx, al
   51 ?? push ecx
   8b 55 24 ?? mov edx, dword ss:[ebp + 0x24<36>]
   52 ?? push edx
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   50 ?? push eax
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   51 ?? push ecx
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   52 ?? push edx
   8d 45 98 ?? lea eax, ss:[ebp + 0x98<152,-104>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 d9 b6 ff ff ?? call function 0x00401230
  
  L45: 83 c4 1c ?? add esp, 0x1c<28>
   8b 10 ?? mov edx, dword ds:[eax]
   8b 40 04 ?? mov eax, dword ds:[eax + 4]
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
   89 45 14 ?? mov dword ss:[ebp + 0x14<20>], eax
   6a 00 ?? push 0
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 d1 b5 ff ff ?? call function 0x00401140
  
  L46: 8b 4d e4 ?? mov ecx, dword ss:[ebp + 0xe4<228,-28>]
   51 ?? push ecx
   0f b6 55 1c ?? movzx edx, byte ss:[ebp + 0x1c<28>]
   52 ?? push edx
   8b 45 14 ?? mov eax, dword ss:[ebp + 0x14<20>]
   50 ?? push eax
   8b 4d 10 ?? mov ecx, dword ss:[ebp + 0x10<16>]
   51 ?? push ecx
   8b 55 0c ?? mov edx, dword ss:[ebp + 12]
   52 ?? push edx
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   50 ?? push eax
   e8 21 b6 ff ff ?? call function 0x004011ae
  
  L47: 83 c4 18 ?? add esp, 0x18<24>
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d c4 ?? lea ecx, ss:[ebp + 0xc4<196,-60>]
   e8 cd b6 ff ff ?? call function 0x0040126c
  
  L48: 8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   8b 4d f4 ?? mov ecx, dword ss:[ebp + 0xf4<244,-12>]
   64 89 0d 00 00 00 00 ?? mov dword fs:[0], ecx
   59 ?? pop ecx
   8b 4d e0 ?? mov ecx, dword ss:[ebp + 0xe0<224,-32>]
   33 cd ?? xor ecx, ebp
   e8 95 3f 00 00 ?? call function 0x00409b4c
  
  L49: 8b e5 ?? mov esp, ebp
   5d ?? pop ebp
   c3 ?? ret
  
  