Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 90 83 43 00 ?? push 0x00438390
   64 a1 00 00 00 00 ?? mov eax, dword fs:[0]
   50 ?? push eax
   81 ec 94 00 00 00 ?? sub esp, 0x00000094<148>
   a1 44 44 44 00 ?? mov eax, dword ds:[0x00444444]
   33 c5 ?? xor eax, ebp
   89 45 e8 ?? mov dword ss:[ebp + 0xe8<232,-24>], eax
   56 ?? push esi
   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 8d 7c ff ff ff ?? mov dword ss:[ebp + 0xffffff7c<4294967164,-132>], ecx
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 a6 d1 ff ff ?? call function 0x00401320
  
  L2: 25 00 40 00 00 ?? and eax, 0x00004000<16384>
   75 3a ?? jne basic block L6
  
  L3: 0f b6 45 1c ?? movzx eax, byte ss:[ebp + 0x1c<28>]
   50 ?? push eax
   0f b6 4d 18 ?? movzx ecx, byte ss:[ebp + 0x18<24>]
   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
   8b 85 7c ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff7c<4294967164,-132>]
   8b 10 ?? mov edx, dword ds:[eax]
   8b 8d 7c ff ff ff ?? mov ecx, dword ss:[ebp + 0xffffff7c<4294967164,-132>]
   8b 42 1c ?? mov eax, dword ds:[edx + 0x1c<28>]
   ff d0 ?? call eax
  
  L4: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   e9 ef 01 00 00 ?? jmp basic block L38
  
  L5: e9 ea 01 00 00 ?? jmp basic block L38
  
  L6: 8d 4d c8 ?? lea ecx, ss:[ebp + 0xc8<200,-56>]
   51 ?? push ecx
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 f7 ce ff ff ?? call function 0x004010be
  
  L7: 89 85 78 ff ff ff ?? mov dword ss:[ebp + 0xffffff78<4294967160,-136>], eax
   8b 95 78 ff ff ff ?? mov edx, dword ss:[ebp + 0xffffff78<4294967160,-136>]
   89 95 74 ff ff ff ?? mov dword ss:[ebp + 0xffffff74<4294967156,-140>], edx
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8b 85 74 ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff74<4294967156,-140>]
   50 ?? push eax
   e8 7d ce ff ff ?? call function 0x00401069
  
  L8: 83 c4 04 ?? add esp, 4
   89 45 f0 ?? mov dword ss:[ebp + 0xf0<240,-16>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d c8 ?? lea ecx, ss:[ebp + 0xc8<200,-56>]
   e8 40 ce ff ff ?? call function 0x00401041
  
  L9: 8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 79 ce ff ff ?? call function 0x00401082
  
  L10: c7 45 fc 01 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 1
   0f b6 4d 1c ?? movzx ecx, byte ss:[ebp + 0x1c<28>]
   85 c9 ?? test ecx, ecx
   74 3f ?? je basic block L15
  
  L11: 8d 55 ac ?? lea edx, ss:[ebp + 0xac<172,-84>]
   52 ?? push edx
   8b 4d f0 ?? mov ecx, dword ss:[ebp + 0xf0<240,-16>]
   e8 98 d0 ff ff ?? call function 0x004012bc
  
  L12: 89 85 70 ff ff ff ?? mov dword ss:[ebp + 0xffffff70<4294967152,-144>], eax
   8b 85 70 ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff70<4294967152,-144>]
   89 85 6c ff ff ff ?? mov dword ss:[ebp + 0xffffff6c<4294967148,-148>], eax
   c6 45 fc 02 ?? mov byte ss:[ebp + 0xfc<252,-4>], 2
   8b 8d 6c ff ff ff ?? mov ecx, dword ss:[ebp + 0xffffff6c<4294967148,-148>]
   51 ?? push ecx
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 3d cf ff ff ?? call function 0x00401186
  
  L13: c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8d 4d ac ?? lea ecx, ss:[ebp + 0xac<172,-84>]
   e8 17 d0 ff ff ?? call function 0x0040126c
  
  L14: eb 3d ?? jmp basic block L18
  
  L15: 8d 55 90 ?? lea edx, ss:[ebp + 0x90<144,-112>]
   52 ?? push edx
   8b 4d f0 ?? mov ecx, dword ss:[ebp + 0xf0<240,-16>]
   e8 c4 ce ff ff ?? call function 0x00401127
  
  L16: 89 85 68 ff ff ff ?? mov dword ss:[ebp + 0xffffff68<4294967144,-152>], eax
   8b 85 68 ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff68<4294967144,-152>]
   89 85 64 ff ff ff ?? mov dword ss:[ebp + 0xffffff64<4294967140,-156>], eax
   c6 45 fc 03 ?? mov byte ss:[ebp + 0xfc<252,-4>], 3
   8b 8d 64 ff ff ff ?? mov ecx, dword ss:[ebp + 0xffffff64<4294967140,-156>]
   51 ?? push ecx
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 fe ce ff ff ?? call function 0x00401186
  
  L17: c6 45 fc 01 ?? mov byte ss:[ebp + 0xfc<252,-4>], 1
   8d 4d 90 ?? lea ecx, ss:[ebp + 0x90<144,-112>]
   e8 d8 cf ff ff ?? call function 0x0040126c
  
  L18: 8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 bd ce ff ff ?? call function 0x00401159
  
  L19: 85 c0 ?? test eax, eax
   7e 32 ?? jle basic block L26
  
  L20: 8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 b1 ce ff ff ?? call function 0x00401159
  
  L21: 8b f0 ?? mov esi, eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 05 d0 ff ff ?? call function 0x004012b7
  
  L22: 3b f0 ?? cmp esi, eax
   76 1c ?? jbe basic block L26
  
  L23: 8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 9b ce ff ff ?? call function 0x00401159
  
  L24: 8b f0 ?? mov esi, eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 ef cf ff ff ?? call function 0x004012b7
  
  L25: 2b f0 ?? sub esi, eax
   89 b5 60 ff ff ff ?? mov dword ss:[ebp + 0xffffff60<4294967136,-160>], esi
   eb 0a ?? jmp basic block L27
  
  L26: c7 85 60 ff ff ff 00 00 ?? mov dword ss:[ebp + 0xffffff60<4294967136,-160>], 0
   00 00
  
  L27: 8b 95 60 ff ff ff ?? mov edx, dword ss:[ebp + 0xffffff60<4294967136,-160>]
   89 55 ec ?? mov dword ss:[ebp + 0xec<236,-20>], edx
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 33 d0 ff ff ?? call function 0x00401320
  
  L28: 25 c0 01 00 00 ?? and eax, 0x000001c0<448>
   83 f8 40 ?? cmp eax, 0x40<64>
   74 36 ?? je basic block L31
  
  L29: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   50 ?? push eax
   0f b6 4d 18 ?? movzx ecx, byte ss:[ebp + 0x18<24>]
   51 ?? push ecx
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   52 ?? push edx
   8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   50 ?? push eax
   8d 4d 88 ?? lea ecx, ss:[ebp + 0x88<136,-120>]
   51 ?? push ecx
   8b 95 7c ff ff ff ?? mov edx, dword ss:[ebp + 0xffffff7c<4294967164,-132>]
   52 ?? push edx
   e8 96 ce ff ff ?? call function 0x004011ae
  
  L30: 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 0c ?? mov dword ss:[ebp + 12], ecx
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
   c7 45 ec 00 00 00 00 ?? mov dword ss:[ebp + 0xec<236,-20>], 0
  
  L31: 8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 82 cf ff ff ?? call function 0x004012b7
  
  L32: 50 ?? push eax
   8d 4d cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 9d ce ff ff ?? call function 0x004011db
  
  L33: 50 ?? push eax
   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
   8d 55 80 ?? lea edx, ss:[ebp + 0x80<128,-128>]
   52 ?? push edx
   8b 85 7c ff ff ff ?? mov eax, dword ss:[ebp + 0xffffff7c<4294967164,-132>]
   50 ?? push eax
   e8 80 cd ff ff ?? call function 0x004010d7
  
  L34: 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 0c ?? mov dword ss:[ebp + 12], ecx
   89 55 10 ?? mov dword ss:[ebp + 0x10<16>], edx
   6a 00 ?? push 0
   8b 4d 14 ?? mov ecx, dword ss:[ebp + 0x14<20>]
   e8 d1 cd ff ff ?? call function 0x00401140
  
  L35: 8b 45 ec ?? mov eax, dword ss:[ebp + 0xec<236,-20>]
   50 ?? push eax
   0f b6 4d 18 ?? movzx ecx, byte ss:[ebp + 0x18<24>]
   51 ?? push ecx
   8b 55 10 ?? mov edx, dword ss:[ebp + 0x10<16>]
   52 ?? push edx
   8b 45 0c ?? mov eax, dword ss:[ebp + 12]
   50 ?? push eax
   8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
   51 ?? push ecx
   8b 95 7c ff ff ff ?? mov edx, dword ss:[ebp + 0xffffff7c<4294967164,-132>]
   52 ?? push edx
   e8 1e ce ff ff ?? call function 0x004011ae
  
  L36: 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 cc ?? lea ecx, ss:[ebp + 0xcc<204,-52>]
   e8 ca ce ff ff ?? call function 0x0040126c
  
  L37: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
  
  L38: 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
   5e ?? pop esi
   8b 4d e8 ?? mov ecx, dword ss:[ebp + 0xe8<232,-24>]
   33 cd ?? xor ecx, ebp
   e8 91 57 00 00 ?? call function 0x00409b4c
  
  L39: 8b e5 ?? mov esp, ebp
   5d ?? pop ebp
   c2 18 00 ?? ret 0x0018<24>
  
  