Function at 0x1012aee0
Capabilities:
Authenticate hmac
Encrypt data using speck
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 0x10315050
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x4a60
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 - 0x200], ecx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x148c], dl
movsx eax, byte [ebp - 0x148c]
xor eax, 0xffffff98
mov byte [ebp - 0x1725], al
mov cl, byte [ebp - 0x1725]
mov byte [ebp - 0x1fc8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x172c], al
movsx ecx, byte [ebp - 0x172c]
xor ecx, 0xffffff98
mov byte [ebp - 0x172d], cl
mov dl, byte [ebp - 0x172d]
mov byte [ebp - 0x1fc7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x1734], cl
movsx edx, byte [ebp - 0x1734]
xor edx, 0xffffff98
mov byte [ebp - 0x1735], dl
mov al, byte [ebp - 0x1735]
mov byte [ebp - 0x1fc6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x173c], al
movsx ecx, byte [ebp - 0x173c]
xor ecx, 0xffffff98
mov byte [ebp - 0x173d], cl
mov dl, byte [ebp - 0x173d]
mov byte [ebp - 0x1fc5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x1744], cl
movsx edx, byte [ebp - 0x1744]
xor edx, 0xffffff98
mov byte [ebp - 0x1745], dl
mov al, byte [ebp - 0x1745]
mov byte [ebp - 0x1fc4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x174c], al
movsx ecx, byte [ebp - 0x174c]
xor ecx, 0xffffff98
mov byte [ebp - 0x174d], cl
mov dl, byte [ebp - 0x174d]
mov byte [ebp - 0x1fc3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x1754], dl
movsx eax, byte [ebp - 0x1754]
xor eax, 0xffffff98
mov byte [ebp - 0x1755], al
mov cl, byte [ebp - 0x1755]
mov byte [ebp - 0x1fc2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x175c], cl
movsx edx, byte [ebp - 0x175c]
xor edx, 0xffffff98
mov byte [ebp - 0x175d], dl
mov al, byte [ebp - 0x175d]
mov byte [ebp - 0x1fc1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x1764], dl
movsx eax, byte [ebp - 0x1764]
xor eax, 0xffffff98
mov byte [ebp - 0x1765], al
mov cl, byte [ebp - 0x1765]
mov byte [ebp - 0x1fc0], cl
mov dword [ebp - 0x1e04], 0
jmp 0x1012b0f3
mov edx, dword [ebp - 0x1e04]
add edx, 1
mov dword [ebp - 0x1e04], edx
cmp dword [ebp - 0x1e04], 9
jae 0x1012b175
lea eax, [ebp - 0x1fc8]
mov dword [ebp - 0x2df4], eax
mov ecx, dword [ebp - 0x2df4]
add ecx, dword [ebp - 0x1e04]
mov dword [ebp - 0x2e68], ecx
mov edx, dword [ebp - 0x2e68]
mov al, byte [edx]
mov byte [ebp - 0x176c], al
mov cl, byte [ebp - 0x218d]
mov byte [ebp - 0x2a7], cl
movsx edx, byte [ebp - 0x176c]
xor edx, 0xffffff98
mov byte [ebp - 0x2a7], dl
lea eax, [ebp - 0x1fc8]
mov dword [ebp - 0x2e74], eax
mov ecx, dword [ebp - 0x2e74]
add ecx, dword [ebp - 0x1e04]
mov dword [ebp - 0x2ee8], ecx
mov edx, dword [ebp - 0x2ee8]
mov al, byte [ebp - 0x2a7]
mov byte [edx], al
jmp 0x1012b0e4
lea ecx, [ebp - 0x1fc8]
mov dword [ebp - 0x2ef4], ecx
mov edx, dword [ebp - 0x2ef4]
mov dword [ebp - 0x23a0], edx
lea eax, [ebp - 0x39c8]
mov dword [ebp - 0x2f68], eax
movzx ecx, byte [ebp - 0x218e]
push ecx
mov ecx, dword [ebp - 0x2f68]
call fcn.1008cde0
mov dword [ebp - 4], 0
mov edx, dword [ebp - 0x23a0]
mov dword [ebp - 0x1e08], edx
mov eax, dword [ebp - 0x1e08]
add eax, 1
mov dword [ebp - 0x2f74], eax
mov ecx, dword [ebp - 0x1e08]
mov dl, byte [ecx]
mov byte [ebp - 0x176d], dl
add dword [ebp - 0x1e08], 1
cmp byte [ebp - 0x176d], 0
jne 0x1012b1ce
mov eax, dword [ebp - 0x1e08]
sub eax, dword [ebp - 0x2f74]
mov dword [ebp - 0x2fe8], eax
mov ecx, dword [ebp - 0x2fe8]
mov dword [ebp - 0x2ff4], ecx
mov edx, dword [ebp - 0x2ff4]
mov dword [ebp - 0x3038], edx
mov eax, dword [ebp - 0x3038]
push eax
mov ecx, dword [ebp - 0x23a0]
push ecx
lea ecx, [ebp - 0x39c8]
call fcn.1008ce30
mov dword [ebp - 4], 1
lea edx, [ebp - 0x39c8]
push edx
mov ecx, dword [ebp - 0x200]
call fcn.100ad110
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x39c8]
call fcn.1008b960
mov eax, dword [ebp - 0x200]
add eax, 0x30
mov dword [ebp - 0x1e1c], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.enable]
mov byte [ebp - 0x1774], al
movsx ecx, byte [ebp - 0x1774]
xor ecx, 0xffffff98
mov byte [ebp - 0x1775], cl
mov dl, byte [ebp - 0x1775]
mov byte [ebp - 0x1f54], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x177c], cl
movsx edx, byte [ebp - 0x177c]
xor edx, 0xffffff98
mov byte [ebp - 0x177d], dl
mov al, byte [ebp - 0x177d]
mov byte [ebp - 0x1f53], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x1784], dl
movsx eax, byte [ebp - 0x1784]
xor eax, 0xffffff98
mov byte [ebp - 0x1785], al
mov cl, byte [ebp - 0x1785]
mov byte [ebp - 0x1f52], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x178c], cl
movsx edx, byte [ebp - 0x178c]
xor edx, 0xffffff98
mov byte [ebp - 0x178d], dl
mov al, byte [ebp - 0x178d]
mov byte [ebp - 0x1f51], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x1794], dl
movsx eax, byte [ebp - 0x1794]
xor eax, 0xffffff98
mov byte [ebp - 0x1795], al
mov cl, byte [ebp - 0x1795]
mov byte [ebp - 0x1f50], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x179c], cl
movsx edx, byte [ebp - 0x179c]
xor edx, 0xffffff98
mov byte [ebp - 0x179d], dl
mov al, byte [ebp - 0x179d]
mov byte [ebp - 0x1f4f], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.enable]
mov byte [ebp - 0x17a4], al
movsx ecx, byte [ebp - 0x17a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x17a5], cl
mov dl, byte [ebp - 0x17a5]
mov byte [ebp - 0x1f4e], dl
mov dword [ebp - 0x1e0c], 0
jmp 0x1012b3d3
mov eax, dword [ebp - 0x1e0c]
add eax, 1
mov dword [ebp - 0x1e0c], eax
cmp dword [ebp - 0x1e0c], 7
jae 0x1012b455
lea ecx, [ebp - 0x1f54]
mov dword [ebp - 0x3044], ecx
mov edx, dword [ebp - 0x3044]
add edx, dword [ebp - 0x1e0c]
mov dword [ebp - 0x3060], edx
mov eax, dword [ebp - 0x3060]
mov cl, byte [eax]
mov byte [ebp - 0x17ac], cl
mov dl, byte [ebp - 0x218f]
mov byte [ebp - 0x2a8], dl
movsx eax, byte [ebp - 0x17ac]
xor eax, 0xffffff98
mov byte [ebp - 0x2a8], al
lea ecx, [ebp - 0x1f54]
mov dword [ebp - 0x306c], ecx
mov edx, dword [ebp - 0x306c]
add edx, dword [ebp - 0x1e0c]
mov dword [ebp - 0x30f8], edx
mov eax, dword [ebp - 0x30f8]
mov cl, byte [ebp - 0x2a8]
mov byte [eax], cl
jmp 0x1012b3c4
lea edx, [ebp - 0x1f54]
mov dword [ebp - 0x3120], edx
mov eax, dword [ebp - 0x3120]
mov dword [ebp - 0x23a4], eax
lea ecx, [ebp - 0x39f8]
mov dword [ebp - 0x312c], ecx
movzx edx, byte [ebp - 0x2190]
push edx
mov ecx, dword [ebp - 0x312c]
call fcn.1008cde0
mov dword [ebp - 4], 2
mov eax, dword [ebp - 0x23a4]
mov dword [ebp - 0x1e10], eax
mov ecx, dword [ebp - 0x1e10]
add ecx, 1
mov dword [ebp - 0x3154], ecx
mov edx, dword [ebp - 0x1e10]
mov al, byte [edx]
mov byte [ebp - 0x17ad], al
add dword [ebp - 0x1e10], 1
cmp byte [ebp - 0x17ad], 0
jne 0x1012b4ae
mov ecx, dword [ebp - 0x1e10]
sub ecx, dword [ebp - 0x3154]
mov dword [ebp - 0x3160], ecx
mov edx, dword [ebp - 0x3160]
mov dword [ebp - 0x3188], edx
mov eax, dword [ebp - 0x3188]
mov dword [ebp - 0x3194], eax
mov ecx, dword [ebp - 0x3194]
push ecx
mov edx, dword [ebp - 0x23a4]
push edx
lea ecx, [ebp - 0x39f8]
call fcn.1008ce30
mov dword [ebp - 4], 3
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x17b4], dl
movsx eax, byte [ebp - 0x17b4]
xor eax, 0xffffff98
mov byte [ebp - 0x17b5], al
mov cl, byte [ebp - 0x17b5]
mov byte [ebp - 0x1f4c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.enable]
mov byte [ebp - 0x17bc], al
movsx ecx, byte [ebp - 0x17bc]
xor ecx, 0xffffff98
mov byte [ebp - 0x17be], cl
mov dl, byte [ebp - 0x17be]
mov byte [ebp - 0x1f4b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x17c4], cl
movsx edx, byte [ebp - 0x17c4]
xor edx, 0xffffff98
mov byte [ebp - 0x17c5], dl
mov al, byte [ebp - 0x17c5]
mov byte [ebp - 0x1f4a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.enable]
mov byte [ebp - 0x17cc], al
movsx ecx, byte [ebp - 0x17cc]
xor ecx, 0xffffff98
mov byte [ebp - 0x17cd], cl
mov dl, byte [ebp - 0x17cd]
mov byte [ebp - 0x1f49], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x17d4], cl
movsx edx, byte [ebp - 0x17d4]
xor edx, 0xffffff98
mov byte [ebp - 0x17d5], dl
mov al, byte [ebp - 0x17d5]
mov byte [ebp - 0x1f48], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.enable]
mov byte [ebp - 0x17dc], al
movsx ecx, byte [ebp - 0x17dc]
xor ecx, 0xffffff98
mov byte [ebp - 0x17dd], cl
mov dl, byte [ebp - 0x17dd]
mov byte [ebp - 0x1f47], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x17e4], dl
movsx eax, byte [ebp - 0x17e4]
xor eax, 0xffffff98
mov byte [ebp - 0x17e5], al
mov cl, byte [ebp - 0x17e5]
mov byte [ebp - 0x1f46], cl
mov dword [ebp - 0x1e14], 0
jmp 0x1012b680
mov edx, dword [ebp - 0x1e14]
add edx, 1
mov dword [ebp - 0x1e14], edx
cmp dword [ebp - 0x1e14], 7
jae 0x1012b702
lea eax, [ebp - 0x1f4c]
mov dword [ebp - 0x31bc], eax
mov ecx, dword [ebp - 0x31bc]
add ecx, dword [ebp - 0x1e14]
mov dword [ebp - 0x31c8], ecx
mov edx, dword [ebp - 0x31c8]
mov al, byte [edx]
mov byte [ebp - 0x17ec], al
mov cl, byte [ebp - 0x2191]
mov byte [ebp - 0x2a9], cl
movsx edx, byte [ebp - 0x17ec]
xor edx, 0xffffff98
mov byte [ebp - 0x2a9], dl
lea eax, [ebp - 0x1f4c]
mov dword [ebp - 0x31f0], eax
mov ecx, dword [ebp - 0x31f0]
add ecx, dword [ebp - 0x1e14]
mov dword [ebp - 0x31fc], ecx
mov edx, dword [ebp - 0x31fc]
mov al, byte [ebp - 0x2a9]
mov byte [edx], al
jmp 0x1012b671
lea ecx, [ebp - 0x1f4c]
mov dword [ebp - 0x3218], ecx
mov edx, dword [ebp - 0x3218]
mov dword [ebp - 0x23a8], edx
lea eax, [ebp - 0x39e0]
mov dword [ebp - 0x3224], eax
movzx ecx, byte [ebp - 0x2192]
push ecx
mov ecx, dword [ebp - 0x3224]
call fcn.1008cde0
mov byte [ebp - 4], 4
mov edx, dword [ebp - 0x23a8]
mov dword [ebp - 0x1e18], edx
mov eax, dword [ebp - 0x1e18]
add eax, 1
mov dword [ebp - 0x328c], eax
mov ecx, dword [ebp - 0x1e18]
mov dl, byte [ecx]
mov byte [ebp - 0x17ed], dl
add dword [ebp - 0x1e18], 1
cmp byte [ebp - 0x17ed], 0
jne 0x1012b758
mov eax, dword [ebp - 0x1e18]
sub eax, dword [ebp - 0x328c]
mov dword [ebp - 0x3298], eax
mov ecx, dword [ebp - 0x3298]
mov dword [ebp - 0x3304], ecx
mov edx, dword [ebp - 0x3304]
mov dword [ebp - 0x3338], edx
mov eax, dword [ebp - 0x3338]
push eax
mov ecx, dword [ebp - 0x23a8]
push ecx
lea ecx, [ebp - 0x39e0]
call fcn.1008ce30
mov byte [ebp - 4], 5
lea edx, [ebp - 0x39f8]
push edx
mov ecx, dword [ebp - 0x1e1c]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x1e1c]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x1e1c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1012b7ff
lea eax, [ebp - 0x39e0]
push eax
mov ecx, dword [ebp - 0x1e1c]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x1e1c]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 3
lea ecx, [ebp - 0x39e0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x39f8]
call fcn.1008b960
mov edx, dword [ebp - 0x200]
add edx, 0x30
mov dword [ebp - 0x38], edx
mov eax, dword [ebp - 0x38]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x38]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x38]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x38]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x38]
mov eax, dword [ebp - 0x200]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x200]
add edx, 0x18
mov dword [ebp - 0x3360], edx
lea eax, [ebp - 0x38]
push eax
mov ecx, dword [ebp - 0x3360]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0xb8
mov dword [ebp - 0x1e30], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.fakeyaw]
mov byte [ebp - 0x17f4], cl
movsx edx, byte [ebp - 0x17f4]
xor edx, 0xffffff98
mov byte [ebp - 0x17f5], dl
mov al, byte [ebp - 0x17f5]
mov byte [ebp - 0x1f8c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.fakeyaw]
mov byte [ebp - 0x17fc], dl
movsx eax, byte [ebp - 0x17fc]
xor eax, 0xffffff98
mov byte [ebp - 0x17fd], al
mov cl, byte [ebp - 0x17fd]
mov byte [ebp - 0x1f8b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.fakeyaw]
mov byte [ebp - 0x1804], al
movsx ecx, byte [ebp - 0x1804]
xor ecx, 0xffffff98
mov byte [ebp - 0x1805], cl
mov dl, byte [ebp - 0x1805]
mov byte [ebp - 0x1f8a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.fakeyaw]
mov byte [ebp - 0x180c], dl
movsx eax, byte [ebp - 0x180c]
xor eax, 0xffffff98
mov byte [ebp - 0x180d], al
mov cl, byte [ebp - 0x180d]
mov byte [ebp - 0x1f89], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.fakeyaw]
mov byte [ebp - 0x1814], al
movsx ecx, byte [ebp - 0x1814]
xor ecx, 0xffffff98
mov byte [ebp - 0x1815], cl
mov dl, byte [ebp - 0x1815]
mov byte [ebp - 0x1f88], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.fakeyaw]
mov byte [ebp - 0x181c], dl
movsx eax, byte [ebp - 0x181c]
xor eax, 0xffffff98
mov byte [ebp - 0x181d], al
mov cl, byte [ebp - 0x181d]
mov byte [ebp - 0x1f87], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.fakeyaw]
mov byte [ebp - 0x1824], cl
movsx edx, byte [ebp - 0x1824]
xor edx, 0xffffff98
mov byte [ebp - 0x1825], dl
mov al, byte [ebp - 0x1825]
mov byte [ebp - 0x1f86], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.fakeyaw]
mov byte [ebp - 0x182c], al
movsx ecx, byte [ebp - 0x182c]
xor ecx, 0xffffff98
mov byte [ebp - 0x182d], cl
mov dl, byte [ebp - 0x182d]
mov byte [ebp - 0x1f85], dl
mov dword [ebp - 0x1e20], 0
jmp 0x1012ba36
mov eax, dword [ebp - 0x1e20]
add eax, 1
mov dword [ebp - 0x1e20], eax
cmp dword [ebp - 0x1e20], 8
jae 0x1012bab8
lea ecx, [ebp - 0x1f8c]
mov dword [ebp - 0x33a4], ecx
mov edx, dword [ebp - 0x33a4]
add edx, dword [ebp - 0x1e20]
mov dword [ebp - 0x33cc], edx
mov eax, dword [ebp - 0x33cc]
mov cl, byte [eax]
mov byte [ebp - 0x1834], cl
mov dl, byte [ebp - 0x2193]
mov byte [ebp - 0x2aa], dl
movsx eax, byte [ebp - 0x1834]
xor eax, 0xffffff98
mov byte [ebp - 0x2aa], al
lea ecx, [ebp - 0x1f8c]
mov dword [ebp - 0x33f4], ecx
mov edx, dword [ebp - 0x33f4]
add edx, dword [ebp - 0x1e20]
mov dword [ebp - 0x3420], edx
mov eax, dword [ebp - 0x3420]
mov cl, byte [ebp - 0x2aa]
mov byte [eax], cl
jmp 0x1012ba27
lea edx, [ebp - 0x1f8c]
mov dword [ebp - 0x344c], edx
mov eax, dword [ebp - 0x344c]
mov dword [ebp - 0x23ac], eax
lea ecx, [ebp - 0x3a28]
mov dword [ebp - 0x3478], ecx
movzx edx, byte [ebp - 0x2194]
push edx
mov ecx, dword [ebp - 0x3478]
call fcn.1008cde0
mov dword [ebp - 4], 6
mov eax, dword [ebp - 0x23ac]
mov dword [ebp - 0x1e24], eax
mov ecx, dword [ebp - 0x1e24]
add ecx, 1
mov dword [ebp - 0x34a4], ecx
mov edx, dword [ebp - 0x1e24]
mov al, byte [edx]
mov byte [ebp - 0x1835], al
add dword [ebp - 0x1e24], 1
cmp byte [ebp - 0x1835], 0
jne 0x1012bb11
mov ecx, dword [ebp - 0x1e24]
sub ecx, dword [ebp - 0x34a4]
mov dword [ebp - 0x3530], ecx
mov edx, dword [ebp - 0x3530]
mov dword [ebp - 0x3558], edx
mov eax, dword [ebp - 0x3558]
mov dword [ebp - 0x35a8], eax
mov ecx, dword [ebp - 0x35a8]
push ecx
mov edx, dword [ebp - 0x23ac]
push edx
lea ecx, [ebp - 0x3a28]
call fcn.1008ce30
mov dword [ebp - 4], 7
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.fake_yaw]
mov byte [ebp - 0x183c], dl
movsx eax, byte [ebp - 0x183c]
xor eax, 0xffffff98
mov byte [ebp - 0x183d], al
mov cl, byte [ebp - 0x183d]
mov byte [ebp - 0x1fbc], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.fake_yaw]
mov byte [ebp - 0x1844], al
movsx ecx, byte [ebp - 0x1844]
xor ecx, 0xffffff98
mov byte [ebp - 0x1845], cl
mov dl, byte [ebp - 0x1845]
mov byte [ebp - 0x1fbb], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.fake_yaw]
mov byte [ebp - 0x184c], cl
movsx edx, byte [ebp - 0x184c]
xor edx, 0xffffff98
mov byte [ebp - 0x184d], dl
mov al, byte [ebp - 0x184d]
mov byte [ebp - 0x1fba], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.fake_yaw]
mov byte [ebp - 0x1854], al
movsx ecx, byte [ebp - 0x1854]
xor ecx, 0xffffff98
mov byte [ebp - 0x1855], cl
mov dl, byte [ebp - 0x1855]
mov byte [ebp - 0x1fb9], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.fake_yaw]
mov byte [ebp - 0x185c], cl
movsx edx, byte [ebp - 0x185c]
xor edx, 0xffffff98
mov byte [ebp - 0x185d], dl
mov al, byte [ebp - 0x185d]
mov byte [ebp - 0x1fb8], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.fake_yaw]
mov byte [ebp - 0x1864], al
movsx ecx, byte [ebp - 0x1864]
xor ecx, 0xffffff98
mov byte [ebp - 0x1865], cl
mov dl, byte [ebp - 0x1865]
mov byte [ebp - 0x1fb7], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.fake_yaw]
mov byte [ebp - 0x186c], dl
movsx eax, byte [ebp - 0x186c]
xor eax, 0xffffff98
mov byte [ebp - 0x186d], al
mov cl, byte [ebp - 0x186d]
mov byte [ebp - 0x1fb6], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.fake_yaw]
mov byte [ebp - 0x1874], cl
movsx edx, byte [ebp - 0x1874]
xor edx, 0xffffff98
mov byte [ebp - 0x1875], dl
mov al, byte [ebp - 0x1875]
mov byte [ebp - 0x1fb5], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.fake_yaw]
mov byte [ebp - 0x187c], dl
movsx eax, byte [ebp - 0x187c]
xor eax, 0xffffff98
mov byte [ebp - 0x187d], al
mov cl, byte [ebp - 0x187d]
mov byte [ebp - 0x1fb4], cl
mov dword [ebp - 0x1e28], 0
jmp 0x1012bd43
mov edx, dword [ebp - 0x1e28]
add edx, 1
mov dword [ebp - 0x1e28], edx
cmp dword [ebp - 0x1e28], 9
jae 0x1012bdc5
lea eax, [ebp - 0x1fbc]
mov dword [ebp - 0x35b4], eax
mov ecx, dword [ebp - 0x35b4]
add ecx, dword [ebp - 0x1e28]
mov dword [ebp - 0x35dc], ecx
mov edx, dword [ebp - 0x35dc]
mov al, byte [edx]
mov byte [ebp - 0x1884], al
mov cl, byte [ebp - 0x2195]
mov byte [ebp - 0x2ab], cl
movsx edx, byte [ebp - 0x1884]
xor edx, 0xffffff98
mov byte [ebp - 0x2ab], dl
lea eax, [ebp - 0x1fbc]
mov dword [ebp - 0x35e8], eax
mov ecx, dword [ebp - 0x35e8]
add ecx, dword [ebp - 0x1e28]
mov dword [ebp - 0x3610], ecx
mov edx, dword [ebp - 0x3610]
mov al, byte [ebp - 0x2ab]
mov byte [edx], al
jmp 0x1012bd34
lea ecx, [ebp - 0x1fbc]
mov dword [ebp - 0x3638], ecx
mov edx, dword [ebp - 0x3638]
mov dword [ebp - 0x23b0], edx
lea eax, [ebp - 0x3a10]
mov dword [ebp - 0x3660], eax
movzx ecx, byte [ebp - 0x2196]
push ecx
mov ecx, dword [ebp - 0x3660]
call fcn.1008cde0
mov byte [ebp - 4], 8
mov edx, dword [ebp - 0x23b0]
mov dword [ebp - 0x1e2c], edx
mov eax, dword [ebp - 0x1e2c]
add eax, 1
mov dword [ebp - 0x3694], eax
mov ecx, dword [ebp - 0x1e2c]
mov dl, byte [ecx]
mov byte [ebp - 0x1885], dl
add dword [ebp - 0x1e2c], 1
cmp byte [ebp - 0x1885], 0
jne 0x1012be1b
mov eax, dword [ebp - 0x1e2c]
sub eax, dword [ebp - 0x3694]
mov dword [ebp - 0x36bc], eax
mov ecx, dword [ebp - 0x36bc]
mov dword [ebp - 0x36c8], ecx
mov edx, dword [ebp - 0x36c8]
mov dword [ebp - 0x36cc], edx
mov eax, dword [ebp - 0x36cc]
push eax
mov ecx, dword [ebp - 0x23b0]
push ecx
lea ecx, [ebp - 0x3a10]
call fcn.1008ce30
mov byte [ebp - 4], 9
lea edx, [ebp - 0x3a28]
push edx
mov ecx, dword [ebp - 0x1e30]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x1e30]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x1e30]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1012bec2
lea eax, [ebp - 0x3a10]
push eax
mov ecx, dword [ebp - 0x1e30]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x1e30]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 7
lea ecx, [ebp - 0x3a10]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3a28]
call fcn.1008b960
mov edx, dword [ebp - 0x200]
add edx, 0xb8
mov dword [ebp - 0x34], edx
mov eax, dword [ebp - 0x34]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x34]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x34]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x34]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x34]
mov eax, dword [ebp - 0x200]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x200]
add edx, 0x18
mov dword [ebp - 0x36d0], edx
lea eax, [ebp - 0x34]
push eax
mov ecx, dword [ebp - 0x36d0]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0x140
mov dword [ebp - 0x1e44], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.edge]
mov byte [ebp - 0x188c], cl
movsx edx, byte [ebp - 0x188c]
xor edx, 0xffffff98
mov byte [ebp - 0x188d], dl
mov al, byte [ebp - 0x188d]
mov byte [ebp - 0x1b00], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x1894], dl
movsx eax, byte [ebp - 0x1894]
xor eax, 0xffffff98
mov byte [ebp - 0x1895], al
mov cl, byte [ebp - 0x1895]
mov byte [ebp - 0x1aff], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.edge]
mov byte [ebp - 0x189c], al
movsx ecx, byte [ebp - 0x189c]
xor ecx, 0xffffff98
mov byte [ebp - 0x189d], cl
mov dl, byte [ebp - 0x189d]
mov byte [ebp - 0x1afe], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x18a4], dl
movsx eax, byte [ebp - 0x18a4]
xor eax, 0xffffff98
mov byte [ebp - 0x18a5], al
mov cl, byte [ebp - 0x18a5]
mov byte [ebp - 0x1afd], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.edge]
mov byte [ebp - 0x18ac], al
movsx ecx, byte [ebp - 0x18ac]
xor ecx, 0xffffff98
mov byte [ebp - 0x18ad], cl
mov dl, byte [ebp - 0x18ad]
mov byte [ebp - 0x1afc], dl
mov dword [ebp - 0x1e34], 0
jmp 0x1012c06c
mov eax, dword [ebp - 0x1e34]
add eax, 1
mov dword [ebp - 0x1e34], eax
cmp dword [ebp - 0x1e34], 5
jae 0x1012c0ee
lea ecx, [ebp - 0x1b00]
mov dword [ebp - 0x36d4], ecx
mov edx, dword [ebp - 0x36d4]
add edx, dword [ebp - 0x1e34]
mov dword [ebp - 0x36d8], edx
mov eax, dword [ebp - 0x36d8]
mov cl, byte [eax]
mov byte [ebp - 0x18b4], cl
mov dl, byte [ebp - 0x2197]
mov byte [ebp - 0x2ac], dl
movsx eax, byte [ebp - 0x18b4]
xor eax, 0xffffff98
mov byte [ebp - 0x2ac], al
lea ecx, [ebp - 0x1b00]
mov dword [ebp - 0x36dc], ecx
mov edx, dword [ebp - 0x36dc]
add edx, dword [ebp - 0x1e34]
mov dword [ebp - 0x36e0], edx
mov eax, dword [ebp - 0x36e0]
mov cl, byte [ebp - 0x2ac]
mov byte [eax], cl
jmp 0x1012c05d
lea edx, [ebp - 0x1b00]
mov dword [ebp - 0x36e4], edx
mov eax, dword [ebp - 0x36e4]
mov dword [ebp - 0x23b4], eax
lea ecx, [ebp - 0x3a58]
mov dword [ebp - 0x36e8], ecx
movzx edx, byte [ebp - 0x2198]
push edx
mov ecx, dword [ebp - 0x36e8]
call fcn.1008cde0
mov dword [ebp - 4], 0xa
mov eax, dword [ebp - 0x23b4]
mov dword [ebp - 0x1e38], eax
mov ecx, dword [ebp - 0x1e38]
add ecx, 1
mov dword [ebp - 0x36ec], ecx
mov edx, dword [ebp - 0x1e38]
mov al, byte [edx]
mov byte [ebp - 0x18b5], al
add dword [ebp - 0x1e38], 1
cmp byte [ebp - 0x18b5], 0
jne 0x1012c147
mov ecx, dword [ebp - 0x1e38]
sub ecx, dword [ebp - 0x36ec]
mov dword [ebp - 0x36f0], ecx
mov edx, dword [ebp - 0x36f0]
mov dword [ebp - 0x36f4], edx
mov eax, dword [ebp - 0x36f4]
mov dword [ebp - 0x36f8], eax
mov ecx, dword [ebp - 0x36f8]
push ecx
mov edx, dword [ebp - 0x23b4]
push edx
lea ecx, [ebp - 0x3a58]
call fcn.1008ce30
mov dword [ebp - 4], 0xb
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x18bc], dl
movsx eax, byte [ebp - 0x18bc]
xor eax, 0xffffff98
mov byte [ebp - 0x18bd], al
mov cl, byte [ebp - 0x18bd]
mov byte [ebp - 0x1b10], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.edge]
mov byte [ebp - 0x18c4], al
movsx ecx, byte [ebp - 0x18c4]
xor ecx, 0xffffff98
mov byte [ebp - 0x18c5], cl
mov dl, byte [ebp - 0x18c5]
mov byte [ebp - 0x1b0f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.edge]
mov byte [ebp - 0x18cc], cl
movsx edx, byte [ebp - 0x18cc]
xor edx, 0xffffff98
mov byte [ebp - 0x18cd], dl
mov al, byte [ebp - 0x18cd]
mov byte [ebp - 0x1b0e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.edge]
mov byte [ebp - 0x18d4], al
movsx ecx, byte [ebp - 0x18d4]
xor ecx, 0xffffff98
mov byte [ebp - 0x18d5], cl
mov dl, byte [ebp - 0x18d5]
mov byte [ebp - 0x1b0d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.edge]
mov byte [ebp - 0x18dc], cl
movsx edx, byte [ebp - 0x18dc]
xor edx, 0xffffff98
mov byte [ebp - 0x18dd], dl
mov al, byte [ebp - 0x18dd]
mov byte [ebp - 0x1b0c], al
mov dword [ebp - 0x1e3c], 0
jmp 0x1012c2b9
mov ecx, dword [ebp - 0x1e3c]
add ecx, 1
mov dword [ebp - 0x1e3c], ecx
cmp dword [ebp - 0x1e3c], 5
jae 0x1012c33b
lea edx, [ebp - 0x1b10]
mov dword [ebp - 0x36fc], edx
mov eax, dword [ebp - 0x36fc]
add eax, dword [ebp - 0x1e3c]
mov dword [ebp - 0x3700], eax
mov ecx, dword [ebp - 0x3700]
mov dl, byte [ecx]
mov byte [ebp - 0x18e4], dl
mov al, byte [ebp - 0x2199]
mov byte [ebp - 0x2ad], al
movsx ecx, byte [ebp - 0x18e4]
xor ecx, 0xffffff98
mov byte [ebp - 0x2ad], cl
lea edx, [ebp - 0x1b10]
mov dword [ebp - 0x3704], edx
mov eax, dword [ebp - 0x3704]
add eax, dword [ebp - 0x1e3c]
mov dword [ebp - 0x3708], eax
mov ecx, dword [ebp - 0x3708]
mov dl, byte [ebp - 0x2ad]
mov byte [ecx], dl
jmp 0x1012c2aa
lea eax, [ebp - 0x1b10]
mov dword [ebp - 0x370c], eax
mov ecx, dword [ebp - 0x370c]
mov dword [ebp - 0x23b8], ecx
lea edx, [ebp - 0x3a40]
mov dword [ebp - 0x3710], edx
movzx eax, byte [ebp - 0x219a]
push eax
mov ecx, dword [ebp - 0x3710]
call fcn.1008cde0
mov byte [ebp - 4], 0xc
mov ecx, dword [ebp - 0x23b8]
mov dword [ebp - 0x1e40], ecx
mov edx, dword [ebp - 0x1e40]
add edx, 1
mov dword [ebp - 0x3714], edx
mov eax, dword [ebp - 0x1e40]
mov cl, byte [eax]
mov byte [ebp - 0x18e5], cl
add dword [ebp - 0x1e40], 1
cmp byte [ebp - 0x18e5], 0
jne 0x1012c391
mov edx, dword [ebp - 0x1e40]
sub edx, dword [ebp - 0x3714]
mov dword [ebp - 0x3718], edx
mov eax, dword [ebp - 0x3718]
mov dword [ebp - 0x371c], eax
mov ecx, dword [ebp - 0x371c]
mov dword [ebp - 0x3720], ecx
mov edx, dword [ebp - 0x3720]
push edx
mov eax, dword [ebp - 0x23b8]
push eax
lea ecx, [ebp - 0x3a40]
call fcn.1008ce30
mov byte [ebp - 4], 0xd
lea ecx, [ebp - 0x3a58]
push ecx
mov ecx, dword [ebp - 0x1e44]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x1e44]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1e44]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1012c438
lea edx, [ebp - 0x3a40]
push edx
mov ecx, dword [ebp - 0x1e44]
add ecx, 0x70
call fcn.100ad110
mov eax, dword [ebp - 0x1e44]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 0xb
lea ecx, [ebp - 0x3a40]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3a58]
call fcn.1008b960
mov ecx, dword [ebp - 0x200]
add ecx, 0x140
mov dword [ebp - 0x30], ecx
mov edx, dword [ebp - 0x30]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x30]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x30]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x30]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x30]
mov edx, dword [ebp - 0x200]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x200]
add ecx, 0x18
mov dword [ebp - 0x3724], ecx
lea edx, [ebp - 0x30]
push edx
mov ecx, dword [ebp - 0x3724]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x250
mov dword [ebp - 0x1e58], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x18f0], al
movsx ecx, byte [ebp - 0x18f0]
xor ecx, 0xffffff98
mov byte [ebp - 0x18f1], cl
mov dl, byte [ebp - 0x18f1]
mov byte [ebp - 0x20f0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.at_targets_stand]
mov byte [ebp - 0x18f8], cl
movsx edx, byte [ebp - 0x18f8]
xor edx, 0xffffff98
mov byte [ebp - 0x18f9], dl
mov al, byte [ebp - 0x18f9]
mov byte [ebp - 0x20ef], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1900], dl
movsx eax, byte [ebp - 0x1900]
xor eax, 0xffffff98
mov byte [ebp - 0x1901], al
mov cl, byte [ebp - 0x1901]
mov byte [ebp - 0x20ee], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.at_targets_stand]
mov byte [ebp - 0x1908], cl
movsx edx, byte [ebp - 0x1908]
xor edx, 0xffffff98
mov byte [ebp - 0x1909], dl
mov al, byte [ebp - 0x1909]
mov byte [ebp - 0x20ed], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1910], dl
movsx eax, byte [ebp - 0x1910]
xor eax, 0xffffff98
mov byte [ebp - 0x1911], al
mov cl, byte [ebp - 0x1911]
mov byte [ebp - 0x20ec], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.at_targets_stand]
mov byte [ebp - 0x1918], cl
movsx edx, byte [ebp - 0x1918]
xor edx, 0xffffff98
mov byte [ebp - 0x1919], dl
mov al, byte [ebp - 0x1919]
mov byte [ebp - 0x20eb], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x1920], al
movsx ecx, byte [ebp - 0x1920]
xor ecx, 0xffffff98
mov byte [ebp - 0x1921], cl
mov dl, byte [ebp - 0x1921]
mov byte [ebp - 0x20ea], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1928], dl
movsx eax, byte [ebp - 0x1928]
xor eax, 0xffffff98
mov byte [ebp - 0x1929], al
mov cl, byte [ebp - 0x1929]
mov byte [ebp - 0x20e9], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x1930], al
movsx ecx, byte [ebp - 0x1930]
xor ecx, 0xffffff98
mov byte [ebp - 0x1931], cl
mov dl, byte [ebp - 0x1931]
mov byte [ebp - 0x20e8], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1938], dl
movsx eax, byte [ebp - 0x1938]
xor eax, 0xffffff98
mov byte [ebp - 0x1939], al
mov cl, byte [ebp - 0x1939]
mov byte [ebp - 0x20e7], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.at_targets_stand]
mov byte [ebp - 0x1940], cl
movsx edx, byte [ebp - 0x1940]
xor edx, 0xffffff98
mov byte [ebp - 0x1941], dl
mov al, byte [ebp - 0x1941]
mov byte [ebp - 0x20e6], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x1948], al
movsx ecx, byte [ebp - 0x1948]
xor ecx, 0xffffff98
mov byte [ebp - 0x1949], cl
mov dl, byte [ebp - 0x1949]
mov byte [ebp - 0x20e5], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1950], dl
movsx eax, byte [ebp - 0x1950]
xor eax, 0xffffff98
mov byte [ebp - 0x1951], al
mov cl, byte [ebp - 0x1951]
mov byte [ebp - 0x20e4], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.at_targets_stand]
mov byte [ebp - 0x1958], cl
movsx edx, byte [ebp - 0x1958]
xor edx, 0xffffff98
mov byte [ebp - 0x1959], dl
mov al, byte [ebp - 0x1959]
mov byte [ebp - 0x20e3], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x1960], al
movsx ecx, byte [ebp - 0x1960]
xor ecx, 0xffffff98
mov byte [ebp - 0x1961], cl
mov dl, byte [ebp - 0x1961]
mov byte [ebp - 0x20e2], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.at_targets_stand]
mov byte [ebp - 0x1968], dl
movsx eax, byte [ebp - 0x1968]
xor eax, 0xffffff98
mov byte [ebp - 0x1969], al
mov cl, byte [ebp - 0x1969]
mov byte [ebp - 0x20e1], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.at_targets_stand]
mov byte [ebp - 0x1970], al
movsx ecx, byte [ebp - 0x1970]
xor ecx, 0xffffff98
mov byte [ebp - 0x1971], cl
mov dl, byte [ebp - 0x1971]
mov byte [ebp - 0x20e0], dl
mov dword [ebp - 0x1e48], 0
jmp 0x1012c821
mov eax, dword [ebp - 0x1e48]
add eax, 1
mov dword [ebp - 0x1e48], eax
cmp dword [ebp - 0x1e48], 0x11
jae 0x1012c8a3
lea ecx, [ebp - 0x20f0]
mov dword [ebp - 0x3728], ecx
mov edx, dword [ebp - 0x3728]
add edx, dword [ebp - 0x1e48]
mov dword [ebp - 0x372c], edx
mov eax, dword [ebp - 0x372c]
mov cl, byte [eax]
mov byte [ebp - 0x1978], cl
mov dl, byte [ebp - 0x219b]
mov byte [ebp - 0x2ae], dl
movsx eax, byte [ebp - 0x1978]
xor eax, 0xffffff98
mov byte [ebp - 0x2ae], al
lea ecx, [ebp - 0x20f0]
mov dword [ebp - 0x3730], ecx
mov edx, dword [ebp - 0x3730]
add edx, dword [ebp - 0x1e48]
mov dword [ebp - 0x3734], edx
mov eax, dword [ebp - 0x3734]
mov cl, byte [ebp - 0x2ae]
mov byte [eax], cl
jmp 0x1012c812
lea edx, [ebp - 0x20f0]
mov dword [ebp - 0x3738], edx
mov eax, dword [ebp - 0x3738]
mov dword [ebp - 0x23bc], eax
lea ecx, [ebp - 0x3a88]
mov dword [ebp - 0x373c], ecx
movzx edx, byte [ebp - 0x219c]
push edx
mov ecx, dword [ebp - 0x373c]
call fcn.1008cde0
mov dword [ebp - 4], 0xe
mov eax, dword [ebp - 0x23bc]
mov dword [ebp - 0x1e4c], eax
mov ecx, dword [ebp - 0x1e4c]
add ecx, 1
mov dword [ebp - 0x3740], ecx
mov edx, dword [ebp - 0x1e4c]
mov al, byte [edx]
mov byte [ebp - 0x1979], al
add dword [ebp - 0x1e4c], 1
cmp byte [ebp - 0x1979], 0
jne 0x1012c8fc
mov ecx, dword [ebp - 0x1e4c]
sub ecx, dword [ebp - 0x3740]
mov dword [ebp - 0x3744], ecx
mov edx, dword [ebp - 0x3744]
mov dword [ebp - 0x3748], edx
mov eax, dword [ebp - 0x3748]
mov dword [ebp - 0x374c], eax
mov ecx, dword [ebp - 0x374c]
push ecx
mov edx, dword [ebp - 0x23bc]
push edx
lea ecx, [ebp - 0x3a88]
call fcn.1008ce30
mov dword [ebp - 4], 0xf
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x1980], dl
movsx eax, byte [ebp - 0x1980]
xor eax, 0xffffff98
mov byte [ebp - 0x1981], al
mov cl, byte [ebp - 0x1981]
mov byte [ebp - 0x1fd4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x1988], al
movsx ecx, byte [ebp - 0x1988]
xor ecx, 0xffffff98
mov byte [ebp - 0x1989], cl
mov dl, byte [ebp - 0x1989]
mov byte [ebp - 0x1fd3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x1990], cl
movsx edx, byte [ebp - 0x1990]
xor edx, 0xffffff98
mov byte [ebp - 0x1991], dl
mov al, byte [ebp - 0x1991]
mov byte [ebp - 0x1fd2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x1998], al
movsx ecx, byte [ebp - 0x1998]
xor ecx, 0xffffff98
mov byte [ebp - 0x1999], cl
mov dl, byte [ebp - 0x1999]
mov byte [ebp - 0x1fd1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x19a0], cl
movsx edx, byte [ebp - 0x19a0]
xor edx, 0xffffff98
mov byte [ebp - 0x19a1], dl
mov al, byte [ebp - 0x19a1]
mov byte [ebp - 0x1fd0], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x19a8], al
movsx ecx, byte [ebp - 0x19a8]
xor ecx, 0xffffff98
mov byte [ebp - 0x19a9], cl
mov dl, byte [ebp - 0x19a9]
mov byte [ebp - 0x1fcf], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x19b0], dl
movsx eax, byte [ebp - 0x19b0]
xor eax, 0xffffff98
mov byte [ebp - 0x19b1], al
mov cl, byte [ebp - 0x19b1]
mov byte [ebp - 0x1fce], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x19b8], cl
movsx edx, byte [ebp - 0x19b8]
xor edx, 0xffffff98
mov byte [ebp - 0x19b9], dl
mov al, byte [ebp - 0x19b9]
mov byte [ebp - 0x1fcd], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x19c0], dl
movsx eax, byte [ebp - 0x19c0]
xor eax, 0xffffff98
mov byte [ebp - 0x19c1], al
mov cl, byte [ebp - 0x19c1]
mov byte [ebp - 0x1fcc], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x19c8], cl
movsx edx, byte [ebp - 0x19c8]
xor edx, 0xffffff98
mov byte [ebp - 0x19c9], dl
mov al, byte [ebp - 0x19c9]
mov byte [ebp - 0x1fcb], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x19d0], al
movsx ecx, byte [ebp - 0x19d0]
xor ecx, 0xffffff98
mov byte [ebp - 0x19d1], cl
mov dl, byte [ebp - 0x19d1]
mov byte [ebp - 0x1fca], dl
mov dword [ebp - 0x1e50], 0
jmp 0x1012cb8e
mov eax, dword [ebp - 0x1e50]
add eax, 1
mov dword [ebp - 0x1e50], eax
cmp dword [ebp - 0x1e50], 0xb
jae 0x1012cc10
lea ecx, [ebp - 0x1fd4]
mov dword [ebp - 0x3750], ecx
mov edx, dword [ebp - 0x3750]
add edx, dword [ebp - 0x1e50]
mov dword [ebp - 0x3754], edx
mov eax, dword [ebp - 0x3754]
mov cl, byte [eax]
mov byte [ebp - 0x19d8], cl
mov dl, byte [ebp - 0x219d]
mov byte [ebp - 0x2af], dl
movsx eax, byte [ebp - 0x19d8]
xor eax, 0xffffff98
mov byte [ebp - 0x2af], al
lea ecx, [ebp - 0x1fd4]
mov dword [ebp - 0x3758], ecx
mov edx, dword [ebp - 0x3758]
add edx, dword [ebp - 0x1e50]
mov dword [ebp - 0x375c], edx
mov eax, dword [ebp - 0x375c]
mov cl, byte [ebp - 0x2af]
mov byte [eax], cl
jmp 0x1012cb7f
lea edx, [ebp - 0x1fd4]
mov dword [ebp - 0x3760], edx
mov eax, dword [ebp - 0x3760]
mov dword [ebp - 0x23c0], eax
lea ecx, [ebp - 0x3980]
mov dword [ebp - 0x3764], ecx
movzx edx, byte [ebp - 0x219e]
push edx
mov ecx, dword [ebp - 0x3764]
call fcn.1008cde0
mov byte [ebp - 4], 0x10
mov eax, dword [ebp - 0x23c0]
mov dword [ebp - 0x1e54], eax
mov ecx, dword [ebp - 0x1e54]
add ecx, 1
mov dword [ebp - 0x3768], ecx
mov edx, dword [ebp - 0x1e54]
mov al, byte [edx]
mov byte [ebp - 0x19d9], al
add dword [ebp - 0x1e54], 1
cmp byte [ebp - 0x19d9], 0
jne 0x1012cc66
mov ecx, dword [ebp - 0x1e54]
sub ecx, dword [ebp - 0x3768]
mov dword [ebp - 0x376c], ecx
mov edx, dword [ebp - 0x376c]
mov dword [ebp - 0x3770], edx
mov eax, dword [ebp - 0x3770]
mov dword [ebp - 0x3774], eax
mov ecx, dword [ebp - 0x3774]
push ecx
mov edx, dword [ebp - 0x23c0]
push edx
lea ecx, [ebp - 0x3980]
call fcn.1008ce30
mov byte [ebp - 4], 0x11
lea eax, [ebp - 0x3a88]
push eax
mov ecx, dword [ebp - 0x1e58]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1e58]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1e58]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1012cd0d
lea ecx, [ebp - 0x3980]
push ecx
mov ecx, dword [ebp - 0x1e58]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x1e58]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0xf
lea ecx, [ebp - 0x3980]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3a88]
call fcn.1008b960
mov eax, dword [ebp - 0x200]
add eax, 0x250
mov dword [ebp - 0x3778], eax
mov dword [ebp - 0x150], 0x100a8ae0
mov ecx, dword [ebp - 0x3778]
add ecx, 0x58
mov dword [ebp - 0x37e8], ecx
lea edx, [ebp - 0x150]
push edx
mov ecx, dword [ebp - 0x37e8]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x250
mov dword [ebp - 0x37ec], eax
mov dword [ebp - 0x14c], 0x100a8b10
mov ecx, dword [ebp - 0x37ec]
add ecx, 0x58
mov dword [ebp - 0x37f4], ecx
lea edx, [ebp - 0x14c]
push edx
mov ecx, dword [ebp - 0x37f4]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x250
mov dword [ebp - 0x2c], eax
mov ecx, dword [ebp - 0x2c]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x2c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x2c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x2c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x2c]
mov ecx, dword [ebp - 0x200]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x200]
add eax, 0x18
mov dword [ebp - 0x37f8], eax
lea ecx, [ebp - 0x2c]
push ecx
mov ecx, dword [ebp - 0x37f8]
call fcn.1008c950
mov edx, dword [ebp - 0x200]
add edx, 0x2d8
mov dword [ebp - 0x1e6c], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.at_targets_walk]
mov byte [ebp - 0x19e0], dl
movsx eax, byte [ebp - 0x19e0]
xor eax, 0xffffff98
mov byte [ebp - 0x19e1], al
mov cl, byte [ebp - 0x19e1]
mov byte [ebp - 0x20c8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.at_targets_walk]
mov byte [ebp - 0x19e8], al
movsx ecx, byte [ebp - 0x19e8]
xor ecx, 0xffffff98
mov byte [ebp - 0x19e9], cl
mov dl, byte [ebp - 0x19e9]
mov byte [ebp - 0x20c7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x19f0], cl
movsx edx, byte [ebp - 0x19f0]
xor edx, 0xffffff98
mov byte [ebp - 0x19f1], dl
mov al, byte [ebp - 0x19f1]
mov byte [ebp - 0x20c6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.at_targets_walk]
mov byte [ebp - 0x19f8], al
movsx ecx, byte [ebp - 0x19f8]
xor ecx, 0xffffff98
mov byte [ebp - 0x19f9], cl
mov dl, byte [ebp - 0x19f9]
mov byte [ebp - 0x20c5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x1a00], cl
movsx edx, byte [ebp - 0x1a00]
xor edx, 0xffffff98
mov byte [ebp - 0x1a01], dl
mov al, byte [ebp - 0x1a01]
mov byte [ebp - 0x20c4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.at_targets_walk]
mov byte [ebp - 0x1a08], al
movsx ecx, byte [ebp - 0x1a08]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a09], cl
mov dl, byte [ebp - 0x1a09]
mov byte [ebp - 0x20c3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.at_targets_walk]
mov byte [ebp - 0x1a10], dl
movsx eax, byte [ebp - 0x1a10]
xor eax, 0xffffff98
mov byte [ebp - 0x1a11], al
mov cl, byte [ebp - 0x1a11]
mov byte [ebp - 0x20c2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x1a18], cl
movsx edx, byte [ebp - 0x1a18]
xor edx, 0xffffff98
mov byte [ebp - 0x1a19], dl
mov al, byte [ebp - 0x1a19]
mov byte [ebp - 0x20c1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.at_targets_walk]
mov byte [ebp - 0x1a20], dl
movsx eax, byte [ebp - 0x1a20]
xor eax, 0xffffff98
mov byte [ebp - 0x1a21], al
mov cl, byte [ebp - 0x1a21]
mov byte [ebp - 0x20c0], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x1a28], cl
movsx edx, byte [ebp - 0x1a28]
xor edx, 0xffffff98
mov byte [ebp - 0x1a29], dl
mov al, byte [ebp - 0x1a29]
mov byte [ebp - 0x20bf], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.at_targets_walk]
mov byte [ebp - 0x1a30], al
movsx ecx, byte [ebp - 0x1a30]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a31], cl
mov dl, byte [ebp - 0x1a31]
mov byte [ebp - 0x20be], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.at_targets_walk]
mov byte [ebp - 0x1a38], dl
movsx eax, byte [ebp - 0x1a38]
xor eax, 0xffffff98
mov byte [ebp - 0x1a39], al
mov cl, byte [ebp - 0x1a39]
mov byte [ebp - 0x20bd], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x1a40], cl
movsx edx, byte [ebp - 0x1a40]
xor edx, 0xffffff98
mov byte [ebp - 0x1a41], dl
mov al, byte [ebp - 0x1a41]
mov byte [ebp - 0x20bc], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.at_targets_walk]
mov byte [ebp - 0x1a48], al
movsx ecx, byte [ebp - 0x1a48]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a49], cl
mov dl, byte [ebp - 0x1a49]
mov byte [ebp - 0x20bb], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.at_targets_walk]
mov byte [ebp - 0x1a50], dl
movsx eax, byte [ebp - 0x1a50]
xor eax, 0xffffff98
mov byte [ebp - 0x1a51], al
mov cl, byte [ebp - 0x1a51]
mov byte [ebp - 0x20ba], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.at_targets_walk]
mov byte [ebp - 0x1a58], cl
movsx edx, byte [ebp - 0x1a58]
xor edx, 0xffffff98
mov byte [ebp - 0x1a59], dl
mov al, byte [ebp - 0x1a59]
mov byte [ebp - 0x20b9], al
mov dword [ebp - 0x1e5c], 0
jmp 0x1012d13e
mov ecx, dword [ebp - 0x1e5c]
add ecx, 1
mov dword [ebp - 0x1e5c], ecx
cmp dword [ebp - 0x1e5c], 0x10
jae 0x1012d1c0
lea edx, [ebp - 0x20c8]
mov dword [ebp - 0x37fc], edx
mov eax, dword [ebp - 0x37fc]
add eax, dword [ebp - 0x1e5c]
mov dword [ebp - 0x3800], eax
mov ecx, dword [ebp - 0x3800]
mov dl, byte [ecx]
mov byte [ebp - 0x1a60], dl
mov al, byte [ebp - 0x219f]
mov byte [ebp - 0x2b0], al
movsx ecx, byte [ebp - 0x1a60]
xor ecx, 0xffffff98
mov byte [ebp - 0x2b0], cl
lea edx, [ebp - 0x20c8]
mov dword [ebp - 0x3804], edx
mov eax, dword [ebp - 0x3804]
add eax, dword [ebp - 0x1e5c]
mov dword [ebp - 0x3808], eax
mov ecx, dword [ebp - 0x3808]
mov dl, byte [ebp - 0x2b0]
mov byte [ecx], dl
jmp 0x1012d12f
lea eax, [ebp - 0x20c8]
mov dword [ebp - 0x380c], eax
mov ecx, dword [ebp - 0x380c]
mov dword [ebp - 0x23c4], ecx
lea edx, [ebp - 0x3ab8]
mov dword [ebp - 0x3810], edx
movzx eax, byte [ebp - 0x21a0]
push eax
mov ecx, dword [ebp - 0x3810]
call fcn.1008cde0
mov dword [ebp - 4], 0x12
mov ecx, dword [ebp - 0x23c4]
mov dword [ebp - 0x1e60], ecx
mov edx, dword [ebp - 0x1e60]
add edx, 1
mov dword [ebp - 0x3814], edx
mov eax, dword [ebp - 0x1e60]
mov cl, byte [eax]
mov byte [ebp - 0x1a61], cl
add dword [ebp - 0x1e60], 1
cmp byte [ebp - 0x1a61], 0
jne 0x1012d219
mov edx, dword [ebp - 0x1e60]
sub edx, dword [ebp - 0x3814]
mov dword [ebp - 0x3818], edx
mov eax, dword [ebp - 0x3818]
mov dword [ebp - 0x381c], eax
mov ecx, dword [ebp - 0x381c]
mov dword [ebp - 0x3820], ecx
mov edx, dword [ebp - 0x3820]
push edx
mov eax, dword [ebp - 0x23c4]
push eax
lea ecx, [ebp - 0x3ab8]
call fcn.1008ce30
mov dword [ebp - 4], 0x13
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x1a68], al
movsx ecx, byte [ebp - 0x1a68]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a69], cl
mov dl, byte [ebp - 0x1a69]
mov byte [ebp - 0x1fe0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x1a70], cl
movsx edx, byte [ebp - 0x1a70]
xor edx, 0xffffff98
mov byte [ebp - 0x1a71], dl
mov al, byte [ebp - 0x1a71]
mov byte [ebp - 0x1fdf], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x1a78], dl
movsx eax, byte [ebp - 0x1a78]
xor eax, 0xffffff98
mov byte [ebp - 0x1a79], al
mov cl, byte [ebp - 0x1a79]
mov byte [ebp - 0x1fde], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x1a80], cl
movsx edx, byte [ebp - 0x1a80]
xor edx, 0xffffff98
mov byte [ebp - 0x1a81], dl
mov al, byte [ebp - 0x1a81]
mov byte [ebp - 0x1fdd], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x1a88], dl
movsx eax, byte [ebp - 0x1a88]
xor eax, 0xffffff98
mov byte [ebp - 0x1a89], al
mov cl, byte [ebp - 0x1a89]
mov byte [ebp - 0x1fdc], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x1a90], cl
movsx edx, byte [ebp - 0x1a90]
xor edx, 0xffffff98
mov byte [ebp - 0x1a91], dl
mov al, byte [ebp - 0x1a91]
mov byte [ebp - 0x1fdb], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x1a98], al
movsx ecx, byte [ebp - 0x1a98]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a99], cl
mov dl, byte [ebp - 0x1a99]
mov byte [ebp - 0x1fda], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x1aa0], dl
movsx eax, byte [ebp - 0x1aa0]
xor eax, 0xffffff98
mov byte [ebp - 0x1aa1], al
mov cl, byte [ebp - 0x1aa1]
mov byte [ebp - 0x1fd9], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x1aa8], al
movsx ecx, byte [ebp - 0x1aa8]
xor ecx, 0xffffff98
mov byte [ebp - 0x1aa9], cl
mov dl, byte [ebp - 0x1aa9]
mov byte [ebp - 0x1fd8], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x1ab0], dl
movsx eax, byte [ebp - 0x1ab0]
xor eax, 0xffffff98
mov byte [ebp - 0x1ab1], al
mov cl, byte [ebp - 0x1ab1]
mov byte [ebp - 0x1fd7], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x1ab8], cl
movsx edx, byte [ebp - 0x1ab8]
xor edx, 0xffffff98
mov byte [ebp - 0x1ab9], dl
mov al, byte [ebp - 0x1ab9]
mov byte [ebp - 0x1fd6], al
mov dword [ebp - 0x1e64], 0
jmp 0x1012d4ab
mov ecx, dword [ebp - 0x1e64]
add ecx, 1
mov dword [ebp - 0x1e64], ecx
cmp dword [ebp - 0x1e64], 0xb
jae 0x1012d52d
lea edx, [ebp - 0x1fe0]
mov dword [ebp - 0x3824], edx
mov eax, dword [ebp - 0x3824]
add eax, dword [ebp - 0x1e64]
mov dword [ebp - 0x3828], eax
mov ecx, dword [ebp - 0x3828]
mov dl, byte [ecx]
mov byte [ebp - 0x1ac0], dl
mov al, byte [ebp - 0x21a1]
mov byte [ebp - 0x2b1], al
movsx ecx, byte [ebp - 0x1ac0]
xor ecx, 0xffffff98
mov byte [ebp - 0x2b1], cl
lea edx, [ebp - 0x1fe0]
mov dword [ebp - 0x382c], edx
mov eax, dword [ebp - 0x382c]
add eax, dword [ebp - 0x1e64]
mov dword [ebp - 0x3830], eax
mov ecx, dword [ebp - 0x3830]
mov dl, byte [ebp - 0x2b1]
mov byte [ecx], dl
jmp 0x1012d49c
lea eax, [ebp - 0x1fe0]
mov dword [ebp - 0x3834], eax
mov ecx, dword [ebp - 0x3834]
mov dword [ebp - 0x23c8], ecx
lea edx, [ebp - 0x3aa0]
mov dword [ebp - 0x3838], edx
movzx eax, byte [ebp - 0x21a2]
push eax
mov ecx, dword [ebp - 0x3838]
call fcn.1008cde0
mov byte [ebp - 4], 0x14
mov ecx, dword [ebp - 0x23c8]
mov dword [ebp - 0x1e68], ecx
mov edx, dword [ebp - 0x1e68]
add edx, 1
mov dword [ebp - 0x383c], edx
mov eax, dword [ebp - 0x1e68]
mov cl, byte [eax]
mov byte [ebp - 0x699], cl
add dword [ebp - 0x1e68], 1
cmp byte [ebp - 0x699], 0
jne 0x1012d583
mov edx, dword [ebp - 0x1e68]
sub edx, dword [ebp - 0x383c]
mov dword [ebp - 0x3840], edx
mov eax, dword [ebp - 0x3840]
mov dword [ebp - 0x3844], eax
mov ecx, dword [ebp - 0x3844]
mov dword [ebp - 0x3848], ecx
mov edx, dword [ebp - 0x3848]
push edx
mov eax, dword [ebp - 0x23c8]
push eax
lea ecx, [ebp - 0x3aa0]
call fcn.1008ce30
mov byte [ebp - 4], 0x15
lea ecx, [ebp - 0x3ab8]
push ecx
mov ecx, dword [ebp - 0x1e6c]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x1e6c]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1e6c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1012d62a
lea edx, [ebp - 0x3aa0]
push edx
mov ecx, dword [ebp - 0x1e6c]
add ecx, 0x70
call fcn.100ad110
mov eax, dword [ebp - 0x1e6c]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 0x13
lea ecx, [ebp - 0x3aa0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3ab8]
call fcn.1008b960
mov ecx, dword [ebp - 0x200]
add ecx, 0x2d8
mov dword [ebp - 0x384c], ecx
mov dword [ebp - 0x148], 0x100a8c30
mov edx, dword [ebp - 0x384c]
add edx, 0x58
mov dword [ebp - 0x3854], edx
lea eax, [ebp - 0x148]
push eax
mov ecx, dword [ebp - 0x3854]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0x2d8
mov dword [ebp - 0x3858], ecx
mov dword [ebp - 0x144], 0x100a8c60
mov edx, dword [ebp - 0x3858]
add edx, 0x58
mov dword [ebp - 0x3860], edx
lea eax, [ebp - 0x144]
push eax
mov ecx, dword [ebp - 0x3860]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0x2d8
mov dword [ebp - 0x28], ecx
mov edx, dword [ebp - 0x28]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x28]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x28]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x28]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x28]
mov edx, dword [ebp - 0x200]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x200]
add ecx, 0x18
mov dword [ebp - 0x3864], ecx
lea edx, [ebp - 0x28]
push edx
mov ecx, dword [ebp - 0x3864]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x360
mov dword [ebp - 0x1e80], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.at_targets_air]
mov byte [ebp - 0x6a0], al
movsx ecx, byte [ebp - 0x6a0]
xor ecx, 0xffffff98
mov byte [ebp - 0x6a1], cl
mov dl, byte [ebp - 0x6a1]
mov byte [ebp - 0x20b8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.at_targets_air]
mov byte [ebp - 0x6a8], cl
movsx edx, byte [ebp - 0x6a8]
xor edx, 0xffffff98
mov byte [ebp - 0x6a9], dl
mov al, byte [ebp - 0x6a9]
mov byte [ebp - 0x20b7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.at_targets_air]
mov byte [ebp - 0x6b0], dl
movsx eax, byte [ebp - 0x6b0]
xor eax, 0xffffff98
mov byte [ebp - 0x6b1], al
mov cl, byte [ebp - 0x6b1]
mov byte [ebp - 0x20b6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.at_targets_air]
mov byte [ebp - 0x6b8], cl
movsx edx, byte [ebp - 0x6b8]
xor edx, 0xffffff98
mov byte [ebp - 0x6b9], dl
mov al, byte [ebp - 0x6b9]
mov byte [ebp - 0x20b5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.at_targets_air]
mov byte [ebp - 0x6c0], dl
movsx eax, byte [ebp - 0x6c0]
xor eax, 0xffffff98
mov byte [ebp - 0x6c1], al
mov cl, byte [ebp - 0x6c1]
mov byte [ebp - 0x20b4], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.at_targets_air]
mov byte [ebp - 0x6c8], cl
movsx edx, byte [ebp - 0x6c8]
xor edx, 0xffffff98
mov byte [ebp - 0x6c9], dl
mov al, byte [ebp - 0x6c9]
mov byte [ebp - 0x20b3], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.at_targets_air]
mov byte [ebp - 0x6d0], al
movsx ecx, byte [ebp - 0x6d0]
xor ecx, 0xffffff98
mov byte [ebp - 0x6d1], cl
mov dl, byte [ebp - 0x6d1]
mov byte [ebp - 0x20b2], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.at_targets_air]
mov byte [ebp - 0x6d8], dl
movsx eax, byte [ebp - 0x6d8]
xor eax, 0xffffff98
mov byte [ebp - 0x6d9], al
mov cl, byte [ebp - 0x6d9]
mov byte [ebp - 0x20b1], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.at_targets_air]
mov byte [ebp - 0x6e0], al
movsx ecx, byte [ebp - 0x6e0]
xor ecx, 0xffffff98
mov byte [ebp - 0x6e1], cl
mov dl, byte [ebp - 0x6e1]
mov byte [ebp - 0x20b0], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.at_targets_air]
mov byte [ebp - 0x6e8], dl
movsx eax, byte [ebp - 0x6e8]
xor eax, 0xffffff98
mov byte [ebp - 0x6e9], al
mov cl, byte [ebp - 0x6e9]
mov byte [ebp - 0x20af], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.at_targets_air]
mov byte [ebp - 0x6f0], cl
movsx edx, byte [ebp - 0x6f0]
xor edx, 0xffffff98
mov byte [ebp - 0x6f1], dl
mov al, byte [ebp - 0x6f1]
mov byte [ebp - 0x20ae], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.at_targets_air]
mov byte [ebp - 0x6f8], al
movsx ecx, byte [ebp - 0x6f8]
xor ecx, 0xffffff98
mov byte [ebp - 0x6f9], cl
mov dl, byte [ebp - 0x6f9]
mov byte [ebp - 0x20ad], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.at_targets_air]
mov byte [ebp - 0x700], dl
movsx eax, byte [ebp - 0x700]
xor eax, 0xffffff98
mov byte [ebp - 0x701], al
mov cl, byte [ebp - 0x701]
mov byte [ebp - 0x20ac], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.at_targets_air]
mov byte [ebp - 0x708], cl
movsx edx, byte [ebp - 0x708]
xor edx, 0xffffff98
mov byte [ebp - 0x709], dl
mov al, byte [ebp - 0x709]
mov byte [ebp - 0x20ab], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.at_targets_air]
mov byte [ebp - 0x710], al
movsx ecx, byte [ebp - 0x710]
xor ecx, 0xffffff98
mov byte [ebp - 0x711], cl
mov dl, byte [ebp - 0x711]
mov byte [ebp - 0x20aa], dl
mov dword [ebp - 0x1e70], 0
jmp 0x1012da2d
mov eax, dword [ebp - 0x1e70]
add eax, 1
mov dword [ebp - 0x1e70], eax
cmp dword [ebp - 0x1e70], 0xf
jae 0x1012daaf
lea ecx, [ebp - 0x20b8]
mov dword [ebp - 0x3868], ecx
mov edx, dword [ebp - 0x3868]
add edx, dword [ebp - 0x1e70]
mov dword [ebp - 0x386c], edx
mov eax, dword [ebp - 0x386c]
mov cl, byte [eax]
mov byte [ebp - 0x718], cl
mov dl, byte [ebp - 0x21a3]
mov byte [ebp - 0x2b2], dl
movsx eax, byte [ebp - 0x718]
xor eax, 0xffffff98
mov byte [ebp - 0x2b2], al
lea ecx, [ebp - 0x20b8]
mov dword [ebp - 0x3870], ecx
mov edx, dword [ebp - 0x3870]
add edx, dword [ebp - 0x1e70]
mov dword [ebp - 0x3874], edx
mov eax, dword [ebp - 0x3874]
mov cl, byte [ebp - 0x2b2]
mov byte [eax], cl
jmp 0x1012da1e
lea edx, [ebp - 0x20b8]
mov dword [ebp - 0x3878], edx
mov eax, dword [ebp - 0x3878]
mov dword [ebp - 0x2584], eax
lea ecx, [ebp - 0x3ae8]
mov dword [ebp - 0x387c], ecx
movzx edx, byte [ebp - 0x21a4]
push edx
mov ecx, dword [ebp - 0x387c]
call fcn.1008cde0
mov dword [ebp - 4], 0x16
mov eax, dword [ebp - 0x2584]
mov dword [ebp - 0x1e74], eax
mov ecx, dword [ebp - 0x1e74]
add ecx, 1
mov dword [ebp - 0x3880], ecx
mov edx, dword [ebp - 0x1e74]
mov al, byte [edx]
mov byte [ebp - 0x719], al
add dword [ebp - 0x1e74], 1
cmp byte [ebp - 0x719], 0
jne 0x1012db08
mov ecx, dword [ebp - 0x1e74]
sub ecx, dword [ebp - 0x3880]
mov dword [ebp - 0x3884], ecx
mov edx, dword [ebp - 0x3884]
mov dword [ebp - 0x3888], edx
mov eax, dword [ebp - 0x3888]
mov dword [ebp - 0x388c], eax
mov ecx, dword [ebp - 0x388c]
push ecx
mov edx, dword [ebp - 0x2584]
push edx
lea ecx, [ebp - 0x3ae8]
call fcn.1008ce30
mov dword [ebp - 4], 0x17
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x720], dl
movsx eax, byte [ebp - 0x720]
xor eax, 0xffffff98
mov byte [ebp - 0x721], al
mov cl, byte [ebp - 0x721]
mov byte [ebp - 0x1fec], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x728], al
movsx ecx, byte [ebp - 0x728]
xor ecx, 0xffffff98
mov byte [ebp - 0x729], cl
mov dl, byte [ebp - 0x729]
mov byte [ebp - 0x1feb], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x730], cl
movsx edx, byte [ebp - 0x730]
xor edx, 0xffffff98
mov byte [ebp - 0x731], dl
mov al, byte [ebp - 0x731]
mov byte [ebp - 0x1fea], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x738], al
movsx ecx, byte [ebp - 0x738]
xor ecx, 0xffffff98
mov byte [ebp - 0x739], cl
mov dl, byte [ebp - 0x739]
mov byte [ebp - 0x1fe9], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x740], cl
movsx edx, byte [ebp - 0x740]
xor edx, 0xffffff98
mov byte [ebp - 0x741], dl
mov al, byte [ebp - 0x741]
mov byte [ebp - 0x1fe8], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x748], al
movsx ecx, byte [ebp - 0x748]
xor ecx, 0xffffff98
mov byte [ebp - 0x749], cl
mov dl, byte [ebp - 0x749]
mov byte [ebp - 0x1fe7], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x750], dl
movsx eax, byte [ebp - 0x750]
xor eax, 0xffffff98
mov byte [ebp - 0x751], al
mov cl, byte [ebp - 0x751]
mov byte [ebp - 0x1fe6], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x758], cl
movsx edx, byte [ebp - 0x758]
xor edx, 0xffffff98
mov byte [ebp - 0x759], dl
mov al, byte [ebp - 0x759]
mov byte [ebp - 0x1fe5], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.at_targets]
mov byte [ebp - 0x760], dl
movsx eax, byte [ebp - 0x760]
xor eax, 0xffffff98
mov byte [ebp - 0x761], al
mov cl, byte [ebp - 0x761]
mov byte [ebp - 0x1fe4], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.at_targets]
mov byte [ebp - 0x768], cl
movsx edx, byte [ebp - 0x768]
xor edx, 0xffffff98
mov byte [ebp - 0x769], dl
mov al, byte [ebp - 0x769]
mov byte [ebp - 0x1fe3], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.at_targets]
mov byte [ebp - 0x770], al
movsx ecx, byte [ebp - 0x770]
xor ecx, 0xffffff98
mov byte [ebp - 0x771], cl
mov dl, byte [ebp - 0x771]
mov byte [ebp - 0x1fe2], dl
mov dword [ebp - 0x1e78], 0
jmp 0x1012dd9a
mov eax, dword [ebp - 0x1e78]
add eax, 1
mov dword [ebp - 0x1e78], eax
cmp dword [ebp - 0x1e78], 0xb
jae 0x1012de1c
lea ecx, [ebp - 0x1fec]
mov dword [ebp - 0x3890], ecx
mov edx, dword [ebp - 0x3890]
add edx, dword [ebp - 0x1e78]
mov dword [ebp - 0x3894], edx
mov eax, dword [ebp - 0x3894]
mov cl, byte [eax]
mov byte [ebp - 0x778], cl
mov dl, byte [ebp - 0x21a5]
mov byte [ebp - 0x2b3], dl
movsx eax, byte [ebp - 0x778]
xor eax, 0xffffff98
mov byte [ebp - 0x2b3], al
lea ecx, [ebp - 0x1fec]
mov dword [ebp - 0x3898], ecx
mov edx, dword [ebp - 0x3898]
add edx, dword [ebp - 0x1e78]
mov dword [ebp - 0x389c], edx
mov eax, dword [ebp - 0x389c]
mov cl, byte [ebp - 0x2b3]
mov byte [eax], cl
jmp 0x1012dd8b
lea edx, [ebp - 0x1fec]
mov dword [ebp - 0x38a0], edx
mov eax, dword [ebp - 0x38a0]
mov dword [ebp - 0x2574], eax
lea ecx, [ebp - 0x3ad0]
mov dword [ebp - 0x38a4], ecx
movzx edx, byte [ebp - 0x21a6]
push edx
mov ecx, dword [ebp - 0x38a4]
call fcn.1008cde0
mov byte [ebp - 4], 0x18
mov eax, dword [ebp - 0x2574]
mov dword [ebp - 0x1e7c], eax
mov ecx, dword [ebp - 0x1e7c]
add ecx, 1
mov dword [ebp - 0x38a8], ecx
mov edx, dword [ebp - 0x1e7c]
mov al, byte [edx]
mov byte [ebp - 0x779], al
add dword [ebp - 0x1e7c], 1
cmp byte [ebp - 0x779], 0
jne 0x1012de72
mov ecx, dword [ebp - 0x1e7c]
sub ecx, dword [ebp - 0x38a8]
mov dword [ebp - 0x38ac], ecx
mov edx, dword [ebp - 0x38ac]
mov dword [ebp - 0x38b0], edx
mov eax, dword [ebp - 0x38b0]
mov dword [ebp - 0x38b4], eax
mov ecx, dword [ebp - 0x38b4]
push ecx
mov edx, dword [ebp - 0x2574]
push edx
lea ecx, [ebp - 0x3ad0]
call fcn.1008ce30
mov byte [ebp - 4], 0x19
lea eax, [ebp - 0x3ae8]
push eax
mov ecx, dword [ebp - 0x1e80]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1e80]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1e80]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1012df19
lea ecx, [ebp - 0x3ad0]
push ecx
mov ecx, dword [ebp - 0x1e80]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x1e80]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x17
lea ecx, [ebp - 0x3ad0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3ae8]
call fcn.1008b960
mov eax, dword [ebp - 0x200]
add eax, 0x360
mov dword [ebp - 0x38b8], eax
mov dword [ebp - 0x140], 0x100a8d80
mov ecx, dword [ebp - 0x38b8]
add ecx, 0x58
mov dword [ebp - 0x38c0], ecx
lea edx, [ebp - 0x140]
push edx
mov ecx, dword [ebp - 0x38c0]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x360
mov dword [ebp - 0x38c4], eax
mov dword [ebp - 0x13c], 0x100a8db0
mov ecx, dword [ebp - 0x38c4]
add ecx, 0x58
mov dword [ebp - 0x38cc], ecx
lea edx, [ebp - 0x13c]
push edx
mov ecx, dword [ebp - 0x38cc]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x360
mov dword [ebp - 0x24], eax
mov ecx, dword [ebp - 0x24]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x24]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x24]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x24]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x24]
mov ecx, dword [ebp - 0x200]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x200]
add eax, 0x18
mov dword [ebp - 0x38d0], eax
lea ecx, [ebp - 0x24]
push ecx
mov ecx, dword [ebp - 0x38d0]
call fcn.1008c950
mov edx, dword [ebp - 0x200]
add edx, 0x488
mov dword [ebp - 0x264], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x10323e30]
mov word [ebp - 0x2374], dx
movzx eax, word [ebp - 0x2374]
xor eax, 0x98
mov word [ebp - 0x236e], ax
mov cx, word [ebp - 0x236e]
mov word [ebp - 0x2010], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x10323e30]
mov word [ebp - 0x236c], ax
movzx ecx, word [ebp - 0x236c]
xor ecx, 0x98
mov word [ebp - 0x2366], cx
mov dx, word [ebp - 0x2366]
mov word [ebp - 0x200e], dx
mov dword [ebp - 0x1e84], 0
jmp 0x1012e0ba
mov eax, dword [ebp - 0x1e84]
add eax, 1
mov dword [ebp - 0x1e84], eax
cmp dword [ebp - 0x1e84], 2
jae 0x1012e150
lea ecx, [ebp - 0x2010]
mov dword [ebp - 0x38d4], ecx
mov edx, dword [ebp - 0x1e84]
mov eax, dword [ebp - 0x38d4]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x38d8], ecx
mov edx, dword [ebp - 0x38d8]
mov ax, word [edx]
mov word [ebp - 0x2364], ax
mov cx, word [ebp - 0x2afe]
mov word [ebp - 0x1dda], cx
movzx edx, word [ebp - 0x2364]
xor edx, 0x98
mov word [ebp - 0x1dda], dx
lea eax, [ebp - 0x2010]
mov dword [ebp - 0x38dc], eax
mov ecx, dword [ebp - 0x1e84]
mov edx, dword [ebp - 0x38dc]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x38e0], eax
mov ecx, dword [ebp - 0x38e0]
mov dx, word [ebp - 0x1dda]
mov word [ecx], dx
jmp 0x1012e0ab
lea eax, [ebp - 0x2010]
mov dword [ebp - 0x38e4], eax
mov ecx, dword [ebp - 0x38e4]
mov dword [ebp - 0x2570], ecx
lea edx, [ebp - 0x3b30]
mov dword [ebp - 0x38e8], edx
movzx eax, byte [ebp - 0x21a7]
push eax
mov ecx, dword [ebp - 0x38e8]
call fcn.1008cde0
mov dword [ebp - 4], 0x1a
mov ecx, dword [ebp - 0x2570]
mov dword [ebp - 0x1e88], ecx
mov edx, dword [ebp - 0x1e88]
add edx, 2
mov dword [ebp - 0x38ec], edx
mov eax, dword [ebp - 0x1e88]
mov cx, word [eax]
mov word [ebp - 0x235e], cx
add dword [ebp - 0x1e88], 2
cmp word [ebp - 0x235e], 0
jne 0x1012e1a9
mov edx, dword [ebp - 0x1e88]
sub edx, dword [ebp - 0x38ec]
sar edx, 1
mov dword [ebp - 0x38f0], edx
mov eax, dword [ebp - 0x38f0]
mov dword [ebp - 0x38f4], eax
mov ecx, dword [ebp - 0x38f4]
mov dword [ebp - 0x38f8], ecx
mov edx, dword [ebp - 0x38f8]
push edx
mov eax, dword [ebp - 0x2570]
push eax
lea ecx, [ebp - 0x3b30]
call fcn.100b23d0
mov dword [ebp - 4], 0x1b
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.pitch]
mov byte [ebp - 0x780], al
movsx ecx, byte [ebp - 0x780]
xor ecx, 0xffffff98
mov byte [ebp - 0x781], cl
mov dl, byte [ebp - 0x781]
mov byte [ebp - 0x1db8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x788], cl
movsx edx, byte [ebp - 0x788]
xor edx, 0xffffff98
mov byte [ebp - 0x789], dl
mov al, byte [ebp - 0x789]
mov byte [ebp - 0x1db7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.pitch]
mov byte [ebp - 0x790], dl
movsx eax, byte [ebp - 0x790]
xor eax, 0xffffff98
mov byte [ebp - 0x791], al
mov cl, byte [ebp - 0x791]
mov byte [ebp - 0x1db6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x798], cl
movsx edx, byte [ebp - 0x798]
xor edx, 0xffffff98
mov byte [ebp - 0x799], dl
mov al, byte [ebp - 0x799]
mov byte [ebp - 0x1db5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.pitch]
mov byte [ebp - 0x7a0], dl
movsx eax, byte [ebp - 0x7a0]
xor eax, 0xffffff98
mov byte [ebp - 0x7a1], al
mov cl, byte [ebp - 0x7a1]
mov byte [ebp - 0x1db4], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x7a8], cl
movsx edx, byte [ebp - 0x7a8]
xor edx, 0xffffff98
mov byte [ebp - 0x7a9], dl
mov al, byte [ebp - 0x7a9]
mov byte [ebp - 0x1db3], al
mov dword [ebp - 0x1e8c], 0
jmp 0x1012e350
mov ecx, dword [ebp - 0x1e8c]
add ecx, 1
mov dword [ebp - 0x1e8c], ecx
cmp dword [ebp - 0x1e8c], 6
jae 0x1012e3d2
lea edx, [ebp - 0x1db8]
mov dword [ebp - 0x38fc], edx
mov eax, dword [ebp - 0x38fc]
add eax, dword [ebp - 0x1e8c]
mov dword [ebp - 0x258c], eax
mov ecx, dword [ebp - 0x258c]
mov dl, byte [ecx]
mov byte [ebp - 0x7b0], dl
mov al, byte [ebp - 0x21a8]
mov byte [ebp - 0x2b4], al
movsx ecx, byte [ebp - 0x7b0]
xor ecx, 0xffffff98
mov byte [ebp - 0x2b4], cl
lea edx, [ebp - 0x1db8]
mov dword [ebp - 0x2590], edx
mov eax, dword [ebp - 0x2590]
add eax, dword [ebp - 0x1e8c]
mov dword [ebp - 0x2594], eax
mov ecx, dword [ebp - 0x2594]
mov dl, byte [ebp - 0x2b4]
mov byte [ecx], dl
jmp 0x1012e341
lea eax, [ebp - 0x1db8]
mov dword [ebp - 0x2598], eax
mov ecx, dword [ebp - 0x2598]
mov dword [ebp - 0x256c], ecx
lea edx, [ebp - 0x3b18]
mov dword [ebp - 0x259c], edx
movzx eax, byte [ebp - 0x21a9]
push eax
mov ecx, dword [ebp - 0x259c]
call fcn.1008cde0
mov byte [ebp - 4], 0x1c
mov ecx, dword [ebp - 0x256c]
mov dword [ebp - 0x1e90], ecx
mov edx, dword [ebp - 0x1e90]
add edx, 1
mov dword [ebp - 0x25a0], edx
mov eax, dword [ebp - 0x1e90]
mov cl, byte [eax]
mov byte [ebp - 0x7b1], cl
add dword [ebp - 0x1e90], 1
cmp byte [ebp - 0x7b1], 0
jne 0x1012e428
mov edx, dword [ebp - 0x1e90]
sub edx, dword [ebp - 0x25a0]
mov dword [ebp - 0x25a4], edx
mov eax, dword [ebp - 0x25a4]
mov dword [ebp - 0x25a8], eax
mov ecx, dword [ebp - 0x25a8]
mov dword [ebp - 0x25ac], ecx
mov edx, dword [ebp - 0x25ac]
push edx
mov eax, dword [ebp - 0x256c]
push eax
lea ecx, [ebp - 0x3b18]
call fcn.1008ce30
mov byte [ebp - 4], 0x1d
lea ecx, [ebp - 0x3b00]
mov dword [ebp - 0x25b0], ecx
movzx edx, byte [ebp - 0x21aa]
push edx
mov ecx, dword [ebp - 0x25b0]
call fcn.1008cde0
mov byte [ebp - 4], 0x1e
mov dword [ebp - 0x1e94], str.pitch
mov eax, dword [ebp - 0x1e94]
add eax, 1
mov dword [ebp - 0x25b4], eax
mov ecx, dword [ebp - 0x1e94]
mov dl, byte [ecx]
mov byte [ebp - 0x7b2], dl
add dword [ebp - 0x1e94], 1
cmp byte [ebp - 0x7b2], 0
jne 0x1012e4c9
mov eax, dword [ebp - 0x1e94]
sub eax, dword [ebp - 0x25b4]
mov dword [ebp - 0x25b8], eax
mov ecx, dword [ebp - 0x25b8]
mov dword [ebp - 0x25bc], ecx
mov edx, dword [ebp - 0x25bc]
mov dword [ebp - 0x25c0], edx
mov eax, dword [ebp - 0x25c0]
push eax
push str.pitch
lea ecx, [ebp - 0x3b00]
call fcn.1008ce30
mov byte [ebp - 4], 0x1f
lea ecx, [ebp - 0x3b18]
push ecx
mov ecx, dword [ebp - 0x264]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x264]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x264]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1012e571
lea edx, [ebp - 0x3b00]
push edx
mov ecx, dword [ebp - 0x264]
add ecx, 0x88
call fcn.100ad110
mov eax, dword [ebp - 0x264]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1012e58b
mov dword [ebp - 0x2568], 0xf
jmp 0x1012e595
mov dword [ebp - 0x2568], 0
mov edx, dword [ebp - 0x264]
mov eax, dword [ebp - 0x2568]
mov dword [edx + 0xb8], eax
mov ecx, dword [ebp - 0x264]
mov edx, dword [ecx + 0xb8]
add edx, 8
mov eax, dword [ebp - 0x264]
mov dword [eax + 0x10], edx
mov ecx, dword [ebp - 0x264]
mov edx, dword [ebp - 0x264]
mov eax, dword [edx + 0x10]
mov dword [ecx + 0x14], eax
mov ecx, dword [ebp - 0x264]
movss xmm0, dword [0x10328b6c]
movss dword [ecx + 0x74], xmm0
mov edx, dword [ebp - 0x264]
movss xmm0, dword [0x10328a54]
movss dword [edx + 0x78], xmm0
mov eax, dword [ebp - 0x264]
xorps xmm0, xmm0
movss dword [eax + 0x70], xmm0
mov ecx, dword [ebp - 0x264]
mov dword [ecx + 0x84], 0
mov edx, dword [ebp - 0x264]
movss xmm0, dword [0x1032891c]
movss dword [edx + 0x7c], xmm0
lea eax, [ebp - 0x3b30]
push eax
mov ecx, dword [ebp - 0x264]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x1d
lea ecx, [ebp - 0x3b00]
call fcn.1008b960
mov byte [ebp - 4], 0x1b
lea ecx, [ebp - 0x3b18]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3b30]
call fcn.100ae140
mov ecx, dword [ebp - 0x200]
add ecx, 0x488
mov dword [ebp - 0x20], ecx
mov edx, dword [ebp - 0x20]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x20]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x20]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x20]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x20]
mov edx, dword [ebp - 0x200]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x200]
add ecx, 0x18
mov dword [ebp - 0x25c4], ecx
lea edx, [ebp - 0x20]
push edx
mov ecx, dword [ebp - 0x25c4]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x3e8
mov dword [ebp - 0x270], eax
lea ecx, [ebp - 0x21ab]
mov dword [ebp - 0x2640], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.stand]
mov byte [ebp - 0x7b8], cl
movsx edx, byte [ebp - 0x7b8]
xor edx, 0xffffff98
mov byte [ebp - 0x7b9], dl
mov al, byte [ebp - 0x7b9]
mov byte [ebp - 0x1dc0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.stand]
mov byte [ebp - 0x7c0], dl
movsx eax, byte [ebp - 0x7c0]
xor eax, 0xffffff98
mov byte [ebp - 0x7c1], al
mov cl, byte [ebp - 0x7c1]
mov byte [ebp - 0x1dbf], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.stand]
mov byte [ebp - 0x7c8], al
movsx ecx, byte [ebp - 0x7c8]
xor ecx, 0xffffff98
mov byte [ebp - 0x7c9], cl
mov dl, byte [ebp - 0x7c9]
mov byte [ebp - 0x1dbe], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.stand]
mov byte [ebp - 0x7d0], dl
movsx eax, byte [ebp - 0x7d0]
xor eax, 0xffffff98
mov byte [ebp - 0x7d1], al
mov cl, byte [ebp - 0x7d1]
mov byte [ebp - 0x1dbd], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.stand]
mov byte [ebp - 0x7d8], al
movsx ecx, byte [ebp - 0x7d8]
xor ecx, 0xffffff98
mov byte [ebp - 0x7d9], cl
mov dl, byte [ebp - 0x7d9]
mov byte [ebp - 0x1dbc], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.stand]
mov byte [ebp - 0x7e0], dl
movsx eax, byte [ebp - 0x7e0]
xor eax, 0xffffff98
mov byte [ebp - 0x7e1], al
mov cl, byte [ebp - 0x7e1]
mov byte [ebp - 0x1dbb], cl
mov dword [ebp - 0x1e98], 0
jmp 0x1012e82a
mov edx, dword [ebp - 0x1e98]
add edx, 1
mov dword [ebp - 0x1e98], edx
cmp dword [ebp - 0x1e98], 6
jae 0x1012e8ac
lea eax, [ebp - 0x1dc0]
mov dword [ebp - 0x25c8], eax
mov ecx, dword [ebp - 0x25c8]
add ecx, dword [ebp - 0x1e98]
mov dword [ebp - 0x25cc], ecx
mov edx, dword [ebp - 0x25cc]
mov al, byte [edx]
mov byte [ebp - 0x7e8], al
mov cl, byte [ebp - 0x21ac]
mov byte [ebp - 0x2b5], cl
movsx edx, byte [ebp - 0x7e8]
xor edx, 0xffffff98
mov byte [ebp - 0x2b5], dl
lea eax, [ebp - 0x1dc0]
mov dword [ebp - 0x25d0], eax
mov ecx, dword [ebp - 0x25d0]
add ecx, dword [ebp - 0x1e98]
mov dword [ebp - 0x25d4], ecx
mov edx, dword [ebp - 0x25d4]
mov al, byte [ebp - 0x2b5]
mov byte [edx], al
jmp 0x1012e81b
lea ecx, [ebp - 0x1dc0]
mov dword [ebp - 0x25d8], ecx
mov edx, dword [ebp - 0x25d8]
mov dword [ebp - 0x2564], edx
lea eax, [ebp - 0x4628]
mov dword [ebp - 0x25dc], eax
movzx ecx, byte [ebp - 0x21ad]
push ecx
mov ecx, dword [ebp - 0x25dc]
call fcn.1008cde0
mov dword [ebp - 4], 0x20
mov edx, dword [ebp - 0x2564]
mov dword [ebp - 0x1e9c], edx
mov eax, dword [ebp - 0x1e9c]
add eax, 1
mov dword [ebp - 0x25e0], eax
mov ecx, dword [ebp - 0x1e9c]
mov dl, byte [ecx]
mov byte [ebp - 0x7e9], dl
add dword [ebp - 0x1e9c], 1
cmp byte [ebp - 0x7e9], 0
jne 0x1012e905
mov eax, dword [ebp - 0x1e9c]
sub eax, dword [ebp - 0x25e0]
mov dword [ebp - 0x25e4], eax
mov ecx, dword [ebp - 0x25e4]
mov dword [ebp - 0x25e8], ecx
mov edx, dword [ebp - 0x25e8]
mov dword [ebp - 0x25ec], edx
mov eax, dword [ebp - 0x25ec]
push eax
mov ecx, dword [ebp - 0x2564]
push ecx
lea ecx, [ebp - 0x4628]
call fcn.1008ce30
mov dword [ebp - 4], 0x21
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.walk]
mov byte [ebp - 0x7f0], cl
movsx edx, byte [ebp - 0x7f0]
xor edx, 0xffffff98
mov byte [ebp - 0x7f1], dl
mov al, byte [ebp - 0x7f1]
mov byte [ebp - 0x1b08], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.walk]
mov byte [ebp - 0x7f8], dl
movsx eax, byte [ebp - 0x7f8]
xor eax, 0xffffff98
mov byte [ebp - 0x7f9], al
mov cl, byte [ebp - 0x7f9]
mov byte [ebp - 0x1b07], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.walk]
mov byte [ebp - 0x800], al
movsx ecx, byte [ebp - 0x800]
xor ecx, 0xffffff98
mov byte [ebp - 0x801], cl
mov dl, byte [ebp - 0x801]
mov byte [ebp - 0x1b06], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.walk]
mov byte [ebp - 0x808], dl
movsx eax, byte [ebp - 0x808]
xor eax, 0xffffff98
mov byte [ebp - 0x809], al
mov cl, byte [ebp - 0x809]
mov byte [ebp - 0x1b05], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.walk]
mov byte [ebp - 0x810], al
movsx ecx, byte [ebp - 0x810]
xor ecx, 0xffffff98
mov byte [ebp - 0x811], cl
mov dl, byte [ebp - 0x811]
mov byte [ebp - 0x1b04], dl
mov dword [ebp - 0x1ea0], 0
jmp 0x1012ea77
mov eax, dword [ebp - 0x1ea0]
add eax, 1
mov dword [ebp - 0x1ea0], eax
cmp dword [ebp - 0x1ea0], 5
jae 0x1012eaf9
lea ecx, [ebp - 0x1b08]
mov dword [ebp - 0x25f0], ecx
mov edx, dword [ebp - 0x25f0]
add edx, dword [ebp - 0x1ea0]
mov dword [ebp - 0x25f4], edx
mov eax, dword [ebp - 0x25f4]
mov cl, byte [eax]
mov byte [ebp - 0x818], cl
mov dl, byte [ebp - 0x21ae]
mov byte [ebp - 0x2b6], dl
movsx eax, byte [ebp - 0x818]
xor eax, 0xffffff98
mov byte [ebp - 0x2b6], al
lea ecx, [ebp - 0x1b08]
mov dword [ebp - 0x25f8], ecx
mov edx, dword [ebp - 0x25f8]
add edx, dword [ebp - 0x1ea0]
mov dword [ebp - 0x25fc], edx
mov eax, dword [ebp - 0x25fc]
mov cl, byte [ebp - 0x2b6]
mov byte [eax], cl
jmp 0x1012ea68
lea edx, [ebp - 0x1b08]
mov dword [ebp - 0x2600], edx
mov eax, dword [ebp - 0x2600]
mov dword [ebp - 0x2554], eax
lea ecx, [ebp - 0x4610]
mov dword [ebp - 0x2604], ecx
movzx edx, byte [ebp - 0x21af]
push edx
mov ecx, dword [ebp - 0x2604]
call fcn.1008cde0
mov byte [ebp - 4], 0x22
mov eax, dword [ebp - 0x2554]
mov dword [ebp - 0x1ea4], eax
mov ecx, dword [ebp - 0x1ea4]
add ecx, 1
mov dword [ebp - 0x2608], ecx
mov edx, dword [ebp - 0x1ea4]
mov al, byte [edx]
mov byte [ebp - 0x819], al
add dword [ebp - 0x1ea4], 1
cmp byte [ebp - 0x819], 0
jne 0x1012eb4f
mov ecx, dword [ebp - 0x1ea4]
sub ecx, dword [ebp - 0x2608]
mov dword [ebp - 0x260c], ecx
mov edx, dword [ebp - 0x260c]
mov dword [ebp - 0x2610], edx
mov eax, dword [ebp - 0x2610]
mov dword [ebp - 0x2614], eax
mov ecx, dword [ebp - 0x2614]
push ecx
mov edx, dword [ebp - 0x2554]
push edx
lea ecx, [ebp - 0x4610]
call fcn.1008ce30
mov byte [ebp - 4], 0x23
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x10323e40]
mov byte [ebp - 0x820], dl
movsx eax, byte [ebp - 0x820]
xor eax, 0xffffff98
mov byte [ebp - 0x821], al
mov cl, byte [ebp - 0x821]
mov byte [ebp - 0x1ac4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x10323e40]
mov byte [ebp - 0x828], al
movsx ecx, byte [ebp - 0x828]
xor ecx, 0xffffff98
mov byte [ebp - 0x829], cl
mov dl, byte [ebp - 0x829]
mov byte [ebp - 0x1ac3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x10323e40]
mov byte [ebp - 0x830], cl
movsx edx, byte [ebp - 0x830]
xor edx, 0xffffff98
mov byte [ebp - 0x831], dl
mov al, byte [ebp - 0x831]
mov byte [ebp - 0x1ac2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x10323e40]
mov byte [ebp - 0x838], al
movsx ecx, byte [ebp - 0x838]
xor ecx, 0xffffff98
mov byte [ebp - 0x839], cl
mov dl, byte [ebp - 0x839]
mov byte [ebp - 0x1ac1], dl
mov dword [ebp - 0x1ea8], 0
jmp 0x1012ec8e
mov eax, dword [ebp - 0x1ea8]
add eax, 1
mov dword [ebp - 0x1ea8], eax
cmp dword [ebp - 0x1ea8], 4
jae 0x1012ed10
lea ecx, [ebp - 0x1ac4]
mov dword [ebp - 0x2618], ecx
mov edx, dword [ebp - 0x2618]
add edx, dword [ebp - 0x1ea8]
mov dword [ebp - 0x261c], edx
mov eax, dword [ebp - 0x261c]
mov cl, byte [eax]
mov byte [ebp - 0x840], cl
mov dl, byte [ebp - 0x21b0]
mov byte [ebp - 0x2b7], dl
movsx eax, byte [ebp - 0x840]
xor eax, 0xffffff98
mov byte [ebp - 0x2b7], al
lea ecx, [ebp - 0x1ac4]
mov dword [ebp - 0x2620], ecx
mov edx, dword [ebp - 0x2620]
add edx, dword [ebp - 0x1ea8]
mov dword [ebp - 0x2624], edx
mov eax, dword [ebp - 0x2624]
mov cl, byte [ebp - 0x2b7]
mov byte [eax], cl
jmp 0x1012ec7f
lea edx, [ebp - 0x1ac4]
mov dword [ebp - 0x2628], edx
mov eax, dword [ebp - 0x2628]
mov dword [ebp - 0x2550], eax
lea ecx, [ebp - 0x45f8]
mov dword [ebp - 0x262c], ecx
movzx edx, byte [ebp - 0x21b1]
push edx
mov ecx, dword [ebp - 0x262c]
call fcn.1008cde0
mov byte [ebp - 4], 0x24
mov eax, dword [ebp - 0x2550]
mov dword [ebp - 0x1eac], eax
mov ecx, dword [ebp - 0x1eac]
add ecx, 1
mov dword [ebp - 0x2630], ecx
mov edx, dword [ebp - 0x1eac]
mov al, byte [edx]
mov byte [ebp - 0x841], al
add dword [ebp - 0x1eac], 1
cmp byte [ebp - 0x841], 0
jne 0x1012ed66
mov ecx, dword [ebp - 0x1eac]
sub ecx, dword [ebp - 0x2630]
mov dword [ebp - 0x2634], ecx
mov edx, dword [ebp - 0x2634]
mov dword [ebp - 0x2638], edx
mov eax, dword [ebp - 0x2638]
mov dword [ebp - 0x263c], eax
mov ecx, dword [ebp - 0x263c]
push ecx
mov edx, dword [ebp - 0x2550]
push edx
lea ecx, [ebp - 0x45f8]
call fcn.1008ce30
mov dword [ebp - 4], 0x25
lea eax, [ebp - 0x4628]
mov dword [ebp - 0x3780], eax
lea ecx, [ebp - 0x45e0]
mov dword [ebp - 0x377c], ecx
mov edx, dword [ebp - 0x3780]
mov eax, dword [ebp - 0x377c]
mov dword [ebp - 0x3788], edx
mov dword [ebp - 0x3784], eax
mov ecx, dword [ebp - 0x2640]
push ecx
mov edx, dword [ebp - 0x3784]
push edx
mov eax, dword [ebp - 0x3788]
push eax
lea ecx, [ebp - 0x3914]
call fcn.10260fe0
mov byte [ebp - 4], 0x26
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.mode]
mov byte [ebp - 0x848], al
movsx ecx, byte [ebp - 0x848]
xor ecx, 0xffffff98
mov byte [ebp - 0x849], cl
mov dl, byte [ebp - 0x849]
mov byte [ebp - 0x1b20], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.mode]
mov byte [ebp - 0x850], cl
movsx edx, byte [ebp - 0x850]
xor edx, 0xffffff98
mov byte [ebp - 0x851], dl
mov al, byte [ebp - 0x851]
mov byte [ebp - 0x1b1f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.mode]
mov byte [ebp - 0x858], dl
movsx eax, byte [ebp - 0x858]
xor eax, 0xffffff98
mov byte [ebp - 0x859], al
mov cl, byte [ebp - 0x859]
mov byte [ebp - 0x1b1e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.mode]
mov byte [ebp - 0x860], cl
movsx edx, byte [ebp - 0x860]
xor edx, 0xffffff98
mov byte [ebp - 0x861], dl
mov al, byte [ebp - 0x861]
mov byte [ebp - 0x1b1d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.mode]
mov byte [ebp - 0x868], dl
movsx eax, byte [ebp - 0x868]
xor eax, 0xffffff98
mov byte [ebp - 0x869], al
mov cl, byte [ebp - 0x869]
mov byte [ebp - 0x1b1c], cl
mov dword [ebp - 0x1eb0], 0
jmp 0x1012ef2c
mov edx, dword [ebp - 0x1eb0]
add edx, 1
mov dword [ebp - 0x1eb0], edx
cmp dword [ebp - 0x1eb0], 5
jae 0x1012efae
lea eax, [ebp - 0x1b20]
mov dword [ebp - 0x2644], eax
mov ecx, dword [ebp - 0x2644]
add ecx, dword [ebp - 0x1eb0]
mov dword [ebp - 0x2648], ecx
mov edx, dword [ebp - 0x2648]
mov al, byte [edx]
mov byte [ebp - 0x870], al
mov cl, byte [ebp - 0x21b2]
mov byte [ebp - 0x2b8], cl
movsx edx, byte [ebp - 0x870]
xor edx, 0xffffff98
mov byte [ebp - 0x2b8], dl
lea eax, [ebp - 0x1b20]
mov dword [ebp - 0x264c], eax
mov ecx, dword [ebp - 0x264c]
add ecx, dword [ebp - 0x1eb0]
mov dword [ebp - 0x2650], ecx
mov edx, dword [ebp - 0x2650]
mov al, byte [ebp - 0x2b8]
mov byte [edx], al
jmp 0x1012ef1d
lea ecx, [ebp - 0x1b20]
mov dword [ebp - 0x2654], ecx
mov edx, dword [ebp - 0x2654]
mov dword [ebp - 0x2538], edx
lea eax, [ebp - 0x3b60]
mov dword [ebp - 0x2658], eax
movzx ecx, byte [ebp - 0x21b3]
push ecx
mov ecx, dword [ebp - 0x2658]
call fcn.1008cde0
mov byte [ebp - 4], 0x27
mov edx, dword [ebp - 0x2538]
mov dword [ebp - 0x1eb4], edx
mov eax, dword [ebp - 0x1eb4]
add eax, 1
mov dword [ebp - 0x265c], eax
mov ecx, dword [ebp - 0x1eb4]
mov dl, byte [ecx]
mov byte [ebp - 0x871], dl
add dword [ebp - 0x1eb4], 1
cmp byte [ebp - 0x871], 0
jne 0x1012f004
mov eax, dword [ebp - 0x1eb4]
sub eax, dword [ebp - 0x265c]
mov dword [ebp - 0x2660], eax
mov ecx, dword [ebp - 0x2660]
mov dword [ebp - 0x2664], ecx
mov edx, dword [ebp - 0x2664]
mov dword [ebp - 0x2668], edx
mov eax, dword [ebp - 0x2668]
push eax
mov ecx, dword [ebp - 0x2538]
push ecx
lea ecx, [ebp - 0x3b60]
call fcn.1008ce30
mov byte [ebp - 4], 0x28
lea edx, [ebp - 0x3b48]
mov dword [ebp - 0x266c], edx
movzx eax, byte [ebp - 0x21b4]
push eax
mov ecx, dword [ebp - 0x266c]
call fcn.1008cde0
mov byte [ebp - 4], 0x29
mov dword [ebp - 0x1eb8], str.state
mov ecx, dword [ebp - 0x1eb8]
add ecx, 1
mov dword [ebp - 0x2670], ecx
mov edx, dword [ebp - 0x1eb8]
mov al, byte [edx]
mov byte [ebp - 0x872], al
add dword [ebp - 0x1eb8], 1
cmp byte [ebp - 0x872], 0
jne 0x1012f0a5
mov ecx, dword [ebp - 0x1eb8]
sub ecx, dword [ebp - 0x2670]
mov dword [ebp - 0x2674], ecx
mov edx, dword [ebp - 0x2674]
mov dword [ebp - 0x2678], edx
mov eax, dword [ebp - 0x2678]
mov dword [ebp - 0x267c], eax
mov ecx, dword [ebp - 0x267c]
push ecx
push str.state
lea ecx, [ebp - 0x3b48]
call fcn.1008ce30
mov byte [ebp - 4], 0x2a
lea edx, [ebp - 0x3b60]
push edx
mov ecx, dword [ebp - 0x270]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x270]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x270]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1012f14a
lea eax, [ebp - 0x3b48]
push eax
mov ecx, dword [ebp - 0x270]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x270]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1012f164
mov dword [ebp - 0x2524], 0xf
jmp 0x1012f16e
mov dword [ebp - 0x2524], 0
mov eax, dword [ebp - 0x270]
mov ecx, dword [ebp - 0x2524]
mov dword [eax + 0x9c], ecx
mov edx, dword [ebp - 0x270]
mov eax, dword [edx + 0x9c]
add eax, 0x14
mov dword [ebp - 0x2520], eax
mov ecx, dword [ebp - 0x270]
mov edx, dword [ebp - 0x2520]
mov dword [ecx + 0x10], edx
mov eax, dword [ebp - 0x270]
mov ecx, dword [ebp - 0x2520]
mov dword [eax + 0x14], ecx
lea edx, [ebp - 0x3914]
mov dword [ebp - 0x251c], edx
mov eax, dword [ebp - 0x251c]
mov ecx, dword [eax]
mov dword [ebp - 0x200c], ecx
mov edx, dword [ebp - 0x251c]
mov eax, dword [edx + 4]
mov dword [ebp - 0x2680], eax
jmp 0x1012f1ed
mov ecx, dword [ebp - 0x200c]
add ecx, 0x18
mov dword [ebp - 0x200c], ecx
mov edx, dword [ebp - 0x200c]
cmp edx, dword [ebp - 0x2680]
je 0x1012f22d
mov eax, dword [ebp - 0x200c]
mov dword [ebp - 0x2684], eax
mov ecx, dword [ebp - 0x270]
add ecx, 0x88
mov dword [ebp - 0x2688], ecx
mov edx, dword [ebp - 0x2684]
push edx
mov ecx, dword [ebp - 0x2688]
call fcn.100fca00
jmp 0x1012f1de
mov eax, dword [ebp - 0x270]
add eax, 0x88
mov dword [ebp - 0x2518], eax
mov ecx, dword [ebp - 0x2518]
mov edx, dword [ebp - 0x2518]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x268c], eax
cmp dword [ebp - 0x268c], 0
jbe 0x1012f276
mov edx, dword [ebp - 0x270]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x28
lea ecx, [ebp - 0x3b48]
call fcn.1008b960
mov byte [ebp - 4], 0x26
lea ecx, [ebp - 0x3b60]
call fcn.1008b960
mov byte [ebp - 4], 0x25
lea ecx, [ebp - 0x3914]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 3
push 0x18
lea eax, [ebp - 0x4628]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x200]
add ecx, 0x3e8
mov dword [ebp - 0x2514], ecx
mov edx, 8
not edx
mov eax, dword [ebp - 0x2514]
and edx, dword [eax + 0x50]
mov ecx, dword [ebp - 0x2514]
mov dword [ecx + 0x50], edx
mov edx, dword [ebp - 0x200]
add edx, 0x3e8
mov dword [ebp - 0x1c], edx
mov eax, dword [ebp - 0x1c]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x1c]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x1c]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x1c]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x1c]
mov eax, dword [ebp - 0x200]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x200]
add edx, 0x18
mov dword [ebp - 0x2690], edx
lea eax, [ebp - 0x1c]
push eax
mov ecx, dword [ebp - 0x2690]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0x544
mov dword [ebp - 0x274], ecx
lea edx, [ebp - 0x21b5]
mov dword [ebp - 0x27ac], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x10323e3c]
mov byte [ebp - 0x878], dl
movsx eax, byte [ebp - 0x878]
xor eax, 0xffffff98
mov byte [ebp - 0x879], al
mov cl, byte [ebp - 0x879]
mov byte [ebp - 0x1ad4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x10323e3c]
mov byte [ebp - 0x880], al
movsx ecx, byte [ebp - 0x880]
xor ecx, 0xffffff98
mov byte [ebp - 0x881], cl
mov dl, byte [ebp - 0x881]
mov byte [ebp - 0x1ad3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x10323e3c]
mov byte [ebp - 0x888], cl
movsx edx, byte [ebp - 0x888]
xor edx, 0xffffff98
mov byte [ebp - 0x889], dl
mov al, byte [ebp - 0x889]
mov byte [ebp - 0x1ad2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x10323e3c]
mov byte [ebp - 0x890], al
movsx ecx, byte [ebp - 0x890]
xor ecx, 0xffffff98
mov byte [ebp - 0x891], cl
mov dl, byte [ebp - 0x891]
mov byte [ebp - 0x1ad1], dl
mov dword [ebp - 0x1ebc], 0
jmp 0x1012f445
mov eax, dword [ebp - 0x1ebc]
add eax, 1
mov dword [ebp - 0x1ebc], eax
cmp dword [ebp - 0x1ebc], 4
jae 0x1012f4c7
lea ecx, [ebp - 0x1ad4]
mov dword [ebp - 0x2694], ecx
mov edx, dword [ebp - 0x2694]
add edx, dword [ebp - 0x1ebc]
mov dword [ebp - 0x2698], edx
mov eax, dword [ebp - 0x2698]
mov cl, byte [eax]
mov byte [ebp - 0x898], cl
mov dl, byte [ebp - 0x21b6]
mov byte [ebp - 0x2b9], dl
movsx eax, byte [ebp - 0x898]
xor eax, 0xffffff98
mov byte [ebp - 0x2b9], al
lea ecx, [ebp - 0x1ad4]
mov dword [ebp - 0x269c], ecx
mov edx, dword [ebp - 0x269c]
add edx, dword [ebp - 0x1ebc]
mov dword [ebp - 0x26a0], edx
mov eax, dword [ebp - 0x26a0]
mov cl, byte [ebp - 0x2b9]
mov byte [eax], cl
jmp 0x1012f436
lea edx, [ebp - 0x1ad4]
mov dword [ebp - 0x26a4], edx
mov eax, dword [ebp - 0x26a4]
mov dword [ebp - 0x2508], eax
lea ecx, [ebp - 0x47a8]
mov dword [ebp - 0x26a8], ecx
movzx edx, byte [ebp - 0x21b7]
push edx
mov ecx, dword [ebp - 0x26a8]
call fcn.1008cde0
mov dword [ebp - 4], 0x2b
mov eax, dword [ebp - 0x2508]
mov dword [ebp - 0x1ec0], eax
mov ecx, dword [ebp - 0x1ec0]
add ecx, 1
mov dword [ebp - 0x26ac], ecx
mov edx, dword [ebp - 0x1ec0]
mov al, byte [edx]
mov byte [ebp - 0x899], al
add dword [ebp - 0x1ec0], 1
cmp byte [ebp - 0x899], 0
jne 0x1012f520
mov ecx, dword [ebp - 0x1ec0]
sub ecx, dword [ebp - 0x26ac]
mov dword [ebp - 0x26b0], ecx
mov edx, dword [ebp - 0x26b0]
mov dword [ebp - 0x26b4], edx
mov eax, dword [ebp - 0x26b4]
mov dword [ebp - 0x26b8], eax
mov ecx, dword [ebp - 0x26b8]
push ecx
mov edx, dword [ebp - 0x2508]
push edx
lea ecx, [ebp - 0x47a8]
call fcn.1008ce30
mov dword [ebp - 4], 0x2c
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.static]
mov byte [ebp - 0x8a0], dl
movsx eax, byte [ebp - 0x8a0]
xor eax, 0xffffff98
mov byte [ebp - 0x8a1], al
mov cl, byte [ebp - 0x8a1]
mov byte [ebp - 0x1f44], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.static]
mov byte [ebp - 0x8a8], al
movsx ecx, byte [ebp - 0x8a8]
xor ecx, 0xffffff98
mov byte [ebp - 0x8a9], cl
mov dl, byte [ebp - 0x8a9]
mov byte [ebp - 0x1f43], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.static]
mov byte [ebp - 0x8b0], cl
movsx edx, byte [ebp - 0x8b0]
xor edx, 0xffffff98
mov byte [ebp - 0x8b1], dl
mov al, byte [ebp - 0x8b1]
mov byte [ebp - 0x1f42], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.static]
mov byte [ebp - 0x8b8], al
movsx ecx, byte [ebp - 0x8b8]
xor ecx, 0xffffff98
mov byte [ebp - 0x8b9], cl
mov dl, byte [ebp - 0x8b9]
mov byte [ebp - 0x1f41], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.static]
mov byte [ebp - 0x8c0], cl
movsx edx, byte [ebp - 0x8c0]
xor edx, 0xffffff98
mov byte [ebp - 0x8c1], dl
mov al, byte [ebp - 0x8c1]
mov byte [ebp - 0x1f40], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.static]
mov byte [ebp - 0x8c8], al
movsx ecx, byte [ebp - 0x8c8]
xor ecx, 0xffffff98
mov byte [ebp - 0x8c9], cl
mov dl, byte [ebp - 0x8c9]
mov byte [ebp - 0x1f3f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.static]
mov byte [ebp - 0x8d0], dl
movsx eax, byte [ebp - 0x8d0]
xor eax, 0xffffff98
mov byte [ebp - 0x8d1], al
mov cl, byte [ebp - 0x8d1]
mov byte [ebp - 0x1f3e], cl
mov dword [ebp - 0x1ec4], 0
jmp 0x1012f6f2
mov edx, dword [ebp - 0x1ec4]
add edx, 1
mov dword [ebp - 0x1ec4], edx
cmp dword [ebp - 0x1ec4], 7
jae 0x1012f774
lea eax, [ebp - 0x1f44]
mov dword [ebp - 0x26bc], eax
mov ecx, dword [ebp - 0x26bc]
add ecx, dword [ebp - 0x1ec4]
mov dword [ebp - 0x26c0], ecx
mov edx, dword [ebp - 0x26c0]
mov al, byte [edx]
mov byte [ebp - 0x8d8], al
mov cl, byte [ebp - 0x21b8]
mov byte [ebp - 0x2ba], cl
movsx edx, byte [ebp - 0x8d8]
xor edx, 0xffffff98
mov byte [ebp - 0x2ba], dl
lea eax, [ebp - 0x1f44]
mov dword [ebp - 0x26c4], eax
mov ecx, dword [ebp - 0x26c4]
add ecx, dword [ebp - 0x1ec4]
mov dword [ebp - 0x26c8], ecx
mov edx, dword [ebp - 0x26c8]
mov al, byte [ebp - 0x2ba]
mov byte [edx], al
jmp 0x1012f6e3
lea ecx, [ebp - 0x1f44]
mov dword [ebp - 0x26cc], ecx
mov edx, dword [ebp - 0x26cc]
mov dword [ebp - 0x2504], edx
lea eax, [ebp - 0x4790]
mov dword [ebp - 0x26d0], eax
movzx ecx, byte [ebp - 0x21b9]
push ecx
mov ecx, dword [ebp - 0x26d0]
call fcn.1008cde0
mov byte [ebp - 4], 0x2d
mov edx, dword [ebp - 0x2504]
mov dword [ebp - 0x1ec8], edx
mov eax, dword [ebp - 0x1ec8]
add eax, 1
mov dword [ebp - 0x26d4], eax
mov ecx, dword [ebp - 0x1ec8]
mov dl, byte [ecx]
mov byte [ebp - 0x8d9], dl
add dword [ebp - 0x1ec8], 1
cmp byte [ebp - 0x8d9], 0
jne 0x1012f7ca
mov eax, dword [ebp - 0x1ec8]
sub eax, dword [ebp - 0x26d4]
mov dword [ebp - 0x26d8], eax
mov ecx, dword [ebp - 0x26d8]
mov dword [ebp - 0x26dc], ecx
mov edx, dword [ebp - 0x26dc]
mov dword [ebp - 0x26e0], edx
mov eax, dword [ebp - 0x26e0]
push eax
mov ecx, dword [ebp - 0x2504]
push ecx
lea ecx, [ebp - 0x4790]
call fcn.1008ce30
mov byte [ebp - 4], 0x2e
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.jitter]
mov byte [ebp - 0x8e0], cl
movsx edx, byte [ebp - 0x8e0]
xor edx, 0xffffff98
mov byte [ebp - 0x8e1], dl
mov al, byte [ebp - 0x8e1]
mov byte [ebp - 0x1f3c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.jitter]
mov byte [ebp - 0x8e8], dl
movsx eax, byte [ebp - 0x8e8]
xor eax, 0xffffff98
mov byte [ebp - 0x8e9], al
mov cl, byte [ebp - 0x8e9]
mov byte [ebp - 0x1f3b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.jitter]
mov byte [ebp - 0x8f0], al
movsx ecx, byte [ebp - 0x8f0]
xor ecx, 0xffffff98
mov byte [ebp - 0x8f1], cl
mov dl, byte [ebp - 0x8f1]
mov byte [ebp - 0x1f3a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.jitter]
mov byte [ebp - 0x8f8], dl
movsx eax, byte [ebp - 0x8f8]
xor eax, 0xffffff98
mov byte [ebp - 0x8f9], al
mov cl, byte [ebp - 0x8f9]
mov byte [ebp - 0x1f39], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.jitter]
mov byte [ebp - 0x900], al
movsx ecx, byte [ebp - 0x900]
xor ecx, 0xffffff98
mov byte [ebp - 0x901], cl
mov dl, byte [ebp - 0x901]
mov byte [ebp - 0x1f38], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.jitter]
mov byte [ebp - 0x908], dl
movsx eax, byte [ebp - 0x908]
xor eax, 0xffffff98
mov byte [ebp - 0x909], al
mov cl, byte [ebp - 0x909]
mov byte [ebp - 0x1f37], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.jitter]
mov byte [ebp - 0x910], cl
movsx edx, byte [ebp - 0x910]
xor edx, 0xffffff98
mov byte [ebp - 0x911], dl
mov al, byte [ebp - 0x911]
mov byte [ebp - 0x1f36], al
mov dword [ebp - 0x1ecc], 0
jmp 0x1012f999
mov ecx, dword [ebp - 0x1ecc]
add ecx, 1
mov dword [ebp - 0x1ecc], ecx
cmp dword [ebp - 0x1ecc], 7
jae 0x1012fa1b
lea edx, [ebp - 0x1f3c]
mov dword [ebp - 0x26e4], edx
mov eax, dword [ebp - 0x26e4]
add eax, dword [ebp - 0x1ecc]
mov dword [ebp - 0x26e8], eax
mov ecx, dword [ebp - 0x26e8]
mov dl, byte [ecx]
mov byte [ebp - 0x918], dl
mov al, byte [ebp - 0x21ba]
mov byte [ebp - 0x2bb], al
movsx ecx, byte [ebp - 0x918]
xor ecx, 0xffffff98
mov byte [ebp - 0x2bb], cl
lea edx, [ebp - 0x1f3c]
mov dword [ebp - 0x26ec], edx
mov eax, dword [ebp - 0x26ec]
add eax, dword [ebp - 0x1ecc]
mov dword [ebp - 0x26f0], eax
mov ecx, dword [ebp - 0x26f0]
mov dl, byte [ebp - 0x2bb]
mov byte [ecx], dl
jmp 0x1012f98a
lea eax, [ebp - 0x1f3c]
mov dword [ebp - 0x26f4], eax
mov ecx, dword [ebp - 0x26f4]
mov dword [ebp - 0x24d0], ecx
lea edx, [ebp - 0x4778]
mov dword [ebp - 0x26f8], edx
movzx eax, byte [ebp - 0x21bb]
push eax
mov ecx, dword [ebp - 0x26f8]
call fcn.1008cde0
mov byte [ebp - 4], 0x2f
mov ecx, dword [ebp - 0x24d0]
mov dword [ebp - 0x1ed0], ecx
mov edx, dword [ebp - 0x1ed0]
add edx, 1
mov dword [ebp - 0x26fc], edx
mov eax, dword [ebp - 0x1ed0]
mov cl, byte [eax]
mov byte [ebp - 0x919], cl
add dword [ebp - 0x1ed0], 1
cmp byte [ebp - 0x919], 0
jne 0x1012fa71
mov edx, dword [ebp - 0x1ed0]
sub edx, dword [ebp - 0x26fc]
mov dword [ebp - 0x2700], edx
mov eax, dword [ebp - 0x2700]
mov dword [ebp - 0x2704], eax
mov ecx, dword [ebp - 0x2704]
mov dword [ebp - 0x2708], ecx
mov edx, dword [ebp - 0x2708]
push edx
mov eax, dword [ebp - 0x24d0]
push eax
lea ecx, [ebp - 0x4778]
call fcn.1008ce30
mov byte [ebp - 4], 0x30
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.rotate]
mov byte [ebp - 0x920], al
movsx ecx, byte [ebp - 0x920]
xor ecx, 0xffffff98
mov byte [ebp - 0x921], cl
mov dl, byte [ebp - 0x921]
mov byte [ebp - 0x1f7c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.rotate]
mov byte [ebp - 0x928], cl
movsx edx, byte [ebp - 0x928]
xor edx, 0xffffff98
mov byte [ebp - 0x929], dl
mov al, byte [ebp - 0x929]
mov byte [ebp - 0x1f7b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.rotate]
mov byte [ebp - 0x930], dl
movsx eax, byte [ebp - 0x930]
xor eax, 0xffffff98
mov byte [ebp - 0x931], al
mov cl, byte [ebp - 0x931]
mov byte [ebp - 0x1f7a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.rotate]
mov byte [ebp - 0x938], cl
movsx edx, byte [ebp - 0x938]
xor edx, 0xffffff98
mov byte [ebp - 0x939], dl
mov al, byte [ebp - 0x939]
mov byte [ebp - 0x1f79], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.rotate]
mov byte [ebp - 0x940], dl
movsx eax, byte [ebp - 0x940]
xor eax, 0xffffff98
mov byte [ebp - 0x941], al
mov cl, byte [ebp - 0x941]
mov byte [ebp - 0x1f78], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.rotate]
mov byte [ebp - 0x948], cl
movsx edx, byte [ebp - 0x948]
xor edx, 0xffffff98
mov byte [ebp - 0x949], dl
mov al, byte [ebp - 0x949]
mov byte [ebp - 0x1f77], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.rotate]
mov byte [ebp - 0x950], al
movsx ecx, byte [ebp - 0x950]
xor ecx, 0xffffff98
mov byte [ebp - 0x951], cl
mov dl, byte [ebp - 0x951]
mov byte [ebp - 0x1f76], dl
mov dword [ebp - 0x1ed4], 0
jmp 0x1012fc40
mov eax, dword [ebp - 0x1ed4]
add eax, 1
mov dword [ebp - 0x1ed4], eax
cmp dword [ebp - 0x1ed4], 7
jae 0x1012fcc2
lea ecx, [ebp - 0x1f7c]
mov dword [ebp - 0x270c], ecx
mov edx, dword [ebp - 0x270c]
add edx, dword [ebp - 0x1ed4]
mov dword [ebp - 0x2710], edx
mov eax, dword [ebp - 0x2710]
mov cl, byte [eax]
mov byte [ebp - 0x958], cl
mov dl, byte [ebp - 0x21bc]
mov byte [ebp - 0x2bc], dl
movsx eax, byte [ebp - 0x958]
xor eax, 0xffffff98
mov byte [ebp - 0x2bc], al
lea ecx, [ebp - 0x1f7c]
mov dword [ebp - 0x2714], ecx
mov edx, dword [ebp - 0x2714]
add edx, dword [ebp - 0x1ed4]
mov dword [ebp - 0x2718], edx
mov eax, dword [ebp - 0x2718]
mov cl, byte [ebp - 0x2bc]
mov byte [eax], cl
jmp 0x1012fc31
lea edx, [ebp - 0x1f7c]
mov dword [ebp - 0x271c], edx
mov eax, dword [ebp - 0x271c]
mov dword [ebp - 0x24b4], eax
lea ecx, [ebp - 0x4760]
mov dword [ebp - 0x2720], ecx
movzx edx, byte [ebp - 0x21bd]
push edx
mov ecx, dword [ebp - 0x2720]
call fcn.1008cde0
mov byte [ebp - 4], 0x31
mov eax, dword [ebp - 0x24b4]
mov dword [ebp - 0x1ed8], eax
mov ecx, dword [ebp - 0x1ed8]
add ecx, 1
mov dword [ebp - 0x2724], ecx
mov edx, dword [ebp - 0x1ed8]
mov al, byte [edx]
mov byte [ebp - 0x959], al
add dword [ebp - 0x1ed8], 1
cmp byte [ebp - 0x959], 0
jne 0x1012fd18
mov ecx, dword [ebp - 0x1ed8]
sub ecx, dword [ebp - 0x2724]
mov dword [ebp - 0x2728], ecx
mov edx, dword [ebp - 0x2728]
mov dword [ebp - 0x272c], edx
mov eax, dword [ebp - 0x272c]
mov dword [ebp - 0x2730], eax
mov ecx, dword [ebp - 0x2730]
push ecx
mov edx, dword [ebp - 0x24b4]
push edx
lea ecx, [ebp - 0x4760]
call fcn.1008ce30
mov byte [ebp - 4], 0x32
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x960], dl
movsx eax, byte [ebp - 0x960]
xor eax, 0xffffff98
mov byte [ebp - 0x961], al
mov cl, byte [ebp - 0x961]
mov byte [ebp - 0x1f74], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.random]
mov byte [ebp - 0x968], al
movsx ecx, byte [ebp - 0x968]
xor ecx, 0xffffff98
mov byte [ebp - 0x969], cl
mov dl, byte [ebp - 0x969]
mov byte [ebp - 0x1f73], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.random]
mov byte [ebp - 0x970], cl
movsx edx, byte [ebp - 0x970]
xor edx, 0xffffff98
mov byte [ebp - 0x971], dl
mov al, byte [ebp - 0x971]
mov byte [ebp - 0x1f72], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.random]
mov byte [ebp - 0x978], al
movsx ecx, byte [ebp - 0x978]
xor ecx, 0xffffff98
mov byte [ebp - 0x979], cl
mov dl, byte [ebp - 0x979]
mov byte [ebp - 0x1f71], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.random]
mov byte [ebp - 0x980], cl
movsx edx, byte [ebp - 0x980]
xor edx, 0xffffff98
mov byte [ebp - 0x981], dl
mov al, byte [ebp - 0x981]
mov byte [ebp - 0x1f70], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.random]
mov byte [ebp - 0x988], al
movsx ecx, byte [ebp - 0x988]
xor ecx, 0xffffff98
mov byte [ebp - 0x989], cl
mov dl, byte [ebp - 0x989]
mov byte [ebp - 0x1f6f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x990], dl
movsx eax, byte [ebp - 0x990]
xor eax, 0xffffff98
mov byte [ebp - 0x991], al
mov cl, byte [ebp - 0x991]
mov byte [ebp - 0x1f6e], cl
mov dword [ebp - 0x1edc], 0
jmp 0x1012fee7
mov edx, dword [ebp - 0x1edc]
add edx, 1
mov dword [ebp - 0x1edc], edx
cmp dword [ebp - 0x1edc], 7
jae 0x1012ff69
lea eax, [ebp - 0x1f74]
mov dword [ebp - 0x2734], eax
mov ecx, dword [ebp - 0x2734]
add ecx, dword [ebp - 0x1edc]
mov dword [ebp - 0x2738], ecx
mov edx, dword [ebp - 0x2738]
mov al, byte [edx]
mov byte [ebp - 0x998], al
mov cl, byte [ebp - 0x21be]
mov byte [ebp - 0x2bd], cl
movsx edx, byte [ebp - 0x998]
xor edx, 0xffffff98
mov byte [ebp - 0x2bd], dl
lea eax, [ebp - 0x1f74]
mov dword [ebp - 0x273c], eax
mov ecx, dword [ebp - 0x273c]
add ecx, dword [ebp - 0x1edc]
mov dword [ebp - 0x2740], ecx
mov edx, dword [ebp - 0x2740]
mov al, byte [ebp - 0x2bd]
mov byte [edx], al
jmp 0x1012fed8
lea ecx, [ebp - 0x1f74]
mov dword [ebp - 0x2744], ecx
mov edx, dword [ebp - 0x2744]
mov dword [ebp - 0x24b0], edx
lea eax, [ebp - 0x4748]
mov dword [ebp - 0x2748], eax
movzx ecx, byte [ebp - 0x21bf]
push ecx
mov ecx, dword [ebp - 0x2748]
call fcn.1008cde0
mov byte [ebp - 4], 0x33
mov edx, dword [ebp - 0x24b0]
mov dword [ebp - 0x1ee0], edx
mov eax, dword [ebp - 0x1ee0]
add eax, 1
mov dword [ebp - 0x274c], eax
mov ecx, dword [ebp - 0x1ee0]
mov dl, byte [ecx]
mov byte [ebp - 0x999], dl
add dword [ebp - 0x1ee0], 1
cmp byte [ebp - 0x999], 0
jne 0x1012ffbf
mov eax, dword [ebp - 0x1ee0]
sub eax, dword [ebp - 0x274c]
mov dword [ebp - 0x2750], eax
mov ecx, dword [ebp - 0x2750]
mov dword [ebp - 0x2754], ecx
mov edx, dword [ebp - 0x2754]
mov dword [ebp - 0x2758], edx
mov eax, dword [ebp - 0x2758]
push eax
mov ecx, dword [ebp - 0x24b0]
push ecx
lea ecx, [ebp - 0x4748]
call fcn.1008ce30
mov byte [ebp - 4], 0x34
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.6_way]
mov byte [ebp - 0x9a0], cl
movsx edx, byte [ebp - 0x9a0]
xor edx, 0xffffff98
mov byte [ebp - 0x9a1], dl
mov al, byte [ebp - 0x9a1]
mov byte [ebp - 0x1dc8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x9a8], dl
movsx eax, byte [ebp - 0x9a8]
xor eax, 0xffffff98
mov byte [ebp - 0x9a9], al
mov cl, byte [ebp - 0x9a9]
mov byte [ebp - 0x1dc7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.6_way]
mov byte [ebp - 0x9b0], al
movsx ecx, byte [ebp - 0x9b0]
xor ecx, 0xffffff98
mov byte [ebp - 0x9b1], cl
mov dl, byte [ebp - 0x9b1]
mov byte [ebp - 0x1dc6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x9b8], dl
movsx eax, byte [ebp - 0x9b8]
xor eax, 0xffffff98
mov byte [ebp - 0x9b9], al
mov cl, byte [ebp - 0x9b9]
mov byte [ebp - 0x1dc5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.6_way]
mov byte [ebp - 0x9c0], al
movsx ecx, byte [ebp - 0x9c0]
xor ecx, 0xffffff98
mov byte [ebp - 0x9c1], cl
mov dl, byte [ebp - 0x9c1]
mov byte [ebp - 0x1dc4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x9c8], dl
movsx eax, byte [ebp - 0x9c8]
xor eax, 0xffffff98
mov byte [ebp - 0x9c9], al
mov cl, byte [ebp - 0x9c9]
mov byte [ebp - 0x1dc3], cl
mov dword [ebp - 0x1ee4], 0
jmp 0x1013015e
mov edx, dword [ebp - 0x1ee4]
add edx, 1
mov dword [ebp - 0x1ee4], edx
cmp dword [ebp - 0x1ee4], 6
jae 0x101301e0
lea eax, [ebp - 0x1dc8]
mov dword [ebp - 0x275c], eax
mov ecx, dword [ebp - 0x275c]
add ecx, dword [ebp - 0x1ee4]
mov dword [ebp - 0x2760], ecx
mov edx, dword [ebp - 0x2760]
mov al, byte [edx]
mov byte [ebp - 0x9d0], al
mov cl, byte [ebp - 0x21c0]
mov byte [ebp - 0x2be], cl
movsx edx, byte [ebp - 0x9d0]
xor edx, 0xffffff98
mov byte [ebp - 0x2be], dl
lea eax, [ebp - 0x1dc8]
mov dword [ebp - 0x2764], eax
mov ecx, dword [ebp - 0x2764]
add ecx, dword [ebp - 0x1ee4]
mov dword [ebp - 0x2768], ecx
mov edx, dword [ebp - 0x2768]
mov al, byte [ebp - 0x2be]
mov byte [edx], al
jmp 0x1013014f
lea ecx, [ebp - 0x1dc8]
mov dword [ebp - 0x276c], ecx
mov edx, dword [ebp - 0x276c]
mov dword [ebp - 0x24ac], edx
lea eax, [ebp - 0x4730]
mov dword [ebp - 0x2770], eax
movzx ecx, byte [ebp - 0x21c1]
push ecx
mov ecx, dword [ebp - 0x2770]
call fcn.1008cde0
mov byte [ebp - 4], 0x35
mov edx, dword [ebp - 0x24ac]
mov dword [ebp - 0x1ee8], edx
mov eax, dword [ebp - 0x1ee8]
add eax, 1
mov dword [ebp - 0x2774], eax
mov ecx, dword [ebp - 0x1ee8]
mov dl, byte [ecx]
mov byte [ebp - 0x9d1], dl
add dword [ebp - 0x1ee8], 1
cmp byte [ebp - 0x9d1], 0
jne 0x10130236
mov eax, dword [ebp - 0x1ee8]
sub eax, dword [ebp - 0x2774]
mov dword [ebp - 0x2778], eax
mov ecx, dword [ebp - 0x2778]
mov dword [ebp - 0x277c], ecx
mov edx, dword [ebp - 0x277c]
mov dword [ebp - 0x2780], edx
mov eax, dword [ebp - 0x2780]
push eax
mov ecx, dword [ebp - 0x24ac]
push ecx
lea ecx, [ebp - 0x4730]
call fcn.1008ce30
mov byte [ebp - 4], 0x36
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.center_jitter]
mov byte [ebp - 0x9d8], cl
movsx edx, byte [ebp - 0x9d8]
xor edx, 0xffffff98
mov byte [ebp - 0x9d9], dl
mov al, byte [ebp - 0x9d9]
mov byte [ebp - 0x2068], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.center_jitter]
mov byte [ebp - 0x9e0], dl
movsx eax, byte [ebp - 0x9e0]
xor eax, 0xffffff98
mov byte [ebp - 0x9e1], al
mov cl, byte [ebp - 0x9e1]
mov byte [ebp - 0x2067], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.center_jitter]
mov byte [ebp - 0x9e8], al
movsx ecx, byte [ebp - 0x9e8]
xor ecx, 0xffffff98
mov byte [ebp - 0x9e9], cl
mov dl, byte [ebp - 0x9e9]
mov byte [ebp - 0x2066], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.center_jitter]
mov byte [ebp - 0x9f0], dl
movsx eax, byte [ebp - 0x9f0]
xor eax, 0xffffff98
mov byte [ebp - 0x9f1], al
mov cl, byte [ebp - 0x9f1]
mov byte [ebp - 0x2065], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.center_jitter]
mov byte [ebp - 0x9f8], al
movsx ecx, byte [ebp - 0x9f8]
xor ecx, 0xffffff98
mov byte [ebp - 0x9f9], cl
mov dl, byte [ebp - 0x9f9]
mov byte [ebp - 0x2064], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.center_jitter]
mov byte [ebp - 0xa00], dl
movsx eax, byte [ebp - 0xa00]
xor eax, 0xffffff98
mov byte [ebp - 0xa01], al
mov cl, byte [ebp - 0xa01]
mov byte [ebp - 0x2063], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.center_jitter]
mov byte [ebp - 0xa08], cl
movsx edx, byte [ebp - 0xa08]
xor edx, 0xffffff98
mov byte [ebp - 0xa09], dl
mov al, byte [ebp - 0xa09]
mov byte [ebp - 0x2062], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.center_jitter]
mov byte [ebp - 0xa10], al
movsx ecx, byte [ebp - 0xa10]
xor ecx, 0xffffff98
mov byte [ebp - 0xa11], cl
mov dl, byte [ebp - 0xa11]
mov byte [ebp - 0x2061], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.center_jitter]
mov byte [ebp - 0xa18], cl
movsx edx, byte [ebp - 0xa18]
xor edx, 0xffffff98
mov byte [ebp - 0xa19], dl
mov al, byte [ebp - 0xa19]
mov byte [ebp - 0x2060], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.center_jitter]
mov byte [ebp - 0xa20], al
movsx ecx, byte [ebp - 0xa20]
xor ecx, 0xffffff98
mov byte [ebp - 0xa21], cl
mov dl, byte [ebp - 0xa21]
mov byte [ebp - 0x205f], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.center_jitter]
mov byte [ebp - 0xa28], dl
movsx eax, byte [ebp - 0xa28]
xor eax, 0xffffff98
mov byte [ebp - 0xa29], al
mov cl, byte [ebp - 0xa29]
mov byte [ebp - 0x205e], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.center_jitter]
mov byte [ebp - 0xa30], cl
movsx edx, byte [ebp - 0xa30]
xor edx, 0xffffff98
mov byte [ebp - 0xa31], dl
mov al, byte [ebp - 0xa31]
mov byte [ebp - 0x205d], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.center_jitter]
mov byte [ebp - 0xa38], al
movsx ecx, byte [ebp - 0xa38]
xor ecx, 0xffffff98
mov byte [ebp - 0xa39], cl
mov dl, byte [ebp - 0xa39]
mov byte [ebp - 0x205c], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.center_jitter]
mov byte [ebp - 0xa40], dl
movsx eax, byte [ebp - 0xa40]
xor eax, 0xffffff98
mov byte [ebp - 0xa41], al
mov cl, byte [ebp - 0xa41]
mov byte [ebp - 0x205b], cl
mov dword [ebp - 0x1eec], 0
jmp 0x10130555
mov edx, dword [ebp - 0x1eec]
add edx, 1
mov dword [ebp - 0x1eec], edx
cmp dword [ebp - 0x1eec], 0xe
jae 0x101305d7
lea eax, [ebp - 0x2068]
mov dword [ebp - 0x2784], eax
mov ecx, dword [ebp - 0x2784]
add ecx, dword [ebp - 0x1eec]
mov dword [ebp - 0x2788], ecx
mov edx, dword [ebp - 0x2788]
mov al, byte [edx]
mov byte [ebp - 0xa48], al
mov cl, byte [ebp - 0x21c2]
mov byte [ebp - 0x2bf], cl
movsx edx, byte [ebp - 0xa48]
xor edx, 0xffffff98
mov byte [ebp - 0x2bf], dl
lea eax, [ebp - 0x2068]
mov dword [ebp - 0x278c], eax
mov ecx, dword [ebp - 0x278c]
add ecx, dword [ebp - 0x1eec]
mov dword [ebp - 0x2790], ecx
mov edx, dword [ebp - 0x2790]
mov al, byte [ebp - 0x2bf]
mov byte [edx], al
jmp 0x10130546
lea ecx, [ebp - 0x2068]
mov dword [ebp - 0x2794], ecx
mov edx, dword [ebp - 0x2794]
mov dword [ebp - 0x2498], edx
lea eax, [ebp - 0x4718]
mov dword [ebp - 0x2798], eax
movzx ecx, byte [ebp - 0x21c3]
push ecx
mov ecx, dword [ebp - 0x2798]
call fcn.1008cde0
mov byte [ebp - 4], 0x37
mov edx, dword [ebp - 0x2498]
mov dword [ebp - 0x1ef0], edx
mov eax, dword [ebp - 0x1ef0]
add eax, 1
mov dword [ebp - 0x279c], eax
mov ecx, dword [ebp - 0x1ef0]
mov dl, byte [ecx]
mov byte [ebp - 0xa49], dl
add dword [ebp - 0x1ef0], 1
cmp byte [ebp - 0xa49], 0
jne 0x1013062d
mov eax, dword [ebp - 0x1ef0]
sub eax, dword [ebp - 0x279c]
mov dword [ebp - 0x27a0], eax
mov ecx, dword [ebp - 0x27a0]
mov dword [ebp - 0x27a4], ecx
mov edx, dword [ebp - 0x27a4]
mov dword [ebp - 0x27a8], edx
mov eax, dword [ebp - 0x27a8]
push eax
mov ecx, dword [ebp - 0x2498]
push ecx
lea ecx, [ebp - 0x4718]
call fcn.1008ce30
mov dword [ebp - 4], 0x38
lea edx, [ebp - 0x47a8]
mov dword [ebp - 0x3790], edx
lea eax, [ebp - 0x4700]
mov dword [ebp - 0x378c], eax
mov ecx, dword [ebp - 0x3790]
mov edx, dword [ebp - 0x378c]
mov dword [ebp - 0x3798], ecx
mov dword [ebp - 0x3794], edx
mov eax, dword [ebp - 0x27ac]
push eax
mov ecx, dword [ebp - 0x3794]
push ecx
mov edx, dword [ebp - 0x3798]
push edx
lea ecx, [ebp - 0x3920]
call fcn.10260fe0
mov byte [ebp - 4], 0x39
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0xa50], dl
movsx eax, byte [ebp - 0xa50]
xor eax, 0xffffff98
mov byte [ebp - 0xa51], al
mov cl, byte [ebp - 0xa51]
mov byte [ebp - 0x1fb0], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0xa58], al
movsx ecx, byte [ebp - 0xa58]
xor ecx, 0xffffff98
mov byte [ebp - 0xa59], cl
mov dl, byte [ebp - 0xa59]
mov byte [ebp - 0x1faf], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0xa60], cl
movsx edx, byte [ebp - 0xa60]
xor edx, 0xffffff98
mov byte [ebp - 0xa61], dl
mov al, byte [ebp - 0xa61]
mov byte [ebp - 0x1fae], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0xa68], al
movsx ecx, byte [ebp - 0xa68]
xor ecx, 0xffffff98
mov byte [ebp - 0xa69], cl
mov dl, byte [ebp - 0xa69]
mov byte [ebp - 0x1fad], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0xa70], cl
movsx edx, byte [ebp - 0xa70]
xor edx, 0xffffff98
mov byte [ebp - 0xa71], dl
mov al, byte [ebp - 0xa71]
mov byte [ebp - 0x1fac], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0xa78], al
movsx ecx, byte [ebp - 0xa78]
xor ecx, 0xffffff98
mov byte [ebp - 0xa79], cl
mov dl, byte [ebp - 0xa79]
mov byte [ebp - 0x1fab], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0xa80], dl
movsx eax, byte [ebp - 0xa80]
xor eax, 0xffffff98
mov byte [ebp - 0xa81], al
mov cl, byte [ebp - 0xa81]
mov byte [ebp - 0x1faa], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0xa88], cl
movsx edx, byte [ebp - 0xa88]
xor edx, 0xffffff98
mov byte [ebp - 0xa89], dl
mov al, byte [ebp - 0xa89]
mov byte [ebp - 0x1fa9], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0xa90], dl
movsx eax, byte [ebp - 0xa90]
xor eax, 0xffffff98
mov byte [ebp - 0xa91], al
mov cl, byte [ebp - 0xa91]
mov byte [ebp - 0x1fa8], cl
mov dword [ebp - 0x1ef4], 0
jmp 0x101308b3
mov edx, dword [ebp - 0x1ef4]
add edx, 1
mov dword [ebp - 0x1ef4], edx
cmp dword [ebp - 0x1ef4], 9
jae 0x10130935
lea eax, [ebp - 0x1fb0]
mov dword [ebp - 0x27b0], eax
mov ecx, dword [ebp - 0x27b0]
add ecx, dword [ebp - 0x1ef4]
mov dword [ebp - 0x27b4], ecx
mov edx, dword [ebp - 0x27b4]
mov al, byte [edx]
mov byte [ebp - 0xa98], al
mov cl, byte [ebp - 0x21c4]
mov byte [ebp - 0x2c0], cl
movsx edx, byte [ebp - 0xa98]
xor edx, 0xffffff98
mov byte [ebp - 0x2c0], dl
lea eax, [ebp - 0x1fb0]
mov dword [ebp - 0x27b8], eax
mov ecx, dword [ebp - 0x27b8]
add ecx, dword [ebp - 0x1ef4]
mov dword [ebp - 0x27bc], ecx
mov edx, dword [ebp - 0x27bc]
mov al, byte [ebp - 0x2c0]
mov byte [edx], al
jmp 0x101308a4
lea ecx, [ebp - 0x1fb0]
mov dword [ebp - 0x27c0], ecx
mov edx, dword [ebp - 0x27c0]
mov dword [ebp - 0x2494], edx
lea eax, [ebp - 0x3b90]
mov dword [ebp - 0x27c4], eax
movzx ecx, byte [ebp - 0x21c5]
push ecx
mov ecx, dword [ebp - 0x27c4]
call fcn.1008cde0
mov byte [ebp - 4], 0x3a
mov edx, dword [ebp - 0x2494]
mov dword [ebp - 0x1ef8], edx
mov eax, dword [ebp - 0x1ef8]
add eax, 1
mov dword [ebp - 0x27c8], eax
mov ecx, dword [ebp - 0x1ef8]
mov dl, byte [ecx]
mov byte [ebp - 0xa99], dl
add dword [ebp - 0x1ef8], 1
cmp byte [ebp - 0xa99], 0
jne 0x1013098b
mov eax, dword [ebp - 0x1ef8]
sub eax, dword [ebp - 0x27c8]
mov dword [ebp - 0x27cc], eax
mov ecx, dword [ebp - 0x27cc]
mov dword [ebp - 0x27d0], ecx
mov edx, dword [ebp - 0x27d0]
mov dword [ebp - 0x27d4], edx
mov eax, dword [ebp - 0x27d4]
push eax
mov ecx, dword [ebp - 0x2494]
push ecx
lea ecx, [ebp - 0x3b90]
call fcn.1008ce30
mov byte [ebp - 4], 0x3b
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + 0x10323e78]
mov byte [ebp - 0xaa0], cl
movsx edx, byte [ebp - 0xaa0]
xor edx, 0xffffff98
mov byte [ebp - 0xaa1], dl
mov al, byte [ebp - 0xaa1]
mov byte [ebp - 0x1ae0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + 0x10323e78]
mov byte [ebp - 0xaa8], dl
movsx eax, byte [ebp - 0xaa8]
xor eax, 0xffffff98
mov byte [ebp - 0xaa9], al
mov cl, byte [ebp - 0xaa9]
mov byte [ebp - 0x1adf], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + 0x10323e78]
mov byte [ebp - 0xab0], al
movsx ecx, byte [ebp - 0xab0]
xor ecx, 0xffffff98
mov byte [ebp - 0xab1], cl
mov dl, byte [ebp - 0xab1]
mov byte [ebp - 0x1ade], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + 0x10323e78]
mov byte [ebp - 0xab8], dl
movsx eax, byte [ebp - 0xab8]
xor eax, 0xffffff98
mov byte [ebp - 0xab9], al
mov cl, byte [ebp - 0xab9]
mov byte [ebp - 0x1add], cl
mov dword [ebp - 0x1efc], 0
jmp 0x10130aca
mov edx, dword [ebp - 0x1efc]
add edx, 1
mov dword [ebp - 0x1efc], edx
cmp dword [ebp - 0x1efc], 4
jae 0x10130b4c
lea eax, [ebp - 0x1ae0]
mov dword [ebp - 0x27d8], eax
mov ecx, dword [ebp - 0x27d8]
add ecx, dword [ebp - 0x1efc]
mov dword [ebp - 0x27dc], ecx
mov edx, dword [ebp - 0x27dc]
mov al, byte [edx]
mov byte [ebp - 0xac0], al
mov cl, byte [ebp - 0x21c6]
mov byte [ebp - 0x2c1], cl
movsx edx, byte [ebp - 0xac0]
xor edx, 0xffffff98
mov byte [ebp - 0x2c1], dl
lea eax, [ebp - 0x1ae0]
mov dword [ebp - 0x27e0], eax
mov ecx, dword [ebp - 0x27e0]
add ecx, dword [ebp - 0x1efc]
mov dword [ebp - 0x27e4], ecx
mov edx, dword [ebp - 0x27e4]
mov al, byte [ebp - 0x2c1]
mov byte [edx], al
jmp 0x10130abb
lea ecx, [ebp - 0x1ae0]
mov dword [ebp - 0x27e8], ecx
mov edx, dword [ebp - 0x27e8]
mov dword [ebp - 0x2490], edx
lea eax, [ebp - 0x3b78]
mov dword [ebp - 0x27ec], eax
movzx ecx, byte [ebp - 0x21c7]
push ecx
mov ecx, dword [ebp - 0x27ec]
call fcn.1008cde0
mov byte [ebp - 4], 0x3c
mov edx, dword [ebp - 0x2490]
mov dword [ebp - 0x1f00], edx
mov eax, dword [ebp - 0x1f00]
add eax, 1
mov dword [ebp - 0x27f0], eax
mov ecx, dword [ebp - 0x1f00]
mov dl, byte [ecx]
mov byte [ebp - 0xac1], dl
add dword [ebp - 0x1f00], 1
cmp byte [ebp - 0xac1], 0
jne 0x10130ba2
mov eax, dword [ebp - 0x1f00]
sub eax, dword [ebp - 0x27f0]
mov dword [ebp - 0x27f4], eax
mov ecx, dword [ebp - 0x27f4]
mov dword [ebp - 0x27f8], ecx
mov edx, dword [ebp - 0x27f8]
mov dword [ebp - 0x27fc], edx
mov eax, dword [ebp - 0x27fc]
push eax
mov ecx, dword [ebp - 0x2490]
push ecx
lea ecx, [ebp - 0x3b78]
call fcn.1008ce30
mov byte [ebp - 4], 0x3d
lea edx, [ebp - 0x3b90]
push edx
mov ecx, dword [ebp - 0x274]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x274]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x274]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10130c49
lea eax, [ebp - 0x3b78]
push eax
mov ecx, dword [ebp - 0x274]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x274]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10130c63
mov dword [ebp - 0x248c], 0xf
jmp 0x10130c6d
mov dword [ebp - 0x248c], 0
mov eax, dword [ebp - 0x274]
mov ecx, dword [ebp - 0x248c]
mov dword [eax + 0x9c], ecx
mov edx, dword [ebp - 0x274]
mov eax, dword [edx + 0x9c]
add eax, 0x14
mov dword [ebp - 0x2488], eax
mov ecx, dword [ebp - 0x274]
mov edx, dword [ebp - 0x2488]
mov dword [ecx + 0x10], edx
mov eax, dword [ebp - 0x274]
mov ecx, dword [ebp - 0x2488]
mov dword [eax + 0x14], ecx
lea edx, [ebp - 0x3920]
mov dword [ebp - 0x246c], edx
mov eax, dword [ebp - 0x246c]
mov ecx, dword [eax]
mov dword [ebp - 0x2008], ecx
mov edx, dword [ebp - 0x246c]
mov eax, dword [edx + 4]
mov dword [ebp - 0x2800], eax
jmp 0x10130cec
mov ecx, dword [ebp - 0x2008]
add ecx, 0x18
mov dword [ebp - 0x2008], ecx
mov edx, dword [ebp - 0x2008]
cmp edx, dword [ebp - 0x2800]
je 0x10130d2c
mov eax, dword [ebp - 0x2008]
mov dword [ebp - 0x2804], eax
mov ecx, dword [ebp - 0x274]
add ecx, 0x88
mov dword [ebp - 0x2808], ecx
mov edx, dword [ebp - 0x2804]
push edx
mov ecx, dword [ebp - 0x2808]
call fcn.100fca00
jmp 0x10130cdd
mov eax, dword [ebp - 0x274]
add eax, 0x88
mov dword [ebp - 0x2454], eax
mov ecx, dword [ebp - 0x2454]
mov edx, dword [ebp - 0x2454]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x280c], eax
cmp dword [ebp - 0x280c], 0
jbe 0x10130d75
mov edx, dword [ebp - 0x274]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x3b
lea ecx, [ebp - 0x3b78]
call fcn.1008b960
mov byte [ebp - 4], 0x39
lea ecx, [ebp - 0x3b90]
call fcn.1008b960
mov byte [ebp - 4], 0x38
lea ecx, [ebp - 0x3920]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 7
push 0x18
lea eax, [ebp - 0x47a8]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x200]
add ecx, 0x544
mov dword [ebp - 0x2810], ecx
mov dword [ebp - 0x138], 0x100a8ae0
mov edx, dword [ebp - 0x2810]
add edx, 0x58
mov dword [ebp - 0x2818], edx
lea eax, [ebp - 0x138]
push eax
mov ecx, dword [ebp - 0x2818]
call fcn.1008c950
mov ecx, dword [ebp - 0x200]
add ecx, 0x544
mov dword [ebp - 0x18], ecx
mov edx, dword [ebp - 0x18]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x18]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x18]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x18]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x18]
mov edx, dword [ebp - 0x200]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x200]
add ecx, 0x18
mov dword [ebp - 0x281c], ecx
lea edx, [ebp - 0x18]
push edx
mov ecx, dword [ebp - 0x281c]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x5e4
mov dword [ebp - 0x260], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x10323e30]
mov word [ebp - 0x235c], ax
movzx ecx, word [ebp - 0x235c]
xor ecx, 0x98
mov word [ebp - 0x2356], cx
mov dx, word [ebp - 0x2356]
mov word [ebp - 0x2004], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x10323e30]
mov word [ebp - 0x2354], cx
movzx edx, word [ebp - 0x2354]
xor edx, 0x98
mov word [ebp - 0x234e], dx
mov ax, word [ebp - 0x234e]
mov word [ebp - 0x2002], ax
mov dword [ebp - 0x1f04], 0
jmp 0x10130efa
mov ecx, dword [ebp - 0x1f04]
add ecx, 1
mov dword [ebp - 0x1f04], ecx
cmp dword [ebp - 0x1f04], 2
jae 0x10130f8f
lea edx, [ebp - 0x2004]
mov dword [ebp - 0x2820], edx
mov eax, dword [ebp - 0x1f04]
mov ecx, dword [ebp - 0x2820]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2824], edx
mov eax, dword [ebp - 0x2824]
mov cx, word [eax]
mov word [ebp - 0x234c], cx
mov dx, word [ebp - 0x2af2]
mov word [ebp - 0x1ddc], dx
movzx eax, word [ebp - 0x234c]
xor eax, 0x98
mov word [ebp - 0x1ddc], ax
lea ecx, [ebp - 0x2004]
mov dword [ebp - 0x2828], ecx
mov edx, dword [ebp - 0x1f04]
mov eax, dword [ebp - 0x2828]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x282c], ecx
mov edx, dword [ebp - 0x282c]
mov ax, word [ebp - 0x1ddc]
mov word [edx], ax
jmp 0x10130eeb
lea ecx, [ebp - 0x2004]
mov dword [ebp - 0x2830], ecx
mov edx, dword [ebp - 0x2830]
mov dword [ebp - 0x2450], edx
lea eax, [ebp - 0x3bd8]
mov dword [ebp - 0x2834], eax
movzx ecx, byte [ebp - 0x21c8]
push ecx
mov ecx, dword [ebp - 0x2834]
call fcn.1008cde0
mov dword [ebp - 4], 0x3e
mov edx, dword [ebp - 0x2450]
mov dword [ebp - 0x1f08], edx
mov eax, dword [ebp - 0x1f08]
add eax, 2
mov dword [ebp - 0x2838], eax
mov ecx, dword [ebp - 0x1f08]
mov dx, word [ecx]
mov word [ebp - 0x2346], dx
add dword [ebp - 0x1f08], 2
cmp word [ebp - 0x2346], 0
jne 0x10130fe8
mov eax, dword [ebp - 0x1f08]
sub eax, dword [ebp - 0x2838]
sar eax, 1
mov dword [ebp - 0x283c], eax
mov ecx, dword [ebp - 0x283c]
mov dword [ebp - 0x2840], ecx
mov edx, dword [ebp - 0x2840]
mov dword [ebp - 0x2844], edx
mov eax, dword [ebp - 0x2844]
push eax
mov ecx, dword [ebp - 0x2450]
push ecx
lea ecx, [ebp - 0x3bd8]
call fcn.100b23d0
mov dword [ebp - 4], 0x3f
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xac8], cl
movsx edx, byte [ebp - 0xac8]
xor edx, 0xffffff98
mov byte [ebp - 0xac9], dl
mov al, byte [ebp - 0xac9]
mov byte [ebp - 0x2104], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xad0], dl
movsx eax, byte [ebp - 0xad0]
xor eax, 0xffffff98
mov byte [ebp - 0xad1], al
mov cl, byte [ebp - 0xad1]
mov byte [ebp - 0x2103], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xad8], al
movsx ecx, byte [ebp - 0xad8]
xor ecx, 0xffffff98
mov byte [ebp - 0xad9], cl
mov dl, byte [ebp - 0xad9]
mov byte [ebp - 0x2102], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xae0], dl
movsx eax, byte [ebp - 0xae0]
xor eax, 0xffffff98
mov byte [ebp - 0xae1], al
mov cl, byte [ebp - 0xae1]
mov byte [ebp - 0x2101], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xae8], al
movsx ecx, byte [ebp - 0xae8]
xor ecx, 0xffffff98
mov byte [ebp - 0xae9], cl
mov dl, byte [ebp - 0xae9]
mov byte [ebp - 0x2100], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xaf0], dl
movsx eax, byte [ebp - 0xaf0]
xor eax, 0xffffff98
mov byte [ebp - 0xaf1], al
mov cl, byte [ebp - 0xaf1]
mov byte [ebp - 0x20ff], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xaf8], cl
movsx edx, byte [ebp - 0xaf8]
xor edx, 0xffffff98
mov byte [ebp - 0xaf9], dl
mov al, byte [ebp - 0xaf9]
mov byte [ebp - 0x20fe], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xb00], al
movsx ecx, byte [ebp - 0xb00]
xor ecx, 0xffffff98
mov byte [ebp - 0xb01], cl
mov dl, byte [ebp - 0xb01]
mov byte [ebp - 0x20fd], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xb08], cl
movsx edx, byte [ebp - 0xb08]
xor edx, 0xffffff98
mov byte [ebp - 0xb09], dl
mov al, byte [ebp - 0xb09]
mov byte [ebp - 0x20fc], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xb10], al
movsx ecx, byte [ebp - 0xb10]
xor ecx, 0xffffff98
mov byte [ebp - 0xb11], cl
mov dl, byte [ebp - 0xb11]
mov byte [ebp - 0x20fb], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xb18], dl
movsx eax, byte [ebp - 0xb18]
xor eax, 0xffffff98
mov byte [ebp - 0xb19], al
mov cl, byte [ebp - 0xb19]
mov byte [ebp - 0x20fa], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xb20], cl
movsx edx, byte [ebp - 0xb20]
xor edx, 0xffffff98
mov byte [ebp - 0xb21], dl
mov al, byte [ebp - 0xb21]
mov byte [ebp - 0x20f9], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xb28], al
movsx ecx, byte [ebp - 0xb28]
xor ecx, 0xffffff98
mov byte [ebp - 0xb29], cl
mov dl, byte [ebp - 0xb29]
mov byte [ebp - 0x20f8], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xb30], dl
movsx eax, byte [ebp - 0xb30]
xor eax, 0xffffff98
mov byte [ebp - 0xb31], al
mov cl, byte [ebp - 0xb31]
mov byte [ebp - 0x20f7], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xb38], cl
movsx edx, byte [ebp - 0xb38]
xor edx, 0xffffff98
mov byte [ebp - 0xb39], dl
mov al, byte [ebp - 0xb39]
mov byte [ebp - 0x20f6], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xb40], al
movsx ecx, byte [ebp - 0xb40]
xor ecx, 0xffffff98
mov byte [ebp - 0xb41], cl
mov dl, byte [ebp - 0xb41]
mov byte [ebp - 0x20f5], dl
mov eax, 1
shl eax, 4
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xb48], cl
movsx edx, byte [ebp - 0xb48]
xor edx, 0xffffff98
mov byte [ebp - 0xb49], dl
mov al, byte [ebp - 0xb49]
mov byte [ebp - 0x20f4], al
mov ecx, 1
imul edx, ecx, 0x11
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xb50], al
movsx ecx, byte [ebp - 0xb50]
xor ecx, 0xffffff98
mov byte [ebp - 0xb51], cl
mov dl, byte [ebp - 0xb51]
mov byte [ebp - 0x20f3], dl
mov dword [ebp - 0x1f0c], 0
jmp 0x101313cf
mov eax, dword [ebp - 0x1f0c]
add eax, 1
mov dword [ebp - 0x1f0c], eax
cmp dword [ebp - 0x1f0c], 0x12
jae 0x10131451
lea ecx, [ebp - 0x2104]
mov dword [ebp - 0x2848], ecx
mov edx, dword [ebp - 0x2848]
add edx, dword [ebp - 0x1f0c]
mov dword [ebp - 0x284c], edx
mov eax, dword [ebp - 0x284c]
mov cl, byte [eax]
mov byte [ebp - 0xb58], cl
mov dl, byte [ebp - 0x21c9]
mov byte [ebp - 0x2c2], dl
movsx eax, byte [ebp - 0xb58]
xor eax, 0xffffff98
mov byte [ebp - 0x2c2], al
lea ecx, [ebp - 0x2104]
mov dword [ebp - 0x2850], ecx
mov edx, dword [ebp - 0x2850]
add edx, dword [ebp - 0x1f0c]
mov dword [ebp - 0x2854], edx
mov eax, dword [ebp - 0x2854]
mov cl, byte [ebp - 0x2c2]
mov byte [eax], cl
jmp 0x101313c0
lea edx, [ebp - 0x2104]
mov dword [ebp - 0x2858], edx
mov eax, dword [ebp - 0x2858]
mov dword [ebp - 0x244c], eax
lea ecx, [ebp - 0x3bc0]
mov dword [ebp - 0x285c], ecx
movzx edx, byte [ebp - 0x21ca]
push edx
mov ecx, dword [ebp - 0x285c]
call fcn.1008cde0
mov byte [ebp - 4], 0x40
mov eax, dword [ebp - 0x244c]
mov dword [ebp - 0x1f10], eax
mov ecx, dword [ebp - 0x1f10]
add ecx, 1
mov dword [ebp - 0x2860], ecx
mov edx, dword [ebp - 0x1f10]
mov al, byte [edx]
mov byte [ebp - 0xb59], al
add dword [ebp - 0x1f10], 1
cmp byte [ebp - 0xb59], 0
jne 0x101314a7
mov ecx, dword [ebp - 0x1f10]
sub ecx, dword [ebp - 0x2860]
mov dword [ebp - 0x2864], ecx
mov edx, dword [ebp - 0x2864]
mov dword [ebp - 0x2868], edx
mov eax, dword [ebp - 0x2868]
mov dword [ebp - 0x286c], eax
mov ecx, dword [ebp - 0x286c]
push ecx
mov edx, dword [ebp - 0x244c]
push edx
lea ecx, [ebp - 0x3bc0]
call fcn.1008ce30
mov byte [ebp - 4], 0x41
lea eax, [ebp - 0x3ba8]
mov dword [ebp - 0x2870], eax
movzx ecx, byte [ebp - 0x21cb]
push ecx
mov ecx, dword [ebp - 0x2870]
call fcn.1008cde0
mov byte [ebp - 4], 0x42
mov dword [ebp - 0x1f14], 0x1031e566
mov edx, dword [ebp - 0x1f14]
add edx, 1
mov dword [ebp - 0x2874], edx
mov eax, dword [ebp - 0x1f14]
mov cl, byte [eax]
mov byte [ebp - 0xb5a], cl
add dword [ebp - 0x1f14], 1
cmp byte [ebp - 0xb5a], 0
jne 0x10131548
mov edx, dword [ebp - 0x1f14]
sub edx, dword [ebp - 0x2874]
mov dword [ebp - 0x2878], edx
mov eax, dword [ebp - 0x2878]
mov dword [ebp - 0x287c], eax
mov ecx, dword [ebp - 0x287c]
mov dword [ebp - 0x2880], ecx
mov edx, dword [ebp - 0x2880]
push edx
push 0x1031e566
lea ecx, [ebp - 0x3ba8]
call fcn.1008ce30
mov byte [ebp - 4], 0x43
lea eax, [ebp - 0x3bc0]
push eax
mov ecx, dword [ebp - 0x260]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x260]
mov byte [ecx + 0x69], 0
mov edx, dword [ebp - 0x260]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x101315f0
lea ecx, [ebp - 0x3ba8]
push ecx
mov ecx, dword [ebp - 0x260]
add ecx, 0x88
call fcn.100ad110
mov edx, dword [ebp - 0x260]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1013160a
mov dword [ebp - 0x2448], 0xf
jmp 0x10131614
mov dword [ebp - 0x2448], 0
mov ecx, dword [ebp - 0x260]
mov edx, dword [ebp - 0x2448]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x260]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x260]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x260]
mov ecx, dword [ebp - 0x260]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x260]
movss xmm0, dword [0x1032891c]
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x260]
movss xmm0, dword [0x10328aa8]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x260]
movss xmm0, dword [0x10328a14]
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x260]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x260]
movss xmm0, dword [0x103289bc]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x3bd8]
push edx
mov ecx, dword [ebp - 0x260]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x41
lea ecx, [ebp - 0x3ba8]
call fcn.1008b960
mov byte [ebp - 4], 0x3f
lea ecx, [ebp - 0x3bc0]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3bd8]
call fcn.100ae140
mov eax, dword [ebp - 0x200]
add eax, 0x5e4
mov dword [ebp - 0x2884], eax
mov dword [ebp - 0x134], 0x100a8ae0
mov ecx, dword [ebp - 0x2884]
add ecx, 0x58
mov dword [ebp - 0x288c], ecx
lea edx, [ebp - 0x134]
push edx
mov ecx, dword [ebp - 0x288c]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x5e4
mov dword [ebp - 0x2890], eax
mov dword [ebp - 0x130], 0x100a8b40
mov ecx, dword [ebp - 0x2890]
add ecx, 0x58
mov dword [ebp - 0x2898], ecx
lea edx, [ebp - 0x130]
push edx
mov ecx, dword [ebp - 0x2898]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x5e4
mov dword [ebp - 0x40], eax
mov ecx, dword [ebp - 0x40]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x40]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x40]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x40]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x40]
mov ecx, dword [ebp - 0x200]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x200]
add eax, 0x18
mov dword [ebp - 0x289c], eax
lea ecx, [ebp - 0x40]
push ecx
mov ecx, dword [ebp - 0x289c]
call fcn.1008c950
mov edx, dword [ebp - 0x200]
add edx, 0x6a0
mov dword [ebp - 0x25c], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x10323e30]
mov word [ebp - 0x2344], dx
movzx eax, word [ebp - 0x2344]
xor eax, 0x98
mov word [ebp - 0x233e], ax
mov cx, word [ebp - 0x233e]
mov word [ebp - 0x2000], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x10323e30]
mov word [ebp - 0x233c], ax
movzx ecx, word [ebp - 0x233c]
xor ecx, 0x98
mov word [ebp - 0x2336], cx
mov dx, word [ebp - 0x2336]
mov word [ebp - 0x1ffe], dx
mov dword [ebp - 0x1f18], 0
jmp 0x1013186a
mov eax, dword [ebp - 0x1f18]
add eax, 1
mov dword [ebp - 0x1f18], eax
cmp dword [ebp - 0x1f18], 2
jae 0x10131900
lea ecx, [ebp - 0x2000]
mov dword [ebp - 0x28a0], ecx
mov edx, dword [ebp - 0x1f18]
mov eax, dword [ebp - 0x28a0]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x28a4], ecx
mov edx, dword [ebp - 0x28a4]
mov ax, word [edx]
mov word [ebp - 0x2334], ax
mov cx, word [ebp - 0x2a92]
mov word [ebp - 0x1dde], cx
movzx edx, word [ebp - 0x2334]
xor edx, 0x98
mov word [ebp - 0x1dde], dx
lea eax, [ebp - 0x2000]
mov dword [ebp - 0x28a8], eax
mov ecx, dword [ebp - 0x1f18]
mov edx, dword [ebp - 0x28a8]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x28ac], eax
mov ecx, dword [ebp - 0x28ac]
mov dx, word [ebp - 0x1dde]
mov word [ecx], dx
jmp 0x1013185b
lea eax, [ebp - 0x2000]
mov dword [ebp - 0x28b0], eax
mov ecx, dword [ebp - 0x28b0]
mov dword [ebp - 0x2444], ecx
lea edx, [ebp - 0x3c20]
mov dword [ebp - 0x28b4], edx
movzx eax, byte [ebp - 0x21cc]
push eax
mov ecx, dword [ebp - 0x28b4]
call fcn.1008cde0
mov dword [ebp - 4], 0x44
mov ecx, dword [ebp - 0x2444]
mov dword [ebp - 0x1f1c], ecx
mov edx, dword [ebp - 0x1f1c]
add edx, 2
mov dword [ebp - 0x28b8], edx
mov eax, dword [ebp - 0x1f1c]
mov cx, word [eax]
mov word [ebp - 0x232e], cx
add dword [ebp - 0x1f1c], 2
cmp word [ebp - 0x232e], 0
jne 0x10131959
mov edx, dword [ebp - 0x1f1c]
sub edx, dword [ebp - 0x28b8]
sar edx, 1
mov dword [ebp - 0x28bc], edx
mov eax, dword [ebp - 0x28bc]
mov dword [ebp - 0x28c0], eax
mov ecx, dword [ebp - 0x28c0]
mov dword [ebp - 0x28c4], ecx
mov edx, dword [ebp - 0x28c4]
push edx
mov eax, dword [ebp - 0x2444]
push eax
lea ecx, [ebp - 0x3c20]
call fcn.100b23d0
mov dword [ebp - 4], 0x45
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xb60], al
movsx ecx, byte [ebp - 0xb60]
xor ecx, 0xffffff98
mov byte [ebp - 0xb61], cl
mov dl, byte [ebp - 0xb61]
mov byte [ebp - 0x20a8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xb68], cl
movsx edx, byte [ebp - 0xb68]
xor edx, 0xffffff98
mov byte [ebp - 0xb69], dl
mov al, byte [ebp - 0xb69]
mov byte [ebp - 0x20a7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xb70], dl
movsx eax, byte [ebp - 0xb70]
xor eax, 0xffffff98
mov byte [ebp - 0xb71], al
mov cl, byte [ebp - 0xb71]
mov byte [ebp - 0x20a6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xb78], cl
movsx edx, byte [ebp - 0xb78]
xor edx, 0xffffff98
mov byte [ebp - 0xb79], dl
mov al, byte [ebp - 0xb79]
mov byte [ebp - 0x20a5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xb80], dl
movsx eax, byte [ebp - 0xb80]
xor eax, 0xffffff98
mov byte [ebp - 0xb81], al
mov cl, byte [ebp - 0xb81]
mov byte [ebp - 0x20a4], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xb88], cl
movsx edx, byte [ebp - 0xb88]
xor edx, 0xffffff98
mov byte [ebp - 0xb89], dl
mov al, byte [ebp - 0xb89]
mov byte [ebp - 0x20a3], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xb90], al
movsx ecx, byte [ebp - 0xb90]
xor ecx, 0xffffff98
mov byte [ebp - 0xb91], cl
mov dl, byte [ebp - 0xb91]
mov byte [ebp - 0x20a2], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xb98], dl
movsx eax, byte [ebp - 0xb98]
xor eax, 0xffffff98
mov byte [ebp - 0xb99], al
mov cl, byte [ebp - 0xb99]
mov byte [ebp - 0x20a1], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xba0], al
movsx ecx, byte [ebp - 0xba0]
xor ecx, 0xffffff98
mov byte [ebp - 0xba1], cl
mov dl, byte [ebp - 0xba1]
mov byte [ebp - 0x20a0], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xba8], dl
movsx eax, byte [ebp - 0xba8]
xor eax, 0xffffff98
mov byte [ebp - 0xba9], al
mov cl, byte [ebp - 0xba9]
mov byte [ebp - 0x209f], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xbb0], cl
movsx edx, byte [ebp - 0xbb0]
xor edx, 0xffffff98
mov byte [ebp - 0xbb1], dl
mov al, byte [ebp - 0xbb1]
mov byte [ebp - 0x209e], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xbb8], al
movsx ecx, byte [ebp - 0xbb8]
xor ecx, 0xffffff98
mov byte [ebp - 0xbb9], cl
mov dl, byte [ebp - 0xbb9]
mov byte [ebp - 0x209d], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xbc0], dl
movsx eax, byte [ebp - 0xbc0]
xor eax, 0xffffff98
mov byte [ebp - 0xbc1], al
mov cl, byte [ebp - 0xbc1]
mov byte [ebp - 0x209c], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xbc8], cl
movsx edx, byte [ebp - 0xbc8]
xor edx, 0xffffff98
mov byte [ebp - 0xbc9], dl
mov al, byte [ebp - 0xbc9]
mov byte [ebp - 0x209b], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xbd0], al
movsx ecx, byte [ebp - 0xbd0]
xor ecx, 0xffffff98
mov byte [ebp - 0xbd1], cl
mov dl, byte [ebp - 0xbd1]
mov byte [ebp - 0x209a], dl
mov dword [ebp - 0x1f20], 0
jmp 0x10131cb0
mov eax, dword [ebp - 0x1f20]
add eax, 1
mov dword [ebp - 0x1f20], eax
cmp dword [ebp - 0x1f20], 0xf
jae 0x10131d32
lea ecx, [ebp - 0x20a8]
mov dword [ebp - 0x28c8], ecx
mov edx, dword [ebp - 0x28c8]
add edx, dword [ebp - 0x1f20]
mov dword [ebp - 0x28cc], edx
mov eax, dword [ebp - 0x28cc]
mov cl, byte [eax]
mov byte [ebp - 0xbd8], cl
mov dl, byte [ebp - 0x21cd]
mov byte [ebp - 0x2c3], dl
movsx eax, byte [ebp - 0xbd8]
xor eax, 0xffffff98
mov byte [ebp - 0x2c3], al
lea ecx, [ebp - 0x20a8]
mov dword [ebp - 0x28d0], ecx
mov edx, dword [ebp - 0x28d0]
add edx, dword [ebp - 0x1f20]
mov dword [ebp - 0x28d4], edx
mov eax, dword [ebp - 0x28d4]
mov cl, byte [ebp - 0x2c3]
mov byte [eax], cl
jmp 0x10131ca1
lea edx, [ebp - 0x20a8]
mov dword [ebp - 0x28d8], edx
mov eax, dword [ebp - 0x28d8]
mov dword [ebp - 0x2440], eax
lea ecx, [ebp - 0x3c08]
mov dword [ebp - 0x28dc], ecx
movzx edx, byte [ebp - 0x21ce]
push edx
mov ecx, dword [ebp - 0x28dc]
call fcn.1008cde0
mov byte [ebp - 4], 0x46
mov eax, dword [ebp - 0x2440]
mov dword [ebp - 0x1f24], eax
mov ecx, dword [ebp - 0x1f24]
add ecx, 1
mov dword [ebp - 0x28e0], ecx
mov edx, dword [ebp - 0x1f24]
mov al, byte [edx]
mov byte [ebp - 0xbd9], al
add dword [ebp - 0x1f24], 1
cmp byte [ebp - 0xbd9], 0
jne 0x10131d88
mov ecx, dword [ebp - 0x1f24]
sub ecx, dword [ebp - 0x28e0]
mov dword [ebp - 0x28e4], ecx
mov edx, dword [ebp - 0x28e4]
mov dword [ebp - 0x28e8], edx
mov eax, dword [ebp - 0x28e8]
mov dword [ebp - 0x28ec], eax
mov ecx, dword [ebp - 0x28ec]
push ecx
mov edx, dword [ebp - 0x2440]
push edx
lea ecx, [ebp - 0x3c08]
call fcn.1008ce30
mov byte [ebp - 4], 0x47
lea eax, [ebp - 0x3bf0]
mov dword [ebp - 0x28f0], eax
movzx ecx, byte [ebp - 0x21cf]
push ecx
mov ecx, dword [ebp - 0x28f0]
call fcn.1008cde0
mov byte [ebp - 4], 0x48
mov dword [ebp - 0x1f28], 0x1031e566
mov edx, dword [ebp - 0x1f28]
add edx, 1
mov dword [ebp - 0x28f4], edx
mov eax, dword [ebp - 0x1f28]
mov cl, byte [eax]
mov byte [ebp - 0xbda], cl
add dword [ebp - 0x1f28], 1
cmp byte [ebp - 0xbda], 0
jne 0x10131e29
mov edx, dword [ebp - 0x1f28]
sub edx, dword [ebp - 0x28f4]
mov dword [ebp - 0x28f8], edx
mov eax, dword [ebp - 0x28f8]
mov dword [ebp - 0x28fc], eax
mov ecx, dword [ebp - 0x28fc]
mov dword [ebp - 0x2900], ecx
mov edx, dword [ebp - 0x2900]
push edx
push 0x1031e566
lea ecx, [ebp - 0x3bf0]
call fcn.1008ce30
mov byte [ebp - 4], 0x49
lea eax, [ebp - 0x3c08]
push eax
mov ecx, dword [ebp - 0x25c]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x25c]
mov byte [ecx + 0x69], 0
mov edx, dword [ebp - 0x25c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10131ed1
lea ecx, [ebp - 0x3bf0]
push ecx
mov ecx, dword [ebp - 0x25c]
add ecx, 0x88
call fcn.100ad110
mov edx, dword [ebp - 0x25c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10131eeb
mov dword [ebp - 0x243c], 0xf
jmp 0x10131ef5
mov dword [ebp - 0x243c], 0
mov ecx, dword [ebp - 0x25c]
mov edx, dword [ebp - 0x243c]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x25c]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x25c]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x25c]
mov ecx, dword [ebp - 0x25c]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x25c]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x25c]
movss xmm0, dword [0x10328adc]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x25c]
movss xmm0, dword [0x10328adc]
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x25c]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x25c]
movss xmm0, dword [0x103289bc]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x3c20]
push edx
mov ecx, dword [ebp - 0x25c]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x47
lea ecx, [ebp - 0x3bf0]
call fcn.1008b960
mov byte [ebp - 4], 0x45
lea ecx, [ebp - 0x3c08]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3c20]
call fcn.100ae140
mov eax, dword [ebp - 0x200]
add eax, 0x6a0
mov dword [ebp - 0x2904], eax
mov dword [ebp - 0x12c], 0x100a8ae0
mov ecx, dword [ebp - 0x2904]
add ecx, 0x58
mov dword [ebp - 0x290c], ecx
lea edx, [ebp - 0x12c]
push edx
mov ecx, dword [ebp - 0x290c]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x6a0
mov dword [ebp - 0x2910], eax
mov dword [ebp - 0x128], 0x100a8b70
mov ecx, dword [ebp - 0x2910]
add ecx, 0x58
mov dword [ebp - 0x2918], ecx
lea edx, [ebp - 0x128]
push edx
mov ecx, dword [ebp - 0x2918]
call fcn.1008c950
mov eax, dword [ebp - 0x200]
add eax, 0x6a0
mov dword [ebp - 0x44], eax
mov ecx, dword [ebp - 0x44]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x44]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x44]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x44]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x44]
mov ecx, dword [ebp - 0x200]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x200]
add eax, 0x18
mov dword [ebp - 0x291c], eax
lea ecx, [ebp - 0x44]
push ecx
mov ecx, dword [ebp - 0x291c]
call fcn.1008c950
mov edx, dword [ebp - 0x200]
add edx, 0x75c
mov dword [ebp - 0x258], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x10323e30]
mov word [ebp - 0x232c], dx
movzx eax, word [ebp - 0x232c]
xor eax, 0x98
mov word [ebp - 0x2326], ax
mov cx, word [ebp - 0x2326]
mov word [ebp - 0x2034], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x10323e30]
mov word [ebp - 0x2324], ax
movzx ecx, word [ebp - 0x2324]
xor ecx, 0x98
mov word [ebp - 0x231e], cx
mov dx, word [ebp - 0x231e]
mov word [ebp - 0x2032], dx
mov dword [ebp - 0x1f2c], 0
jmp 0x10132146
mov eax, dword [ebp - 0x1f2c]
add eax, 1
mov dword [ebp - 0x1f2c], eax
cmp dword [ebp - 0x1f2c], 2
jae 0x101321dc
lea ecx, [ebp - 0x2034]
mov dword [ebp - 0x2920], ecx
mov edx, dword [ebp - 0x1f2c]
mov eax, dword [ebp - 0x2920]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2924], ecx
mov edx, dword [ebp - 0x2924]
mov ax, word [edx]
mov word [ebp - 0x231c], ax
mov cx, word [ebp - 0x2a86]
mov word [ebp - 0x1de0], cx
movzx edx, word [ebp - 0x231c]
xor edx, 0x98
mov word [ebp - 0x1de0], dx
lea eax, [ebp - 0x2034]
mov dword [ebp - 0x2928], eax
mov ecx, dword [ebp - 0x1f2c]
mov edx, dword [ebp - 0x2928]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x292c], eax
mov ecx, dword [ebp - 0x292c]
mov dx, word [ebp - 0x1de0]
mov word [ecx], dx
jmp 0x10132137
lea eax, [ebp - 0x2034]
mov dword [ebp - 0x2930], eax
mov ecx, dword [ebp - 0x2930]
mov dword [ebp - 0x2438], ecx
lea edx, [ebp - 0x3c68]
mov dword [ebp - 0x2934], edx
movzx eax, byte [ebp - 0x21d0]
push eax
mov ecx, dword [ebp - 0x2934]
call fcn.1008cde0
mov dword [ebp - 4], 0x4a
mov ecx, dword [ebp - 0x2438]
mov dword [ebp - 0x1f30], ecx
mov edx, dword [ebp - 0x1f30]
add edx, 2
mov dword [ebp - 0x2938], edx
mov eax, dword [ebp - 0x1f30]
mov cx, word [eax]
mov word [ebp - 0x2316], cx
add dword [ebp - 0x1f30], 2
cmp word [ebp - 0x2316], 0
jne 0x10132235
mov edx, dword [ebp - 0x1f30]
sub edx, dword [ebp - 0x2938]
sar edx, 1
mov dword [ebp - 0x293c], edx
mov eax, dword [ebp - 0x293c]
mov dword [ebp - 0x2940], eax
mov ecx, dword [ebp - 0x2940]
mov dword [ebp - 0x2944], ecx
mov edx, dword [ebp - 0x2944]
push edx
mov eax, dword [ebp - 0x2438]
push eax
lea ecx, [ebp - 0x3c68]
call fcn.100b23d0
mov dword [ebp - 4], 0x4b
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xbe0], al
movsx ecx, byte [ebp - 0xbe0]
xor ecx, 0xffffff98
mov byte [ebp - 0xbe1], cl
mov dl, byte [ebp - 0xbe1]
mov byte [ebp - 0x2154], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xbe8], cl
movsx edx, byte [ebp - 0xbe8]
xor edx, 0xffffff98
mov byte [ebp - 0xbe9], dl
mov al, byte [ebp - 0xbe9]
mov byte [ebp - 0x2153], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xbf0], dl
movsx eax, byte [ebp - 0xbf0]
xor eax, 0xffffff98
mov byte [ebp - 0xbf1], al
mov cl, byte [ebp - 0xbf1]
mov byte [ebp - 0x2152], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xbf8], cl
movsx edx, byte [ebp - 0xbf8]
xor edx, 0xffffff98
mov byte [ebp - 0xbf9], dl
mov al, byte [ebp - 0xbf9]
mov byte [ebp - 0x2151], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc00], dl
movsx eax, byte [ebp - 0xc00]
xor eax, 0xffffff98
mov byte [ebp - 0xc01], al
mov cl, byte [ebp - 0xc01]
mov byte [ebp - 0x2150], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xc08], cl
movsx edx, byte [ebp - 0xc08]
xor edx, 0xffffff98
mov byte [ebp - 0xc09], dl
mov al, byte [ebp - 0xc09]
mov byte [ebp - 0x214f], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xc10], al
movsx ecx, byte [ebp - 0xc10]
xor ecx, 0xffffff98
mov byte [ebp - 0xc11], cl
mov dl, byte [ebp - 0xc11]
mov byte [ebp - 0x214e], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc18], dl
movsx eax, byte [ebp - 0xc18]
xor eax, 0xffffff98
mov byte [ebp - 0xc19], al
mov cl, byte [ebp - 0xc19]
mov byte [ebp - 0x214d], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xc20], al
movsx ecx, byte [ebp - 0xc20]
xor ecx, 0xffffff98
mov byte [ebp - 0xc21], cl
mov dl, byte [ebp - 0xc21]
mov byte [ebp - 0x214c], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc28], dl
movsx eax, byte [ebp - 0xc28]
xor eax, 0xffffff98
mov byte [ebp - 0xc29], al
mov cl, byte [ebp - 0xc29]
mov byte [ebp - 0x214b], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xc30], cl
movsx edx, byte [ebp - 0xc30]
xor edx, 0xffffff98
mov byte [ebp - 0xc31], dl
mov al, byte [ebp - 0xc31]
mov byte [ebp - 0x214a], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xc38], al
movsx ecx, byte [ebp - 0xc38]
xor ecx, 0xffffff98
mov byte [ebp - 0xc39], cl
mov dl, byte [ebp - 0xc39]
mov byte [ebp - 0x2149], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc40], dl
movsx eax, byte [ebp - 0xc40]
xor eax, 0xffffff98
mov byte [ebp - 0xc41], al
mov cl, byte [ebp - 0xc41]
mov byte [ebp - 0x2148], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xc48], cl
movsx edx, byte [ebp - 0xc48]
xor edx, 0xffffff98
mov byte [ebp - 0xc49], dl
mov al, byte [ebp - 0xc49]
mov byte [ebp - 0x2147], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xc50], al
movsx ecx, byte [ebp - 0xc50]
xor ecx, 0xffffff98
mov byte [ebp - 0xc51], cl
mov dl, byte [ebp - 0xc51]
mov byte [ebp - 0x2146], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc58], dl
movsx eax, byte [ebp - 0xc58]
xor eax, 0xffffff98
mov byte [ebp - 0xc59], al
mov cl, byte [ebp - 0xc59]
mov byte [ebp - 0x2145], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xc60], al
movsx ecx, byte [ebp - 0xc60]
xor ecx, 0xffffff98
mov byte [ebp - 0xc61], cl
mov dl, byte [ebp - 0xc61]
mov byte [ebp - 0x2144], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xc68], dl
movsx eax, byte [ebp - 0xc68]
xor eax, 0xffffff98
mov byte [ebp - 0xc69], al
mov cl, byte [ebp - 0xc69]
mov byte [ebp - 0x2143], cl
mov edx, 1
imul eax, edx, 0x12
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xc70], cl
movsx edx, byte [ebp - 0xc70]
xor edx, 0xffffff98
mov byte [ebp - 0xc71], dl
mov al, byte [ebp - 0xc71]
mov byte [ebp - 0x2142], al
mov dword [ebp - 0x1f34], 0
jmp 0x1013264c
mov ecx, dword [ebp - 0x1f34]
add ecx, 1
mov dword [ebp - 0x1f34], ecx
cmp dword [ebp - 0x1f34], 0x13
jae 0x101326ce
lea edx, [ebp - 0x2154]
mov dword [ebp - 0x2948], edx
mov eax, dword [ebp - 0x2948]
add eax, dword [ebp - 0x1f34]
mov dword [ebp - 0x294c], eax
mov ecx, dword [ebp - 0x294c]
mov dl, byte [ecx]
mov byte [ebp - 0xc78], dl
mov al, byte [ebp - 0x21d1]
mov byte [ebp - 0x2c4], al
movsx ecx, byte [ebp - 0xc78]
xor ecx, 0xffffff98
mov byte [ebp - 0x2c4], cl
lea edx, [ebp - 0x2154]
mov dword [ebp - 0x2950], edx
mov eax, dword [ebp - 0x2950]
add eax, dword [ebp - 0x1f34]
mov dword [ebp - 0x2954], eax
mov ecx, dword [ebp - 0x2954]
mov dl, byte [ebp - 0x2c4]
mov byte [ecx], dl
jmp 0x1013263d
lea eax, [ebp - 0x2154]
mov dword [ebp - 0x2958], eax
mov ecx, dword [ebp - 0x2958]
mov dword [ebp - 0x2434], ecx
lea edx, [ebp - 0x3c50]
mov dword [ebp - 0x295c], edx
movzx eax, byte [ebp - 0x21d2]
push eax
mov ecx, dword [ebp - 0x295c]
call fcn.1008cde0
mov byte [ebp - 4], 0x4c
mov ecx, dword [ebp - 0x2434]
mov dword [ebp - 0x1b34], ecx
mov edx, dword [ebp - 0x1b34]
add edx, 1
mov dword [ebp - 0x2960], edx
mov eax, dword [ebp - 0x1b34]
mov cl, byte [eax]
mov byte [ebp - 0xc79], cl
add dword [ebp - 0x1b34], 1
cmp byte [ebp - 0xc79], 0
jne 0x10132724
mov edx, dword [ebp - 0x1b34]
sub edx, dword [ebp - 0x2960]
mov dword [ebp - 0x2964], edx
mov eax, dword [ebp - 0x2964]
mov dword [ebp - 0x2968], eax
mov ecx, dword [ebp - 0x2968]
mov dword [ebp - 0x296c], ecx
mov edx, dword [ebp - 0x296c]
push edx
mov eax, dword [ebp - 0x2434]
push eax
lea ecx, [ebp - 0x3c50]
call fcn.1008ce30
mov byte [ebp - 4], 0x4d
lea ecx, [ebp - 0x3a70]
mov dword [ebp - 0x2970], ecx
movzx edx, byte [ebp - 0x21d3]
push edx
mov ecx, dword [ebp - 0x2970]
call fcn.1008cde0
mov byte [ebp - 4], 0x4e
mov dword [ebp - 0x1b38], 0x1031e566
mov eax, dword [ebp - 0x1b38]
add eax, 1
mov dword [ebp - 0x2974], eax
mov ecx, dword [ebp - 0x1b38]
mov dl, byte [ecx]
mov byte [ebp - 0xc7a], dl
add dword [ebp - 0x1b38], 1
cmp byte [ebp - 0xc7a], 0
jne 0x101327c5