Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 a0 7f 43 00 ?? push 0x00437fa0
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   51 ?? push ecx
   83 ec 50 ?? sub esp, 0x50<80>
   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
   89 4d bc ?? mov dword ss:[ebp + 0xbc<188,-68>], ecx
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
   8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   50 ?? push eax
   8d 4d e4 ?? lea ecx, ss:[ebp + 0xe4<228,-28>]
   e8 75 f9 ff ff ?? call function 0x00401307
  
  L2: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8d 4d e4 ?? lea ecx, ss:[ebp + 0xe4<228,-28>]
   e8 be f6 ff ff ?? call function 0x0040105f
  
  L3: 0f b6 c8 ?? movzx ecx, al
   85 c9 ?? test ecx, ecx
   0f 84 38 01 00 00 ?? je basic block L25
  
  L4: 8d 55 d4 ?? lea edx, ss:[ebp + 0xd4<212,-44>]
   52 ?? push edx
   8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 bc ?? mov edx, dword ss:[ebp + 0xbc<188,-68>]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 fc f6 ff ff ?? call function 0x004010be
  
  L5: 89 45 b8 ?? mov dword ss:[ebp + 0xb8<184,-72>], eax
   8b 45 b8 ?? mov eax, dword ss:[ebp + 0xb8<184,-72>]
   89 45 b4 ?? mov dword ss:[ebp + 0xb4<180,-76>], eax
   c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8b 4d b4 ?? mov ecx, dword ss:[ebp + 0xb4<180,-76>]
   51 ?? push ecx
   e8 34 f9 ff ff ?? call function 0x0040130c
  
  L6: 83 c4 04 ?? add esp, 4
   89 45 d8 ?? mov dword ss:[ebp + 0xd8<216,-40>], eax
   c6 45 fc 00 ?? mov byte ss:[ebp + 0xfc<252,-4>], 0
   8d 4d d4 ?? lea ecx, ss:[ebp + 0xd4<212,-44>]
   e8 57 f6 ff ff ?? call function 0x00401041
  
  L7: 8b 55 bc ?? mov edx, dword ss:[ebp + 0xbc<188,-68>]
   8b 02 ?? mov eax, dword ds:[edx]
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   03 48 04 ?? add ecx, dword ds:[eax + 4]
   e8 26 f9 ff ff ?? call function 0x00401320
  
  L8: 25 00 0e 00 00 ?? and eax, 0x00000e00<3584>
   89 45 dc ?? mov dword ss:[ebp + 0xdc<220,-36>], eax
   81 7d dc 00 04 00 00 ?? cmp dword ss:[ebp + 0xdc<220,-36>], 0x00000400<1024>
   74 11 ?? je basic block L11
  
  L9: 81 7d dc 00 08 00 00 ?? cmp dword ss:[ebp + 0xdc<220,-36>], 0x00000800<2048>
   74 08 ?? je basic block L11
  
  L10: 8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   89 4d b0 ?? mov dword ss:[ebp + 0xb0<176,-80>], ecx
   eb 06 ?? jmp basic block L12
  
  L11: 8b 55 08 ?? mov edx, dword ss:[ebp + 8]
   89 55 b0 ?? mov dword ss:[ebp + 0xb0<176,-80>], edx
  
  L12: 8b 45 b0 ?? mov eax, dword ss:[ebp + 0xb0<176,-80>]
   89 45 e0 ?? mov dword ss:[ebp + 0xe0<224,-32>], eax
   c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   83 7d bc 00 ?? cmp dword ss:[ebp + 0xbc<188,-68>], 0
   75 09 ?? jne basic block L14
  
  L13: c7 45 ac 00 00 00 00 ?? mov dword ss:[ebp + 0xac<172,-84>], 0
   eb 0e ?? jmp basic block L15
  
  L14: 8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   03 42 04 ?? add eax, dword ds:[edx + 4]
   89 45 ac ?? mov dword ss:[ebp + 0xac<172,-84>], eax
  
  L15: 8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 c2 f8 ff ff ?? call function 0x0040131b
  
  L16: 88 45 ab ?? mov byte ss:[ebp + 0xab<171,-85>], al
   8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 bc ?? mov edx, dword ss:[ebp + 0xbc<188,-68>]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 3c f6 ff ff ?? call function 0x004010aa
  
  L17: 89 45 a4 ?? mov dword ss:[ebp + 0xa4<164,-92>], eax
   8b 45 e0 ?? mov eax, dword ss:[ebp + 0xe0<224,-32>]
   50 ?? push eax
   0f b6 4d ab ?? movzx ecx, byte ss:[ebp + 0xab<171,-85>]
   51 ?? push ecx
   8b 55 ac ?? mov edx, dword ss:[ebp + 0xac<172,-84>]
   52 ?? push edx
   8b 45 a4 ?? mov eax, dword ss:[ebp + 0xa4<164,-92>]
   50 ?? push eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 a1 f7 ff ff ?? call function 0x0040122b
  
  L18: 8b 48 04 ?? mov ecx, dword ds:[eax + 4]
   51 ?? push ecx
   8b 10 ?? mov edx, dword ds:[eax]
   52 ?? push edx
   8d 45 c4 ?? lea eax, ss:[ebp + 0xc4<196,-60>]
   50 ?? push eax
   8b 4d d8 ?? mov ecx, dword ss:[ebp + 0xd8<216,-40>]
   e8 4c f8 ff ff ?? call function 0x004012e9
  
  L19: 89 45 a0 ?? mov dword ss:[ebp + 0xa0<160,-96>], eax
   8b 4d a0 ?? mov ecx, dword ss:[ebp + 0xa0<160,-96>]
   e8 a7 f6 ff ff ?? call function 0x0040114f
  
  L20: 0f b6 c8 ?? movzx ecx, al
   85 c9 ?? test ecx, ecx
   74 09 ?? je basic block L22
  
  L21: 8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
   83 ca 04 ?? or edx, 4
   89 55 ec ?? mov dword ss:[ebp + 0xec<236,-20>], edx
  
  L22: eb 23 ?? jmp 0x00401add
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
  
  L23: 6a 01 ?? push 1
   6a 04 ?? push 4
   8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   8b 08 ?? mov ecx, dword ds:[eax]
   8b 55 bc ?? mov edx, dword ss:[ebp + 0xbc<188,-68>]
   03 51 04 ?? add edx, dword ds:[ecx + 4]
   8b ca ?? mov ecx, edx
   e8 f8 f5 ff ff ?? call function 0x004010c8
  
  L24: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   b8 e4 1a 40 00 ?? mov eax, basic block L25
   c3 ?? ret
  
  L25: 6a 00 ?? push 0
   8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   50 ?? push eax
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   8b 11 ?? mov edx, dword ds:[ecx]
   8b 4d bc ?? mov ecx, dword ss:[ebp + 0xbc<188,-68>]
   03 4a 04 ?? add ecx, dword ds:[edx + 4]
   e8 ce f5 ff ff ?? call function 0x004010c8
  
  L26: 8b 45 bc ?? mov eax, dword ss:[ebp + 0xbc<188,-68>]
   89 45 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d e4 ?? lea ecx, ss:[ebp + 0xe4<228,-28>]
   e8 d1 f6 ff ff ?? call function 0x004011e0
  
  L27: 8b 45 c0 ?? mov eax, dword ss:[ebp + 0xc0<192,-64>]
   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
   c2 04 00 ?? ret 4
  
  