Function at 0x101487a0
Capabilities:
Authenticate hmac
Parse pe header

Disassembly:
push ebx
mov ebx, esp
sub esp, 8
and esp, 0xfffffff8
add esp, 4
push ebp
mov ebp, dword [ebx + 4]
mov dword [esp + 4], ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x10315dc1
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x5588
call fcn.1030e0a0
mov eax, dword [0x10338040]
xor eax, ebp
mov dword [ebp - 0x14], eax
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov dword [ebp - 0x1b8], ecx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.players]
mov byte [ebp - 0x1b18], dl
movsx eax, byte [ebp - 0x1b18]
xor eax, 0xffffff98
mov byte [ebp - 0x1b19], al
mov cl, byte [ebp - 0x1b19]
mov byte [ebp - 0x2470], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.players]
mov byte [ebp - 0x1b20], al
movsx ecx, byte [ebp - 0x1b20]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b21], cl
mov dl, byte [ebp - 0x1b21]
mov byte [ebp - 0x246f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.players]
mov byte [ebp - 0x1b28], cl
movsx edx, byte [ebp - 0x1b28]
xor edx, 0xffffff98
mov byte [ebp - 0x1b29], dl
mov al, byte [ebp - 0x1b29]
mov byte [ebp - 0x246e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.players]
mov byte [ebp - 0x1b30], al
movsx ecx, byte [ebp - 0x1b30]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b31], cl
mov dl, byte [ebp - 0x1b31]
mov byte [ebp - 0x246d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.players]
mov byte [ebp - 0x1b38], cl
movsx edx, byte [ebp - 0x1b38]
xor edx, 0xffffff98
mov byte [ebp - 0x1b39], dl
mov al, byte [ebp - 0x1b39]
mov byte [ebp - 0x246c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.players]
mov byte [ebp - 0x1b40], al
movsx ecx, byte [ebp - 0x1b40]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b41], cl
mov dl, byte [ebp - 0x1b41]
mov byte [ebp - 0x246b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.players]
mov byte [ebp - 0x1b48], dl
movsx eax, byte [ebp - 0x1b48]
xor eax, 0xffffff98
mov byte [ebp - 0x1b49], al
mov cl, byte [ebp - 0x1b49]
mov byte [ebp - 0x246a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.players]
mov byte [ebp - 0x1b50], cl
movsx edx, byte [ebp - 0x1b50]
xor edx, 0xffffff98
mov byte [ebp - 0x1b51], dl
mov al, byte [ebp - 0x1b51]
mov byte [ebp - 0x2469], al
mov dword [ebp - 0x23b4], 0
jmp 0x10148983
mov ecx, dword [ebp - 0x23b4]
add ecx, 1
mov dword [ebp - 0x23b4], ecx
cmp dword [ebp - 0x23b4], 8
jae 0x10148a05
lea edx, [ebp - 0x2470]
mov dword [ebp - 0x3f70], edx
mov eax, dword [ebp - 0x3f70]
add eax, dword [ebp - 0x23b4]
mov dword [ebp - 0x3f74], eax
mov ecx, dword [ebp - 0x3f74]
mov dl, byte [ecx]
mov byte [ebp - 0x1b58], dl
mov al, byte [ebp - 0x2862]
mov byte [ebp - 0x279], al
movsx ecx, byte [ebp - 0x1b58]
xor ecx, 0xffffff98
mov byte [ebp - 0x279], cl
lea edx, [ebp - 0x2470]
mov dword [ebp - 0x3f78], edx
mov eax, dword [ebp - 0x3f78]
add eax, dword [ebp - 0x23b4]
mov dword [ebp - 0x3f7c], eax
mov ecx, dword [ebp - 0x3f7c]
mov dl, byte [ebp - 0x279]
mov byte [ecx], dl
jmp 0x10148974
lea eax, [ebp - 0x2470]
mov dword [ebp - 0x3f80], eax
mov ecx, dword [ebp - 0x3f80]
mov dword [ebp - 0x28d0], ecx
lea edx, [ebp - 0x4248]
mov dword [ebp - 0x3f84], edx
movzx eax, byte [ebp - 0x2863]
push eax
mov ecx, dword [ebp - 0x3f84]
call fcn.1008cde0
mov dword [ebp - 4], 0
mov ecx, dword [ebp - 0x28d0]
mov dword [ebp - 0x23b8], ecx
mov edx, dword [ebp - 0x23b8]
add edx, 1
mov dword [ebp - 0x3f88], edx
mov eax, dword [ebp - 0x23b8]
mov cl, byte [eax]
mov byte [ebp - 0x1b59], cl
add dword [ebp - 0x23b8], 1
cmp byte [ebp - 0x1b59], 0
jne 0x10148a5e
mov edx, dword [ebp - 0x23b8]
sub edx, dword [ebp - 0x3f88]
mov dword [ebp - 0x3f8c], edx
mov eax, dword [ebp - 0x3f8c]
mov dword [ebp - 0x3f90], eax
mov ecx, dword [ebp - 0x3f90]
mov dword [ebp - 0x3f94], ecx
mov edx, dword [ebp - 0x3f94]
push edx
mov eax, dword [ebp - 0x28d0]
push eax
lea ecx, [ebp - 0x4248]
call fcn.1008ce30
mov dword [ebp - 4], 1
lea ecx, [ebp - 0x4248]
push ecx
mov ecx, dword [ebp - 0x1b8]
call fcn.100ad110
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4248]
call fcn.1008b960
mov edx, dword [ebp - 0x1b8]
add edx, 0x30
mov dword [ebp - 0x1bc], edx
lea eax, [ebp - 0x2864]
mov dword [ebp - 0x3c00], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x103242e4]
mov byte [ebp - 0x1b60], al
movsx ecx, byte [ebp - 0x1b60]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b61], cl
mov dl, byte [ebp - 0x1b61]
mov byte [ebp - 0x1f44], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x103242e4]
mov byte [ebp - 0x1b68], cl
movsx edx, byte [ebp - 0x1b68]
xor edx, 0xffffff98
mov byte [ebp - 0x1b69], dl
mov al, byte [ebp - 0x1b69]
mov byte [ebp - 0x1f43], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x103242e4]
mov byte [ebp - 0x1b70], dl
movsx eax, byte [ebp - 0x1b70]
xor eax, 0xffffff98
mov byte [ebp - 0x1b71], al
mov cl, byte [ebp - 0x1b71]
mov byte [ebp - 0x1f42], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x103242e4]
mov byte [ebp - 0x1b78], cl
movsx edx, byte [ebp - 0x1b78]
xor edx, 0xffffff98
mov byte [ebp - 0x1b79], dl
mov al, byte [ebp - 0x1b79]
mov byte [ebp - 0x1f41], al
mov dword [ebp - 0x23bc], 0
jmp 0x10148bdf
mov ecx, dword [ebp - 0x23bc]
add ecx, 1
mov dword [ebp - 0x23bc], ecx
cmp dword [ebp - 0x23bc], 4
jae 0x10148c61
lea edx, [ebp - 0x1f44]
mov dword [ebp - 0x3f98], edx
mov eax, dword [ebp - 0x3f98]
add eax, dword [ebp - 0x23bc]
mov dword [ebp - 0x3f9c], eax
mov ecx, dword [ebp - 0x3f9c]
mov dl, byte [ecx]
mov byte [ebp - 0x1b80], dl
mov al, byte [ebp - 0x2865]
mov byte [ebp - 0x27a], al
movsx ecx, byte [ebp - 0x1b80]
xor ecx, 0xffffff98
mov byte [ebp - 0x27a], cl
lea edx, [ebp - 0x1f44]
mov dword [ebp - 0x3fa0], edx
mov eax, dword [ebp - 0x3fa0]
add eax, dword [ebp - 0x23bc]
mov dword [ebp - 0x3fa4], eax
mov ecx, dword [ebp - 0x3fa4]
mov dl, byte [ebp - 0x27a]
mov byte [ecx], dl
jmp 0x10148bd0
lea eax, [ebp - 0x1f44]
mov dword [ebp - 0x3fa8], eax
mov ecx, dword [ebp - 0x3fa8]
mov dword [ebp - 0x28d4], ecx
lea edx, [ebp - 0x5090]
mov dword [ebp - 0x3fac], edx
movzx eax, byte [ebp - 0x2866]
push eax
mov ecx, dword [ebp - 0x3fac]
call fcn.1008cde0
mov dword [ebp - 4], 2
mov ecx, dword [ebp - 0x28d4]
mov dword [ebp - 0x23c0], ecx
mov edx, dword [ebp - 0x23c0]
add edx, 1
mov dword [ebp - 0x3fb0], edx
mov eax, dword [ebp - 0x23c0]
mov cl, byte [eax]
mov byte [ebp - 0x1b81], cl
add dword [ebp - 0x23c0], 1
cmp byte [ebp - 0x1b81], 0
jne 0x10148cba
mov edx, dword [ebp - 0x23c0]
sub edx, dword [ebp - 0x3fb0]
mov dword [ebp - 0x3fb4], edx
mov eax, dword [ebp - 0x3fb4]
mov dword [ebp - 0x3fb8], eax
mov ecx, dword [ebp - 0x3fb8]
mov dword [ebp - 0x3fbc], ecx
mov edx, dword [ebp - 0x3fbc]
push edx
mov eax, dword [ebp - 0x28d4]
push eax
lea ecx, [ebp - 0x5090]
call fcn.1008ce30
mov dword [ebp - 4], 3
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.name]
mov byte [ebp - 0x1b88], al
movsx ecx, byte [ebp - 0x1b88]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b89], cl
mov dl, byte [ebp - 0x1b89]
mov byte [ebp - 0x1fac], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.name]
mov byte [ebp - 0x1b90], cl
movsx edx, byte [ebp - 0x1b90]
xor edx, 0xffffff98
mov byte [ebp - 0x1be5], dl
mov al, byte [ebp - 0x1be5]
mov byte [ebp - 0x1fab], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.name]
mov byte [ebp - 0x1bec], dl
movsx eax, byte [ebp - 0x1bec]
xor eax, 0xffffff98
mov byte [ebp - 0x1bed], al
mov cl, byte [ebp - 0x1bed]
mov byte [ebp - 0x1faa], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.name]
mov byte [ebp - 0x1bf4], cl
movsx edx, byte [ebp - 0x1bf4]
xor edx, 0xffffff98
mov byte [ebp - 0x1bf5], dl
mov al, byte [ebp - 0x1bf5]
mov byte [ebp - 0x1fa9], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.name]
mov byte [ebp - 0x1bfc], dl
movsx eax, byte [ebp - 0x1bfc]
xor eax, 0xffffff98
mov byte [ebp - 0x1bfd], al
mov cl, byte [ebp - 0x1bfd]
mov byte [ebp - 0x1fa8], cl
mov dword [ebp - 0x23c4], 0
jmp 0x10148e2c
mov edx, dword [ebp - 0x23c4]
add edx, 1
mov dword [ebp - 0x23c4], edx
cmp dword [ebp - 0x23c4], 5
jae 0x10148eae
lea eax, [ebp - 0x1fac]
mov dword [ebp - 0x3fc0], eax
mov ecx, dword [ebp - 0x3fc0]
add ecx, dword [ebp - 0x23c4]
mov dword [ebp - 0x3fc4], ecx
mov edx, dword [ebp - 0x3fc4]
mov al, byte [edx]
mov byte [ebp - 0x1c04], al
mov cl, byte [ebp - 0x2867]
mov byte [ebp - 0x27b], cl
movsx edx, byte [ebp - 0x1c04]
xor edx, 0xffffff98
mov byte [ebp - 0x27b], dl
lea eax, [ebp - 0x1fac]
mov dword [ebp - 0x3fc8], eax
mov ecx, dword [ebp - 0x3fc8]
add ecx, dword [ebp - 0x23c4]
mov dword [ebp - 0x3fcc], ecx
mov edx, dword [ebp - 0x3fcc]
mov al, byte [ebp - 0x27b]
mov byte [edx], al
jmp 0x10148e1d
lea ecx, [ebp - 0x1fac]
mov dword [ebp - 0x3fd0], ecx
mov edx, dword [ebp - 0x3fd0]
mov dword [ebp - 0x28d8], edx
lea eax, [ebp - 0x5078]
mov dword [ebp - 0x3fd4], eax
movzx ecx, byte [ebp - 0x2868]
push ecx
mov ecx, dword [ebp - 0x3fd4]
call fcn.1008cde0
mov byte [ebp - 4], 4
mov edx, dword [ebp - 0x28d8]
mov dword [ebp - 0x23c8], edx
mov eax, dword [ebp - 0x23c8]
add eax, 1
mov dword [ebp - 0x3fd8], eax
mov ecx, dword [ebp - 0x23c8]
mov dl, byte [ecx]
mov byte [ebp - 0x1c05], dl
add dword [ebp - 0x23c8], 1
cmp byte [ebp - 0x1c05], 0
jne 0x10148f04
mov eax, dword [ebp - 0x23c8]
sub eax, dword [ebp - 0x3fd8]
mov dword [ebp - 0x3fdc], eax
mov ecx, dword [ebp - 0x3fdc]
mov dword [ebp - 0x3fe0], ecx
mov edx, dword [ebp - 0x3fe0]
mov dword [ebp - 0x3fe4], edx
mov eax, dword [ebp - 0x3fe4]
push eax
mov ecx, dword [ebp - 0x28d8]
push ecx
lea ecx, [ebp - 0x5078]
call fcn.1008ce30
mov byte [ebp - 4], 5
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.health]
mov byte [ebp - 0x1c0c], cl
movsx edx, byte [ebp - 0x1c0c]
xor edx, 0xffffff98
mov byte [ebp - 0x1c0d], dl
mov al, byte [ebp - 0x1c0d]
mov byte [ebp - 0x2438], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.health]
mov byte [ebp - 0x1c14], dl
movsx eax, byte [ebp - 0x1c14]
xor eax, 0xffffff98
mov byte [ebp - 0x1c15], al
mov cl, byte [ebp - 0x1c15]
mov byte [ebp - 0x2437], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.health]
mov byte [ebp - 0x1c1c], al
movsx ecx, byte [ebp - 0x1c1c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c1d], cl
mov dl, byte [ebp - 0x1c1d]
mov byte [ebp - 0x2436], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.health]
mov byte [ebp - 0x1c24], dl
movsx eax, byte [ebp - 0x1c24]
xor eax, 0xffffff98
mov byte [ebp - 0x1c25], al
mov cl, byte [ebp - 0x1c25]
mov byte [ebp - 0x2435], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.health]
mov byte [ebp - 0x1c2c], al
movsx ecx, byte [ebp - 0x1c2c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c2d], cl
mov dl, byte [ebp - 0x1c2d]
mov byte [ebp - 0x2434], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.health]
mov byte [ebp - 0x1c34], dl
movsx eax, byte [ebp - 0x1c34]
xor eax, 0xffffff98
mov byte [ebp - 0x1c35], al
mov cl, byte [ebp - 0x1c35]
mov byte [ebp - 0x2433], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.health]
mov byte [ebp - 0x1c3c], cl
movsx edx, byte [ebp - 0x1c3c]
xor edx, 0xffffff98
mov byte [ebp - 0x1c3d], dl
mov al, byte [ebp - 0x1c3d]
mov byte [ebp - 0x2432], al
mov dword [ebp - 0x23cc], 0
jmp 0x101490d3
mov ecx, dword [ebp - 0x23cc]
add ecx, 1
mov dword [ebp - 0x23cc], ecx
cmp dword [ebp - 0x23cc], 7
jae 0x10149155
lea edx, [ebp - 0x2438]
mov dword [ebp - 0x3fe8], edx
mov eax, dword [ebp - 0x3fe8]
add eax, dword [ebp - 0x23cc]
mov dword [ebp - 0x3fec], eax
mov ecx, dword [ebp - 0x3fec]
mov dl, byte [ecx]
mov byte [ebp - 0x1c44], dl
mov al, byte [ebp - 0x2869]
mov byte [ebp - 0x27c], al
movsx ecx, byte [ebp - 0x1c44]
xor ecx, 0xffffff98
mov byte [ebp - 0x27c], cl
lea edx, [ebp - 0x2438]
mov dword [ebp - 0x3ff0], edx
mov eax, dword [ebp - 0x3ff0]
add eax, dword [ebp - 0x23cc]
mov dword [ebp - 0x3ff4], eax
mov ecx, dword [ebp - 0x3ff4]
mov dl, byte [ebp - 0x27c]
mov byte [ecx], dl
jmp 0x101490c4
lea eax, [ebp - 0x2438]
mov dword [ebp - 0x3ff8], eax
mov ecx, dword [ebp - 0x3ff8]
mov dword [ebp - 0x28dc], ecx
lea edx, [ebp - 0x5060]
mov dword [ebp - 0x3ffc], edx
movzx eax, byte [ebp - 0x286a]
push eax
mov ecx, dword [ebp - 0x3ffc]
call fcn.1008cde0
mov byte [ebp - 4], 6
mov ecx, dword [ebp - 0x28dc]
mov dword [ebp - 0x23d0], ecx
mov edx, dword [ebp - 0x23d0]
add edx, 1
mov dword [ebp - 0x4000], edx
mov eax, dword [ebp - 0x23d0]
mov cl, byte [eax]
mov byte [ebp - 0x1c45], cl
add dword [ebp - 0x23d0], 1
cmp byte [ebp - 0x1c45], 0
jne 0x101491ab
mov edx, dword [ebp - 0x23d0]
sub edx, dword [ebp - 0x4000]
mov dword [ebp - 0x4004], edx
mov eax, dword [ebp - 0x4004]
mov dword [ebp - 0x4008], eax
mov ecx, dword [ebp - 0x4008]
mov dword [ebp - 0x400c], ecx
mov edx, dword [ebp - 0x400c]
push edx
mov eax, dword [ebp - 0x28dc]
push eax
lea ecx, [ebp - 0x5060]
call fcn.1008ce30
mov byte [ebp - 4], 7
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.weapon]
mov byte [ebp - 0x1c4c], al
movsx ecx, byte [ebp - 0x1c4c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c4d], cl
mov dl, byte [ebp - 0x1c4d]
mov byte [ebp - 0x2440], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.weapon]
mov byte [ebp - 0x1c54], cl
movsx edx, byte [ebp - 0x1c54]
xor edx, 0xffffff98
mov byte [ebp - 0x1c55], dl
mov al, byte [ebp - 0x1c55]
mov byte [ebp - 0x243f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.weapon]
mov byte [ebp - 0x1c5c], dl
movsx eax, byte [ebp - 0x1c5c]
xor eax, 0xffffff98
mov byte [ebp - 0x1c5d], al
mov cl, byte [ebp - 0x1c5d]
mov byte [ebp - 0x243e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.weapon]
mov byte [ebp - 0x1c64], cl
movsx edx, byte [ebp - 0x1c64]
xor edx, 0xffffff98
mov byte [ebp - 0x1c65], dl
mov al, byte [ebp - 0x1c65]
mov byte [ebp - 0x243d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.weapon]
mov byte [ebp - 0x1c6c], dl
movsx eax, byte [ebp - 0x1c6c]
xor eax, 0xffffff98
mov byte [ebp - 0x1c6d], al
mov cl, byte [ebp - 0x1c6d]
mov byte [ebp - 0x243c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.weapon]
mov byte [ebp - 0x1c74], cl
movsx edx, byte [ebp - 0x1c74]
xor edx, 0xffffff98
mov byte [ebp - 0x1c75], dl
mov al, byte [ebp - 0x1c75]
mov byte [ebp - 0x243b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.weapon]
mov byte [ebp - 0x1c7c], al
movsx ecx, byte [ebp - 0x1c7c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c7d], cl
mov dl, byte [ebp - 0x1c7d]
mov byte [ebp - 0x243a], dl
mov dword [ebp - 0x23d4], 0
jmp 0x1014937a
mov eax, dword [ebp - 0x23d4]
add eax, 1
mov dword [ebp - 0x23d4], eax
cmp dword [ebp - 0x23d4], 7
jae 0x101493fc
lea ecx, [ebp - 0x2440]
mov dword [ebp - 0x4010], ecx
mov edx, dword [ebp - 0x4010]
add edx, dword [ebp - 0x23d4]
mov dword [ebp - 0x4014], edx
mov eax, dword [ebp - 0x4014]
mov cl, byte [eax]
mov byte [ebp - 0x1c84], cl
mov dl, byte [ebp - 0x286b]
mov byte [ebp - 0x27d], dl
movsx eax, byte [ebp - 0x1c84]
xor eax, 0xffffff98
mov byte [ebp - 0x27d], al
lea ecx, [ebp - 0x2440]
mov dword [ebp - 0x4018], ecx
mov edx, dword [ebp - 0x4018]
add edx, dword [ebp - 0x23d4]
mov dword [ebp - 0x401c], edx
mov eax, dword [ebp - 0x401c]
mov cl, byte [ebp - 0x27d]
mov byte [eax], cl
jmp 0x1014936b
lea edx, [ebp - 0x2440]
mov dword [ebp - 0x4020], edx
mov eax, dword [ebp - 0x4020]
mov dword [ebp - 0x28e0], eax
lea ecx, [ebp - 0x5048]
mov dword [ebp - 0x4024], ecx
movzx edx, byte [ebp - 0x286c]
push edx
mov ecx, dword [ebp - 0x4024]
call fcn.1008cde0
mov byte [ebp - 4], 8
mov eax, dword [ebp - 0x28e0]
mov dword [ebp - 0x23d8], eax
mov ecx, dword [ebp - 0x23d8]
add ecx, 1
mov dword [ebp - 0x4028], ecx
mov edx, dword [ebp - 0x23d8]
mov al, byte [edx]
mov byte [ebp - 0x1c85], al
add dword [ebp - 0x23d8], 1
cmp byte [ebp - 0x1c85], 0
jne 0x10149452
mov ecx, dword [ebp - 0x23d8]
sub ecx, dword [ebp - 0x4028]
mov dword [ebp - 0x402c], ecx
mov edx, dword [ebp - 0x402c]
mov dword [ebp - 0x4030], edx
mov eax, dword [ebp - 0x4030]
mov dword [ebp - 0x4034], eax
mov ecx, dword [ebp - 0x4034]
push ecx
mov edx, dword [ebp - 0x28e0]
push edx
lea ecx, [ebp - 0x5048]
call fcn.1008ce30
mov byte [ebp - 4], 9
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.ammo]
mov byte [ebp - 0x1c8c], dl
movsx eax, byte [ebp - 0x1c8c]
xor eax, 0xffffff98
mov byte [ebp - 0x1c8d], al
mov cl, byte [ebp - 0x1c8d]
mov byte [ebp - 0x1fa4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.ammo]
mov byte [ebp - 0x1c94], al
movsx ecx, byte [ebp - 0x1c94]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c95], cl
mov dl, byte [ebp - 0x1c95]
mov byte [ebp - 0x1fa3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x1c9c], cl
movsx edx, byte [ebp - 0x1c9c]
xor edx, 0xffffff98
mov byte [ebp - 0x1c9d], dl
mov al, byte [ebp - 0x1c9d]
mov byte [ebp - 0x1fa2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.ammo]
mov byte [ebp - 0x1ca4], al
movsx ecx, byte [ebp - 0x1ca4]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ca5], cl
mov dl, byte [ebp - 0x1ca5]
mov byte [ebp - 0x1fa1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x1cac], cl
movsx edx, byte [ebp - 0x1cac]
xor edx, 0xffffff98
mov byte [ebp - 0x1cad], dl
mov al, byte [ebp - 0x1cad]
mov byte [ebp - 0x1fa0], al
mov dword [ebp - 0x23dc], 0
jmp 0x101495c1
mov ecx, dword [ebp - 0x23dc]
add ecx, 1
mov dword [ebp - 0x23dc], ecx
cmp dword [ebp - 0x23dc], 5
jae 0x10149643
lea edx, [ebp - 0x1fa4]
mov dword [ebp - 0x4038], edx
mov eax, dword [ebp - 0x4038]
add eax, dword [ebp - 0x23dc]
mov dword [ebp - 0x403c], eax
mov ecx, dword [ebp - 0x403c]
mov dl, byte [ecx]
mov byte [ebp - 0x1cb4], dl
mov al, byte [ebp - 0x286d]
mov byte [ebp - 0x27e], al
movsx ecx, byte [ebp - 0x1cb4]
xor ecx, 0xffffff98
mov byte [ebp - 0x27e], cl
lea edx, [ebp - 0x1fa4]
mov dword [ebp - 0x4040], edx
mov eax, dword [ebp - 0x4040]
add eax, dword [ebp - 0x23dc]
mov dword [ebp - 0x4044], eax
mov ecx, dword [ebp - 0x4044]
mov dl, byte [ebp - 0x27e]
mov byte [ecx], dl
jmp 0x101495b2
lea eax, [ebp - 0x1fa4]
mov dword [ebp - 0x4048], eax
mov ecx, dword [ebp - 0x4048]
mov dword [ebp - 0x28e4], ecx
lea edx, [ebp - 0x5030]
mov dword [ebp - 0x404c], edx
movzx eax, byte [ebp - 0x286e]
push eax
mov ecx, dword [ebp - 0x404c]
call fcn.1008cde0
mov byte [ebp - 4], 0xa
mov ecx, dword [ebp - 0x28e4]
mov dword [ebp - 0x23e0], ecx
mov edx, dword [ebp - 0x23e0]
add edx, 1
mov dword [ebp - 0x4050], edx
mov eax, dword [ebp - 0x23e0]
mov cl, byte [eax]
mov byte [ebp - 0x1cb5], cl
add dword [ebp - 0x23e0], 1
cmp byte [ebp - 0x1cb5], 0
jne 0x10149699
mov edx, dword [ebp - 0x23e0]
sub edx, dword [ebp - 0x4050]
mov dword [ebp - 0x4054], edx
mov eax, dword [ebp - 0x4054]
mov dword [ebp - 0x4058], eax
mov ecx, dword [ebp - 0x4058]
mov dword [ebp - 0x405c], ecx
mov edx, dword [ebp - 0x405c]
push edx
mov eax, dword [ebp - 0x28e4]
push eax
lea ecx, [ebp - 0x5030]
call fcn.1008ce30
mov byte [ebp - 4], 0xb
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.lby_timer]
mov byte [ebp - 0x1cbc], al
movsx ecx, byte [ebp - 0x1cbc]
xor ecx, 0xffffff98
mov byte [ebp - 0x1cbd], cl
mov dl, byte [ebp - 0x1cbd]
mov byte [ebp - 0x24ec], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.lby_timer]
mov byte [ebp - 0x1cc4], cl
movsx edx, byte [ebp - 0x1cc4]
xor edx, 0xffffff98
mov byte [ebp - 0x1cc5], dl
mov al, byte [ebp - 0x1cc5]
mov byte [ebp - 0x24eb], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.lby_timer]
mov byte [ebp - 0x1ccc], dl
movsx eax, byte [ebp - 0x1ccc]
xor eax, 0xffffff98
mov byte [ebp - 0x1ccd], al
mov cl, byte [ebp - 0x1ccd]
mov byte [ebp - 0x24ea], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.lby_timer]
mov byte [ebp - 0x1cd8], cl
movsx edx, byte [ebp - 0x1cd8]
xor edx, 0xffffff98
mov byte [ebp - 0x1cd9], dl
mov al, byte [ebp - 0x1cd9]
mov byte [ebp - 0x24e9], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.lby_timer]
mov byte [ebp - 0x1ce0], dl
movsx eax, byte [ebp - 0x1ce0]
xor eax, 0xffffff98
mov byte [ebp - 0x1ce1], al
mov cl, byte [ebp - 0x1ce1]
mov byte [ebp - 0x24e8], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.lby_timer]
mov byte [ebp - 0x1ce8], cl
movsx edx, byte [ebp - 0x1ce8]
xor edx, 0xffffff98
mov byte [ebp - 0x1ce9], dl
mov al, byte [ebp - 0x1ce9]
mov byte [ebp - 0x24e7], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.lby_timer]
mov byte [ebp - 0x1cf0], al
movsx ecx, byte [ebp - 0x1cf0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1cf1], cl
mov dl, byte [ebp - 0x1cf1]
mov byte [ebp - 0x24e6], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.lby_timer]
mov byte [ebp - 0x1cf8], dl
movsx eax, byte [ebp - 0x1cf8]
xor eax, 0xffffff98
mov byte [ebp - 0x1cf9], al
mov cl, byte [ebp - 0x1cf9]
mov byte [ebp - 0x24e5], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.lby_timer]
mov byte [ebp - 0x1d00], al
movsx ecx, byte [ebp - 0x1d00]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d01], cl
mov dl, byte [ebp - 0x1d01]
mov byte [ebp - 0x24e4], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.lby_timer]
mov byte [ebp - 0x1d08], dl
movsx eax, byte [ebp - 0x1d08]
xor eax, 0xffffff98
mov byte [ebp - 0x1d09], al
mov cl, byte [ebp - 0x1d09]
mov byte [ebp - 0x24e3], cl
mov dword [ebp - 0x23e4], 0
jmp 0x101498f8
mov edx, dword [ebp - 0x23e4]
add edx, 1
mov dword [ebp - 0x23e4], edx
cmp dword [ebp - 0x23e4], 0xa
jae 0x1014997a
lea eax, [ebp - 0x24ec]
mov dword [ebp - 0x4060], eax
mov ecx, dword [ebp - 0x4060]
add ecx, dword [ebp - 0x23e4]
mov dword [ebp - 0x4064], ecx
mov edx, dword [ebp - 0x4064]
mov al, byte [edx]
mov byte [ebp - 0x1d10], al
mov cl, byte [ebp - 0x286f]
mov byte [ebp - 0x27f], cl
movsx edx, byte [ebp - 0x1d10]
xor edx, 0xffffff98
mov byte [ebp - 0x27f], dl
lea eax, [ebp - 0x24ec]
mov dword [ebp - 0x37e0], eax
mov ecx, dword [ebp - 0x37e0]
add ecx, dword [ebp - 0x23e4]
mov dword [ebp - 0x3808], ecx
mov edx, dword [ebp - 0x3808]
mov al, byte [ebp - 0x27f]
mov byte [edx], al
jmp 0x101498e9
lea ecx, [ebp - 0x24ec]
mov dword [ebp - 0x3880], ecx
mov edx, dword [ebp - 0x3880]
mov dword [ebp - 0x28e8], edx
lea eax, [ebp - 0x5018]
mov dword [ebp - 0x3900], eax
movzx ecx, byte [ebp - 0x2870]
push ecx
mov ecx, dword [ebp - 0x3900]
call fcn.1008cde0
mov byte [ebp - 4], 0xc
mov edx, dword [ebp - 0x28e8]
mov dword [ebp - 0x23e8], edx
mov eax, dword [ebp - 0x23e8]
add eax, 1
mov dword [ebp - 0x392c], eax
mov ecx, dword [ebp - 0x23e8]
mov dl, byte [ecx]
mov byte [ebp - 0x1d11], dl
add dword [ebp - 0x23e8], 1
cmp byte [ebp - 0x1d11], 0
jne 0x101499d0
mov eax, dword [ebp - 0x23e8]
sub eax, dword [ebp - 0x392c]
mov dword [ebp - 0x3958], eax
mov ecx, dword [ebp - 0x3958]
mov dword [ebp - 0x3980], ecx
mov edx, dword [ebp - 0x3980]
mov dword [ebp - 0x39a8], edx
mov eax, dword [ebp - 0x39a8]
push eax
mov ecx, dword [ebp - 0x28e8]
push ecx
lea ecx, [ebp - 0x5018]
call fcn.1008ce30
mov byte [ebp - 4], 0xd
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.off_screen]
mov byte [ebp - 0x1414], cl
movsx edx, byte [ebp - 0x1414]
xor edx, 0xffffff98
mov byte [ebp - 0x1d12], dl
mov al, byte [ebp - 0x1d12]
mov byte [ebp - 0x251c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.off_screen]
mov byte [ebp - 0x1d18], dl
movsx eax, byte [ebp - 0x1d18]
xor eax, 0xffffff98
mov byte [ebp - 0x1d19], al
mov cl, byte [ebp - 0x1d19]
mov byte [ebp - 0x251b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.off_screen]
mov byte [ebp - 0x1d20], al
movsx ecx, byte [ebp - 0x1d20]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d21], cl
mov dl, byte [ebp - 0x1d21]
mov byte [ebp - 0x251a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.off_screen]
mov byte [ebp - 0x1d28], dl
movsx eax, byte [ebp - 0x1d28]
xor eax, 0xffffff98
mov byte [ebp - 0x1d29], al
mov cl, byte [ebp - 0x1d29]
mov byte [ebp - 0x2519], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.off_screen]
mov byte [ebp - 0x1d30], al
movsx ecx, byte [ebp - 0x1d30]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d31], cl
mov dl, byte [ebp - 0x1d31]
mov byte [ebp - 0x2518], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.off_screen]
mov byte [ebp - 0x1d38], dl
movsx eax, byte [ebp - 0x1d38]
xor eax, 0xffffff98
mov byte [ebp - 0x1d39], al
mov cl, byte [ebp - 0x1d39]
mov byte [ebp - 0x2517], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.off_screen]
mov byte [ebp - 0x1d40], cl
movsx edx, byte [ebp - 0x1d40]
xor edx, 0xffffff98
mov byte [ebp - 0x1d41], dl
mov al, byte [ebp - 0x1d41]
mov byte [ebp - 0x2516], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.off_screen]
mov byte [ebp - 0x1d48], al
movsx ecx, byte [ebp - 0x1d48]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d49], cl
mov dl, byte [ebp - 0x1d49]
mov byte [ebp - 0x2515], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.off_screen]
mov byte [ebp - 0x1d50], cl
movsx edx, byte [ebp - 0x1d50]
xor edx, 0xffffff98
mov byte [ebp - 0x1d51], dl
mov al, byte [ebp - 0x1d51]
mov byte [ebp - 0x2514], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.off_screen]
mov byte [ebp - 0x1d58], al
movsx ecx, byte [ebp - 0x1d58]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d59], cl
mov dl, byte [ebp - 0x1d59]
mov byte [ebp - 0x2513], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.off_screen]
mov byte [ebp - 0x1d60], dl
movsx eax, byte [ebp - 0x1d60]
xor eax, 0xffffff98
mov byte [ebp - 0x1d61], al
mov cl, byte [ebp - 0x1d61]
mov byte [ebp - 0x2512], cl
mov dword [ebp - 0x23ec], 0
jmp 0x10149c5f
mov edx, dword [ebp - 0x23ec]
add edx, 1
mov dword [ebp - 0x23ec], edx
cmp dword [ebp - 0x23ec], 0xb
jae 0x10149ce1
lea eax, [ebp - 0x251c]
mov dword [ebp - 0x3a28], eax
mov ecx, dword [ebp - 0x3a28]
add ecx, dword [ebp - 0x23ec]
mov dword [ebp - 0x3a54], ecx
mov edx, dword [ebp - 0x3a54]
mov al, byte [edx]
mov byte [ebp - 0x1d68], al
mov cl, byte [ebp - 0x2871]
mov byte [ebp - 0x280], cl
movsx edx, byte [ebp - 0x1d68]
xor edx, 0xffffff98
mov byte [ebp - 0x280], dl
lea eax, [ebp - 0x251c]
mov dword [ebp - 0x3a7c], eax
mov ecx, dword [ebp - 0x3a7c]
add ecx, dword [ebp - 0x23ec]
mov dword [ebp - 0x3aa4], ecx
mov edx, dword [ebp - 0x3aa4]
mov al, byte [ebp - 0x280]
mov byte [edx], al
jmp 0x10149c50
lea ecx, [ebp - 0x251c]
mov dword [ebp - 0x3acc], ecx
mov edx, dword [ebp - 0x3acc]
mov dword [ebp - 0x28ec], edx
lea eax, [ebp - 0x5000]
mov dword [ebp - 0x3b4c], eax
movzx ecx, byte [ebp - 0x2872]
push ecx
mov ecx, dword [ebp - 0x3b4c]
call fcn.1008cde0
mov byte [ebp - 4], 0xe
mov edx, dword [ebp - 0x28ec]
mov dword [ebp - 0x23f0], edx
mov eax, dword [ebp - 0x23f0]
add eax, 1
mov dword [ebp - 0x3b78], eax
mov ecx, dword [ebp - 0x23f0]
mov dl, byte [ecx]
mov byte [ebp - 0x1d69], dl
add dword [ebp - 0x23f0], 1
cmp byte [ebp - 0x1d69], 0
jne 0x10149d37
mov eax, dword [ebp - 0x23f0]
sub eax, dword [ebp - 0x3b78]
mov dword [ebp - 0x3ba4], eax
mov ecx, dword [ebp - 0x3ba4]
mov dword [ebp - 0x3bb0], ecx
mov edx, dword [ebp - 0x3bb0]
mov dword [ebp - 0x3bd8], edx
mov eax, dword [ebp - 0x3bd8]
push eax
mov ecx, dword [ebp - 0x28ec]
push ecx
lea ecx, [ebp - 0x5000]
call fcn.1008ce30
mov dword [ebp - 4], 0xf
lea edx, [ebp - 0x5090]
mov dword [ebp - 0x3e04], edx
lea eax, [ebp - 0x4fe8]
mov dword [ebp - 0x3e00], eax
mov ecx, dword [ebp - 0x3e04]
mov edx, dword [ebp - 0x3e00]
mov dword [ebp - 0x3e10], ecx
mov dword [ebp - 0x3e0c], edx
mov eax, dword [ebp - 0x3c00]
push eax
mov ecx, dword [ebp - 0x3e0c]
push ecx
mov edx, dword [ebp - 0x3e10]
push edx
lea ecx, [ebp - 0x409c]
call fcn.10260fe0
mov byte [ebp - 4], 0x10
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x103242f4]
mov byte [ebp - 0x1d70], dl
movsx eax, byte [ebp - 0x1d70]
xor eax, 0xffffff98
mov byte [ebp - 0x1d71], al
mov cl, byte [ebp - 0x1d71]
mov byte [ebp - 0x264c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x103242f4]
mov byte [ebp - 0x1d78], al
movsx ecx, byte [ebp - 0x1d78]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d79], cl
mov dl, byte [ebp - 0x1d79]
mov byte [ebp - 0x264b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x103242f4]
mov byte [ebp - 0x1d80], cl
movsx edx, byte [ebp - 0x1d80]
xor edx, 0xffffff98
mov byte [ebp - 0x1d81], dl
mov al, byte [ebp - 0x1d81]
mov byte [ebp - 0x264a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x103242f4]
mov byte [ebp - 0x1d88], al
movsx ecx, byte [ebp - 0x1d88]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d89], cl
mov dl, byte [ebp - 0x1d89]
mov byte [ebp - 0x2649], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x103242f4]
mov byte [ebp - 0x1d90], cl
movsx edx, byte [ebp - 0x1d90]
xor edx, 0xffffff98
mov byte [ebp - 0x1d91], dl
mov al, byte [ebp - 0x1d91]
mov byte [ebp - 0x2648], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x103242f4]
mov byte [ebp - 0x1d98], al
movsx ecx, byte [ebp - 0x1d98]
xor ecx, 0xffffff98
mov byte [ebp - 0x1d99], cl
mov dl, byte [ebp - 0x1d99]
mov byte [ebp - 0x2647], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x103242f4]
mov byte [ebp - 0x1da0], dl
movsx eax, byte [ebp - 0x1da0]
xor eax, 0xffffff98
mov byte [ebp - 0x1da1], al
mov cl, byte [ebp - 0x1da1]
mov byte [ebp - 0x2646], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x103242f4]
mov byte [ebp - 0x1da8], cl
movsx edx, byte [ebp - 0x1da8]
xor edx, 0xffffff98
mov byte [ebp - 0x1da9], dl
mov al, byte [ebp - 0x1da9]
mov byte [ebp - 0x2645], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x103242f4]
mov byte [ebp - 0x1db0], dl
movsx eax, byte [ebp - 0x1db0]
xor eax, 0xffffff98
mov byte [ebp - 0x1db1], al
mov cl, byte [ebp - 0x1db1]
mov byte [ebp - 0x2644], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + 0x103242f4]
mov byte [ebp - 0x1db8], cl
movsx edx, byte [ebp - 0x1db8]
xor edx, 0xffffff98
mov byte [ebp - 0x1db9], dl
mov al, byte [ebp - 0x1db9]
mov byte [ebp - 0x2643], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + 0x103242f4]
mov byte [ebp - 0x1dc0], al
movsx ecx, byte [ebp - 0x1dc0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1dc1], cl
mov dl, byte [ebp - 0x1dc1]
mov byte [ebp - 0x2642], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + 0x103242f4]
mov byte [ebp - 0x1dc8], dl
movsx eax, byte [ebp - 0x1dc8]
xor eax, 0xffffff98
mov byte [ebp - 0x1dc9], al
mov cl, byte [ebp - 0x1dc9]
mov byte [ebp - 0x2641], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + 0x103242f4]
mov byte [ebp - 0x1dd0], cl
movsx edx, byte [ebp - 0x1dd0]
xor edx, 0xffffff98
mov byte [ebp - 0x1dd1], dl
mov al, byte [ebp - 0x1dd1]
mov byte [ebp - 0x2640], al
mov dword [ebp - 0x23f4], 0
jmp 0x1014a07d
mov ecx, dword [ebp - 0x23f4]
add ecx, 1
mov dword [ebp - 0x23f4], ecx
cmp dword [ebp - 0x23f4], 0xd
jae 0x1014a0ff
lea edx, [ebp - 0x264c]
mov dword [ebp - 0x3c80], edx
mov eax, dword [ebp - 0x3c80]
add eax, dword [ebp - 0x23f4]
mov dword [ebp - 0x3c98], eax
mov ecx, dword [ebp - 0x3c98]
mov dl, byte [ecx]
mov byte [ebp - 0x1dd8], dl
mov al, byte [ebp - 0x2873]
mov byte [ebp - 0x281], al
movsx ecx, byte [ebp - 0x1dd8]
xor ecx, 0xffffff98
mov byte [ebp - 0x281], cl
lea edx, [ebp - 0x264c]
mov dword [ebp - 0x3cac], edx
mov eax, dword [ebp - 0x3cac]
add eax, dword [ebp - 0x23f4]
mov dword [ebp - 0x3cd4], eax
mov ecx, dword [ebp - 0x3cd4]
mov dl, byte [ebp - 0x281]
mov byte [ecx], dl
jmp 0x1014a06e
lea eax, [ebp - 0x264c]
mov dword [ebp - 0x3d00], eax
mov ecx, dword [ebp - 0x3d00]
mov dword [ebp - 0x28f0], ecx
lea edx, [ebp - 0x4278]
mov dword [ebp - 0x3d28], edx
movzx eax, byte [ebp - 0x2874]
push eax
mov ecx, dword [ebp - 0x3d28]
call fcn.1008cde0
mov byte [ebp - 4], 0x11
mov ecx, dword [ebp - 0x28f0]
mov dword [ebp - 0x23f8], ecx
mov edx, dword [ebp - 0x23f8]
add edx, 1
mov dword [ebp - 0x3d34], edx
mov eax, dword [ebp - 0x23f8]
mov cl, byte [eax]
mov byte [ebp - 0x1dd9], cl
add dword [ebp - 0x23f8], 1
cmp byte [ebp - 0x1dd9], 0
jne 0x1014a155
mov edx, dword [ebp - 0x23f8]
sub edx, dword [ebp - 0x3d34]
mov dword [ebp - 0x3d38], edx
mov eax, dword [ebp - 0x3d38]
mov dword [ebp - 0x3d3c], eax
mov ecx, dword [ebp - 0x3d3c]
mov dword [ebp - 0x3d40], ecx
mov edx, dword [ebp - 0x3d40]
push edx
mov eax, dword [ebp - 0x28f0]
push eax
lea ecx, [ebp - 0x4278]
call fcn.1008ce30
mov byte [ebp - 4], 0x12
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.esp_elements]
mov byte [ebp - 0x1de0], al
movsx ecx, byte [ebp - 0x1de0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1de1], cl
mov dl, byte [ebp - 0x1de1]
mov byte [ebp - 0x263c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.esp_elements]
mov byte [ebp - 0x1de8], cl
movsx edx, byte [ebp - 0x1de8]
xor edx, 0xffffff98
mov byte [ebp - 0x1de9], dl
mov al, byte [ebp - 0x1de9]
mov byte [ebp - 0x263b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.esp_elements]
mov byte [ebp - 0x1df0], dl
movsx eax, byte [ebp - 0x1df0]
xor eax, 0xffffff98
mov byte [ebp - 0x1df1], al
mov cl, byte [ebp - 0x1df1]
mov byte [ebp - 0x263a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.esp_elements]
mov byte [ebp - 0x1df8], cl
movsx edx, byte [ebp - 0x1df8]
xor edx, 0xffffff98
mov byte [ebp - 0x1df9], dl
mov al, byte [ebp - 0x1df9]
mov byte [ebp - 0x2639], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.esp_elements]
mov byte [ebp - 0x1e00], dl
movsx eax, byte [ebp - 0x1e00]
xor eax, 0xffffff98
mov byte [ebp - 0x1e01], al
mov cl, byte [ebp - 0x1e01]
mov byte [ebp - 0x2638], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.esp_elements]
mov byte [ebp - 0x1e08], cl
movsx edx, byte [ebp - 0x1e08]
xor edx, 0xffffff98
mov byte [ebp - 0x1e09], dl
mov al, byte [ebp - 0x1e09]
mov byte [ebp - 0x2637], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.esp_elements]
mov byte [ebp - 0x1e10], al
movsx ecx, byte [ebp - 0x1e10]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e11], cl
mov dl, byte [ebp - 0x1e11]
mov byte [ebp - 0x2636], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.esp_elements]
mov byte [ebp - 0x1e18], dl
movsx eax, byte [ebp - 0x1e18]
xor eax, 0xffffff98
mov byte [ebp - 0x1e19], al
mov cl, byte [ebp - 0x1e19]
mov byte [ebp - 0x2635], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.esp_elements]
mov byte [ebp - 0x1e20], al
movsx ecx, byte [ebp - 0x1e20]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e21], cl
mov dl, byte [ebp - 0x1e21]
mov byte [ebp - 0x2634], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.esp_elements]
mov byte [ebp - 0x1e28], dl
movsx eax, byte [ebp - 0x1e28]
xor eax, 0xffffff98
mov byte [ebp - 0x1e29], al
mov cl, byte [ebp - 0x1e29]
mov byte [ebp - 0x2633], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.esp_elements]
mov byte [ebp - 0x1e30], cl
movsx edx, byte [ebp - 0x1e30]
xor edx, 0xffffff98
mov byte [ebp - 0x1e31], dl
mov al, byte [ebp - 0x1e31]
mov byte [ebp - 0x2632], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.esp_elements]
mov byte [ebp - 0x1e38], al
movsx ecx, byte [ebp - 0x1e38]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e39], cl
mov dl, byte [ebp - 0x1e39]
mov byte [ebp - 0x2631], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.esp_elements]
mov byte [ebp - 0x1e40], dl
movsx eax, byte [ebp - 0x1e40]
xor eax, 0xffffff98
mov byte [ebp - 0x1e41], al
mov cl, byte [ebp - 0x1e41]
mov byte [ebp - 0x2630], cl
mov dword [ebp - 0x23fc], 0
jmp 0x1014a444
mov edx, dword [ebp - 0x23fc]
add edx, 1
mov dword [ebp - 0x23fc], edx
cmp dword [ebp - 0x23fc], 0xd
jae 0x1014a4c6
lea eax, [ebp - 0x263c]
mov dword [ebp - 0x3d44], eax
mov ecx, dword [ebp - 0x3d44]
add ecx, dword [ebp - 0x23fc]
mov dword [ebp - 0x3d48], ecx
mov edx, dword [ebp - 0x3d48]
mov al, byte [edx]
mov byte [ebp - 0x1e48], al
mov cl, byte [ebp - 0x2875]
mov byte [ebp - 0x282], cl
movsx edx, byte [ebp - 0x1e48]
xor edx, 0xffffff98
mov byte [ebp - 0x282], dl
lea eax, [ebp - 0x263c]
mov dword [ebp - 0x3d4c], eax
mov ecx, dword [ebp - 0x3d4c]
add ecx, dword [ebp - 0x23fc]
mov dword [ebp - 0x3d50], ecx
mov edx, dword [ebp - 0x3d50]
mov al, byte [ebp - 0x282]
mov byte [edx], al
jmp 0x1014a435
lea ecx, [ebp - 0x263c]
mov dword [ebp - 0x3d54], ecx
mov edx, dword [ebp - 0x3d54]
mov dword [ebp - 0x28f4], edx
lea eax, [ebp - 0x4260]
mov dword [ebp - 0x3d58], eax
movzx ecx, byte [ebp - 0x2876]
push ecx
mov ecx, dword [ebp - 0x3d58]
call fcn.1008cde0
mov byte [ebp - 4], 0x13
mov edx, dword [ebp - 0x28f4]
mov dword [ebp - 0x2400], edx
mov eax, dword [ebp - 0x2400]
add eax, 1
mov dword [ebp - 0x3d5c], eax
mov ecx, dword [ebp - 0x2400]
mov dl, byte [ecx]
mov byte [ebp - 0x1e49], dl
add dword [ebp - 0x2400], 1
cmp byte [ebp - 0x1e49], 0
jne 0x1014a51c
mov eax, dword [ebp - 0x2400]
sub eax, dword [ebp - 0x3d5c]
mov dword [ebp - 0x3d60], eax
mov ecx, dword [ebp - 0x3d60]
mov dword [ebp - 0x3d64], ecx
mov edx, dword [ebp - 0x3d64]
mov dword [ebp - 0x3d68], edx
mov eax, dword [ebp - 0x3d68]
push eax
mov ecx, dword [ebp - 0x28f4]
push ecx
lea ecx, [ebp - 0x4260]
call fcn.1008ce30
mov byte [ebp - 4], 0x14
lea edx, [ebp - 0x4090]
mov dword [ebp - 0x2738], edx
mov eax, dword [ebp - 0x2738]
mov dword [ebp - 0x3d6c], eax
mov ecx, dword [ebp - 0x3d6c]
call fcn.1008da90
mov ecx, dword [ebp - 0x2738]
mov dword [ebp - 0x4178], ecx
mov edx, dword [ebp - 0x2738]
mov dword [ebp - 0x417c], edx
mov byte [ebp - 4], 0x15
lea eax, [ebp - 0x4278]
push eax
mov ecx, dword [ebp - 0x1bc]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1bc]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1bc]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1014a602
lea ecx, [ebp - 0x4260]
push ecx
mov ecx, dword [ebp - 0x1bc]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x1bc]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1014a61c
mov dword [ebp - 0x28f8], 0xf
jmp 0x1014a626
mov dword [ebp - 0x28f8], 0
mov ecx, dword [ebp - 0x1bc]
mov edx, dword [ebp - 0x28f8]
mov dword [ecx + 0xa4], edx
mov eax, dword [ebp - 0x1bc]
mov ecx, dword [eax + 0xa4]
add ecx, 0x14
mov dword [ebp - 0x28fc], ecx
mov edx, dword [ebp - 0x1bc]
mov eax, dword [ebp - 0x28fc]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0x1bc]
mov edx, dword [ebp - 0x28fc]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x409c]
mov dword [ebp - 0x2900], eax
mov ecx, dword [ebp - 0x2900]
mov edx, dword [ecx]
mov dword [ebp - 0x2590], edx
mov eax, dword [ebp - 0x2900]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x3d70], ecx
jmp 0x1014a6a5
mov edx, dword [ebp - 0x2590]
add edx, 0x18
mov dword [ebp - 0x2590], edx
mov eax, dword [ebp - 0x2590]
cmp eax, dword [ebp - 0x3d70]
je 0x1014a6e5
mov ecx, dword [ebp - 0x2590]
mov dword [ebp - 0x3d74], ecx
mov edx, dword [ebp - 0x1bc]
add edx, 0x88
mov dword [ebp - 0x3d78], edx
mov eax, dword [ebp - 0x3d74]
push eax
mov ecx, dword [ebp - 0x3d78]
call fcn.100fca00
jmp 0x1014a696
lea ecx, [ebp - 0x4090]
mov dword [ebp - 0x2904], ecx
mov edx, dword [ebp - 0x2904]
mov eax, dword [edx]
mov dword [ebp - 0x259c], eax
mov ecx, dword [ebp - 0x2904]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x3d7c], edx
jmp 0x1014a71f
mov eax, dword [ebp - 0x259c]
add eax, 4
mov dword [ebp - 0x259c], eax
mov ecx, dword [ebp - 0x259c]
cmp ecx, dword [ebp - 0x3d7c]
je 0x1014a8a6
mov edx, dword [ebp - 0x259c]
mov dword [ebp - 0x3d80], edx
mov eax, dword [ebp - 0x3d80]
mov ecx, dword [eax]
mov dword [ebp - 0x20], ecx
mov edx, dword [ebp - 0x1bc]
add edx, 0x98
mov dword [ebp - 0x3d84], edx
lea eax, [ebp - 0x4180]
push eax
mov ecx, dword [ebp - 0x3d84]
call fcn.10098ab0
mov ecx, dword [eax]
mov dword [ebp - 0x3d8c], ecx
mov edx, dword [ebp - 0x1bc]
add edx, 0x98
mov dword [ebp - 0x3d88], edx
lea eax, [ebp - 0x4188]
push eax
mov ecx, dword [ebp - 0x3d88]
call fcn.10098af0
mov ecx, dword [eax]
mov dword [ebp - 0x3d90], ecx
lea edx, [ebp - 0x20]
push edx
mov eax, dword [ebp - 0x3d8c]
push eax
mov ecx, dword [ebp - 0x3d90]
push ecx
lea edx, [ebp - 0x4184]
push edx
call fcn.1009a180
add esp, 0x10
mov dword [ebp - 0x3d98], eax
mov eax, dword [ebp - 0x1bc]
add eax, 0x98
mov dword [ebp - 0x3d94], eax
lea ecx, [ebp - 0x418c]
push ecx
mov ecx, dword [ebp - 0x3d94]
call fcn.10098ab0
mov dword [ebp - 0x3d9c], eax
mov edx, dword [ebp - 0x3d98]
mov eax, dword [ebp - 0x3d9c]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x1014a80e
mov dword [ebp - 0x2908], 1
jmp 0x1014a818
mov dword [ebp - 0x2908], 0
mov dl, byte [ebp - 0x2908]
mov byte [ebp - 0x1e4a], dl
mov eax, dword [ebp - 0x1bc]
add eax, 0x88
mov dword [ebp - 0x290c], eax
mov ecx, dword [ebp - 0x290c]
mov edx, dword [ebp - 0x290c]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x3da0], eax
mov edx, dword [ebp - 0x20]
cmp edx, dword [ebp - 0x3da0]
jae 0x1014a87f
mov eax, dword [ebp - 0x1bc]
add eax, 0x98
mov dword [ebp - 0x3da4], eax
lea ecx, [ebp - 0x20]
push ecx
mov ecx, dword [ebp - 0x3da4]
call fcn.1008c950
movzx edx, byte [ebp - 0x1e4a]
test edx, edx
je 0x1014a8a1
mov eax, dword [ebp - 0x1bc]
cmp dword [eax + 0x64], 0
je 0x1014a8a1
mov ecx, dword [ebp - 0x1bc]
mov edx, dword [ecx + 0x64]
call edx
jmp 0x1014a710
mov byte [ebp - 4], 0x14
lea ecx, [ebp - 0x4090]
call fcn.1008b490
mov byte [ebp - 4], 0x12
lea ecx, [ebp - 0x4260]
call fcn.1008b960
mov byte [ebp - 4], 0x10
lea ecx, [ebp - 0x4278]
call fcn.1008b960
mov byte [ebp - 4], 0xf
lea ecx, [ebp - 0x409c]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 7
push 0x18
lea eax, [ebp - 0x5090]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x30
mov dword [ebp - 0x5c], ecx
mov edx, dword [ebp - 0x5c]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x5c]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x5c]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x5c]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x5c]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x3da8], ecx
lea edx, [ebp - 0x5c]
push edx
mov ecx, dword [ebp - 0x3da8]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x4b0
mov dword [ebp - 0x1c8], eax
lea ecx, [ebp - 0x2877]
mov dword [ebp - 0x2b3c], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.money]
mov byte [ebp - 0x1e50], cl
movsx edx, byte [ebp - 0x1e50]
xor edx, 0xffffff98
mov byte [ebp - 0x1e51], dl
mov al, byte [ebp - 0x1e51]
mov byte [ebp - 0x2304], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.money]
mov byte [ebp - 0x1e58], dl
movsx eax, byte [ebp - 0x1e58]
xor eax, 0xffffff98
mov byte [ebp - 0x1e59], al
mov cl, byte [ebp - 0x1e59]
mov byte [ebp - 0x2303], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.money]
mov byte [ebp - 0x1e60], al
movsx ecx, byte [ebp - 0x1e60]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e61], cl
mov dl, byte [ebp - 0x1e61]
mov byte [ebp - 0x2302], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.money]
mov byte [ebp - 0x1e68], dl
movsx eax, byte [ebp - 0x1e68]
xor eax, 0xffffff98
mov byte [ebp - 0x1e69], al
mov cl, byte [ebp - 0x1e69]
mov byte [ebp - 0x2301], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.money]
mov byte [ebp - 0x1e70], al
movsx ecx, byte [ebp - 0x1e70]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e71], cl
mov dl, byte [ebp - 0x1e71]
mov byte [ebp - 0x2300], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.money]
mov byte [ebp - 0x1e78], dl
movsx eax, byte [ebp - 0x1e78]
xor eax, 0xffffff98
mov byte [ebp - 0x1e79], al
mov cl, byte [ebp - 0x1e79]
mov byte [ebp - 0x22ff], cl
mov dword [ebp - 0x2404], 0
jmp 0x1014aab5
mov edx, dword [ebp - 0x2404]
add edx, 1
mov dword [ebp - 0x2404], edx
cmp dword [ebp - 0x2404], 6
jae 0x1014ab37
lea eax, [ebp - 0x2304]
mov dword [ebp - 0x3dac], eax
mov ecx, dword [ebp - 0x3dac]
add ecx, dword [ebp - 0x2404]
mov dword [ebp - 0x3db0], ecx
mov edx, dword [ebp - 0x3db0]
mov al, byte [edx]
mov byte [ebp - 0x1e80], al
mov cl, byte [ebp - 0x2878]
mov byte [ebp - 0x283], cl
movsx edx, byte [ebp - 0x1e80]
xor edx, 0xffffff98
mov byte [ebp - 0x283], dl
lea eax, [ebp - 0x2304]
mov dword [ebp - 0x3db4], eax
mov ecx, dword [ebp - 0x3db4]
add ecx, dword [ebp - 0x2404]
mov dword [ebp - 0x3db8], ecx
mov edx, dword [ebp - 0x3db8]
mov al, byte [ebp - 0x283]
mov byte [edx], al
jmp 0x1014aaa6
lea ecx, [ebp - 0x2304]
mov dword [ebp - 0x3dbc], ecx
mov edx, dword [ebp - 0x3dbc]
mov dword [ebp - 0x2910], edx
lea eax, [ebp - 0x5220]
mov dword [ebp - 0x3dc0], eax
movzx ecx, byte [ebp - 0x2861]
push ecx
mov ecx, dword [ebp - 0x3dc0]
call fcn.1008cde0
mov dword [ebp - 4], 0x16
mov edx, dword [ebp - 0x2910]
mov dword [ebp - 0x2408], edx
mov eax, dword [ebp - 0x2408]
add eax, 1
mov dword [ebp - 0x3dc4], eax
mov ecx, dword [ebp - 0x2408]
mov dl, byte [ecx]
mov byte [ebp - 0x1e81], dl
add dword [ebp - 0x2408], 1
cmp byte [ebp - 0x1e81], 0
jne 0x1014ab90
mov eax, dword [ebp - 0x2408]
sub eax, dword [ebp - 0x3dc4]
mov dword [ebp - 0x3dc8], eax
mov ecx, dword [ebp - 0x3dc8]
mov dword [ebp - 0x3dcc], ecx
mov edx, dword [ebp - 0x3dcc]
mov dword [ebp - 0x3dd0], edx
mov eax, dword [ebp - 0x3dd0]
push eax
mov ecx, dword [ebp - 0x2910]
push ecx
lea ecx, [ebp - 0x5220]
call fcn.1008ce30
mov dword [ebp - 4], 0x17
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.armor]
mov byte [ebp - 0x1e88], cl
movsx edx, byte [ebp - 0x1e88]
xor edx, 0xffffff98
mov byte [ebp - 0x1e89], dl
mov al, byte [ebp - 0x1e89]
mov byte [ebp - 0x230c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.armor]
mov byte [ebp - 0x1e90], dl
movsx eax, byte [ebp - 0x1e90]
xor eax, 0xffffff98
mov byte [ebp - 0x1e91], al
mov cl, byte [ebp - 0x1e91]
mov byte [ebp - 0x230b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.armor]
mov byte [ebp - 0x1e98], al
movsx ecx, byte [ebp - 0x1e98]
xor ecx, 0xffffff98
mov byte [ebp - 0x1e99], cl
mov dl, byte [ebp - 0x1e99]
mov byte [ebp - 0x230a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.armor]
mov byte [ebp - 0x1ea0], dl
movsx eax, byte [ebp - 0x1ea0]
xor eax, 0xffffff98
mov byte [ebp - 0x1ea1], al
mov cl, byte [ebp - 0x1ea1]
mov byte [ebp - 0x2309], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.armor]
mov byte [ebp - 0x1ea8], al
movsx ecx, byte [ebp - 0x1ea8]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ea9], cl
mov dl, byte [ebp - 0x1ea9]
mov byte [ebp - 0x2308], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.armor]
mov byte [ebp - 0x1eb0], dl
movsx eax, byte [ebp - 0x1eb0]
xor eax, 0xffffff98
mov byte [ebp - 0x1eb1], al
mov cl, byte [ebp - 0x1eb1]
mov byte [ebp - 0x2307], cl
mov dword [ebp - 0x240c], 0
jmp 0x1014ad32
mov edx, dword [ebp - 0x240c]
add edx, 1
mov dword [ebp - 0x240c], edx
cmp dword [ebp - 0x240c], 6
jae 0x1014adb4
lea eax, [ebp - 0x230c]
mov dword [ebp - 0x3dd4], eax
mov ecx, dword [ebp - 0x3dd4]
add ecx, dword [ebp - 0x240c]
mov dword [ebp - 0x3dd8], ecx
mov edx, dword [ebp - 0x3dd8]
mov al, byte [edx]
mov byte [ebp - 0x1eb8], al
mov cl, byte [ebp - 0x2879]
mov byte [ebp - 0x284], cl
movsx edx, byte [ebp - 0x1eb8]
xor edx, 0xffffff98
mov byte [ebp - 0x284], dl
lea eax, [ebp - 0x230c]
mov dword [ebp - 0x3ddc], eax
mov ecx, dword [ebp - 0x3ddc]
add ecx, dword [ebp - 0x240c]
mov dword [ebp - 0x3de0], ecx
mov edx, dword [ebp - 0x3de0]
mov al, byte [ebp - 0x284]
mov byte [edx], al
jmp 0x1014ad23
lea ecx, [ebp - 0x230c]
mov dword [ebp - 0x3de4], ecx
mov edx, dword [ebp - 0x3de4]
mov dword [ebp - 0x2914], edx
lea eax, [ebp - 0x5208]
mov dword [ebp - 0x3de8], eax
movzx ecx, byte [ebp - 0x287a]
push ecx
mov ecx, dword [ebp - 0x3de8]
call fcn.1008cde0
mov byte [ebp - 4], 0x18
mov edx, dword [ebp - 0x2914]
mov dword [ebp - 0x237c], edx
mov eax, dword [ebp - 0x237c]
add eax, 1
mov dword [ebp - 0x3dec], eax
mov ecx, dword [ebp - 0x237c]
mov dl, byte [ecx]
mov byte [ebp - 0x1eb9], dl
add dword [ebp - 0x237c], 1
cmp byte [ebp - 0x1eb9], 0
jne 0x1014ae0a
mov eax, dword [ebp - 0x237c]
sub eax, dword [ebp - 0x3dec]
mov dword [ebp - 0x3df0], eax
mov ecx, dword [ebp - 0x3df0]
mov dword [ebp - 0x3df4], ecx
mov edx, dword [ebp - 0x3df4]
mov dword [ebp - 0x3df8], edx
mov eax, dword [ebp - 0x3df8]
push eax
mov ecx, dword [ebp - 0x2914]
push ecx
lea ecx, [ebp - 0x5208]
call fcn.1008ce30
mov byte [ebp - 4], 0x19
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.scoped]
mov byte [ebp - 0x1ec0], cl
movsx edx, byte [ebp - 0x1ec0]
xor edx, 0xffffff98
mov byte [ebp - 0x1ec1], dl
mov al, byte [ebp - 0x1ec1]
mov byte [ebp - 0x2448], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.scoped]
mov byte [ebp - 0x1ec8], dl
movsx eax, byte [ebp - 0x1ec8]
xor eax, 0xffffff98
mov byte [ebp - 0x1ec9], al
mov cl, byte [ebp - 0x1ec9]
mov byte [ebp - 0x2447], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.scoped]
mov byte [ebp - 0x1ed0], al
movsx ecx, byte [ebp - 0x1ed0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ed1], cl
mov dl, byte [ebp - 0x1ed1]
mov byte [ebp - 0x2446], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.scoped]
mov byte [ebp - 0x1ed8], dl
movsx eax, byte [ebp - 0x1ed8]
xor eax, 0xffffff98
mov byte [ebp - 0x1ed9], al
mov cl, byte [ebp - 0x1ed9]
mov byte [ebp - 0x2445], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.scoped]
mov byte [ebp - 0x1ee0], al
movsx ecx, byte [ebp - 0x1ee0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ee1], cl
mov dl, byte [ebp - 0x1ee1]
mov byte [ebp - 0x2444], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.scoped]
mov byte [ebp - 0x1ee8], dl
movsx eax, byte [ebp - 0x1ee8]
xor eax, 0xffffff98
mov byte [ebp - 0x1ee9], al
mov cl, byte [ebp - 0x1ee9]
mov byte [ebp - 0x2443], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.scoped]
mov byte [ebp - 0x1ef0], cl
movsx edx, byte [ebp - 0x1ef0]
xor edx, 0xffffff98
mov byte [ebp - 0x1ef1], dl
mov al, byte [ebp - 0x1ef1]
mov byte [ebp - 0x2442], al
mov dword [ebp - 0x2380], 0
jmp 0x1014afd9
mov ecx, dword [ebp - 0x2380]
add ecx, 1
mov dword [ebp - 0x2380], ecx
cmp dword [ebp - 0x2380], 7
jae 0x1014b05b
lea edx, [ebp - 0x2448]
mov dword [ebp - 0x3dfc], edx
mov eax, dword [ebp - 0x3dfc]
add eax, dword [ebp - 0x2380]
mov dword [ebp - 0x3e8c], eax
mov ecx, dword [ebp - 0x3e8c]
mov dl, byte [ecx]
mov byte [ebp - 0x1ef8], dl
mov al, byte [ebp - 0x287b]
mov byte [ebp - 0x285], al
movsx ecx, byte [ebp - 0x1ef8]
xor ecx, 0xffffff98
mov byte [ebp - 0x285], cl
lea edx, [ebp - 0x2448]
mov dword [ebp - 0x3e90], edx
mov eax, dword [ebp - 0x3e90]
add eax, dword [ebp - 0x2380]
mov dword [ebp - 0x3e94], eax
mov ecx, dword [ebp - 0x3e94]
mov dl, byte [ebp - 0x285]
mov byte [ecx], dl
jmp 0x1014afca
lea eax, [ebp - 0x2448]
mov dword [ebp - 0x3e98], eax
mov ecx, dword [ebp - 0x3e98]
mov dword [ebp - 0x2918], ecx
lea edx, [ebp - 0x51f0]
mov dword [ebp - 0x3e9c], edx
movzx eax, byte [ebp - 0x287c]
push eax
mov ecx, dword [ebp - 0x3e9c]
call fcn.1008cde0
mov byte [ebp - 4], 0x1a
mov ecx, dword [ebp - 0x2918]
mov dword [ebp - 0x2384], ecx
mov edx, dword [ebp - 0x2384]
add edx, 1
mov dword [ebp - 0x3ea0], edx
mov eax, dword [ebp - 0x2384]
mov cl, byte [eax]
mov byte [ebp - 0x1ef9], cl
add dword [ebp - 0x2384], 1
cmp byte [ebp - 0x1ef9], 0
jne 0x1014b0b1
mov edx, dword [ebp - 0x2384]
sub edx, dword [ebp - 0x3ea0]
mov dword [ebp - 0x3ea4], edx
mov eax, dword [ebp - 0x3ea4]
mov dword [ebp - 0x3ea8], eax
mov ecx, dword [ebp - 0x3ea8]
mov dword [ebp - 0x3eac], ecx
mov edx, dword [ebp - 0x3eac]
push edx
mov eax, dword [ebp - 0x2918]
push eax
lea ecx, [ebp - 0x51f0]
call fcn.1008ce30
mov byte [ebp - 4], 0x1b
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.flashed]
mov byte [ebp - 0x1f00], al
movsx ecx, byte [ebp - 0x1f00]
xor ecx, 0xffffff98
mov byte [ebp - 0x1f01], cl
mov dl, byte [ebp - 0x1f01]
mov byte [ebp - 0x2478], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.flashed]
mov byte [ebp - 0x1f08], cl
movsx edx, byte [ebp - 0x1f08]
xor edx, 0xffffff98
mov byte [ebp - 0x1f09], dl
mov al, byte [ebp - 0x1f09]
mov byte [ebp - 0x2477], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.flashed]
mov byte [ebp - 0x1f10], dl
movsx eax, byte [ebp - 0x1f10]
xor eax, 0xffffff98
mov byte [ebp - 0x1f11], al
mov cl, byte [ebp - 0x1f11]
mov byte [ebp - 0x2476], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.flashed]
mov byte [ebp - 0x1f18], cl
movsx edx, byte [ebp - 0x1f18]
xor edx, 0xffffff98
mov byte [ebp - 0x1f19], dl
mov al, byte [ebp - 0x1f19]
mov byte [ebp - 0x2475], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.flashed]
mov byte [ebp - 0x1f20], dl
movsx eax, byte [ebp - 0x1f20]
xor eax, 0xffffff98
mov byte [ebp - 0x1f21], al
mov cl, byte [ebp - 0x1f21]
mov byte [ebp - 0x2474], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.flashed]
mov byte [ebp - 0x1f28], cl
movsx edx, byte [ebp - 0x1f28]
xor edx, 0xffffff98
mov byte [ebp - 0x1f29], dl
mov al, byte [ebp - 0x1f29]
mov byte [ebp - 0x2473], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.flashed]
mov byte [ebp - 0x954], al
movsx ecx, byte [ebp - 0x954]
xor ecx, 0xffffff98
mov byte [ebp - 0x955], cl
mov dl, byte [ebp - 0x955]
mov byte [ebp - 0x2472], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.flashed]
mov byte [ebp - 0x95c], dl
movsx eax, byte [ebp - 0x95c]
xor eax, 0xffffff98
mov byte [ebp - 0x95d], al
mov cl, byte [ebp - 0x95d]
mov byte [ebp - 0x2471], cl
mov dword [ebp - 0x2388], 0
jmp 0x1014b2b0
mov edx, dword [ebp - 0x2388]
add edx, 1
mov dword [ebp - 0x2388], edx
cmp dword [ebp - 0x2388], 8
jae 0x1014b332
lea eax, [ebp - 0x2478]
mov dword [ebp - 0x3eb0], eax
mov ecx, dword [ebp - 0x3eb0]
add ecx, dword [ebp - 0x2388]
mov dword [ebp - 0x3eb4], ecx
mov edx, dword [ebp - 0x3eb4]
mov al, byte [edx]
mov byte [ebp - 0x964], al
mov cl, byte [ebp - 0x287d]
mov byte [ebp - 0x286], cl
movsx edx, byte [ebp - 0x964]
xor edx, 0xffffff98
mov byte [ebp - 0x286], dl
lea eax, [ebp - 0x2478]
mov dword [ebp - 0x3eb8], eax
mov ecx, dword [ebp - 0x3eb8]
add ecx, dword [ebp - 0x2388]
mov dword [ebp - 0x3ebc], ecx
mov edx, dword [ebp - 0x3ebc]
mov al, byte [ebp - 0x286]
mov byte [edx], al
jmp 0x1014b2a1
lea ecx, [ebp - 0x2478]
mov dword [ebp - 0x3ec0], ecx
mov edx, dword [ebp - 0x3ec0]
mov dword [ebp - 0x291c], edx
lea eax, [ebp - 0x51d8]
mov dword [ebp - 0x3ec4], eax
movzx ecx, byte [ebp - 0x287e]
push ecx
mov ecx, dword [ebp - 0x3ec4]
call fcn.1008cde0
mov byte [ebp - 4], 0x1c
mov edx, dword [ebp - 0x291c]
mov dword [ebp - 0x238c], edx
mov eax, dword [ebp - 0x238c]
add eax, 1
mov dword [ebp - 0x3ec8], eax
mov ecx, dword [ebp - 0x238c]
mov dl, byte [ecx]
mov byte [ebp - 0x965], dl
add dword [ebp - 0x238c], 1
cmp byte [ebp - 0x965], 0
jne 0x1014b388
mov eax, dword [ebp - 0x238c]
sub eax, dword [ebp - 0x3ec8]
mov dword [ebp - 0x3ecc], eax
mov ecx, dword [ebp - 0x3ecc]
mov dword [ebp - 0x3ed0], ecx
mov edx, dword [ebp - 0x3ed0]
mov dword [ebp - 0x3ed4], edx
mov eax, dword [ebp - 0x3ed4]
push eax
mov ecx, dword [ebp - 0x291c]
push ecx
lea ecx, [ebp - 0x51d8]
call fcn.1008ce30
mov byte [ebp - 4], 0x1d
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.reloading]
mov byte [ebp - 0x96c], cl
movsx edx, byte [ebp - 0x96c]
xor edx, 0xffffff98
mov byte [ebp - 0x96d], dl
mov al, byte [ebp - 0x96d]
mov byte [ebp - 0x24e0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.reloading]
mov byte [ebp - 0x974], dl
movsx eax, byte [ebp - 0x974]
xor eax, 0xffffff98
mov byte [ebp - 0x975], al
mov cl, byte [ebp - 0x975]
mov byte [ebp - 0x24df], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.reloading]
mov byte [ebp - 0x97c], al
movsx ecx, byte [ebp - 0x97c]
xor ecx, 0xffffff98
mov byte [ebp - 0x97d], cl
mov dl, byte [ebp - 0x97d]
mov byte [ebp - 0x24de], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.reloading]
mov byte [ebp - 0x984], dl
movsx eax, byte [ebp - 0x984]
xor eax, 0xffffff98
mov byte [ebp - 0x985], al
mov cl, byte [ebp - 0x985]
mov byte [ebp - 0x24dd], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.reloading]
mov byte [ebp - 0x98c], al
movsx ecx, byte [ebp - 0x98c]
xor ecx, 0xffffff98
mov byte [ebp - 0x98d], cl
mov dl, byte [ebp - 0x98d]
mov byte [ebp - 0x24dc], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.reloading]
mov byte [ebp - 0x994], dl
movsx eax, byte [ebp - 0x994]
xor eax, 0xffffff98
mov byte [ebp - 0x995], al
mov cl, byte [ebp - 0x995]
mov byte [ebp - 0x24db], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.reloading]
mov byte [ebp - 0x99c], cl
movsx edx, byte [ebp - 0x99c]
xor edx, 0xffffff98
mov byte [ebp - 0x99d], dl
mov al, byte [ebp - 0x99d]
mov byte [ebp - 0x24da], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.reloading]
mov byte [ebp - 0x9a4], al
movsx ecx, byte [ebp - 0x9a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x9a5], cl
mov dl, byte [ebp - 0x9a5]
mov byte [ebp - 0x24d9], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.reloading]
mov byte [ebp - 0x9ac], cl
movsx edx, byte [ebp - 0x9ac]
xor edx, 0xffffff98
mov byte [ebp - 0x9ad], dl
mov al, byte [ebp - 0x9ad]
mov byte [ebp - 0x24d8], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.reloading]
mov byte [ebp - 0x9b4], al
movsx ecx, byte [ebp - 0x9b4]
xor ecx, 0xffffff98
mov byte [ebp - 0x9b5], cl
mov dl, byte [ebp - 0x9b5]
mov byte [ebp - 0x24d7], dl
mov dword [ebp - 0x2390], 0
jmp 0x1014b5e7
mov eax, dword [ebp - 0x2390]
add eax, 1
mov dword [ebp - 0x2390], eax
cmp dword [ebp - 0x2390], 0xa
jae 0x1014b669
lea ecx, [ebp - 0x24e0]
mov dword [ebp - 0x3ed8], ecx
mov edx, dword [ebp - 0x3ed8]
add edx, dword [ebp - 0x2390]
mov dword [ebp - 0x3edc], edx
mov eax, dword [ebp - 0x3edc]
mov cl, byte [eax]
mov byte [ebp - 0x9bc], cl
mov dl, byte [ebp - 0x287f]
mov byte [ebp - 0x287], dl
movsx eax, byte [ebp - 0x9bc]
xor eax, 0xffffff98
mov byte [ebp - 0x287], al
lea ecx, [ebp - 0x24e0]
mov dword [ebp - 0x3ee0], ecx
mov edx, dword [ebp - 0x3ee0]
add edx, dword [ebp - 0x2390]
mov dword [ebp - 0x3ee4], edx
mov eax, dword [ebp - 0x3ee4]
mov cl, byte [ebp - 0x287]
mov byte [eax], cl
jmp 0x1014b5d8
lea edx, [ebp - 0x24e0]
mov dword [ebp - 0x3ee8], edx
mov eax, dword [ebp - 0x3ee8]
mov dword [ebp - 0x2924], eax
lea ecx, [ebp - 0x51c0]
mov dword [ebp - 0x3eec], ecx
movzx edx, byte [ebp - 0x2880]
push edx
mov ecx, dword [ebp - 0x3eec]
call fcn.1008cde0
mov byte [ebp - 4], 0x1e
mov eax, dword [ebp - 0x2924]
mov dword [ebp - 0x2394], eax
mov ecx, dword [ebp - 0x2394]
add ecx, 1
mov dword [ebp - 0x3ef0], ecx
mov edx, dword [ebp - 0x2394]
mov al, byte [edx]
mov byte [ebp - 0x9bd], al
add dword [ebp - 0x2394], 1
cmp byte [ebp - 0x9bd], 0
jne 0x1014b6bf
mov ecx, dword [ebp - 0x2394]
sub ecx, dword [ebp - 0x3ef0]
mov dword [ebp - 0x3ef4], ecx
mov edx, dword [ebp - 0x3ef4]
mov dword [ebp - 0x3ef8], edx
mov eax, dword [ebp - 0x3ef8]
mov dword [ebp - 0x3efc], eax
mov ecx, dword [ebp - 0x3efc]
push ecx
mov edx, dword [ebp - 0x2924]
push edx
lea ecx, [ebp - 0x51c0]
call fcn.1008ce30
mov byte [ebp - 4], 0x1f
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.bomb]
mov byte [ebp - 0x9c4], dl
movsx eax, byte [ebp - 0x9c4]
xor eax, 0xffffff98
mov byte [ebp - 0x9c5], al
mov cl, byte [ebp - 0x9c5]
mov byte [ebp - 0x1f9c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.bomb]
mov byte [ebp - 0x9cc], al
movsx ecx, byte [ebp - 0x9cc]
xor ecx, 0xffffff98
mov byte [ebp - 0x9cd], cl
mov dl, byte [ebp - 0x9cd]
mov byte [ebp - 0x1f9b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.bomb]
mov byte [ebp - 0x9d4], cl
movsx edx, byte [ebp - 0x9d4]
xor edx, 0xffffff98
mov byte [ebp - 0x9d5], dl
mov al, byte [ebp - 0x9d5]
mov byte [ebp - 0x1f9a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.bomb]
mov byte [ebp - 0x9dc], al
movsx ecx, byte [ebp - 0x9dc]
xor ecx, 0xffffff98
mov byte [ebp - 0x9dd], cl
mov dl, byte [ebp - 0x9dd]
mov byte [ebp - 0x1f99], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.bomb]
mov byte [ebp - 0x9e4], cl
movsx edx, byte [ebp - 0x9e4]
xor edx, 0xffffff98
mov byte [ebp - 0x9e5], dl
mov al, byte [ebp - 0x9e5]
mov byte [ebp - 0x1f98], al
mov dword [ebp - 0x2398], 0
jmp 0x1014b82e
mov ecx, dword [ebp - 0x2398]
add ecx, 1
mov dword [ebp - 0x2398], ecx
cmp dword [ebp - 0x2398], 5
jae 0x1014b8b0
lea edx, [ebp - 0x1f9c]
mov dword [ebp - 0x3f00], edx
mov eax, dword [ebp - 0x3f00]
add eax, dword [ebp - 0x2398]
mov dword [ebp - 0x3f04], eax
mov ecx, dword [ebp - 0x3f04]
mov dl, byte [ecx]
mov byte [ebp - 0x9ec], dl
mov al, byte [ebp - 0x2881]
mov byte [ebp - 0x288], al
movsx ecx, byte [ebp - 0x9ec]
xor ecx, 0xffffff98
mov byte [ebp - 0x288], cl
lea edx, [ebp - 0x1f9c]
mov dword [ebp - 0x3f08], edx
mov eax, dword [ebp - 0x3f08]
add eax, dword [ebp - 0x2398]
mov dword [ebp - 0x3f0c], eax
mov ecx, dword [ebp - 0x3f0c]
mov dl, byte [ebp - 0x288]
mov byte [ecx], dl
jmp 0x1014b81f
lea eax, [ebp - 0x1f9c]
mov dword [ebp - 0x3f10], eax
mov ecx, dword [ebp - 0x3f10]
mov dword [ebp - 0x2928], ecx
lea edx, [ebp - 0x51a8]
mov dword [ebp - 0x3f14], edx
movzx eax, byte [ebp - 0x2882]
push eax
mov ecx, dword [ebp - 0x3f14]
call fcn.1008cde0
mov byte [ebp - 4], 0x20
mov ecx, dword [ebp - 0x2928]
mov dword [ebp - 0x239c], ecx
mov edx, dword [ebp - 0x239c]
add edx, 1
mov dword [ebp - 0x3f18], edx
mov eax, dword [ebp - 0x239c]
mov cl, byte [eax]
mov byte [ebp - 0x9ed], cl
add dword [ebp - 0x239c], 1
cmp byte [ebp - 0x9ed], 0
jne 0x1014b906
mov edx, dword [ebp - 0x239c]
sub edx, dword [ebp - 0x3f18]
mov dword [ebp - 0x3f1c], edx
mov eax, dword [ebp - 0x3f1c]
mov dword [ebp - 0x3f20], eax
mov ecx, dword [ebp - 0x3f20]
mov dword [ebp - 0x3f24], ecx
mov edx, dword [ebp - 0x3f24]
push edx
mov eax, dword [ebp - 0x2928]
push eax
lea ecx, [ebp - 0x51a8]
call fcn.1008ce30
mov byte [ebp - 4], 0x21
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.resolver_mode]
mov byte [ebp - 0x9f4], al
movsx ecx, byte [ebp - 0x9f4]
xor ecx, 0xffffff98
mov byte [ebp - 0x9f5], cl
mov dl, byte [ebp - 0x9f5]
mov byte [ebp - 0x266c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.resolver_mode]
mov byte [ebp - 0x9fc], cl
movsx edx, byte [ebp - 0x9fc]
xor edx, 0xffffff98
mov byte [ebp - 0x9fd], dl
mov al, byte [ebp - 0x9fd]
mov byte [ebp - 0x266b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.resolver_mode]
mov byte [ebp - 0xa04], dl
movsx eax, byte [ebp - 0xa04]
xor eax, 0xffffff98
mov byte [ebp - 0xa05], al
mov cl, byte [ebp - 0xa05]
mov byte [ebp - 0x266a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.resolver_mode]
mov byte [ebp - 0xa0c], cl
movsx edx, byte [ebp - 0xa0c]
xor edx, 0xffffff98
mov byte [ebp - 0xa0d], dl
mov al, byte [ebp - 0xa0d]
mov byte [ebp - 0x2669], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.resolver_mode]
mov byte [ebp - 0xa14], dl
movsx eax, byte [ebp - 0xa14]
xor eax, 0xffffff98
mov byte [ebp - 0xa15], al
mov cl, byte [ebp - 0xa15]
mov byte [ebp - 0x2668], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.resolver_mode]
mov byte [ebp - 0xa1c], cl
movsx edx, byte [ebp - 0xa1c]
xor edx, 0xffffff98
mov byte [ebp - 0xa1d], dl
mov al, byte [ebp - 0xa1d]
mov byte [ebp - 0x2667], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.resolver_mode]
mov byte [ebp - 0xa24], al
movsx ecx, byte [ebp - 0xa24]
xor ecx, 0xffffff98
mov byte [ebp - 0xa25], cl
mov dl, byte [ebp - 0xa25]
mov byte [ebp - 0x2666], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.resolver_mode]
mov byte [ebp - 0xa2c], dl
movsx eax, byte [ebp - 0xa2c]
xor eax, 0xffffff98
mov byte [ebp - 0xa2d], al
mov cl, byte [ebp - 0xa2d]
mov byte [ebp - 0x2665], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.resolver_mode]
mov byte [ebp - 0xa34], al
movsx ecx, byte [ebp - 0xa34]
xor ecx, 0xffffff98
mov byte [ebp - 0xa35], cl
mov dl, byte [ebp - 0xa35]
mov byte [ebp - 0x2664], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.resolver_mode]
mov byte [ebp - 0xa3c], dl
movsx eax, byte [ebp - 0xa3c]
xor eax, 0xffffff98
mov byte [ebp - 0xa3d], al
mov cl, byte [ebp - 0xa3d]
mov byte [ebp - 0x2663], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.resolver_mode]
mov byte [ebp - 0xa44], cl
movsx edx, byte [ebp - 0xa44]
xor edx, 0xffffff98
mov byte [ebp - 0xa45], dl
mov al, byte [ebp - 0xa45]
mov byte [ebp - 0x2662], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.resolver_mode]
mov byte [ebp - 0xa4c], al
movsx ecx, byte [ebp - 0xa4c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa4d], cl
mov dl, byte [ebp - 0xa4d]
mov byte [ebp - 0x2661], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.resolver_mode]
mov byte [ebp - 0xa54], dl
movsx eax, byte [ebp - 0xa54]
xor eax, 0xffffff98
mov byte [ebp - 0xa55], al
mov cl, byte [ebp - 0xa55]
mov byte [ebp - 0x2660], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.resolver_mode]
mov byte [ebp - 0xa5c], cl
movsx edx, byte [ebp - 0xa5c]
xor edx, 0xffffff98
mov byte [ebp - 0xa5d], dl
mov al, byte [ebp - 0xa5d]
mov byte [ebp - 0x265f], al
mov dword [ebp - 0x23a0], 0
jmp 0x1014bc25
mov ecx, dword [ebp - 0x23a0]
add ecx, 1
mov dword [ebp - 0x23a0], ecx
cmp dword [ebp - 0x23a0], 0xe
jae 0x1014bca7
lea edx, [ebp - 0x266c]
mov dword [ebp - 0x3f28], edx
mov eax, dword [ebp - 0x3f28]
add eax, dword [ebp - 0x23a0]
mov dword [ebp - 0x3f2c], eax
mov ecx, dword [ebp - 0x3f2c]
mov dl, byte [ecx]
mov byte [ebp - 0xa64], dl
mov al, byte [ebp - 0x2883]
mov byte [ebp - 0x289], al
movsx ecx, byte [ebp - 0xa64]
xor ecx, 0xffffff98
mov byte [ebp - 0x289], cl
lea edx, [ebp - 0x266c]
mov dword [ebp - 0x3f30], edx
mov eax, dword [ebp - 0x3f30]
add eax, dword [ebp - 0x23a0]
mov dword [ebp - 0x3f34], eax
mov ecx, dword [ebp - 0x3f34]
mov dl, byte [ebp - 0x289]
mov byte [ecx], dl
jmp 0x1014bc16
lea eax, [ebp - 0x266c]
mov dword [ebp - 0x3f38], eax
mov ecx, dword [ebp - 0x3f38]
mov dword [ebp - 0x292c], ecx
lea edx, [ebp - 0x5190]
mov dword [ebp - 0x3f3c], edx
movzx eax, byte [ebp - 0x2884]
push eax
mov ecx, dword [ebp - 0x3f3c]
call fcn.1008cde0
mov byte [ebp - 4], 0x22
mov ecx, dword [ebp - 0x292c]
mov dword [ebp - 0x223c], ecx
mov edx, dword [ebp - 0x223c]
add edx, 1
mov dword [ebp - 0x3f40], edx
mov eax, dword [ebp - 0x223c]
mov cl, byte [eax]
mov byte [ebp - 0xa65], cl
add dword [ebp - 0x223c], 1
cmp byte [ebp - 0xa65], 0
jne 0x1014bcfd
mov edx, dword [ebp - 0x223c]
sub edx, dword [ebp - 0x3f40]
mov dword [ebp - 0x3f44], edx
mov eax, dword [ebp - 0x3f44]
mov dword [ebp - 0x3f48], eax
mov ecx, dword [ebp - 0x3f48]
mov dword [ebp - 0x3f4c], ecx
mov edx, dword [ebp - 0x3f4c]
push edx
mov eax, dword [ebp - 0x292c]
push eax
lea ecx, [ebp - 0x5190]
call fcn.1008ce30
mov byte [ebp - 4], 0x23
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xa6c], al
movsx ecx, byte [ebp - 0xa6c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa6d], cl
mov dl, byte [ebp - 0xa6d]
mov byte [ebp - 0x26d4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.shifting_tickbase]
mov byte [ebp - 0xa74], cl
movsx edx, byte [ebp - 0xa74]
xor edx, 0xffffff98
mov byte [ebp - 0xa75], dl
mov al, byte [ebp - 0xa75]
mov byte [ebp - 0x26d3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xa7c], dl
movsx eax, byte [ebp - 0xa7c]
xor eax, 0xffffff98
mov byte [ebp - 0xa7d], al
mov cl, byte [ebp - 0xa7d]
mov byte [ebp - 0x26d2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.shifting_tickbase]
mov byte [ebp - 0xa84], cl
movsx edx, byte [ebp - 0xa84]
xor edx, 0xffffff98
mov byte [ebp - 0xa85], dl
mov al, byte [ebp - 0xa85]
mov byte [ebp - 0x26d1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xa8c], dl
movsx eax, byte [ebp - 0xa8c]
xor eax, 0xffffff98
mov byte [ebp - 0xa8d], al
mov cl, byte [ebp - 0xa8d]
mov byte [ebp - 0x26d0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.shifting_tickbase]
mov byte [ebp - 0xa94], cl
movsx edx, byte [ebp - 0xa94]
xor edx, 0xffffff98
mov byte [ebp - 0xa95], dl
mov al, byte [ebp - 0xa95]
mov byte [ebp - 0x26cf], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xa9c], al
movsx ecx, byte [ebp - 0xa9c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa9d], cl
mov dl, byte [ebp - 0xa9d]
mov byte [ebp - 0x26ce], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xaa4], dl
movsx eax, byte [ebp - 0xaa4]
xor eax, 0xffffff98
mov byte [ebp - 0xaa5], al
mov cl, byte [ebp - 0xaa5]
mov byte [ebp - 0x26cd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xaac], al
movsx ecx, byte [ebp - 0xaac]
xor ecx, 0xffffff98
mov byte [ebp - 0xaad], cl
mov dl, byte [ebp - 0xaad]
mov byte [ebp - 0x26cc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xab4], dl
movsx eax, byte [ebp - 0xab4]
xor eax, 0xffffff98
mov byte [ebp - 0xab5], al
mov cl, byte [ebp - 0xab5]
mov byte [ebp - 0x26cb], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.shifting_tickbase]
mov byte [ebp - 0xabc], cl
movsx edx, byte [ebp - 0xabc]
xor edx, 0xffffff98
mov byte [ebp - 0xabd], dl
mov al, byte [ebp - 0xabd]
mov byte [ebp - 0x26ca], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xac4], al
movsx ecx, byte [ebp - 0xac4]
xor ecx, 0xffffff98
mov byte [ebp - 0xac5], cl
mov dl, byte [ebp - 0xac5]
mov byte [ebp - 0x26c9], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xacc], dl
movsx eax, byte [ebp - 0xacc]
xor eax, 0xffffff98
mov byte [ebp - 0xacd], al
mov cl, byte [ebp - 0xacd]
mov byte [ebp - 0x26c8], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.shifting_tickbase]
mov byte [ebp - 0xad4], cl
movsx edx, byte [ebp - 0xad4]
xor edx, 0xffffff98
mov byte [ebp - 0xad5], dl
mov al, byte [ebp - 0xad5]
mov byte [ebp - 0x26c7], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xadc], al
movsx ecx, byte [ebp - 0xadc]
xor ecx, 0xffffff98
mov byte [ebp - 0xadd], cl
mov dl, byte [ebp - 0xadd]
mov byte [ebp - 0x26c6], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xae4], dl
movsx eax, byte [ebp - 0xae4]
xor eax, 0xffffff98
mov byte [ebp - 0xae5], al
mov cl, byte [ebp - 0xae5]
mov byte [ebp - 0x26c5], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.shifting_tickbase]
mov byte [ebp - 0xaec], al
movsx ecx, byte [ebp - 0xaec]
xor ecx, 0xffffff98
mov byte [ebp - 0xaed], cl
mov dl, byte [ebp - 0xaed]
mov byte [ebp - 0x26c4], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.shifting_tickbase]
mov byte [ebp - 0xaf4], dl
movsx eax, byte [ebp - 0xaf4]
xor eax, 0xffffff98
mov byte [ebp - 0xaf5], al
mov cl, byte [ebp - 0xaf5]
mov byte [ebp - 0x26c3], cl
mov dword [ebp - 0x2240], 0
jmp 0x1014c0dc
mov edx, dword [ebp - 0x2240]
add edx, 1
mov dword [ebp - 0x2240], edx
cmp dword [ebp - 0x2240], 0x12
jae 0x1014c15e
lea eax, [ebp - 0x26d4]
mov dword [ebp - 0x3f50], eax
mov ecx, dword [ebp - 0x3f50]
add ecx, dword [ebp - 0x2240]
mov dword [ebp - 0x3f54], ecx
mov edx, dword [ebp - 0x3f54]
mov al, byte [edx]
mov byte [ebp - 0xafc], al
mov cl, byte [ebp - 0x2885]
mov byte [ebp - 0x28a], cl
movsx edx, byte [ebp - 0xafc]
xor edx, 0xffffff98
mov byte [ebp - 0x28a], dl
lea eax, [ebp - 0x26d4]
mov dword [ebp - 0x3f58], eax
mov ecx, dword [ebp - 0x3f58]
add ecx, dword [ebp - 0x2240]
mov dword [ebp - 0x3f5c], ecx
mov edx, dword [ebp - 0x3f5c]
mov al, byte [ebp - 0x28a]
mov byte [edx], al
jmp 0x1014c0cd
lea ecx, [ebp - 0x26d4]
mov dword [ebp - 0x3f60], ecx
mov edx, dword [ebp - 0x3f60]
mov dword [ebp - 0x2930], edx
lea eax, [ebp - 0x5178]
mov dword [ebp - 0x3f64], eax
movzx ecx, byte [ebp - 0x2886]
push ecx
mov ecx, dword [ebp - 0x3f64]
call fcn.1008cde0
mov byte [ebp - 4], 0x24
mov edx, dword [ebp - 0x2930]
mov dword [ebp - 0x2244], edx
mov eax, dword [ebp - 0x2244]
add eax, 1
mov dword [ebp - 0x3f68], eax
mov ecx, dword [ebp - 0x2244]
mov dl, byte [ecx]
mov byte [ebp - 0xafd], dl
add dword [ebp - 0x2244], 1
cmp byte [ebp - 0xafd], 0
jne 0x1014c1b4
mov eax, dword [ebp - 0x2244]
sub eax, dword [ebp - 0x3f68]
mov dword [ebp - 0x2ae0], eax
mov ecx, dword [ebp - 0x2ae0]
mov dword [ebp - 0x2ae4], ecx
mov edx, dword [ebp - 0x2ae4]
mov dword [ebp - 0x2ae8], edx
mov eax, dword [ebp - 0x2ae8]
push eax
mov ecx, dword [ebp - 0x2930]
push ecx
lea ecx, [ebp - 0x5178]
call fcn.1008ce30
mov byte [ebp - 4], 0x25
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.lethal]
mov byte [ebp - 0xb04], cl
movsx edx, byte [ebp - 0xb04]
xor edx, 0xffffff98
mov byte [ebp - 0xb05], dl
mov al, byte [ebp - 0xb05]
mov byte [ebp - 0x2450], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.lethal]
mov byte [ebp - 0xb0c], dl
movsx eax, byte [ebp - 0xb0c]
xor eax, 0xffffff98
mov byte [ebp - 0xb0d], al
mov cl, byte [ebp - 0xb0d]
mov byte [ebp - 0x244f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.lethal]
mov byte [ebp - 0xb14], al
movsx ecx, byte [ebp - 0xb14]
xor ecx, 0xffffff98
mov byte [ebp - 0xb15], cl
mov dl, byte [ebp - 0xb15]
mov byte [ebp - 0x244e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.lethal]
mov byte [ebp - 0xb1c], dl
movsx eax, byte [ebp - 0xb1c]
xor eax, 0xffffff98
mov byte [ebp - 0xb1d], al
mov cl, byte [ebp - 0xb1d]
mov byte [ebp - 0x244d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.lethal]
mov byte [ebp - 0xb24], al
movsx ecx, byte [ebp - 0xb24]
xor ecx, 0xffffff98
mov byte [ebp - 0xb25], cl
mov dl, byte [ebp - 0xb25]
mov byte [ebp - 0x244c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.lethal]
mov byte [ebp - 0xb2c], dl
movsx eax, byte [ebp - 0xb2c]
xor eax, 0xffffff98
mov byte [ebp - 0xb2d], al
mov cl, byte [ebp - 0xb2d]
mov byte [ebp - 0x244b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.lethal]
mov byte [ebp - 0xb34], cl
movsx edx, byte [ebp - 0xb34]
xor edx, 0xffffff98
mov byte [ebp - 0xb35], dl
mov al, byte [ebp - 0xb35]
mov byte [ebp - 0x244a], al
mov dword [ebp - 0x2248], 0
jmp 0x1014c383
mov ecx, dword [ebp - 0x2248]
add ecx, 1
mov dword [ebp - 0x2248], ecx
cmp dword [ebp - 0x2248], 7
jae 0x1014c405
lea edx, [ebp - 0x2450]
mov dword [ebp - 0x2aec], edx
mov eax, dword [ebp - 0x2aec]
add eax, dword [ebp - 0x2248]
mov dword [ebp - 0x2af0], eax
mov ecx, dword [ebp - 0x2af0]
mov dl, byte [ecx]
mov byte [ebp - 0xb3c], dl
mov al, byte [ebp - 0x2887]
mov byte [ebp - 0x28b], al
movsx ecx, byte [ebp - 0xb3c]
xor ecx, 0xffffff98
mov byte [ebp - 0x28b], cl
lea edx, [ebp - 0x2450]
mov dword [ebp - 0x2af4], edx
mov eax, dword [ebp - 0x2af4]
add eax, dword [ebp - 0x2248]
mov dword [ebp - 0x2af8], eax
mov ecx, dword [ebp - 0x2af8]
mov dl, byte [ebp - 0x28b]
mov byte [ecx], dl
jmp 0x1014c374
lea eax, [ebp - 0x2450]
mov dword [ebp - 0x2afc], eax
mov ecx, dword [ebp - 0x2afc]
mov dword [ebp - 0x2934], ecx
lea edx, [ebp - 0x5160]
mov dword [ebp - 0x2b00], edx
movzx eax, byte [ebp - 0x2888]
push eax
mov ecx, dword [ebp - 0x2b00]
call fcn.1008cde0
mov byte [ebp - 4], 0x26
mov ecx, dword [ebp - 0x2934]
mov dword [ebp - 0x224c], ecx
mov edx, dword [ebp - 0x224c]
add edx, 1
mov dword [ebp - 0x2b04], edx
mov eax, dword [ebp - 0x224c]
mov cl, byte [eax]
mov byte [ebp - 0xb3d], cl
add dword [ebp - 0x224c], 1
cmp byte [ebp - 0xb3d], 0
jne 0x1014c45b
mov edx, dword [ebp - 0x224c]
sub edx, dword [ebp - 0x2b04]
mov dword [ebp - 0x2b08], edx
mov eax, dword [ebp - 0x2b08]
mov dword [ebp - 0x2b0c], eax
mov ecx, dword [ebp - 0x2b0c]
mov dword [ebp - 0x2b10], ecx
mov edx, dword [ebp - 0x2b10]
push edx
mov eax, dword [ebp - 0x2934]
push eax
lea ecx, [ebp - 0x5160]
call fcn.1008ce30
mov byte [ebp - 4], 0x27
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.fake_angles]
mov byte [ebp - 0xb44], al
movsx ecx, byte [ebp - 0xb44]
xor ecx, 0xffffff98
mov byte [ebp - 0xb45], cl
mov dl, byte [ebp - 0xb45]
mov byte [ebp - 0x261c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.fake_angles]
mov byte [ebp - 0xb4c], cl
movsx edx, byte [ebp - 0xb4c]
xor edx, 0xffffff98
mov byte [ebp - 0xb4d], dl
mov al, byte [ebp - 0xb4d]
mov byte [ebp - 0x261b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.fake_angles]
mov byte [ebp - 0xb54], dl
movsx eax, byte [ebp - 0xb54]
xor eax, 0xffffff98
mov byte [ebp - 0xb55], al
mov cl, byte [ebp - 0xb55]
mov byte [ebp - 0x261a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.fake_angles]
mov byte [ebp - 0xb5c], cl
movsx edx, byte [ebp - 0xb5c]
xor edx, 0xffffff98
mov byte [ebp - 0xb5d], dl
mov al, byte [ebp - 0xb5d]
mov byte [ebp - 0x2619], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.fake_angles]
mov byte [ebp - 0xb64], dl
movsx eax, byte [ebp - 0xb64]
xor eax, 0xffffff98
mov byte [ebp - 0xb65], al
mov cl, byte [ebp - 0xb65]
mov byte [ebp - 0x2618], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.fake_angles]
mov byte [ebp - 0xb6c], cl
movsx edx, byte [ebp - 0xb6c]
xor edx, 0xffffff98
mov byte [ebp - 0xb6d], dl
mov al, byte [ebp - 0xb6d]
mov byte [ebp - 0x2617], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.fake_angles]
mov byte [ebp - 0xb74], al
movsx ecx, byte [ebp - 0xb74]
xor ecx, 0xffffff98
mov byte [ebp - 0xb75], cl
mov dl, byte [ebp - 0xb75]
mov byte [ebp - 0x2616], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.fake_angles]
mov byte [ebp - 0xb7c], dl
movsx eax, byte [ebp - 0xb7c]
xor eax, 0xffffff98
mov byte [ebp - 0xb7d], al
mov cl, byte [ebp - 0xb7d]
mov byte [ebp - 0x2615], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.fake_angles]
mov byte [ebp - 0xb84], al
movsx ecx, byte [ebp - 0xb84]
xor ecx, 0xffffff98
mov byte [ebp - 0xb85], cl
mov dl, byte [ebp - 0xb85]
mov byte [ebp - 0x2614], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.fake_angles]
mov byte [ebp - 0xb8c], dl
movsx eax, byte [ebp - 0xb8c]
xor eax, 0xffffff98
mov byte [ebp - 0xb8d], al
mov cl, byte [ebp - 0xb8d]
mov byte [ebp - 0x2613], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.fake_angles]
mov byte [ebp - 0xb94], cl
movsx edx, byte [ebp - 0xb94]
xor edx, 0xffffff98
mov byte [ebp - 0xb95], dl
mov al, byte [ebp - 0xb95]
mov byte [ebp - 0x2612], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.fake_angles]
mov byte [ebp - 0xb9c], al
movsx ecx, byte [ebp - 0xb9c]
xor ecx, 0xffffff98
mov byte [ebp - 0xb9d], cl
mov dl, byte [ebp - 0xb9d]
mov byte [ebp - 0x2611], dl
mov dword [ebp - 0x2250], 0
jmp 0x1014c71a
mov eax, dword [ebp - 0x2250]
add eax, 1
mov dword [ebp - 0x2250], eax
cmp dword [ebp - 0x2250], 0xc
jae 0x1014c79c
lea ecx, [ebp - 0x261c]
mov dword [ebp - 0x2b14], ecx
mov edx, dword [ebp - 0x2b14]
add edx, dword [ebp - 0x2250]
mov dword [ebp - 0x2b18], edx
mov eax, dword [ebp - 0x2b18]
mov cl, byte [eax]
mov byte [ebp - 0xba4], cl
mov dl, byte [ebp - 0x2889]
mov byte [ebp - 0x28c], dl
movsx eax, byte [ebp - 0xba4]
xor eax, 0xffffff98
mov byte [ebp - 0x28c], al
lea ecx, [ebp - 0x261c]
mov dword [ebp - 0x2b1c], ecx
mov edx, dword [ebp - 0x2b1c]
add edx, dword [ebp - 0x2250]
mov dword [ebp - 0x2b20], edx
mov eax, dword [ebp - 0x2b20]
mov cl, byte [ebp - 0x28c]
mov byte [eax], cl
jmp 0x1014c70b
lea edx, [ebp - 0x261c]
mov dword [ebp - 0x2b24], edx
mov eax, dword [ebp - 0x2b24]
mov dword [ebp - 0x2938], eax
lea ecx, [ebp - 0x5148]
mov dword [ebp - 0x2b28], ecx
movzx edx, byte [ebp - 0x288a]
push edx
mov ecx, dword [ebp - 0x2b28]
call fcn.1008cde0
mov byte [ebp - 4], 0x28
mov eax, dword [ebp - 0x2938]
mov dword [ebp - 0x2254], eax
mov ecx, dword [ebp - 0x2254]
add ecx, 1
mov dword [ebp - 0x2b2c], ecx
mov edx, dword [ebp - 0x2254]
mov al, byte [edx]
mov byte [ebp - 0xba5], al
add dword [ebp - 0x2254], 1
cmp byte [ebp - 0xba5], 0
jne 0x1014c7f2
mov ecx, dword [ebp - 0x2254]
sub ecx, dword [ebp - 0x2b2c]
mov dword [ebp - 0x2b30], ecx
mov edx, dword [ebp - 0x2b30]
mov dword [ebp - 0x2b34], edx
mov eax, dword [ebp - 0x2b34]
mov dword [ebp - 0x2b38], eax
mov ecx, dword [ebp - 0x2b38]
push ecx
mov edx, dword [ebp - 0x2938]
push edx
lea ecx, [ebp - 0x5148]
call fcn.1008ce30
mov dword [ebp - 4], 0x29
lea eax, [ebp - 0x5220]
mov dword [ebp - 0x3e18], eax
lea ecx, [ebp - 0x5130]
mov dword [ebp - 0x3e14], ecx
mov edx, dword [ebp - 0x3e18]
mov eax, dword [ebp - 0x3e14]
mov dword [ebp - 0x3e20], edx
mov dword [ebp - 0x3e1c], eax
mov ecx, dword [ebp - 0x2b3c]
push ecx
mov edx, dword [ebp - 0x3e1c]
push edx
mov eax, dword [ebp - 0x3e20]
push eax
lea ecx, [ebp - 0x40bc]
call fcn.10260fe0
mov byte [ebp - 4], 0x2a
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.flags_enemy]
mov byte [ebp - 0xbac], al
movsx ecx, byte [ebp - 0xbac]
xor ecx, 0xffffff98
mov byte [ebp - 0xbad], cl
mov dl, byte [ebp - 0xbad]
mov byte [ebp - 0x25dc], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.flags_enemy]
mov byte [ebp - 0xbb4], cl
movsx edx, byte [ebp - 0xbb4]
xor edx, 0xffffff98
mov byte [ebp - 0xbb5], dl
mov al, byte [ebp - 0xbb5]
mov byte [ebp - 0x25db], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.flags_enemy]
mov byte [ebp - 0xbbc], dl
movsx eax, byte [ebp - 0xbbc]
xor eax, 0xffffff98
mov byte [ebp - 0xbbd], al
mov cl, byte [ebp - 0xbbd]
mov byte [ebp - 0x25da], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.flags_enemy]
mov byte [ebp - 0xbc4], cl
movsx edx, byte [ebp - 0xbc4]
xor edx, 0xffffff98
mov byte [ebp - 0xbc5], dl
mov al, byte [ebp - 0xbc5]
mov byte [ebp - 0x25d9], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.flags_enemy]
mov byte [ebp - 0xbcc], dl
movsx eax, byte [ebp - 0xbcc]
xor eax, 0xffffff98
mov byte [ebp - 0xbcd], al
mov cl, byte [ebp - 0xbcd]
mov byte [ebp - 0x25d8], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.flags_enemy]
mov byte [ebp - 0xbd4], cl
movsx edx, byte [ebp - 0xbd4]
xor edx, 0xffffff98
mov byte [ebp - 0xbd5], dl
mov al, byte [ebp - 0xbd5]
mov byte [ebp - 0x25d7], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.flags_enemy]
mov byte [ebp - 0xbdc], al
movsx ecx, byte [ebp - 0xbdc]
xor ecx, 0xffffff98
mov byte [ebp - 0xbdd], cl
mov dl, byte [ebp - 0xbdd]
mov byte [ebp - 0x25d6], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.flags_enemy]
mov byte [ebp - 0xbe4], dl
movsx eax, byte [ebp - 0xbe4]
xor eax, 0xffffff98
mov byte [ebp - 0xbe5], al
mov cl, byte [ebp - 0xbe5]
mov byte [ebp - 0x25d5], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.flags_enemy]
mov byte [ebp - 0xbec], al
movsx ecx, byte [ebp - 0xbec]
xor ecx, 0xffffff98
mov byte [ebp - 0xbed], cl
mov dl, byte [ebp - 0xbed]
mov byte [ebp - 0x25d4], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.flags_enemy]
mov byte [ebp - 0xbf4], dl
movsx eax, byte [ebp - 0xbf4]
xor eax, 0xffffff98
mov byte [ebp - 0xbf5], al
mov cl, byte [ebp - 0xbf5]
mov byte [ebp - 0x25d3], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.flags_enemy]
mov byte [ebp - 0xbfc], cl
movsx edx, byte [ebp - 0xbfc]
xor edx, 0xffffff98
mov byte [ebp - 0xbfd], dl
mov al, byte [ebp - 0xbfd]
mov byte [ebp - 0x25d2], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.flags_enemy]
mov byte [ebp - 0xc04], al
movsx ecx, byte [ebp - 0xc04]
xor ecx, 0xffffff98
mov byte [ebp - 0xc05], cl
mov dl, byte [ebp - 0xc05]
mov byte [ebp - 0x25d1], dl
mov dword [ebp - 0x2258], 0
jmp 0x1014cb08
mov eax, dword [ebp - 0x2258]
add eax, 1
mov dword [ebp - 0x2258], eax
cmp dword [ebp - 0x2258], 0xc
jae 0x1014cb8a
lea ecx, [ebp - 0x25dc]
mov dword [ebp - 0x2b40], ecx
mov edx, dword [ebp - 0x2b40]
add edx, dword [ebp - 0x2258]
mov dword [ebp - 0x2b44], edx
mov eax, dword [ebp - 0x2b44]
mov cl, byte [eax]
mov byte [ebp - 0xc0c], cl
mov dl, byte [ebp - 0x288b]
mov byte [ebp - 0x28d], dl
movsx eax, byte [ebp - 0xc0c]
xor eax, 0xffffff98
mov byte [ebp - 0x28d], al
lea ecx, [ebp - 0x25dc]
mov dword [ebp - 0x2b48], ecx
mov edx, dword [ebp - 0x2b48]
add edx, dword [ebp - 0x2258]
mov dword [ebp - 0x2b4c], edx
mov eax, dword [ebp - 0x2b4c]
mov cl, byte [ebp - 0x28d]
mov byte [eax], cl
jmp 0x1014caf9
lea edx, [ebp - 0x25dc]
mov dword [ebp - 0x2b50], edx
mov eax, dword [ebp - 0x2b50]
mov dword [ebp - 0x293c], eax
lea ecx, [ebp - 0x42a8]
mov dword [ebp - 0x2b54], ecx
movzx edx, byte [ebp - 0x288c]
push edx
mov ecx, dword [ebp - 0x2b54]
call fcn.1008cde0
mov byte [ebp - 4], 0x2b
mov eax, dword [ebp - 0x293c]
mov dword [ebp - 0x225c], eax
mov ecx, dword [ebp - 0x225c]
add ecx, 1
mov dword [ebp - 0x2b58], ecx
mov edx, dword [ebp - 0x225c]
mov al, byte [edx]
mov byte [ebp - 0xc0d], al
add dword [ebp - 0x225c], 1
cmp byte [ebp - 0xc0d], 0
jne 0x1014cbe0
mov ecx, dword [ebp - 0x225c]
sub ecx, dword [ebp - 0x2b58]
mov dword [ebp - 0x2b5c], ecx
mov edx, dword [ebp - 0x2b5c]
mov dword [ebp - 0x2b60], edx
mov eax, dword [ebp - 0x2b60]
mov dword [ebp - 0x2b64], eax
mov ecx, dword [ebp - 0x2b64]
push ecx
mov edx, dword [ebp - 0x293c]
push edx
lea ecx, [ebp - 0x42a8]
call fcn.1008ce30
mov byte [ebp - 4], 0x2c
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.esp_flags]
mov byte [ebp - 0xc14], dl
movsx eax, byte [ebp - 0xc14]
xor eax, 0xffffff98
mov byte [ebp - 0xc15], al
mov cl, byte [ebp - 0xc15]
mov byte [ebp - 0x2504], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.esp_flags]
mov byte [ebp - 0xc1c], al
movsx ecx, byte [ebp - 0xc1c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc1d], cl
mov dl, byte [ebp - 0xc1d]
mov byte [ebp - 0x2503], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.esp_flags]
mov byte [ebp - 0xc24], cl
movsx edx, byte [ebp - 0xc24]
xor edx, 0xffffff98
mov byte [ebp - 0xc25], dl
mov al, byte [ebp - 0xc25]
mov byte [ebp - 0x2502], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.esp_flags]
mov byte [ebp - 0xc2c], al
movsx ecx, byte [ebp - 0xc2c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc2d], cl
mov dl, byte [ebp - 0xc2d]
mov byte [ebp - 0x2501], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.esp_flags]
mov byte [ebp - 0xc34], cl
movsx edx, byte [ebp - 0xc34]
xor edx, 0xffffff98
mov byte [ebp - 0xc35], dl
mov al, byte [ebp - 0xc35]
mov byte [ebp - 0x2500], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.esp_flags]
mov byte [ebp - 0xc3c], al
movsx ecx, byte [ebp - 0xc3c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc3d], cl
mov dl, byte [ebp - 0xc3d]
mov byte [ebp - 0x24ff], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.esp_flags]
mov byte [ebp - 0xc44], dl
movsx eax, byte [ebp - 0xc44]
xor eax, 0xffffff98
mov byte [ebp - 0xc45], al
mov cl, byte [ebp - 0xc45]
mov byte [ebp - 0x24fe], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.esp_flags]
mov byte [ebp - 0xc4c], cl
movsx edx, byte [ebp - 0xc4c]
xor edx, 0xffffff98
mov byte [ebp - 0xc4d], dl
mov al, byte [ebp - 0xc4d]
mov byte [ebp - 0x24fd], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.esp_flags]
mov byte [ebp - 0xc54], dl
movsx eax, byte [ebp - 0xc54]
xor eax, 0xffffff98
mov byte [ebp - 0xc55], al
mov cl, byte [ebp - 0xc55]
mov byte [ebp - 0x24fc], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.esp_flags]
mov byte [ebp - 0xc5c], cl
movsx edx, byte [ebp - 0xc5c]
xor edx, 0xffffff98
mov byte [ebp - 0xc5d], dl
mov al, byte [ebp - 0xc5d]
mov byte [ebp - 0x24fb], al
mov dword [ebp - 0x2260], 0
jmp 0x1014ce3f
mov ecx, dword [ebp - 0x2260]
add ecx, 1
mov dword [ebp - 0x2260], ecx
cmp dword [ebp - 0x2260], 0xa
jae 0x1014cec1
lea edx, [ebp - 0x2504]
mov dword [ebp - 0x2b68], edx
mov eax, dword [ebp - 0x2b68]
add eax, dword [ebp - 0x2260]
mov dword [ebp - 0x2b6c], eax
mov ecx, dword [ebp - 0x2b6c]
mov dl, byte [ecx]
mov byte [ebp - 0xc64], dl
mov al, byte [ebp - 0x288d]
mov byte [ebp - 0x28e], al
movsx ecx, byte [ebp - 0xc64]
xor ecx, 0xffffff98
mov byte [ebp - 0x28e], cl
lea edx, [ebp - 0x2504]
mov dword [ebp - 0x2b70], edx
mov eax, dword [ebp - 0x2b70]
add eax, dword [ebp - 0x2260]
mov dword [ebp - 0x2b74], eax
mov ecx, dword [ebp - 0x2b74]
mov dl, byte [ebp - 0x28e]
mov byte [ecx], dl
jmp 0x1014ce30
lea eax, [ebp - 0x2504]
mov dword [ebp - 0x2b78], eax
mov ecx, dword [ebp - 0x2b78]
mov dword [ebp - 0x2940], ecx
lea edx, [ebp - 0x4290]
mov dword [ebp - 0x2b7c], edx
movzx eax, byte [ebp - 0x288e]
push eax
mov ecx, dword [ebp - 0x2b7c]
call fcn.1008cde0
mov byte [ebp - 4], 0x2d
mov ecx, dword [ebp - 0x2940]
mov dword [ebp - 0x2264], ecx
mov edx, dword [ebp - 0x2264]
add edx, 1
mov dword [ebp - 0x2b80], edx
mov eax, dword [ebp - 0x2264]
mov cl, byte [eax]
mov byte [ebp - 0xc65], cl
add dword [ebp - 0x2264], 1
cmp byte [ebp - 0xc65], 0
jne 0x1014cf17
mov edx, dword [ebp - 0x2264]
sub edx, dword [ebp - 0x2b80]
mov dword [ebp - 0x2b84], edx
mov eax, dword [ebp - 0x2b84]
mov dword [ebp - 0x2b88], eax
mov ecx, dword [ebp - 0x2b88]
mov dword [ebp - 0x2b8c], ecx
mov edx, dword [ebp - 0x2b8c]
push edx
mov eax, dword [ebp - 0x2940]
push eax
lea ecx, [ebp - 0x4290]
call fcn.1008ce30
mov byte [ebp - 4], 0x2e
lea ecx, [ebp - 0x40b0]
mov dword [ebp - 0x2740], ecx
mov edx, dword [ebp - 0x2740]
mov dword [ebp - 0x2b90], edx
mov ecx, dword [ebp - 0x2b90]
call fcn.1008da90
mov eax, dword [ebp - 0x2740]
mov dword [ebp - 0x4190], eax
mov ecx, dword [ebp - 0x2740]
mov dword [ebp - 0x4194], ecx
mov byte [ebp - 4], 0x2f
lea edx, [ebp - 0x42a8]
push edx
mov ecx, dword [ebp - 0x1c8]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x1c8]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x1c8]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1014cffd
lea eax, [ebp - 0x4290]
push eax
mov ecx, dword [ebp - 0x1c8]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x1c8]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1014d017
mov dword [ebp - 0x2944], 0xf
jmp 0x1014d021
mov dword [ebp - 0x2944], 0
mov eax, dword [ebp - 0x1c8]
mov ecx, dword [ebp - 0x2944]
mov dword [eax + 0xa4], ecx
mov edx, dword [ebp - 0x1c8]
mov eax, dword [edx + 0xa4]
add eax, 0x14
mov dword [ebp - 0x2948], eax
mov ecx, dword [ebp - 0x1c8]
mov edx, dword [ebp - 0x2948]
mov dword [ecx + 0x10], edx
mov eax, dword [ebp - 0x1c8]
mov ecx, dword [ebp - 0x2948]
mov dword [eax + 0x14], ecx
lea edx, [ebp - 0x40bc]
mov dword [ebp - 0x294c], edx
mov eax, dword [ebp - 0x294c]
mov ecx, dword [eax]
mov dword [ebp - 0x25a0], ecx
mov edx, dword [ebp - 0x294c]
mov eax, dword [edx + 4]
mov dword [ebp - 0x2b94], eax
jmp 0x1014d0a0
mov ecx, dword [ebp - 0x25a0]
add ecx, 0x18
mov dword [ebp - 0x25a0], ecx
mov edx, dword [ebp - 0x25a0]
cmp edx, dword [ebp - 0x2b94]
je 0x1014d0e0
mov eax, dword [ebp - 0x25a0]
mov dword [ebp - 0x2b98], eax
mov ecx, dword [ebp - 0x1c8]
add ecx, 0x88
mov dword [ebp - 0x2b9c], ecx
mov edx, dword [ebp - 0x2b98]
push edx
mov ecx, dword [ebp - 0x2b9c]
call fcn.100fca00
jmp 0x1014d091
lea eax, [ebp - 0x40b0]
mov dword [ebp - 0x2950], eax
mov ecx, dword [ebp - 0x2950]
mov edx, dword [ecx]
mov dword [ebp - 0x25a4], edx
mov eax, dword [ebp - 0x2950]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x2ba0], ecx
jmp 0x1014d11a
mov edx, dword [ebp - 0x25a4]
add edx, 4
mov dword [ebp - 0x25a4], edx
mov eax, dword [ebp - 0x25a4]
cmp eax, dword [ebp - 0x2ba0]
je 0x1014d2a3
mov ecx, dword [ebp - 0x25a4]
mov dword [ebp - 0x2ba4], ecx
mov edx, dword [ebp - 0x2ba4]
mov eax, dword [edx]
mov dword [ebp - 0x18], eax
mov ecx, dword [ebp - 0x1c8]
add ecx, 0x98
mov dword [ebp - 0x2ba8], ecx
lea edx, [ebp - 0x4198]
push edx
mov ecx, dword [ebp - 0x2ba8]
call fcn.10098ab0
mov eax, dword [eax]
mov dword [ebp - 0x2bb0], eax
mov ecx, dword [ebp - 0x1c8]
add ecx, 0x98
mov dword [ebp - 0x2bac], ecx
lea edx, [ebp - 0x419c]
push edx
mov ecx, dword [ebp - 0x2bac]
call fcn.10098af0
mov eax, dword [eax]
mov dword [ebp - 0x2bb4], eax
lea ecx, [ebp - 0x18]
push ecx
mov edx, dword [ebp - 0x2bb0]
push edx
mov eax, dword [ebp - 0x2bb4]
push eax
lea ecx, [ebp - 0x41a0]
push ecx
call fcn.1009a180
add esp, 0x10
mov dword [ebp - 0x2bbc], eax
mov edx, dword [ebp - 0x1c8]
add edx, 0x98
mov dword [ebp - 0x2bb8], edx
lea eax, [ebp - 0x4068]
push eax
mov ecx, dword [ebp - 0x2bb8]
call fcn.10098ab0
mov dword [ebp - 0x2bc0], eax
mov ecx, dword [ebp - 0x2bbc]
mov edx, dword [ebp - 0x2bc0]
mov eax, dword [ecx]
cmp eax, dword [edx]
jne 0x1014d20a
mov dword [ebp - 0x2954], 1
jmp 0x1014d214
mov dword [ebp - 0x2954], 0
mov cl, byte [ebp - 0x2954]
mov byte [ebp - 0xc66], cl
mov edx, dword [ebp - 0x1c8]
add edx, 0x88
mov dword [ebp - 0x2958], edx
mov eax, dword [ebp - 0x2958]
mov ecx, dword [ebp - 0x2958]
mov eax, dword [eax + 4]
sub eax, dword [ecx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x2bc4], eax
mov edx, dword [ebp - 0x18]
cmp edx, dword [ebp - 0x2bc4]
jae 0x1014d27c
mov eax, dword [ebp - 0x1c8]
add eax, 0x98
mov dword [ebp - 0x2bc8], eax
lea ecx, [ebp - 0x18]
push ecx
mov ecx, dword [ebp - 0x2bc8]
call fcn.1008c950
movzx edx, byte [ebp - 0xc66]
test edx, edx
je 0x1014d29e
mov eax, dword [ebp - 0x1c8]
cmp dword [eax + 0x64], 0
je 0x1014d29e
mov ecx, dword [ebp - 0x1c8]
mov edx, dword [ecx + 0x64]
call edx
jmp 0x1014d10b
mov byte [ebp - 4], 0x2e
lea ecx, [ebp - 0x40b0]
call fcn.1008b490
mov byte [ebp - 4], 0x2c
lea ecx, [ebp - 0x4290]
call fcn.1008b960
mov byte [ebp - 4], 0x2a
lea ecx, [ebp - 0x42a8]
call fcn.1008b960
mov byte [ebp - 4], 0x29
lea ecx, [ebp - 0x40bc]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 0xa
push 0x18
lea eax, [ebp - 0x5220]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x4b0
mov dword [ebp - 0x60], ecx
mov edx, dword [ebp - 0x60]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x60]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x60]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x60]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x60]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x2bcc], ecx
lea edx, [ebp - 0x60]
push edx
mov ecx, dword [ebp - 0x2bcc]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x600
mov dword [ebp - 0x22c], eax
lea ecx, [ebp - 0x288f]
mov dword [ebp - 0x2c20], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.text]
mov byte [ebp - 0xc6c], cl
movsx edx, byte [ebp - 0xc6c]
xor edx, 0xffffff98
mov byte [ebp - 0xc6d], dl
mov al, byte [ebp - 0xc6d]
mov byte [ebp - 0x1f94], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.text]
mov byte [ebp - 0xc74], dl
movsx eax, byte [ebp - 0xc74]
xor eax, 0xffffff98
mov byte [ebp - 0xc75], al
mov cl, byte [ebp - 0xc75]
mov byte [ebp - 0x1f93], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.text]
mov byte [ebp - 0xc7c], al
movsx ecx, byte [ebp - 0xc7c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc7d], cl
mov dl, byte [ebp - 0xc7d]
mov byte [ebp - 0x1f92], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.text]
mov byte [ebp - 0xc84], dl
movsx eax, byte [ebp - 0xc84]
xor eax, 0xffffff98
mov byte [ebp - 0xc85], al
mov cl, byte [ebp - 0xc85]
mov byte [ebp - 0x1f91], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.text]
mov byte [ebp - 0xc8c], al
movsx ecx, byte [ebp - 0xc8c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc8d], cl
mov dl, byte [ebp - 0xc8d]
mov byte [ebp - 0x1f90], dl
mov dword [ebp - 0x2268], 0
jmp 0x1014d485
mov eax, dword [ebp - 0x2268]
add eax, 1
mov dword [ebp - 0x2268], eax
cmp dword [ebp - 0x2268], 5
jae 0x1014d507
lea ecx, [ebp - 0x1f94]
mov dword [ebp - 0x2bd0], ecx
mov edx, dword [ebp - 0x2bd0]
add edx, dword [ebp - 0x2268]
mov dword [ebp - 0x2bd4], edx
mov eax, dword [ebp - 0x2bd4]
mov cl, byte [eax]
mov byte [ebp - 0xc94], cl
mov dl, byte [ebp - 0x2890]
mov byte [ebp - 0x28f], dl
movsx eax, byte [ebp - 0xc94]
xor eax, 0xffffff98
mov byte [ebp - 0x28f], al
lea ecx, [ebp - 0x1f94]
mov dword [ebp - 0x2bd8], ecx
mov edx, dword [ebp - 0x2bd8]
add edx, dword [ebp - 0x2268]
mov dword [ebp - 0x2bdc], edx
mov eax, dword [ebp - 0x2bdc]
mov cl, byte [ebp - 0x28f]
mov byte [eax], cl
jmp 0x1014d476
lea edx, [ebp - 0x1f94]
mov dword [ebp - 0x2be0], edx
mov eax, dword [ebp - 0x2be0]
mov dword [ebp - 0x295c], eax
lea ecx, [ebp - 0x45c4]
mov dword [ebp - 0x2be4], ecx
movzx edx, byte [ebp - 0x2891]
push edx
mov ecx, dword [ebp - 0x2be4]
call fcn.1008cde0
mov dword [ebp - 4], 0x30
mov eax, dword [ebp - 0x295c]
mov dword [ebp - 0x226c], eax
mov ecx, dword [ebp - 0x226c]
add ecx, 1
mov dword [ebp - 0x2be8], ecx
mov edx, dword [ebp - 0x226c]
mov al, byte [edx]
mov byte [ebp - 0xc95], al
add dword [ebp - 0x226c], 1
cmp byte [ebp - 0xc95], 0
jne 0x1014d560
mov ecx, dword [ebp - 0x226c]
sub ecx, dword [ebp - 0x2be8]
mov dword [ebp - 0x2bec], ecx
mov edx, dword [ebp - 0x2bec]
mov dword [ebp - 0x2bf0], edx
mov eax, dword [ebp - 0x2bf0]
mov dword [ebp - 0x2bf4], eax
mov ecx, dword [ebp - 0x2bf4]
push ecx
mov edx, dword [ebp - 0x295c]
push edx
lea ecx, [ebp - 0x45c4]
call fcn.1008ce30
mov dword [ebp - 4], 0x31
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.icon]
mov byte [ebp - 0xc9c], dl
movsx eax, byte [ebp - 0xc9c]
xor eax, 0xffffff98
mov byte [ebp - 0xc9d], al
mov cl, byte [ebp - 0xc9d]
mov byte [ebp - 0x1f8c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.icon]
mov byte [ebp - 0xca4], al
movsx ecx, byte [ebp - 0xca4]
xor ecx, 0xffffff98
mov byte [ebp - 0xca5], cl
mov dl, byte [ebp - 0xca5]
mov byte [ebp - 0x1f8b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.icon]
mov byte [ebp - 0xcac], cl
movsx edx, byte [ebp - 0xcac]
xor edx, 0xffffff98
mov byte [ebp - 0xcad], dl
mov al, byte [ebp - 0xcad]
mov byte [ebp - 0x1f8a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.icon]
mov byte [ebp - 0xcb4], al
movsx ecx, byte [ebp - 0xcb4]
xor ecx, 0xffffff98
mov byte [ebp - 0xcb5], cl
mov dl, byte [ebp - 0xcb5]
mov byte [ebp - 0x1f89], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.icon]
mov byte [ebp - 0xcbc], cl
movsx edx, byte [ebp - 0xcbc]
xor edx, 0xffffff98
mov byte [ebp - 0xcbd], dl
mov al, byte [ebp - 0xcbd]
mov byte [ebp - 0x1f88], al
mov dword [ebp - 0x2270], 0
jmp 0x1014d6d2
mov ecx, dword [ebp - 0x2270]
add ecx, 1
mov dword [ebp - 0x2270], ecx
cmp dword [ebp - 0x2270], 5
jae 0x1014d754
lea edx, [ebp - 0x1f8c]
mov dword [ebp - 0x2bf8], edx
mov eax, dword [ebp - 0x2bf8]
add eax, dword [ebp - 0x2270]
mov dword [ebp - 0x2bfc], eax
mov ecx, dword [ebp - 0x2bfc]
mov dl, byte [ecx]
mov byte [ebp - 0xcc4], dl
mov al, byte [ebp - 0x2892]
mov byte [ebp - 0x290], al
movsx ecx, byte [ebp - 0xcc4]
xor ecx, 0xffffff98
mov byte [ebp - 0x290], cl
lea edx, [ebp - 0x1f8c]
mov dword [ebp - 0x2c00], edx
mov eax, dword [ebp - 0x2c00]
add eax, dword [ebp - 0x2270]
mov dword [ebp - 0x2c04], eax
mov ecx, dword [ebp - 0x2c04]
mov dl, byte [ebp - 0x290]
mov byte [ecx], dl
jmp 0x1014d6c3
lea eax, [ebp - 0x1f8c]
mov dword [ebp - 0x2c08], eax
mov ecx, dword [ebp - 0x2c08]
mov dword [ebp - 0x2960], ecx
lea edx, [ebp - 0x45ac]
mov dword [ebp - 0x2c0c], edx
movzx eax, byte [ebp - 0x2893]
push eax
mov ecx, dword [ebp - 0x2c0c]
call fcn.1008cde0
mov byte [ebp - 4], 0x32
mov ecx, dword [ebp - 0x2960]
mov dword [ebp - 0x2274], ecx
mov edx, dword [ebp - 0x2274]
add edx, 1
mov dword [ebp - 0x2c10], edx
mov eax, dword [ebp - 0x2274]
mov cl, byte [eax]
mov byte [ebp - 0xcc5], cl
add dword [ebp - 0x2274], 1
cmp byte [ebp - 0xcc5], 0
jne 0x1014d7aa
mov edx, dword [ebp - 0x2274]
sub edx, dword [ebp - 0x2c10]
mov dword [ebp - 0x2c14], edx
mov eax, dword [ebp - 0x2c14]
mov dword [ebp - 0x2c18], eax
mov ecx, dword [ebp - 0x2c18]
mov dword [ebp - 0x2c1c], ecx
mov edx, dword [ebp - 0x2c1c]
push edx
mov eax, dword [ebp - 0x2960]
push eax
lea ecx, [ebp - 0x45ac]
call fcn.1008ce30
mov dword [ebp - 4], 0x33
lea ecx, [ebp - 0x45c4]
mov dword [ebp - 0x3e28], ecx
lea edx, [ebp - 0x4594]
mov dword [ebp - 0x3e24], edx
mov eax, dword [ebp - 0x3e28]
mov ecx, dword [ebp - 0x3e24]
mov dword [ebp - 0x3e30], eax
mov dword [ebp - 0x3e2c], ecx
mov edx, dword [ebp - 0x2c20]
push edx
mov eax, dword [ebp - 0x3e2c]
push eax
mov ecx, dword [ebp - 0x3e30]
push ecx
lea ecx, [ebp - 0x40c8]
call fcn.10260fe0
mov byte [ebp - 4], 0x34
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + 0x103243a8]
mov byte [ebp - 0xccc], cl
movsx edx, byte [ebp - 0xccc]
xor edx, 0xffffff98
mov byte [ebp - 0xccd], dl
mov al, byte [ebp - 0xccd]
mov byte [ebp - 0x25e8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + 0x103243a8]
mov byte [ebp - 0xcd4], dl
movsx eax, byte [ebp - 0xcd4]
xor eax, 0xffffff98
mov byte [ebp - 0xcd5], al
mov cl, byte [ebp - 0xcd5]
mov byte [ebp - 0x25e7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + 0x103243a8]
mov byte [ebp - 0xcdc], al
movsx ecx, byte [ebp - 0xcdc]
xor ecx, 0xffffff98
mov byte [ebp - 0xcdd], cl
mov dl, byte [ebp - 0xcdd]
mov byte [ebp - 0x25e6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + 0x103243a8]
mov byte [ebp - 0xce4], dl
movsx eax, byte [ebp - 0xce4]
xor eax, 0xffffff98
mov byte [ebp - 0xce5], al
mov cl, byte [ebp - 0xce5]
mov byte [ebp - 0x25e5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + 0x103243a8]
mov byte [ebp - 0xcec], al
movsx ecx, byte [ebp - 0xcec]
xor ecx, 0xffffff98
mov byte [ebp - 0xced], cl
mov dl, byte [ebp - 0xced]
mov byte [ebp - 0x25e4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + 0x103243a8]
mov byte [ebp - 0xcf4], dl
movsx eax, byte [ebp - 0xcf4]
xor eax, 0xffffff98
mov byte [ebp - 0xcf5], al
mov cl, byte [ebp - 0xcf5]
mov byte [ebp - 0x25e3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + 0x103243a8]
mov byte [ebp - 0xcfc], cl
movsx edx, byte [ebp - 0xcfc]
xor edx, 0xffffff98
mov byte [ebp - 0xcfd], dl
mov al, byte [ebp - 0xcfd]
mov byte [ebp - 0x25e2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + 0x103243a8]
mov byte [ebp - 0xd04], al
movsx ecx, byte [ebp - 0xd04]
xor ecx, 0xffffff98
mov byte [ebp - 0xd05], cl
mov dl, byte [ebp - 0xd05]
mov byte [ebp - 0x25e1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + 0x103243a8]
mov byte [ebp - 0xd0c], cl
movsx edx, byte [ebp - 0xd0c]
xor edx, 0xffffff98
mov byte [ebp - 0xd0d], dl
mov al, byte [ebp - 0xd0d]
mov byte [ebp - 0x25e0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + 0x103243a8]
mov byte [ebp - 0xd14], al
movsx ecx, byte [ebp - 0xd14]
xor ecx, 0xffffff98
mov byte [ebp - 0xd15], cl
mov dl, byte [ebp - 0xd15]
mov byte [ebp - 0x25df], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + 0x103243a8]
mov byte [ebp - 0xd1c], dl
movsx eax, byte [ebp - 0xd1c]
xor eax, 0xffffff98
mov byte [ebp - 0xd1d], al
mov cl, byte [ebp - 0xd1d]
mov byte [ebp - 0x25de], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + 0x103243a8]
mov byte [ebp - 0xd24], cl
movsx edx, byte [ebp - 0xd24]
xor edx, 0xffffff98
mov byte [ebp - 0xd25], dl
mov al, byte [ebp - 0xd25]
mov byte [ebp - 0x25dd], al
mov dword [ebp - 0x2278], 0
jmp 0x1014dac0
mov ecx, dword [ebp - 0x2278]
add ecx, 1
mov dword [ebp - 0x2278], ecx
cmp dword [ebp - 0x2278], 0xc
jae 0x1014db42
lea edx, [ebp - 0x25e8]
mov dword [ebp - 0x2c24], edx
mov eax, dword [ebp - 0x2c24]
add eax, dword [ebp - 0x2278]
mov dword [ebp - 0x2c28], eax
mov ecx, dword [ebp - 0x2c28]
mov dl, byte [ecx]
mov byte [ebp - 0xd2c], dl
mov al, byte [ebp - 0x2894]
mov byte [ebp - 0x291], al
movsx ecx, byte [ebp - 0xd2c]
xor ecx, 0xffffff98
mov byte [ebp - 0x291], cl
lea edx, [ebp - 0x25e8]
mov dword [ebp - 0x2c2c], edx
mov eax, dword [ebp - 0x2c2c]
add eax, dword [ebp - 0x2278]
mov dword [ebp - 0x2c30], eax
mov ecx, dword [ebp - 0x2c30]
mov dl, byte [ebp - 0x291]
mov byte [ecx], dl
jmp 0x1014dab1
lea eax, [ebp - 0x25e8]
mov dword [ebp - 0x2c34], eax
mov ecx, dword [ebp - 0x2c34]
mov dword [ebp - 0x2964], ecx
lea edx, [ebp - 0x42d8]
mov dword [ebp - 0x2c38], edx
movzx eax, byte [ebp - 0x2895]
push eax
mov ecx, dword [ebp - 0x2c38]
call fcn.1008cde0
mov byte [ebp - 4], 0x35
mov ecx, dword [ebp - 0x2964]
mov dword [ebp - 0x227c], ecx
mov edx, dword [ebp - 0x227c]
add edx, 1
mov dword [ebp - 0x2c3c], edx
mov eax, dword [ebp - 0x227c]
mov cl, byte [eax]
mov byte [ebp - 0xd2d], cl
add dword [ebp - 0x227c], 1
cmp byte [ebp - 0xd2d], 0
jne 0x1014db98
mov edx, dword [ebp - 0x227c]
sub edx, dword [ebp - 0x2c3c]
mov dword [ebp - 0x2c40], edx
mov eax, dword [ebp - 0x2c40]
mov dword [ebp - 0x2c44], eax
mov ecx, dword [ebp - 0x2c44]
mov dword [ebp - 0x2c48], ecx
mov edx, dword [ebp - 0x2c48]
push edx
mov eax, dword [ebp - 0x2964]
push eax
lea ecx, [ebp - 0x42d8]
call fcn.1008ce30
mov byte [ebp - 4], 0x36
lea ecx, [ebp - 0x42c0]
mov dword [ebp - 0x2c4c], ecx
movzx edx, byte [ebp - 0x2896]
push edx
mov ecx, dword [ebp - 0x2c4c]
call fcn.1008cde0
mov byte [ebp - 4], 0x37
mov dword [ebp - 0x2280], str.weapon_mode
mov eax, dword [ebp - 0x2280]
add eax, 1
mov dword [ebp - 0x2c50], eax
mov ecx, dword [ebp - 0x2280]
mov dl, byte [ecx]
mov byte [ebp - 0xd2e], dl
add dword [ebp - 0x2280], 1
cmp byte [ebp - 0xd2e], 0
jne 0x1014dc39
mov eax, dword [ebp - 0x2280]
sub eax, dword [ebp - 0x2c50]
mov dword [ebp - 0x2c54], eax
mov ecx, dword [ebp - 0x2c54]
mov dword [ebp - 0x2c58], ecx
mov edx, dword [ebp - 0x2c58]
mov dword [ebp - 0x2c5c], edx
mov eax, dword [ebp - 0x2c5c]
push eax
push str.weapon_mode
lea ecx, [ebp - 0x42c0]
call fcn.1008ce30
mov byte [ebp - 4], 0x38
lea ecx, [ebp - 0x42d8]
push ecx
mov ecx, dword [ebp - 0x22c]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x22c]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x22c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1014dcde
lea edx, [ebp - 0x42c0]
push edx
mov ecx, dword [ebp - 0x22c]
add ecx, 0x70
call fcn.100ad110
mov eax, dword [ebp - 0x22c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1014dcf8
mov dword [ebp - 0x2968], 0xf
jmp 0x1014dd02
mov dword [ebp - 0x2968], 0
mov edx, dword [ebp - 0x22c]
mov eax, dword [ebp - 0x2968]
mov dword [edx + 0x9c], eax
mov ecx, dword [ebp - 0x22c]
mov edx, dword [ecx + 0x9c]
add edx, 0x14
mov dword [ebp - 0x296c], edx
mov eax, dword [ebp - 0x22c]
mov ecx, dword [ebp - 0x296c]
mov dword [eax + 0x10], ecx
mov edx, dword [ebp - 0x22c]
mov eax, dword [ebp - 0x296c]
mov dword [edx + 0x14], eax
lea ecx, [ebp - 0x40c8]
mov dword [ebp - 0x2970], ecx
mov edx, dword [ebp - 0x2970]
mov eax, dword [edx]
mov dword [ebp - 0x25a8], eax
mov ecx, dword [ebp - 0x2970]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x2c60], edx
jmp 0x1014dd81
mov eax, dword [ebp - 0x25a8]
add eax, 0x18
mov dword [ebp - 0x25a8], eax
mov ecx, dword [ebp - 0x25a8]
cmp ecx, dword [ebp - 0x2c60]
je 0x1014ddc0
mov edx, dword [ebp - 0x25a8]
mov dword [ebp - 0x2c64], edx
mov eax, dword [ebp - 0x22c]
add eax, 0x88
mov dword [ebp - 0x2c68], eax
mov ecx, dword [ebp - 0x2c64]
push ecx
mov ecx, dword [ebp - 0x2c68]
call fcn.100fca00
jmp 0x1014dd72
mov edx, dword [ebp - 0x22c]
add edx, 0x88
mov dword [ebp - 0x2974], edx
mov eax, dword [ebp - 0x2974]
mov ecx, dword [ebp - 0x2974]
mov eax, dword [eax + 4]
sub eax, dword [ecx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x2c6c], eax
cmp dword [ebp - 0x2c6c], 0
jbe 0x1014de0a
mov edx, dword [ebp - 0x22c]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x36
lea ecx, [ebp - 0x42c0]
call fcn.1008b960
mov byte [ebp - 4], 0x34
lea ecx, [ebp - 0x42d8]
call fcn.1008b960
mov byte [ebp - 4], 0x33
lea ecx, [ebp - 0x40c8]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 2
push 0x18
lea eax, [ebp - 0x45c4]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x600
mov dword [ebp - 0x64], ecx
mov edx, dword [ebp - 0x64]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x64]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x64]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x64]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x64]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x2c70], ecx
lea edx, [ebp - 0x64]
push edx
mov ecx, dword [ebp - 0x2c70]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x1f0
mov dword [ebp - 0x2294], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.dormant]
mov byte [ebp - 0xd34], al
movsx ecx, byte [ebp - 0xd34]
xor ecx, 0xffffff98
mov byte [ebp - 0xd35], cl
mov dl, byte [ebp - 0xd35]
mov byte [ebp - 0x2480], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.dormant]
mov byte [ebp - 0xd3c], cl
movsx edx, byte [ebp - 0xd3c]
xor edx, 0xffffff98
mov byte [ebp - 0xd3d], dl
mov al, byte [ebp - 0xd3d]
mov byte [ebp - 0x247f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xd44], dl
movsx eax, byte [ebp - 0xd44]
xor eax, 0xffffff98
mov byte [ebp - 0xd45], al
mov cl, byte [ebp - 0xd45]
mov byte [ebp - 0x247e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.dormant]
mov byte [ebp - 0xd4c], cl
movsx edx, byte [ebp - 0xd4c]
xor edx, 0xffffff98
mov byte [ebp - 0xd4d], dl
mov al, byte [ebp - 0xd4d]
mov byte [ebp - 0x247d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xd54], dl
movsx eax, byte [ebp - 0xd54]
xor eax, 0xffffff98
mov byte [ebp - 0xd55], al
mov cl, byte [ebp - 0xd55]
mov byte [ebp - 0x247c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.dormant]
mov byte [ebp - 0xd5c], cl
movsx edx, byte [ebp - 0xd5c]
xor edx, 0xffffff98
mov byte [ebp - 0xd5d], dl
mov al, byte [ebp - 0xd5d]
mov byte [ebp - 0x247b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.dormant]
mov byte [ebp - 0xd64], al
movsx ecx, byte [ebp - 0xd64]
xor ecx, 0xffffff98
mov byte [ebp - 0xd65], cl
mov dl, byte [ebp - 0xd65]
mov byte [ebp - 0x247a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xd6c], dl
movsx eax, byte [ebp - 0xd6c]
xor eax, 0xffffff98
mov byte [ebp - 0xd6d], al
mov cl, byte [ebp - 0xd6d]
mov byte [ebp - 0x2479], cl
mov dword [ebp - 0x2284], 0
jmp 0x1014e061
mov edx, dword [ebp - 0x2284]
add edx, 1
mov dword [ebp - 0x2284], edx
cmp dword [ebp - 0x2284], 8
jae 0x1014e0e3
lea eax, [ebp - 0x2480]
mov dword [ebp - 0x2c74], eax
mov ecx, dword [ebp - 0x2c74]
add ecx, dword [ebp - 0x2284]
mov dword [ebp - 0x2c78], ecx
mov edx, dword [ebp - 0x2c78]
mov al, byte [edx]
mov byte [ebp - 0xd74], al
mov cl, byte [ebp - 0x2897]
mov byte [ebp - 0x292], cl
movsx edx, byte [ebp - 0xd74]
xor edx, 0xffffff98
mov byte [ebp - 0x292], dl
lea eax, [ebp - 0x2480]
mov dword [ebp - 0x2c7c], eax
mov ecx, dword [ebp - 0x2c7c]
add ecx, dword [ebp - 0x2284]
mov dword [ebp - 0x2c80], ecx
mov edx, dword [ebp - 0x2c80]
mov al, byte [ebp - 0x292]
mov byte [edx], al
jmp 0x1014e052
lea ecx, [ebp - 0x2480]
mov dword [ebp - 0x2c84], ecx
mov edx, dword [ebp - 0x2c84]
mov dword [ebp - 0x2978], edx
lea eax, [ebp - 0x4308]
mov dword [ebp - 0x2c88], eax
movzx ecx, byte [ebp - 0x2898]
push ecx
mov ecx, dword [ebp - 0x2c88]
call fcn.1008cde0
mov dword [ebp - 4], 0x39
mov edx, dword [ebp - 0x2978]
mov dword [ebp - 0x2288], edx
mov eax, dword [ebp - 0x2288]
add eax, 1
mov dword [ebp - 0x2c8c], eax
mov ecx, dword [ebp - 0x2288]
mov dl, byte [ecx]
mov byte [ebp - 0xd75], dl
add dword [ebp - 0x2288], 1
cmp byte [ebp - 0xd75], 0
jne 0x1014e13c
mov eax, dword [ebp - 0x2288]
sub eax, dword [ebp - 0x2c8c]
mov dword [ebp - 0x2c90], eax
mov ecx, dword [ebp - 0x2c90]
mov dword [ebp - 0x2c94], ecx
mov edx, dword [ebp - 0x2c94]
mov dword [ebp - 0x2c98], edx
mov eax, dword [ebp - 0x2c98]
push eax
mov ecx, dword [ebp - 0x2978]
push ecx
lea ecx, [ebp - 0x4308]
call fcn.1008ce30
mov dword [ebp - 4], 0x3a
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.dormant]
mov byte [ebp - 0xd7c], cl
movsx edx, byte [ebp - 0xd7c]
xor edx, 0xffffff98
mov byte [ebp - 0xd7d], dl
mov al, byte [ebp - 0xd7d]
mov byte [ebp - 0x2460], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xd84], dl
movsx eax, byte [ebp - 0xd84]
xor eax, 0xffffff98
mov byte [ebp - 0xd85], al
mov cl, byte [ebp - 0xd85]
mov byte [ebp - 0x245f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.dormant]
mov byte [ebp - 0xd8c], al
movsx ecx, byte [ebp - 0xd8c]
xor ecx, 0xffffff98
mov byte [ebp - 0xd8d], cl
mov dl, byte [ebp - 0xd8d]
mov byte [ebp - 0x245e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xd94], dl
movsx eax, byte [ebp - 0xd94]
xor eax, 0xffffff98
mov byte [ebp - 0xd95], al
mov cl, byte [ebp - 0xd95]
mov byte [ebp - 0x245d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.dormant]
mov byte [ebp - 0xd9c], al
movsx ecx, byte [ebp - 0xd9c]
xor ecx, 0xffffff98
mov byte [ebp - 0xd9d], cl
mov dl, byte [ebp - 0xd9d]
mov byte [ebp - 0x245c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.dormant]
mov byte [ebp - 0xda4], dl
movsx eax, byte [ebp - 0xda4]
xor eax, 0xffffff98
mov byte [ebp - 0xda5], al
mov cl, byte [ebp - 0xda5]
mov byte [ebp - 0x245b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.dormant]
mov byte [ebp - 0xdac], cl
movsx edx, byte [ebp - 0xdac]
xor edx, 0xffffff98
mov byte [ebp - 0xdad], dl
mov al, byte [ebp - 0xdad]
mov byte [ebp - 0x245a], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.dormant]
mov byte [ebp - 0xdb4], al
movsx ecx, byte [ebp - 0xdb4]
xor ecx, 0xffffff98
mov byte [ebp - 0xdb5], cl
mov dl, byte [ebp - 0xdb5]
mov byte [ebp - 0x2459], dl
mov dword [ebp - 0x228c], 0
jmp 0x1014e33e
mov eax, dword [ebp - 0x228c]
add eax, 1
mov dword [ebp - 0x228c], eax
cmp dword [ebp - 0x228c], 8
jae 0x1014e3c0
lea ecx, [ebp - 0x2460]
mov dword [ebp - 0x2c9c], ecx
mov edx, dword [ebp - 0x2c9c]
add edx, dword [ebp - 0x228c]
mov dword [ebp - 0x2ca0], edx
mov eax, dword [ebp - 0x2ca0]
mov cl, byte [eax]
mov byte [ebp - 0xdbc], cl
mov dl, byte [ebp - 0x2899]
mov byte [ebp - 0x293], dl
movsx eax, byte [ebp - 0xdbc]
xor eax, 0xffffff98
mov byte [ebp - 0x293], al
lea ecx, [ebp - 0x2460]
mov dword [ebp - 0x2ca4], ecx
mov edx, dword [ebp - 0x2ca4]
add edx, dword [ebp - 0x228c]
mov dword [ebp - 0x2ca8], edx
mov eax, dword [ebp - 0x2ca8]
mov cl, byte [ebp - 0x293]
mov byte [eax], cl
jmp 0x1014e32f
lea edx, [ebp - 0x2460]
mov dword [ebp - 0x2cac], edx
mov eax, dword [ebp - 0x2cac]
mov dword [ebp - 0x297c], eax
lea ecx, [ebp - 0x42f0]
mov dword [ebp - 0x2cb0], ecx
movzx edx, byte [ebp - 0x289a]
push edx
mov ecx, dword [ebp - 0x2cb0]
call fcn.1008cde0
mov byte [ebp - 4], 0x3b
mov eax, dword [ebp - 0x297c]
mov dword [ebp - 0x2290], eax
mov ecx, dword [ebp - 0x2290]
add ecx, 1
mov dword [ebp - 0x2cb4], ecx
mov edx, dword [ebp - 0x2290]
mov al, byte [edx]
mov byte [ebp - 0xdbd], al
add dword [ebp - 0x2290], 1
cmp byte [ebp - 0xdbd], 0
jne 0x1014e416
mov ecx, dword [ebp - 0x2290]
sub ecx, dword [ebp - 0x2cb4]
mov dword [ebp - 0x2cb8], ecx
mov edx, dword [ebp - 0x2cb8]
mov dword [ebp - 0x2cbc], edx
mov eax, dword [ebp - 0x2cbc]
mov dword [ebp - 0x2cc0], eax
mov ecx, dword [ebp - 0x2cc0]
push ecx
mov edx, dword [ebp - 0x297c]
push edx
lea ecx, [ebp - 0x42f0]
call fcn.1008ce30
mov byte [ebp - 4], 0x3c
lea eax, [ebp - 0x4308]
push eax
mov ecx, dword [ebp - 0x2294]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x2294]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x2294]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1014e4bd
lea ecx, [ebp - 0x42f0]
push ecx
mov ecx, dword [ebp - 0x2294]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x2294]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x3a
lea ecx, [ebp - 0x42f0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4308]
call fcn.1008b960
mov eax, dword [ebp - 0x1b8]
add eax, 0x1f0
mov dword [ebp - 0x68], eax
mov ecx, dword [ebp - 0x68]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x68]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x68]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x68]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x68]
mov ecx, dword [ebp - 0x1b8]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x1b8]
add eax, 0x18
mov dword [ebp - 0x2cc4], eax
lea ecx, [ebp - 0x68]
push ecx
mov ecx, dword [ebp - 0x2cc4]
call fcn.1008c950
mov edx, dword [ebp - 0x1b8]
add edx, 0xd8
mov dword [ebp - 0x22a8], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x103243c8]
mov byte [ebp - 0xdc4], dl
movsx eax, byte [ebp - 0xdc4]
xor eax, 0xffffff98
mov byte [ebp - 0xdc5], al
mov cl, byte [ebp - 0xdc5]
mov byte [ebp - 0x24b0], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x103243c8]
mov byte [ebp - 0xdcc], al
movsx ecx, byte [ebp - 0xdcc]
xor ecx, 0xffffff98
mov byte [ebp - 0xdcd], cl
mov dl, byte [ebp - 0xdcd]
mov byte [ebp - 0x24af], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x103243c8]
mov byte [ebp - 0xdd4], cl
movsx edx, byte [ebp - 0xdd4]
xor edx, 0xffffff98
mov byte [ebp - 0xdd5], dl
mov al, byte [ebp - 0xdd5]
mov byte [ebp - 0x24ae], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x103243c8]
mov byte [ebp - 0xddc], al
movsx ecx, byte [ebp - 0xddc]
xor ecx, 0xffffff98
mov byte [ebp - 0xddd], cl
mov dl, byte [ebp - 0xddd]
mov byte [ebp - 0x24ad], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x103243c8]
mov byte [ebp - 0xde4], cl
movsx edx, byte [ebp - 0xde4]
xor edx, 0xffffff98
mov byte [ebp - 0xde5], dl
mov al, byte [ebp - 0xde5]
mov byte [ebp - 0x24ac], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x103243c8]
mov byte [ebp - 0xdec], al
movsx ecx, byte [ebp - 0xdec]
xor ecx, 0xffffff98
mov byte [ebp - 0xded], cl
mov dl, byte [ebp - 0xded]
mov byte [ebp - 0x24ab], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x103243c8]
mov byte [ebp - 0xdf4], dl
movsx eax, byte [ebp - 0xdf4]
xor eax, 0xffffff98
mov byte [ebp - 0xdf5], al
mov cl, byte [ebp - 0xdf5]
mov byte [ebp - 0x24aa], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x103243c8]
mov byte [ebp - 0xdfc], cl
movsx edx, byte [ebp - 0xdfc]
xor edx, 0xffffff98
mov byte [ebp - 0xdfd], dl
mov al, byte [ebp - 0xdfd]
mov byte [ebp - 0x24a9], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x103243c8]
mov byte [ebp - 0xe04], dl
movsx eax, byte [ebp - 0xe04]
xor eax, 0xffffff98
mov byte [ebp - 0xe05], al
mov cl, byte [ebp - 0xe05]
mov byte [ebp - 0x24a8], cl
mov dword [ebp - 0x2298], 0
jmp 0x1014e726
mov edx, dword [ebp - 0x2298]
add edx, 1
mov dword [ebp - 0x2298], edx
cmp dword [ebp - 0x2298], 9
jae 0x1014e7a8
lea eax, [ebp - 0x24b0]
mov dword [ebp - 0x2cc8], eax
mov ecx, dword [ebp - 0x2cc8]
add ecx, dword [ebp - 0x2298]
mov dword [ebp - 0x2ccc], ecx
mov edx, dword [ebp - 0x2ccc]
mov al, byte [edx]
mov byte [ebp - 0xe0c], al
mov cl, byte [ebp - 0x289b]
mov byte [ebp - 0x294], cl
movsx edx, byte [ebp - 0xe0c]
xor edx, 0xffffff98
mov byte [ebp - 0x294], dl
lea eax, [ebp - 0x24b0]
mov dword [ebp - 0x2cd0], eax
mov ecx, dword [ebp - 0x2cd0]
add ecx, dword [ebp - 0x2298]
mov dword [ebp - 0x2cd4], ecx
mov edx, dword [ebp - 0x2cd4]
mov al, byte [ebp - 0x294]
mov byte [edx], al
jmp 0x1014e717
lea ecx, [ebp - 0x24b0]
mov dword [ebp - 0x2cd8], ecx
mov edx, dword [ebp - 0x2cd8]
mov dword [ebp - 0x2980], edx
lea eax, [ebp - 0x4338]
mov dword [ebp - 0x2cdc], eax
movzx ecx, byte [ebp - 0x289c]
push ecx
mov ecx, dword [ebp - 0x2cdc]
call fcn.1008cde0
mov dword [ebp - 4], 0x3d
mov edx, dword [ebp - 0x2980]
mov dword [ebp - 0x229c], edx
mov eax, dword [ebp - 0x229c]
add eax, 1
mov dword [ebp - 0x2ce0], eax
mov ecx, dword [ebp - 0x229c]
mov dl, byte [ecx]
mov byte [ebp - 0xe0d], dl
add dword [ebp - 0x229c], 1
cmp byte [ebp - 0xe0d], 0
jne 0x1014e801
mov eax, dword [ebp - 0x229c]
sub eax, dword [ebp - 0x2ce0]
mov dword [ebp - 0x2ce4], eax
mov ecx, dword [ebp - 0x2ce4]
mov dword [ebp - 0x2ce8], ecx
mov edx, dword [ebp - 0x2ce8]
mov dword [ebp - 0x2cec], edx
mov eax, dword [ebp - 0x2cec]
push eax
mov ecx, dword [ebp - 0x2980]
push ecx
lea ecx, [ebp - 0x4338]
call fcn.1008ce30
mov dword [ebp - 4], 0x3e
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.team_esp]
mov byte [ebp - 0xe14], cl
movsx edx, byte [ebp - 0xe14]
xor edx, 0xffffff98
mov byte [ebp - 0xe15], dl
mov al, byte [ebp - 0xe15]
mov byte [ebp - 0x248c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.team_esp]
mov byte [ebp - 0xe1c], dl
movsx eax, byte [ebp - 0xe1c]
xor eax, 0xffffff98
mov byte [ebp - 0xe1d], al
mov cl, byte [ebp - 0xe1d]
mov byte [ebp - 0x248b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.team_esp]
mov byte [ebp - 0xe24], al
movsx ecx, byte [ebp - 0xe24]
xor ecx, 0xffffff98
mov byte [ebp - 0xe25], cl
mov dl, byte [ebp - 0xe25]
mov byte [ebp - 0x248a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.team_esp]
mov byte [ebp - 0xe2c], dl
movsx eax, byte [ebp - 0xe2c]
xor eax, 0xffffff98
mov byte [ebp - 0xe2d], al
mov cl, byte [ebp - 0xe2d]
mov byte [ebp - 0x2489], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.team_esp]
mov byte [ebp - 0xe34], al
movsx ecx, byte [ebp - 0xe34]
xor ecx, 0xffffff98
mov byte [ebp - 0xe35], cl
mov dl, byte [ebp - 0xe35]
mov byte [ebp - 0x2488], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.team_esp]
mov byte [ebp - 0xe3c], dl
movsx eax, byte [ebp - 0xe3c]
xor eax, 0xffffff98
mov byte [ebp - 0xe3d], al
mov cl, byte [ebp - 0xe3d]
mov byte [ebp - 0x2487], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.team_esp]
mov byte [ebp - 0xe44], cl
movsx edx, byte [ebp - 0xe44]
xor edx, 0xffffff98
mov byte [ebp - 0xe45], dl
mov al, byte [ebp - 0xe45]
mov byte [ebp - 0x2486], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.team_esp]
mov byte [ebp - 0xe4c], al
movsx ecx, byte [ebp - 0xe4c]
xor ecx, 0xffffff98
mov byte [ebp - 0xe4d], cl
mov dl, byte [ebp - 0xe4d]
mov byte [ebp - 0x2485], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.team_esp]
mov byte [ebp - 0xe54], cl
movsx edx, byte [ebp - 0xe54]
xor edx, 0xffffff98
mov byte [ebp - 0xe55], dl
mov al, byte [ebp - 0xe55]
mov byte [ebp - 0x2484], al
mov dword [ebp - 0x22a0], 0
jmp 0x1014ea33
mov ecx, dword [ebp - 0x22a0]
add ecx, 1
mov dword [ebp - 0x22a0], ecx
cmp dword [ebp - 0x22a0], 9
jae 0x1014eab5
lea edx, [ebp - 0x248c]
mov dword [ebp - 0x2cf0], edx
mov eax, dword [ebp - 0x2cf0]
add eax, dword [ebp - 0x22a0]
mov dword [ebp - 0x2cf4], eax
mov ecx, dword [ebp - 0x2cf4]
mov dl, byte [ecx]
mov byte [ebp - 0xe5c], dl
mov al, byte [ebp - 0x289d]
mov byte [ebp - 0x295], al
movsx ecx, byte [ebp - 0xe5c]
xor ecx, 0xffffff98
mov byte [ebp - 0x295], cl
lea edx, [ebp - 0x248c]
mov dword [ebp - 0x2cf8], edx
mov eax, dword [ebp - 0x2cf8]
add eax, dword [ebp - 0x22a0]
mov dword [ebp - 0x2cfc], eax
mov ecx, dword [ebp - 0x2cfc]
mov dl, byte [ebp - 0x295]
mov byte [ecx], dl
jmp 0x1014ea24
lea eax, [ebp - 0x248c]
mov dword [ebp - 0x2d00], eax
mov ecx, dword [ebp - 0x2d00]
mov dword [ebp - 0x2984], ecx
lea edx, [ebp - 0x4320]
mov dword [ebp - 0x2d04], edx
movzx eax, byte [ebp - 0x289e]
push eax
mov ecx, dword [ebp - 0x2d04]
call fcn.1008cde0
mov byte [ebp - 4], 0x3f
mov ecx, dword [ebp - 0x2984]
mov dword [ebp - 0x22a4], ecx
mov edx, dword [ebp - 0x22a4]
add edx, 1
mov dword [ebp - 0x2d08], edx
mov eax, dword [ebp - 0x22a4]
mov cl, byte [eax]
mov byte [ebp - 0xe5d], cl
add dword [ebp - 0x22a4], 1
cmp byte [ebp - 0xe5d], 0
jne 0x1014eb0b
mov edx, dword [ebp - 0x22a4]
sub edx, dword [ebp - 0x2d08]
mov dword [ebp - 0x2d0c], edx
mov eax, dword [ebp - 0x2d0c]
mov dword [ebp - 0x2d10], eax
mov ecx, dword [ebp - 0x2d10]
mov dword [ebp - 0x2d14], ecx
mov edx, dword [ebp - 0x2d14]
push edx
mov eax, dword [ebp - 0x2984]
push eax
lea ecx, [ebp - 0x4320]
call fcn.1008ce30
mov byte [ebp - 4], 0x40
lea ecx, [ebp - 0x4338]
push ecx
mov ecx, dword [ebp - 0x22a8]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x22a8]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x22a8]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1014ebb2
lea edx, [ebp - 0x4320]
push edx
mov ecx, dword [ebp - 0x22a8]
add ecx, 0x70
call fcn.100ad110
mov eax, dword [ebp - 0x22a8]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 0x3e
lea ecx, [ebp - 0x4320]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4338]
call fcn.1008b960
mov ecx, dword [ebp - 0x1b8]
add ecx, 0xd8
mov dword [ebp - 0x34], ecx
mov edx, dword [ebp - 0x34]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x34]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x34]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x34]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x34]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x2d18], ecx
lea edx, [ebp - 0x34]
push edx
mov ecx, dword [ebp - 0x2d18]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x160
mov dword [ebp - 0x1b94], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x1032440c]
mov byte [ebp - 0xe64], al
movsx ecx, byte [ebp - 0xe64]
xor ecx, 0xffffff98
mov byte [ebp - 0xe65], cl
mov dl, byte [ebp - 0xe65]
mov byte [ebp - 0x24d4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x1032440c]
mov byte [ebp - 0xe6c], cl
movsx edx, byte [ebp - 0xe6c]
xor edx, 0xffffff98
mov byte [ebp - 0xe6d], dl
mov al, byte [ebp - 0xe6d]
mov byte [ebp - 0x24d3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x1032440c]
mov byte [ebp - 0xe74], dl
movsx eax, byte [ebp - 0xe74]
xor eax, 0xffffff98
mov byte [ebp - 0xe75], al
mov cl, byte [ebp - 0xe75]
mov byte [ebp - 0x24d2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x1032440c]
mov byte [ebp - 0xe7c], cl
movsx edx, byte [ebp - 0xe7c]
xor edx, 0xffffff98
mov byte [ebp - 0xe7d], dl
mov al, byte [ebp - 0xe7d]
mov byte [ebp - 0x24d1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + 0x1032440c]
mov byte [ebp - 0xe84], dl
movsx eax, byte [ebp - 0xe84]
xor eax, 0xffffff98
mov byte [ebp - 0xe85], al
mov cl, byte [ebp - 0xe85]
mov byte [ebp - 0x24d0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + 0x1032440c]
mov byte [ebp - 0xe8c], cl
movsx edx, byte [ebp - 0xe8c]
xor edx, 0xffffff98
mov byte [ebp - 0xe8d], dl
mov al, byte [ebp - 0xe8d]
mov byte [ebp - 0x24cf], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + 0x1032440c]
mov byte [ebp - 0xe94], al
movsx ecx, byte [ebp - 0xe94]
xor ecx, 0xffffff98
mov byte [ebp - 0xe95], cl
mov dl, byte [ebp - 0xe95]
mov byte [ebp - 0x24ce], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + 0x1032440c]
mov byte [ebp - 0xe9c], dl
movsx eax, byte [ebp - 0xe9c]
xor eax, 0xffffff98
mov byte [ebp - 0xe9d], al
mov cl, byte [ebp - 0xe9d]
mov byte [ebp - 0x24cd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + 0x1032440c]
mov byte [ebp - 0xea4], al
movsx ecx, byte [ebp - 0xea4]
xor ecx, 0xffffff98
mov byte [ebp - 0xea5], cl
mov dl, byte [ebp - 0xea5]
mov byte [ebp - 0x24cc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + 0x1032440c]
mov byte [ebp - 0xeac], dl
movsx eax, byte [ebp - 0xeac]
xor eax, 0xffffff98
mov byte [ebp - 0xead], al
mov cl, byte [ebp - 0xead]
mov byte [ebp - 0x24cb], cl
mov dword [ebp - 0x22ac], 0
jmp 0x1014ee4b
mov edx, dword [ebp - 0x22ac]
add edx, 1
mov dword [ebp - 0x22ac], edx
cmp dword [ebp - 0x22ac], 0xa
jae 0x1014eecd
lea eax, [ebp - 0x24d4]
mov dword [ebp - 0x2d1c], eax
mov ecx, dword [ebp - 0x2d1c]
add ecx, dword [ebp - 0x22ac]
mov dword [ebp - 0x2d20], ecx
mov edx, dword [ebp - 0x2d20]
mov al, byte [edx]
mov byte [ebp - 0xeb4], al
mov cl, byte [ebp - 0x289f]
mov byte [ebp - 0x296], cl
movsx edx, byte [ebp - 0xeb4]
xor edx, 0xffffff98
mov byte [ebp - 0x296], dl
lea eax, [ebp - 0x24d4]
mov dword [ebp - 0x2d24], eax
mov ecx, dword [ebp - 0x2d24]
add ecx, dword [ebp - 0x22ac]
mov dword [ebp - 0x2d28], ecx
mov edx, dword [ebp - 0x2d28]
mov al, byte [ebp - 0x296]
mov byte [edx], al
jmp 0x1014ee3c
lea ecx, [ebp - 0x24d4]
mov dword [ebp - 0x2d2c], ecx
mov edx, dword [ebp - 0x2d2c]
mov dword [ebp - 0x2988], edx
lea eax, [ebp - 0x4368]
mov dword [ebp - 0x2d30], eax
movzx ecx, byte [ebp - 0x28a0]
push ecx
mov ecx, dword [ebp - 0x2d30]
call fcn.1008cde0
mov dword [ebp - 4], 0x41
mov edx, dword [ebp - 0x2988]
mov dword [ebp - 0x22b0], edx
mov eax, dword [ebp - 0x22b0]
add eax, 1
mov dword [ebp - 0x2d34], eax
mov ecx, dword [ebp - 0x22b0]
mov dl, byte [ecx]
mov byte [ebp - 0xeb5], dl
add dword [ebp - 0x22b0], 1
cmp byte [ebp - 0xeb5], 0
jne 0x1014ef26
mov eax, dword [ebp - 0x22b0]
sub eax, dword [ebp - 0x2d34]
mov dword [ebp - 0x2d38], eax
mov ecx, dword [ebp - 0x2d38]
mov dword [ebp - 0x2d3c], ecx
mov edx, dword [ebp - 0x2d3c]
mov dword [ebp - 0x2d40], edx
mov eax, dword [ebp - 0x2d40]
push eax
mov ecx, dword [ebp - 0x2988]
push ecx
lea ecx, [ebp - 0x4368]
call fcn.1008ce30
mov dword [ebp - 4], 0x42
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.box_color]
mov byte [ebp - 0xebc], cl
movsx edx, byte [ebp - 0xebc]
xor edx, 0xffffff98
mov byte [ebp - 0xebd], dl
mov al, byte [ebp - 0xebd]
mov byte [ebp - 0x24c8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.box_color]
mov byte [ebp - 0xec4], dl
movsx eax, byte [ebp - 0xec4]
xor eax, 0xffffff98
mov byte [ebp - 0xec5], al
mov cl, byte [ebp - 0xec5]
mov byte [ebp - 0x24c7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.box_color]
mov byte [ebp - 0xecc], al
movsx ecx, byte [ebp - 0xecc]
xor ecx, 0xffffff98
mov byte [ebp - 0xecd], cl
mov dl, byte [ebp - 0xecd]
mov byte [ebp - 0x24c6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.box_color]
mov byte [ebp - 0xed4], dl
movsx eax, byte [ebp - 0xed4]
xor eax, 0xffffff98
mov byte [ebp - 0xed5], al
mov cl, byte [ebp - 0xed5]
mov byte [ebp - 0x24c5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.box_color]
mov byte [ebp - 0xedc], al
movsx ecx, byte [ebp - 0xedc]
xor ecx, 0xffffff98
mov byte [ebp - 0xedd], cl
mov dl, byte [ebp - 0xedd]
mov byte [ebp - 0x24c4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.box_color]
mov byte [ebp - 0xee4], dl
movsx eax, byte [ebp - 0xee4]
xor eax, 0xffffff98
mov byte [ebp - 0xee5], al
mov cl, byte [ebp - 0xee5]
mov byte [ebp - 0x24c3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.box_color]
mov byte [ebp - 0xeec], cl
movsx edx, byte [ebp - 0xeec]
xor edx, 0xffffff98
mov byte [ebp - 0xeed], dl
mov al, byte [ebp - 0xeed]
mov byte [ebp - 0x24c2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.box_color]
mov byte [ebp - 0xef4], al
movsx ecx, byte [ebp - 0xef4]
xor ecx, 0xffffff98
mov byte [ebp - 0xef5], cl
mov dl, byte [ebp - 0xef5]
mov byte [ebp - 0x24c1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.box_color]
mov byte [ebp - 0xefc], cl
movsx edx, byte [ebp - 0xefc]
xor edx, 0xffffff98
mov byte [ebp - 0xefd], dl
mov al, byte [ebp - 0xefd]
mov byte [ebp - 0x24c0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.box_color]
mov byte [ebp - 0xf04], al
movsx ecx, byte [ebp - 0xf04]
xor ecx, 0xffffff98
mov byte [ebp - 0xf05], cl
mov dl, byte [ebp - 0xf05]
mov byte [ebp - 0x24bf], dl
mov dword [ebp - 0x22b4], 0
jmp 0x1014f188
mov eax, dword [ebp - 0x22b4]
add eax, 1
mov dword [ebp - 0x22b4], eax
cmp dword [ebp - 0x22b4], 0xa
jae 0x1014f20a
lea ecx, [ebp - 0x24c8]
mov dword [ebp - 0x2d44], ecx
mov edx, dword [ebp - 0x2d44]
add edx, dword [ebp - 0x22b4]
mov dword [ebp - 0x2d48], edx
mov eax, dword [ebp - 0x2d48]
mov cl, byte [eax]
mov byte [ebp - 0xf0c], cl
mov dl, byte [ebp - 0x28a1]
mov byte [ebp - 0x297], dl
movsx eax, byte [ebp - 0xf0c]
xor eax, 0xffffff98
mov byte [ebp - 0x297], al
lea ecx, [ebp - 0x24c8]
mov dword [ebp - 0x2d4c], ecx
mov edx, dword [ebp - 0x2d4c]
add edx, dword [ebp - 0x22b4]
mov dword [ebp - 0x2d50], edx
mov eax, dword [ebp - 0x2d50]
mov cl, byte [ebp - 0x297]
mov byte [eax], cl
jmp 0x1014f179
lea edx, [ebp - 0x24c8]
mov dword [ebp - 0x2d54], edx
mov eax, dword [ebp - 0x2d54]
mov dword [ebp - 0x298c], eax
lea ecx, [ebp - 0x4350]
mov dword [ebp - 0x2d58], ecx
movzx edx, byte [ebp - 0x28a2]
push edx
mov ecx, dword [ebp - 0x2d58]
call fcn.1008cde0
mov byte [ebp - 4], 0x43
mov eax, dword [ebp - 0x298c]
mov dword [ebp - 0x22b8], eax
mov ecx, dword [ebp - 0x22b8]
add ecx, 1
mov dword [ebp - 0x2d5c], ecx
mov edx, dword [ebp - 0x22b8]
mov al, byte [edx]
mov byte [ebp - 0xf0d], al
add dword [ebp - 0x22b8], 1
cmp byte [ebp - 0xf0d], 0
jne 0x1014f260
mov ecx, dword [ebp - 0x22b8]
sub ecx, dword [ebp - 0x2d5c]
mov dword [ebp - 0x2d60], ecx
mov edx, dword [ebp - 0x2d60]
mov dword [ebp - 0x2d64], edx
mov eax, dword [ebp - 0x2d64]
mov dword [ebp - 0x2d68], eax
mov ecx, dword [ebp - 0x2d68]
push ecx
mov edx, dword [ebp - 0x298c]
push edx
lea ecx, [ebp - 0x4350]
call fcn.1008ce30
mov byte [ebp - 4], 0x44
lea eax, [ebp - 0x2d6c]
mov dword [ebp - 0x25ac], eax
mov ecx, dword [ebp - 0x25ac]
mov byte [ecx], 0x96
mov edx, dword [ebp - 0x25ac]
mov byte [edx + 1], 0xc8
mov eax, dword [ebp - 0x25ac]
mov byte [eax + 2], 0x3c
mov ecx, dword [ebp - 0x25ac]
mov byte [ecx + 3], 0xff
lea edx, [ebp - 0x4350]
push edx
mov ecx, dword [ebp - 0x1b94]
add ecx, 0x70
call fcn.100ad110
lea eax, [ebp - 0x4368]
push eax
mov ecx, dword [ebp - 0x1b94]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1b94]
mov edx, dword [ebp - 0x2d6c]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1b94]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1b94]
cmp dword [ecx + 0x8c], 0
je 0x1014f36d
mov edx, dword [ebp - 0x1b94]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1b94]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 0x42
lea ecx, [ebp - 0x4350]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4368]
call fcn.1008b960
mov eax, dword [ebp - 0x1b8]
add eax, 0x160
mov dword [ebp - 0x6c], eax
mov ecx, dword [ebp - 0x6c]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x6c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x6c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x6c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x6c]
mov ecx, dword [ebp - 0x1b8]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x1b8]
add eax, 0x18
mov dword [ebp - 0x2d70], eax
lea ecx, [ebp - 0x6c]
push ecx
mov ecx, dword [ebp - 0x2d70]
call fcn.1008c950
mov edx, dword [ebp - 0x1b8]
add edx, 0x390
mov dword [ebp - 0x1b98], edx
mov eax, dword [0x103bfacc]
mov dword [ebp - 0x2d74], eax
mov ecx, dword [ebp - 0x2d74]
mov dword [ebp - 0x2d78], ecx
mov edx, dword [ebp - 0x2d78]
mov dword [ebp - 0x2dcc], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x103243f4]
mov byte [ebp - 0xf14], dl
movsx eax, byte [ebp - 0xf14]
xor eax, 0xffffff98
mov byte [ebp - 0xf15], al
mov cl, byte [ebp - 0xf15]
mov byte [ebp - 0x2528], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x103243f4]
mov byte [ebp - 0xf1c], al
movsx ecx, byte [ebp - 0xf1c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf1d], cl
mov dl, byte [ebp - 0xf1d]
mov byte [ebp - 0x2527], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x103243f4]
mov byte [ebp - 0xf24], cl
movsx edx, byte [ebp - 0xf24]
xor edx, 0xffffff98
mov byte [ebp - 0xf25], dl
mov al, byte [ebp - 0xf25]
mov byte [ebp - 0x2526], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x103243f4]
mov byte [ebp - 0xf2c], al
movsx ecx, byte [ebp - 0xf2c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf2d], cl
mov dl, byte [ebp - 0xf2d]
mov byte [ebp - 0x2525], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x103243f4]
mov byte [ebp - 0xf34], cl
movsx edx, byte [ebp - 0xf34]
xor edx, 0xffffff98
mov byte [ebp - 0xf35], dl
mov al, byte [ebp - 0xf35]
mov byte [ebp - 0x2524], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x103243f4]
mov byte [ebp - 0xf3c], al
movsx ecx, byte [ebp - 0xf3c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf3d], cl
mov dl, byte [ebp - 0xf3d]
mov byte [ebp - 0x2523], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x103243f4]
mov byte [ebp - 0xf44], dl
movsx eax, byte [ebp - 0xf44]
xor eax, 0xffffff98
mov byte [ebp - 0xf45], al
mov cl, byte [ebp - 0xf45]
mov byte [ebp - 0x2522], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x103243f4]
mov byte [ebp - 0xf4c], cl
movsx edx, byte [ebp - 0xf4c]
xor edx, 0xffffff98
mov byte [ebp - 0xf4d], dl
mov al, byte [ebp - 0xf4d]
mov byte [ebp - 0x2521], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x103243f4]
mov byte [ebp - 0xf54], dl
movsx eax, byte [ebp - 0xf54]
xor eax, 0xffffff98
mov byte [ebp - 0xf55], al
mov cl, byte [ebp - 0xf55]
mov byte [ebp - 0x2520], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + 0x103243f4]
mov byte [ebp - 0xf5c], cl
movsx edx, byte [ebp - 0xf5c]
xor edx, 0xffffff98
mov byte [ebp - 0xf5d], dl
mov al, byte [ebp - 0xf5d]
mov byte [ebp - 0x251f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + 0x103243f4]
mov byte [ebp - 0xf64], al
movsx ecx, byte [ebp - 0xf64]
xor ecx, 0xffffff98
mov byte [ebp - 0xf65], cl
mov dl, byte [ebp - 0xf65]
mov byte [ebp - 0x251e], dl
mov dword [ebp - 0x22bc], 0
jmp 0x1014f64f
mov eax, dword [ebp - 0x22bc]
add eax, 1
mov dword [ebp - 0x22bc], eax
cmp dword [ebp - 0x22bc], 0xb
jae 0x1014f6d1
lea ecx, [ebp - 0x2528]
mov dword [ebp - 0x2d7c], ecx
mov edx, dword [ebp - 0x2d7c]
add edx, dword [ebp - 0x22bc]
mov dword [ebp - 0x2d80], edx
mov eax, dword [ebp - 0x2d80]
mov cl, byte [eax]
mov byte [ebp - 0xf6c], cl
mov dl, byte [ebp - 0x28a3]
mov byte [ebp - 0x298], dl
movsx eax, byte [ebp - 0xf6c]
xor eax, 0xffffff98
mov byte [ebp - 0x298], al
lea ecx, [ebp - 0x2528]
mov dword [ebp - 0x2d84], ecx
mov edx, dword [ebp - 0x2d84]
add edx, dword [ebp - 0x22bc]
mov dword [ebp - 0x2d88], edx
mov eax, dword [ebp - 0x2d88]
mov cl, byte [ebp - 0x298]
mov byte [eax], cl
jmp 0x1014f640
lea edx, [ebp - 0x2528]
mov dword [ebp - 0x2d8c], edx
mov eax, dword [ebp - 0x2d8c]
mov dword [ebp - 0x2990], eax
lea ecx, [ebp - 0x4398]
mov dword [ebp - 0x2d90], ecx
movzx edx, byte [ebp - 0x28a4]
push edx
mov ecx, dword [ebp - 0x2d90]
call fcn.1008cde0
mov dword [ebp - 4], 0x45
mov eax, dword [ebp - 0x2990]
mov dword [ebp - 0x22c0], eax
mov ecx, dword [ebp - 0x22c0]
add ecx, 1
mov dword [ebp - 0x2d94], ecx
mov edx, dword [ebp - 0x22c0]
mov al, byte [edx]
mov byte [ebp - 0xf6d], al
add dword [ebp - 0x22c0], 1
cmp byte [ebp - 0xf6d], 0
jne 0x1014f72a
mov ecx, dword [ebp - 0x22c0]
sub ecx, dword [ebp - 0x2d94]
mov dword [ebp - 0x2d98], ecx
mov edx, dword [ebp - 0x2d98]
mov dword [ebp - 0x2d9c], edx
mov eax, dword [ebp - 0x2d9c]
mov dword [ebp - 0x2da0], eax
mov ecx, dword [ebp - 0x2da0]
push ecx
mov edx, dword [ebp - 0x2990]
push edx
lea ecx, [ebp - 0x4398]
call fcn.1008ce30
mov dword [ebp - 4], 0x46
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.name_color]
mov byte [ebp - 0xf74], dl
movsx eax, byte [ebp - 0xf74]
xor eax, 0xffffff98
mov byte [ebp - 0xf75], al
mov cl, byte [ebp - 0xf75]
mov byte [ebp - 0x2510], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.name_color]
mov byte [ebp - 0xf7c], al
movsx ecx, byte [ebp - 0xf7c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf7d], cl
mov dl, byte [ebp - 0xf7d]
mov byte [ebp - 0x250f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.name_color]
mov byte [ebp - 0xf84], cl
movsx edx, byte [ebp - 0xf84]
xor edx, 0xffffff98
mov byte [ebp - 0xf85], dl
mov al, byte [ebp - 0xf85]
mov byte [ebp - 0x250e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.name_color]
mov byte [ebp - 0xf8c], al
movsx ecx, byte [ebp - 0xf8c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf8d], cl
mov dl, byte [ebp - 0xf8d]
mov byte [ebp - 0x250d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.name_color]
mov byte [ebp - 0xf94], cl
movsx edx, byte [ebp - 0xf94]
xor edx, 0xffffff98
mov byte [ebp - 0xf95], dl
mov al, byte [ebp - 0xf95]
mov byte [ebp - 0x250c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.name_color]
mov byte [ebp - 0xf9c], al
movsx ecx, byte [ebp - 0xf9c]
xor ecx, 0xffffff98
mov byte [ebp - 0xf9d], cl
mov dl, byte [ebp - 0xf9d]
mov byte [ebp - 0x250b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.name_color]
mov byte [ebp - 0xfa4], dl
movsx eax, byte [ebp - 0xfa4]
xor eax, 0xffffff98
mov byte [ebp - 0xfa5], al
mov cl, byte [ebp - 0xfa5]
mov byte [ebp - 0x250a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.name_color]
mov byte [ebp - 0xfac], cl
movsx edx, byte [ebp - 0xfac]
xor edx, 0xffffff98
mov byte [ebp - 0xfad], dl
mov al, byte [ebp - 0xfad]
mov byte [ebp - 0x2509], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.name_color]
mov byte [ebp - 0xfb4], dl
movsx eax, byte [ebp - 0xfb4]
xor eax, 0xffffff98
mov byte [ebp - 0xfb5], al
mov cl, byte [ebp - 0xfb5]
mov byte [ebp - 0x2508], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.name_color]
mov byte [ebp - 0xfbc], cl
movsx edx, byte [ebp - 0xfbc]
xor edx, 0xffffff98
mov byte [ebp - 0xfbd], dl
mov al, byte [ebp - 0xfbd]
mov byte [ebp - 0x2507], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.name_color]
mov byte [ebp - 0xfc4], al
movsx ecx, byte [ebp - 0xfc4]
xor ecx, 0xffffff98
mov byte [ebp - 0xfc5], cl
mov dl, byte [ebp - 0xfc5]
mov byte [ebp - 0x2506], dl
mov dword [ebp - 0x22c4], 0
jmp 0x1014f9bc
mov eax, dword [ebp - 0x22c4]
add eax, 1
mov dword [ebp - 0x22c4], eax
cmp dword [ebp - 0x22c4], 0xb
jae 0x1014fa3e
lea ecx, [ebp - 0x2510]
mov dword [ebp - 0x2da4], ecx
mov edx, dword [ebp - 0x2da4]
add edx, dword [ebp - 0x22c4]
mov dword [ebp - 0x2da8], edx
mov eax, dword [ebp - 0x2da8]
mov cl, byte [eax]
mov byte [ebp - 0xfcc], cl
mov dl, byte [ebp - 0x28a5]
mov byte [ebp - 0x299], dl
movsx eax, byte [ebp - 0xfcc]
xor eax, 0xffffff98
mov byte [ebp - 0x299], al
lea ecx, [ebp - 0x2510]
mov dword [ebp - 0x2dac], ecx
mov edx, dword [ebp - 0x2dac]
add edx, dword [ebp - 0x22c4]
mov dword [ebp - 0x2db0], edx
mov eax, dword [ebp - 0x2db0]
mov cl, byte [ebp - 0x299]
mov byte [eax], cl
jmp 0x1014f9ad
lea edx, [ebp - 0x2510]
mov dword [ebp - 0x2db4], edx
mov eax, dword [ebp - 0x2db4]
mov dword [ebp - 0x2994], eax
lea ecx, [ebp - 0x4380]
mov dword [ebp - 0x2db8], ecx
movzx edx, byte [ebp - 0x28a6]
push edx
mov ecx, dword [ebp - 0x2db8]
call fcn.1008cde0
mov byte [ebp - 4], 0x47
mov eax, dword [ebp - 0x2994]
mov dword [ebp - 0x22c8], eax
mov ecx, dword [ebp - 0x22c8]
add ecx, 1
mov dword [ebp - 0x2dbc], ecx
mov edx, dword [ebp - 0x22c8]
mov al, byte [edx]
mov byte [ebp - 0xfcd], al
add dword [ebp - 0x22c8], 1
cmp byte [ebp - 0xfcd], 0
jne 0x1014fa94
mov ecx, dword [ebp - 0x22c8]
sub ecx, dword [ebp - 0x2dbc]
mov dword [ebp - 0x2dc0], ecx
mov edx, dword [ebp - 0x2dc0]
mov dword [ebp - 0x2dc4], edx
mov eax, dword [ebp - 0x2dc4]
mov dword [ebp - 0x2dc8], eax
mov ecx, dword [ebp - 0x2dc8]
push ecx
mov edx, dword [ebp - 0x2994]
push edx
lea ecx, [ebp - 0x4380]
call fcn.1008ce30
mov byte [ebp - 4], 0x48
lea eax, [ebp - 0x4380]
push eax
mov ecx, dword [ebp - 0x1b98]
add ecx, 0x70
call fcn.100ad110
lea ecx, [ebp - 0x4398]
push ecx
mov ecx, dword [ebp - 0x1b98]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x1b98]
mov eax, dword [ebp - 0x2dcc]
mov dword [edx + 0x88], eax
mov ecx, dword [ebp - 0x1b98]
mov dword [ecx + 0x8c], 0
mov edx, dword [ebp - 0x1b98]
cmp dword [edx + 0x8c], 0
je 0x1014fb6e
mov eax, dword [ebp - 0x1b98]
mov ecx, dword [eax + 0x88]
mov edx, dword [ebp - 0x1b98]
mov eax, dword [edx + 0x8c]
mov dword [eax], ecx
mov byte [ebp - 4], 0x46
lea ecx, [ebp - 0x4380]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4398]
call fcn.1008b960
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x390
mov dword [ebp - 0xb0], ecx
mov edx, dword [ebp - 0xb0]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xb0]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xb0]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xb0]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xb0]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x2dd0], ecx
lea edx, [ebp - 0xb0]
push edx
mov ecx, dword [ebp - 0x2dd0]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x420
mov dword [ebp - 0x1b9c], eax
mov ecx, dword [0x103bfacc]
mov dword [ebp - 0x2dd4], ecx
mov edx, dword [ebp - 0x2dd4]
mov dword [ebp - 0x2dd8], edx
mov eax, dword [ebp - 0x2dd8]
mov dword [ebp - 0x2e2c], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x1032443c]
mov byte [ebp - 0xfd4], al
movsx ecx, byte [ebp - 0xfd4]
xor ecx, 0xffffff98
mov byte [ebp - 0xfd5], cl
mov dl, byte [ebp - 0xfd5]
mov byte [ebp - 0x262c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x1032443c]
mov byte [ebp - 0xfdc], cl
movsx edx, byte [ebp - 0xfdc]
xor edx, 0xffffff98
mov byte [ebp - 0xfdd], dl
mov al, byte [ebp - 0xfdd]
mov byte [ebp - 0x262b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x1032443c]
mov byte [ebp - 0xfe4], dl
movsx eax, byte [ebp - 0xfe4]
xor eax, 0xffffff98
mov byte [ebp - 0xfe5], al
mov cl, byte [ebp - 0xfe5]
mov byte [ebp - 0x262a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x1032443c]
mov byte [ebp - 0xfec], cl
movsx edx, byte [ebp - 0xfec]
xor edx, 0xffffff98
mov byte [ebp - 0xfed], dl
mov al, byte [ebp - 0xfed]
mov byte [ebp - 0x2629], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + 0x1032443c]
mov byte [ebp - 0xff4], dl
movsx eax, byte [ebp - 0xff4]
xor eax, 0xffffff98
mov byte [ebp - 0xff5], al
mov cl, byte [ebp - 0xff5]
mov byte [ebp - 0x2628], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + 0x1032443c]
mov byte [ebp - 0xffc], cl
movsx edx, byte [ebp - 0xffc]
xor edx, 0xffffff98
mov byte [ebp - 0xffd], dl
mov al, byte [ebp - 0xffd]
mov byte [ebp - 0x2627], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + 0x1032443c]
mov byte [ebp - 0x1004], al
movsx ecx, byte [ebp - 0x1004]
xor ecx, 0xffffff98
mov byte [ebp - 0x1005], cl
mov dl, byte [ebp - 0x1005]
mov byte [ebp - 0x2626], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + 0x1032443c]
mov byte [ebp - 0x100c], dl
movsx eax, byte [ebp - 0x100c]
xor eax, 0xffffff98
mov byte [ebp - 0x100d], al
mov cl, byte [ebp - 0x100d]
mov byte [ebp - 0x2625], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + 0x1032443c]
mov byte [ebp - 0x1014], al
movsx ecx, byte [ebp - 0x1014]
xor ecx, 0xffffff98
mov byte [ebp - 0x1015], cl
mov dl, byte [ebp - 0x1015]
mov byte [ebp - 0x2624], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + 0x1032443c]
mov byte [ebp - 0x101c], dl
movsx eax, byte [ebp - 0x101c]
xor eax, 0xffffff98
mov byte [ebp - 0x101d], al
mov cl, byte [ebp - 0x101d]
mov byte [ebp - 0x2623], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + 0x1032443c]
mov byte [ebp - 0x1024], cl
movsx edx, byte [ebp - 0x1024]
xor edx, 0xffffff98
mov byte [ebp - 0x1025], dl
mov al, byte [ebp - 0x1025]
mov byte [ebp - 0x2622], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + 0x1032443c]
mov byte [ebp - 0x102c], al
movsx ecx, byte [ebp - 0x102c]
xor ecx, 0xffffff98
mov byte [ebp - 0x102d], cl
mov dl, byte [ebp - 0x102d]
mov byte [ebp - 0x2621], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + 0x1032443c]
mov byte [ebp - 0x1034], dl
movsx eax, byte [ebp - 0x1034]
xor eax, 0xffffff98
mov byte [ebp - 0x1035], al
mov cl, byte [ebp - 0x1035]
mov byte [ebp - 0x2620], cl
mov dword [ebp - 0x22cc], 0
jmp 0x1014fec6
mov edx, dword [ebp - 0x22cc]
add edx, 1
mov dword [ebp - 0x22cc], edx
cmp dword [ebp - 0x22cc], 0xd
jae 0x1014ff48
lea eax, [ebp - 0x262c]
mov dword [ebp - 0x2ddc], eax
mov ecx, dword [ebp - 0x2ddc]
add ecx, dword [ebp - 0x22cc]
mov dword [ebp - 0x2de0], ecx
mov edx, dword [ebp - 0x2de0]
mov al, byte [edx]
mov byte [ebp - 0x103c], al
mov cl, byte [ebp - 0x28a7]
mov byte [ebp - 0x29a], cl
movsx edx, byte [ebp - 0x103c]
xor edx, 0xffffff98
mov byte [ebp - 0x29a], dl
lea eax, [ebp - 0x262c]
mov dword [ebp - 0x2de4], eax
mov ecx, dword [ebp - 0x2de4]
add ecx, dword [ebp - 0x22cc]
mov dword [ebp - 0x2de8], ecx
mov edx, dword [ebp - 0x2de8]
mov al, byte [ebp - 0x29a]
mov byte [edx], al
jmp 0x1014feb7
lea ecx, [ebp - 0x262c]
mov dword [ebp - 0x2dec], ecx
mov edx, dword [ebp - 0x2dec]
mov dword [ebp - 0x2998], edx
lea eax, [ebp - 0x43c8]
mov dword [ebp - 0x2df0], eax
movzx ecx, byte [ebp - 0x28a8]
push ecx
mov ecx, dword [ebp - 0x2df0]
call fcn.1008cde0
mov dword [ebp - 4], 0x49
mov edx, dword [ebp - 0x2998]
mov dword [ebp - 0x22d0], edx
mov eax, dword [ebp - 0x22d0]
add eax, 1
mov dword [ebp - 0x2df4], eax
mov ecx, dword [ebp - 0x22d0]
mov dl, byte [ecx]
mov byte [ebp - 0x103d], dl
add dword [ebp - 0x22d0], 1
cmp byte [ebp - 0x103d], 0
jne 0x1014ffa1
mov eax, dword [ebp - 0x22d0]
sub eax, dword [ebp - 0x2df4]
mov dword [ebp - 0x2df8], eax
mov ecx, dword [ebp - 0x2df8]
mov dword [ebp - 0x2dfc], ecx
mov edx, dword [ebp - 0x2dfc]
mov dword [ebp - 0x2e00], edx
mov eax, dword [ebp - 0x2e00]
push eax
mov ecx, dword [ebp - 0x2998]
push ecx
lea ecx, [ebp - 0x43c8]
call fcn.1008ce30
mov dword [ebp - 4], 0x4a
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.weapon_color]
mov byte [ebp - 0x1044], cl
movsx edx, byte [ebp - 0x1044]
xor edx, 0xffffff98
mov byte [ebp - 0x1045], dl
mov al, byte [ebp - 0x1045]
mov byte [ebp - 0x265c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.weapon_color]
mov byte [ebp - 0x104c], dl
movsx eax, byte [ebp - 0x104c]
xor eax, 0xffffff98
mov byte [ebp - 0x104d], al
mov cl, byte [ebp - 0x104d]
mov byte [ebp - 0x265b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.weapon_color]
mov byte [ebp - 0x1054], al
movsx ecx, byte [ebp - 0x1054]
xor ecx, 0xffffff98
mov byte [ebp - 0x1055], cl
mov dl, byte [ebp - 0x1055]
mov byte [ebp - 0x265a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.weapon_color]
mov byte [ebp - 0x105c], dl
movsx eax, byte [ebp - 0x105c]
xor eax, 0xffffff98
mov byte [ebp - 0x105d], al
mov cl, byte [ebp - 0x105d]
mov byte [ebp - 0x2659], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.weapon_color]
mov byte [ebp - 0x1064], al
movsx ecx, byte [ebp - 0x1064]
xor ecx, 0xffffff98
mov byte [ebp - 0x1065], cl
mov dl, byte [ebp - 0x1065]
mov byte [ebp - 0x2658], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.weapon_color]
mov byte [ebp - 0x106c], dl
movsx eax, byte [ebp - 0x106c]
xor eax, 0xffffff98
mov byte [ebp - 0x106d], al
mov cl, byte [ebp - 0x106d]
mov byte [ebp - 0x2657], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.weapon_color]
mov byte [ebp - 0x1074], cl
movsx edx, byte [ebp - 0x1074]
xor edx, 0xffffff98
mov byte [ebp - 0x1075], dl
mov al, byte [ebp - 0x1075]
mov byte [ebp - 0x2656], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.weapon_color]
mov byte [ebp - 0x107c], al
movsx ecx, byte [ebp - 0x107c]
xor ecx, 0xffffff98
mov byte [ebp - 0x107d], cl
mov dl, byte [ebp - 0x107d]
mov byte [ebp - 0x2655], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.weapon_color]
mov byte [ebp - 0x1084], cl
movsx edx, byte [ebp - 0x1084]
xor edx, 0xffffff98
mov byte [ebp - 0x1085], dl
mov al, byte [ebp - 0x1085]
mov byte [ebp - 0x2654], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.weapon_color]
mov byte [ebp - 0x108c], al
movsx ecx, byte [ebp - 0x108c]
xor ecx, 0xffffff98
mov byte [ebp - 0x108d], cl
mov dl, byte [ebp - 0x108d]
mov byte [ebp - 0x2653], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.weapon_color]
mov byte [ebp - 0x1094], dl
movsx eax, byte [ebp - 0x1094]
xor eax, 0xffffff98
mov byte [ebp - 0x1095], al
mov cl, byte [ebp - 0x1095]
mov byte [ebp - 0x2652], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.weapon_color]
mov byte [ebp - 0x109c], cl
movsx edx, byte [ebp - 0x109c]
xor edx, 0xffffff98
mov byte [ebp - 0x109d], dl
mov al, byte [ebp - 0x109d]
mov byte [ebp - 0x2651], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.weapon_color]
mov byte [ebp - 0x10a4], al
movsx ecx, byte [ebp - 0x10a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x10a5], cl
mov dl, byte [ebp - 0x10a5]
mov byte [ebp - 0x2650], dl
mov dword [ebp - 0x22d4], 0
jmp 0x10150293
mov eax, dword [ebp - 0x22d4]
add eax, 1
mov dword [ebp - 0x22d4], eax
cmp dword [ebp - 0x22d4], 0xd
jae 0x10150315
lea ecx, [ebp - 0x265c]
mov dword [ebp - 0x2e04], ecx
mov edx, dword [ebp - 0x2e04]
add edx, dword [ebp - 0x22d4]
mov dword [ebp - 0x2e08], edx
mov eax, dword [ebp - 0x2e08]
mov cl, byte [eax]
mov byte [ebp - 0x10ac], cl
mov dl, byte [ebp - 0x28a9]
mov byte [ebp - 0x29b], dl
movsx eax, byte [ebp - 0x10ac]
xor eax, 0xffffff98
mov byte [ebp - 0x29b], al
lea ecx, [ebp - 0x265c]
mov dword [ebp - 0x2e0c], ecx
mov edx, dword [ebp - 0x2e0c]
add edx, dword [ebp - 0x22d4]
mov dword [ebp - 0x2e10], edx
mov eax, dword [ebp - 0x2e10]
mov cl, byte [ebp - 0x29b]
mov byte [eax], cl
jmp 0x10150284
lea edx, [ebp - 0x265c]
mov dword [ebp - 0x2e14], edx
mov eax, dword [ebp - 0x2e14]
mov dword [ebp - 0x299c], eax
lea ecx, [ebp - 0x43b0]
mov dword [ebp - 0x2e18], ecx
movzx edx, byte [ebp - 0x28aa]
push edx
mov ecx, dword [ebp - 0x2e18]
call fcn.1008cde0
mov byte [ebp - 4], 0x4b
mov eax, dword [ebp - 0x299c]
mov dword [ebp - 0x22d8], eax
mov ecx, dword [ebp - 0x22d8]
add ecx, 1
mov dword [ebp - 0x2e1c], ecx
mov edx, dword [ebp - 0x22d8]
mov al, byte [edx]
mov byte [ebp - 0x10ad], al
add dword [ebp - 0x22d8], 1
cmp byte [ebp - 0x10ad], 0
jne 0x1015036b
mov ecx, dword [ebp - 0x22d8]
sub ecx, dword [ebp - 0x2e1c]
mov dword [ebp - 0x2e20], ecx
mov edx, dword [ebp - 0x2e20]
mov dword [ebp - 0x2e24], edx
mov eax, dword [ebp - 0x2e24]
mov dword [ebp - 0x2e28], eax
mov ecx, dword [ebp - 0x2e28]
push ecx
mov edx, dword [ebp - 0x299c]
push edx
lea ecx, [ebp - 0x43b0]
call fcn.1008ce30
mov byte [ebp - 4], 0x4c
lea eax, [ebp - 0x43b0]
push eax
mov ecx, dword [ebp - 0x1b9c]
add ecx, 0x70
call fcn.100ad110
lea ecx, [ebp - 0x43c8]
push ecx
mov ecx, dword [ebp - 0x1b9c]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x1b9c]
mov eax, dword [ebp - 0x2e2c]
mov dword [edx + 0x88], eax
mov ecx, dword [ebp - 0x1b9c]
mov dword [ecx + 0x8c], 0
mov edx, dword [ebp - 0x1b9c]
cmp dword [edx + 0x8c], 0
je 0x10150445
mov eax, dword [ebp - 0x1b9c]
mov ecx, dword [eax + 0x88]
mov edx, dword [ebp - 0x1b9c]
mov eax, dword [edx + 0x8c]
mov dword [eax], ecx
mov byte [ebp - 4], 0x4a
lea ecx, [ebp - 0x43b0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x43c8]
call fcn.1008b960
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x420
mov dword [ebp - 0xb4], ecx
mov edx, dword [ebp - 0xb4]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xb4]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xb4]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xb4]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xb4]
mov edx, dword [ebp - 0x1b8]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x1b8]
add ecx, 0x18
mov dword [ebp - 0x2e30], ecx
lea edx, [ebp - 0xb4]
push edx
mov ecx, dword [ebp - 0x2e30]
call fcn.1008c950
mov eax, dword [ebp - 0x1b8]
add eax, 0x6a0
mov dword [ebp - 0x1ba0], eax
mov ecx, dword [0x103bfb2c]
mov dword [ebp - 0x2e34], ecx
mov edx, dword [ebp - 0x2e34]
mov dword [ebp - 0x2e38], edx
mov eax, dword [ebp - 0x2e38]
mov dword [ebp - 0x2e8c], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x10324424]
mov byte [ebp - 0x10b4], al
movsx ecx, byte [ebp - 0x10b4]
xor ecx, 0xffffff98
mov byte [ebp - 0x10b5], cl
mov dl, byte [ebp - 0x10b5]
mov byte [ebp - 0x2534], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x10324424]
mov byte [ebp - 0x10bc], cl
movsx edx, byte [ebp - 0x10bc]
xor edx, 0xffffff98
mov byte [ebp - 0x10bd], dl
mov al, byte [ebp - 0x10bd]
mov byte [ebp - 0x2533], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x10324424]
mov byte [ebp - 0x10c4], dl
movsx eax, byte [ebp - 0x10c4]
xor eax, 0xffffff98
mov byte [ebp - 0x10c5], al
mov cl, byte [ebp - 0x10c5]
mov byte [ebp - 0x2532], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x10324424]
mov byte [ebp - 0x10cc], cl
movsx edx, byte [ebp - 0x10cc]
xor edx, 0xffffff98
mov byte [ebp - 0x10cd], dl
mov al, byte [ebp - 0x10cd]
mov byte [ebp - 0x2531], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + 0x10324424]
mov byte [ebp - 0x10d4], dl
movsx eax, byte [ebp - 0x10d4]
xor eax, 0xffffff98
mov byte [ebp - 0x10d5], al
mov cl, byte [ebp - 0x10d5]
mov byte [ebp - 0x2530], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + 0x10324424]
mov byte [ebp - 0x10dc], cl
movsx edx, byte [ebp - 0x10dc]
xor edx, 0xffffff98
mov byte [ebp - 0x10dd], dl
mov al, byte [ebp - 0x10dd]
mov byte [ebp - 0x252f], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + 0x10324424]
mov byte [ebp - 0x10e4], al
movsx ecx, byte [ebp - 0x10e4]
xor ecx, 0xffffff98
mov byte [ebp - 0x10e5], cl
mov dl, byte [ebp - 0x10e5]
mov byte [ebp - 0x252e], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + 0x10324424]
mov byte [ebp - 0x10ec], dl
movsx eax, byte [ebp - 0x10ec]
xor eax, 0xffffff98
mov byte [ebp - 0x10ed], al
mov cl, byte [ebp - 0x10ed]
mov byte [ebp - 0x252d], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + 0x10324424]
mov byte [ebp - 0x10f4], al
movsx ecx, byte [ebp - 0x10f4]
xor ecx, 0xffffff98
mov byte [ebp - 0x10f5], cl
mov dl, byte [ebp - 0x10f5]
mov byte [ebp - 0x252c], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + 0x10324424]
mov byte [ebp - 0x10fc], dl
movsx eax, byte [ebp - 0x10fc]
xor eax, 0xffffff98
mov byte [ebp - 0x10fd], al
mov cl, byte [ebp - 0x10fd]
mov byte [ebp - 0x252b], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + 0x10324424]
mov byte [ebp - 0x1104], cl
movsx edx, byte [ebp - 0x1104]
xor edx, 0xffffff98
mov byte [ebp - 0x1105], dl
mov al, byte [ebp - 0x1105]
mov byte [ebp - 0x252a], al
mov dword [ebp - 0x22dc], 0
jmp 0x1015073d