Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 e8 83 43 00 ?? push 0x004383e8
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   81 ec e8 00 00 00 ?? sub esp, 0x000000e8<232>
   a1 44 44 44 00 ?? mov eax, dword ds:[0x00444444]
   33 c5 ?? xor eax, ebp
   89 45 cc ?? mov dword ss:[ebp + 0xcc<204,-52>], 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 80 ?? lea eax, ss:[ebp + 0x80<128,-128>]
   50 ?? push eax
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 77 c1 ff ff ?? call function 0x004010be
  
  L2: 89 85 1c ff ff ff ?? mov dword ss:[ebp + 0xffffff1c<4294967068,-228>], eax
   8b 8d 1c ff ff ff ?? mov ecx, dword ss:[ebp + 0xffffff1c<4294967068,-228>]
   89 8d 18 ff ff ff ?? mov dword ss:[ebp + 0xffffff18<4294967064,-232>], ecx
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8b 95 18 ff ff ff ?? mov edx, dword ss:[ebp + 0xffffff18<4294967064,-232>]
   52 ?? push edx
   e8 fd c0 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 80 ?? lea ecx, ss:[ebp + 0x80<128,-128>]
   e8 c0 c0 ff ff ?? call function 0x00401041
  
  L4: 8d 45 b0 ?? lea eax, ss:[ebp + 0xb0<176,-80>]
   50 ?? push eax
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   e8 6c c2 ff ff ?? call function 0x004011f9
  
  L5: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   e8 35 c2 ff ff ?? call function 0x004011d1
  
  L6: 88 45 db ?? mov byte ss:[ebp + 0xdb<219,-37>], al
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 db c0 ff ff ?? call function 0x00401082
  
  L7: c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   83 c1 08 ?? add ecx, 8
   51 ?? push ecx
   6a 00 ?? push 0
   6a 30 ?? push 0x30<48>
   e8 02 c2 ff ff ?? call function 0x004011bd
  
  L8: 83 c4 0c ?? add esp, 12
   88 45 eb ?? mov byte ss:[ebp + 0xeb<235,-21>], al
   8b 55 20 ?? mov edx, dword ss:[ebp + 0x20<32>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   83 f8 2b ?? cmp eax, 0x2b<43>
   74 17 ?? je basic block L11
  
  L9: 8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   0f be 11 ?? movsx edx, byte ds:[ecx]
   83 fa 2d ?? cmp edx, 0x2d<45>
   74 0c ?? je basic block L11
  
  L10: c7 85 14 ff ff ff 00 00 ?? mov dword ss:[ebp + 0xffffff14<4294967060,-236>], 0
   00 00
   eb 0a ?? jmp basic block L12
  
  L11: c7 85 14 ff ff ff 01 00 ?? mov dword ss:[ebp + 0xffffff14<4294967060,-236>], 1
   00 00
  
  L12: 8b 85 14 ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff14<4294967060,-236>]
   89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   e8 72 55 00 00 ?? call function 0x0040a56d
  
  L13: 8b 08 ?? mov ecx, dword ds:[eax]
   8a 11 ?? mov dl, byte ds:[ecx]
   88 55 e4 ?? mov byte ss:[ebp + 0xe4<228,-28>], dl
   c6 45 e5 65 ?? mov byte ss:[ebp + 0xe5<229,-27>], 0x65<101>
   c6 45 e6 00 ?? mov byte ss:[ebp + 0xe6<230,-26>], 0
   8b 45 30 ?? mov eax, dword ss:[ebp + 0x30<48>]
   50 ?? push eax
   6a 65 ?? push 0x65<101>
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   51 ?? push ecx
   e8 a7 54 00 00 ?? call function 0x0040a4c0
  
  L14: 83 c4 0c ?? add esp, 12
   89 45 d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], eax
   8b 55 30 ?? mov edx, dword ss:[ebp + 0x30<48>]
   52 ?? push edx
   0f be 45 e4 ?? movsx eax, byte ss:[ebp + 0xe4<228,-28>]
   50 ?? push eax
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   51 ?? push ecx
   e8 8f 54 00 00 ?? call function 0x0040a4c0
  
  L15: 83 c4 0c ?? add esp, 12
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   83 7d e0 00 ?? cmp dword ss:[ebp + 0xe0<224,-32>], 0
   75 07 ?? jne basic block L17
  
  L16: c7 45 2c 00 00 00 00 ?? mov dword ss:[ebp + 0x2c<44>], 0
  
  L17: 8d 4d b0 ?? lea ecx, ss:[ebp + 0xb0<176,-80>]
   e8 8f c1 ff ff ?? call function 0x004011db
  
  L18: 0f be 10 ?? movsx edx, byte ds:[eax]
   83 fa 7f ?? cmp edx, 0x7f<127>
   0f 84 5e 01 00 00 ?? je basic block L49
  
  L19: 8d 4d b0 ?? lea ecx, ss:[ebp + 0xb0<176,-80>]
   e8 7b c1 ff ff ?? call function 0x004011db
  
  L20: 0f be 00 ?? movsx eax, byte ds:[eax]
   85 c0 ?? test eax, eax
   0f 8e 4b 01 00 00 ?? jle basic block L49
  
  L21: 8b 4d 30 ?? mov ecx, dword ss:[ebp + 0x30<48>]
   51 ?? push ecx
   8b 55 20 ?? mov edx, dword ss:[ebp + 0x20<32>]
   52 ?? push edx
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 7d c2 ff ff ?? call function 0x004012f8
  
  L22: 83 7d d0 00 ?? cmp dword ss:[ebp + 0xd0<208,-48>], 0
   75 10 ?? jne basic block L25
  
  L23: 6a 30 ?? push 0x30<48>
   8b 45 2c ?? mov eax, dword ss:[ebp + 0x2c<44>]
   50 ?? push eax
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 6e c2 ff ff ?? call function 0x004012fd
  
  L24: eb 30 ?? jmp basic block L29
  
  L25: 83 7d e0 00 ?? cmp dword ss:[ebp + 0xe0<224,-32>], 0
   75 15 ?? jne basic block L28
  
  L26: 6a 30 ?? push 0x30<48>
   8b 4d 24 ?? mov ecx, dword ss:[ebp + 0x24<36>]
   51 ?? push ecx
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 58 c2 ff ff ?? call function 0x004012fd
  
  L27: c7 45 24 00 00 00 00 ?? mov dword ss:[ebp + 0x24<36>], 0
  
  L28: 6a 30 ?? push 0x30<48>
   8b 55 2c ?? mov edx, dword ss:[ebp + 0x2c<44>]
   52 ?? push edx
   8b 45 d0 ?? mov eax, dword ss:[ebp + 0xd0<208,-48>]
   2b 45 20 ?? sub eax, dword ss:[ebp + 0x20<32>]
   50 ?? push eax
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 99 bf ff ff ?? call function 0x0040105a
  
  L29: c7 45 2c 00 00 00 00 ?? mov dword ss:[ebp + 0x2c<44>], 0
   83 7d e0 00 ?? cmp dword ss:[ebp + 0xe0<224,-32>], 0
   75 10 ?? jne basic block L32
  
  L30: 6a 30 ?? push 0x30<48>
   8b 4d 24 ?? mov ecx, dword ss:[ebp + 0x24<36>]
   51 ?? push ecx
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 21 c2 ff ff ?? call function 0x004012fd
  
  L31: eb 34 ?? jmp basic block L35
  
  L32: 6a 30 ?? push 0x30<48>
   8b 55 28 ?? mov edx, dword ss:[ebp + 0x28<40>]
   52 ?? push edx
   8b 45 e0 ?? mov eax, dword ss:[ebp + 0xe0<224,-32>]
   2b 45 20 ?? sub eax, dword ss:[ebp + 0x20<32>]
   83 c0 01 ?? add eax, 1
   50 ?? push eax
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 64 bf ff ff ?? call function 0x0040105a
  
  L33: 6a 30 ?? push 0x30<48>
   8b 4d 24 ?? mov ecx, dword ss:[ebp + 0x24<36>]
   51 ?? push ecx
   8b 55 e0 ?? mov edx, dword ss:[ebp + 0xe0<224,-32>]
   2b 55 20 ?? sub edx, dword ss:[ebp + 0x20<32>]
   52 ?? push edx
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 4f bf ff ff ?? call function 0x0040105a
  
  L34: c7 45 28 00 00 00 00 ?? mov dword ss:[ebp + 0x28<40>], 0
  
  L35: c7 45 24 00 00 00 00 ?? mov dword ss:[ebp + 0x24<36>], 0
   8d 4d b0 ?? lea ecx, ss:[ebp + 0xb0<176,-80>]
   e8 ba c0 ff ff ?? call function 0x004011db
  
  L36: 89 45 90 ?? mov dword ss:[ebp + 0x90<144,-112>], eax
   8d 45 e4 ?? lea eax, ss:[ebp + 0xe4<228,-28>]
   50 ?? push eax
   6a 00 ?? push 0
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 9a c0 ff ff ?? call function 0x004011cc
  
  L37: 50 ?? push eax
   e8 38 53 00 00 ?? call function 0x0040a470
  
  L38: 83 c4 08 ?? add esp, 8
   89 45 8c ?? mov dword ss:[ebp + 0x8c<140,-116>], eax
  
  L39: 8b 4d 90 ?? mov ecx, dword ss:[ebp + 0x90<144,-112>]
   0f be 11 ?? movsx edx, byte ds:[ecx]
   83 fa 7f ?? cmp edx, 0x7f<127>
   74 4e ?? je basic block L46
  
  L40: 8b 45 90 ?? mov eax, dword ss:[ebp + 0x90<144,-112>]
   0f be 08 ?? movsx ecx, byte ds:[eax]
   85 c9 ?? test ecx, ecx
   7e 44 ?? jle basic block L46
  
  L41: 8b 55 90 ?? mov edx, dword ss:[ebp + 0x90<144,-112>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   8b 4d 8c ?? mov ecx, dword ss:[ebp + 0x8c<140,-116>]
   2b 4d dc ?? sub ecx, dword ss:[ebp + 0xdc<220,-36>]
   3b c1 ?? cmp eax, ecx
   73 34 ?? jae basic block L46
  
  L42: 8b 55 90 ?? mov edx, dword ss:[ebp + 0x90<144,-112>]
   0f be 02 ?? movsx eax, byte ds:[edx]
   8b 4d 8c ?? mov ecx, dword ss:[ebp + 0x8c<140,-116>]
   2b c8 ?? sub ecx, eax
   89 4d 8c ?? mov dword ss:[ebp + 0x8c<140,-116>], ecx
   6a 00 ?? push 0
   6a 01 ?? push 1
   8b 55 8c ?? mov edx, dword ss:[ebp + 0x8c<140,-116>]
   52 ?? push edx
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 d9 be ff ff ?? call function 0x0040105a
  
  L43: 8b 45 90 ?? mov eax, dword ss:[ebp + 0x90<144,-112>]
   0f be 48 01 ?? movsx ecx, byte ds:[eax + 1]
   85 c9 ?? test ecx, ecx
   7e 09 ?? jle basic block L45
  
  L44: 8b 55 90 ?? mov edx, dword ss:[ebp + 0x90<144,-112>]
   83 c2 01 ?? add edx, 1
   89 55 90 ?? mov dword ss:[ebp + 0x90<144,-112>], edx
  
  L45: eb a7 ?? jmp basic block L39
  
  L46: 6a 00 ?? push 0
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 2b c0 ff ff ?? call function 0x004011cc
  
  L47: 89 45 20 ?? mov dword ss:[ebp + 0x20<32>], eax
   c7 45 2c 00 00 00 00 ?? mov dword ss:[ebp + 0x2c<44>], 0
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 04 c1 ff ff ?? call function 0x004012b7
  
  L48: 89 45 30 ?? mov dword ss:[ebp + 0x30<48>], eax
  
  L49: 8b 45 24 ?? mov eax, dword ss:[ebp + 0x24<36>]
   03 45 28 ?? add eax, dword ss:[ebp + 0x28<40>]
   03 45 2c ?? add eax, dword ss:[ebp + 0x2c<44>]
   03 45 30 ?? add eax, dword ss:[ebp + 0x30<48>]
   89 45 d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], eax
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 8c bf ff ff ?? call function 0x00401159
  
  L50: 85 c0 ?? test eax, eax
   7e 20 ?? jle basic block L55
  
  L51: 8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 80 bf ff ff ?? call function 0x00401159
  
  L52: 3b 45 d4 ?? cmp eax, dword ss:[ebp + 0xd4<212,-44>]
   76 13 ?? jbe basic block L55
  
  L53: 8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 73 bf ff ff ?? call function 0x00401159
  
  L54: 2b 45 d4 ?? sub eax, dword ss:[ebp + 0xd4<212,-44>]
   89 85 10 ff ff ff ?? mov dword ss:[ebp + 0xffffff10<4294967056,-240>], eax
   eb 0a ?? jmp basic block L56
  
  L55: c7 85 10 ff ff ff 00 00 ?? mov dword ss:[ebp + 0xffffff10<4294967056,-240>], 0
   00 00
  
  L56: 8b 8d 10 ff ff ff ?? mov ecx, dword ss:[ebp + 0xffffff10<4294967056,-240>]
   89 4d d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], ecx
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 14 c1 ff ff ?? call function 0x00401320
  
  L57: 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 44 ?? je basic block L61
  
  L58: 81 7d f0 00 01 00 00 ?? cmp dword ss:[ebp + 0xf0<240,-16>], 0x00000100<256>
   74 3b ?? je basic block L61
  
  L59: 8b 55 d4 ?? mov edx, dword ss:[ebp + 0xd4<212,-44>]
   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 85 78 ff ff ff ?? lea eax, ss:[ebp + 0xffffff78<4294967160,-136>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 6a bf ff ff ?? call function 0x004011ae
  
  L60: 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 d4 00 00 00 00 ?? mov dword ss:[ebp + 0xd4<212,-44>], 0
   e9 83 00 00 00 ?? jmp basic block L67
  
  L61: 81 7d f0 00 01 00 00 ?? cmp dword ss:[ebp + 0xf0<240,-16>], 0x00000100<256>
   75 7a ?? jne basic block L67
  
  L62: 83 7d dc 00 ?? cmp dword ss:[ebp + 0xdc<220,-36>], 0
   76 3e ?? jbe basic block L65
  
  L63: 6a 01 ?? push 1
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 70 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff70<4294967152,-144>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 82 bf ff ff ?? call function 0x0040120d
  
  L64: 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>]
   83 c0 01 ?? add eax, 1
   89 45 20 ?? mov dword ss:[ebp + 0x20<32>], eax
   8b 4d 30 ?? mov ecx, dword ss:[ebp + 0x30<48>]
   83 e9 01 ?? sub ecx, 1
   89 4d 30 ?? mov dword ss:[ebp + 0x30<48>], ecx
  
  L65: 8b 55 d4 ?? mov edx, dword ss:[ebp + 0xd4<212,-44>]
   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 85 68 ff ff ff ?? lea eax, ss:[ebp + 0xffffff68<4294967144,-152>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 e2 be ff ff ?? call function 0x004011ae
  
  L66: 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 d4 00 00 00 00 ?? mov dword ss:[ebp + 0xd4<212,-44>], 0
  
  L67: 8b 4d 30 ?? mov ecx, dword ss:[ebp + 0x30<48>]
   51 ?? push ecx
   0f be 55 e4 ?? movsx edx, byte ss:[ebp + 0xe4<228,-28>]
   52 ?? push edx
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   50 ?? push eax
   e8 cd 51 00 00 ?? call function 0x0040a4c0
  
  L68: 83 c4 0c ?? add esp, 12
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   83 7d e0 00 ?? cmp dword ss:[ebp + 0xe0<224,-32>], 0
   0f 84 e6 00 00 00 ?? je basic block L75
  
  L69: 8b 4d e0 ?? mov ecx, dword ss:[ebp + 0xe0<224,-32>]
   2b 4d 20 ?? sub ecx, dword ss:[ebp + 0x20<32>]
   83 c1 01 ?? add ecx, 1
   89 4d 88 ?? mov dword ss:[ebp + 0x88<136,-120>], ecx
   0f b6 55 db ?? movzx edx, byte ss:[ebp + 0xdb<219,-37>]
   52 ?? push edx
   8b 45 88 ?? mov eax, dword ss:[ebp + 0x88<136,-120>]
   83 e8 01 ?? sub eax, 1
   50 ?? push eax
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 60 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff60<4294967136,-160>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 f9 be ff ff ?? call function 0x00401230
  
  L70: 83 c4 1c ?? add esp, 0x1c<28>
   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 24 ?? mov eax, dword ss:[ebp + 0x24<36>]
   50 ?? push eax
   0f b6 4d eb ?? movzx ecx, byte ss:[ebp + 0xeb<235,-21>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 58 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff58<4294967128,-168>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 48 be ff ff ?? call function 0x004011ae
  
  L71: 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
   6a 01 ?? push 1
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   e8 cd bc ff ff ?? call function 0x0040104b
  
  L72: 0f b6 c0 ?? movzx eax, al
   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 85 50 ff ff ff ?? lea eax, ss:[ebp + 0xffffff50<4294967120,-176>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 14 be ff ff ?? call function 0x004011ae
  
  L73: 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
   8b 4d 28 ?? mov ecx, dword ss:[ebp + 0x28<40>]
   51 ?? push ecx
   0f b6 55 eb ?? movzx edx, byte ss:[ebp + 0xeb<235,-21>]
   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 95 48 ff ff ff ?? lea edx, ss:[ebp + 0xffffff48<4294967112,-184>]
   52 ?? push edx
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   50 ?? push eax
   e8 e5 bd ff ff ?? call function 0x004011ae
  
  L74: 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 88 ?? add eax, dword ss:[ebp + 0x88<136,-120>]
   89 45 20 ?? mov dword ss:[ebp + 0x20<32>], eax
   8b 4d 30 ?? mov ecx, dword ss:[ebp + 0x30<48>]
   2b 4d 88 ?? sub ecx, dword ss:[ebp + 0x88<136,-120>]
   89 4d 30 ?? mov dword ss:[ebp + 0x30<48>], ecx
  
  L75: 8b 55 30 ?? mov edx, dword ss:[ebp + 0x30<48>]
   52 ?? push edx
   6a 65 ?? push 0x65<101>
   8b 45 20 ?? mov eax, dword ss:[ebp + 0x20<32>]
   50 ?? push eax
   e8 c8 50 00 00 ?? call function 0x0040a4c0
  
  L76: 83 c4 0c ?? add esp, 12
   89 45 d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], eax
   83 7d d0 00 ?? cmp dword ss:[ebp + 0xd0<208,-48>], 0
   0f 84 dc 00 00 00 ?? je basic block L85
  
  L77: 8b 4d d0 ?? mov ecx, dword ss:[ebp + 0xd0<208,-48>]
   2b 4d 20 ?? sub ecx, dword ss:[ebp + 0x20<32>]
   83 c1 01 ?? add ecx, 1
   89 4d 84 ?? mov dword ss:[ebp + 0x84<132,-124>], ecx
   0f b6 55 db ?? movzx edx, byte ss:[ebp + 0xdb<219,-37>]
   52 ?? push edx
   8b 45 84 ?? mov eax, dword ss:[ebp + 0x84<132,-124>]
   83 e8 01 ?? sub eax, 1
   50 ?? push eax
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 40 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff40<4294967104,-192>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 f4 bd ff ff ?? call function 0x00401230
  
  L78: 83 c4 1c ?? add esp, 0x1c<28>
   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 2c ?? mov eax, dword ss:[ebp + 0x2c<44>]
   50 ?? push eax
   0f b6 4d eb ?? movzx ecx, byte ss:[ebp + 0xeb<235,-21>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 38 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff38<4294967096,-200>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 43 bd ff ff ?? call function 0x004011ae
  
  L79: 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
   c7 45 2c 00 00 00 00 ?? mov dword ss:[ebp + 0x2c<44>], 0
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 98 be ff ff ?? call function 0x00401320
  
  L80: 83 e0 04 ?? and eax, 4
   74 0c ?? je basic block L82
  
  L81: c7 85 0c ff ff ff a4 d1 ?? mov dword ss:[ebp + 0xffffff0c<4294967052,-244>], 0x0043d1a4<"E">
   43 00
   eb 0a ?? jmp basic block L83
  
  L82: c7 85 0c ff ff ff a0 d1 ?? mov dword ss:[ebp + 0xffffff0c<4294967052,-244>], 0x0043d1a0<"e">
   43 00
  
  L83: 6a 01 ?? push 1
   8b 85 0c ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff0c<4294967052,-244>]
   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 85 30 ff ff ff ?? lea eax, ss:[ebp + 0xffffff30<4294967088,-208>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   e8 49 bd ff ff ?? call function 0x0040120d
  
  L84: 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
   8b 4d 20 ?? mov ecx, dword ss:[ebp + 0x20<32>]
   03 4d 84 ?? add ecx, dword ss:[ebp + 0x84<132,-124>]
   89 4d 20 ?? mov dword ss:[ebp + 0x20<32>], ecx
   8b 55 30 ?? mov edx, dword ss:[ebp + 0x30<48>]
   2b 55 84 ?? sub edx, dword ss:[ebp + 0x84<132,-124>]
   89 55 30 ?? mov dword ss:[ebp + 0x30<48>], edx
  
  L85: 0f b6 45 db ?? movzx eax, byte ss:[ebp + 0xdb<219,-37>]
   50 ?? push eax
   8b 4d 30 ?? mov ecx, dword ss:[ebp + 0x30<48>]
   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 95 28 ff ff ff ?? lea edx, ss:[ebp + 0xffffff28<4294967080,-216>]
   52 ?? push edx
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   50 ?? push eax
   e8 27 bd ff ff ?? call function 0x00401230
  
  L86: 83 c4 1c ?? add esp, 0x1c<28>
   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 2c ?? mov eax, dword ss:[ebp + 0x2c<44>]
   50 ?? push eax
   0f b6 4d eb ?? movzx ecx, byte ss:[ebp + 0xeb<235,-21>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8d 8d 20 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff20<4294967072,-224>]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 76 bc ff ff ?? call function 0x004011ae
  
  L87: 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
   6a 00 ?? push 0
   8b 4d 18 ?? mov ecx, dword ss:[ebp + 0x18<24>]
   e8 f0 bb ff ff ?? call function 0x00401140
  
  L88: 8b 45 d4 ?? mov eax, dword ss:[ebp + 0xd4<212,-44>]
   50 ?? push eax
   0f b6 4d 1c ?? movzx ecx, byte ss:[ebp + 0x1c<28>]
   51 ?? push ecx
   8b 55 14 ?? mov edx, dword ss:[ebp + 0x14<20>]
   52 ?? push edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   50 ?? push eax
   8b 4d 0c ?? mov ecx, dword ss:[ebp + 12]
   51 ?? push ecx
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   52 ?? push edx
   e8 40 bc ff ff ?? call function 0x004011ae
  
  L89: 83 c4 18 ?? add esp, 0x18<24>
   c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8d 4d 94 ?? lea ecx, ss:[ebp + 0x94<148,-108>]
   e8 ef bc ff ff ?? call function 0x0040126c
  
  L90: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d b0 ?? lea ecx, ss:[ebp + 0xb0<176,-80>]
   e8 e0 bc ff ff ?? call function 0x0040126c
  
  L91: 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 cc ?? mov ecx, dword ss:[ebp + 0xcc<204,-52>]
   33 cd ?? xor ecx, ebp
   e8 a8 45 00 00 ?? call function 0x00409b4c
  
  L92: 8b e5 ?? mov esp, ebp
   5d ?? pop ebp
   c3 ?? ret
  
  