Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 90 85 43 00 ?? push 0x00438590
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   51 ?? push ecx
   83 ec 68 ?? sub esp, 0x68<104>
   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 a8 ?? mov dword ss:[ebp + 0xa8<168,-88>], ecx
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 ab a6 ff ff ?? call function 0x00401212
  
  L2: 89 45 ec ?? mov dword ss:[ebp + 0xec<236,-20>], eax
   8b 45 a8 ?? mov eax, dword ss:[ebp + 0xa8<168,-88>]
   c7 40 08 00 00 00 00 ?? mov dword ds:[eax + 8], 0
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   c7 41 10 00 00 00 00 ?? mov dword ds:[ecx + 0x10<16>], 0
   8b 55 a8 ?? mov edx, dword ss:[ebp + 0xa8<168,-88>]
   c7 42 14 00 00 00 00 ?? mov dword ds:[edx + 0x14<20>], 0
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8d 45 e4 ?? lea eax, ss:[ebp + 0xe4<228,-28>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 4f a6 ff ff ?? call function 0x004011ea
  
  L3: 89 45 a4 ?? mov dword ss:[ebp + 0xa4<164,-92>], eax
   8b 4d a4 ?? mov ecx, dword ss:[ebp + 0xa4<164,-92>]
   51 ?? push ecx
   6a 00 ?? push 0
   8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
   8b 42 08 ?? mov eax, dword ds:[edx + 8]
   50 ?? push eax
   e8 a8 a6 ff ff ?? call function 0x00401258
  
  L4: 83 c4 0c ?? add esp, 12
   89 45 a0 ?? mov dword ss:[ebp + 0xa0<160,-96>], eax
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   8b 55 a0 ?? mov edx, dword ss:[ebp + 0xa0<160,-96>]
   89 51 08 ?? mov dword ds:[ecx + 8], edx
   8d 45 dc ?? lea eax, ss:[ebp + 0xdc<220,-36>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 1f a6 ff ff ?? call function 0x004011ea
  
  L5: 89 45 9c ?? mov dword ss:[ebp + 0x9c<156,-100>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 70 a4 ff ff ?? call function 0x00401046
  
  L6: 89 45 98 ?? mov dword ss:[ebp + 0x98<152,-104>], eax
   8b 4d 9c ?? mov ecx, dword ss:[ebp + 0x9c<156,-100>]
   51 ?? push ecx
   6a 00 ?? push 0
   8b 55 98 ?? mov edx, dword ss:[ebp + 0x98<152,-104>]
   52 ?? push edx
   e8 70 a6 ff ff ?? call function 0x00401258
  
  L7: 83 c4 0c ?? add esp, 12
   89 45 94 ?? mov dword ss:[ebp + 0x94<148,-108>], eax
   8b 45 a8 ?? mov eax, dword ss:[ebp + 0xa8<168,-88>]
   8b 4d 94 ?? mov ecx, dword ss:[ebp + 0x94<148,-108>]
   89 48 10 ?? mov dword ds:[eax + 0x10<16>], ecx
   8d 55 d4 ?? lea edx, ss:[ebp + 0xd4<212,-44>]
   52 ?? push edx
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 e7 a5 ff ff ?? call function 0x004011ea
  
  L8: 89 45 90 ?? mov dword ss:[ebp + 0x90<144,-112>], eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 96 a5 ff ff ?? call function 0x004011a4
  
  L9: 89 45 8c ?? mov dword ss:[ebp + 0x8c<140,-116>], eax
   8b 45 90 ?? mov eax, dword ss:[ebp + 0x90<144,-112>]
   50 ?? push eax
   6a 00 ?? push 0
   8b 4d 8c ?? mov ecx, dword ss:[ebp + 0x8c<140,-116>]
   51 ?? push ecx
   e8 38 a6 ff ff ?? call function 0x00401258
  
  L10: 83 c4 0c ?? add esp, 12
   89 45 88 ?? mov dword ss:[ebp + 0x88<136,-120>], eax
   8b 55 a8 ?? mov edx, dword ss:[ebp + 0xa8<168,-88>]
   8b 45 88 ?? mov eax, dword ss:[ebp + 0x88<136,-120>]
   89 42 14 ?? mov dword ds:[edx + 0x14<20>], eax
   eb 1e ?? jmp 0x00406c4f
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   51 ?? push ecx
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 88 a5 ff ff ?? call function 0x004011ea
  
  L11: 8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   e8 97 a6 ff ff ?? call function 0x004012d0
  
  L12: 6a 00 ?? push 0
   6a 00 ?? push 0
   e8 a9 2f 00 00 ?? call function 0x00409beb
  
  L13: c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   b8 56 6c 40 00 ?? mov eax, 0x00406c56
   c3 ?? ret
  
  L14: 50 ?? push eax
   6a 00 ?? push 0
   8b 55 ec ?? mov edx, dword ss:[ebp + 0xec<236,-20>]
   8b 02 ?? mov eax, dword ds:[edx]
   0f b6 08 ?? movzx ecx, byte ds:[eax]
   51 ?? push ecx
   e8 4a a5 ff ff ?? call function 0x004011bd
  
  L15: 83 c4 0c ?? add esp, 12
   8b 55 a8 ?? mov edx, dword ss:[ebp + 0xa8<168,-88>]
   88 42 0c ?? mov byte ds:[edx + 12], al
   8d 45 c4 ?? lea eax, ss:[ebp + 0xc4<196,-60>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 62 a5 ff ff ?? call function 0x004011ea
  
  L16: 50 ?? push eax
   6a 00 ?? push 0
   8b 4d ec ?? mov ecx, dword ss:[ebp + 0xec<236,-20>]
   8b 51 04 ?? mov edx, dword ds:[ecx + 4]
   0f b6 02 ?? movzx eax, byte ds:[edx]
   50 ?? push eax
   e8 23 a5 ff ff ?? call function 0x004011bd
  
  L17: 83 c4 0c ?? add esp, 12
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   88 41 0d ?? mov byte ds:[ecx + 13], al
   0f b6 55 0c ?? movzx edx, byte ss:[ebp + 12]
   85 d2 ?? test edx, edx
   74 60 ?? je basic block L25
  
  L18: 8d 45 bc ?? lea eax, ss:[ebp + 0xbc<188,-68>]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 33 a5 ff ff ?? call function 0x004011ea
  
  L19: 50 ?? push eax
   6a 00 ?? push 0
   68 c9 d1 43 00 ?? push 0x0043d1c9
   e8 94 a5 ff ff ?? call function 0x00401258
  
  L20: 83 c4 0c ?? add esp, 12
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   89 41 08 ?? mov dword ds:[ecx + 8], eax
   8d 55 b4 ?? lea edx, ss:[ebp + 0xb4<180,-76>]
   52 ?? push edx
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 11 a5 ff ff ?? call function 0x004011ea
  
  L21: 50 ?? push eax
   6a 00 ?? push 0
   6a 2e ?? push 0x2e<46>
   e8 da a4 ff ff ?? call function 0x004011bd
  
  L22: 83 c4 0c ?? add esp, 12
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   88 41 0c ?? mov byte ds:[ecx + 12], al
   8d 55 ac ?? lea edx, ss:[ebp + 0xac<172,-84>]
   52 ?? push edx
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   e8 f2 a4 ff ff ?? call function 0x004011ea
  
  L23: 50 ?? push eax
   6a 00 ?? push 0
   6a 2c ?? push 0x2c<44>
   e8 bb a4 ff ff ?? call function 0x004011bd
  
  L24: 83 c4 0c ?? add esp, 12
   8b 4d a8 ?? mov ecx, dword ss:[ebp + 0xa8<168,-88>]
   88 41 0d ?? mov byte ds:[ecx + 13], al
  
  L25: 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 08 00 ?? ret 8
  
  