Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 78 81 43 00 ?? push 0x00438178
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   51 ?? push ecx
   83 ec 74 ?? sub esp, 0x74<116>
   53 ?? push ebx
   56 ?? push esi
   57 ?? push edi
   a1 44 44 44 00 ?? mov eax, dword ds:[0x00444444]
   33 c5 ?? xor eax, ebp
   50 ?? push eax
   8d 45 f4 ?? lea eax, ss:[ebp + 0xf4<244,-12>]
   64 a3 00 00 00 00 ?? mov dword fs:[0], eax
   89 65 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], esp
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
   8b 4d 0c ?? mov ecx, dword ss:[ebp + 12]
   e8 dc de ff ff ?? call function 0x004012b7
  
  L2: 89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 69 dd ff ff ?? call function 0x00401159
  
  L3: 85 c0 ?? test eax, eax
   7e 31 ?? jle basic block L8
  
  L4: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 53 dd ff ff ?? call function 0x00401159
  
  L5: 3b 45 dc ?? cmp eax, dword ss:[ebp + 0xdc<220,-36>]
   76 1a ?? jbe basic block L8
  
  L6: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 3c dd ff ff ?? call function 0x00401159
  
  L7: 2b 45 dc ?? sub eax, dword ss:[ebp + 0xdc<220,-36>]
   89 45 b8 ?? mov dword ss:[ebp + 0xb8<184,-72>], eax
   eb 07 ?? jmp basic block L9
  
  L8: c7 45 b8 00 00 00 00 ?? mov dword ss:[ebp + 0xb8<184,-72>], 0
  
  L9: 8b 45 b8 ?? mov eax, dword ss:[ebp + 0xb8<184,-72>]
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
   e8 c9 de ff ff ?? call function 0x00401307
  
  L10: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
   e8 12 dc ff ff ?? call function 0x0040105f
  
  L11: 0f b6 d0 ?? movzx edx, al
   85 d2 ?? test edx, edx
   75 0e ?? jne basic block L13
  
  L12: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   e9 1d 02 00 00 ?? jmp basic block L51
  
  L13: c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 aa de ff ff ?? call function 0x00401320
  
  L14: 89 45 b4 ?? mov dword ss:[ebp + 0xb4<180,-76>], eax
   8b 45 b4 ?? mov eax, dword ss:[ebp + 0xb4<180,-76>]
   25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   0f 84 86 00 00 00 ?? je basic block L25
  
  L15: eb 09 ?? jmp basic block L16
  
  L16: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   76 75 ?? jbe basic block L25
  
  L17: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   8b 02 ?? mov eax, dword ds:[edx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 48 04 ?? add ecx, dword ds:[eax + 4]
   e8 70 de ff ff ?? call function 0x0040131b
  
  L18: 88 45 b3 ?? mov byte ss:[ebp + 0xb3<179,-77>], al
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 ec db ff ff ?? call function 0x004010aa
  
  L19: 89 45 ac ?? mov dword ss:[ebp + 0xac<172,-84>], eax
   0f b6 45 b3 ?? movzx eax, byte ss:[ebp + 0xb3<179,-77>]
   50 ?? push eax
   8b 4d ac ?? mov ecx, dword ss:[ebp + 0xac<172,-84>]
   e8 86 dc ff ff ?? call function 0x00401154
  
  L20: 89 45 a8 ?? mov dword ss:[ebp + 0xa8<168,-88>], eax
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   89 4d d4 ?? mov dword ss:[ebp + 0xd4<212,-44>], ecx
   e8 fa dc ff ff ?? call function 0x004011d6
  
  L21: 89 45 a4 ?? mov dword ss:[ebp + 0xa4<164,-92>], eax
   8b 55 a4 ?? mov edx, dword ss:[ebp + 0xa4<164,-92>]
   89 55 d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], edx
   8d 45 d4 ?? lea eax, ss:[ebp + 0xd4<212,-44>]
   50 ?? push eax
   8d 4d d0 ?? lea ecx, ss:[ebp + 0xd0<208,-48>]
   51 ?? push ecx
   e8 26 dc ff ff ?? call function 0x00401118
  
  L22: 83 c4 08 ?? add esp, 8
   88 45 a3 ?? mov byte ss:[ebp + 0xa3<163,-93>], al
   0f b6 55 a3 ?? movzx edx, byte ss:[ebp + 0xa3<163,-93>]
   85 d2 ?? test edx, edx
   74 0b ?? je basic block L24
  
  L23: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   eb 05 ?? jmp basic block L25
  
  L24: e9 7c ff ff ff ?? jmp 0x0040348c
   8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   83 e9 01 ?? sub ecx, 1
   89 4d e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], ecx
  
  L25: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   0f 85 8d 00 00 00 ?? jne basic block L36
  
  L26: c7 45 d8 00 00 00 00 ?? mov dword ss:[ebp + 0xd8<216,-40>], 0
   eb 09 ?? jmp basic block L27
  
  L27: 8b 55 d8 ?? mov edx, dword ss:[ebp + 0xd8<216,-40>]
   3b 55 dc ?? cmp edx, dword ss:[ebp + 0xdc<220,-36>]
   73 73 ?? jae basic block L36
  
  L28: 8b 45 d8 ?? mov eax, dword ss:[ebp + 0xd8<216,-40>]
   50 ?? push eax
   8b 4d 0c ?? mov ecx, dword ss:[ebp + 12]
   e8 b4 dc ff ff ?? call function 0x004011f4
  
  L29: 89 45 9c ?? mov dword ss:[ebp + 0x9c<156,-100>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 57 db ff ff ?? call function 0x004010aa
  
  L30: 89 45 98 ?? mov dword ss:[ebp + 0x98<152,-104>], eax
   8b 45 9c ?? mov eax, dword ss:[ebp + 0x9c<156,-100>]
   0f b6 08 ?? movzx ecx, byte ds:[eax]
   51 ?? push ecx
   8b 4d 98 ?? mov ecx, dword ss:[ebp + 0x98<152,-104>]
   e8 ef db ff ff ?? call function 0x00401154
  
  L31: 89 45 94 ?? mov dword ss:[ebp + 0x94<148,-108>], eax
   8b 55 94 ?? mov edx, dword ss:[ebp + 0x94<148,-108>]
   89 55 cc ?? mov dword ss:[ebp + 0xcc<204,-52>], edx
   e8 63 dc ff ff ?? call function 0x004011d6
  
  L32: 89 45 90 ?? mov dword ss:[ebp + 0x90<144,-112>], eax
   8b 45 90 ?? mov eax, dword ss:[ebp + 0x90<144,-112>]
   89 45 c8 ?? mov dword ss:[ebp + 0xc8<200,-56>], eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   51 ?? push ecx
   8d 55 c8 ?? lea edx, ss:[ebp + 0xc8<200,-56>]
   52 ?? push edx
   e8 8f db ff ff ?? call function 0x00401118
  
  L33: 83 c4 08 ?? add esp, 8
   88 45 8f ?? mov byte ss:[ebp + 0x8f<143,-113>], al
   0f b6 45 8f ?? movzx eax, byte ss:[ebp + 0x8f<143,-113>]
   85 c0 ?? test eax, eax
   74 0b ?? je basic block L35
  
  L34: 8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   83 c9 04 ?? or ecx, 4
   89 4d ec ?? mov dword ss:[ebp + 0xec<236,-20>], ecx
   eb 05 ?? jmp basic block L36
  
  L35: e9 7c ff ff ff ?? jmp 0x00403523
   8b 4d d8 ?? mov ecx, dword ss:[ebp + 0xd8<216,-40>]
   83 c1 01 ?? add ecx, 1
   89 4d d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], ecx
  
  L36: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   0f 85 90 00 00 00 ?? jne basic block L47
  
  L37: eb 09 ?? jmp basic block L38
  
  L38: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   76 7f ?? jbe basic block L47
  
  L39: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 47 dd ff ff ?? call function 0x0040131b
  
  L40: 88 45 8e ?? mov byte ss:[ebp + 0x8e<142,-114>], al
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 c1 da ff ff ?? call function 0x004010aa
  
  L41: 89 45 88 ?? mov dword ss:[ebp + 0x88<136,-120>], eax
   0f b6 45 8e ?? movzx eax, byte ss:[ebp + 0x8e<142,-114>]
   50 ?? push eax
   8b 4d 88 ?? mov ecx, dword ss:[ebp + 0x88<136,-120>]
   e8 5b db ff ff ?? call function 0x00401154
  
  L42: 89 45 84 ?? mov dword ss:[ebp + 0x84<132,-124>], eax
   8b 4d 84 ?? mov ecx, dword ss:[ebp + 0x84<132,-124>]
   89 4d c4 ?? mov dword ss:[ebp + 0xc4<196,-60>], ecx
   e8 cf db ff ff ?? call function 0x004011d6
  
  L43: 89 45 80 ?? mov dword ss:[ebp + 0x80<128,-128>], eax
   8b 55 80 ?? mov edx, dword ss:[ebp + 0x80<128,-128>]
   89 55 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], edx
   8d 45 c4 ?? lea eax, ss:[ebp + 0xc4<196,-60>]
   50 ?? push eax
   8d 4d c0 ?? lea ecx, ss:[ebp + 0xc0<192,-64>]
   51 ?? push ecx
   e8 fb da ff ff ?? call function 0x00401118
  
  L44: 83 c4 08 ?? add esp, 8
   88 85 7f ff ff ff ?? mov byte ss:[ebp + 0xffffff7f<4294967167,-129>], al
   0f b6 95 7f ff ff ff ?? movzx edx, byte ss:[ebp + 0xffffff7f<4294967167,-129>]
   85 d2 ?? test edx, edx
   74 0b ?? je basic block L46
  
  L45: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   83 c8 04 ?? or eax, 4
   89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   eb 05 ?? jmp basic block L47
  
  L46: e9 72 ff ff ff ?? jmp 0x004035b3
   8b 55 e8 ?? mov edx, dword ss:[ebp + 0xe8<232,-24>]
   83 ea 01 ?? sub edx, 1
   89 55 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], edx
  
  L47: 6a 00 ?? push 0
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 ed da ff ff ?? call function 0x00401140
  
  L48: eb 23 ?? jmp 0x00403678
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
  
  L49: 6a 01 ?? push 1
   6a 04 ?? push 4
   8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 5d da ff ff ?? call function 0x004010c8
  
  L50: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   b8 7f 36 40 00 ?? mov eax, basic block L51
   c3 ?? ret
  
  L51: 6a 00 ?? push 0
   8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 33 da ff ff ?? call function 0x004010c8
  
  L52: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   89 45 bc ?? mov dword ss:[ebp + 0xbc<188,-68>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d e0 ?? lea ecx, ss:[ebp + 0xe0<224,-32>]
   e8 36 db ff ff ?? call function 0x004011e0
  
  L53: 8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   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
   5f ?? pop edi
   5e ?? pop esi
   5b ?? pop ebx
   8b e5 ?? mov esp, ebp
   5d ?? pop ebp
   c3 ?? ret
  
  