Disassembly: 
  L1: 55 ?? push ebp
   8b ec ?? mov ebp, esp
   6a ff ?? push 0xff<255,-1>
   68 68 8d 40 00 ?? push 0x00408d68
   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
   8d 7d 88 ?? lea edi, ss:[ebp + 0x88<136,-120>]
   b9 1a 00 00 00 ?? mov ecx, 0x0000001a<26>
   b8 cc cc cc cc ?? mov eax, 0xcccccccc
   f3 ab ?? rep_stosd
   a1 04 d0 40 00 ?? mov eax, dword ds:[0x0040d004]
   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 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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 cc e0 40 00 ?? call dword ds:[function 0x0040e0cc]
  
  L2: 3b f4 ?? cmp esi, esp
   e8 af f4 ff ff ?? call function 0x004012ad
  
  L3: 89 45 bc ?? mov dword ss:[ebp + 0xbc<188,-68>], eax
   89 55 c0 ?? mov dword ss:[ebp + 0xc0<192,-64>], edx
   83 7d c0 00 ?? cmp dword ss:[ebp + 0xc0<192,-64>], 0
   7c 4d ?? jl basic block L12
  
  L4: 7f 06 ?? jg basic block L6
  
  L5: 83 7d bc 00 ?? cmp dword ss:[ebp + 0xbc<188,-68>], 0
   76 45 ?? jbe basic block L12
  
  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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 cc e0 40 00 ?? call dword ds:[function 0x0040e0cc]
  
  L7: 3b f4 ?? cmp esi, esp
   e8 7f f4 ff ff ?? call function 0x004012ad
  
  L8: 3b 45 10 ?? cmp eax, dword ss:[ebp + 0x10<16>]
   76 24 ?? jbe basic block L12
  
  L9: 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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 cc e0 40 00 ?? call dword ds:[function 0x0040e0cc]
  
  L10: 3b f4 ?? cmp esi, esp
   e8 5e f4 ff ff ?? call function 0x004012ad
  
  L11: 2b 45 10 ?? sub eax, dword ss:[ebp + 0x10<16>]
   89 45 b8 ?? mov dword ss:[ebp + 0xb8<184,-72>], eax
   eb 07 ?? jmp basic block L13
  
  L12: c7 45 b8 00 00 00 00 ?? mov dword ss:[ebp + 0xb8<184,-72>], 0
  
  L13: 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 dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 9b f5 ff ff ?? call function 0x0040140b
  
  L14: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   8d 4d dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 9f f1 ff ff ?? call function 0x0040101e
  
  L15: 0f b6 d0 ?? movzx edx, al
   85 d2 ?? test edx, edx
   75 0e ?? jne basic block L17
  
  L16: 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 3b 02 00 00 ?? jmp basic block L61
  
  L17: 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]
   8b f4 ?? mov esi, esp
   ff 15 d0 e0 40 00 ?? call dword ds:[function 0x0040e0d0]
  
  L18: 3b f4 ?? cmp esi, esp
   e8 fb f3 ff ff ?? call function 0x004012ad
  
  L19: 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 9e 00 00 00 ?? je basic block L33
  
  L20: eb 09 ?? jmp basic block L21
  
  L21: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   0f 86 89 00 00 00 ?? jbe basic block L33
  
  L22: 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]
   8b f4 ?? mov esi, esp
   ff 15 b0 e0 40 00 ?? call dword ds:[function 0x0040e0b0]
  
  L23: 3b f4 ?? cmp esi, esp
   e8 b8 f3 ff ff ?? call function 0x004012ad
  
  L24: 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]
   8b f4 ?? mov esi, esp
   ff 15 b4 e0 40 00 ?? call dword ds:[function 0x0040e0b4]
  
  L25: 3b f4 ?? cmp esi, esp
   e8 9b f3 ff ff ?? call function 0x004012ad
  
  L26: 89 45 ac ?? mov dword ss:[ebp + 0xac<172,-84>], eax
   8b f4 ?? mov esi, esp
   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>]
   ff 15 c4 e0 40 00 ?? call dword ds:[function 0x0040e0c4]
  
  L27: 3b f4 ?? cmp esi, esp
   e8 81 f3 ff ff ?? call function 0x004012ad
  
  L28: 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 01 f2 ff ff ?? call function 0x0040113b
  
  L29: 89 45 d0 ?? mov dword ss:[ebp + 0xd0<208,-48>], eax
   8d 55 d4 ?? lea edx, ss:[ebp + 0xd4<212,-44>]
   52 ?? push edx
   8d 45 d0 ?? lea eax, ss:[ebp + 0xd0<208,-48>]
   50 ?? push eax
   e8 45 f3 ff ff ?? call function 0x0040128f
  
  L30: 83 c4 08 ?? add esp, 8
   0f b6 c8 ?? movzx ecx, al
   85 c9 ?? test ecx, ecx
   74 0b ?? je basic block L32
  
  L31: 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
   eb 05 ?? jmp basic block L33
  
  L32: e9 64 ff ff ff ?? jmp 0x00401ec8
   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
  
  L33: 83 7d ec 00 ?? cmp dword ss:[ebp + 0xec<236,-20>], 0
   75 6b ?? jne basic block L41
  
  L34: 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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 b4 e0 40 00 ?? call dword ds:[function 0x0040e0b4]
  
  L35: 3b f4 ?? cmp esi, esp
   e8 27 f3 ff ff ?? call function 0x004012ad
  
  L36: 89 45 a4 ?? mov dword ss:[ebp + 0xa4<164,-92>], eax
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   33 c9 ?? xor ecx, ecx
   8b f4 ?? mov esi, esp
   51 ?? push ecx
   50 ?? push eax
   8b 55 0c ?? mov edx, dword ss:[ebp + 12]
   52 ?? push edx
   8b 4d a4 ?? mov ecx, dword ss:[ebp + 0xa4<164,-92>]
   ff 15 c0 e0 40 00 ?? call dword ds:[function 0x0040e0c0]
  
  L37: 3b f4 ?? cmp esi, esp
   e8 07 f3 ff ff ?? call function 0x004012ad
  
  L38: 89 45 9c ?? mov dword ss:[ebp + 0x9c<156,-100>], eax
   89 55 a0 ?? mov dword ss:[ebp + 0xa0<160,-96>], edx
   8b 45 10 ?? mov eax, dword ss:[ebp + 0x10<16>]
   33 c9 ?? xor ecx, ecx
   89 45 94 ?? mov dword ss:[ebp + 0x94<148,-108>], eax
   89 4d 98 ?? mov dword ss:[ebp + 0x98<152,-104>], ecx
   8b 55 9c ?? mov edx, dword ss:[ebp + 0x9c<156,-100>]
   3b 55 94 ?? cmp edx, dword ss:[ebp + 0x94<148,-108>]
   75 08 ?? jne basic block L40
  
  L39: 8b 45 a0 ?? mov eax, dword ss:[ebp + 0xa0<160,-96>]
   3b 45 98 ?? cmp eax, dword ss:[ebp + 0x98<152,-104>]
   74 0e ?? je basic block L41
  
  L40: 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
   e9 a2 00 00 00 ?? jmp basic block L54
  
  L41: eb 09 ?? jmp basic block L42
  
  L42: 83 7d e8 00 ?? cmp dword ss:[ebp + 0xe8<232,-24>], 0
   0f 86 8d 00 00 00 ?? jbe basic block L54
  
  L43: 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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 b0 e0 40 00 ?? call dword ds:[function 0x0040e0b0]
  
  L44: 3b f4 ?? cmp esi, esp
   e8 a7 f2 ff ff ?? call function 0x004012ad
  
  L45: 88 45 93 ?? mov byte ss:[ebp + 0x93<147,-109>], 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 f4 ?? mov esi, esp
   8b ca ?? mov ecx, edx
   ff 15 b4 e0 40 00 ?? call dword ds:[function 0x0040e0b4]
  
  L46: 3b f4 ?? cmp esi, esp
   e8 88 f2 ff ff ?? call function 0x004012ad
  
  L47: 89 45 8c ?? mov dword ss:[ebp + 0x8c<140,-116>], eax
   8b f4 ?? mov esi, esp
   0f b6 45 93 ?? movzx eax, byte ss:[ebp + 0x93<147,-109>]
   50 ?? push eax
   8b 4d 8c ?? mov ecx, dword ss:[ebp + 0x8c<140,-116>]
   ff 15 c4 e0 40 00 ?? call dword ds:[function 0x0040e0c4]
  
  L48: 3b f4 ?? cmp esi, esp
   e8 6e f2 ff ff ?? call function 0x004012ad
  
  L49: 89 45 88 ?? mov dword ss:[ebp + 0x88<136,-120>], eax
   8b 4d 88 ?? mov ecx, dword ss:[ebp + 0x88<136,-120>]
   89 4d cc ?? mov dword ss:[ebp + 0xcc<204,-52>], ecx
   e8 ee f0 ff ff ?? call function 0x0040113b
  
  L50: 89 45 c8 ?? mov dword ss:[ebp + 0xc8<200,-56>], eax
   8d 55 cc ?? lea edx, ss:[ebp + 0xcc<204,-52>]
   52 ?? push edx
   8d 45 c8 ?? lea eax, ss:[ebp + 0xc8<200,-56>]
   50 ?? push eax
   e8 32 f2 ff ff ?? call function 0x0040128f
  
  L51: 83 c4 08 ?? add esp, 8
   0f b6 c8 ?? movzx ecx, al
   85 c9 ?? test ecx, ecx
   74 0b ?? je basic block L53
  
  L52: 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
   eb 05 ?? jmp basic block L54
  
  L53: e9 60 ff ff ff ?? jmp 0x00401fd7
   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
  
  L54: 8b f4 ?? mov esi, esp
   6a 00 ?? push 0
   6a 00 ?? push 0
   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
   ff 15 c8 e0 40 00 ?? call dword ds:[function 0x0040e0c8]
  
  L55: 3b f4 ?? cmp esi, esp
   e8 16 f2 ff ff ?? call function 0x004012ad
  
  L56: eb 26 ?? jmp 0x004020bf
   c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
   eb 07 ?? jmp basic block L61
  
  L57: 8b f4 ?? mov esi, esp
   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
   ff 15 bc e0 40 00 ?? call dword ds:[function 0x0040e0bc]
  
  L58: 3b f4 ?? cmp esi, esp
   e8 f4 f1 ff ff ?? call function 0x004012ad
  
  L59: b8 c8 20 40 00 ?? mov eax, basic block L60
   c3 ?? ret
  
  L60: c7 45 fc 00 00 00 00 ?? mov dword ss:[ebp + 0xfc<252,-4>], 0
  
  L61: 8b f4 ?? mov esi, esp
   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]
   ff 15 bc e0 40 00 ?? call dword ds:[function 0x0040e0bc]
  
  L62: 3b f4 ?? cmp esi, esp
   e8 be f1 ff ff ?? call function 0x004012ad
  
  L63: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
   89 45 c4 ?? mov dword ss:[ebp + 0xc4<196,-60>], eax
   c7 45 fc ff ff ff ff ?? mov dword ss:[ebp + 0xfc<252,-4>], 0xffffffff<4294967295,-1>
   8d 4d dc ?? lea ecx, ss:[ebp + 0xdc<220,-36>]
   e8 19 f0 ff ff ?? call function 0x0040111d
  
  L64: 8b 45 c4 ?? mov eax, dword ss:[ebp + 0xc4<196,-60>]
   52 ?? push edx
   8b cd ?? mov ecx, ebp
   50 ?? push eax
   8d 15 34 21 40 00 ?? lea edx, ds:[0x00402134]
   e8 c9 f1 ff ff ?? call function 0x004012df
  
  L65: 58 ?? pop eax
   5a ?? pop edx
   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
   83 c4 78 ?? add esp, 0x78<120>
   3b ec ?? cmp ebp, esp
   e8 7d f1 ff ff ?? call function 0x004012ad
  
  L66: 8b e5 ?? mov esp, ebp
   5d ?? pop ebp
   c3 ?? ret
  
  