Function at 0x1016dca0
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 0x1031678a
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x4588
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 - 0x130], ecx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.visuals]
mov byte [ebp - 0x192c], dl
movsx eax, byte [ebp - 0x192c]
xor eax, 0xffffff98
mov byte [ebp - 0x1a35], al
mov cl, byte [ebp - 0x1a35]
mov byte [ebp - 0x2064], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1a3c], al
movsx ecx, byte [ebp - 0x1a3c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a3d], cl
mov dl, byte [ebp - 0x1a3d]
mov byte [ebp - 0x2063], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1a44], cl
movsx edx, byte [ebp - 0x1a44]
xor edx, 0xffffff98
mov byte [ebp - 0x1a45], dl
mov al, byte [ebp - 0x1a45]
mov byte [ebp - 0x2062], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1a4c], al
movsx ecx, byte [ebp - 0x1a4c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a4d], cl
mov dl, byte [ebp - 0x1a4d]
mov byte [ebp - 0x2061], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1a54], cl
movsx edx, byte [ebp - 0x1a54]
xor edx, 0xffffff98
mov byte [ebp - 0x1a55], dl
mov al, byte [ebp - 0x1a55]
mov byte [ebp - 0x2060], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1a5c], al
movsx ecx, byte [ebp - 0x1a5c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a5d], cl
mov dl, byte [ebp - 0x1a5d]
mov byte [ebp - 0x205f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.visuals]
mov byte [ebp - 0x1a64], dl
movsx eax, byte [ebp - 0x1a64]
xor eax, 0xffffff98
mov byte [ebp - 0x1a65], al
mov cl, byte [ebp - 0x1a65]
mov byte [ebp - 0x205e], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1a6c], cl
movsx edx, byte [ebp - 0x1a6c]
xor edx, 0xffffff98
mov byte [ebp - 0x1a6d], dl
mov al, byte [ebp - 0x1a6d]
mov byte [ebp - 0x205d], al
mov dword [ebp - 0x1f30], 0
jmp 0x1016de83
mov ecx, dword [ebp - 0x1f30]
add ecx, 1
mov dword [ebp - 0x1f30], ecx
cmp dword [ebp - 0x1f30], 8
jae 0x1016df05
lea edx, [ebp - 0x2064]
mov dword [ebp - 0x3344], edx
mov eax, dword [ebp - 0x3344]
add eax, dword [ebp - 0x1f30]
mov dword [ebp - 0x336c], eax
mov ecx, dword [ebp - 0x336c]
mov dl, byte [ecx]
mov byte [ebp - 0x1a74], dl
mov al, byte [ebp - 0x23c1]
mov byte [ebp - 0x19d], al
movsx ecx, byte [ebp - 0x1a74]
xor ecx, 0xffffff98
mov byte [ebp - 0x19d], cl
lea edx, [ebp - 0x2064]
mov dword [ebp - 0x33bc], edx
mov eax, dword [ebp - 0x33bc]
add eax, dword [ebp - 0x1f30]
mov dword [ebp - 0x340c], eax
mov ecx, dword [ebp - 0x340c]
mov dl, byte [ebp - 0x19d]
mov byte [ecx], dl
jmp 0x1016de74
lea eax, [ebp - 0x2064]
mov dword [ebp - 0x3540], eax
mov ecx, dword [ebp - 0x3540]
mov dword [ebp - 0x2500], ecx
lea edx, [ebp - 0x3e04]
mov dword [ebp - 0x3574], edx
movzx eax, byte [ebp - 0x23c2]
push eax
mov ecx, dword [ebp - 0x3574]
call fcn.1008cde0
mov dword [ebp - 4], 0
mov ecx, dword [ebp - 0x2500]
mov dword [ebp - 0x1f34], ecx
mov edx, dword [ebp - 0x1f34]
add edx, 1
mov dword [ebp - 0x35a8], edx
mov eax, dword [ebp - 0x1f34]
mov cl, byte [eax]
mov byte [ebp - 0x1a75], cl
add dword [ebp - 0x1f34], 1
cmp byte [ebp - 0x1a75], 0
jne 0x1016df5e
mov edx, dword [ebp - 0x1f34]
sub edx, dword [ebp - 0x35a8]
mov dword [ebp - 0x35f0], edx
mov eax, dword [ebp - 0x35f0]
mov dword [ebp - 0x35f4], eax
mov ecx, dword [ebp - 0x35f4]
mov dword [ebp - 0x35f8], ecx
mov edx, dword [ebp - 0x35f8]
push edx
mov eax, dword [ebp - 0x2500]
push eax
lea ecx, [ebp - 0x3e04]
call fcn.1008ce30
mov dword [ebp - 4], 1
lea ecx, [ebp - 0x3e04]
push ecx
mov ecx, dword [ebp - 0x130]
call fcn.100ad110
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3e04]
call fcn.1008b960
mov edx, dword [ebp - 0x130]
add edx, 0x584
mov dword [ebp - 0x148], edx
lea eax, [ebp - 0x23c3]
mov dword [ebp - 0x3700], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.night_mode]
mov byte [ebp - 0x1a7c], al
movsx ecx, byte [ebp - 0x1a7c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a7d], cl
mov dl, byte [ebp - 0x1a7d]
mov byte [ebp - 0x2108], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.night_mode]
mov byte [ebp - 0x1a84], cl
movsx edx, byte [ebp - 0x1a84]
xor edx, 0xffffff98
mov byte [ebp - 0x1a85], dl
mov al, byte [ebp - 0x1a85]
mov byte [ebp - 0x2107], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.night_mode]
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 - 0x2106], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.night_mode]
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 - 0x2105], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.night_mode]
mov byte [ebp - 0x1ac0], dl
movsx eax, byte [ebp - 0x1ac0]
xor eax, 0xffffff98
mov byte [ebp - 0x1ac1], al
mov cl, byte [ebp - 0x1ac1]
mov byte [ebp - 0x2104], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.night_mode]
mov byte [ebp - 0x1ac8], cl
movsx edx, byte [ebp - 0x1ac8]
xor edx, 0xffffff98
mov byte [ebp - 0x1ac9], dl
mov al, byte [ebp - 0x1ac9]
mov byte [ebp - 0x2103], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.night_mode]
mov byte [ebp - 0x1ad0], al
movsx ecx, byte [ebp - 0x1ad0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ad1], cl
mov dl, byte [ebp - 0x1ad1]
mov byte [ebp - 0x2102], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.night_mode]
mov byte [ebp - 0x1ad8], dl
movsx eax, byte [ebp - 0x1ad8]
xor eax, 0xffffff98
mov byte [ebp - 0x1ad9], al
mov cl, byte [ebp - 0x1ad9]
mov byte [ebp - 0x2101], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.night_mode]
mov byte [ebp - 0x1ae0], al
movsx ecx, byte [ebp - 0x1ae0]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ae1], cl
mov dl, byte [ebp - 0x1ae1]
mov byte [ebp - 0x2100], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.night_mode]
mov byte [ebp - 0x1ae8], dl
movsx eax, byte [ebp - 0x1ae8]
xor eax, 0xffffff98
mov byte [ebp - 0x1ae9], al
mov cl, byte [ebp - 0x1ae9]
mov byte [ebp - 0x20ff], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.night_mode]
mov byte [ebp - 0x1af0], cl
movsx edx, byte [ebp - 0x1af0]
xor edx, 0xffffff98
mov byte [ebp - 0x1af1], dl
mov al, byte [ebp - 0x1af1]
mov byte [ebp - 0x20fe], al
mov dword [ebp - 0x1f38], 0
jmp 0x1016e232
mov ecx, dword [ebp - 0x1f38]
add ecx, 1
mov dword [ebp - 0x1f38], ecx
cmp dword [ebp - 0x1f38], 0xb
jae 0x1016e2b4
lea edx, [ebp - 0x2108]
mov dword [ebp - 0x35fc], edx
mov eax, dword [ebp - 0x35fc]
add eax, dword [ebp - 0x1f38]
mov dword [ebp - 0x3600], eax
mov ecx, dword [ebp - 0x3600]
mov dl, byte [ecx]
mov byte [ebp - 0x1af8], dl
mov al, byte [ebp - 0x23c4]
mov byte [ebp - 0x19e], al
movsx ecx, byte [ebp - 0x1af8]
xor ecx, 0xffffff98
mov byte [ebp - 0x19e], cl
lea edx, [ebp - 0x2108]
mov dword [ebp - 0x3604], edx
mov eax, dword [ebp - 0x3604]
add eax, dword [ebp - 0x1f38]
mov dword [ebp - 0x3608], eax
mov ecx, dword [ebp - 0x3608]
mov dl, byte [ebp - 0x19e]
mov byte [ecx], dl
jmp 0x1016e223
lea eax, [ebp - 0x2108]
mov dword [ebp - 0x360c], eax
mov ecx, dword [ebp - 0x360c]
mov dword [ebp - 0x2504], ecx
lea edx, [ebp - 0x43c8]
mov dword [ebp - 0x3610], edx
movzx eax, byte [ebp - 0x23c5]
push eax
mov ecx, dword [ebp - 0x3610]
call fcn.1008cde0
mov dword [ebp - 4], 2
mov ecx, dword [ebp - 0x2504]
mov dword [ebp - 0x1f3c], ecx
mov edx, dword [ebp - 0x1f3c]
add edx, 1
mov dword [ebp - 0x3614], edx
mov eax, dword [ebp - 0x1f3c]
mov cl, byte [eax]
mov byte [ebp - 0x1af9], cl
add dword [ebp - 0x1f3c], 1
cmp byte [ebp - 0x1af9], 0
jne 0x1016e30d
mov edx, dword [ebp - 0x1f3c]
sub edx, dword [ebp - 0x3614]
mov dword [ebp - 0x3618], edx
mov eax, dword [ebp - 0x3618]
mov dword [ebp - 0x361c], eax
mov ecx, dword [ebp - 0x361c]
mov dword [ebp - 0x3620], ecx
mov edx, dword [ebp - 0x3620]
push edx
mov eax, dword [ebp - 0x2504]
push eax
lea ecx, [ebp - 0x43c8]
call fcn.1008ce30
mov dword [ebp - 4], 3
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.full_bright]
mov byte [ebp - 0x1b00], al
movsx ecx, byte [ebp - 0x1b00]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b01], cl
mov dl, byte [ebp - 0x1b01]
mov byte [ebp - 0x2180], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.full_bright]
mov byte [ebp - 0x1b08], cl
movsx edx, byte [ebp - 0x1b08]
xor edx, 0xffffff98
mov byte [ebp - 0x1b09], dl
mov al, byte [ebp - 0x1b09]
mov byte [ebp - 0x217f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.full_bright]
mov byte [ebp - 0x1b10], dl
movsx eax, byte [ebp - 0x1b10]
xor eax, 0xffffff98
mov byte [ebp - 0x1b11], al
mov cl, byte [ebp - 0x1b11]
mov byte [ebp - 0x217e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.full_bright]
mov byte [ebp - 0x1b18], cl
movsx edx, byte [ebp - 0x1b18]
xor edx, 0xffffff98
mov byte [ebp - 0x1b19], dl
mov al, byte [ebp - 0x1b19]
mov byte [ebp - 0x217d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.full_bright]
mov byte [ebp - 0x1b20], dl
movsx eax, byte [ebp - 0x1b20]
xor eax, 0xffffff98
mov byte [ebp - 0x1b21], al
mov cl, byte [ebp - 0x1b21]
mov byte [ebp - 0x217c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.full_bright]
mov byte [ebp - 0x1b28], cl
movsx edx, byte [ebp - 0x1b28]
xor edx, 0xffffff98
mov byte [ebp - 0x1b29], dl
mov al, byte [ebp - 0x1b29]
mov byte [ebp - 0x217b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.full_bright]
mov byte [ebp - 0x1b30], al
movsx ecx, byte [ebp - 0x1b30]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b31], cl
mov dl, byte [ebp - 0x1b31]
mov byte [ebp - 0x217a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.full_bright]
mov byte [ebp - 0x1b38], dl
movsx eax, byte [ebp - 0x1b38]
xor eax, 0xffffff98
mov byte [ebp - 0x1b39], al
mov cl, byte [ebp - 0x1b39]
mov byte [ebp - 0x2179], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.full_bright]
mov byte [ebp - 0x1b40], al
movsx ecx, byte [ebp - 0x1b40]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b41], cl
mov dl, byte [ebp - 0x1b41]
mov byte [ebp - 0x2178], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.full_bright]
mov byte [ebp - 0x1b48], dl
movsx eax, byte [ebp - 0x1b48]
xor eax, 0xffffff98
mov byte [ebp - 0x1b49], al
mov cl, byte [ebp - 0x1b49]
mov byte [ebp - 0x2177], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.full_bright]
mov byte [ebp - 0x1b50], cl
movsx edx, byte [ebp - 0x1b50]
xor edx, 0xffffff98
mov byte [ebp - 0x1b51], dl
mov al, byte [ebp - 0x1b51]
mov byte [ebp - 0x2176], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.full_bright]
mov byte [ebp - 0x1b58], al
movsx ecx, byte [ebp - 0x1b58]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b59], cl
mov dl, byte [ebp - 0x1b59]
mov byte [ebp - 0x2175], dl
mov dword [ebp - 0x1f40], 0
jmp 0x1016e5cf
mov eax, dword [ebp - 0x1f40]
add eax, 1
mov dword [ebp - 0x1f40], eax
cmp dword [ebp - 0x1f40], 0xc
jae 0x1016e651
lea ecx, [ebp - 0x2180]
mov dword [ebp - 0x3624], ecx
mov edx, dword [ebp - 0x3624]
add edx, dword [ebp - 0x1f40]
mov dword [ebp - 0x3628], edx
mov eax, dword [ebp - 0x3628]
mov cl, byte [eax]
mov byte [ebp - 0x1b60], cl
mov dl, byte [ebp - 0x23c6]
mov byte [ebp - 0x19f], dl
movsx eax, byte [ebp - 0x1b60]
xor eax, 0xffffff98
mov byte [ebp - 0x19f], al
lea ecx, [ebp - 0x2180]
mov dword [ebp - 0x362c], ecx
mov edx, dword [ebp - 0x362c]
add edx, dword [ebp - 0x1f40]
mov dword [ebp - 0x3630], edx
mov eax, dword [ebp - 0x3630]
mov cl, byte [ebp - 0x19f]
mov byte [eax], cl
jmp 0x1016e5c0
lea edx, [ebp - 0x2180]
mov dword [ebp - 0x3634], edx
mov eax, dword [ebp - 0x3634]
mov dword [ebp - 0x2508], eax
lea ecx, [ebp - 0x43b0]
mov dword [ebp - 0x3638], ecx
movzx edx, byte [ebp - 0x23c7]
push edx
mov ecx, dword [ebp - 0x3638]
call fcn.1008cde0
mov byte [ebp - 4], 4
mov eax, dword [ebp - 0x2508]
mov dword [ebp - 0x1f44], eax
mov ecx, dword [ebp - 0x1f44]
add ecx, 1
mov dword [ebp - 0x363c], ecx
mov edx, dword [ebp - 0x1f44]
mov al, byte [edx]
mov byte [ebp - 0x1b65], al
add dword [ebp - 0x1f44], 1
cmp byte [ebp - 0x1b65], 0
jne 0x1016e6a7
mov ecx, dword [ebp - 0x1f44]
sub ecx, dword [ebp - 0x363c]
mov dword [ebp - 0x36a4], ecx
mov edx, dword [ebp - 0x36a4]
mov dword [ebp - 0x36a8], edx
mov eax, dword [ebp - 0x36a8]
mov dword [ebp - 0x36ac], eax
mov ecx, dword [ebp - 0x36ac]
push ecx
mov edx, dword [ebp - 0x2508]
push edx
lea ecx, [ebp - 0x43b0]
call fcn.1008ce30
mov byte [ebp - 4], 5
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.ambient]
mov byte [ebp - 0x1b6c], dl
movsx eax, byte [ebp - 0x1b6c]
xor eax, 0xffffff98
mov byte [ebp - 0x1b6d], al
mov cl, byte [ebp - 0x1b6d]
mov byte [ebp - 0x205c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.ambient]
mov byte [ebp - 0x1b74], al
movsx ecx, byte [ebp - 0x1b74]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b75], cl
mov dl, byte [ebp - 0x1b75]
mov byte [ebp - 0x205b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.ambient]
mov byte [ebp - 0x1b7c], cl
movsx edx, byte [ebp - 0x1b7c]
xor edx, 0xffffff98
mov byte [ebp - 0x1b7d], dl
mov al, byte [ebp - 0x1b7d]
mov byte [ebp - 0x205a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.ambient]
mov byte [ebp - 0x1b84], al
movsx ecx, byte [ebp - 0x1b84]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b85], cl
mov dl, byte [ebp - 0x1b85]
mov byte [ebp - 0x2059], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.ambient]
mov byte [ebp - 0x1b8c], cl
movsx edx, byte [ebp - 0x1b8c]
xor edx, 0xffffff98
mov byte [ebp - 0x1b8d], dl
mov al, byte [ebp - 0x1b8d]
mov byte [ebp - 0x2058], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.ambient]
mov byte [ebp - 0x1b94], al
movsx ecx, byte [ebp - 0x1b94]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b95], cl
mov dl, byte [ebp - 0x1b95]
mov byte [ebp - 0x2057], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.ambient]
mov byte [ebp - 0x1b9c], dl
movsx eax, byte [ebp - 0x1b9c]
xor eax, 0xffffff98
mov byte [ebp - 0x1b9d], al
mov cl, byte [ebp - 0x1b9d]
mov byte [ebp - 0x2056], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.ambient]
mov byte [ebp - 0x1ba4], cl
movsx edx, byte [ebp - 0x1ba4]
xor edx, 0xffffff98
mov byte [ebp - 0x1ba5], dl
mov al, byte [ebp - 0x1ba5]
mov byte [ebp - 0x2055], al
mov dword [ebp - 0x1f48], 0
jmp 0x1016e8a6
mov ecx, dword [ebp - 0x1f48]
add ecx, 1
mov dword [ebp - 0x1f48], ecx
cmp dword [ebp - 0x1f48], 8
jae 0x1016e928
lea edx, [ebp - 0x205c]
mov dword [ebp - 0x36b0], edx
mov eax, dword [ebp - 0x36b0]
add eax, dword [ebp - 0x1f48]
mov dword [ebp - 0x36b4], eax
mov ecx, dword [ebp - 0x36b4]
mov dl, byte [ecx]
mov byte [ebp - 0x1bac], dl
mov al, byte [ebp - 0x23c8]
mov byte [ebp - 0x1a0], al
movsx ecx, byte [ebp - 0x1bac]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a0], cl
lea edx, [ebp - 0x205c]
mov dword [ebp - 0x36b8], edx
mov eax, dword [ebp - 0x36b8]
add eax, dword [ebp - 0x1f48]
mov dword [ebp - 0x36bc], eax
mov ecx, dword [ebp - 0x36bc]
mov dl, byte [ebp - 0x1a0]
mov byte [ecx], dl
jmp 0x1016e897
lea eax, [ebp - 0x205c]
mov dword [ebp - 0x36c0], eax
mov ecx, dword [ebp - 0x36c0]
mov dword [ebp - 0x250c], ecx
lea edx, [ebp - 0x4398]
mov dword [ebp - 0x36c4], edx
movzx eax, byte [ebp - 0x23c9]
push eax
mov ecx, dword [ebp - 0x36c4]
call fcn.1008cde0
mov byte [ebp - 4], 6
mov ecx, dword [ebp - 0x250c]
mov dword [ebp - 0x1f58], ecx
mov edx, dword [ebp - 0x1f58]
add edx, 1
mov dword [ebp - 0x36c8], edx
mov eax, dword [ebp - 0x1f58]
mov cl, byte [eax]
mov byte [ebp - 0x1bad], cl
add dword [ebp - 0x1f58], 1
cmp byte [ebp - 0x1bad], 0
jne 0x1016e97e
mov edx, dword [ebp - 0x1f58]
sub edx, dword [ebp - 0x36c8]
mov dword [ebp - 0x36cc], edx
mov eax, dword [ebp - 0x36cc]
mov dword [ebp - 0x36d0], eax
mov ecx, dword [ebp - 0x36d0]
mov dword [ebp - 0x36d4], ecx
mov edx, dword [ebp - 0x36d4]
push edx
mov eax, dword [ebp - 0x250c]
push eax
lea ecx, [ebp - 0x4398]
call fcn.1008ce30
mov byte [ebp - 4], 7
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.transparency]
mov byte [ebp - 0x1bb4], al
movsx ecx, byte [ebp - 0x1bb4]
xor ecx, 0xffffff98
mov byte [ebp - 0x1bb5], cl
mov dl, byte [ebp - 0x1bb5]
mov byte [ebp - 0x220c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.transparency]
mov byte [ebp - 0x1bbc], cl
movsx edx, byte [ebp - 0x1bbc]
xor edx, 0xffffff98
mov byte [ebp - 0x1bbd], dl
mov al, byte [ebp - 0x1bbd]
mov byte [ebp - 0x220b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.transparency]
mov byte [ebp - 0x1bc4], dl
movsx eax, byte [ebp - 0x1bc4]
xor eax, 0xffffff98
mov byte [ebp - 0x1bc5], al
mov cl, byte [ebp - 0x1bc5]
mov byte [ebp - 0x220a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.transparency]
mov byte [ebp - 0x1bcc], cl
movsx edx, byte [ebp - 0x1bcc]
xor edx, 0xffffff98
mov byte [ebp - 0x1bcd], dl
mov al, byte [ebp - 0x1bcd]
mov byte [ebp - 0x2209], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.transparency]
mov byte [ebp - 0x1bd4], dl
movsx eax, byte [ebp - 0x1bd4]
xor eax, 0xffffff98
mov byte [ebp - 0x1bd5], al
mov cl, byte [ebp - 0x1bd5]
mov byte [ebp - 0x2208], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.transparency]
mov byte [ebp - 0x1bdc], cl
movsx edx, byte [ebp - 0x1bdc]
xor edx, 0xffffff98
mov byte [ebp - 0x1bdd], dl
mov al, byte [ebp - 0x1bdd]
mov byte [ebp - 0x2207], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.transparency]
mov byte [ebp - 0x1be4], al
movsx ecx, byte [ebp - 0x1be4]
xor ecx, 0xffffff98
mov byte [ebp - 0x1be5], cl
mov dl, byte [ebp - 0x1be5]
mov byte [ebp - 0x2206], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.transparency]
mov byte [ebp - 0x1bec], dl
movsx eax, byte [ebp - 0x1bec]
xor eax, 0xffffff98
mov byte [ebp - 0x1bed], al
mov cl, byte [ebp - 0x1bed]
mov byte [ebp - 0x2205], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.transparency]
mov byte [ebp - 0x1bf4], al
movsx ecx, byte [ebp - 0x1bf4]
xor ecx, 0xffffff98
mov byte [ebp - 0x1bf5], cl
mov dl, byte [ebp - 0x1bf5]
mov byte [ebp - 0x2204], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.transparency]
mov byte [ebp - 0x1bfc], dl
movsx eax, byte [ebp - 0x1bfc]
xor eax, 0xffffff98
mov byte [ebp - 0x1bfd], al
mov cl, byte [ebp - 0x1bfd]
mov byte [ebp - 0x2203], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.transparency]
mov byte [ebp - 0x1c04], cl
movsx edx, byte [ebp - 0x1c04]
xor edx, 0xffffff98
mov byte [ebp - 0x1c05], dl
mov al, byte [ebp - 0x1c05]
mov byte [ebp - 0x2202], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.transparency]
mov byte [ebp - 0x1c0c], al
movsx ecx, byte [ebp - 0x1c0c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c0d], cl
mov dl, byte [ebp - 0x1c0d]
mov byte [ebp - 0x2201], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.transparency]
mov byte [ebp - 0x1c14], dl
movsx eax, byte [ebp - 0x1c14]
xor eax, 0xffffff98
mov byte [ebp - 0x1c15], al
mov cl, byte [ebp - 0x1c15]
mov byte [ebp - 0x2200], cl
mov dword [ebp - 0x1f5c], 0
jmp 0x1016ec6d
mov edx, dword [ebp - 0x1f5c]
add edx, 1
mov dword [ebp - 0x1f5c], edx
cmp dword [ebp - 0x1f5c], 0xd
jae 0x1016ecef
lea eax, [ebp - 0x220c]
mov dword [ebp - 0x36d8], eax
mov ecx, dword [ebp - 0x36d8]
add ecx, dword [ebp - 0x1f5c]
mov dword [ebp - 0x36dc], ecx
mov edx, dword [ebp - 0x36dc]
mov al, byte [edx]
mov byte [ebp - 0x1c1c], al
mov cl, byte [ebp - 0x23ca]
mov byte [ebp - 0x1a1], cl
movsx edx, byte [ebp - 0x1c1c]
xor edx, 0xffffff98
mov byte [ebp - 0x1a1], dl
lea eax, [ebp - 0x220c]
mov dword [ebp - 0x36e0], eax
mov ecx, dword [ebp - 0x36e0]
add ecx, dword [ebp - 0x1f5c]
mov dword [ebp - 0x36e4], ecx
mov edx, dword [ebp - 0x36e4]
mov al, byte [ebp - 0x1a1]
mov byte [edx], al
jmp 0x1016ec5e
lea ecx, [ebp - 0x220c]
mov dword [ebp - 0x36e8], ecx
mov edx, dword [ebp - 0x36e8]
mov dword [ebp - 0x2510], edx
lea eax, [ebp - 0x4380]
mov dword [ebp - 0x36ec], eax
movzx ecx, byte [ebp - 0x23cb]
push ecx
mov ecx, dword [ebp - 0x36ec]
call fcn.1008cde0
mov byte [ebp - 4], 8
mov edx, dword [ebp - 0x2510]
mov dword [ebp - 0x1f60], edx
mov eax, dword [ebp - 0x1f60]
add eax, 1
mov dword [ebp - 0x36f0], eax
mov ecx, dword [ebp - 0x1f60]
mov dl, byte [ecx]
mov byte [ebp - 0x1c1d], dl
add dword [ebp - 0x1f60], 1
cmp byte [ebp - 0x1c1d], 0
jne 0x1016ed45
mov eax, dword [ebp - 0x1f60]
sub eax, dword [ebp - 0x36f0]
mov dword [ebp - 0x36f4], eax
mov ecx, dword [ebp - 0x36f4]
mov dword [ebp - 0x36f8], ecx
mov edx, dword [ebp - 0x36f8]
mov dword [ebp - 0x36fc], edx
mov eax, dword [ebp - 0x36fc]
push eax
mov ecx, dword [ebp - 0x2510]
push ecx
lea ecx, [ebp - 0x4380]
call fcn.1008ce30
mov dword [ebp - 4], 9
lea edx, [ebp - 0x43c8]
mov dword [ebp - 0x3644], edx
lea eax, [ebp - 0x4368]
mov dword [ebp - 0x3640], eax
mov ecx, dword [ebp - 0x3644]
mov edx, dword [ebp - 0x3640]
mov dword [ebp - 0x3650], ecx
mov dword [ebp - 0x364c], edx
mov eax, dword [ebp - 0x3700]
push eax
mov ecx, dword [ebp - 0x364c]
push ecx
mov edx, dword [ebp - 0x3650]
push edx
lea ecx, [ebp - 0x38a4]
call fcn.10260fe0
mov byte [ebp - 4], 0xa
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.world]
mov byte [ebp - 0x1c24], dl
movsx eax, byte [ebp - 0x1c24]
xor eax, 0xffffff98
mov byte [ebp - 0x1c25], al
mov cl, byte [ebp - 0x1c25]
mov byte [ebp - 0x1f68], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.world]
mov byte [ebp - 0x1c2c], al
movsx ecx, byte [ebp - 0x1c2c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c2d], cl
mov dl, byte [ebp - 0x1c2d]
mov byte [ebp - 0x1f67], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.world]
mov byte [ebp - 0x1c34], cl
movsx edx, byte [ebp - 0x1c34]
xor edx, 0xffffff98
mov byte [ebp - 0x1c35], dl
mov al, byte [ebp - 0x1c35]
mov byte [ebp - 0x1f66], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.world]
mov byte [ebp - 0x1c3c], al
movsx ecx, byte [ebp - 0x1c3c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c3d], cl
mov dl, byte [ebp - 0x1c3d]
mov byte [ebp - 0x1f65], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.world]
mov byte [ebp - 0x1c44], cl
movsx edx, byte [ebp - 0x1c44]
xor edx, 0xffffff98
mov byte [ebp - 0x1c45], dl
mov al, byte [ebp - 0x1c45]
mov byte [ebp - 0x1f64], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.world]
mov byte [ebp - 0x1c4c], al
movsx ecx, byte [ebp - 0x1c4c]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c4d], cl
mov dl, byte [ebp - 0x1c4d]
mov byte [ebp - 0x1f63], dl
mov dword [ebp - 0x1fa4], 0
jmp 0x1016ef3b
mov eax, dword [ebp - 0x1fa4]
add eax, 1
mov dword [ebp - 0x1fa4], eax
cmp dword [ebp - 0x1fa4], 6
jae 0x1016efbd
lea ecx, [ebp - 0x1f68]
mov dword [ebp - 0x3704], ecx
mov edx, dword [ebp - 0x3704]
add edx, dword [ebp - 0x1fa4]
mov dword [ebp - 0x3708], edx
mov eax, dword [ebp - 0x3708]
mov cl, byte [eax]
mov byte [ebp - 0x1c54], cl
mov dl, byte [ebp - 0x23cc]
mov byte [ebp - 0x1a2], dl
movsx eax, byte [ebp - 0x1c54]
xor eax, 0xffffff98
mov byte [ebp - 0x1a2], al
lea ecx, [ebp - 0x1f68]
mov dword [ebp - 0x370c], ecx
mov edx, dword [ebp - 0x370c]
add edx, dword [ebp - 0x1fa4]
mov dword [ebp - 0x3710], edx
mov eax, dword [ebp - 0x3710]
mov cl, byte [ebp - 0x1a2]
mov byte [eax], cl
jmp 0x1016ef2c
lea edx, [ebp - 0x1f68]
mov dword [ebp - 0x3714], edx
mov eax, dword [ebp - 0x3714]
mov dword [ebp - 0x2514], eax
lea ecx, [ebp - 0x3e34]
mov dword [ebp - 0x3718], ecx
movzx edx, byte [ebp - 0x23cd]
push edx
mov ecx, dword [ebp - 0x3718]
call fcn.1008cde0
mov byte [ebp - 4], 0xb
mov eax, dword [ebp - 0x2514]
mov dword [ebp - 0x1fa8], eax
mov ecx, dword [ebp - 0x1fa8]
add ecx, 1
mov dword [ebp - 0x371c], ecx
mov edx, dword [ebp - 0x1fa8]
mov al, byte [edx]
mov byte [ebp - 0x1c55], al
add dword [ebp - 0x1fa8], 1
cmp byte [ebp - 0x1c55], 0
jne 0x1016f013
mov ecx, dword [ebp - 0x1fa8]
sub ecx, dword [ebp - 0x371c]
mov dword [ebp - 0x3720], ecx
mov edx, dword [ebp - 0x3720]
mov dword [ebp - 0x3724], edx
mov eax, dword [ebp - 0x3724]
mov dword [ebp - 0x3728], eax
mov ecx, dword [ebp - 0x3728]
push ecx
mov edx, dword [ebp - 0x2514]
push edx
lea ecx, [ebp - 0x3e34]
call fcn.1008ce30
mov byte [ebp - 4], 0xc
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x1c5c], dl
movsx eax, byte [ebp - 0x1c5c]
xor eax, 0xffffff98
mov byte [ebp - 0x1c5d], al
mov cl, byte [ebp - 0x1c5d]
mov byte [ebp - 0x22b8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.world_modulation]
mov byte [ebp - 0x1c64], al
movsx ecx, byte [ebp - 0x1c64]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c65], cl
mov dl, byte [ebp - 0x1c65]
mov byte [ebp - 0x22b7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x1c6c], cl
movsx edx, byte [ebp - 0x1c6c]
xor edx, 0xffffff98
mov byte [ebp - 0x1c6d], dl
mov al, byte [ebp - 0x1c6d]
mov byte [ebp - 0x22b6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.world_modulation]
mov byte [ebp - 0x1c74], al
movsx ecx, byte [ebp - 0x1c74]
xor ecx, 0xffffff98
mov byte [ebp - 0x1c75], cl
mov dl, byte [ebp - 0x1c75]
mov byte [ebp - 0x22b5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x1c7c], cl
movsx edx, byte [ebp - 0x1c7c]
xor edx, 0xffffff98
mov byte [ebp - 0x505], dl
mov al, byte [ebp - 0x505]
mov byte [ebp - 0x22b4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.world_modulation]
mov byte [ebp - 0x50c], al
movsx ecx, byte [ebp - 0x50c]
xor ecx, 0xffffff98
mov byte [ebp - 0x50d], cl
mov dl, byte [ebp - 0x50d]
mov byte [ebp - 0x22b3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x514], dl
movsx eax, byte [ebp - 0x514]
xor eax, 0xffffff98
mov byte [ebp - 0x515], al
mov cl, byte [ebp - 0x515]
mov byte [ebp - 0x22b2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x51c], cl
movsx edx, byte [ebp - 0x51c]
xor edx, 0xffffff98
mov byte [ebp - 0x51d], dl
mov al, byte [ebp - 0x51d]
mov byte [ebp - 0x22b1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x524], dl
movsx eax, byte [ebp - 0x524]
xor eax, 0xffffff98
mov byte [ebp - 0x525], al
mov cl, byte [ebp - 0x525]
mov byte [ebp - 0x22b0], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x52c], cl
movsx edx, byte [ebp - 0x52c]
xor edx, 0xffffff98
mov byte [ebp - 0x52d], dl
mov al, byte [ebp - 0x52d]
mov byte [ebp - 0x22af], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.world_modulation]
mov byte [ebp - 0x534], al
movsx ecx, byte [ebp - 0x534]
xor ecx, 0xffffff98
mov byte [ebp - 0x535], cl
mov dl, byte [ebp - 0x535]
mov byte [ebp - 0x22ae], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x53c], dl
movsx eax, byte [ebp - 0x53c]
xor eax, 0xffffff98
mov byte [ebp - 0x53d], al
mov cl, byte [ebp - 0x53d]
mov byte [ebp - 0x22ad], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x544], cl
movsx edx, byte [ebp - 0x544]
xor edx, 0xffffff98
mov byte [ebp - 0x545], dl
mov al, byte [ebp - 0x545]
mov byte [ebp - 0x22ac], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.world_modulation]
mov byte [ebp - 0x54c], al
movsx ecx, byte [ebp - 0x54c]
xor ecx, 0xffffff98
mov byte [ebp - 0x54d], cl
mov dl, byte [ebp - 0x54d]
mov byte [ebp - 0x22ab], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x554], dl
movsx eax, byte [ebp - 0x554]
xor eax, 0xffffff98
mov byte [ebp - 0x555], al
mov cl, byte [ebp - 0x555]
mov byte [ebp - 0x22aa], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.world_modulation]
mov byte [ebp - 0x55c], cl
movsx edx, byte [ebp - 0x55c]
xor edx, 0xffffff98
mov byte [ebp - 0x55d], dl
mov al, byte [ebp - 0x55d]
mov byte [ebp - 0x22a9], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.world_modulation]
mov byte [ebp - 0x564], dl
movsx eax, byte [ebp - 0x564]
xor eax, 0xffffff98
mov byte [ebp - 0x565], al
mov cl, byte [ebp - 0x565]
mov byte [ebp - 0x22a8], cl
mov dword [ebp - 0x1fac], 0
jmp 0x1016f3c2
mov edx, dword [ebp - 0x1fac]
add edx, 1
mov dword [ebp - 0x1fac], edx
cmp dword [ebp - 0x1fac], 0x11
jae 0x1016f444
lea eax, [ebp - 0x22b8]
mov dword [ebp - 0x372c], eax
mov ecx, dword [ebp - 0x372c]
add ecx, dword [ebp - 0x1fac]
mov dword [ebp - 0x3730], ecx
mov edx, dword [ebp - 0x3730]
mov al, byte [edx]
mov byte [ebp - 0x56c], al
mov cl, byte [ebp - 0x23ce]
mov byte [ebp - 0x1a3], cl
movsx edx, byte [ebp - 0x56c]
xor edx, 0xffffff98
mov byte [ebp - 0x1a3], dl
lea eax, [ebp - 0x22b8]
mov dword [ebp - 0x3734], eax
mov ecx, dword [ebp - 0x3734]
add ecx, dword [ebp - 0x1fac]
mov dword [ebp - 0x3738], ecx
mov edx, dword [ebp - 0x3738]
mov al, byte [ebp - 0x1a3]
mov byte [edx], al
jmp 0x1016f3b3
lea ecx, [ebp - 0x22b8]
mov dword [ebp - 0x373c], ecx
mov edx, dword [ebp - 0x373c]
mov dword [ebp - 0x2518], edx
lea eax, [ebp - 0x3e1c]
mov dword [ebp - 0x3740], eax
movzx ecx, byte [ebp - 0x23cf]
push ecx
mov ecx, dword [ebp - 0x3740]
call fcn.1008cde0
mov byte [ebp - 4], 0xd
mov edx, dword [ebp - 0x2518]
mov dword [ebp - 0x1fb0], edx
mov eax, dword [ebp - 0x1fb0]
add eax, 1
mov dword [ebp - 0x3744], eax
mov ecx, dword [ebp - 0x1fb0]
mov dl, byte [ecx]
mov byte [ebp - 0x56d], dl
add dword [ebp - 0x1fb0], 1
cmp byte [ebp - 0x56d], 0
jne 0x1016f49a
mov eax, dword [ebp - 0x1fb0]
sub eax, dword [ebp - 0x3744]
mov dword [ebp - 0x3748], eax
mov ecx, dword [ebp - 0x3748]
mov dword [ebp - 0x374c], ecx
mov edx, dword [ebp - 0x374c]
mov dword [ebp - 0x3750], edx
mov eax, dword [ebp - 0x3750]
push eax
mov ecx, dword [ebp - 0x2518]
push ecx
lea ecx, [ebp - 0x3e1c]
call fcn.1008ce30
mov byte [ebp - 4], 0xe
lea edx, [ebp - 0x3898]
mov dword [ebp - 0x2410], edx
mov eax, dword [ebp - 0x2410]
mov dword [ebp - 0x3754], eax
mov ecx, dword [ebp - 0x3754]
call fcn.1008da90
mov ecx, dword [ebp - 0x2410]
mov dword [ebp - 0x3820], ecx
mov edx, dword [ebp - 0x2410]
mov dword [ebp - 0x3824], edx
mov byte [ebp - 4], 0xf
lea eax, [ebp - 0x3e34]
push eax
mov ecx, dword [ebp - 0x148]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x148]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x148]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1016f580
lea ecx, [ebp - 0x3e1c]
push ecx
mov ecx, dword [ebp - 0x148]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x148]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1016f59a
mov dword [ebp - 0x251c], 0xf
jmp 0x1016f5a4
mov dword [ebp - 0x251c], 0
mov ecx, dword [ebp - 0x148]
mov edx, dword [ebp - 0x251c]
mov dword [ecx + 0xa4], edx
mov eax, dword [ebp - 0x148]
mov ecx, dword [eax + 0xa4]
add ecx, 0x14
mov dword [ebp - 0x2520], ecx
mov edx, dword [ebp - 0x148]
mov eax, dword [ebp - 0x2520]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0x148]
mov edx, dword [ebp - 0x2520]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x38a4]
mov dword [ebp - 0x2524], eax
mov ecx, dword [ebp - 0x2524]
mov edx, dword [ecx]
mov dword [ebp - 0x2184], edx
mov eax, dword [ebp - 0x2524]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x3758], ecx
jmp 0x1016f623
mov edx, dword [ebp - 0x2184]
add edx, 0x18
mov dword [ebp - 0x2184], edx
mov eax, dword [ebp - 0x2184]
cmp eax, dword [ebp - 0x3758]
je 0x1016f663
mov ecx, dword [ebp - 0x2184]
mov dword [ebp - 0x375c], ecx
mov edx, dword [ebp - 0x148]
add edx, 0x88
mov dword [ebp - 0x3760], edx
mov eax, dword [ebp - 0x375c]
push eax
mov ecx, dword [ebp - 0x3760]
call fcn.100fca00
jmp 0x1016f614
lea ecx, [ebp - 0x3898]
mov dword [ebp - 0x2528], ecx
mov edx, dword [ebp - 0x2528]
mov eax, dword [edx]
mov dword [ebp - 0x2188], eax
mov ecx, dword [ebp - 0x2528]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x3764], edx
jmp 0x1016f69d
mov eax, dword [ebp - 0x2188]
add eax, 4
mov dword [ebp - 0x2188], eax
mov ecx, dword [ebp - 0x2188]
cmp ecx, dword [ebp - 0x3764]
je 0x1016f824
mov edx, dword [ebp - 0x2188]
mov dword [ebp - 0x3768], edx
mov eax, dword [ebp - 0x3768]
mov ecx, dword [eax]
mov dword [ebp - 0x1c], ecx
mov edx, dword [ebp - 0x148]
add edx, 0x98
mov dword [ebp - 0x376c], edx
lea eax, [ebp - 0x3828]
push eax
mov ecx, dword [ebp - 0x376c]
call fcn.10098ab0
mov ecx, dword [eax]
mov dword [ebp - 0x3774], ecx
mov edx, dword [ebp - 0x148]
add edx, 0x98
mov dword [ebp - 0x3770], edx
lea eax, [ebp - 0x382c]
push eax
mov ecx, dword [ebp - 0x3770]
call fcn.10098af0
mov ecx, dword [eax]
mov dword [ebp - 0x3778], ecx
lea edx, [ebp - 0x1c]
push edx
mov eax, dword [ebp - 0x3774]
push eax
mov ecx, dword [ebp - 0x3778]
push ecx
lea edx, [ebp - 0x3830]
push edx
call fcn.1009a180
add esp, 0x10
mov dword [ebp - 0x3780], eax
mov eax, dword [ebp - 0x148]
add eax, 0x98
mov dword [ebp - 0x377c], eax
lea ecx, [ebp - 0x3834]
push ecx
mov ecx, dword [ebp - 0x377c]
call fcn.10098ab0
mov dword [ebp - 0x3784], eax
mov edx, dword [ebp - 0x3780]
mov eax, dword [ebp - 0x3784]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x1016f78c
mov dword [ebp - 0x252c], 1
jmp 0x1016f796
mov dword [ebp - 0x252c], 0
mov dl, byte [ebp - 0x252c]
mov byte [ebp - 0x56e], dl
mov eax, dword [ebp - 0x148]
add eax, 0x88
mov dword [ebp - 0x2530], eax
mov ecx, dword [ebp - 0x2530]
mov edx, dword [ebp - 0x2530]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x3788], eax
mov edx, dword [ebp - 0x1c]
cmp edx, dword [ebp - 0x3788]
jae 0x1016f7fd
mov eax, dword [ebp - 0x148]
add eax, 0x98
mov dword [ebp - 0x378c], eax
lea ecx, [ebp - 0x1c]
push ecx
mov ecx, dword [ebp - 0x378c]
call fcn.1008c950
movzx edx, byte [ebp - 0x56e]
test edx, edx
je 0x1016f81f
mov eax, dword [ebp - 0x148]
cmp dword [eax + 0x64], 0
je 0x1016f81f
mov ecx, dword [ebp - 0x148]
mov edx, dword [ecx + 0x64]
call edx
jmp 0x1016f68e
mov byte [ebp - 4], 0xe
lea ecx, [ebp - 0x3898]
call fcn.1008b490
mov byte [ebp - 4], 0xc
lea ecx, [ebp - 0x3e1c]
call fcn.1008b960
mov byte [ebp - 4], 0xa
lea ecx, [ebp - 0x3e34]
call fcn.1008b960
mov byte [ebp - 4], 9
lea ecx, [ebp - 0x38a4]
call fcn.10099030
mov dword [ebp - 4], 0xffffffff
push fcn.1008adc0
push 4
push 0x18
lea eax, [ebp - 0x43c8]
push eax
call fcn.1030cc76
mov ecx, dword [ebp - 0x130]
add ecx, 0x584
mov dword [ebp - 0x3790], ecx
mov edx, dword [ebp - 0x3790]
mov dword [edx + 0x64], fcn.102e1320
mov eax, dword [ebp - 0x130]
add eax, 0x584
mov dword [ebp - 0x6c], eax
mov ecx, dword [ebp - 0x6c]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x6c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x6c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x6c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x6c]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x3794], eax
lea ecx, [ebp - 0x6c]
push ecx
mov ecx, dword [ebp - 0x3794]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0x62c
mov dword [ebp - 0x16c], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x10323ad0]
mov word [ebp - 0x24b4], dx
movzx eax, word [ebp - 0x24b4]
xor eax, 0x98
mov word [ebp - 0x24b6], ax
mov cx, word [ebp - 0x24b6]
mov word [ebp - 0x218c], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x10323ad0]
mov word [ebp - 0x24bc], ax
movzx ecx, word [ebp - 0x24bc]
xor ecx, 0x98
mov word [ebp - 0x24be], cx
mov dx, word [ebp - 0x24be]
mov word [ebp - 0x218a], dx
mov dword [ebp - 0x1fb4], 0
jmp 0x1016f999
mov eax, dword [ebp - 0x1fb4]
add eax, 1
mov dword [ebp - 0x1fb4], eax
cmp dword [ebp - 0x1fb4], 2
jae 0x1016fa2f
lea ecx, [ebp - 0x218c]
mov dword [ebp - 0x3798], ecx
mov edx, dword [ebp - 0x1fb4]
mov eax, dword [ebp - 0x3798]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x379c], ecx
mov edx, dword [ebp - 0x379c]
mov ax, word [edx]
mov word [ebp - 0x24c4], ax
mov cx, word [ebp - 0x287a]
mov word [ebp - 0x1f18], cx
movzx edx, word [ebp - 0x24c4]
xor edx, 0x98
mov word [ebp - 0x1f18], dx
lea eax, [ebp - 0x218c]
mov dword [ebp - 0x37a0], eax
mov ecx, dword [ebp - 0x1fb4]
mov edx, dword [ebp - 0x37a0]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x37a4], eax
mov ecx, dword [ebp - 0x37a4]
mov dx, word [ebp - 0x1f18]
mov word [ecx], dx
jmp 0x1016f98a
lea eax, [ebp - 0x218c]
mov dword [ebp - 0x37a8], eax
mov ecx, dword [ebp - 0x37a8]
mov dword [ebp - 0x2534], ecx
lea edx, [ebp - 0x3984]
mov dword [ebp - 0x37ac], edx
movzx eax, byte [ebp - 0x23d0]
push eax
mov ecx, dword [ebp - 0x37ac]
call fcn.1008cde0
mov dword [ebp - 4], 0x10
mov ecx, dword [ebp - 0x2534]
mov dword [ebp - 0x1fbc], ecx
mov edx, dword [ebp - 0x1fbc]
add edx, 2
mov dword [ebp - 0x37b0], edx
mov eax, dword [ebp - 0x1fbc]
mov cx, word [eax]
mov word [ebp - 0x24c6], cx
add dword [ebp - 0x1fbc], 2
cmp word [ebp - 0x24c6], 0
jne 0x1016fa88
mov edx, dword [ebp - 0x1fbc]
sub edx, dword [ebp - 0x37b0]
sar edx, 1
mov dword [ebp - 0x37b4], edx
mov eax, dword [ebp - 0x37b4]
mov dword [ebp - 0x37b8], eax
mov ecx, dword [ebp - 0x37b8]
mov dword [ebp - 0x37bc], ecx
mov edx, dword [ebp - 0x37bc]
push edx
mov eax, dword [ebp - 0x2534]
push eax
lea ecx, [ebp - 0x3984]
call fcn.100b23d0
mov dword [ebp - 4], 0x11
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.nightamt]
mov byte [ebp - 0x574], al
movsx ecx, byte [ebp - 0x574]
xor ecx, 0xffffff98
mov byte [ebp - 0x575], cl
mov dl, byte [ebp - 0x575]
mov byte [ebp - 0x2090], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.nightamt]
mov byte [ebp - 0x57c], cl
movsx edx, byte [ebp - 0x57c]
xor edx, 0xffffff98
mov byte [ebp - 0x57d], dl
mov al, byte [ebp - 0x57d]
mov byte [ebp - 0x208f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.nightamt]
mov byte [ebp - 0x584], dl
movsx eax, byte [ebp - 0x584]
xor eax, 0xffffff98
mov byte [ebp - 0x585], al
mov cl, byte [ebp - 0x585]
mov byte [ebp - 0x208e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.nightamt]
mov byte [ebp - 0x58c], cl
movsx edx, byte [ebp - 0x58c]
xor edx, 0xffffff98
mov byte [ebp - 0x58d], dl
mov al, byte [ebp - 0x58d]
mov byte [ebp - 0x208d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.nightamt]
mov byte [ebp - 0x594], dl
movsx eax, byte [ebp - 0x594]
xor eax, 0xffffff98
mov byte [ebp - 0x595], al
mov cl, byte [ebp - 0x595]
mov byte [ebp - 0x208c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.nightamt]
mov byte [ebp - 0x59c], cl
movsx edx, byte [ebp - 0x59c]
xor edx, 0xffffff98
mov byte [ebp - 0x59d], dl
mov al, byte [ebp - 0x59d]
mov byte [ebp - 0x208b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.nightamt]
mov byte [ebp - 0x5a4], al
movsx ecx, byte [ebp - 0x5a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x5a5], cl
mov dl, byte [ebp - 0x5a5]
mov byte [ebp - 0x208a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.nightamt]
mov byte [ebp - 0x5ac], dl
movsx eax, byte [ebp - 0x5ac]
xor eax, 0xffffff98
mov byte [ebp - 0x5ad], al
mov cl, byte [ebp - 0x5ad]
mov byte [ebp - 0x2089], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.nightamt]
mov byte [ebp - 0x5b4], al
movsx ecx, byte [ebp - 0x5b4]
xor ecx, 0xffffff98
mov byte [ebp - 0x5b5], cl
mov dl, byte [ebp - 0x5b5]
mov byte [ebp - 0x2088], dl
mov dword [ebp - 0x1fc0], 0
jmp 0x1016fcbf
mov eax, dword [ebp - 0x1fc0]
add eax, 1
mov dword [ebp - 0x1fc0], eax
cmp dword [ebp - 0x1fc0], 9
jae 0x1016fd41
lea ecx, [ebp - 0x2090]
mov dword [ebp - 0x37c0], ecx
mov edx, dword [ebp - 0x37c0]
add edx, dword [ebp - 0x1fc0]
mov dword [ebp - 0x37c4], edx
mov eax, dword [ebp - 0x37c4]
mov cl, byte [eax]
mov byte [ebp - 0x5bc], cl
mov dl, byte [ebp - 0x23d1]
mov byte [ebp - 0x1a4], dl
movsx eax, byte [ebp - 0x5bc]
xor eax, 0xffffff98
mov byte [ebp - 0x1a4], al
lea ecx, [ebp - 0x2090]
mov dword [ebp - 0x37c8], ecx
mov edx, dword [ebp - 0x37c8]
add edx, dword [ebp - 0x1fc0]
mov dword [ebp - 0x37cc], edx
mov eax, dword [ebp - 0x37cc]
mov cl, byte [ebp - 0x1a4]
mov byte [eax], cl
jmp 0x1016fcb0
lea edx, [ebp - 0x2090]
mov dword [ebp - 0x37d0], edx
mov eax, dword [ebp - 0x37d0]
mov dword [ebp - 0x2538], eax
lea ecx, [ebp - 0x396c]
mov dword [ebp - 0x37d4], ecx
movzx edx, byte [ebp - 0x23d2]
push edx
mov ecx, dword [ebp - 0x37d4]
call fcn.1008cde0
mov byte [ebp - 4], 0x12
mov eax, dword [ebp - 0x2538]
mov dword [ebp - 0x1fc4], eax
mov ecx, dword [ebp - 0x1fc4]
add ecx, 1
mov dword [ebp - 0x37d8], ecx
mov edx, dword [ebp - 0x1fc4]
mov al, byte [edx]
mov byte [ebp - 0x5bd], al
add dword [ebp - 0x1fc4], 1
cmp byte [ebp - 0x5bd], 0
jne 0x1016fd97
mov ecx, dword [ebp - 0x1fc4]
sub ecx, dword [ebp - 0x37d8]
mov dword [ebp - 0x37dc], ecx
mov edx, dword [ebp - 0x37dc]
mov dword [ebp - 0x37e0], edx
mov eax, dword [ebp - 0x37e0]
mov dword [ebp - 0x37e4], eax
mov ecx, dword [ebp - 0x37e4]
push ecx
mov edx, dword [ebp - 0x2538]
push edx
lea ecx, [ebp - 0x396c]
call fcn.1008ce30
mov byte [ebp - 4], 0x13
lea eax, [ebp - 0x3e4c]
mov dword [ebp - 0x37e8], eax
movzx ecx, byte [ebp - 0x23d3]
push ecx
mov ecx, dword [ebp - 0x37e8]
call fcn.1008cde0
mov byte [ebp - 4], 0x14
mov dword [ebp - 0x1fc8], str.nightmode_amount
mov edx, dword [ebp - 0x1fc8]
add edx, 1
mov dword [ebp - 0x37ec], edx
mov eax, dword [ebp - 0x1fc8]
mov cl, byte [eax]
mov byte [ebp - 0x5be], cl
add dword [ebp - 0x1fc8], 1
cmp byte [ebp - 0x5be], 0
jne 0x1016fe38
mov edx, dword [ebp - 0x1fc8]
sub edx, dword [ebp - 0x37ec]
mov dword [ebp - 0x26b8], edx
mov eax, dword [ebp - 0x26b8]
mov dword [ebp - 0x26bc], eax
mov ecx, dword [ebp - 0x26bc]
mov dword [ebp - 0x26c0], ecx
mov edx, dword [ebp - 0x26c0]
push edx
push str.nightmode_amount
lea ecx, [ebp - 0x3e4c]
call fcn.1008ce30
mov byte [ebp - 4], 0x15
lea eax, [ebp - 0x396c]
push eax
mov ecx, dword [ebp - 0x16c]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x16c]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x16c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1016fee0
lea ecx, [ebp - 0x3e4c]
push ecx
mov ecx, dword [ebp - 0x16c]
add ecx, 0x88
call fcn.100ad110
mov edx, dword [ebp - 0x16c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1016fefa
mov dword [ebp - 0x253c], 0xf
jmp 0x1016ff04
mov dword [ebp - 0x253c], 0
mov ecx, dword [ebp - 0x16c]
mov edx, dword [ebp - 0x253c]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x16c]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x16c]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x16c]
mov ecx, dword [ebp - 0x16c]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x16c]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x16c]
movss xmm0, dword [0x10328a64]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x16c]
movss xmm0, dword [0x10328a64]
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x16c]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x16c]
movss xmm0, dword [0x1032891c]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x3984]
push edx
mov ecx, dword [ebp - 0x16c]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x13
lea ecx, [ebp - 0x3e4c]
call fcn.1008b960
mov byte [ebp - 4], 0x11
lea ecx, [ebp - 0x396c]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3984]
call fcn.100ae140
mov eax, dword [ebp - 0x130]
add eax, 0x62c
mov dword [ebp - 0x26c4], eax
mov dword [ebp - 0xe8], 0x100a81b0
mov ecx, dword [ebp - 0x26c4]
add ecx, 0x58
mov dword [ebp - 0x26cc], ecx
lea edx, [ebp - 0xe8]
push edx
mov ecx, dword [ebp - 0x26cc]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0x62c
mov dword [ebp - 0x26d0], eax
mov ecx, dword [ebp - 0x26d0]
mov dword [ecx + 0x64], fcn.102e1320
mov edx, dword [ebp - 0x130]
add edx, 0x62c
mov dword [ebp - 0xb0], edx
mov eax, dword [ebp - 0xb0]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0xb0]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0xb0]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0xb0]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0xb0]
mov eax, dword [ebp - 0x130]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x130]
add edx, 0x18
mov dword [ebp - 0x26d4], edx
lea eax, [ebp - 0xb0]
push eax
mov ecx, dword [ebp - 0x26d4]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0x6e8
mov dword [ebp - 0x158], ecx
mov edx, 2
imul eax, edx, 0
mov cx, word [eax + 0x10323ad0]
mov word [ebp - 0x24cc], cx
movzx edx, word [ebp - 0x24cc]
xor edx, 0x98
mov word [ebp - 0x24ce], dx
mov ax, word [ebp - 0x24ce]
mov word [ebp - 0x21ac], ax
mov ecx, 2
shl ecx, 0
mov dx, word [ecx + 0x10323ad0]
mov word [ebp - 0x24d4], dx
movzx eax, word [ebp - 0x24d4]
xor eax, 0x98
mov word [ebp - 0x24d6], ax
mov cx, word [ebp - 0x24d6]
mov word [ebp - 0x21aa], cx
mov dword [ebp - 0x1fcc], 0
jmp 0x1017014d
mov edx, dword [ebp - 0x1fcc]
add edx, 1
mov dword [ebp - 0x1fcc], edx
cmp dword [ebp - 0x1fcc], 2
jae 0x101701e3
lea eax, [ebp - 0x21ac]
mov dword [ebp - 0x26d8], eax
mov ecx, dword [ebp - 0x1fcc]
mov edx, dword [ebp - 0x26d8]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x26dc], eax
mov ecx, dword [ebp - 0x26dc]
mov dx, word [ecx]
mov word [ebp - 0x24dc], dx
mov ax, word [ebp - 0x28f2]
mov word [ebp - 0x1f1e], ax
movzx ecx, word [ebp - 0x24dc]
xor ecx, 0x98
mov word [ebp - 0x1f1e], cx
lea edx, [ebp - 0x21ac]
mov dword [ebp - 0x26e0], edx
mov eax, dword [ebp - 0x1fcc]
mov ecx, dword [ebp - 0x26e0]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x26e4], edx
mov eax, dword [ebp - 0x26e4]
mov cx, word [ebp - 0x1f1e]
mov word [eax], cx
jmp 0x1017013e
lea edx, [ebp - 0x21ac]
mov dword [ebp - 0x26e8], edx
mov eax, dword [ebp - 0x26e8]
mov dword [ebp - 0x2540], eax
lea ecx, [ebp - 0x39cc]
mov dword [ebp - 0x26ec], ecx
movzx edx, byte [ebp - 0x23d4]
push edx
mov ecx, dword [ebp - 0x26ec]
call fcn.1008cde0
mov dword [ebp - 4], 0x16
mov eax, dword [ebp - 0x2540]
mov dword [ebp - 0x1fd0], eax
mov ecx, dword [ebp - 0x1fd0]
add ecx, 2
mov dword [ebp - 0x26f0], ecx
mov edx, dword [ebp - 0x1fd0]
mov ax, word [edx]
mov word [ebp - 0x24de], ax
add dword [ebp - 0x1fd0], 2
cmp word [ebp - 0x24de], 0
jne 0x1017023c
mov ecx, dword [ebp - 0x1fd0]
sub ecx, dword [ebp - 0x26f0]
sar ecx, 1
mov dword [ebp - 0x26f4], ecx
mov edx, dword [ebp - 0x26f4]
mov dword [ebp - 0x26f8], edx
mov eax, dword [ebp - 0x26f8]
mov dword [ebp - 0x26fc], eax
mov ecx, dword [ebp - 0x26fc]
push ecx
mov edx, dword [ebp - 0x2540]
push edx
lea ecx, [ebp - 0x39cc]
call fcn.100b23d0
mov dword [ebp - 4], 0x17
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.purpleamt]
mov byte [ebp - 0x5c4], dl
movsx eax, byte [ebp - 0x5c4]
xor eax, 0xffffff98
mov byte [ebp - 0x5c5], al
mov cl, byte [ebp - 0x5c5]
mov byte [ebp - 0x20a8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.purpleamt]
mov byte [ebp - 0x5cc], al
movsx ecx, byte [ebp - 0x5cc]
xor ecx, 0xffffff98
mov byte [ebp - 0x5cd], cl
mov dl, byte [ebp - 0x5cd]
mov byte [ebp - 0x20a7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.purpleamt]
mov byte [ebp - 0x5d4], cl
movsx edx, byte [ebp - 0x5d4]
xor edx, 0xffffff98
mov byte [ebp - 0x5d5], dl
mov al, byte [ebp - 0x5d5]
mov byte [ebp - 0x20a6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.purpleamt]
mov byte [ebp - 0x5dc], al
movsx ecx, byte [ebp - 0x5dc]
xor ecx, 0xffffff98
mov byte [ebp - 0x5dd], cl
mov dl, byte [ebp - 0x5dd]
mov byte [ebp - 0x20a5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.purpleamt]
mov byte [ebp - 0x5e4], cl
movsx edx, byte [ebp - 0x5e4]
xor edx, 0xffffff98
mov byte [ebp - 0x5e5], dl
mov al, byte [ebp - 0x5e5]
mov byte [ebp - 0x20a4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.purpleamt]
mov byte [ebp - 0x5ec], al
movsx ecx, byte [ebp - 0x5ec]
xor ecx, 0xffffff98
mov byte [ebp - 0x5ed], cl
mov dl, byte [ebp - 0x5ed]
mov byte [ebp - 0x20a3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.purpleamt]
mov byte [ebp - 0x5f4], dl
movsx eax, byte [ebp - 0x5f4]
xor eax, 0xffffff98
mov byte [ebp - 0x5f5], al
mov cl, byte [ebp - 0x5f5]
mov byte [ebp - 0x20a2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.purpleamt]
mov byte [ebp - 0x5fc], cl
movsx edx, byte [ebp - 0x5fc]
xor edx, 0xffffff98
mov byte [ebp - 0x5fd], dl
mov al, byte [ebp - 0x5fd]
mov byte [ebp - 0x20a1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.purpleamt]
mov byte [ebp - 0x604], dl
movsx eax, byte [ebp - 0x604]
xor eax, 0xffffff98
mov byte [ebp - 0x605], al
mov cl, byte [ebp - 0x605]
mov byte [ebp - 0x20a0], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.purpleamt]
mov byte [ebp - 0x60c], cl
movsx edx, byte [ebp - 0x60c]
xor edx, 0xffffff98
mov byte [ebp - 0x60d], dl
mov al, byte [ebp - 0x60d]
mov byte [ebp - 0x209f], al
mov dword [ebp - 0x1fd4], 0
jmp 0x101704a3
mov ecx, dword [ebp - 0x1fd4]
add ecx, 1
mov dword [ebp - 0x1fd4], ecx
cmp dword [ebp - 0x1fd4], 0xa
jae 0x10170525
lea edx, [ebp - 0x20a8]
mov dword [ebp - 0x2700], edx
mov eax, dword [ebp - 0x2700]
add eax, dword [ebp - 0x1fd4]
mov dword [ebp - 0x2704], eax
mov ecx, dword [ebp - 0x2704]
mov dl, byte [ecx]
mov byte [ebp - 0x614], dl
mov al, byte [ebp - 0x23d5]
mov byte [ebp - 0x1a5], al
movsx ecx, byte [ebp - 0x614]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a5], cl
lea edx, [ebp - 0x20a8]
mov dword [ebp - 0x2708], edx
mov eax, dword [ebp - 0x2708]
add eax, dword [ebp - 0x1fd4]
mov dword [ebp - 0x270c], eax
mov ecx, dword [ebp - 0x270c]
mov dl, byte [ebp - 0x1a5]
mov byte [ecx], dl
jmp 0x10170494
lea eax, [ebp - 0x20a8]
mov dword [ebp - 0x2710], eax
mov ecx, dword [ebp - 0x2710]
mov dword [ebp - 0x2544], ecx
lea edx, [ebp - 0x39b4]
mov dword [ebp - 0x2714], edx
movzx eax, byte [ebp - 0x23d6]
push eax
mov ecx, dword [ebp - 0x2714]
call fcn.1008cde0
mov byte [ebp - 4], 0x18
mov ecx, dword [ebp - 0x2544]
mov dword [ebp - 0x1fd8], ecx
mov edx, dword [ebp - 0x1fd8]
add edx, 1
mov dword [ebp - 0x2718], edx
mov eax, dword [ebp - 0x1fd8]
mov cl, byte [eax]
mov byte [ebp - 0x615], cl
add dword [ebp - 0x1fd8], 1
cmp byte [ebp - 0x615], 0
jne 0x1017057b
mov edx, dword [ebp - 0x1fd8]
sub edx, dword [ebp - 0x2718]
mov dword [ebp - 0x271c], edx
mov eax, dword [ebp - 0x271c]
mov dword [ebp - 0x2720], eax
mov ecx, dword [ebp - 0x2720]
mov dword [ebp - 0x2724], ecx
mov edx, dword [ebp - 0x2724]
push edx
mov eax, dword [ebp - 0x2544]
push eax
lea ecx, [ebp - 0x39b4]
call fcn.1008ce30
mov byte [ebp - 4], 0x19
lea ecx, [ebp - 0x399c]
mov dword [ebp - 0x2728], ecx
movzx edx, byte [ebp - 0x23d7]
push edx
mov ecx, dword [ebp - 0x2728]
call fcn.1008cde0
mov byte [ebp - 4], 0x1a
mov dword [ebp - 0x1fdc], str.adjustment_amount
mov eax, dword [ebp - 0x1fdc]
add eax, 1
mov dword [ebp - 0x272c], eax
mov ecx, dword [ebp - 0x1fdc]
mov dl, byte [ecx]
mov byte [ebp - 0x616], dl
add dword [ebp - 0x1fdc], 1
cmp byte [ebp - 0x616], 0
jne 0x1017061c
mov eax, dword [ebp - 0x1fdc]
sub eax, dword [ebp - 0x272c]
mov dword [ebp - 0x2730], eax
mov ecx, dword [ebp - 0x2730]
mov dword [ebp - 0x2734], ecx
mov edx, dword [ebp - 0x2734]
mov dword [ebp - 0x2738], edx
mov eax, dword [ebp - 0x2738]
push eax
push str.adjustment_amount
lea ecx, [ebp - 0x399c]
call fcn.1008ce30
mov byte [ebp - 4], 0x1b
lea ecx, [ebp - 0x39b4]
push ecx
mov ecx, dword [ebp - 0x158]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x158]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x158]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x101706c4
lea edx, [ebp - 0x399c]
push edx
mov ecx, dword [ebp - 0x158]
add ecx, 0x88
call fcn.100ad110
mov eax, dword [ebp - 0x158]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x101706de
mov dword [ebp - 0x2548], 0xf
jmp 0x101706e8
mov dword [ebp - 0x2548], 0
mov edx, dword [ebp - 0x158]
mov eax, dword [ebp - 0x2548]
mov dword [edx + 0xb8], eax
mov ecx, dword [ebp - 0x158]
mov edx, dword [ecx + 0xb8]
add edx, 8
mov eax, dword [ebp - 0x158]
mov dword [eax + 0x10], edx
mov ecx, dword [ebp - 0x158]
mov edx, dword [ebp - 0x158]
mov eax, dword [edx + 0x10]
mov dword [ecx + 0x14], eax
mov ecx, dword [ebp - 0x158]
xorps xmm0, xmm0
movss dword [ecx + 0x74], xmm0
mov edx, dword [ebp - 0x158]
movss xmm0, dword [0x10328a64]
movss dword [edx + 0x78], xmm0
mov eax, dword [ebp - 0x158]
movss xmm0, dword [0x10328a64]
movss dword [eax + 0x70], xmm0
mov ecx, dword [ebp - 0x158]
mov dword [ecx + 0x84], 0
mov edx, dword [ebp - 0x158]
movss xmm0, dword [0x1032891c]
movss dword [edx + 0x7c], xmm0
lea eax, [ebp - 0x39cc]
push eax
mov ecx, dword [ebp - 0x158]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x19
lea ecx, [ebp - 0x399c]
call fcn.1008b960
mov byte [ebp - 4], 0x17
lea ecx, [ebp - 0x39b4]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x39cc]
call fcn.100ae140
mov ecx, dword [ebp - 0x130]
add ecx, 0x6e8
mov dword [ebp - 0x273c], ecx
mov dword [ebp - 0xec], 0x100a81b0
mov edx, dword [ebp - 0x273c]
add edx, 0x58
mov dword [ebp - 0x2744], edx
lea eax, [ebp - 0xec]
push eax
mov ecx, dword [ebp - 0x2744]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0x6e8
mov dword [ebp - 0x2748], ecx
mov edx, dword [ebp - 0x2748]
mov dword [edx + 0x64], fcn.102e1320
mov eax, dword [ebp - 0x130]
add eax, 0x6e8
mov dword [ebp - 0x74], eax
mov ecx, dword [ebp - 0x74]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x74]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x74]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x74]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x74]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x274c], eax
lea ecx, [ebp - 0x74]
push ecx
mov ecx, dword [ebp - 0x274c]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0x978
mov dword [ebp - 0x1a8c], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x10324ad0]
mov byte [ebp - 0x61c], dl
movsx eax, byte [ebp - 0x61c]
xor eax, 0xffffff98
mov byte [ebp - 0x61d], al
mov cl, byte [ebp - 0x61d]
mov byte [ebp - 0x222c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x10324ad0]
mov byte [ebp - 0x624], al
movsx ecx, byte [ebp - 0x624]
xor ecx, 0xffffff98
mov byte [ebp - 0x625], cl
mov dl, byte [ebp - 0x625]
mov byte [ebp - 0x222b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x10324ad0]
mov byte [ebp - 0x62c], cl
movsx edx, byte [ebp - 0x62c]
xor edx, 0xffffff98
mov byte [ebp - 0x62d], dl
mov al, byte [ebp - 0x62d]
mov byte [ebp - 0x222a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x10324ad0]
mov byte [ebp - 0x634], al
movsx ecx, byte [ebp - 0x634]
xor ecx, 0xffffff98
mov byte [ebp - 0x635], cl
mov dl, byte [ebp - 0x635]
mov byte [ebp - 0x2229], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x10324ad0]
mov byte [ebp - 0x63c], cl
movsx edx, byte [ebp - 0x63c]
xor edx, 0xffffff98
mov byte [ebp - 0x63d], dl
mov al, byte [ebp - 0x63d]
mov byte [ebp - 0x2228], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x10324ad0]
mov byte [ebp - 0x644], al
movsx ecx, byte [ebp - 0x644]
xor ecx, 0xffffff98
mov byte [ebp - 0x645], cl
mov dl, byte [ebp - 0x645]
mov byte [ebp - 0x2227], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x10324ad0]
mov byte [ebp - 0x64c], dl
movsx eax, byte [ebp - 0x64c]
xor eax, 0xffffff98
mov byte [ebp - 0x64d], al
mov cl, byte [ebp - 0x64d]
mov byte [ebp - 0x2226], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x10324ad0]
mov byte [ebp - 0x654], cl
movsx edx, byte [ebp - 0x654]
xor edx, 0xffffff98
mov byte [ebp - 0x655], dl
mov al, byte [ebp - 0x655]
mov byte [ebp - 0x2225], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x10324ad0]
mov byte [ebp - 0x65c], dl
movsx eax, byte [ebp - 0x65c]
xor eax, 0xffffff98
mov byte [ebp - 0x65d], al
mov cl, byte [ebp - 0x65d]
mov byte [ebp - 0x2224], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + 0x10324ad0]
mov byte [ebp - 0x664], cl
movsx edx, byte [ebp - 0x664]
xor edx, 0xffffff98
mov byte [ebp - 0x665], dl
mov al, byte [ebp - 0x665]
mov byte [ebp - 0x2223], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + 0x10324ad0]
mov byte [ebp - 0x66c], al
movsx ecx, byte [ebp - 0x66c]
xor ecx, 0xffffff98
mov byte [ebp - 0x66d], cl
mov dl, byte [ebp - 0x66d]
mov byte [ebp - 0x2222], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + 0x10324ad0]
mov byte [ebp - 0x674], dl
movsx eax, byte [ebp - 0x674]
xor eax, 0xffffff98
mov byte [ebp - 0x675], al
mov cl, byte [ebp - 0x675]
mov byte [ebp - 0x2221], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + 0x10324ad0]
mov byte [ebp - 0x67c], cl
movsx edx, byte [ebp - 0x67c]
xor edx, 0xffffff98
mov byte [ebp - 0x67d], dl
mov al, byte [ebp - 0x67d]
mov byte [ebp - 0x2220], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + 0x10324ad0]
mov byte [ebp - 0x684], al
movsx ecx, byte [ebp - 0x684]
xor ecx, 0xffffff98
mov byte [ebp - 0x685], cl
mov dl, byte [ebp - 0x685]
mov byte [ebp - 0x221f], dl
mov dword [ebp - 0x1fe0], 0
jmp 0x10170b4d
mov eax, dword [ebp - 0x1fe0]
add eax, 1
mov dword [ebp - 0x1fe0], eax
cmp dword [ebp - 0x1fe0], 0xe
jae 0x10170bcf
lea ecx, [ebp - 0x222c]
mov dword [ebp - 0x2750], ecx
mov edx, dword [ebp - 0x2750]
add edx, dword [ebp - 0x1fe0]
mov dword [ebp - 0x2754], edx
mov eax, dword [ebp - 0x2754]
mov cl, byte [eax]
mov byte [ebp - 0x68c], cl
mov dl, byte [ebp - 0x23d8]
mov byte [ebp - 0x1a6], dl
movsx eax, byte [ebp - 0x68c]
xor eax, 0xffffff98
mov byte [ebp - 0x1a6], al
lea ecx, [ebp - 0x222c]
mov dword [ebp - 0x2758], ecx
mov edx, dword [ebp - 0x2758]
add edx, dword [ebp - 0x1fe0]
mov dword [ebp - 0x275c], edx
mov eax, dword [ebp - 0x275c]
mov cl, byte [ebp - 0x1a6]
mov byte [eax], cl
jmp 0x10170b3e
lea edx, [ebp - 0x222c]
mov dword [ebp - 0x2760], edx
mov eax, dword [ebp - 0x2760]
mov dword [ebp - 0x254c], eax
lea ecx, [ebp - 0x39fc]
mov dword [ebp - 0x2764], ecx
movzx edx, byte [ebp - 0x23d9]
push edx
mov ecx, dword [ebp - 0x2764]
call fcn.1008cde0
mov dword [ebp - 4], 0x1c
mov eax, dword [ebp - 0x254c]
mov dword [ebp - 0x1fe4], eax
mov ecx, dword [ebp - 0x1fe4]
add ecx, 1
mov dword [ebp - 0x2768], ecx
mov edx, dword [ebp - 0x1fe4]
mov al, byte [edx]
mov byte [ebp - 0x68d], al
add dword [ebp - 0x1fe4], 1
cmp byte [ebp - 0x68d], 0
jne 0x10170c28
mov ecx, dword [ebp - 0x1fe4]
sub ecx, dword [ebp - 0x2768]
mov dword [ebp - 0x276c], ecx
mov edx, dword [ebp - 0x276c]
mov dword [ebp - 0x2770], edx
mov eax, dword [ebp - 0x2770]
mov dword [ebp - 0x2774], eax
mov ecx, dword [ebp - 0x2774]
push ecx
mov edx, dword [ebp - 0x254c]
push edx
lea ecx, [ebp - 0x39fc]
call fcn.1008ce30
mov dword [ebp - 4], 0x1d
lea eax, [ebp - 0x39e4]
mov dword [ebp - 0x2778], eax
movzx ecx, byte [ebp - 0x23da]
push ecx
mov ecx, dword [ebp - 0x2778]
call fcn.1008cde0
mov byte [ebp - 4], 0x1e
mov dword [ebp - 0x1fe8], str.ambient_color
mov edx, dword [ebp - 0x1fe8]
add edx, 1
mov dword [ebp - 0x277c], edx
mov eax, dword [ebp - 0x1fe8]
mov cl, byte [eax]
mov byte [ebp - 0x68e], cl
add dword [ebp - 0x1fe8], 1
cmp byte [ebp - 0x68e], 0
jne 0x10170ccc
mov edx, dword [ebp - 0x1fe8]
sub edx, dword [ebp - 0x277c]
mov dword [ebp - 0x2780], edx
mov eax, dword [ebp - 0x2780]
mov dword [ebp - 0x2784], eax
mov ecx, dword [ebp - 0x2784]
mov dword [ebp - 0x2788], ecx
mov edx, dword [ebp - 0x2788]
push edx
push str.ambient_color
lea ecx, [ebp - 0x39e4]
call fcn.1008ce30
mov byte [ebp - 4], 0x1f
lea eax, [ebp - 0x278c]
mov dword [ebp - 0x2190], eax
mov ecx, dword [ebp - 0x2190]
mov byte [ecx], 0x19
mov edx, dword [ebp - 0x2190]
mov byte [edx + 1], 0x19
mov eax, dword [ebp - 0x2190]
mov byte [eax + 2], 0x19
mov ecx, dword [ebp - 0x2190]
mov byte [ecx + 3], 0xff
lea edx, [ebp - 0x39e4]
push edx
mov ecx, dword [ebp - 0x1a8c]
add ecx, 0x70
call fcn.100ad110
lea eax, [ebp - 0x39fc]
push eax
mov ecx, dword [ebp - 0x1a8c]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1a8c]
mov edx, dword [ebp - 0x278c]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1a8c]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1a8c]
cmp dword [ecx + 0x8c], 0
je 0x10170dd7
mov edx, dword [ebp - 0x1a8c]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1a8c]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 0x1d
lea ecx, [ebp - 0x39e4]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x39fc]
call fcn.1008b960
mov eax, dword [ebp - 0x130]
add eax, 0x978
mov dword [ebp - 0x2790], eax
mov dword [ebp - 0xf0], 0x100a8390
mov ecx, dword [ebp - 0x2790]
add ecx, 0x58
mov dword [ebp - 0x2798], ecx
lea edx, [ebp - 0xf0]
push edx
mov ecx, dword [ebp - 0x2798]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0x978
mov dword [ebp - 0x78], eax
mov ecx, dword [ebp - 0x78]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x78]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x78]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x78]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x78]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x279c], eax
lea ecx, [ebp - 0x78]
push ecx
mov ecx, dword [ebp - 0x279c]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0xa08
mov dword [ebp - 0x154], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x10323ad0]
mov word [ebp - 0x24e4], dx
movzx eax, word [ebp - 0x24e4]
xor eax, 0x98
mov word [ebp - 0x24e6], ax
mov cx, word [ebp - 0x24e6]
mov word [ebp - 0x2194], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x10323ad0]
mov word [ebp - 0x2338], ax
movzx ecx, word [ebp - 0x2338]
xor ecx, 0x98
mov word [ebp - 0x233a], cx
mov dx, word [ebp - 0x233a]
mov word [ebp - 0x2192], dx
mov dword [ebp - 0x1fec], 0
jmp 0x10170f32
mov eax, dword [ebp - 0x1fec]
add eax, 1
mov dword [ebp - 0x1fec], eax
cmp dword [ebp - 0x1fec], 2
jae 0x10170fc8
lea ecx, [ebp - 0x2194]
mov dword [ebp - 0x27a0], ecx
mov edx, dword [ebp - 0x1fec]
mov eax, dword [ebp - 0x27a0]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x27a4], ecx
mov edx, dword [ebp - 0x27a4]
mov ax, word [edx]
mov word [ebp - 0x2340], ax
mov cx, word [ebp - 0x29aa]
mov word [ebp - 0x1f20], cx
movzx edx, word [ebp - 0x2340]
xor edx, 0x98
mov word [ebp - 0x1f20], dx
lea eax, [ebp - 0x2194]
mov dword [ebp - 0x27a8], eax
mov ecx, dword [ebp - 0x1fec]
mov edx, dword [ebp - 0x27a8]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x27ac], eax
mov ecx, dword [ebp - 0x27ac]
mov dx, word [ebp - 0x1f20]
mov word [ecx], dx
jmp 0x10170f23
lea eax, [ebp - 0x2194]
mov dword [ebp - 0x27b0], eax
mov ecx, dword [ebp - 0x27b0]
mov dword [ebp - 0x2550], ecx
lea edx, [ebp - 0x3a44]
mov dword [ebp - 0x27b4], edx
movzx eax, byte [ebp - 0x23db]
push eax
mov ecx, dword [ebp - 0x27b4]
call fcn.1008cde0
mov dword [ebp - 4], 0x20
mov ecx, dword [ebp - 0x2550]
mov dword [ebp - 0x1ff0], ecx
mov edx, dword [ebp - 0x1ff0]
add edx, 2
mov dword [ebp - 0x27b8], edx
mov eax, dword [ebp - 0x1ff0]
mov cx, word [eax]
mov word [ebp - 0x2342], cx
add dword [ebp - 0x1ff0], 2
cmp word [ebp - 0x2342], 0
jne 0x10171021
mov edx, dword [ebp - 0x1ff0]
sub edx, dword [ebp - 0x27b8]
sar edx, 1
mov dword [ebp - 0x27bc], edx
mov eax, dword [ebp - 0x27bc]
mov dword [ebp - 0x27c0], eax
mov ecx, dword [ebp - 0x27c0]
mov dword [ebp - 0x27c4], ecx
mov edx, dword [ebp - 0x27c4]
push edx
mov eax, dword [ebp - 0x2550]
push eax
lea ecx, [ebp - 0x3a44]
call fcn.100b23d0
mov dword [ebp - 4], 0x21
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.ambient_alpha]
mov byte [ebp - 0x694], al
movsx ecx, byte [ebp - 0x694]
xor ecx, 0xffffff98
mov byte [ebp - 0x695], cl
mov dl, byte [ebp - 0x695]
mov byte [ebp - 0x224c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.ambient_alpha]
mov byte [ebp - 0x69c], cl
movsx edx, byte [ebp - 0x69c]
xor edx, 0xffffff98
mov byte [ebp - 0x69d], dl
mov al, byte [ebp - 0x69d]
mov byte [ebp - 0x224b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.ambient_alpha]
mov byte [ebp - 0x6a4], dl
movsx eax, byte [ebp - 0x6a4]
xor eax, 0xffffff98
mov byte [ebp - 0x6a5], al
mov cl, byte [ebp - 0x6a5]
mov byte [ebp - 0x224a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.ambient_alpha]
mov byte [ebp - 0x6ac], cl
movsx edx, byte [ebp - 0x6ac]
xor edx, 0xffffff98
mov byte [ebp - 0x6ad], dl
mov al, byte [ebp - 0x6ad]
mov byte [ebp - 0x2249], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.ambient_alpha]
mov byte [ebp - 0x6b4], dl
movsx eax, byte [ebp - 0x6b4]
xor eax, 0xffffff98
mov byte [ebp - 0x6b5], al
mov cl, byte [ebp - 0x6b5]
mov byte [ebp - 0x2248], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.ambient_alpha]
mov byte [ebp - 0x6bc], cl
movsx edx, byte [ebp - 0x6bc]
xor edx, 0xffffff98
mov byte [ebp - 0x6bd], dl
mov al, byte [ebp - 0x6bd]
mov byte [ebp - 0x2247], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.ambient_alpha]
mov byte [ebp - 0x6c4], al
movsx ecx, byte [ebp - 0x6c4]
xor ecx, 0xffffff98
mov byte [ebp - 0x6c5], cl
mov dl, byte [ebp - 0x6c5]
mov byte [ebp - 0x2246], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.ambient_alpha]
mov byte [ebp - 0x6cc], dl
movsx eax, byte [ebp - 0x6cc]
xor eax, 0xffffff98
mov byte [ebp - 0x6cd], al
mov cl, byte [ebp - 0x6cd]
mov byte [ebp - 0x2245], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.ambient_alpha]
mov byte [ebp - 0x6d4], al
movsx ecx, byte [ebp - 0x6d4]
xor ecx, 0xffffff98
mov byte [ebp - 0x6d5], cl
mov dl, byte [ebp - 0x6d5]
mov byte [ebp - 0x2244], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.ambient_alpha]
mov byte [ebp - 0x6dc], dl
movsx eax, byte [ebp - 0x6dc]
xor eax, 0xffffff98
mov byte [ebp - 0x6dd], al
mov cl, byte [ebp - 0x6dd]
mov byte [ebp - 0x2243], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.ambient_alpha]
mov byte [ebp - 0x6e4], cl
movsx edx, byte [ebp - 0x6e4]
xor edx, 0xffffff98
mov byte [ebp - 0x6e5], dl
mov al, byte [ebp - 0x6e5]
mov byte [ebp - 0x2242], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.ambient_alpha]
mov byte [ebp - 0x6ec], al
movsx ecx, byte [ebp - 0x6ec]
xor ecx, 0xffffff98
mov byte [ebp - 0x6ed], cl
mov dl, byte [ebp - 0x6ed]
mov byte [ebp - 0x2241], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.ambient_alpha]
mov byte [ebp - 0x6f4], dl
movsx eax, byte [ebp - 0x6f4]
xor eax, 0xffffff98
mov byte [ebp - 0x6f5], al
mov cl, byte [ebp - 0x6f5]
mov byte [ebp - 0x2240], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.ambient_alpha]
mov byte [ebp - 0x6fc], cl
movsx edx, byte [ebp - 0x6fc]
xor edx, 0xffffff98
mov byte [ebp - 0x6fd], dl
mov al, byte [ebp - 0x6fd]
mov byte [ebp - 0x223f], al
mov dword [ebp - 0x1fb8], 0
jmp 0x10171348
mov ecx, dword [ebp - 0x1fb8]
add ecx, 1
mov dword [ebp - 0x1fb8], ecx
cmp dword [ebp - 0x1fb8], 0xe
jae 0x101713ca
lea edx, [ebp - 0x224c]
mov dword [ebp - 0x27c8], edx
mov eax, dword [ebp - 0x27c8]
add eax, dword [ebp - 0x1fb8]
mov dword [ebp - 0x27cc], eax
mov ecx, dword [ebp - 0x27cc]
mov dl, byte [ecx]
mov byte [ebp - 0x704], dl
mov al, byte [ebp - 0x23dc]
mov byte [ebp - 0x1a7], al
movsx ecx, byte [ebp - 0x704]
xor ecx, 0xffffff98
mov byte [ebp - 0x1a7], cl
lea edx, [ebp - 0x224c]
mov dword [ebp - 0x27d0], edx
mov eax, dword [ebp - 0x27d0]
add eax, dword [ebp - 0x1fb8]
mov dword [ebp - 0x27d4], eax
mov ecx, dword [ebp - 0x27d4]
mov dl, byte [ebp - 0x1a7]
mov byte [ecx], dl
jmp 0x10171339
lea eax, [ebp - 0x224c]
mov dword [ebp - 0x27d8], eax
mov ecx, dword [ebp - 0x27d8]
mov dword [ebp - 0x2554], ecx
lea edx, [ebp - 0x3a2c]
mov dword [ebp - 0x27dc], edx
movzx eax, byte [ebp - 0x23dd]
push eax
mov ecx, dword [ebp - 0x27dc]
call fcn.1008cde0
mov byte [ebp - 4], 0x22
mov ecx, dword [ebp - 0x2554]
mov dword [ebp - 0x1ff8], ecx
mov edx, dword [ebp - 0x1ff8]
add edx, 1
mov dword [ebp - 0x27e0], edx
mov eax, dword [ebp - 0x1ff8]
mov cl, byte [eax]
mov byte [ebp - 0x705], cl
add dword [ebp - 0x1ff8], 1
cmp byte [ebp - 0x705], 0
jne 0x10171420
mov edx, dword [ebp - 0x1ff8]
sub edx, dword [ebp - 0x27e0]
mov dword [ebp - 0x27e4], edx
mov eax, dword [ebp - 0x27e4]
mov dword [ebp - 0x27e8], eax
mov ecx, dword [ebp - 0x27e8]
mov dword [ebp - 0x27ec], ecx
mov edx, dword [ebp - 0x27ec]
push edx
mov eax, dword [ebp - 0x2554]
push eax
lea ecx, [ebp - 0x3a2c]
call fcn.1008ce30
mov byte [ebp - 4], 0x23
lea ecx, [ebp - 0x3a14]
mov dword [ebp - 0x27f0], ecx
movzx edx, byte [ebp - 0x23de]
push edx
mov ecx, dword [ebp - 0x27f0]
call fcn.1008cde0
mov byte [ebp - 4], 0x24
mov dword [ebp - 0x1ffc], 0x1031e566
mov eax, dword [ebp - 0x1ffc]
add eax, 1
mov dword [ebp - 0x27f4], eax
mov ecx, dword [ebp - 0x1ffc]
mov dl, byte [ecx]
mov byte [ebp - 0x706], dl
add dword [ebp - 0x1ffc], 1
cmp byte [ebp - 0x706], 0
jne 0x101714c1
mov eax, dword [ebp - 0x1ffc]
sub eax, dword [ebp - 0x27f4]
mov dword [ebp - 0x27f8], eax
mov ecx, dword [ebp - 0x27f8]
mov dword [ebp - 0x27fc], ecx
mov edx, dword [ebp - 0x27fc]
mov dword [ebp - 0x2800], edx
mov eax, dword [ebp - 0x2800]
push eax
push 0x1031e566
lea ecx, [ebp - 0x3a14]
call fcn.1008ce30
mov byte [ebp - 4], 0x25
lea ecx, [ebp - 0x3a2c]
push ecx
mov ecx, dword [ebp - 0x154]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x154]
mov byte [edx + 0x69], 0
mov eax, dword [ebp - 0x154]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10171569
lea edx, [ebp - 0x3a14]
push edx
mov ecx, dword [ebp - 0x154]
add ecx, 0x88
call fcn.100ad110
mov eax, dword [ebp - 0x154]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10171583
mov dword [ebp - 0x2558], 0xf
jmp 0x1017158d
mov dword [ebp - 0x2558], 0
mov edx, dword [ebp - 0x154]
mov eax, dword [ebp - 0x2558]
mov dword [edx + 0xb8], eax
mov ecx, dword [ebp - 0x154]
mov edx, dword [ecx + 0xb8]
add edx, 8
mov eax, dword [ebp - 0x154]
mov dword [eax + 0x10], edx
mov ecx, dword [ebp - 0x154]
mov edx, dword [ebp - 0x154]
mov eax, dword [edx + 0x10]
mov dword [ecx + 0x14], eax
mov ecx, dword [ebp - 0x154]
xorps xmm0, xmm0
movss dword [ecx + 0x74], xmm0
mov edx, dword [ebp - 0x154]
movss xmm0, dword [0x10328ac8]
movss dword [edx + 0x78], xmm0
mov eax, dword [ebp - 0x154]
movss xmm0, dword [0x10328ac8]
movss dword [eax + 0x70], xmm0
mov ecx, dword [ebp - 0x154]
mov dword [ecx + 0x84], 0
mov edx, dword [ebp - 0x154]
movss xmm0, dword [0x1032891c]
movss dword [edx + 0x7c], xmm0
lea eax, [ebp - 0x3a44]
push eax
mov ecx, dword [ebp - 0x154]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x23
lea ecx, [ebp - 0x3a14]
call fcn.1008b960
mov byte [ebp - 4], 0x21
lea ecx, [ebp - 0x3a2c]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3a44]
call fcn.100ae140
mov ecx, dword [ebp - 0x130]
add ecx, 0xa08
mov dword [ebp - 0x2804], ecx
mov dword [ebp - 0xf4], 0x100a8390
mov edx, dword [ebp - 0x2804]
add edx, 0x58
mov dword [ebp - 0x280c], edx
lea eax, [ebp - 0xf4]
push eax
mov ecx, dword [ebp - 0x280c]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0xa08
mov dword [ebp - 0x7c], ecx
mov edx, dword [ebp - 0x7c]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x7c]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x7c]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x7c]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x7c]
mov edx, dword [ebp - 0x130]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x130]
add ecx, 0x18
mov dword [ebp - 0x2810], ecx
lea edx, [ebp - 0x7c]
push edx
mov ecx, dword [ebp - 0x2810]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0xac4
mov dword [ebp - 0x150], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x10323ad0]
mov word [ebp - 0x2348], ax
movzx ecx, word [ebp - 0x2348]
xor ecx, 0x98
mov word [ebp - 0x234a], cx
mov dx, word [ebp - 0x234a]
mov word [ebp - 0x2198], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x10323ad0]
mov word [ebp - 0x2350], cx
movzx edx, word [ebp - 0x2350]
xor edx, 0x98
mov word [ebp - 0x2352], dx
mov ax, word [ebp - 0x2352]
mov word [ebp - 0x2196], ax
mov dword [ebp - 0x2000], 0
jmp 0x101717a4
mov ecx, dword [ebp - 0x2000]
add ecx, 1
mov dword [ebp - 0x2000], ecx
cmp dword [ebp - 0x2000], 2
jae 0x10171839
lea edx, [ebp - 0x2198]
mov dword [ebp - 0x2814], edx
mov eax, dword [ebp - 0x2000]
mov ecx, dword [ebp - 0x2814]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2818], edx
mov eax, dword [ebp - 0x2818]
mov cx, word [eax]
mov word [ebp - 0x2358], cx
mov dx, word [ebp - 0x2a16]
mov word [ebp - 0x1f26], dx
movzx eax, word [ebp - 0x2358]
xor eax, 0x98
mov word [ebp - 0x1f26], ax
lea ecx, [ebp - 0x2198]
mov dword [ebp - 0x281c], ecx
mov edx, dword [ebp - 0x2000]
mov eax, dword [ebp - 0x281c]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2820], ecx
mov edx, dword [ebp - 0x2820]
mov ax, word [ebp - 0x1f26]
mov word [edx], ax
jmp 0x10171795
lea ecx, [ebp - 0x2198]
mov dword [ebp - 0x2824], ecx
mov edx, dword [ebp - 0x2824]
mov dword [ebp - 0x255c], edx
lea eax, [ebp - 0x3a8c]
mov dword [ebp - 0x2828], eax
movzx ecx, byte [ebp - 0x23df]
push ecx
mov ecx, dword [ebp - 0x2828]
call fcn.1008cde0
mov dword [ebp - 4], 0x26
mov edx, dword [ebp - 0x255c]
mov dword [ebp - 0x2004], edx
mov eax, dword [ebp - 0x2004]
add eax, 2
mov dword [ebp - 0x282c], eax
mov ecx, dword [ebp - 0x2004]
mov dx, word [ecx]
mov word [ebp - 0x235a], dx
add dword [ebp - 0x2004], 2
cmp word [ebp - 0x235a], 0
jne 0x10171892
mov eax, dword [ebp - 0x2004]
sub eax, dword [ebp - 0x282c]
sar eax, 1
mov dword [ebp - 0x2830], eax
mov ecx, dword [ebp - 0x2830]
mov dword [ebp - 0x2834], ecx
mov edx, dword [ebp - 0x2834]
mov dword [ebp - 0x2838], edx
mov eax, dword [ebp - 0x2838]
push eax
mov ecx, dword [ebp - 0x255c]
push ecx
lea ecx, [ebp - 0x3a8c]
call fcn.100b23d0
mov dword [ebp - 4], 0x27
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.walls_amount]
mov byte [ebp - 0x70c], cl
movsx edx, byte [ebp - 0x70c]
xor edx, 0xffffff98
mov byte [ebp - 0x70d], dl
mov al, byte [ebp - 0x70d]
mov byte [ebp - 0x21fc], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.walls_amount]
mov byte [ebp - 0x714], dl
movsx eax, byte [ebp - 0x714]
xor eax, 0xffffff98
mov byte [ebp - 0x715], al
mov cl, byte [ebp - 0x715]
mov byte [ebp - 0x21fb], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.walls_amount]
mov byte [ebp - 0x71c], al
movsx ecx, byte [ebp - 0x71c]
xor ecx, 0xffffff98
mov byte [ebp - 0x71d], cl
mov dl, byte [ebp - 0x71d]
mov byte [ebp - 0x21fa], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.walls_amount]
mov byte [ebp - 0x724], dl
movsx eax, byte [ebp - 0x724]
xor eax, 0xffffff98
mov byte [ebp - 0x725], al
mov cl, byte [ebp - 0x725]
mov byte [ebp - 0x21f9], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.walls_amount]
mov byte [ebp - 0x72c], al
movsx ecx, byte [ebp - 0x72c]
xor ecx, 0xffffff98
mov byte [ebp - 0x72d], cl
mov dl, byte [ebp - 0x72d]
mov byte [ebp - 0x21f8], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.walls_amount]
mov byte [ebp - 0x734], dl
movsx eax, byte [ebp - 0x734]
xor eax, 0xffffff98
mov byte [ebp - 0x735], al
mov cl, byte [ebp - 0x735]
mov byte [ebp - 0x21f7], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.walls_amount]
mov byte [ebp - 0x73c], cl
movsx edx, byte [ebp - 0x73c]
xor edx, 0xffffff98
mov byte [ebp - 0x73d], dl
mov al, byte [ebp - 0x73d]
mov byte [ebp - 0x21f6], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.walls_amount]
mov byte [ebp - 0x744], al
movsx ecx, byte [ebp - 0x744]
xor ecx, 0xffffff98
mov byte [ebp - 0x745], cl
mov dl, byte [ebp - 0x745]
mov byte [ebp - 0x21f5], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.walls_amount]
mov byte [ebp - 0x74c], cl
movsx edx, byte [ebp - 0x74c]
xor edx, 0xffffff98
mov byte [ebp - 0x74d], dl
mov al, byte [ebp - 0x74d]
mov byte [ebp - 0x21f4], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.walls_amount]
mov byte [ebp - 0x754], al
movsx ecx, byte [ebp - 0x754]
xor ecx, 0xffffff98
mov byte [ebp - 0x755], cl
mov dl, byte [ebp - 0x755]
mov byte [ebp - 0x21f3], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.walls_amount]
mov byte [ebp - 0x75c], dl
movsx eax, byte [ebp - 0x75c]
xor eax, 0xffffff98
mov byte [ebp - 0x75d], al
mov cl, byte [ebp - 0x75d]
mov byte [ebp - 0x21f2], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.walls_amount]
mov byte [ebp - 0x764], cl
movsx edx, byte [ebp - 0x764]
xor edx, 0xffffff98
mov byte [ebp - 0x765], dl
mov al, byte [ebp - 0x765]
mov byte [ebp - 0x21f1], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.walls_amount]
mov byte [ebp - 0x76c], al
movsx ecx, byte [ebp - 0x76c]
xor ecx, 0xffffff98
mov byte [ebp - 0x76d], cl
mov dl, byte [ebp - 0x76d]
mov byte [ebp - 0x21f0], dl
mov dword [ebp - 0x2008], 0
jmp 0x10171b89
mov eax, dword [ebp - 0x2008]
add eax, 1
mov dword [ebp - 0x2008], eax
cmp dword [ebp - 0x2008], 0xd
jae 0x10171c0b
lea ecx, [ebp - 0x21fc]
mov dword [ebp - 0x283c], ecx
mov edx, dword [ebp - 0x283c]
add edx, dword [ebp - 0x2008]
mov dword [ebp - 0x2840], edx
mov eax, dword [ebp - 0x2840]
mov cl, byte [eax]
mov byte [ebp - 0x774], cl
mov dl, byte [ebp - 0x23e0]
mov byte [ebp - 0x1a8], dl
movsx eax, byte [ebp - 0x774]
xor eax, 0xffffff98
mov byte [ebp - 0x1a8], al
lea ecx, [ebp - 0x21fc]
mov dword [ebp - 0x2844], ecx
mov edx, dword [ebp - 0x2844]
add edx, dword [ebp - 0x2008]
mov dword [ebp - 0x2848], edx
mov eax, dword [ebp - 0x2848]
mov cl, byte [ebp - 0x1a8]
mov byte [eax], cl
jmp 0x10171b7a
lea edx, [ebp - 0x21fc]
mov dword [ebp - 0x284c], edx
mov eax, dword [ebp - 0x284c]
mov dword [ebp - 0x2560], eax
lea ecx, [ebp - 0x3a74]
mov dword [ebp - 0x2850], ecx
movzx edx, byte [ebp - 0x23e1]
push edx
mov ecx, dword [ebp - 0x2850]
call fcn.1008cde0
mov byte [ebp - 4], 0x28
mov eax, dword [ebp - 0x2560]
mov dword [ebp - 0x200c], eax
mov ecx, dword [ebp - 0x200c]
add ecx, 1
mov dword [ebp - 0x2854], ecx
mov edx, dword [ebp - 0x200c]
mov al, byte [edx]
mov byte [ebp - 0x775], al
add dword [ebp - 0x200c], 1
cmp byte [ebp - 0x775], 0
jne 0x10171c61
mov ecx, dword [ebp - 0x200c]
sub ecx, dword [ebp - 0x2854]
mov dword [ebp - 0x2858], ecx
mov edx, dword [ebp - 0x2858]
mov dword [ebp - 0x285c], edx
mov eax, dword [ebp - 0x285c]
mov dword [ebp - 0x2860], eax
mov ecx, dword [ebp - 0x2860]
push ecx
mov edx, dword [ebp - 0x2560]
push edx
lea ecx, [ebp - 0x3a74]
call fcn.1008ce30
mov byte [ebp - 4], 0x29
lea eax, [ebp - 0x3a5c]
mov dword [ebp - 0x2864], eax
movzx ecx, byte [ebp - 0x23e2]
push ecx
mov ecx, dword [ebp - 0x2864]
call fcn.1008cde0
mov byte [ebp - 4], 0x2a
mov dword [ebp - 0x2010], str.transparent_walls
mov edx, dword [ebp - 0x2010]
add edx, 1
mov dword [ebp - 0x2868], edx
mov eax, dword [ebp - 0x2010]
mov cl, byte [eax]
mov byte [ebp - 0x776], cl
add dword [ebp - 0x2010], 1
cmp byte [ebp - 0x776], 0
jne 0x10171d02
mov edx, dword [ebp - 0x2010]
sub edx, dword [ebp - 0x2868]
mov dword [ebp - 0x286c], edx
mov eax, dword [ebp - 0x286c]
mov dword [ebp - 0x2870], eax
mov ecx, dword [ebp - 0x2870]
mov dword [ebp - 0x2874], ecx
mov edx, dword [ebp - 0x2874]
push edx
push str.transparent_walls
lea ecx, [ebp - 0x3a5c]
call fcn.1008ce30
mov byte [ebp - 4], 0x2b
lea eax, [ebp - 0x3a74]
push eax
mov ecx, dword [ebp - 0x150]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x150]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x150]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10171daa
lea ecx, [ebp - 0x3a5c]
push ecx
mov ecx, dword [ebp - 0x150]
add ecx, 0x88
call fcn.100ad110
mov edx, dword [ebp - 0x150]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10171dc4
mov dword [ebp - 0x2564], 0xf
jmp 0x10171dce
mov dword [ebp - 0x2564], 0
mov ecx, dword [ebp - 0x150]
mov edx, dword [ebp - 0x2564]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x150]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x150]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x150]
mov ecx, dword [ebp - 0x150]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x150]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x150]
movss xmm0, dword [0x10328a64]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x150]
movss xmm0, dword [0x10328a64]
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x150]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x150]
movss xmm0, dword [0x1032891c]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x3a8c]
push edx
mov ecx, dword [ebp - 0x150]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x29
lea ecx, [ebp - 0x3a5c]
call fcn.1008b960
mov byte [ebp - 4], 0x27
lea ecx, [ebp - 0x3a74]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3a8c]
call fcn.100ae140
mov eax, dword [ebp - 0x130]
add eax, 0xac4
mov dword [ebp - 0x2878], eax
mov dword [ebp - 0xf8], 0x100a8570
mov ecx, dword [ebp - 0x2878]
add ecx, 0x58
mov dword [ebp - 0x2880], ecx
lea edx, [ebp - 0xf8]
push edx
mov ecx, dword [ebp - 0x2880]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0xac4
mov dword [ebp - 0x2884], eax
mov ecx, dword [ebp - 0x2884]
mov dword [ecx + 0x64], fcn.102e1320
mov edx, dword [ebp - 0x130]
add edx, 0xac4
mov dword [ebp - 0x80], edx
mov eax, dword [ebp - 0x80]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x80]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x80]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x80]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x80]
mov eax, dword [ebp - 0x130]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x130]
add edx, 0x18
mov dword [ebp - 0x2888], edx
lea eax, [ebp - 0x80]
push eax
mov ecx, dword [ebp - 0x2888]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0x82c
mov dword [ebp - 0x14c], ecx
mov edx, 2
imul eax, edx, 0
mov cx, word [eax + 0x10323ad0]
mov word [ebp - 0x2360], cx
movzx edx, word [ebp - 0x2360]
xor edx, 0x98
mov word [ebp - 0x2362], dx
mov ax, word [ebp - 0x2362]
mov word [ebp - 0x219c], ax
mov ecx, 2
shl ecx, 0
mov dx, word [ecx + 0x10323ad0]
mov word [ebp - 0x2368], dx
movzx eax, word [ebp - 0x2368]
xor eax, 0x98
mov word [ebp - 0x236a], ax
mov cx, word [ebp - 0x236a]
mov word [ebp - 0x219a], cx
mov dword [ebp - 0x2014], 0
jmp 0x10172002
mov edx, dword [ebp - 0x2014]
add edx, 1
mov dword [ebp - 0x2014], edx
cmp dword [ebp - 0x2014], 2
jae 0x10172098
lea eax, [ebp - 0x219c]
mov dword [ebp - 0x288c], eax
mov ecx, dword [ebp - 0x2014]
mov edx, dword [ebp - 0x288c]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x2890], eax
mov ecx, dword [ebp - 0x2890]
mov dx, word [ecx]
mov word [ebp - 0x2370], dx
mov ax, word [ebp - 0x31d2]
mov word [ebp - 0x1f28], ax
movzx ecx, word [ebp - 0x2370]
xor ecx, 0x98
mov word [ebp - 0x1f28], cx
lea edx, [ebp - 0x219c]
mov dword [ebp - 0x2894], edx
mov eax, dword [ebp - 0x2014]
mov ecx, dword [ebp - 0x2894]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2898], edx
mov eax, dword [ebp - 0x2898]
mov cx, word [ebp - 0x1f28]
mov word [eax], cx
jmp 0x10171ff3
lea edx, [ebp - 0x219c]
mov dword [ebp - 0x289c], edx
mov eax, dword [ebp - 0x289c]
mov dword [ebp - 0x2568], eax
lea ecx, [ebp - 0x3ad4]
mov dword [ebp - 0x28a0], ecx
movzx edx, byte [ebp - 0x23e3]
push edx
mov ecx, dword [ebp - 0x28a0]
call fcn.1008cde0
mov dword [ebp - 4], 0x2c
mov eax, dword [ebp - 0x2568]
mov dword [ebp - 0x2018], eax
mov ecx, dword [ebp - 0x2018]
add ecx, 2
mov dword [ebp - 0x28a4], ecx
mov edx, dword [ebp - 0x2018]
mov ax, word [edx]
mov word [ebp - 0x2372], ax
add dword [ebp - 0x2018], 2
cmp word [ebp - 0x2372], 0
jne 0x101720f1
mov ecx, dword [ebp - 0x2018]
sub ecx, dword [ebp - 0x28a4]
sar ecx, 1
mov dword [ebp - 0x28a8], ecx
mov edx, dword [ebp - 0x28a8]
mov dword [ebp - 0x28ac], edx
mov eax, dword [ebp - 0x28ac]
mov dword [ebp - 0x28b0], eax
mov ecx, dword [ebp - 0x28b0]
push ecx
mov edx, dword [ebp - 0x2568]
push edx
lea ecx, [ebp - 0x3ad4]
call fcn.100b23d0
mov dword [ebp - 4], 0x2d
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x77c], dl
movsx eax, byte [ebp - 0x77c]
xor eax, 0xffffff98
mov byte [ebp - 0x77d], al
mov cl, byte [ebp - 0x77d]
mov byte [ebp - 0x2318], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x784], al
movsx ecx, byte [ebp - 0x784]
xor ecx, 0xffffff98
mov byte [ebp - 0x785], cl
mov dl, byte [ebp - 0x785]
mov byte [ebp - 0x2317], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x78c], cl
movsx edx, byte [ebp - 0x78c]
xor edx, 0xffffff98
mov byte [ebp - 0x78d], dl
mov al, byte [ebp - 0x78d]
mov byte [ebp - 0x2316], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x794], al
movsx ecx, byte [ebp - 0x794]
xor ecx, 0xffffff98
mov byte [ebp - 0x795], cl
mov dl, byte [ebp - 0x795]
mov byte [ebp - 0x2315], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x79c], cl
movsx edx, byte [ebp - 0x79c]
xor edx, 0xffffff98
mov byte [ebp - 0x79d], dl
mov al, byte [ebp - 0x79d]
mov byte [ebp - 0x2314], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x7a4], al
movsx ecx, byte [ebp - 0x7a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x7a5], cl
mov dl, byte [ebp - 0x7a5]
mov byte [ebp - 0x2313], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x7ac], dl
movsx eax, byte [ebp - 0x7ac]
xor eax, 0xffffff98
mov byte [ebp - 0x7ad], al
mov cl, byte [ebp - 0x7ad]
mov byte [ebp - 0x2312], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x7b4], cl
movsx edx, byte [ebp - 0x7b4]
xor edx, 0xffffff98
mov byte [ebp - 0x7b5], dl
mov al, byte [ebp - 0x7b5]
mov byte [ebp - 0x2311], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x7bc], dl
movsx eax, byte [ebp - 0x7bc]
xor eax, 0xffffff98
mov byte [ebp - 0x7bd], al
mov cl, byte [ebp - 0x7bd]
mov byte [ebp - 0x2310], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x7c4], cl
movsx edx, byte [ebp - 0x7c4]
xor edx, 0xffffff98
mov byte [ebp - 0x7c5], dl
mov al, byte [ebp - 0x7c5]
mov byte [ebp - 0x230f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x7cc], al
movsx ecx, byte [ebp - 0x7cc]
xor ecx, 0xffffff98
mov byte [ebp - 0x7cd], cl
mov dl, byte [ebp - 0x7cd]
mov byte [ebp - 0x230e], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x7d4], dl
movsx eax, byte [ebp - 0x7d4]
xor eax, 0xffffff98
mov byte [ebp - 0x7d5], al
mov cl, byte [ebp - 0x7d5]
mov byte [ebp - 0x230d], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x7dc], cl
movsx edx, byte [ebp - 0x7dc]
xor edx, 0xffffff98
mov byte [ebp - 0x7dd], dl
mov al, byte [ebp - 0x7dd]
mov byte [ebp - 0x230c], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x7e4], al
movsx ecx, byte [ebp - 0x7e4]
xor ecx, 0xffffff98
mov byte [ebp - 0x7e5], cl
mov dl, byte [ebp - 0x7e5]
mov byte [ebp - 0x230b], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x7ec], dl
movsx eax, byte [ebp - 0x7ec]
xor eax, 0xffffff98
mov byte [ebp - 0x7ed], al
mov cl, byte [ebp - 0x7ed]
mov byte [ebp - 0x230a], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x7f4], cl
movsx edx, byte [ebp - 0x7f4]
xor edx, 0xffffff98
mov byte [ebp - 0x7f5], dl
mov al, byte [ebp - 0x7f5]
mov byte [ebp - 0x2309], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x7fc], dl
movsx eax, byte [ebp - 0x7fc]
xor eax, 0xffffff98
mov byte [ebp - 0x7fd], al
mov cl, byte [ebp - 0x7fd]
mov byte [ebp - 0x2308], cl
mov edx, 1
imul eax, edx, 0x11
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x804], cl
movsx edx, byte [ebp - 0x804]
xor edx, 0xffffff98
mov byte [ebp - 0x805], dl
mov al, byte [ebp - 0x805]
mov byte [ebp - 0x2307], al
mov ecx, 1
imul edx, ecx, 0x12
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x80c], al
movsx ecx, byte [ebp - 0x80c]
xor ecx, 0xffffff98
mov byte [ebp - 0x80d], cl
mov dl, byte [ebp - 0x80d]
mov byte [ebp - 0x2306], dl
mov eax, 1
imul ecx, eax, 0x13
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x814], dl
movsx eax, byte [ebp - 0x814]
xor eax, 0xffffff98
mov byte [ebp - 0x815], al
mov cl, byte [ebp - 0x815]
mov byte [ebp - 0x2305], cl
mov edx, 1
imul eax, edx, 0x14
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x81c], cl
movsx edx, byte [ebp - 0x81c]
xor edx, 0xffffff98
mov byte [ebp - 0x81d], dl
mov al, byte [ebp - 0x81d]
mov byte [ebp - 0x2304], al
mov ecx, 1
imul edx, ecx, 0x15
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x824], al
movsx ecx, byte [ebp - 0x824]
xor ecx, 0xffffff98
mov byte [ebp - 0x825], cl
mov dl, byte [ebp - 0x825]
mov byte [ebp - 0x2303], dl
mov eax, 1
imul ecx, eax, 0x16
mov dl, byte [ecx + str.transparent_props_amount]
mov byte [ebp - 0x82c], dl
movsx eax, byte [ebp - 0x82c]
xor eax, 0xffffff98
mov byte [ebp - 0x82d], al
mov cl, byte [ebp - 0x82d]
mov byte [ebp - 0x2302], cl
mov edx, 1
imul eax, edx, 0x17
mov cl, byte [eax + str.transparent_props_amount]
mov byte [ebp - 0x834], cl
movsx edx, byte [ebp - 0x834]
xor edx, 0xffffff98
mov byte [ebp - 0x835], dl
mov al, byte [ebp - 0x835]
mov byte [ebp - 0x2301], al
mov ecx, 1
imul edx, ecx, 0x18
mov al, byte [edx + str.transparent_props_amount]
mov byte [ebp - 0x83c], al
movsx ecx, byte [ebp - 0x83c]
xor ecx, 0xffffff98
mov byte [ebp - 0x83d], cl
mov dl, byte [ebp - 0x83d]
mov byte [ebp - 0x2300], dl
mov dword [ebp - 0x201c], 0
jmp 0x10172628
mov eax, dword [ebp - 0x201c]
add eax, 1
mov dword [ebp - 0x201c], eax
cmp dword [ebp - 0x201c], 0x19
jae 0x101726aa
lea ecx, [ebp - 0x2318]
mov dword [ebp - 0x28b4], ecx
mov edx, dword [ebp - 0x28b4]
add edx, dword [ebp - 0x201c]
mov dword [ebp - 0x28b8], edx
mov eax, dword [ebp - 0x28b8]
mov cl, byte [eax]
mov byte [ebp - 0x844], cl
mov dl, byte [ebp - 0x23e4]
mov byte [ebp - 0x1a9], dl
movsx eax, byte [ebp - 0x844]
xor eax, 0xffffff98
mov byte [ebp - 0x1a9], al
lea ecx, [ebp - 0x2318]
mov dword [ebp - 0x28bc], ecx
mov edx, dword [ebp - 0x28bc]
add edx, dword [ebp - 0x201c]
mov dword [ebp - 0x28c0], edx
mov eax, dword [ebp - 0x28c0]
mov cl, byte [ebp - 0x1a9]
mov byte [eax], cl
jmp 0x10172619
lea edx, [ebp - 0x2318]
mov dword [ebp - 0x28c4], edx
mov eax, dword [ebp - 0x28c4]
mov dword [ebp - 0x256c], eax
lea ecx, [ebp - 0x3abc]
mov dword [ebp - 0x28c8], ecx
movzx edx, byte [ebp - 0x23e5]
push edx
mov ecx, dword [ebp - 0x28c8]
call fcn.1008cde0
mov byte [ebp - 4], 0x2e
mov eax, dword [ebp - 0x256c]
mov dword [ebp - 0x2020], eax
mov ecx, dword [ebp - 0x2020]
add ecx, 1
mov dword [ebp - 0x28cc], ecx
mov edx, dword [ebp - 0x2020]
mov al, byte [edx]
mov byte [ebp - 0x845], al
add dword [ebp - 0x2020], 1
cmp byte [ebp - 0x845], 0
jne 0x10172700
mov ecx, dword [ebp - 0x2020]
sub ecx, dword [ebp - 0x28cc]
mov dword [ebp - 0x28d0], ecx
mov edx, dword [ebp - 0x28d0]
mov dword [ebp - 0x28d4], edx
mov eax, dword [ebp - 0x28d4]
mov dword [ebp - 0x28d8], eax
mov ecx, dword [ebp - 0x28d8]
push ecx
mov edx, dword [ebp - 0x256c]
push edx
lea ecx, [ebp - 0x3abc]
call fcn.1008ce30
mov byte [ebp - 4], 0x2f
lea eax, [ebp - 0x3aa4]
mov dword [ebp - 0x28dc], eax
movzx ecx, byte [ebp - 0x23e6]
push ecx
mov ecx, dword [ebp - 0x28dc]
call fcn.1008cde0
mov byte [ebp - 4], 0x30
mov dword [ebp - 0x2024], str.transparent_props
mov edx, dword [ebp - 0x2024]
add edx, 1
mov dword [ebp - 0x28e0], edx
mov eax, dword [ebp - 0x2024]
mov cl, byte [eax]
mov byte [ebp - 0x846], cl
add dword [ebp - 0x2024], 1
cmp byte [ebp - 0x846], 0
jne 0x101727a1
mov edx, dword [ebp - 0x2024]
sub edx, dword [ebp - 0x28e0]
mov dword [ebp - 0x28e4], edx
mov eax, dword [ebp - 0x28e4]
mov dword [ebp - 0x28e8], eax
mov ecx, dword [ebp - 0x28e8]
mov dword [ebp - 0x28ec], ecx
mov edx, dword [ebp - 0x28ec]
push edx
push str.transparent_props
lea ecx, [ebp - 0x3aa4]
call fcn.1008ce30
mov byte [ebp - 4], 0x31
lea eax, [ebp - 0x3abc]
push eax
mov ecx, dword [ebp - 0x14c]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x14c]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x14c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10172849
lea ecx, [ebp - 0x3aa4]
push ecx
mov ecx, dword [ebp - 0x14c]
add ecx, 0x88
call fcn.100ad110
mov edx, dword [ebp - 0x14c]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10172863
mov dword [ebp - 0x2570], 0xf
jmp 0x1017286d
mov dword [ebp - 0x2570], 0
mov ecx, dword [ebp - 0x14c]
mov edx, dword [ebp - 0x2570]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x14c]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x14c]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x14c]
mov ecx, dword [ebp - 0x14c]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x14c]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x14c]
movss xmm0, dword [0x10328a64]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x14c]
movss xmm0, dword [0x10328a64]
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x14c]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x14c]
movss xmm0, dword [0x1032891c]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x3ad4]
push edx
mov ecx, dword [ebp - 0x14c]
add ecx, 0xa0
call fcn.100acaa0
mov byte [ebp - 4], 0x2f
lea ecx, [ebp - 0x3aa4]
call fcn.1008b960
mov byte [ebp - 4], 0x2d
lea ecx, [ebp - 0x3abc]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3ad4]
call fcn.100ae140
mov eax, dword [ebp - 0x130]
add eax, 0x82c
mov dword [ebp - 0x28f0], eax
mov dword [ebp - 0xfc], 0x100a8570
mov ecx, dword [ebp - 0x28f0]
add ecx, 0x58
mov dword [ebp - 0x28f8], ecx
lea edx, [ebp - 0xfc]
push edx
mov ecx, dword [ebp - 0x28f8]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0x82c
mov dword [ebp - 0x28fc], eax
mov ecx, dword [ebp - 0x28fc]
mov dword [ecx + 0x64], fcn.102e1320
mov edx, dword [ebp - 0x130]
add edx, 0x82c
mov dword [ebp - 0x84], edx
mov eax, dword [ebp - 0x84]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x84]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x84]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x84]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x84]
mov eax, dword [ebp - 0x130]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x130]
add edx, 0x18
mov dword [ebp - 0x2900], edx
lea eax, [ebp - 0x84]
push eax
mov ecx, dword [ebp - 0x2900]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0x30
mov dword [ebp - 0x2038], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.items]
mov byte [ebp - 0x84c], cl
movsx edx, byte [ebp - 0x84c]
xor edx, 0xffffff98
mov byte [ebp - 0x84d], dl
mov al, byte [ebp - 0x84d]
mov byte [ebp - 0x1f70], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x854], dl
movsx eax, byte [ebp - 0x854]
xor eax, 0xffffff98
mov byte [ebp - 0x855], al
mov cl, byte [ebp - 0x855]
mov byte [ebp - 0x1f6f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.items]
mov byte [ebp - 0x85c], al
movsx ecx, byte [ebp - 0x85c]
xor ecx, 0xffffff98
mov byte [ebp - 0x85d], cl
mov dl, byte [ebp - 0x85d]
mov byte [ebp - 0x1f6e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x864], dl
movsx eax, byte [ebp - 0x864]
xor eax, 0xffffff98
mov byte [ebp - 0x865], al
mov cl, byte [ebp - 0x865]
mov byte [ebp - 0x1f6d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.items]
mov byte [ebp - 0x86c], al
movsx ecx, byte [ebp - 0x86c]
xor ecx, 0xffffff98
mov byte [ebp - 0x86d], cl
mov dl, byte [ebp - 0x86d]
mov byte [ebp - 0x1f6c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x874], dl
movsx eax, byte [ebp - 0x874]
xor eax, 0xffffff98
mov byte [ebp - 0x875], al
mov cl, byte [ebp - 0x875]
mov byte [ebp - 0x1f6b], cl
mov dword [ebp - 0x2028], 0
jmp 0x10172b63
mov edx, dword [ebp - 0x2028]
add edx, 1
mov dword [ebp - 0x2028], edx
cmp dword [ebp - 0x2028], 6
jae 0x10172be5
lea eax, [ebp - 0x1f70]
mov dword [ebp - 0x2904], eax
mov ecx, dword [ebp - 0x2904]
add ecx, dword [ebp - 0x2028]
mov dword [ebp - 0x2908], ecx
mov edx, dword [ebp - 0x2908]
mov al, byte [edx]
mov byte [ebp - 0x87c], al
mov cl, byte [ebp - 0x23e7]
mov byte [ebp - 0x1aa], cl
movsx edx, byte [ebp - 0x87c]
xor edx, 0xffffff98
mov byte [ebp - 0x1aa], dl
lea eax, [ebp - 0x1f70]
mov dword [ebp - 0x290c], eax
mov ecx, dword [ebp - 0x290c]
add ecx, dword [ebp - 0x2028]
mov dword [ebp - 0x2910], ecx
mov edx, dword [ebp - 0x2910]
mov al, byte [ebp - 0x1aa]
mov byte [edx], al
jmp 0x10172b54
lea ecx, [ebp - 0x1f70]
mov dword [ebp - 0x2914], ecx
mov edx, dword [ebp - 0x2914]
mov dword [ebp - 0x2574], edx
lea eax, [ebp - 0x3b04]
mov dword [ebp - 0x2918], eax
movzx ecx, byte [ebp - 0x23e8]
push ecx
mov ecx, dword [ebp - 0x2918]
call fcn.1008cde0
mov dword [ebp - 4], 0x32
mov edx, dword [ebp - 0x2574]
mov dword [ebp - 0x202c], edx
mov eax, dword [ebp - 0x202c]
add eax, 1
mov dword [ebp - 0x291c], eax
mov ecx, dword [ebp - 0x202c]
mov dl, byte [ecx]
mov byte [ebp - 0x87d], dl
add dword [ebp - 0x202c], 1
cmp byte [ebp - 0x87d], 0
jne 0x10172c3e
mov eax, dword [ebp - 0x202c]
sub eax, dword [ebp - 0x291c]
mov dword [ebp - 0x2920], eax
mov ecx, dword [ebp - 0x2920]
mov dword [ebp - 0x2924], ecx
mov edx, dword [ebp - 0x2924]
mov dword [ebp - 0x2928], edx
mov eax, dword [ebp - 0x2928]
push eax
mov ecx, dword [ebp - 0x2574]
push ecx
lea ecx, [ebp - 0x3b04]
call fcn.1008ce30
mov dword [ebp - 4], 0x33
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x884], cl
movsx edx, byte [ebp - 0x884]
xor edx, 0xffffff98
mov byte [ebp - 0x885], dl
mov al, byte [ebp - 0x885]
mov byte [ebp - 0x226c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x88c], dl
movsx eax, byte [ebp - 0x88c]
xor eax, 0xffffff98
mov byte [ebp - 0x88d], al
mov cl, byte [ebp - 0x88d]
mov byte [ebp - 0x226b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x894], al
movsx ecx, byte [ebp - 0x894]
xor ecx, 0xffffff98
mov byte [ebp - 0x895], cl
mov dl, byte [ebp - 0x895]
mov byte [ebp - 0x226a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x89c], dl
movsx eax, byte [ebp - 0x89c]
xor eax, 0xffffff98
mov byte [ebp - 0x89d], al
mov cl, byte [ebp - 0x89d]
mov byte [ebp - 0x2269], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x8a4], al
movsx ecx, byte [ebp - 0x8a4]
xor ecx, 0xffffff98
mov byte [ebp - 0x8a5], cl
mov dl, byte [ebp - 0x8a5]
mov byte [ebp - 0x2268], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x8ac], dl
movsx eax, byte [ebp - 0x8ac]
xor eax, 0xffffff98
mov byte [ebp - 0x8ad], al
mov cl, byte [ebp - 0x8ad]
mov byte [ebp - 0x2267], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x8b4], cl
movsx edx, byte [ebp - 0x8b4]
xor edx, 0xffffff98
mov byte [ebp - 0x8b5], dl
mov al, byte [ebp - 0x8b5]
mov byte [ebp - 0x2266], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x8bc], al
movsx ecx, byte [ebp - 0x8bc]
xor ecx, 0xffffff98
mov byte [ebp - 0x8bd], cl
mov dl, byte [ebp - 0x8bd]
mov byte [ebp - 0x2265], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x8c4], cl
movsx edx, byte [ebp - 0x8c4]
xor edx, 0xffffff98
mov byte [ebp - 0x8c5], dl
mov al, byte [ebp - 0x8c5]
mov byte [ebp - 0x2264], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x8cc], al
movsx ecx, byte [ebp - 0x8cc]
xor ecx, 0xffffff98
mov byte [ebp - 0x8cd], cl
mov dl, byte [ebp - 0x8cd]
mov byte [ebp - 0x2263], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x8d4], dl
movsx eax, byte [ebp - 0x8d4]
xor eax, 0xffffff98
mov byte [ebp - 0x8d5], al
mov cl, byte [ebp - 0x8d5]
mov byte [ebp - 0x2262], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x8dc], cl
movsx edx, byte [ebp - 0x8dc]
xor edx, 0xffffff98
mov byte [ebp - 0x8dd], dl
mov al, byte [ebp - 0x8dd]
mov byte [ebp - 0x2261], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x8e4], al
movsx ecx, byte [ebp - 0x8e4]
xor ecx, 0xffffff98
mov byte [ebp - 0x8e5], cl
mov dl, byte [ebp - 0x8e5]
mov byte [ebp - 0x2260], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x8ec], dl
movsx eax, byte [ebp - 0x8ec]
xor eax, 0xffffff98
mov byte [ebp - 0x8ed], al
mov cl, byte [ebp - 0x8ed]
mov byte [ebp - 0x225f], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x8f4], cl
movsx edx, byte [ebp - 0x8f4]
xor edx, 0xffffff98
mov byte [ebp - 0x8f5], dl
mov al, byte [ebp - 0x8f5]
mov byte [ebp - 0x225e], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x8fc], al
movsx ecx, byte [ebp - 0x8fc]
xor ecx, 0xffffff98
mov byte [ebp - 0x8fd], cl
mov dl, byte [ebp - 0x8fd]
mov byte [ebp - 0x225d], dl
mov dword [ebp - 0x2030], 0
jmp 0x10172fc0
mov eax, dword [ebp - 0x2030]
add eax, 1
mov dword [ebp - 0x2030], eax
cmp dword [ebp - 0x2030], 0x10
jae 0x10173042
lea ecx, [ebp - 0x226c]
mov dword [ebp - 0x292c], ecx
mov edx, dword [ebp - 0x292c]
add edx, dword [ebp - 0x2030]
mov dword [ebp - 0x2930], edx
mov eax, dword [ebp - 0x2930]
mov cl, byte [eax]
mov byte [ebp - 0x904], cl
mov dl, byte [ebp - 0x23e9]
mov byte [ebp - 0x1ab], dl
movsx eax, byte [ebp - 0x904]
xor eax, 0xffffff98
mov byte [ebp - 0x1ab], al
lea ecx, [ebp - 0x226c]
mov dword [ebp - 0x2934], ecx
mov edx, dword [ebp - 0x2934]
add edx, dword [ebp - 0x2030]
mov dword [ebp - 0x2938], edx
mov eax, dword [ebp - 0x2938]
mov cl, byte [ebp - 0x1ab]
mov byte [eax], cl
jmp 0x10172fb1
lea edx, [ebp - 0x226c]
mov dword [ebp - 0x293c], edx
mov eax, dword [ebp - 0x293c]
mov dword [ebp - 0x2578], eax
lea ecx, [ebp - 0x3aec]
mov dword [ebp - 0x2940], ecx
movzx edx, byte [ebp - 0x23ea]
push edx
mov ecx, dword [ebp - 0x2940]
call fcn.1008cde0
mov byte [ebp - 4], 0x34
mov eax, dword [ebp - 0x2578]
mov dword [ebp - 0x2034], eax
mov ecx, dword [ebp - 0x2034]
add ecx, 1
mov dword [ebp - 0x2944], ecx
mov edx, dword [ebp - 0x2034]
mov al, byte [edx]
mov byte [ebp - 0x905], al
add dword [ebp - 0x2034], 1
cmp byte [ebp - 0x905], 0
jne 0x10173098
mov ecx, dword [ebp - 0x2034]
sub ecx, dword [ebp - 0x2944]
mov dword [ebp - 0x2948], ecx
mov edx, dword [ebp - 0x2948]
mov dword [ebp - 0x294c], edx
mov eax, dword [ebp - 0x294c]
mov dword [ebp - 0x2950], eax
mov ecx, dword [ebp - 0x2950]
push ecx
mov edx, dword [ebp - 0x2578]
push edx
lea ecx, [ebp - 0x3aec]
call fcn.1008ce30
mov byte [ebp - 4], 0x35
lea eax, [ebp - 0x3b04]
push eax
mov ecx, dword [ebp - 0x2038]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x2038]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x2038]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1017313f
lea ecx, [ebp - 0x3aec]
push ecx
mov ecx, dword [ebp - 0x2038]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x2038]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x33
lea ecx, [ebp - 0x3aec]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3b04]
call fcn.1008b960
mov eax, dword [ebp - 0x130]
add eax, 0x30
mov dword [ebp - 0x88], eax
mov ecx, dword [ebp - 0x88]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x88]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x88]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x88]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x88]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x2954], eax
lea ecx, [ebp - 0x88]
push ecx
mov ecx, dword [ebp - 0x2954]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0xb8
mov dword [ebp - 0x204c], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.ammo]
mov byte [ebp - 0x90c], dl
movsx eax, byte [ebp - 0x90c]
xor eax, 0xffffff98
mov byte [ebp - 0x90d], al
mov cl, byte [ebp - 0x90d]
mov byte [ebp - 0x1ca0], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.ammo]
mov byte [ebp - 0x914], al
movsx ecx, byte [ebp - 0x914]
xor ecx, 0xffffff98
mov byte [ebp - 0x915], cl
mov dl, byte [ebp - 0x915]
mov byte [ebp - 0x1c9f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x91c], cl
movsx edx, byte [ebp - 0x91c]
xor edx, 0xffffff98
mov byte [ebp - 0x91d], dl
mov al, byte [ebp - 0x91d]
mov byte [ebp - 0x1c9e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.ammo]
mov byte [ebp - 0x924], al
movsx ecx, byte [ebp - 0x924]
xor ecx, 0xffffff98
mov byte [ebp - 0x925], cl
mov dl, byte [ebp - 0x925]
mov byte [ebp - 0x1c9d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x92c], cl
movsx edx, byte [ebp - 0x92c]
xor edx, 0xffffff98
mov byte [ebp - 0x92d], dl
mov al, byte [ebp - 0x92d]
mov byte [ebp - 0x1c9c], al
mov dword [ebp - 0x203c], 0
jmp 0x101732fb
mov ecx, dword [ebp - 0x203c]
add ecx, 1
mov dword [ebp - 0x203c], ecx
cmp dword [ebp - 0x203c], 5
jae 0x1017337d
lea edx, [ebp - 0x1ca0]
mov dword [ebp - 0x2958], edx
mov eax, dword [ebp - 0x2958]
add eax, dword [ebp - 0x203c]
mov dword [ebp - 0x295c], eax
mov ecx, dword [ebp - 0x295c]
mov dl, byte [ecx]
mov byte [ebp - 0x934], dl
mov al, byte [ebp - 0x23eb]
mov byte [ebp - 0x1ac], al
movsx ecx, byte [ebp - 0x934]
xor ecx, 0xffffff98
mov byte [ebp - 0x1ac], cl
lea edx, [ebp - 0x1ca0]
mov dword [ebp - 0x2960], edx
mov eax, dword [ebp - 0x2960]
add eax, dword [ebp - 0x203c]
mov dword [ebp - 0x2964], eax
mov ecx, dword [ebp - 0x2964]
mov dl, byte [ebp - 0x1ac]
mov byte [ecx], dl
jmp 0x101732ec
lea eax, [ebp - 0x1ca0]
mov dword [ebp - 0x2968], eax
mov ecx, dword [ebp - 0x2968]
mov dword [ebp - 0x257c], ecx
lea edx, [ebp - 0x3b34]
mov dword [ebp - 0x296c], edx
movzx eax, byte [ebp - 0x23ec]
push eax
mov ecx, dword [ebp - 0x296c]
call fcn.1008cde0
mov dword [ebp - 4], 0x36
mov ecx, dword [ebp - 0x257c]
mov dword [ebp - 0x2040], ecx
mov edx, dword [ebp - 0x2040]
add edx, 1
mov dword [ebp - 0x2970], edx
mov eax, dword [ebp - 0x2040]
mov cl, byte [eax]
mov byte [ebp - 0x935], cl
add dword [ebp - 0x2040], 1
cmp byte [ebp - 0x935], 0
jne 0x101733d6
mov edx, dword [ebp - 0x2040]
sub edx, dword [ebp - 0x2970]
mov dword [ebp - 0x2974], edx
mov eax, dword [ebp - 0x2974]
mov dword [ebp - 0x2978], eax
mov ecx, dword [ebp - 0x2978]
mov dword [ebp - 0x297c], ecx
mov edx, dword [ebp - 0x297c]
push edx
mov eax, dword [ebp - 0x257c]
push eax
lea ecx, [ebp - 0x3b34]
call fcn.1008ce30
mov dword [ebp - 4], 0x37
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x93c], al
movsx ecx, byte [ebp - 0x93c]
xor ecx, 0xffffff98
mov byte [ebp - 0x93d], cl
mov dl, byte [ebp - 0x93d]
mov byte [ebp - 0x22e4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x944], cl
movsx edx, byte [ebp - 0x944]
xor edx, 0xffffff98
mov byte [ebp - 0x945], dl
mov al, byte [ebp - 0x945]
mov byte [ebp - 0x22e3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x94c], dl
movsx eax, byte [ebp - 0x94c]
xor eax, 0xffffff98
mov byte [ebp - 0x94d], al
mov cl, byte [ebp - 0x94d]
mov byte [ebp - 0x22e2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x954], cl
movsx edx, byte [ebp - 0x954]
xor edx, 0xffffff98
mov byte [ebp - 0x955], dl
mov al, byte [ebp - 0x955]
mov byte [ebp - 0x22e1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x95c], dl
movsx eax, byte [ebp - 0x95c]
xor eax, 0xffffff98
mov byte [ebp - 0x95d], al
mov cl, byte [ebp - 0x95d]
mov byte [ebp - 0x22e0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x964], cl
movsx edx, byte [ebp - 0x964]
xor edx, 0xffffff98
mov byte [ebp - 0x965], dl
mov al, byte [ebp - 0x965]
mov byte [ebp - 0x22df], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x96c], al
movsx ecx, byte [ebp - 0x96c]
xor ecx, 0xffffff98
mov byte [ebp - 0x96d], cl
mov dl, byte [ebp - 0x96d]
mov byte [ebp - 0x22de], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x974], dl
movsx eax, byte [ebp - 0x974]
xor eax, 0xffffff98
mov byte [ebp - 0x975], al
mov cl, byte [ebp - 0x975]
mov byte [ebp - 0x22dd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x97c], al
movsx ecx, byte [ebp - 0x97c]
xor ecx, 0xffffff98
mov byte [ebp - 0x97d], cl
mov dl, byte [ebp - 0x97d]
mov byte [ebp - 0x22dc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x984], dl
movsx eax, byte [ebp - 0x984]
xor eax, 0xffffff98
mov byte [ebp - 0x985], al
mov cl, byte [ebp - 0x985]
mov byte [ebp - 0x22db], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x98c], cl
movsx edx, byte [ebp - 0x98c]
xor edx, 0xffffff98
mov byte [ebp - 0x98d], dl
mov al, byte [ebp - 0x98d]
mov byte [ebp - 0x22da], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x994], al
movsx ecx, byte [ebp - 0x994]
xor ecx, 0xffffff98
mov byte [ebp - 0x995], cl
mov dl, byte [ebp - 0x995]
mov byte [ebp - 0x22d9], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x99c], dl
movsx eax, byte [ebp - 0x99c]
xor eax, 0xffffff98
mov byte [ebp - 0x99d], al
mov cl, byte [ebp - 0x99d]
mov byte [ebp - 0x22d8], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x9a4], cl
movsx edx, byte [ebp - 0x9a4]
xor edx, 0xffffff98
mov byte [ebp - 0x9a5], dl
mov al, byte [ebp - 0x9a5]
mov byte [ebp - 0x22d7], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9ac], al
movsx ecx, byte [ebp - 0x9ac]
xor ecx, 0xffffff98
mov byte [ebp - 0x9ad], cl
mov dl, byte [ebp - 0x9ad]
mov byte [ebp - 0x22d6], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9b4], dl
movsx eax, byte [ebp - 0x9b4]
xor eax, 0xffffff98
mov byte [ebp - 0x9b5], al
mov cl, byte [ebp - 0x9b5]
mov byte [ebp - 0x22d5], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9bc], al
movsx ecx, byte [ebp - 0x9bc]
xor ecx, 0xffffff98
mov byte [ebp - 0x9bd], cl
mov dl, byte [ebp - 0x9bd]
mov byte [ebp - 0x22d4], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9c4], dl
movsx eax, byte [ebp - 0x9c4]
xor eax, 0xffffff98
mov byte [ebp - 0x9c5], al
mov cl, byte [ebp - 0x9c5]
mov byte [ebp - 0x22d3], cl
mov edx, 1
imul eax, edx, 0x12
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x9cc], cl
movsx edx, byte [ebp - 0x9cc]
xor edx, 0xffffff98
mov byte [ebp - 0x9cd], dl
mov al, byte [ebp - 0x9cd]
mov byte [ebp - 0x22d2], al
mov ecx, 1
imul edx, ecx, 0x13
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9d4], al
movsx ecx, byte [ebp - 0x9d4]
xor ecx, 0xffffff98
mov byte [ebp - 0x9d5], cl
mov dl, byte [ebp - 0x9d5]
mov byte [ebp - 0x22d1], dl
mov eax, 1
imul ecx, eax, 0x14
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x9dc], dl
movsx eax, byte [ebp - 0x9dc]
xor eax, 0xffffff98
mov byte [ebp - 0x9dd], al
mov cl, byte [ebp - 0x9dd]
mov byte [ebp - 0x22d0], cl
mov dword [ebp - 0x2044], 0
jmp 0x10173848
mov edx, dword [ebp - 0x2044]
add edx, 1
mov dword [ebp - 0x2044], edx
cmp dword [ebp - 0x2044], 0x15
jae 0x101738ca
lea eax, [ebp - 0x22e4]
mov dword [ebp - 0x2980], eax
mov ecx, dword [ebp - 0x2980]
add ecx, dword [ebp - 0x2044]
mov dword [ebp - 0x2984], ecx
mov edx, dword [ebp - 0x2984]
mov al, byte [edx]
mov byte [ebp - 0x9e4], al
mov cl, byte [ebp - 0x23ed]
mov byte [ebp - 0x1ad], cl
movsx edx, byte [ebp - 0x9e4]
xor edx, 0xffffff98
mov byte [ebp - 0x1ad], dl
lea eax, [ebp - 0x22e4]
mov dword [ebp - 0x2988], eax
mov ecx, dword [ebp - 0x2988]
add ecx, dword [ebp - 0x2044]
mov dword [ebp - 0x298c], ecx
mov edx, dword [ebp - 0x298c]
mov al, byte [ebp - 0x1ad]
mov byte [edx], al
jmp 0x10173839
lea ecx, [ebp - 0x22e4]
mov dword [ebp - 0x2990], ecx
mov edx, dword [ebp - 0x2990]
mov dword [ebp - 0x2580], edx
lea eax, [ebp - 0x3b1c]
mov dword [ebp - 0x2994], eax
movzx ecx, byte [ebp - 0x23ee]
push ecx
mov ecx, dword [ebp - 0x2994]
call fcn.1008cde0
mov byte [ebp - 4], 0x38
mov edx, dword [ebp - 0x2580]
mov dword [ebp - 0x2048], edx
mov eax, dword [ebp - 0x2048]
add eax, 1
mov dword [ebp - 0x2998], eax
mov ecx, dword [ebp - 0x2048]
mov dl, byte [ecx]
mov byte [ebp - 0x9e5], dl
add dword [ebp - 0x2048], 1
cmp byte [ebp - 0x9e5], 0
jne 0x10173920
mov eax, dword [ebp - 0x2048]
sub eax, dword [ebp - 0x2998]
mov dword [ebp - 0x299c], eax
mov ecx, dword [ebp - 0x299c]
mov dword [ebp - 0x29a0], ecx
mov edx, dword [ebp - 0x29a0]
mov dword [ebp - 0x29a4], edx
mov eax, dword [ebp - 0x29a4]
push eax
mov ecx, dword [ebp - 0x2580]
push ecx
lea ecx, [ebp - 0x3b1c]
call fcn.1008ce30
mov byte [ebp - 4], 0x39
lea edx, [ebp - 0x3b34]
push edx
mov ecx, dword [ebp - 0x204c]
add ecx, 0x38
call fcn.100ad110
mov eax, dword [ebp - 0x204c]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x204c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x101739c7
lea eax, [ebp - 0x3b1c]
push eax
mov ecx, dword [ebp - 0x204c]
add ecx, 0x70
call fcn.100ad110
mov ecx, dword [ebp - 0x204c]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 0x37
lea ecx, [ebp - 0x3b1c]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3b34]
call fcn.1008b960
mov edx, dword [ebp - 0x130]
add edx, 0xb8
mov dword [ebp - 0x29a8], edx
mov dword [ebp - 0x100], 0x100a8190
mov eax, dword [ebp - 0x29a8]
add eax, 0x58
mov dword [ebp - 0x29b0], eax
lea ecx, [ebp - 0x100]
push ecx
mov ecx, dword [ebp - 0x29b0]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0xb8
mov dword [ebp - 0x8c], edx
mov eax, dword [ebp - 0x8c]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x8c]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x8c]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x8c]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x8c]
mov eax, dword [ebp - 0x130]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x130]
add edx, 0x18
mov dword [ebp - 0x29b4], edx
lea eax, [ebp - 0x8c]
push eax
mov ecx, dword [ebp - 0x29b4]
call fcn.1008c950
mov ecx, dword [ebp - 0x130]
add ecx, 0x140
mov dword [ebp - 0x1a90], ecx
mov edx, dword [0x103bfacc]
mov dword [ebp - 0x29b8], edx
mov eax, dword [ebp - 0x29b8]
mov dword [ebp - 0x29bc], eax
mov ecx, dword [ebp - 0x29bc]
mov dword [ebp - 0x2a10], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0x9ec], cl
movsx edx, byte [ebp - 0x9ec]
xor edx, 0xffffff98
mov byte [ebp - 0x9ed], dl
mov al, byte [ebp - 0x9ed]
mov byte [ebp - 0x20fc], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0x9f4], dl
movsx eax, byte [ebp - 0x9f4]
xor eax, 0xffffff98
mov byte [ebp - 0x9f5], al
mov cl, byte [ebp - 0x9f5]
mov byte [ebp - 0x20fb], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.item_color]
mov byte [ebp - 0x9fc], al
movsx ecx, byte [ebp - 0x9fc]
xor ecx, 0xffffff98
mov byte [ebp - 0x9fd], cl
mov dl, byte [ebp - 0x9fd]
mov byte [ebp - 0x20fa], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0xa04], dl
movsx eax, byte [ebp - 0xa04]
xor eax, 0xffffff98
mov byte [ebp - 0xa05], al
mov cl, byte [ebp - 0xa05]
mov byte [ebp - 0x20f9], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.item_color]
mov byte [ebp - 0xa0c], al
movsx ecx, byte [ebp - 0xa0c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa0d], cl
mov dl, byte [ebp - 0xa0d]
mov byte [ebp - 0x20f8], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0xa14], dl
movsx eax, byte [ebp - 0xa14]
xor eax, 0xffffff98
mov byte [ebp - 0xa15], al
mov cl, byte [ebp - 0xa15]
mov byte [ebp - 0x20f7], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0xa1c], cl
movsx edx, byte [ebp - 0xa1c]
xor edx, 0xffffff98
mov byte [ebp - 0xa1d], dl
mov al, byte [ebp - 0xa1d]
mov byte [ebp - 0x20f6], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.item_color]
mov byte [ebp - 0xa24], al
movsx ecx, byte [ebp - 0xa24]
xor ecx, 0xffffff98
mov byte [ebp - 0xa25], cl
mov dl, byte [ebp - 0xa25]
mov byte [ebp - 0x20f5], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0xa2c], cl
movsx edx, byte [ebp - 0xa2c]
xor edx, 0xffffff98
mov byte [ebp - 0xa2d], dl
mov al, byte [ebp - 0xa2d]
mov byte [ebp - 0x20f4], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.item_color]
mov byte [ebp - 0xa34], al
movsx ecx, byte [ebp - 0xa34]
xor ecx, 0xffffff98
mov byte [ebp - 0xa35], cl
mov dl, byte [ebp - 0xa35]
mov byte [ebp - 0x20f3], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0xa3c], dl
movsx eax, byte [ebp - 0xa3c]
xor eax, 0xffffff98
mov byte [ebp - 0xa3d], al
mov cl, byte [ebp - 0xa3d]
mov byte [ebp - 0x20f2], cl
mov dword [ebp - 0x1ef8], 0
jmp 0x10173d07
mov edx, dword [ebp - 0x1ef8]
add edx, 1
mov dword [ebp - 0x1ef8], edx
cmp dword [ebp - 0x1ef8], 0xb
jae 0x10173d89
lea eax, [ebp - 0x20fc]
mov dword [ebp - 0x29c0], eax
mov ecx, dword [ebp - 0x29c0]
add ecx, dword [ebp - 0x1ef8]
mov dword [ebp - 0x29c4], ecx
mov edx, dword [ebp - 0x29c4]
mov al, byte [edx]
mov byte [ebp - 0xa44], al
mov cl, byte [ebp - 0x23ef]
mov byte [ebp - 0x1ae], cl
movsx edx, byte [ebp - 0xa44]
xor edx, 0xffffff98
mov byte [ebp - 0x1ae], dl
lea eax, [ebp - 0x20fc]
mov dword [ebp - 0x29c8], eax
mov ecx, dword [ebp - 0x29c8]
add ecx, dword [ebp - 0x1ef8]
mov dword [ebp - 0x29cc], ecx
mov edx, dword [ebp - 0x29cc]
mov al, byte [ebp - 0x1ae]
mov byte [edx], al
jmp 0x10173cf8
lea ecx, [ebp - 0x20fc]
mov dword [ebp - 0x29d0], ecx
mov edx, dword [ebp - 0x29d0]
mov dword [ebp - 0x2584], edx
lea eax, [ebp - 0x3b64]
mov dword [ebp - 0x29d4], eax
movzx ecx, byte [ebp - 0x23f0]
push ecx
mov ecx, dword [ebp - 0x29d4]
call fcn.1008cde0
mov dword [ebp - 4], 0x3a
mov edx, dword [ebp - 0x2584]
mov dword [ebp - 0x1efc], edx
mov eax, dword [ebp - 0x1efc]
add eax, 1
mov dword [ebp - 0x29d8], eax
mov ecx, dword [ebp - 0x1efc]
mov dl, byte [ecx]
mov byte [ebp - 0xa45], dl
add dword [ebp - 0x1efc], 1
cmp byte [ebp - 0xa45], 0
jne 0x10173de2
mov eax, dword [ebp - 0x1efc]
sub eax, dword [ebp - 0x29d8]
mov dword [ebp - 0x29dc], eax
mov ecx, dword [ebp - 0x29dc]
mov dword [ebp - 0x29e0], ecx
mov edx, dword [ebp - 0x29e0]
mov dword [ebp - 0x29e4], edx
mov eax, dword [ebp - 0x29e4]
push eax
mov ecx, dword [ebp - 0x2584]
push ecx
lea ecx, [ebp - 0x3b64]
call fcn.1008ce30
mov dword [ebp - 4], 0x3b
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.color]
mov byte [ebp - 0xa4c], cl
movsx edx, byte [ebp - 0xa4c]
xor edx, 0xffffff98
mov byte [ebp - 0xa4d], dl
mov al, byte [ebp - 0xa4d]
mov byte [ebp - 0x1f78], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.color]
mov byte [ebp - 0xa54], dl
movsx eax, byte [ebp - 0xa54]
xor eax, 0xffffff98
mov byte [ebp - 0xa55], al
mov cl, byte [ebp - 0xa55]
mov byte [ebp - 0x1f77], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.color]
mov byte [ebp - 0xa5c], al
movsx ecx, byte [ebp - 0xa5c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa5d], cl
mov dl, byte [ebp - 0xa5d]
mov byte [ebp - 0x1f76], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.color]
mov byte [ebp - 0xa64], dl
movsx eax, byte [ebp - 0xa64]
xor eax, 0xffffff98
mov byte [ebp - 0xa65], al
mov cl, byte [ebp - 0xa65]
mov byte [ebp - 0x1f75], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.color]
mov byte [ebp - 0xa6c], al
movsx ecx, byte [ebp - 0xa6c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa6d], cl
mov dl, byte [ebp - 0xa6d]
mov byte [ebp - 0x1f74], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.color]
mov byte [ebp - 0xa74], dl
movsx eax, byte [ebp - 0xa74]
xor eax, 0xffffff98
mov byte [ebp - 0xa75], al
mov cl, byte [ebp - 0xa75]
mov byte [ebp - 0x1f73], cl
mov dword [ebp - 0x1f00], 0
jmp 0x10173f84
mov edx, dword [ebp - 0x1f00]
add edx, 1
mov dword [ebp - 0x1f00], edx
cmp dword [ebp - 0x1f00], 6
jae 0x10174006
lea eax, [ebp - 0x1f78]
mov dword [ebp - 0x29e8], eax
mov ecx, dword [ebp - 0x29e8]
add ecx, dword [ebp - 0x1f00]
mov dword [ebp - 0x29ec], ecx
mov edx, dword [ebp - 0x29ec]
mov al, byte [edx]
mov byte [ebp - 0xa7c], al
mov cl, byte [ebp - 0x23f1]
mov byte [ebp - 0x1af], cl
movsx edx, byte [ebp - 0xa7c]
xor edx, 0xffffff98
mov byte [ebp - 0x1af], dl
lea eax, [ebp - 0x1f78]
mov dword [ebp - 0x29f0], eax
mov ecx, dword [ebp - 0x29f0]
add ecx, dword [ebp - 0x1f00]
mov dword [ebp - 0x29f4], ecx
mov edx, dword [ebp - 0x29f4]
mov al, byte [ebp - 0x1af]
mov byte [edx], al
jmp 0x10173f75
lea ecx, [ebp - 0x1f78]
mov dword [ebp - 0x29f8], ecx
mov edx, dword [ebp - 0x29f8]
mov dword [ebp - 0x2588], edx
lea eax, [ebp - 0x3b4c]
mov dword [ebp - 0x29fc], eax
movzx ecx, byte [ebp - 0x23f2]
push ecx
mov ecx, dword [ebp - 0x29fc]
call fcn.1008cde0
mov byte [ebp - 4], 0x3c
mov edx, dword [ebp - 0x2588]
mov dword [ebp - 0x1f08], edx
mov eax, dword [ebp - 0x1f08]
add eax, 1
mov dword [ebp - 0x2a00], eax
mov ecx, dword [ebp - 0x1f08]
mov dl, byte [ecx]
mov byte [ebp - 0xa7d], dl
add dword [ebp - 0x1f08], 1
cmp byte [ebp - 0xa7d], 0
jne 0x1017405c
mov eax, dword [ebp - 0x1f08]
sub eax, dword [ebp - 0x2a00]
mov dword [ebp - 0x2a04], eax
mov ecx, dword [ebp - 0x2a04]
mov dword [ebp - 0x2a08], ecx
mov edx, dword [ebp - 0x2a08]
mov dword [ebp - 0x2a0c], edx
mov eax, dword [ebp - 0x2a0c]
push eax
mov ecx, dword [ebp - 0x2588]
push ecx
lea ecx, [ebp - 0x3b4c]
call fcn.1008ce30
mov byte [ebp - 4], 0x3d
lea edx, [ebp - 0x3b4c]
push edx
mov ecx, dword [ebp - 0x1a90]
add ecx, 0x70
call fcn.100ad110
lea eax, [ebp - 0x3b64]
push eax
mov ecx, dword [ebp - 0x1a90]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1a90]
mov edx, dword [ebp - 0x2a10]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1a90]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1a90]
cmp dword [ecx + 0x8c], 0
je 0x10174136
mov edx, dword [ebp - 0x1a90]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1a90]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 0x3b
lea ecx, [ebp - 0x3b4c]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3b64]
call fcn.1008b960
mov eax, dword [ebp - 0x130]
add eax, 0x140
mov dword [ebp - 0x2a14], eax
mov dword [ebp - 0xe4], 0x100a8190
mov ecx, dword [ebp - 0x2a14]
add ecx, 0x58
mov dword [ebp - 0x2a1c], ecx
lea edx, [ebp - 0xe4]
push edx
mov ecx, dword [ebp - 0x2a1c]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0x140
mov dword [ebp - 0x90], eax
mov ecx, dword [ebp - 0x90]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x90]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x90]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x90]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x90]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x2a20], eax
lea ecx, [ebp - 0x90]
push ecx
mov ecx, dword [ebp - 0x2a20]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0x1d0
mov dword [ebp - 0x1f50], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.proj]
mov byte [ebp - 0xa84], dl
movsx eax, byte [ebp - 0xa84]
xor eax, 0xffffff98
mov byte [ebp - 0xa85], al
mov cl, byte [ebp - 0xa85]
mov byte [ebp - 0x1ca8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.proj]
mov byte [ebp - 0xa8c], al
movsx ecx, byte [ebp - 0xa8c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa8d], cl
mov dl, byte [ebp - 0xa8d]
mov byte [ebp - 0x1ca7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.proj]
mov byte [ebp - 0xa94], cl
movsx edx, byte [ebp - 0xa94]
xor edx, 0xffffff98
mov byte [ebp - 0xa95], dl
mov al, byte [ebp - 0xa95]
mov byte [ebp - 0x1ca6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.proj]
mov byte [ebp - 0xa9c], al
movsx ecx, byte [ebp - 0xa9c]
xor ecx, 0xffffff98
mov byte [ebp - 0xa9d], cl
mov dl, byte [ebp - 0xa9d]
mov byte [ebp - 0x1ca5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.proj]
mov byte [ebp - 0xaa4], cl
movsx edx, byte [ebp - 0xaa4]
xor edx, 0xffffff98
mov byte [ebp - 0xaa5], dl
mov al, byte [ebp - 0xaa5]
mov byte [ebp - 0x1ca4], al
mov dword [ebp - 0x1f10], 0
jmp 0x10174326
mov ecx, dword [ebp - 0x1f10]
add ecx, 1
mov dword [ebp - 0x1f10], ecx
cmp dword [ebp - 0x1f10], 5
jae 0x101743a8
lea edx, [ebp - 0x1ca8]
mov dword [ebp - 0x2a24], edx
mov eax, dword [ebp - 0x2a24]
add eax, dword [ebp - 0x1f10]
mov dword [ebp - 0x2a28], eax
mov ecx, dword [ebp - 0x2a28]
mov dl, byte [ecx]
mov byte [ebp - 0xaac], dl
mov al, byte [ebp - 0x23f3]
mov byte [ebp - 0x1b0], al
movsx ecx, byte [ebp - 0xaac]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b0], cl
lea edx, [ebp - 0x1ca8]
mov dword [ebp - 0x2a2c], edx
mov eax, dword [ebp - 0x2a2c]
add eax, dword [ebp - 0x1f10]
mov dword [ebp - 0x2a30], eax
mov ecx, dword [ebp - 0x2a30]
mov dl, byte [ebp - 0x1b0]
mov byte [ecx], dl
jmp 0x10174317
lea eax, [ebp - 0x1ca8]
mov dword [ebp - 0x2a34], eax
mov ecx, dword [ebp - 0x2a34]
mov dword [ebp - 0x258c], ecx
lea edx, [ebp - 0x3b94]
mov dword [ebp - 0x2a38], edx
movzx eax, byte [ebp - 0x23f4]
push eax
mov ecx, dword [ebp - 0x2a38]
call fcn.1008cde0
mov dword [ebp - 4], 0x3e
mov ecx, dword [ebp - 0x258c]
mov dword [ebp - 0x1f1c], ecx
mov edx, dword [ebp - 0x1f1c]
add edx, 1
mov dword [ebp - 0x2a3c], edx
mov eax, dword [ebp - 0x1f1c]
mov cl, byte [eax]
mov byte [ebp - 0xaad], cl
add dword [ebp - 0x1f1c], 1
cmp byte [ebp - 0xaad], 0
jne 0x10174401
mov edx, dword [ebp - 0x1f1c]
sub edx, dword [ebp - 0x2a3c]
mov dword [ebp - 0x2a40], edx
mov eax, dword [ebp - 0x2a40]
mov dword [ebp - 0x2a44], eax
mov ecx, dword [ebp - 0x2a44]
mov dword [ebp - 0x2a48], ecx
mov edx, dword [ebp - 0x2a48]
push edx
mov eax, dword [ebp - 0x258c]
push eax
lea ecx, [ebp - 0x3b94]
call fcn.1008ce30
mov dword [ebp - 4], 0x3f
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0xab4], al
movsx ecx, byte [ebp - 0xab4]
xor ecx, 0xffffff98
mov byte [ebp - 0xab5], cl
mov dl, byte [ebp - 0xab5]
mov byte [ebp - 0x213c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0xabc], cl
movsx edx, byte [ebp - 0xabc]
xor edx, 0xffffff98
mov byte [ebp - 0xabd], dl
mov al, byte [ebp - 0xabd]
mov byte [ebp - 0x213b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0xac4], dl
movsx eax, byte [ebp - 0xac4]
xor eax, 0xffffff98
mov byte [ebp - 0xac5], al
mov cl, byte [ebp - 0xac5]
mov byte [ebp - 0x213a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0xacc], cl
movsx edx, byte [ebp - 0xacc]
xor edx, 0xffffff98
mov byte [ebp - 0xacd], dl
mov al, byte [ebp - 0xacd]
mov byte [ebp - 0x2139], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0xad4], dl
movsx eax, byte [ebp - 0xad4]
xor eax, 0xffffff98
mov byte [ebp - 0xad5], al
mov cl, byte [ebp - 0xad5]
mov byte [ebp - 0x2138], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0xadc], cl
movsx edx, byte [ebp - 0xadc]
xor edx, 0xffffff98
mov byte [ebp - 0xadd], dl
mov al, byte [ebp - 0xadd]
mov byte [ebp - 0x2137], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0xae4], al
movsx ecx, byte [ebp - 0xae4]
xor ecx, 0xffffff98
mov byte [ebp - 0xae5], cl
mov dl, byte [ebp - 0xae5]
mov byte [ebp - 0x2136], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0xaec], dl
movsx eax, byte [ebp - 0xaec]
xor eax, 0xffffff98
mov byte [ebp - 0xaed], al
mov cl, byte [ebp - 0xaed]
mov byte [ebp - 0x2135], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0xaf4], al
movsx ecx, byte [ebp - 0xaf4]
xor ecx, 0xffffff98
mov byte [ebp - 0xaf5], cl
mov dl, byte [ebp - 0xaf5]
mov byte [ebp - 0x2134], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0xafc], dl
movsx eax, byte [ebp - 0xafc]
xor eax, 0xffffff98
mov byte [ebp - 0xafd], al
mov cl, byte [ebp - 0xafd]
mov byte [ebp - 0x2133], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0xb04], cl
movsx edx, byte [ebp - 0xb04]
xor edx, 0xffffff98
mov byte [ebp - 0xb05], dl
mov al, byte [ebp - 0xb05]
mov byte [ebp - 0x2132], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0xb0c], al
movsx ecx, byte [ebp - 0xb0c]
xor ecx, 0xffffff98
mov byte [ebp - 0xb0d], cl
mov dl, byte [ebp - 0xb0d]
mov byte [ebp - 0x2131], dl
mov dword [ebp - 0x1f24], 0
jmp 0x101746c3
mov eax, dword [ebp - 0x1f24]
add eax, 1
mov dword [ebp - 0x1f24], eax
cmp dword [ebp - 0x1f24], 0xc
jae 0x10174745
lea ecx, [ebp - 0x213c]
mov dword [ebp - 0x2a4c], ecx
mov edx, dword [ebp - 0x2a4c]
add edx, dword [ebp - 0x1f24]
mov dword [ebp - 0x2a50], edx
mov eax, dword [ebp - 0x2a50]
mov cl, byte [eax]
mov byte [ebp - 0xb14], cl
mov dl, byte [ebp - 0x23f5]
mov byte [ebp - 0x1b1], dl
movsx eax, byte [ebp - 0xb14]
xor eax, 0xffffff98
mov byte [ebp - 0x1b1], al
lea ecx, [ebp - 0x213c]
mov dword [ebp - 0x2a54], ecx
mov edx, dword [ebp - 0x2a54]
add edx, dword [ebp - 0x1f24]
mov dword [ebp - 0x2a58], edx
mov eax, dword [ebp - 0x2a58]
mov cl, byte [ebp - 0x1b1]
mov byte [eax], cl
jmp 0x101746b4
lea edx, [ebp - 0x213c]
mov dword [ebp - 0x2a5c], edx
mov eax, dword [ebp - 0x2a5c]
mov dword [ebp - 0x2590], eax
lea ecx, [ebp - 0x3b7c]
mov dword [ebp - 0x2a60], ecx
movzx edx, byte [ebp - 0x23f6]
push edx
mov ecx, dword [ebp - 0x2a60]
call fcn.1008cde0
mov byte [ebp - 4], 0x40
mov eax, dword [ebp - 0x2590]
mov dword [ebp - 0x1f4c], eax
mov ecx, dword [ebp - 0x1f4c]
add ecx, 1
mov dword [ebp - 0x2a64], ecx
mov edx, dword [ebp - 0x1f4c]
mov al, byte [edx]
mov byte [ebp - 0xb15], al
add dword [ebp - 0x1f4c], 1
cmp byte [ebp - 0xb15], 0
jne 0x1017479b
mov ecx, dword [ebp - 0x1f4c]
sub ecx, dword [ebp - 0x2a64]
mov dword [ebp - 0x2a68], ecx
mov edx, dword [ebp - 0x2a68]
mov dword [ebp - 0x2a6c], edx
mov eax, dword [ebp - 0x2a6c]
mov dword [ebp - 0x2a70], eax
mov ecx, dword [ebp - 0x2a70]
push ecx
mov edx, dword [ebp - 0x2590]
push edx
lea ecx, [ebp - 0x3b7c]
call fcn.1008ce30
mov byte [ebp - 4], 0x41
lea eax, [ebp - 0x3b94]
push eax
mov ecx, dword [ebp - 0x1f50]
add ecx, 0x38
call fcn.100ad110
mov ecx, dword [ebp - 0x1f50]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1f50]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10174842
lea ecx, [ebp - 0x3b7c]
push ecx
mov ecx, dword [ebp - 0x1f50]
add ecx, 0x70
call fcn.100ad110
mov edx, dword [ebp - 0x1f50]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x3f
lea ecx, [ebp - 0x3b7c]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3b94]
call fcn.1008b960
mov eax, dword [ebp - 0x130]
add eax, 0x1d0
mov dword [ebp - 0x94], eax
mov ecx, dword [ebp - 0x94]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x94]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x94]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x94]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x94]
mov ecx, dword [ebp - 0x130]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x130]
add eax, 0x18
mov dword [ebp - 0x2a74], eax
lea ecx, [ebp - 0x94]
push ecx
mov ecx, dword [ebp - 0x2a74]
call fcn.1008c950
mov edx, dword [ebp - 0x130]
add edx, 0x258
mov dword [ebp - 0x1a94], edx
mov eax, dword [0x103bfacc]
mov dword [ebp - 0x2a78], eax
mov ecx, dword [ebp - 0x2a78]
mov dword [ebp - 0x2a7c], ecx
mov edx, dword [ebp - 0x2a7c]
mov dword [ebp - 0x2ad0], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0xb1c], dl
movsx eax, byte [ebp - 0xb1c]
xor eax, 0xffffff98
mov byte [ebp - 0xb1d], al
mov cl, byte [ebp - 0xb1d]
mov byte [ebp - 0x2114], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0xb24], al
movsx ecx, byte [ebp - 0xb24]
xor ecx, 0xffffff98
mov byte [ebp - 0xb25], cl
mov dl, byte [ebp - 0xb25]
mov byte [ebp - 0x2113], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0xb2c], cl
movsx edx, byte [ebp - 0xb2c]
xor edx, 0xffffff98
mov byte [ebp - 0xb2d], dl
mov al, byte [ebp - 0xb2d]
mov byte [ebp - 0x2112], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0xb34], al
movsx ecx, byte [ebp - 0xb34]
xor ecx, 0xffffff98
mov byte [ebp - 0xb35], cl
mov dl, byte [ebp - 0xb35]
mov byte [ebp - 0x2111], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0xb3c], cl
movsx edx, byte [ebp - 0xb3c]
xor edx, 0xffffff98
mov byte [ebp - 0xb3d], dl
mov al, byte [ebp - 0xb3d]
mov byte [ebp - 0x2110], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0xb44], al
movsx ecx, byte [ebp - 0xb44]
xor ecx, 0xffffff98
mov byte [ebp - 0xb45], cl
mov dl, byte [ebp - 0xb45]
mov byte [ebp - 0x210f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0xb4c], dl
movsx eax, byte [ebp - 0xb4c]
xor eax, 0xffffff98
mov byte [ebp - 0xb4d], al
mov cl, byte [ebp - 0xb4d]
mov byte [ebp - 0x210e], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0xb54], cl
movsx edx, byte [ebp - 0xb54]
xor edx, 0xffffff98
mov byte [ebp - 0xb55], dl
mov al, byte [ebp - 0xb55]
mov byte [ebp - 0x210d], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0xb5c], dl
movsx eax, byte [ebp - 0xb5c]
xor eax, 0xffffff98
mov byte [ebp - 0xb5d], al
mov cl, byte [ebp - 0xb5d]
mov byte [ebp - 0x210c], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0xb64], cl
movsx edx, byte [ebp - 0xb64]
xor edx, 0xffffff98
mov byte [ebp - 0xb65], dl
mov al, byte [ebp - 0xb65]
mov byte [ebp - 0x210b], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0xb6c], al
movsx ecx, byte [ebp - 0xb6c]
xor ecx, 0xffffff98
mov byte [ebp - 0xb6d], cl
mov dl, byte [ebp - 0xb6d]
mov byte [ebp - 0x210a], dl
mov dword [ebp - 0x1f54], 0
jmp 0x10174b43
mov eax, dword [ebp - 0x1f54]
add eax, 1
mov dword [ebp - 0x1f54], eax
cmp dword [ebp - 0x1f54], 0xb
jae 0x10174bc5
lea ecx, [ebp - 0x2114]
mov dword [ebp - 0x2a80], ecx
mov edx, dword [ebp - 0x2a80]
add edx, dword [ebp - 0x1f54]
mov dword [ebp - 0x2a84], edx
mov eax, dword [ebp - 0x2a84]
mov cl, byte [eax]
mov byte [ebp - 0xb74], cl
mov dl, byte [ebp - 0x23f7]
mov byte [ebp - 0x1b2], dl
movsx eax, byte [ebp - 0xb74]
xor eax, 0xffffff98
mov byte [ebp - 0x1b2], al
lea ecx, [ebp - 0x2114]
mov dword [ebp - 0x2a88], ecx
mov edx, dword [ebp - 0x2a88]
add edx, dword [ebp - 0x1f54]
mov dword [ebp - 0x2a8c], edx
mov eax, dword [ebp - 0x2a8c]
mov cl, byte [ebp - 0x1b2]
mov byte [eax], cl
jmp 0x10174b34
lea edx, [ebp - 0x2114]
mov dword [ebp - 0x2a90], edx
mov eax, dword [ebp - 0x2a90]
mov dword [ebp - 0x2594], eax
lea ecx, [ebp - 0x3bc4]
mov dword [ebp - 0x2a94], ecx
movzx edx, byte [ebp - 0x23f8]
push edx
mov ecx, dword [ebp - 0x2a94]
call fcn.1008cde0
mov dword [ebp - 4], 0x42
mov eax, dword [ebp - 0x2594]
mov dword [ebp - 0x1cb4], eax
mov ecx, dword [ebp - 0x1cb4]
add ecx, 1
mov dword [ebp - 0x2a98], ecx
mov edx, dword [ebp - 0x1cb4]
mov al, byte [edx]
mov byte [ebp - 0xb75], al
add dword [ebp - 0x1cb4], 1
cmp byte [ebp - 0xb75], 0
jne 0x10174c1e
mov ecx, dword [ebp - 0x1cb4]
sub ecx, dword [ebp - 0x2a98]
mov dword [ebp - 0x2a9c], ecx
mov edx, dword [ebp - 0x2a9c]
mov dword [ebp - 0x2aa0], edx
mov eax, dword [ebp - 0x2aa0]
mov dword [ebp - 0x2aa4], eax
mov ecx, dword [ebp - 0x2aa4]
push ecx
mov edx, dword [ebp - 0x2594]
push edx
lea ecx, [ebp - 0x3bc4]
call fcn.1008ce30
mov dword [ebp - 4], 0x43
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.color]
mov byte [ebp - 0xb7c], dl
movsx eax, byte [ebp - 0xb7c]
xor eax, 0xffffff98
mov byte [ebp - 0xb7d], al
mov cl, byte [ebp - 0xb7d]
mov byte [ebp - 0x1f80], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.color]
mov byte [ebp - 0xb84], al
movsx ecx, byte [ebp - 0xb84]
xor ecx, 0xffffff98
mov byte [ebp - 0xb85], cl
mov dl, byte [ebp - 0xb85]
mov byte [ebp - 0x1f7f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.color]
mov byte [ebp - 0xb8c], cl
movsx edx, byte [ebp - 0xb8c]
xor edx, 0xffffff98
mov byte [ebp - 0xb8d], dl
mov al, byte [ebp - 0xb8d]
mov byte [ebp - 0x1f7e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.color]
mov byte [ebp - 0xb94], al
movsx ecx, byte [ebp - 0xb94]
xor ecx, 0xffffff98
mov byte [ebp - 0xb95], cl
mov dl, byte [ebp - 0xb95]
mov byte [ebp - 0x1f7d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.color]
mov byte [ebp - 0xb9c], cl
movsx edx, byte [ebp - 0xb9c]
xor edx, 0xffffff98
mov byte [ebp - 0xb9d], dl
mov al, byte [ebp - 0xb9d]
mov byte [ebp - 0x1f7c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.color]
mov byte [ebp - 0xba4], al
movsx ecx, byte [ebp - 0xba4]
xor ecx, 0xffffff98
mov byte [ebp - 0xba5], cl
mov dl, byte [ebp - 0xba5]
mov byte [ebp - 0x1f7b], dl
mov dword [ebp - 0x1cb8], 0
jmp 0x10174dc0
mov eax, dword [ebp - 0x1cb8]
add eax, 1
mov dword [ebp - 0x1cb8], eax
cmp dword [ebp - 0x1cb8], 6
jae 0x10174e42
lea ecx, [ebp - 0x1f80]
mov dword [ebp - 0x2aa8], ecx
mov edx, dword [ebp - 0x2aa8]
add edx, dword [ebp - 0x1cb8]
mov dword [ebp - 0x2aac], edx
mov eax, dword [ebp - 0x2aac]
mov cl, byte [eax]
mov byte [ebp - 0xbac], cl
mov dl, byte [ebp - 0x23f9]
mov byte [ebp - 0x1b3], dl
movsx eax, byte [ebp - 0xbac]
xor eax, 0xffffff98
mov byte [ebp - 0x1b3], al
lea ecx, [ebp - 0x1f80]
mov dword [ebp - 0x2ab0], ecx
mov edx, dword [ebp - 0x2ab0]
add edx, dword [ebp - 0x1cb8]
mov dword [ebp - 0x2ab4], edx
mov eax, dword [ebp - 0x2ab4]
mov cl, byte [ebp - 0x1b3]
mov byte [eax], cl
jmp 0x10174db1
lea edx, [ebp - 0x1f80]
mov dword [ebp - 0x2ab8], edx
mov eax, dword [ebp - 0x2ab8]
mov dword [ebp - 0x2598], eax
lea ecx, [ebp - 0x3bac]
mov dword [ebp - 0x2abc], ecx
movzx edx, byte [ebp - 0x23fa]
push edx
mov ecx, dword [ebp - 0x2abc]
call fcn.1008cde0
mov byte [ebp - 4], 0x44
mov eax, dword [ebp - 0x2598]
mov dword [ebp - 0x1cbc], eax
mov ecx, dword [ebp - 0x1cbc]
add ecx, 1
mov dword [ebp - 0x2ac0], ecx
mov edx, dword [ebp - 0x1cbc]
mov al, byte [edx]
mov byte [ebp - 0xbad], al
add dword [ebp - 0x1cbc], 1
cmp byte [ebp - 0xbad], 0
jne 0x10174e98
mov ecx, dword [ebp - 0x1cbc]
sub ecx, dword [ebp - 0x2ac0]
mov dword [ebp - 0x2ac4], ecx
mov edx, dword [ebp - 0x2ac4]
mov dword [ebp - 0x2ac8], edx
mov eax, dword [ebp - 0x2ac8]
mov dword [ebp - 0x2acc], eax
mov ecx, dword [ebp - 0x2acc]
push ecx
mov edx, dword [ebp - 0x2598]
push edx
lea ecx, [ebp - 0x3bac]
call fcn.1008ce30
mov byte [ebp - 4], 0x45
lea eax, [ebp - 0x3bac]
push eax
mov ecx, dword [ebp - 0x1a94]
add ecx, 0x70
call fcn.100ad110
lea ecx, [ebp - 0x3bc4]
push ecx
mov ecx, dword [ebp - 0x1a94]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x1a94]
mov eax, dword [ebp - 0x2ad0]
mov dword [edx + 0x88], eax
mov ecx, dword [ebp - 0x1a94]
mov dword [ecx + 0x8c], 0
mov edx, dword [ebp - 0x1a94]
cmp dword [edx + 0x8c], 0
je 0x10174f72
mov eax, dword [ebp - 0x1a94]
mov ecx, dword [eax + 0x88]
mov edx, dword [ebp - 0x1a94]
mov eax, dword [edx + 0x8c]
mov dword [eax], ecx
mov byte [ebp - 4], 0x43
lea ecx, [ebp - 0x3bac]
call fcn.1008b960
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3bc4]
call fcn.1008b960
mov ecx, dword [ebp - 0x130]
add ecx, 0x258
mov dword [ebp - 0x98], ecx
mov edx, dword [ebp - 0x98]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x98]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x98]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x98]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x98]
mov edx, dword [ebp - 0x130]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x130]
add ecx, 0x18
mov dword [ebp - 0x2ad4], ecx
lea edx, [ebp - 0x98]
push edx
mov ecx, dword [ebp - 0x2ad4]
call fcn.1008c950
mov eax, dword [ebp - 0x130]
add eax, 0x2e8
mov dword [ebp - 0x144], eax
lea ecx, [ebp - 0x23fb]
mov dword [ebp - 0x2b28], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.frag]
mov byte [ebp - 0xbb4], cl
movsx edx, byte [ebp - 0xbb4]
xor edx, 0xffffff98
mov byte [ebp - 0xbb5], dl
mov al, byte [ebp - 0xbb5]
mov byte [ebp - 0x1cb0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.frag]
mov byte [ebp - 0xbbc], dl
movsx eax, byte [ebp - 0xbbc]
xor eax, 0xffffff98
mov byte [ebp - 0xbbd], al
mov cl, byte [ebp - 0xbbd]
mov byte [ebp - 0x1caf], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.frag]
mov byte [ebp - 0xbc4], al
movsx ecx, byte [ebp - 0xbc4]
xor ecx, 0xffffff98
mov byte [ebp - 0xbc5], cl
mov dl, byte [ebp - 0xbc5]
mov byte [ebp - 0x1cae], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.frag]
mov byte [ebp - 0xbcc], dl
movsx eax, byte [ebp - 0xbcc]
xor eax, 0xffffff98
mov byte [ebp - 0xbcd], al
mov cl, byte [ebp - 0xbcd]
mov byte [ebp - 0x1cad], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.frag]
mov byte [ebp - 0xbd4], al
movsx ecx, byte [ebp - 0xbd4]
xor ecx, 0xffffff98
mov byte [ebp - 0xbd5], cl
mov dl, byte [ebp - 0xbd5]
mov byte [ebp - 0x1cac], dl
mov dword [ebp - 0x1cc0], 0
jmp 0x10175132
mov eax, dword [ebp - 0x1cc0]
add eax, 1
mov dword [ebp - 0x1cc0], eax
cmp dword [ebp - 0x1cc0], 5
jae 0x101751b4
lea ecx, [ebp - 0x1cb0]
mov dword [ebp - 0x2ad8], ecx
mov edx, dword [ebp - 0x2ad8]
add edx, dword [ebp - 0x1cc0]
mov dword [ebp - 0x2adc], edx
mov eax, dword [ebp - 0x2adc]
mov cl, byte [eax]
mov byte [ebp - 0xbdc], cl
mov dl, byte [ebp - 0x23fc]
mov byte [ebp - 0x1b4], dl
movsx eax, byte [ebp - 0xbdc]
xor eax, 0xffffff98
mov byte [ebp - 0x1b4], al
lea ecx, [ebp - 0x1cb0]
mov dword [ebp - 0x2ae0], ecx
mov edx, dword [ebp - 0x2ae0]
add edx, dword [ebp - 0x1cc0]
mov dword [ebp - 0x2ae4], edx
mov eax, dword [ebp - 0x2ae4]
mov cl, byte [ebp - 0x1b4]
mov byte [eax], cl
jmp 0x10175123
lea edx, [ebp - 0x1cb0]
mov dword [ebp - 0x2ae8], edx
mov eax, dword [ebp - 0x2ae8]
mov dword [ebp - 0x259c], eax
lea ecx, [ebp - 0x3e80]
mov dword [ebp - 0x2aec], ecx
movzx edx, byte [ebp - 0x23fd]
push edx
mov ecx, dword [ebp - 0x2aec]
call fcn.1008cde0
mov dword [ebp - 4], 0x46
mov eax, dword [ebp - 0x259c]
mov dword [ebp - 0x1cc4], eax
mov ecx, dword [ebp - 0x1cc4]
add ecx, 1
mov dword [ebp - 0x2af0], ecx
mov edx, dword [ebp - 0x1cc4]
mov al, byte [edx]
mov byte [ebp - 0xbdd], al
add dword [ebp - 0x1cc4], 1
cmp byte [ebp - 0xbdd], 0
jne 0x1017520d
mov ecx, dword [ebp - 0x1cc4]
sub ecx, dword [ebp - 0x2af0]
mov dword [ebp - 0x2af4], ecx
mov edx, dword [ebp - 0x2af4]
mov dword [ebp - 0x2af8], edx
mov eax, dword [ebp - 0x2af8]
mov dword [ebp - 0x2afc], eax
mov ecx, dword [ebp - 0x2afc]
push ecx
mov edx, dword [ebp - 0x259c]
push edx
lea ecx, [ebp - 0x3e80]
call fcn.1008ce30
mov dword [ebp - 4], 0x47
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.molly]
mov byte [ebp - 0xbe4], dl
movsx eax, byte [ebp - 0xbe4]
xor eax, 0xffffff98
mov byte [ebp - 0xbe5], al
mov cl, byte [ebp - 0xbe5]
mov byte [ebp - 0x1f88], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.molly]
mov byte [ebp - 0xbec], al
movsx ecx, byte [ebp - 0xbec]
xor ecx, 0xffffff98
mov byte [ebp - 0xbed], cl
mov dl, byte [ebp - 0xbed]
mov byte [ebp - 0x1f87], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.molly]
mov byte [ebp - 0xbf4], cl
movsx edx, byte [ebp - 0xbf4]
xor edx, 0xffffff98
mov byte [ebp - 0xbf5], dl
mov al, byte [ebp - 0xbf5]
mov byte [ebp - 0x1f86], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.molly]
mov byte [ebp - 0xbfc], al
movsx ecx, byte [ebp - 0xbfc]
xor ecx, 0xffffff98
mov byte [ebp - 0xbfd], cl
mov dl, byte [ebp - 0xbfd]
mov byte [ebp - 0x1f85], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.molly]
mov byte [ebp - 0xc04], cl
movsx edx, byte [ebp - 0xc04]
xor edx, 0xffffff98
mov byte [ebp - 0xc05], dl
mov al, byte [ebp - 0xc05]
mov byte [ebp - 0x1f84], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.molly]
mov byte [ebp - 0xc0c], al
movsx ecx, byte [ebp - 0xc0c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc0d], cl
mov dl, byte [ebp - 0xc0d]
mov byte [ebp - 0x1f83], dl
mov dword [ebp - 0x1cc8], 0
jmp 0x101753af
mov eax, dword [ebp - 0x1cc8]
add eax, 1
mov dword [ebp - 0x1cc8], eax
cmp dword [ebp - 0x1cc8], 6
jae 0x10175431
lea ecx, [ebp - 0x1f88]
mov dword [ebp - 0x2b00], ecx
mov edx, dword [ebp - 0x2b00]
add edx, dword [ebp - 0x1cc8]
mov dword [ebp - 0x2b04], edx
mov eax, dword [ebp - 0x2b04]
mov cl, byte [eax]
mov byte [ebp - 0xc14], cl
mov dl, byte [ebp - 0x23fe]
mov byte [ebp - 0x1b5], dl
movsx eax, byte [ebp - 0xc14]
xor eax, 0xffffff98
mov byte [ebp - 0x1b5], al
lea ecx, [ebp - 0x1f88]
mov dword [ebp - 0x2b08], ecx
mov edx, dword [ebp - 0x2b08]
add edx, dword [ebp - 0x1cc8]
mov dword [ebp - 0x2b0c], edx
mov eax, dword [ebp - 0x2b0c]
mov cl, byte [ebp - 0x1b5]
mov byte [eax], cl
jmp 0x101753a0
lea edx, [ebp - 0x1f88]
mov dword [ebp - 0x2b10], edx
mov eax, dword [ebp - 0x2b10]
mov dword [ebp - 0x25a0], eax
lea ecx, [ebp - 0x3e68]
mov dword [ebp - 0x2b14], ecx
movzx edx, byte [ebp - 0x23ff]
push edx
mov ecx, dword [ebp - 0x2b14]
call fcn.1008cde0
mov byte [ebp - 4], 0x48
mov eax, dword [ebp - 0x25a0]
mov dword [ebp - 0x1ccc], eax
mov ecx, dword [ebp - 0x1ccc]
add ecx, 1
mov dword [ebp - 0x2b18], ecx
mov edx, dword [ebp - 0x1ccc]
mov al, byte [edx]
mov byte [ebp - 0xc15], al
add dword [ebp - 0x1ccc], 1
cmp byte [ebp - 0xc15], 0
jne 0x10175487
mov ecx, dword [ebp - 0x1ccc]
sub ecx, dword [ebp - 0x2b18]
mov dword [ebp - 0x2b1c], ecx
mov edx, dword [ebp - 0x2b1c]
mov dword [ebp - 0x2b20], edx
mov eax, dword [ebp - 0x2b20]
mov dword [ebp - 0x2b24], eax
mov ecx, dword [ebp - 0x2b24]
push ecx
mov edx, dword [ebp - 0x25a0]
push edx
lea ecx, [ebp - 0x3e68]
call fcn.1008ce30
mov dword [ebp - 4], 0x49
lea eax, [ebp - 0x3e80]
mov dword [ebp - 0x3658], eax
lea ecx, [ebp - 0x3e50]
mov dword [ebp - 0x3654], ecx
mov edx, dword [ebp - 0x3658]
mov eax, dword [ebp - 0x3654]
mov dword [ebp - 0x3660], edx
mov dword [ebp - 0x365c], eax
mov ecx, dword [ebp - 0x2b28]
push ecx
mov edx, dword [ebp - 0x365c]
push edx
mov eax, dword [ebp - 0x3660]
push eax
lea ecx, [ebp - 0x38c4]
call fcn.10260fe0
mov byte [ebp - 4], 0x4a
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0xc1c], al
movsx ecx, byte [ebp - 0xc1c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc1d], cl
mov dl, byte [ebp - 0xc1d]
mov byte [ebp - 0x2120], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0xc24], cl
movsx edx, byte [ebp - 0xc24]
xor edx, 0xffffff98
mov byte [ebp - 0xc25], dl
mov al, byte [ebp - 0xc25]
mov byte [ebp - 0x211f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0xc2c], dl
movsx eax, byte [ebp - 0xc2c]
xor eax, 0xffffff98
mov byte [ebp - 0xc2d], al
mov cl, byte [ebp - 0xc2d]
mov byte [ebp - 0x211e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0xc34], cl
movsx edx, byte [ebp - 0xc34]
xor edx, 0xffffff98
mov byte [ebp - 0xc35], dl
mov al, byte [ebp - 0xc35]
mov byte [ebp - 0x211d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0xc3c], dl
movsx eax, byte [ebp - 0xc3c]
xor eax, 0xffffff98
mov byte [ebp - 0xc3d], al
mov cl, byte [ebp - 0xc3d]
mov byte [ebp - 0x211c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0xc44], cl
movsx edx, byte [ebp - 0xc44]
xor edx, 0xffffff98
mov byte [ebp - 0xc45], dl
mov al, byte [ebp - 0xc45]
mov byte [ebp - 0x211b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0xc4c], al
movsx ecx, byte [ebp - 0xc4c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc4d], cl
mov dl, byte [ebp - 0xc4d]
mov byte [ebp - 0x211a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0xc54], dl
movsx eax, byte [ebp - 0xc54]
xor eax, 0xffffff98
mov byte [ebp - 0xc55], al
mov cl, byte [ebp - 0xc55]
mov byte [ebp - 0x2119], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0xc5c], al
movsx ecx, byte [ebp - 0xc5c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc5d], cl
mov dl, byte [ebp - 0xc5d]
mov byte [ebp - 0x2118], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0xc64], dl
movsx eax, byte [ebp - 0xc64]
xor eax, 0xffffff98
mov byte [ebp - 0xc65], al
mov cl, byte [ebp - 0xc65]
mov byte [ebp - 0x2117], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0xc6c], cl
movsx edx, byte [ebp - 0xc6c]
xor edx, 0xffffff98
mov byte [ebp - 0xc6d], dl
mov al, byte [ebp - 0xc6d]
mov byte [ebp - 0x2116], al
mov dword [ebp - 0x1cd0], 0
jmp 0x1017576d
mov ecx, dword [ebp - 0x1cd0]
add ecx, 1
mov dword [ebp - 0x1cd0], ecx
cmp dword [ebp - 0x1cd0], 0xb
jae 0x101757ef
lea edx, [ebp - 0x2120]
mov dword [ebp - 0x2b2c], edx
mov eax, dword [ebp - 0x2b2c]
add eax, dword [ebp - 0x1cd0]
mov dword [ebp - 0x2b30], eax
mov ecx, dword [ebp - 0x2b30]
mov dl, byte [ecx]
mov byte [ebp - 0xc74], dl
mov al, byte [ebp - 0x2400]
mov byte [ebp - 0x1b6], al
movsx ecx, byte [ebp - 0xc74]
xor ecx, 0xffffff98
mov byte [ebp - 0x1b6], cl
lea edx, [ebp - 0x2120]
mov dword [ebp - 0x2b34], edx
mov eax, dword [ebp - 0x2b34]
add eax, dword [ebp - 0x1cd0]
mov dword [ebp - 0x2b38], eax
mov ecx, dword [ebp - 0x2b38]
mov dl, byte [ebp - 0x1b6]
mov byte [ecx], dl
jmp 0x1017575e
lea eax, [ebp - 0x2120]
mov dword [ebp - 0x2b3c], eax
mov ecx, dword [ebp - 0x2b3c]
mov dword [ebp - 0x25a4], ecx
lea edx, [ebp - 0x3bf4]
mov dword [ebp - 0x2b40], edx
movzx eax, byte [ebp - 0x2401]
push eax
mov ecx, dword [ebp - 0x2b40]
call fcn.1008cde0
mov byte [ebp - 4], 0x4b
mov ecx, dword [ebp - 0x25a4]
mov dword [ebp - 0x1cd4], ecx
mov edx, dword [ebp - 0x1cd4]
add edx, 1
mov dword [ebp - 0x2b44], edx
mov eax, dword [ebp - 0x1cd4]
mov cl, byte [eax]
mov byte [ebp - 0xc75], cl
add dword [ebp - 0x1cd4], 1
cmp byte [ebp - 0xc75], 0
jne 0x10175845
mov edx, dword [ebp - 0x1cd4]
sub edx, dword [ebp - 0x2b44]
mov dword [ebp - 0x2b48], edx
mov eax, dword [ebp - 0x2b48]
mov dword [ebp - 0x2b4c], eax
mov ecx, dword [ebp - 0x2b4c]
mov dword [ebp - 0x2b50], ecx
mov edx, dword [ebp - 0x2b50]
push edx
mov eax, dword [ebp - 0x25a4]
push eax
lea ecx, [ebp - 0x3bf4]
call fcn.1008ce30
mov byte [ebp - 4], 0x4c
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xc7c], al
movsx ecx, byte [ebp - 0xc7c]
xor ecx, 0xffffff98
mov byte [ebp - 0xc7d], cl
mov dl, byte [ebp - 0xc7d]
mov byte [ebp - 0x22cc], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0xc84], cl
movsx edx, byte [ebp - 0xc84]
xor edx, 0xffffff98
mov byte [ebp - 0xc85], dl
mov al, byte [ebp - 0xc85]
mov byte [ebp - 0x22cb], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xc8c], dl
movsx eax, byte [ebp - 0xc8c]
xor eax, 0xffffff98
mov byte [ebp - 0xc8d], al
mov cl, byte [ebp - 0xc8d]
mov byte [ebp - 0x22ca], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0xc94], cl
movsx edx, byte [ebp - 0xc94]
xor edx, 0xffffff98
mov byte [ebp - 0xc95], dl
mov al, byte [ebp - 0xc95]
mov byte [ebp - 0x22c9], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xc9c], dl
movsx eax, byte [ebp - 0xc9c]
xor eax, 0xffffff98
mov byte [ebp - 0xc9d], al
mov cl, byte [ebp - 0xc9d]
mov byte [ebp - 0x22c8], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0xca4], cl
movsx edx, byte [ebp - 0xca4]
xor edx, 0xffffff98
mov byte [ebp - 0xca5], dl
mov al, byte [ebp - 0xca5]
mov byte [ebp - 0x22c7], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xcac], al
movsx ecx, byte [ebp - 0xcac]
xor ecx, 0xffffff98
mov byte [ebp - 0xcad], cl
mov dl, byte [ebp - 0xcad]
mov byte [ebp - 0x22c6], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xcb4], dl
movsx eax, byte [ebp - 0xcb4]
xor eax, 0xffffff98
mov byte [ebp - 0xcb5], al
mov cl, byte [ebp - 0xcb5]
mov byte [ebp - 0x22c5], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xcbc], al
movsx ecx, byte [ebp - 0xcbc]
xor ecx, 0xffffff98
mov byte [ebp - 0xcbd], cl
mov dl, byte [ebp - 0xcbd]
mov byte [ebp - 0x22c4], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xcc4], dl
movsx eax, byte [ebp - 0xcc4]
xor eax, 0xffffff98
mov byte [ebp - 0xcc5], al
mov cl, byte [ebp - 0xcc5]
mov byte [ebp - 0x22c3], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0xccc], cl
movsx edx, byte [ebp - 0xccc]
xor edx, 0xffffff98
mov byte [ebp - 0xccd], dl
mov al, byte [ebp - 0xccd]
mov byte [ebp - 0x22c2], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xcd4], al
movsx ecx, byte [ebp - 0xcd4]
xor ecx, 0xffffff98
mov byte [ebp - 0xcd5], cl
mov dl, byte [ebp - 0xcd5]
mov byte [ebp - 0x22c1], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xcdc], dl
movsx eax, byte [ebp - 0xcdc]
xor eax, 0xffffff98
mov byte [ebp - 0xcdd], al
mov cl, byte [ebp - 0xcdd]
mov byte [ebp - 0x22c0], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0xce4], cl
movsx edx, byte [ebp - 0xce4]
xor edx, 0xffffff98
mov byte [ebp - 0xce5], dl
mov al, byte [ebp - 0xce5]
mov byte [ebp - 0x22bf], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xcec], al
movsx ecx, byte [ebp - 0xcec]
xor ecx, 0xffffff98
mov byte [ebp - 0xced], cl
mov dl, byte [ebp - 0xced]
mov byte [ebp - 0x22be], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0xcf4], dl
movsx eax, byte [ebp - 0xcf4]
xor eax, 0xffffff98
mov byte [ebp - 0xcf5], al
mov cl, byte [ebp - 0xcf5]
mov byte [ebp - 0x22bd], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0xcfc], al
movsx ecx, byte [ebp - 0xcfc]
xor ecx, 0xffffff98
mov byte [ebp - 0xcfd], cl
mov dl, byte [ebp - 0xcfd]
mov byte [ebp - 0x22bc], dl
mov dword [ebp - 0x1cd8], 0
jmp 0x10175bf4
mov eax, dword [ebp - 0x1cd8]
add eax, 1
mov dword [ebp - 0x1cd8], eax
cmp dword [ebp - 0x1cd8], 0x11
jae 0x10175c76
lea ecx, [ebp - 0x22cc]
mov dword [ebp - 0x2b54], ecx
mov edx, dword [ebp - 0x2b54]
add edx, dword [ebp - 0x1cd8]
mov dword [ebp - 0x2b58], edx
mov eax, dword [ebp - 0x2b58]
mov cl, byte [eax]
mov byte [ebp - 0xd04], cl
mov dl, byte [ebp - 0x2402]
mov byte [ebp - 0x1b7], dl
movsx eax, byte [ebp - 0xd04]
xor eax, 0xffffff98
mov byte [ebp - 0x1b7], al
lea ecx, [ebp - 0x22cc]
mov dword [ebp - 0x2b5c], ecx
mov edx, dword [ebp - 0x2b5c]
add edx, dword [ebp - 0x1cd8]
mov dword [ebp - 0x2b60], edx
mov eax, dword [ebp - 0x2b60]
mov cl, byte [ebp - 0x1b7]
mov byte [eax], cl
jmp 0x10175be5
lea edx, [ebp - 0x22cc]
mov dword [ebp - 0x2b64], edx
mov eax, dword [ebp - 0x2b64]
mov dword [ebp - 0x25a8], eax
lea ecx, [ebp - 0x3bdc]
mov dword [ebp - 0x2b68], ecx
movzx edx, byte [ebp - 0x2403]
push edx
mov ecx, dword [ebp - 0x2b68]
call fcn.1008cde0
mov byte [ebp - 4], 0x4d
mov eax, dword [ebp - 0x25a8]
mov dword [ebp - 0x1cdc], eax
mov ecx, dword [ebp - 0x1cdc]
add ecx, 1
mov dword [ebp - 0x2b6c], ecx
mov edx, dword [ebp - 0x1cdc]
mov al, byte [edx]
mov byte [ebp - 0xd05], al
add dword [ebp - 0x1cdc], 1
cmp byte [ebp - 0xd05], 0
jne 0x10175ccc
mov ecx, dword [ebp - 0x1cdc]
sub ecx, dword [ebp - 0x2b6c]
mov dword [ebp - 0x2b70], ecx
mov edx, dword [ebp - 0x2b70]
mov dword [ebp - 0x2b74], edx
mov eax, dword [ebp - 0x2b74]
mov dword [ebp - 0x2b78], eax
mov ecx, dword [ebp - 0x2b78]
push ecx
mov edx, dword [ebp - 0x25a8]
push edx
lea ecx, [ebp - 0x3bdc]
call fcn.1008ce30
mov byte [ebp - 4], 0x4e
lea eax, [ebp - 0x38b8]
mov dword [ebp - 0x2418], eax
mov ecx, dword [ebp - 0x2418]
mov dword [ebp - 0x2b7c], ecx
mov ecx, dword [ebp - 0x2b7c]
call fcn.1008da90
mov edx, dword [ebp - 0x2418]
mov dword [ebp - 0x3838], edx
mov eax, dword [ebp - 0x2418]
mov dword [ebp - 0x383c], eax
mov byte [ebp - 4], 0x4f
lea ecx, [ebp - 0x3bf4]
push ecx
mov ecx, dword [ebp - 0x144]
add ecx, 0x38
call fcn.100ad110
mov edx, dword [ebp - 0x144]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x144]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10175db2
lea edx, [ebp - 0x3bdc]
push edx
mov ecx, dword [ebp - 0x144]
add ecx, 0x70
call fcn.100ad110
mov eax, dword [ebp - 0x144]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10175dcc
mov dword [ebp - 0x25ac], 0xf
jmp 0x10175dd6
mov dword [ebp - 0x25ac], 0
mov edx, dword [ebp - 0x144]
mov eax, dword [ebp - 0x25ac]
mov dword [edx + 0xa4], eax
mov ecx, dword [ebp - 0x144]
mov edx, dword [ecx + 0xa4]
add edx, 0x14
mov dword [ebp - 0x25b0], edx
mov eax, dword [ebp - 0x144]
mov ecx, dword [ebp - 0x25b0]
mov dword [eax + 0x10], ecx
mov edx, dword [ebp - 0x144]
mov eax, dword [ebp - 0x25b0]
mov dword [edx + 0x14], eax
lea ecx, [ebp - 0x38c4]
mov dword [ebp - 0x25b4], ecx
mov edx, dword [ebp - 0x25b4]
mov eax, dword [edx]
mov dword [ebp - 0x21a4], eax
mov ecx, dword [ebp - 0x25b4]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x2b80], edx
jmp 0x10175e55
mov ecx, dword [ebp - 0x21a4]
cmp ecx, dword [ebp - 0x2b80]
je 0x10175e94
mov edx, dword [ebp - 0x21a4]
mov dword [ebp - 0x2b84], edx
mov eax, dword [ebp - 0x144]
add eax, 0x88
mov dword [ebp - 0x2b88], eax
mov ecx, dword [ebp - 0x2b84]
push ecx
mov ecx, dword [ebp - 0x2b88]
call fcn.100fca00
jmp 0x10175e46
lea edx, [ebp - 0x38b8]
mov dword [ebp - 0x25b8], edx
mov eax, dword [ebp - 0x25b8]
mov ecx, dword [eax]
mov dword [ebp - 0x21a8], ecx
mov edx, dword [ebp - 0x25b8]
mov eax, dword [edx + 4]
mov dword [ebp - 0x2b8c], eax
jmp 0x10175ece