
L1: 8b ff ?? mov edi, edi
 55 ?? push ebp
 8b ec ?? mov ebp, esp
 81 ec c4 01 00 00 ?? sub esp, 0x000001c4<452>
 a1 3c 70 42 00 ?? mov eax, dword ds:[0x0042703c]
 33 c5 ?? xor eax, ebp
 89 45 fc ?? mov dword ss:[ebp + 0xfc<252,-4>], eax
 53 ?? push ebx
 57 ?? push edi
 8b d9 ?? mov ebx, ecx
 e8 16 be ff ff ?? call function 0x00403605

L2: ff 75 08 ?? push dword ss:[ebp + 8]
 8b f8 ?? mov edi, eax
 8d 85 68 fe ff ff ?? lea eax, ss:[ebp + 0xfffffe68<4294966888,-408>]
 50 ?? push eax
 8d 85 50 fe ff ff ?? lea eax, ss:[ebp + 0xfffffe50<4294966864,-432>]
 50 ?? push eax
 68 83 00 00 00 ?? push 0x00000083<131>
 8d 85 78 ff ff ff ?? lea eax, ss:[ebp + 0xffffff78<4294967160,-136>]
 50 ?? push eax
 53 ?? push ebx
 81 c7 d0 01 00 00 ?? add edi, 0x000001d0<464>
 e8 86 fd ff ff ?? call function 0x004075a0

L3: 83 c4 18 ?? add esp, 0x18<24>
 85 c0 ?? test eax, eax
 75 07 ?? jne basic block L5

L4: 33 c0 ?? xor eax, eax
 e9 9d 02 00 00 ?? jmp basic block L48

L5: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 c1 e0 04 ?? shl eax, 4
 8d 1c 30 ?? lea ebx, ds:[eax + esi]
 ff 73 48 ?? push dword ds:[ebx + 0x48<72>]
 8d 85 78 ff ff ff ?? lea eax, ss:[ebp + 0xffffff78<4294967160,-136>]
 50 ?? push eax
 e8 30 ed ff ff ?? call function 0x00406570

L6: 59 ?? pop ecx
 59 ?? pop ecx
 85 c0 ?? test eax, eax
 0f 84 78 02 00 00 ?? je basic block L47

L7: 8d 85 78 ff ff ff ?? lea eax, ss:[ebp + 0xffffff78<4294967160,-136>]
 50 ?? push eax
 e8 1a e9 ff ff ?? call function 0x00406170

L8: 83 c0 05 ?? add eax, 5
 50 ?? push eax
 89 85 74 fe ff ff ?? mov dword ss:[ebp + 0xfffffe74<4294966900,-396>], eax
 e8 ce ed ff ff ?? call function 0x00406633

L9: 59 ?? pop ecx
 59 ?? pop ecx
 89 85 70 fe ff ff ?? mov dword ss:[ebp + 0xfffffe70<4294966896,-400>], eax
 85 c0 ?? test eax, eax
 74 b0 ?? je basic block L4

L10: 8b 43 48 ?? mov eax, dword ds:[ebx + 0x48<72>]
 8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
 89 85 5c fe ff ff ?? mov dword ss:[ebp + 0xfffffe5c<4294966876,-420>], eax
 8d 44 8e 0c ?? lea eax, ds:[esi + ecx * 4 + 12]
 83 c1 06 ?? add ecx, 6
 6b c9 06 ?? imul ecx, ecx, 6
 89 85 6c fe ff ff ?? mov dword ss:[ebp + 0xfffffe6c<4294966892,-404>], eax
 8b 00 ?? mov eax, dword ds:[eax]
 89 85 58 fe ff ff ?? mov dword ss:[ebp + 0xfffffe58<4294966872,-424>], eax
 8d 04 31 ?? lea eax, ds:[ecx + esi]
 6a 06 ?? push 6
 50 ?? push eax
 89 85 64 fe ff ff ?? mov dword ss:[ebp + 0xfffffe64<4294966884,-412>], eax
 8d 85 3c fe ff ff ?? lea eax, ss:[ebp + 0xfffffe3c<4294966844,-452>]
 50 ?? push eax
 e8 d3 21 00 00 ?? call function 0x00409a80

L11: 8b 46 04 ?? mov eax, dword ds:[esi + 4]
 8d 8d 78 ff ff ff ?? lea ecx, ss:[ebp + 0xffffff78<4294967160,-136>]
 51 ?? push ecx
 8b 8d 74 fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe74<4294966900,-396>]
 89 85 4c fe ff ff ?? mov dword ss:[ebp + 0xfffffe4c<4294966860,-436>], eax
 8b 85 70 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe70<4294966896,-400>]
 83 c1 fc ?? add ecx, 0xfc<252,-4>
 83 c0 04 ?? add eax, 4
 51 ?? push ecx
 50 ?? push eax
 e8 2d e8 ff ff ?? call function 0x00406103

L12: 83 c4 18 ?? add esp, 0x18<24>
 85 c0 ?? test eax, eax
 74 0f ?? je basic block L15

L13: 33 c0 ?? xor eax, eax
 50 ?? push eax
 50 ?? push eax
 50 ?? push eax
 50 ?? push eax
 50 ?? push eax
 e8 b5 10 00 00 ?? call function 0x0040899e

L14: 83 c4 14 ?? add esp, 0x14<20>

L15: 8b 85 70 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe70<4294966896,-400>]
 8b 8d 6c fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe6c<4294966892,-404>]
 83 c0 04 ?? add eax, 4
 89 43 48 ?? mov dword ds:[ebx + 0x48<72>], eax
 0f b7 85 50 fe ff ff ?? movzx eax, word ss:[ebp + 0xfffffe50<4294966864,-432>]
 89 01 ?? mov dword ds:[ecx], eax
 6a 06 ?? push 6
 8d 85 50 fe ff ff ?? lea eax, ss:[ebp + 0xfffffe50<4294966864,-432>]
 50 ?? push eax
 ff b5 64 fe ff ff ?? push dword ss:[ebp + 0xfffffe64<4294966884,-412>]
 e8 65 21 00 00 ?? call function 0x00409a80

L16: 83 c4 0c ?? add esp, 12
 83 7d 08 02 ?? cmp dword ss:[ebp + 8], 2
 0f 85 f7 00 00 00 ?? jne basic block L34

L17: 8b 85 68 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe68<4294966888,-408>]
 83 a5 74 fe ff ff 00 ?? and dword ss:[ebp + 0xfffffe74<4294966900,-396>], 0
 89 46 04 ?? mov dword ds:[esi + 4], eax
 8b 47 24 ?? mov eax, dword ds:[edi + 0x24<36>]
 8b 4f 20 ?? mov ecx, dword ds:[edi + 0x20<32>]
 89 85 64 fe ff ff ?? mov dword ss:[ebp + 0xfffffe64<4294966884,-412>], eax
 8b c7 ?? mov eax, edi

L18: 8b 56 04 ?? mov edx, dword ds:[esi + 4]
 3b 10 ?? cmp edx, dword ds:[eax]
 74 36 ?? je basic block L21

L19: 8b 10 ?? mov edx, dword ds:[eax]
 ff 85 74 fe ff ff ?? inc dword ss:[ebp + 0xfffffe74<4294966900,-396>]
 89 08 ?? mov dword ds:[eax], ecx
 8b 8d 64 fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe64<4294966884,-412>]
 89 95 44 fe ff ff ?? mov dword ss:[ebp + 0xfffffe44<4294966852,-444>], edx
 8b 50 04 ?? mov edx, dword ds:[eax + 4]
 89 48 04 ?? mov dword ds:[eax + 4], ecx
 8b 8d 44 fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe44<4294966852,-444>]
 83 c0 08 ?? add eax, 8
 83 bd 74 fe ff ff 05 ?? cmp dword ss:[ebp + 0xfffffe74<4294966900,-396>], 5
 89 95 64 fe ff ff ?? mov dword ss:[ebp + 0xfffffe64<4294966884,-412>], edx
 7c c5 ?? jl basic block L18

L20: eb 22 ?? jmp basic block L23

L21: 8b 85 74 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe74<4294966900,-396>]
 85 c0 ?? test eax, eax
 74 18 ?? je basic block L23

L22: 8d 04 c7 ?? lea eax, ds:[edi + eax * 8]
 8b 10 ?? mov edx, dword ds:[eax]
 89 17 ?? mov dword ds:[edi], edx
 8b 50 04 ?? mov edx, dword ds:[eax + 4]
 89 57 04 ?? mov dword ds:[edi + 4], edx
 89 08 ?? mov dword ds:[eax], ecx
 8b 8d 64 fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe64<4294966884,-412>]
 89 48 04 ?? mov dword ds:[eax + 4], ecx

L23: 83 bd 74 fe ff ff 05 ?? cmp dword ss:[ebp + 0xfffffe74<4294966900,-396>], 5
 75 68 ?? jne basic block L33

L24: 6a 01 ?? push 1
 ff 76 14 ?? push dword ds:[esi + 0x14<20>]
 8d 85 78 fe ff ff ?? lea eax, ss:[ebp + 0xfffffe78<4294966904,-392>]
 ff 76 04 ?? push dword ds:[esi + 4]
 50 ?? push eax
 6a 7f ?? push 0x7f<127>
 68 78 32 42 00 ?? push 0x00423278
 6a 01 ?? push 1
 6a 00 ?? push 0
 e8 99 d6 00 00 ?? call function 0x00415066

L25: 83 c4 20 ?? add esp, 0x20<32>
 85 c0 ?? test eax, eax
 74 39 ?? je basic block L31

L26: 33 c0 ?? xor eax, eax

L27: b9 ff 01 00 00 ?? mov ecx, 0x000001ff<511>
 66 21 8c 45 78 fe ff ff ?? and word ss:[ebp + 0xfffffe78<4294966904,-392> + eax * 2], cx
 40 ?? inc eax
 83 f8 7f ?? cmp eax, 0x7f<127>

L28: 72 ed ?? jb basic block L27

L29: 68 fe 00 00 00 ?? push 0x000000fe<254>
 ff 35 c0 74 42 00 ?? push dword ds:[0x004274c0<"LAB">]
 8d 85 78 fe ff ff ?? lea eax, ss:[ebp + 0xfffffe78<4294966904,-392>]
 50 ?? push eax
 e8 2c be 00 00 ?? call function 0x0041382c

L30: 83 c4 0c ?? add esp, 12
 f7 d8 ?? neg eax
 1b c0 ?? sbb eax, eax
 40 ?? inc eax
 89 47 04 ?? mov dword ds:[edi + 4], eax
 eb 04 ?? jmp basic block L32

L31: 83 67 04 00 ?? and dword ds:[edi + 4], 0

L32: 8b 46 04 ?? mov eax, dword ds:[esi + 4]
 89 07 ?? mov dword ds:[edi], eax

L33: 8b 47 04 ?? mov eax, dword ds:[edi + 4]
 89 86 a8 00 00 00 ?? mov dword ds:[esi + 0x000000a8<168>], eax

L34: 83 7d 08 01 ?? cmp dword ss:[ebp + 8], 1
 75 09 ?? jne basic block L36

L35: 8b 85 68 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe68<4294966888,-408>]
 89 46 08 ?? mov dword ds:[esi + 8], eax

L36: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 6b c0 0c ?? imul eax, eax, 12
 56 ?? push esi
 ff 90 38 32 42 00 ?? call dword ds:[eax + 0x00423238<"Jr@">]

L37: 59 ?? pop ecx
 85 c0 ?? test eax, eax
 74 31 ?? je basic block L40

L38: 8b 85 5c fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe5c<4294966876,-420>]
 ff b5 70 fe ff ff ?? push dword ss:[ebp + 0xfffffe70<4294966896,-400>]
 89 43 48 ?? mov dword ds:[ebx + 0x48<72>], eax
 e8 df 9e ff ff ?? call function 0x00401933

L39: 8b 85 58 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe58<4294966872,-424>]
 59 ?? pop ecx
 8b 8d 6c fe ff ff ?? mov ecx, dword ss:[ebp + 0xfffffe6c<4294966892,-404>]
 89 01 ?? mov dword ds:[ecx], eax
 8b 85 4c fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe4c<4294966860,-436>]
 89 46 04 ?? mov dword ds:[esi + 4], eax
 e9 b0 fd ff ff ?? jmp basic block L4

L40: 81 bd 5c fe ff ff c8 74 ?? cmp dword ss:[ebp + 0xfffffe5c<4294966876,-420>], 0x004274c8<"C">
 42 00
 74 2d ?? je basic block L46

L41: 8b 45 08 ?? mov eax, dword ss:[ebp + 8]
 83 c0 05 ?? add eax, 5
 c1 e0 04 ?? shl eax, 4
 8d 3c 30 ?? lea edi, ds:[eax + esi]
 ff 37 ?? push dword ds:[edi]
 ff 15 f0 91 42 00 ?? call dword ds:[0x004291f0]

L42: 85 c0 ?? test eax, eax
 75 15 ?? jne basic block L46

L43: ff 37 ?? push dword ds:[edi]
 e8 97 9e ff ff ?? call function 0x00401933

L44: ff 73 54 ?? push dword ds:[ebx + 0x54<84>]
 e8 8f 9e ff ff ?? call function 0x00401933

L45: 83 63 4c 00 ?? and dword ds:[ebx + 0x4c<76>], 0
 59 ?? pop ecx
 59 ?? pop ecx

L46: 8b 4d 08 ?? mov ecx, dword ss:[ebp + 8]
 8b 85 70 fe ff ff ?? mov eax, dword ss:[ebp + 0xfffffe70<4294966896,-400>]
 83 c1 05 ?? add ecx, 5
 c1 e1 04 ?? shl ecx, 4
 c7 00 01 00 00 00 ?? mov dword ds:[eax], 1
 89 04 31 ?? mov dword ds:[ecx + esi], eax

L47: 8b 43 48 ?? mov eax, dword ds:[ebx + 0x48<72>]

L48: 8b 4d fc ?? mov ecx, dword ss:[ebp + 0xfc<252,-4>]
 5f ?? pop edi
 33 cd ?? xor ecx, ebp
 5b ?? pop ebx
 e8 53 9c ff ff ?? call function 0x00401724

L49: c9 ?? leave
 c3 ?? ret

