Function at 0x1014e820
Capabilities:
Authenticate hmac
Parse pe header

Disassembly:
push ebx
mov ebx, esp
sub esp, 8
and esp, 0xfffffff8
add esp, 4
push ebp
mov ebp, dword [ebx + 4]
mov dword [esp + 4], ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x1029af92
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x3ea0
call fcn.10294b80
mov eax, dword [0x102b2040]
xor eax, ebp
mov dword [ebp - 0x14], eax
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov dword [ebp - 0xc0], ecx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.visuals]
mov byte [ebp - 0x1c60], dl
movsx eax, byte [ebp - 0x1c60]
xor eax, 0x34
mov byte [ebp - 0x1c61], al
mov cl, byte [ebp - 0x1c61]
mov byte [ebp - 0x2048], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1c68], al
movsx ecx, byte [ebp - 0x1c68]
xor ecx, 0x34
mov byte [ebp - 0x1c69], cl
mov dl, byte [ebp - 0x1c69]
mov byte [ebp - 0x2047], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1c70], cl
movsx edx, byte [ebp - 0x1c70]
xor edx, 0x34
mov byte [ebp - 0x1c71], dl
mov al, byte [ebp - 0x1c71]
mov byte [ebp - 0x2046], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1c78], al
movsx ecx, byte [ebp - 0x1c78]
xor ecx, 0x34
mov byte [ebp - 0x1c79], cl
mov dl, byte [ebp - 0x1c79]
mov byte [ebp - 0x2045], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1c80], cl
movsx edx, byte [ebp - 0x1c80]
xor edx, 0x34
mov byte [ebp - 0x1c81], dl
mov al, byte [ebp - 0x1c81]
mov byte [ebp - 0x2044], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.visuals]
mov byte [ebp - 0x1c88], al
movsx ecx, byte [ebp - 0x1c88]
xor ecx, 0x34
mov byte [ebp - 0x1c89], cl
mov dl, byte [ebp - 0x1c89]
mov byte [ebp - 0x2043], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.visuals]
mov byte [ebp - 0x1c90], dl
movsx eax, byte [ebp - 0x1c90]
xor eax, 0x34
mov byte [ebp - 0x1c91], al
mov cl, byte [ebp - 0x1c91]
mov byte [ebp - 0x2042], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.visuals]
mov byte [ebp - 0x1c98], cl
movsx edx, byte [ebp - 0x1c98]
xor edx, 0x34
mov byte [ebp - 0x1cb1], dl
mov al, byte [ebp - 0x1cb1]
mov byte [ebp - 0x2041], al
lea ecx, [ebp - 0x2048]
mov dword [ebp - 0x3238], ecx
mov edx, dword [ebp - 0x3238]
mov dword [ebp - 0x2430], edx
mov dword [ebp - 0x1e18], 0
jmp 0x1014ea1b
mov eax, dword [ebp - 0x1e18]
add eax, 1
mov dword [ebp - 0x1e18], eax
cmp dword [ebp - 0x1e18], 8
jae 0x1014ea9d
mov ecx, dword [ebp - 0x2430]
mov dword [ebp - 0x323c], ecx
mov edx, dword [ebp - 0x323c]
add edx, dword [ebp - 0x1e18]
mov dword [ebp - 0x3240], edx
mov eax, dword [ebp - 0x3240]
mov cl, byte [eax]
mov byte [ebp - 0x1cb8], cl
movsx edx, byte [ebp - 0x1cb8]
xor edx, 0x34
mov byte [ebp - 0x1cb9], dl
mov al, byte [ebp - 0x1cb9]
mov byte [ebp - 0x1cba], al
mov ecx, dword [ebp - 0x2430]
mov dword [ebp - 0x3244], ecx
mov edx, dword [ebp - 0x3244]
add edx, dword [ebp - 0x1e18]
mov dword [ebp - 0x3248], edx
mov eax, dword [ebp - 0x3248]
mov cl, byte [ebp - 0x1cba]
mov byte [eax], cl
jmp 0x1014ea0c
mov edx, dword [ebp - 0x2430]
mov dword [ebp - 0x324c], edx
mov eax, dword [ebp - 0x324c]
mov dword [ebp - 0x3250], eax
mov ecx, dword [ebp - 0x3250]
mov dword [ebp - 0x3254], ecx
mov edx, dword [ebp - 0x3254]
push edx
lea ecx, [ebp - 0x34e8]
call fcn.1007b880
mov dword [ebp - 4], 0
lea eax, [ebp - 0x34e8]
push eax
mov ecx, dword [ebp - 0xc0]
call fcn.1008d0b0
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x34e8]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x30
mov dword [ebp - 0x1e24], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.items]
mov byte [ebp - 0x1cc0], cl
movsx edx, byte [ebp - 0x1cc0]
xor edx, 0x34
mov byte [ebp - 0x1cc1], dl
mov al, byte [ebp - 0x1cc1]
mov byte [ebp - 0x1ff8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x1cc8], dl
movsx eax, byte [ebp - 0x1cc8]
xor eax, 0x34
mov byte [ebp - 0x1cc9], al
mov cl, byte [ebp - 0x1cc9]
mov byte [ebp - 0x1ff7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.items]
mov byte [ebp - 0x1cd0], al
movsx ecx, byte [ebp - 0x1cd0]
xor ecx, 0x34
mov byte [ebp - 0x1cd1], cl
mov dl, byte [ebp - 0x1cd1]
mov byte [ebp - 0x1ff6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x1cd8], dl
movsx eax, byte [ebp - 0x1cd8]
xor eax, 0x34
mov byte [ebp - 0x1cd9], al
mov cl, byte [ebp - 0x1cd9]
mov byte [ebp - 0x1ff5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.items]
mov byte [ebp - 0x1ce0], al
movsx ecx, byte [ebp - 0x1ce0]
xor ecx, 0x34
mov byte [ebp - 0x1ce1], cl
mov dl, byte [ebp - 0x1ce1]
mov byte [ebp - 0x1ff4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.items]
mov byte [ebp - 0x1ce8], dl
movsx eax, byte [ebp - 0x1ce8]
xor eax, 0x34
mov byte [ebp - 0x1ce9], al
mov cl, byte [ebp - 0x1ce9]
mov byte [ebp - 0x1ff3], cl
lea edx, [ebp - 0x1ff8]
mov dword [ebp - 0x3258], edx
mov eax, dword [ebp - 0x3258]
mov dword [ebp - 0x2424], eax
mov dword [ebp - 0x1e1c], 0
jmp 0x1014ec61
mov ecx, dword [ebp - 0x1e1c]
add ecx, 1
mov dword [ebp - 0x1e1c], ecx
cmp dword [ebp - 0x1e1c], 6
jae 0x1014ece3
mov edx, dword [ebp - 0x2424]
mov dword [ebp - 0x325c], edx
mov eax, dword [ebp - 0x325c]
add eax, dword [ebp - 0x1e1c]
mov dword [ebp - 0x3260], eax
mov ecx, dword [ebp - 0x3260]
mov dl, byte [ecx]
mov byte [ebp - 0x1cf0], dl
movsx eax, byte [ebp - 0x1cf0]
xor eax, 0x34
mov byte [ebp - 0x1cf1], al
mov cl, byte [ebp - 0x1cf1]
mov byte [ebp - 0x1cf2], cl
mov edx, dword [ebp - 0x2424]
mov dword [ebp - 0x3264], edx
mov eax, dword [ebp - 0x3264]
add eax, dword [ebp - 0x1e1c]
mov dword [ebp - 0x3268], eax
mov ecx, dword [ebp - 0x3268]
mov dl, byte [ebp - 0x1cf2]
mov byte [ecx], dl
jmp 0x1014ec52
mov eax, dword [ebp - 0x2424]
mov dword [ebp - 0x326c], eax
mov ecx, dword [ebp - 0x326c]
mov dword [ebp - 0x3270], ecx
mov edx, dword [ebp - 0x3270]
mov dword [ebp - 0x3274], edx
mov eax, dword [ebp - 0x3274]
push eax
lea ecx, [ebp - 0x3518]
call fcn.1007b880
mov dword [ebp - 4], 1
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x1cf8], al
movsx ecx, byte [ebp - 0x1cf8]
xor ecx, 0x34
mov byte [ebp - 0x1cf9], cl
mov dl, byte [ebp - 0x1cf9]
mov byte [ebp - 0x21a0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x1d00], cl
movsx edx, byte [ebp - 0x1d00]
xor edx, 0x34
mov byte [ebp - 0x1d01], dl
mov al, byte [ebp - 0x1d01]
mov byte [ebp - 0x219f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d08], dl
movsx eax, byte [ebp - 0x1d08]
xor eax, 0x34
mov byte [ebp - 0x1d09], al
mov cl, byte [ebp - 0x1d09]
mov byte [ebp - 0x219e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x1d10], cl
movsx edx, byte [ebp - 0x1d10]
xor edx, 0x34
mov byte [ebp - 0x1d11], dl
mov al, byte [ebp - 0x1d11]
mov byte [ebp - 0x219d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d18], dl
movsx eax, byte [ebp - 0x1d18]
xor eax, 0x34
mov byte [ebp - 0x1d19], al
mov cl, byte [ebp - 0x1d19]
mov byte [ebp - 0x219c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x1d20], cl
movsx edx, byte [ebp - 0x1d20]
xor edx, 0x34
mov byte [ebp - 0x1d21], dl
mov al, byte [ebp - 0x1d21]
mov byte [ebp - 0x219b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x1d28], al
movsx ecx, byte [ebp - 0x1d28]
xor ecx, 0x34
mov byte [ebp - 0x1d29], cl
mov dl, byte [ebp - 0x1d29]
mov byte [ebp - 0x219a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d30], dl
movsx eax, byte [ebp - 0x1d30]
xor eax, 0x34
mov byte [ebp - 0x1d31], al
mov cl, byte [ebp - 0x1d31]
mov byte [ebp - 0x2199], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x1d38], al
movsx ecx, byte [ebp - 0x1d38]
xor ecx, 0x34
mov byte [ebp - 0x1d39], cl
mov dl, byte [ebp - 0x1d39]
mov byte [ebp - 0x2198], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d40], dl
movsx eax, byte [ebp - 0x1d40]
xor eax, 0x34
mov byte [ebp - 0x1d41], al
mov cl, byte [ebp - 0x1d41]
mov byte [ebp - 0x2197], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x1d48], cl
movsx edx, byte [ebp - 0x1d48]
xor edx, 0x34
mov byte [ebp - 0x1d49], dl
mov al, byte [ebp - 0x1d49]
mov byte [ebp - 0x2196], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x1d50], al
movsx ecx, byte [ebp - 0x1d50]
xor ecx, 0x34
mov byte [ebp - 0x1d51], cl
mov dl, byte [ebp - 0x1d51]
mov byte [ebp - 0x2195], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d58], dl
movsx eax, byte [ebp - 0x1d58]
xor eax, 0x34
mov byte [ebp - 0x1d59], al
mov cl, byte [ebp - 0x1d59]
mov byte [ebp - 0x2194], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.dropped_weapons]
mov byte [ebp - 0x1d60], cl
movsx edx, byte [ebp - 0x1d60]
xor edx, 0x34
mov byte [ebp - 0x1d61], dl
mov al, byte [ebp - 0x1d61]
mov byte [ebp - 0x2193], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.dropped_weapons]
mov byte [ebp - 0x1d68], al
movsx ecx, byte [ebp - 0x1d68]
xor ecx, 0x34
mov byte [ebp - 0x1d69], cl
mov dl, byte [ebp - 0x1d69]
mov byte [ebp - 0x2192], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.dropped_weapons]
mov byte [ebp - 0x1d70], dl
movsx eax, byte [ebp - 0x1d70]
xor eax, 0x34
mov byte [ebp - 0x1d71], al
mov cl, byte [ebp - 0x1d71]
mov byte [ebp - 0x2191], cl
lea edx, [ebp - 0x21a0]
mov dword [ebp - 0x3278], edx
mov eax, dword [ebp - 0x3278]
mov dword [ebp - 0x2554], eax
mov dword [ebp - 0x1e20], 0
jmp 0x1014f052
mov ecx, dword [ebp - 0x1e20]
add ecx, 1
mov dword [ebp - 0x1e20], ecx
cmp dword [ebp - 0x1e20], 0x10
jae 0x1014f0d4
mov edx, dword [ebp - 0x2554]
mov dword [ebp - 0x327c], edx
mov eax, dword [ebp - 0x327c]
add eax, dword [ebp - 0x1e20]
mov dword [ebp - 0x3280], eax
mov ecx, dword [ebp - 0x3280]
mov dl, byte [ecx]
mov byte [ebp - 0x1d78], dl
movsx eax, byte [ebp - 0x1d78]
xor eax, 0x34
mov byte [ebp - 0x1d79], al
mov cl, byte [ebp - 0x1d79]
mov byte [ebp - 0x1d7a], cl
mov edx, dword [ebp - 0x2554]
mov dword [ebp - 0x32b4], edx
mov eax, dword [ebp - 0x32b4]
add eax, dword [ebp - 0x1e20]
mov dword [ebp - 0x32b8], eax
mov ecx, dword [ebp - 0x32b8]
mov dl, byte [ebp - 0x1d7a]
mov byte [ecx], dl
jmp 0x1014f043
mov eax, dword [ebp - 0x2554]
mov dword [ebp - 0x32bc], eax
mov ecx, dword [ebp - 0x32bc]
mov dword [ebp - 0x32c0], ecx
mov edx, dword [ebp - 0x32c0]
mov dword [ebp - 0x32c4], edx
mov eax, dword [ebp - 0x32c4]
push eax
lea ecx, [ebp - 0x3500]
call fcn.1007b880
mov byte [ebp - 4], 2
lea ecx, [ebp - 0x3518]
push ecx
mov ecx, dword [ebp - 0x1e24]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x1e24]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1e24]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1014f151
lea edx, [ebp - 0x3500]
push edx
mov ecx, dword [ebp - 0x1e24]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x1e24]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 1
lea ecx, [ebp - 0x3500]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3518]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x30
mov dword [ebp - 0x54], ecx
mov edx, dword [ebp - 0x54]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x54]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x54]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x54]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x54]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x32c8], ecx
lea edx, [ebp - 0x54]
push edx
mov ecx, dword [ebp - 0x32c8]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0xb8
mov dword [ebp - 0x1e30], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.ammo]
mov byte [ebp - 0x1d80], al
movsx ecx, byte [ebp - 0x1d80]
xor ecx, 0x34
mov byte [ebp - 0x1d81], cl
mov dl, byte [ebp - 0x1d81]
mov byte [ebp - 0x1fd8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x1d88], cl
movsx edx, byte [ebp - 0x1d88]
xor edx, 0x34
mov byte [ebp - 0x1d89], dl
mov al, byte [ebp - 0x1d89]
mov byte [ebp - 0x1fd7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.ammo]
mov byte [ebp - 0x1d90], dl
movsx eax, byte [ebp - 0x1d90]
xor eax, 0x34
mov byte [ebp - 0x1d91], al
mov cl, byte [ebp - 0x1d91]
mov byte [ebp - 0x1fd6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.ammo]
mov byte [ebp - 0x1d98], cl
movsx edx, byte [ebp - 0x1d98]
xor edx, 0x34
mov byte [ebp - 0x1d99], dl
mov al, byte [ebp - 0x1d99]
mov byte [ebp - 0x1fd5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.ammo]
mov byte [ebp - 0x1da0], dl
movsx eax, byte [ebp - 0x1da0]
xor eax, 0x34
mov byte [ebp - 0x1da1], al
mov cl, byte [ebp - 0x1da1]
mov byte [ebp - 0x1fd4], cl
lea edx, [ebp - 0x1fd8]
mov dword [ebp - 0x32cc], edx
mov eax, dword [ebp - 0x32cc]
mov dword [ebp - 0x2550], eax
mov dword [ebp - 0x1e28], 0
jmp 0x1014f312
mov ecx, dword [ebp - 0x1e28]
add ecx, 1
mov dword [ebp - 0x1e28], ecx
cmp dword [ebp - 0x1e28], 5
jae 0x1014f394
mov edx, dword [ebp - 0x2550]
mov dword [ebp - 0x32d0], edx
mov eax, dword [ebp - 0x32d0]
add eax, dword [ebp - 0x1e28]
mov dword [ebp - 0x32d4], eax
mov ecx, dword [ebp - 0x32d4]
mov dl, byte [ecx]
mov byte [ebp - 0x1da8], dl
movsx eax, byte [ebp - 0x1da8]
xor eax, 0x34
mov byte [ebp - 0x1da9], al
mov cl, byte [ebp - 0x1da9]
mov byte [ebp - 0x1daa], cl
mov edx, dword [ebp - 0x2550]
mov dword [ebp - 0x32d8], edx
mov eax, dword [ebp - 0x32d8]
add eax, dword [ebp - 0x1e28]
mov dword [ebp - 0x32dc], eax
mov ecx, dword [ebp - 0x32dc]
mov dl, byte [ebp - 0x1daa]
mov byte [ecx], dl
jmp 0x1014f303
mov eax, dword [ebp - 0x2550]
mov dword [ebp - 0x32e0], eax
mov ecx, dword [ebp - 0x32e0]
mov dword [ebp - 0x32e4], ecx
mov edx, dword [ebp - 0x32e4]
mov dword [ebp - 0x32e8], edx
mov eax, dword [ebp - 0x32e8]
push eax
lea ecx, [ebp - 0x3548]
call fcn.1007b880
mov dword [ebp - 4], 3
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x1db0], al
movsx ecx, byte [ebp - 0x1db0]
xor ecx, 0x34
mov byte [ebp - 0x2a9], cl
mov dl, byte [ebp - 0x2a9]
mov byte [ebp - 0x228c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x2b0], cl
movsx edx, byte [ebp - 0x2b0]
xor edx, 0x34
mov byte [ebp - 0x2b1], dl
mov al, byte [ebp - 0x2b1]
mov byte [ebp - 0x228b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2b8], dl
movsx eax, byte [ebp - 0x2b8]
xor eax, 0x34
mov byte [ebp - 0x2b9], al
mov cl, byte [ebp - 0x2b9]
mov byte [ebp - 0x228a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x2c0], cl
movsx edx, byte [ebp - 0x2c0]
xor edx, 0x34
mov byte [ebp - 0x2c1], dl
mov al, byte [ebp - 0x2c1]
mov byte [ebp - 0x2289], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2c8], dl
movsx eax, byte [ebp - 0x2c8]
xor eax, 0x34
mov byte [ebp - 0x2c9], al
mov cl, byte [ebp - 0x2c9]
mov byte [ebp - 0x2288], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x2d0], cl
movsx edx, byte [ebp - 0x2d0]
xor edx, 0x34
mov byte [ebp - 0x2d1], dl
mov al, byte [ebp - 0x2d1]
mov byte [ebp - 0x2287], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2d8], al
movsx ecx, byte [ebp - 0x2d8]
xor ecx, 0x34
mov byte [ebp - 0x2d9], cl
mov dl, byte [ebp - 0x2d9]
mov byte [ebp - 0x2286], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2e0], dl
movsx eax, byte [ebp - 0x2e0]
xor eax, 0x34
mov byte [ebp - 0x2e1], al
mov cl, byte [ebp - 0x2e1]
mov byte [ebp - 0x2285], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2e8], al
movsx ecx, byte [ebp - 0x2e8]
xor ecx, 0x34
mov byte [ebp - 0x2e9], cl
mov dl, byte [ebp - 0x2e9]
mov byte [ebp - 0x2284], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x2f0], dl
movsx eax, byte [ebp - 0x2f0]
xor eax, 0x34
mov byte [ebp - 0x2f1], al
mov cl, byte [ebp - 0x2f1]
mov byte [ebp - 0x2283], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x2f8], cl
movsx edx, byte [ebp - 0x2f8]
xor edx, 0x34
mov byte [ebp - 0x2f9], dl
mov al, byte [ebp - 0x2f9]
mov byte [ebp - 0x2282], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x300], al
movsx ecx, byte [ebp - 0x300]
xor ecx, 0x34
mov byte [ebp - 0x301], cl
mov dl, byte [ebp - 0x301]
mov byte [ebp - 0x2281], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x308], dl
movsx eax, byte [ebp - 0x308]
xor eax, 0x34
mov byte [ebp - 0x309], al
mov cl, byte [ebp - 0x309]
mov byte [ebp - 0x2280], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x310], cl
movsx edx, byte [ebp - 0x310]
xor edx, 0x34
mov byte [ebp - 0x311], dl
mov al, byte [ebp - 0x311]
mov byte [ebp - 0x227f], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x318], al
movsx ecx, byte [ebp - 0x318]
xor ecx, 0x34
mov byte [ebp - 0x319], cl
mov dl, byte [ebp - 0x319]
mov byte [ebp - 0x227e], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x320], dl
movsx eax, byte [ebp - 0x320]
xor eax, 0x34
mov byte [ebp - 0x321], al
mov cl, byte [ebp - 0x321]
mov byte [ebp - 0x227d], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x328], al
movsx ecx, byte [ebp - 0x328]
xor ecx, 0x34
mov byte [ebp - 0x329], cl
mov dl, byte [ebp - 0x329]
mov byte [ebp - 0x227c], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x330], dl
movsx eax, byte [ebp - 0x330]
xor eax, 0x34
mov byte [ebp - 0x331], al
mov cl, byte [ebp - 0x331]
mov byte [ebp - 0x227b], cl
mov edx, 1
imul eax, edx, 0x12
mov cl, byte [eax + str.dropped_weapons_ammo]
mov byte [ebp - 0x338], cl
movsx edx, byte [ebp - 0x338]
xor edx, 0x34
mov byte [ebp - 0x339], dl
mov al, byte [ebp - 0x339]
mov byte [ebp - 0x227a], al
mov ecx, 1
imul edx, ecx, 0x13
mov al, byte [edx + str.dropped_weapons_ammo]
mov byte [ebp - 0x340], al
movsx ecx, byte [ebp - 0x340]
xor ecx, 0x34
mov byte [ebp - 0x341], cl
mov dl, byte [ebp - 0x341]
mov byte [ebp - 0x2279], dl
mov eax, 1
imul ecx, eax, 0x14
mov dl, byte [ecx + str.dropped_weapons_ammo]
mov byte [ebp - 0x348], dl
movsx eax, byte [ebp - 0x348]
xor eax, 0x34
mov byte [ebp - 0x349], al
mov cl, byte [ebp - 0x349]
mov byte [ebp - 0x2278], cl
lea edx, [ebp - 0x228c]
mov dword [ebp - 0x32ec], edx
mov eax, dword [ebp - 0x32ec]
mov dword [ebp - 0x2548], eax
mov dword [ebp - 0x1e2c], 0
jmp 0x1014f7f3
mov ecx, dword [ebp - 0x1e2c]
add ecx, 1
mov dword [ebp - 0x1e2c], ecx
cmp dword [ebp - 0x1e2c], 0x15
jae 0x1014f875
mov edx, dword [ebp - 0x2548]
mov dword [ebp - 0x32f0], edx
mov eax, dword [ebp - 0x32f0]
add eax, dword [ebp - 0x1e2c]
mov dword [ebp - 0x32f4], eax
mov ecx, dword [ebp - 0x32f4]
mov dl, byte [ecx]
mov byte [ebp - 0x350], dl
movsx eax, byte [ebp - 0x350]
xor eax, 0x34
mov byte [ebp - 0x351], al
mov cl, byte [ebp - 0x351]
mov byte [ebp - 0x352], cl
mov edx, dword [ebp - 0x2548]
mov dword [ebp - 0x32f8], edx
mov eax, dword [ebp - 0x32f8]
add eax, dword [ebp - 0x1e2c]
mov dword [ebp - 0x32fc], eax
mov ecx, dword [ebp - 0x32fc]
mov dl, byte [ebp - 0x352]
mov byte [ecx], dl
jmp 0x1014f7e4
mov eax, dword [ebp - 0x2548]
mov dword [ebp - 0x3300], eax
mov ecx, dword [ebp - 0x3300]
mov dword [ebp - 0x3304], ecx
mov edx, dword [ebp - 0x3304]
mov dword [ebp - 0x3308], edx
mov eax, dword [ebp - 0x3308]
push eax
lea ecx, [ebp - 0x3530]
call fcn.1007b880
mov byte [ebp - 4], 4
lea ecx, [ebp - 0x3548]
push ecx
mov ecx, dword [ebp - 0x1e30]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x1e30]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1e30]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x1014f8f2
lea edx, [ebp - 0x3530]
push edx
mov ecx, dword [ebp - 0x1e30]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x1e30]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 3
lea ecx, [ebp - 0x3530]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3548]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0xb8
mov dword [ebp - 0x58], ecx
mov edx, dword [ebp - 0x58]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x58]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x58]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x58]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x58]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x330c], ecx
lea edx, [ebp - 0x58]
push edx
mov ecx, dword [ebp - 0x330c]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x140
mov dword [ebp - 0x1c9c], eax
mov ecx, dword [0x103f856c]
mov dword [ebp - 0x3310], ecx
mov edx, dword [ebp - 0x3310]
mov dword [ebp - 0x3314], edx
mov eax, dword [ebp - 0x3314]
mov dword [ebp - 0x3358], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.item_color]
mov byte [ebp - 0x358], al
movsx ecx, byte [ebp - 0x358]
xor ecx, 0x34
mov byte [ebp - 0x359], cl
mov dl, byte [ebp - 0x359]
mov byte [ebp - 0x208c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0x360], cl
movsx edx, byte [ebp - 0x360]
xor edx, 0x34
mov byte [ebp - 0x361], dl
mov al, byte [ebp - 0x361]
mov byte [ebp - 0x208b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0x368], dl
movsx eax, byte [ebp - 0x368]
xor eax, 0x34
mov byte [ebp - 0x369], al
mov cl, byte [ebp - 0x369]
mov byte [ebp - 0x208a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0x370], cl
movsx edx, byte [ebp - 0x370]
xor edx, 0x34
mov byte [ebp - 0x371], dl
mov al, byte [ebp - 0x371]
mov byte [ebp - 0x2089], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0x378], dl
movsx eax, byte [ebp - 0x378]
xor eax, 0x34
mov byte [ebp - 0x379], al
mov cl, byte [ebp - 0x379]
mov byte [ebp - 0x2088], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0x380], cl
movsx edx, byte [ebp - 0x380]
xor edx, 0x34
mov byte [ebp - 0x381], dl
mov al, byte [ebp - 0x381]
mov byte [ebp - 0x2087], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.item_color]
mov byte [ebp - 0x388], al
movsx ecx, byte [ebp - 0x388]
xor ecx, 0x34
mov byte [ebp - 0x389], cl
mov dl, byte [ebp - 0x389]
mov byte [ebp - 0x2086], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0x390], dl
movsx eax, byte [ebp - 0x390]
xor eax, 0x34
mov byte [ebp - 0x391], al
mov cl, byte [ebp - 0x391]
mov byte [ebp - 0x2085], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.item_color]
mov byte [ebp - 0x398], al
movsx ecx, byte [ebp - 0x398]
xor ecx, 0x34
mov byte [ebp - 0x399], cl
mov dl, byte [ebp - 0x399]
mov byte [ebp - 0x2084], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.item_color]
mov byte [ebp - 0x3a0], dl
movsx eax, byte [ebp - 0x3a0]
xor eax, 0x34
mov byte [ebp - 0x3a1], al
mov cl, byte [ebp - 0x3a1]
mov byte [ebp - 0x2083], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.item_color]
mov byte [ebp - 0x3a8], cl
movsx edx, byte [ebp - 0x3a8]
xor edx, 0x34
mov byte [ebp - 0x3a9], dl
mov al, byte [ebp - 0x3a9]
mov byte [ebp - 0x2082], al
lea ecx, [ebp - 0x208c]
mov dword [ebp - 0x3318], ecx
mov edx, dword [ebp - 0x3318]
mov dword [ebp - 0x2544], edx
mov dword [ebp - 0x1e34], 0
jmp 0x1014fbfa
mov eax, dword [ebp - 0x1e34]
add eax, 1
mov dword [ebp - 0x1e34], eax
cmp dword [ebp - 0x1e34], 0xb
jae 0x1014fc7c
mov ecx, dword [ebp - 0x2544]
mov dword [ebp - 0x331c], ecx
mov edx, dword [ebp - 0x331c]
add edx, dword [ebp - 0x1e34]
mov dword [ebp - 0x3320], edx
mov eax, dword [ebp - 0x3320]
mov cl, byte [eax]
mov byte [ebp - 0x3b0], cl
movsx edx, byte [ebp - 0x3b0]
xor edx, 0x34
mov byte [ebp - 0x3b1], dl
mov al, byte [ebp - 0x3b1]
mov byte [ebp - 0x3b2], al
mov ecx, dword [ebp - 0x2544]
mov dword [ebp - 0x3324], ecx
mov edx, dword [ebp - 0x3324]
add edx, dword [ebp - 0x1e34]
mov dword [ebp - 0x3328], edx
mov eax, dword [ebp - 0x3328]
mov cl, byte [ebp - 0x3b2]
mov byte [eax], cl
jmp 0x1014fbeb
mov edx, dword [ebp - 0x2544]
mov dword [ebp - 0x332c], edx
mov eax, dword [ebp - 0x332c]
mov dword [ebp - 0x3330], eax
mov ecx, dword [ebp - 0x3330]
mov dword [ebp - 0x3334], ecx
mov edx, dword [ebp - 0x3334]
push edx
lea ecx, [ebp - 0x3578]
call fcn.1007b880
mov dword [ebp - 4], 5
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.color]
mov byte [ebp - 0x3b8], dl
movsx eax, byte [ebp - 0x3b8]
xor eax, 0x34
mov byte [ebp - 0x3b9], al
mov cl, byte [ebp - 0x3b9]
mov byte [ebp - 0x2000], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.color]
mov byte [ebp - 0x3c0], al
movsx ecx, byte [ebp - 0x3c0]
xor ecx, 0x34
mov byte [ebp - 0x3c1], cl
mov dl, byte [ebp - 0x3c1]
mov byte [ebp - 0x1fff], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.color]
mov byte [ebp - 0x3c8], cl
movsx edx, byte [ebp - 0x3c8]
xor edx, 0x34
mov byte [ebp - 0x3c9], dl
mov al, byte [ebp - 0x3c9]
mov byte [ebp - 0x1ffe], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.color]
mov byte [ebp - 0x3d0], al
movsx ecx, byte [ebp - 0x3d0]
xor ecx, 0x34
mov byte [ebp - 0x3d1], cl
mov dl, byte [ebp - 0x3d1]
mov byte [ebp - 0x1ffd], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.color]
mov byte [ebp - 0x3d8], cl
movsx edx, byte [ebp - 0x3d8]
xor edx, 0x34
mov byte [ebp - 0x3d9], dl
mov al, byte [ebp - 0x3d9]
mov byte [ebp - 0x1ffc], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.color]
mov byte [ebp - 0x3e0], al
movsx ecx, byte [ebp - 0x3e0]
xor ecx, 0x34
mov byte [ebp - 0x3e1], cl
mov dl, byte [ebp - 0x3e1]
mov byte [ebp - 0x1ffb], dl
lea eax, [ebp - 0x2000]
mov dword [ebp - 0x3338], eax
mov ecx, dword [ebp - 0x3338]
mov dword [ebp - 0x2540], ecx
mov dword [ebp - 0x1e38], 0
jmp 0x1014fe0b
mov edx, dword [ebp - 0x1e38]
add edx, 1
mov dword [ebp - 0x1e38], edx
cmp dword [ebp - 0x1e38], 6
jae 0x1014fe8d
mov eax, dword [ebp - 0x2540]
mov dword [ebp - 0x333c], eax
mov ecx, dword [ebp - 0x333c]
add ecx, dword [ebp - 0x1e38]
mov dword [ebp - 0x3340], ecx
mov edx, dword [ebp - 0x3340]
mov al, byte [edx]
mov byte [ebp - 0x3e8], al
movsx ecx, byte [ebp - 0x3e8]
xor ecx, 0x34
mov byte [ebp - 0x3e9], cl
mov dl, byte [ebp - 0x3e9]
mov byte [ebp - 0x3ea], dl
mov eax, dword [ebp - 0x2540]
mov dword [ebp - 0x3344], eax
mov ecx, dword [ebp - 0x3344]
add ecx, dword [ebp - 0x1e38]
mov dword [ebp - 0x3348], ecx
mov edx, dword [ebp - 0x3348]
mov al, byte [ebp - 0x3ea]
mov byte [edx], al
jmp 0x1014fdfc
mov ecx, dword [ebp - 0x2540]
mov dword [ebp - 0x334c], ecx
mov edx, dword [ebp - 0x334c]
mov dword [ebp - 0x3350], edx
mov eax, dword [ebp - 0x3350]
mov dword [ebp - 0x3354], eax
mov ecx, dword [ebp - 0x3354]
push ecx
lea ecx, [ebp - 0x3560]
call fcn.1007b880
mov byte [ebp - 4], 6
lea edx, [ebp - 0x3560]
push edx
mov ecx, dword [ebp - 0x1c9c]
add ecx, 0x70
call fcn.1008d0b0
lea eax, [ebp - 0x3578]
push eax
mov ecx, dword [ebp - 0x1c9c]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x1c9c]
mov edx, dword [ebp - 0x3358]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1c9c]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1c9c]
cmp dword [ecx + 0x8c], 0
je 0x1014ff3c
mov edx, dword [ebp - 0x1c9c]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1c9c]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 5
lea ecx, [ebp - 0x3560]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3578]
call fcn.1007c260
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x140
mov dword [ebp - 0x5c], eax
mov ecx, dword [ebp - 0x5c]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x5c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x5c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x5c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x5c]
mov ecx, dword [ebp - 0xc0]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0xc0]
add eax, 0x18
mov dword [ebp - 0x335c], eax
lea ecx, [ebp - 0x5c]
push ecx
mov ecx, dword [ebp - 0x335c]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x1d0
mov dword [ebp - 0x1e44], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.proj]
mov byte [ebp - 0x3f0], dl
movsx eax, byte [ebp - 0x3f0]
xor eax, 0x34
mov byte [ebp - 0x3f1], al
mov cl, byte [ebp - 0x3f1]
mov byte [ebp - 0x1fe0], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.proj]
mov byte [ebp - 0x3f8], al
movsx ecx, byte [ebp - 0x3f8]
xor ecx, 0x34
mov byte [ebp - 0x3f9], cl
mov dl, byte [ebp - 0x3f9]
mov byte [ebp - 0x1fdf], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.proj]
mov byte [ebp - 0x400], cl
movsx edx, byte [ebp - 0x400]
xor edx, 0x34
mov byte [ebp - 0x401], dl
mov al, byte [ebp - 0x401]
mov byte [ebp - 0x1fde], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.proj]
mov byte [ebp - 0x408], al
movsx ecx, byte [ebp - 0x408]
xor ecx, 0x34
mov byte [ebp - 0x409], cl
mov dl, byte [ebp - 0x409]
mov byte [ebp - 0x1fdd], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.proj]
mov byte [ebp - 0x410], cl
movsx edx, byte [ebp - 0x410]
xor edx, 0x34
mov byte [ebp - 0x411], dl
mov al, byte [ebp - 0x411]
mov byte [ebp - 0x1fdc], al
lea ecx, [ebp - 0x1fe0]
mov dword [ebp - 0x3360], ecx
mov edx, dword [ebp - 0x3360]
mov dword [ebp - 0x253c], edx
mov dword [ebp - 0x1e3c], 0
jmp 0x101500f6
mov eax, dword [ebp - 0x1e3c]
add eax, 1
mov dword [ebp - 0x1e3c], eax
cmp dword [ebp - 0x1e3c], 5
jae 0x10150178
mov ecx, dword [ebp - 0x253c]
mov dword [ebp - 0x3364], ecx
mov edx, dword [ebp - 0x3364]
add edx, dword [ebp - 0x1e3c]
mov dword [ebp - 0x3368], edx
mov eax, dword [ebp - 0x3368]
mov cl, byte [eax]
mov byte [ebp - 0x418], cl
movsx edx, byte [ebp - 0x418]
xor edx, 0x34
mov byte [ebp - 0x419], dl
mov al, byte [ebp - 0x419]
mov byte [ebp - 0x41a], al
mov ecx, dword [ebp - 0x253c]
mov dword [ebp - 0x336c], ecx
mov edx, dword [ebp - 0x336c]
add edx, dword [ebp - 0x1e3c]
mov dword [ebp - 0x3370], edx
mov eax, dword [ebp - 0x3370]
mov cl, byte [ebp - 0x41a]
mov byte [eax], cl
jmp 0x101500e7
mov edx, dword [ebp - 0x253c]
mov dword [ebp - 0x3374], edx
mov eax, dword [ebp - 0x3374]
mov dword [ebp - 0x3378], eax
mov ecx, dword [ebp - 0x3378]
mov dword [ebp - 0x337c], ecx
mov edx, dword [ebp - 0x337c]
push edx
lea ecx, [ebp - 0x35a8]
call fcn.1007b880
mov dword [ebp - 4], 7
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0x420], dl
movsx eax, byte [ebp - 0x420]
xor eax, 0x34
mov byte [ebp - 0x421], al
mov cl, byte [ebp - 0x421]
mov byte [ebp - 0x2110], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0x428], al
movsx ecx, byte [ebp - 0x428]
xor ecx, 0x34
mov byte [ebp - 0x429], cl
mov dl, byte [ebp - 0x429]
mov byte [ebp - 0x210f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0x430], cl
movsx edx, byte [ebp - 0x430]
xor edx, 0x34
mov byte [ebp - 0x431], dl
mov al, byte [ebp - 0x431]
mov byte [ebp - 0x210e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0x438], al
movsx ecx, byte [ebp - 0x438]
xor ecx, 0x34
mov byte [ebp - 0x439], cl
mov dl, byte [ebp - 0x439]
mov byte [ebp - 0x210d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0x440], cl
movsx edx, byte [ebp - 0x440]
xor edx, 0x34
mov byte [ebp - 0x441], dl
mov al, byte [ebp - 0x441]
mov byte [ebp - 0x210c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0x448], al
movsx ecx, byte [ebp - 0x448]
xor ecx, 0x34
mov byte [ebp - 0x449], cl
mov dl, byte [ebp - 0x449]
mov byte [ebp - 0x210b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0x450], dl
movsx eax, byte [ebp - 0x450]
xor eax, 0x34
mov byte [ebp - 0x451], al
mov cl, byte [ebp - 0x451]
mov byte [ebp - 0x210a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0x458], cl
movsx edx, byte [ebp - 0x458]
xor edx, 0x34
mov byte [ebp - 0x459], dl
mov al, byte [ebp - 0x459]
mov byte [ebp - 0x2109], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0x460], dl
movsx eax, byte [ebp - 0x460]
xor eax, 0x34
mov byte [ebp - 0x461], al
mov cl, byte [ebp - 0x461]
mov byte [ebp - 0x2108], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.projectiles]
mov byte [ebp - 0x468], cl
movsx edx, byte [ebp - 0x468]
xor edx, 0x34
mov byte [ebp - 0x469], dl
mov al, byte [ebp - 0x469]
mov byte [ebp - 0x2107], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.projectiles]
mov byte [ebp - 0x470], al
movsx ecx, byte [ebp - 0x470]
xor ecx, 0x34
mov byte [ebp - 0x471], cl
mov dl, byte [ebp - 0x471]
mov byte [ebp - 0x2106], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.projectiles]
mov byte [ebp - 0x478], dl
movsx eax, byte [ebp - 0x478]
xor eax, 0x34
mov byte [ebp - 0x479], al
mov cl, byte [ebp - 0x479]
mov byte [ebp - 0x2105], cl
lea edx, [ebp - 0x2110]
mov dword [ebp - 0x3380], edx
mov eax, dword [ebp - 0x3380]
mov dword [ebp - 0x2538], eax
mov dword [ebp - 0x1e40], 0
jmp 0x10150427
mov ecx, dword [ebp - 0x1e40]
add ecx, 1
mov dword [ebp - 0x1e40], ecx
cmp dword [ebp - 0x1e40], 0xc
jae 0x101504a9
mov edx, dword [ebp - 0x2538]
mov dword [ebp - 0x3384], edx
mov eax, dword [ebp - 0x3384]
add eax, dword [ebp - 0x1e40]
mov dword [ebp - 0x3388], eax
mov ecx, dword [ebp - 0x3388]
mov dl, byte [ecx]
mov byte [ebp - 0x480], dl
movsx eax, byte [ebp - 0x480]
xor eax, 0x34
mov byte [ebp - 0x481], al
mov cl, byte [ebp - 0x481]
mov byte [ebp - 0x482], cl
mov edx, dword [ebp - 0x2538]
mov dword [ebp - 0x338c], edx
mov eax, dword [ebp - 0x338c]
add eax, dword [ebp - 0x1e40]
mov dword [ebp - 0x3390], eax
mov ecx, dword [ebp - 0x3390]
mov dl, byte [ebp - 0x482]
mov byte [ecx], dl
jmp 0x10150418
mov eax, dword [ebp - 0x2538]
mov dword [ebp - 0x3394], eax
mov ecx, dword [ebp - 0x3394]
mov dword [ebp - 0x3398], ecx
mov edx, dword [ebp - 0x3398]
mov dword [ebp - 0x339c], edx
mov eax, dword [ebp - 0x339c]
push eax
lea ecx, [ebp - 0x3590]
call fcn.1007b880
mov byte [ebp - 4], 8
lea ecx, [ebp - 0x35a8]
push ecx
mov ecx, dword [ebp - 0x1e44]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x1e44]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1e44]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10150526
lea edx, [ebp - 0x3590]
push edx
mov ecx, dword [ebp - 0x1e44]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x1e44]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 7
lea ecx, [ebp - 0x3590]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x35a8]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x1d0
mov dword [ebp - 0x60], ecx
mov edx, dword [ebp - 0x60]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x60]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x60]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x60]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x60]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x33a0], ecx
lea edx, [ebp - 0x60]
push edx
mov ecx, dword [ebp - 0x33a0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x258
mov dword [ebp - 0x1ca0], eax
mov ecx, dword [0x103f856c]
mov dword [ebp - 0x33a4], ecx
mov edx, dword [ebp - 0x33a4]
mov dword [ebp - 0x33a8], edx
mov eax, dword [ebp - 0x33a8]
mov dword [ebp - 0x2628], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0x488], al
movsx ecx, byte [ebp - 0x488]
xor ecx, 0x34
mov byte [ebp - 0x489], cl
mov dl, byte [ebp - 0x489]
mov byte [ebp - 0x20e0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0x490], cl
movsx edx, byte [ebp - 0x490]
xor edx, 0x34
mov byte [ebp - 0x491], dl
mov al, byte [ebp - 0x491]
mov byte [ebp - 0x20df], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0x498], dl
movsx eax, byte [ebp - 0x498]
xor eax, 0x34
mov byte [ebp - 0x499], al
mov cl, byte [ebp - 0x499]
mov byte [ebp - 0x20de], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0x4a0], cl
movsx edx, byte [ebp - 0x4a0]
xor edx, 0x34
mov byte [ebp - 0x4a1], dl
mov al, byte [ebp - 0x4a1]
mov byte [ebp - 0x20dd], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0x4a8], dl
movsx eax, byte [ebp - 0x4a8]
xor eax, 0x34
mov byte [ebp - 0x4a9], al
mov cl, byte [ebp - 0x4a9]
mov byte [ebp - 0x20dc], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0x4b0], cl
movsx edx, byte [ebp - 0x4b0]
xor edx, 0x34
mov byte [ebp - 0x4b1], dl
mov al, byte [ebp - 0x4b1]
mov byte [ebp - 0x20db], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0x4b8], al
movsx ecx, byte [ebp - 0x4b8]
xor ecx, 0x34
mov byte [ebp - 0x4b9], cl
mov dl, byte [ebp - 0x4b9]
mov byte [ebp - 0x20da], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0x4c0], dl
movsx eax, byte [ebp - 0x4c0]
xor eax, 0x34
mov byte [ebp - 0x4c1], al
mov cl, byte [ebp - 0x4c1]
mov byte [ebp - 0x20d9], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.proj_color]
mov byte [ebp - 0x4c8], al
movsx ecx, byte [ebp - 0x4c8]
xor ecx, 0x34
mov byte [ebp - 0x4c9], cl
mov dl, byte [ebp - 0x4c9]
mov byte [ebp - 0x20d8], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.proj_color]
mov byte [ebp - 0x4d0], dl
movsx eax, byte [ebp - 0x4d0]
xor eax, 0x34
mov byte [ebp - 0x4d1], al
mov cl, byte [ebp - 0x4d1]
mov byte [ebp - 0x20d7], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.proj_color]
mov byte [ebp - 0x4d8], cl
movsx edx, byte [ebp - 0x4d8]
xor edx, 0x34
mov byte [ebp - 0x4d9], dl
mov al, byte [ebp - 0x4d9]
mov byte [ebp - 0x20d6], al
lea ecx, [ebp - 0x20e0]
mov dword [ebp - 0x33ac], ecx
mov edx, dword [ebp - 0x33ac]
mov dword [ebp - 0x2524], edx
mov dword [ebp - 0x1e48], 0
jmp 0x1015082e
mov eax, dword [ebp - 0x1e48]
add eax, 1
mov dword [ebp - 0x1e48], eax
cmp dword [ebp - 0x1e48], 0xb
jae 0x101508b0
mov ecx, dword [ebp - 0x2524]
mov dword [ebp - 0x33b0], ecx
mov edx, dword [ebp - 0x33b0]
add edx, dword [ebp - 0x1e48]
mov dword [ebp - 0x33b4], edx
mov eax, dword [ebp - 0x33b4]
mov cl, byte [eax]
mov byte [ebp - 0x4e0], cl
movsx edx, byte [ebp - 0x4e0]
xor edx, 0x34
mov byte [ebp - 0x4e1], dl
mov al, byte [ebp - 0x4e1]
mov byte [ebp - 0x4e2], al
mov ecx, dword [ebp - 0x2524]
mov dword [ebp - 0x33b8], ecx
mov edx, dword [ebp - 0x33b8]
add edx, dword [ebp - 0x1e48]
mov dword [ebp - 0x33bc], edx
mov eax, dword [ebp - 0x33bc]
mov cl, byte [ebp - 0x4e2]
mov byte [eax], cl
jmp 0x1015081f
mov edx, dword [ebp - 0x2524]
mov dword [ebp - 0x33c0], edx
mov eax, dword [ebp - 0x33c0]
mov dword [ebp - 0x2600], eax
mov ecx, dword [ebp - 0x2600]
mov dword [ebp - 0x2604], ecx
mov edx, dword [ebp - 0x2604]
push edx
lea ecx, [ebp - 0x35d8]
call fcn.1007b880
mov dword [ebp - 4], 9
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.color]
mov byte [ebp - 0x4e8], dl
movsx eax, byte [ebp - 0x4e8]
xor eax, 0x34
mov byte [ebp - 0x4e9], al
mov cl, byte [ebp - 0x4e9]
mov byte [ebp - 0x2008], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.color]
mov byte [ebp - 0x4f0], al
movsx ecx, byte [ebp - 0x4f0]
xor ecx, 0x34
mov byte [ebp - 0x4f1], cl
mov dl, byte [ebp - 0x4f1]
mov byte [ebp - 0x2007], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.color]
mov byte [ebp - 0x4f8], cl
movsx edx, byte [ebp - 0x4f8]
xor edx, 0x34
mov byte [ebp - 0x4f9], dl
mov al, byte [ebp - 0x4f9]
mov byte [ebp - 0x2006], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.color]
mov byte [ebp - 0x500], al
movsx ecx, byte [ebp - 0x500]
xor ecx, 0x34
mov byte [ebp - 0x501], cl
mov dl, byte [ebp - 0x501]
mov byte [ebp - 0x2005], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.color]
mov byte [ebp - 0x508], cl
movsx edx, byte [ebp - 0x508]
xor edx, 0x34
mov byte [ebp - 0x509], dl
mov al, byte [ebp - 0x509]
mov byte [ebp - 0x2004], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.color]
mov byte [ebp - 0x510], al
movsx ecx, byte [ebp - 0x510]
xor ecx, 0x34
mov byte [ebp - 0x511], cl
mov dl, byte [ebp - 0x511]
mov byte [ebp - 0x2003], dl
lea eax, [ebp - 0x2008]
mov dword [ebp - 0x2608], eax
mov ecx, dword [ebp - 0x2608]
mov dword [ebp - 0x2520], ecx
mov dword [ebp - 0x1e4c], 0
jmp 0x10150a3f
mov edx, dword [ebp - 0x1e4c]
add edx, 1
mov dword [ebp - 0x1e4c], edx
cmp dword [ebp - 0x1e4c], 6
jae 0x10150ac1
mov eax, dword [ebp - 0x2520]
mov dword [ebp - 0x260c], eax
mov ecx, dword [ebp - 0x260c]
add ecx, dword [ebp - 0x1e4c]
mov dword [ebp - 0x2610], ecx
mov edx, dword [ebp - 0x2610]
mov al, byte [edx]
mov byte [ebp - 0x518], al
movsx ecx, byte [ebp - 0x518]
xor ecx, 0x34
mov byte [ebp - 0x519], cl
mov dl, byte [ebp - 0x519]
mov byte [ebp - 0x51a], dl
mov eax, dword [ebp - 0x2520]
mov dword [ebp - 0x2614], eax
mov ecx, dword [ebp - 0x2614]
add ecx, dword [ebp - 0x1e4c]
mov dword [ebp - 0x2618], ecx
mov edx, dword [ebp - 0x2618]
mov al, byte [ebp - 0x51a]
mov byte [edx], al
jmp 0x10150a30
mov ecx, dword [ebp - 0x2520]
mov dword [ebp - 0x261c], ecx
mov edx, dword [ebp - 0x261c]
mov dword [ebp - 0x2620], edx
mov eax, dword [ebp - 0x2620]
mov dword [ebp - 0x2624], eax
mov ecx, dword [ebp - 0x2624]
push ecx
lea ecx, [ebp - 0x35c0]
call fcn.1007b880
mov byte [ebp - 4], 0xa
lea edx, [ebp - 0x35c0]
push edx
mov ecx, dword [ebp - 0x1ca0]
add ecx, 0x70
call fcn.1008d0b0
lea eax, [ebp - 0x35d8]
push eax
mov ecx, dword [ebp - 0x1ca0]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x1ca0]
mov edx, dword [ebp - 0x2628]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1ca0]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1ca0]
cmp dword [ecx + 0x8c], 0
je 0x10150b70
mov edx, dword [ebp - 0x1ca0]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1ca0]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 9
lea ecx, [ebp - 0x35c0]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x35d8]
call fcn.1007c260
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x258
mov dword [ebp - 0x64], eax
mov ecx, dword [ebp - 0x64]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x64]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x64]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x64]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x64]
mov ecx, dword [ebp - 0xc0]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0xc0]
add eax, 0x18
mov dword [ebp - 0x262c], eax
lea ecx, [ebp - 0x64]
push ecx
mov ecx, dword [ebp - 0x262c]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x2e8
mov dword [ebp - 0xd0], edx
lea eax, [ebp - 0x2449]
mov dword [ebp - 0x2630], eax
mov ecx, dword [ebp - 0x2630]
mov dword [ebp - 0x2678], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.frag]
mov byte [ebp - 0x520], cl
movsx edx, byte [ebp - 0x520]
xor edx, 0x34
mov byte [ebp - 0x521], dl
mov al, byte [ebp - 0x521]
mov byte [ebp - 0x1fe8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.frag]
mov byte [ebp - 0x528], dl
movsx eax, byte [ebp - 0x528]
xor eax, 0x34
mov byte [ebp - 0x529], al
mov cl, byte [ebp - 0x529]
mov byte [ebp - 0x1fe7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.frag]
mov byte [ebp - 0x530], al
movsx ecx, byte [ebp - 0x530]
xor ecx, 0x34
mov byte [ebp - 0x531], cl
mov dl, byte [ebp - 0x531]
mov byte [ebp - 0x1fe6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.frag]
mov byte [ebp - 0x538], dl
movsx eax, byte [ebp - 0x538]
xor eax, 0x34
mov byte [ebp - 0x539], al
mov cl, byte [ebp - 0x539]
mov byte [ebp - 0x1fe5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.frag]
mov byte [ebp - 0x540], al
movsx ecx, byte [ebp - 0x540]
xor ecx, 0x34
mov byte [ebp - 0x541], cl
mov dl, byte [ebp - 0x541]
mov byte [ebp - 0x1fe4], dl
lea eax, [ebp - 0x1fe8]
mov dword [ebp - 0x2634], eax
mov ecx, dword [ebp - 0x2634]
mov dword [ebp - 0x2518], ecx
mov dword [ebp - 0x1e50], 0
jmp 0x10150d42
mov edx, dword [ebp - 0x1e50]
add edx, 1
mov dword [ebp - 0x1e50], edx
cmp dword [ebp - 0x1e50], 5
jae 0x10150dc4
mov eax, dword [ebp - 0x2518]
mov dword [ebp - 0x2638], eax
mov ecx, dword [ebp - 0x2638]
add ecx, dword [ebp - 0x1e50]
mov dword [ebp - 0x263c], ecx
mov edx, dword [ebp - 0x263c]
mov al, byte [edx]
mov byte [ebp - 0x548], al
movsx ecx, byte [ebp - 0x548]
xor ecx, 0x34
mov byte [ebp - 0x549], cl
mov dl, byte [ebp - 0x549]
mov byte [ebp - 0x54a], dl
mov eax, dword [ebp - 0x2518]
mov dword [ebp - 0x2640], eax
mov ecx, dword [ebp - 0x2640]
add ecx, dword [ebp - 0x1e50]
mov dword [ebp - 0x2644], ecx
mov edx, dword [ebp - 0x2644]
mov al, byte [ebp - 0x54a]
mov byte [edx], al
jmp 0x10150d33
mov ecx, dword [ebp - 0x2518]
mov dword [ebp - 0x2648], ecx
mov edx, dword [ebp - 0x2648]
mov dword [ebp - 0x264c], edx
mov eax, dword [ebp - 0x264c]
mov dword [ebp - 0x2650], eax
mov ecx, dword [ebp - 0x2650]
push ecx
lea ecx, [ebp - 0x3cf4]
call fcn.1007b880
mov dword [ebp - 4], 0xb
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.molly]
mov byte [ebp - 0x550], cl
movsx edx, byte [ebp - 0x550]
xor edx, 0x34
mov byte [ebp - 0x551], dl
mov al, byte [ebp - 0x551]
mov byte [ebp - 0x2010], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.molly]
mov byte [ebp - 0x558], dl
movsx eax, byte [ebp - 0x558]
xor eax, 0x34
mov byte [ebp - 0x559], al
mov cl, byte [ebp - 0x559]
mov byte [ebp - 0x200f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.molly]
mov byte [ebp - 0x560], al
movsx ecx, byte [ebp - 0x560]
xor ecx, 0x34
mov byte [ebp - 0x561], cl
mov dl, byte [ebp - 0x561]
mov byte [ebp - 0x200e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.molly]
mov byte [ebp - 0x568], dl
movsx eax, byte [ebp - 0x568]
xor eax, 0x34
mov byte [ebp - 0x569], al
mov cl, byte [ebp - 0x569]
mov byte [ebp - 0x200d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.molly]
mov byte [ebp - 0x570], al
movsx ecx, byte [ebp - 0x570]
xor ecx, 0x34
mov byte [ebp - 0x571], cl
mov dl, byte [ebp - 0x571]
mov byte [ebp - 0x200c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.molly]
mov byte [ebp - 0x578], dl
movsx eax, byte [ebp - 0x578]
xor eax, 0x34
mov byte [ebp - 0x579], al
mov cl, byte [ebp - 0x579]
mov byte [ebp - 0x200b], cl
lea edx, [ebp - 0x2010]
mov dword [ebp - 0x2654], edx
mov eax, dword [ebp - 0x2654]
mov dword [ebp - 0x250c], eax
mov dword [ebp - 0x1e54], 0
jmp 0x10150f53
mov ecx, dword [ebp - 0x1e54]
add ecx, 1
mov dword [ebp - 0x1e54], ecx
cmp dword [ebp - 0x1e54], 6
jae 0x10150fd5
mov edx, dword [ebp - 0x250c]
mov dword [ebp - 0x2658], edx
mov eax, dword [ebp - 0x2658]
add eax, dword [ebp - 0x1e54]
mov dword [ebp - 0x265c], eax
mov ecx, dword [ebp - 0x265c]
mov dl, byte [ecx]
mov byte [ebp - 0x580], dl
movsx eax, byte [ebp - 0x580]
xor eax, 0x34
mov byte [ebp - 0x581], al
mov cl, byte [ebp - 0x581]
mov byte [ebp - 0x582], cl
mov edx, dword [ebp - 0x250c]
mov dword [ebp - 0x2660], edx
mov eax, dword [ebp - 0x2660]
add eax, dword [ebp - 0x1e54]
mov dword [ebp - 0x2664], eax
mov ecx, dword [ebp - 0x2664]
mov dl, byte [ebp - 0x582]
mov byte [ecx], dl
jmp 0x10150f44
mov eax, dword [ebp - 0x250c]
mov dword [ebp - 0x2668], eax
mov ecx, dword [ebp - 0x2668]
mov dword [ebp - 0x266c], ecx
mov edx, dword [ebp - 0x266c]
mov dword [ebp - 0x2670], edx
mov eax, dword [ebp - 0x2670]
push eax
lea ecx, [ebp - 0x3cdc]
call fcn.1007b880
mov dword [ebp - 4], 0xc
lea ecx, [ebp - 0x3cf4]
mov dword [ebp - 0x33d0], ecx
lea edx, [ebp - 0x3cc4]
mov dword [ebp - 0x33cc], edx
lea eax, [ebp - 0x33d0]
mov dword [ebp - 0x2674], eax
mov ecx, dword [ebp - 0x2674]
mov edx, dword [ecx]
mov eax, dword [ecx + 4]
mov dword [ebp - 0x3288], edx
mov dword [ebp - 0x3284], eax
mov ecx, dword [ebp - 0x2678]
push ecx
mov edx, dword [ebp - 0x3284]
push edx
mov eax, dword [ebp - 0x3288]
push eax
lea ecx, [ebp - 0x344c]
call fcn.101ed250
mov byte [ebp - 4], 0xd
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0x588], al
movsx ecx, byte [ebp - 0x588]
xor ecx, 0x34
mov byte [ebp - 0x589], cl
mov dl, byte [ebp - 0x589]
mov byte [ebp - 0x20d4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0x590], cl
movsx edx, byte [ebp - 0x590]
xor edx, 0x34
mov byte [ebp - 0x591], dl
mov al, byte [ebp - 0x591]
mov byte [ebp - 0x20d3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0x598], dl
movsx eax, byte [ebp - 0x598]
xor eax, 0x34
mov byte [ebp - 0x599], al
mov cl, byte [ebp - 0x599]
mov byte [ebp - 0x20d2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0x5a0], cl
movsx edx, byte [ebp - 0x5a0]
xor edx, 0x34
mov byte [ebp - 0x5a1], dl
mov al, byte [ebp - 0x5a1]
mov byte [ebp - 0x20d1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0x5a8], dl
movsx eax, byte [ebp - 0x5a8]
xor eax, 0x34
mov byte [ebp - 0x5a9], al
mov cl, byte [ebp - 0x5a9]
mov byte [ebp - 0x20d0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0x5b0], cl
movsx edx, byte [ebp - 0x5b0]
xor edx, 0x34
mov byte [ebp - 0x5b1], dl
mov al, byte [ebp - 0x5b1]
mov byte [ebp - 0x20cf], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0x5b8], al
movsx ecx, byte [ebp - 0x5b8]
xor ecx, 0x34
mov byte [ebp - 0x5b9], cl
mov dl, byte [ebp - 0x5b9]
mov byte [ebp - 0x20ce], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0x5c0], dl
movsx eax, byte [ebp - 0x5c0]
xor eax, 0x34
mov byte [ebp - 0x5c1], al
mov cl, byte [ebp - 0x5c1]
mov byte [ebp - 0x20cd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.proj_range]
mov byte [ebp - 0x5c8], al
movsx ecx, byte [ebp - 0x5c8]
xor ecx, 0x34
mov byte [ebp - 0x5c9], cl
mov dl, byte [ebp - 0x5c9]
mov byte [ebp - 0x20cc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.proj_range]
mov byte [ebp - 0x5d0], dl
movsx eax, byte [ebp - 0x5d0]
xor eax, 0x34
mov byte [ebp - 0x5d1], al
mov cl, byte [ebp - 0x5d1]
mov byte [ebp - 0x20cb], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.proj_range]
mov byte [ebp - 0x5d8], cl
movsx edx, byte [ebp - 0x5d8]
xor edx, 0x34
mov byte [ebp - 0x5d9], dl
mov al, byte [ebp - 0x5d9]
mov byte [ebp - 0x20ca], al
lea ecx, [ebp - 0x20d4]
mov dword [ebp - 0x267c], ecx
mov edx, dword [ebp - 0x267c]
mov dword [ebp - 0x2508], edx
mov dword [ebp - 0x1e58], 0
jmp 0x101512b3
mov eax, dword [ebp - 0x1e58]
add eax, 1
mov dword [ebp - 0x1e58], eax
cmp dword [ebp - 0x1e58], 0xb
jae 0x10151335
mov ecx, dword [ebp - 0x2508]
mov dword [ebp - 0x2680], ecx
mov edx, dword [ebp - 0x2680]
add edx, dword [ebp - 0x1e58]
mov dword [ebp - 0x2684], edx
mov eax, dword [ebp - 0x2684]
mov cl, byte [eax]
mov byte [ebp - 0x5e0], cl
movsx edx, byte [ebp - 0x5e0]
xor edx, 0x34
mov byte [ebp - 0x5e1], dl
mov al, byte [ebp - 0x5e1]
mov byte [ebp - 0x5e2], al
mov ecx, dword [ebp - 0x2508]
mov dword [ebp - 0x2688], ecx
mov edx, dword [ebp - 0x2688]
add edx, dword [ebp - 0x1e58]
mov dword [ebp - 0x268c], edx
mov eax, dword [ebp - 0x268c]
mov cl, byte [ebp - 0x5e2]
mov byte [eax], cl
jmp 0x101512a4
mov edx, dword [ebp - 0x2508]
mov dword [ebp - 0x2690], edx
mov eax, dword [ebp - 0x2690]
mov dword [ebp - 0x2694], eax
mov ecx, dword [ebp - 0x2694]
mov dword [ebp - 0x2698], ecx
mov edx, dword [ebp - 0x2698]
push edx
lea ecx, [ebp - 0x3608]
call fcn.1007b880
mov byte [ebp - 4], 0xe
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x5e8], dl
movsx eax, byte [ebp - 0x5e8]
xor eax, 0x34
mov byte [ebp - 0x5e9], al
mov cl, byte [ebp - 0x5e9]
mov byte [ebp - 0x21d4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0x5f0], al
movsx ecx, byte [ebp - 0x5f0]
xor ecx, 0x34
mov byte [ebp - 0x5f1], cl
mov dl, byte [ebp - 0x5f1]
mov byte [ebp - 0x21d3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x5f8], cl
movsx edx, byte [ebp - 0x5f8]
xor edx, 0x34
mov byte [ebp - 0x5f9], dl
mov al, byte [ebp - 0x5f9]
mov byte [ebp - 0x21d2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0x600], al
movsx ecx, byte [ebp - 0x600]
xor ecx, 0x34
mov byte [ebp - 0x601], cl
mov dl, byte [ebp - 0x601]
mov byte [ebp - 0x21d1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x608], cl
movsx edx, byte [ebp - 0x608]
xor edx, 0x34
mov byte [ebp - 0x609], dl
mov al, byte [ebp - 0x609]
mov byte [ebp - 0x21d0], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0x610], al
movsx ecx, byte [ebp - 0x610]
xor ecx, 0x34
mov byte [ebp - 0x611], cl
mov dl, byte [ebp - 0x611]
mov byte [ebp - 0x21cf], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x618], dl
movsx eax, byte [ebp - 0x618]
xor eax, 0x34
mov byte [ebp - 0x619], al
mov cl, byte [ebp - 0x619]
mov byte [ebp - 0x21ce], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x620], cl
movsx edx, byte [ebp - 0x620]
xor edx, 0x34
mov byte [ebp - 0x621], dl
mov al, byte [ebp - 0x621]
mov byte [ebp - 0x21cd], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x628], dl
movsx eax, byte [ebp - 0x628]
xor eax, 0x34
mov byte [ebp - 0x629], al
mov cl, byte [ebp - 0x629]
mov byte [ebp - 0x21cc], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x630], cl
movsx edx, byte [ebp - 0x630]
xor edx, 0x34
mov byte [ebp - 0x631], dl
mov al, byte [ebp - 0x631]
mov byte [ebp - 0x21cb], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0x638], al
movsx ecx, byte [ebp - 0x638]
xor ecx, 0x34
mov byte [ebp - 0x639], cl
mov dl, byte [ebp - 0x639]
mov byte [ebp - 0x21ca], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x640], dl
movsx eax, byte [ebp - 0x640]
xor eax, 0x34
mov byte [ebp - 0x641], al
mov cl, byte [ebp - 0x641]
mov byte [ebp - 0x21c9], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x648], cl
movsx edx, byte [ebp - 0x648]
xor edx, 0x34
mov byte [ebp - 0x649], dl
mov al, byte [ebp - 0x649]
mov byte [ebp - 0x21c8], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.projectile_range]
mov byte [ebp - 0x650], al
movsx ecx, byte [ebp - 0x650]
xor ecx, 0x34
mov byte [ebp - 0x651], cl
mov dl, byte [ebp - 0x651]
mov byte [ebp - 0x21c7], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x658], dl
movsx eax, byte [ebp - 0x658]
xor eax, 0x34
mov byte [ebp - 0x659], al
mov cl, byte [ebp - 0x659]
mov byte [ebp - 0x21c6], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.projectile_range]
mov byte [ebp - 0x660], cl
movsx edx, byte [ebp - 0x660]
xor edx, 0x34
mov byte [ebp - 0x661], dl
mov al, byte [ebp - 0x661]
mov byte [ebp - 0x21c5], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.projectile_range]
mov byte [ebp - 0x668], dl
movsx eax, byte [ebp - 0x668]
xor eax, 0x34
mov byte [ebp - 0x669], al
mov cl, byte [ebp - 0x669]
mov byte [ebp - 0x21c4], cl
lea edx, [ebp - 0x21d4]
mov dword [ebp - 0x269c], edx
mov eax, dword [ebp - 0x269c]
mov dword [ebp - 0x2504], eax
mov dword [ebp - 0x1e5c], 0
jmp 0x101516d1
mov ecx, dword [ebp - 0x1e5c]
add ecx, 1
mov dword [ebp - 0x1e5c], ecx
cmp dword [ebp - 0x1e5c], 0x11
jae 0x10151753
mov edx, dword [ebp - 0x2504]
mov dword [ebp - 0x26a0], edx
mov eax, dword [ebp - 0x26a0]
add eax, dword [ebp - 0x1e5c]
mov dword [ebp - 0x26a4], eax
mov ecx, dword [ebp - 0x26a4]
mov dl, byte [ecx]
mov byte [ebp - 0x670], dl
movsx eax, byte [ebp - 0x670]
xor eax, 0x34
mov byte [ebp - 0x671], al
mov cl, byte [ebp - 0x671]
mov byte [ebp - 0x672], cl
mov edx, dword [ebp - 0x2504]
mov dword [ebp - 0x26a8], edx
mov eax, dword [ebp - 0x26a8]
add eax, dword [ebp - 0x1e5c]
mov dword [ebp - 0x26ac], eax
mov ecx, dword [ebp - 0x26ac]
mov dl, byte [ebp - 0x672]
mov byte [ecx], dl
jmp 0x101516c2
mov eax, dword [ebp - 0x2504]
mov dword [ebp - 0x26b0], eax
mov ecx, dword [ebp - 0x26b0]
mov dword [ebp - 0x26b4], ecx
mov edx, dword [ebp - 0x26b4]
mov dword [ebp - 0x26b8], edx
mov eax, dword [ebp - 0x26b8]
push eax
lea ecx, [ebp - 0x35f0]
call fcn.1007b880
mov byte [ebp - 4], 0xf
lea ecx, [ebp - 0x3440]
mov dword [ebp - 0x2500], ecx
mov edx, dword [ebp - 0x2500]
mov dword [ebp - 0x26bc], edx
mov ecx, dword [ebp - 0x26bc]
call fcn.1007e520
nop
mov eax, dword [ebp - 0x2500]
mov dword [ebp - 0x3428], eax
mov ecx, dword [ebp - 0x2500]
mov dword [ebp - 0x26c0], ecx
mov edx, dword [ebp - 0x26c0]
mov dword [ebp - 0x342c], edx
mov byte [ebp - 4], 0x10
lea eax, [ebp - 0x3608]
push eax
mov ecx, dword [ebp - 0xd0]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0xd0]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0xd0]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1015181c
lea ecx, [ebp - 0x35f0]
push ecx
mov ecx, dword [ebp - 0xd0]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0xd0]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10151836
mov dword [ebp - 0x2558], 0xf
jmp 0x10151840
mov dword [ebp - 0x2558], 0
mov ecx, dword [ebp - 0xd0]
mov edx, dword [ebp - 0x2558]
mov dword [ecx + 0xa4], edx
mov eax, dword [ebp - 0xd0]
mov ecx, dword [eax + 0xa4]
add ecx, 0x14
mov dword [ebp - 0x255c], ecx
mov edx, dword [ebp - 0xd0]
mov eax, dword [ebp - 0x255c]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0xd0]
mov edx, dword [ebp - 0x255c]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x344c]
mov dword [ebp - 0x2560], eax
mov ecx, dword [ebp - 0x2560]
mov edx, dword [ecx]
mov dword [ebp - 0x26c4], edx
mov eax, dword [ebp - 0x26c4]
mov dword [ebp - 0x26c8], eax
mov ecx, dword [ebp - 0x26c8]
mov dword [ebp - 0x26cc], ecx
mov edx, dword [ebp - 0x26cc]
mov dword [ebp - 0x1f9c], edx
mov eax, dword [ebp - 0x2560]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x26d0], ecx
mov edx, dword [ebp - 0x26d0]
mov dword [ebp - 0x26d4], edx
mov eax, dword [ebp - 0x26d4]
mov dword [ebp - 0x26d8], eax
mov ecx, dword [ebp - 0x26d8]
mov dword [ebp - 0x26dc], ecx
jmp 0x10151907
mov edx, dword [ebp - 0x1f9c]
add edx, 0x18
mov dword [ebp - 0x1f9c], edx
mov eax, dword [ebp - 0x1f9c]
cmp eax, dword [ebp - 0x26dc]
je 0x10151948
mov ecx, dword [ebp - 0x1f9c]
mov dword [ebp - 0x26e0], ecx
mov edx, dword [ebp - 0xd0]
add edx, 0x88
mov dword [ebp - 0x26e4], edx
mov eax, dword [ebp - 0x26e0]
push eax
mov ecx, dword [ebp - 0x26e4]
call fcn.100d29a0
nop
jmp 0x101518f8
lea ecx, [ebp - 0x3440]
mov dword [ebp - 0x2564], ecx
mov edx, dword [ebp - 0x2564]
mov eax, dword [edx]
mov dword [ebp - 0x26e8], eax
mov ecx, dword [ebp - 0x26e8]
mov dword [ebp - 0x26ec], ecx
mov edx, dword [ebp - 0x26ec]
mov dword [ebp - 0x26f0], edx
mov eax, dword [ebp - 0x26f0]
mov dword [ebp - 0x1fac], eax
mov ecx, dword [ebp - 0x2564]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x26f4], edx
mov eax, dword [ebp - 0x26f4]
mov dword [ebp - 0x26f8], eax
mov ecx, dword [ebp - 0x26f8]
mov dword [ebp - 0x26fc], ecx
mov edx, dword [ebp - 0x26fc]
mov dword [ebp - 0x2700], edx
jmp 0x101519ca
mov eax, dword [ebp - 0x1fac]
add eax, 4
mov dword [ebp - 0x1fac], eax
mov ecx, dword [ebp - 0x1fac]
cmp ecx, dword [ebp - 0x2700]
je 0x10151b62
mov edx, dword [ebp - 0x1fac]
mov dword [ebp - 0x2704], edx
mov eax, dword [ebp - 0x2704]
mov ecx, dword [eax]
mov dword [ebp - 0x18], ecx
mov edx, dword [ebp - 0xd0]
add edx, 0x98
mov dword [ebp - 0x2708], edx
lea eax, [ebp - 0x341c]
push eax
mov ecx, dword [ebp - 0x2708]
call fcn.1007a250
mov ecx, dword [eax]
mov dword [ebp - 0x2710], ecx
mov edx, dword [ebp - 0xd0]
add edx, 0x98
mov dword [ebp - 0x270c], edx
lea eax, [ebp - 0x34c4]
push eax
mov ecx, dword [ebp - 0x270c]
call fcn.1007a290
mov ecx, dword [eax]
mov dword [ebp - 0x2714], ecx
lea edx, [ebp - 0x18]
push edx
mov eax, dword [ebp - 0x2710]
push eax
mov ecx, dword [ebp - 0x2714]
push ecx
lea edx, [ebp - 0x34c8]
push edx
call fcn.1007d760
add esp, 0x10
mov dword [ebp - 0x271c], eax
mov eax, dword [ebp - 0xd0]
add eax, 0x98
mov dword [ebp - 0x2718], eax
lea ecx, [ebp - 0x34cc]
push ecx
mov ecx, dword [ebp - 0x2718]
call fcn.1007a250
mov dword [ebp - 0x2720], eax
mov edx, dword [ebp - 0x271c]
mov eax, dword [ebp - 0x2720]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x10151ab9
mov dword [ebp - 0x2568], 1
jmp 0x10151ac3
mov dword [ebp - 0x2568], 0
mov dl, byte [ebp - 0x2568]
mov byte [ebp - 0x673], dl
mov al, byte [ebp - 0x673]
mov byte [ebp - 0x674], al
mov ecx, dword [ebp - 0xd0]
add ecx, 0x88
mov dword [ebp - 0x256c], ecx
mov edx, dword [ebp - 0x256c]
mov eax, dword [ebp - 0x256c]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x2724], eax
mov edx, dword [ebp - 0x2724]
cmp dword [ebp - 0x18], edx
jae 0x10151b3a
mov eax, dword [ebp - 0xd0]
add eax, 0x98
mov dword [ebp - 0x2728], eax
lea ecx, [ebp - 0x18]
push ecx
mov ecx, dword [ebp - 0x2728]
call fcn.1007d7f0
nop
movzx edx, byte [ebp - 0x674]
test edx, edx
je 0x10151b5d
mov eax, dword [ebp - 0xd0]
cmp dword [eax + 0x64], 0
je 0x10151b5d
mov ecx, dword [ebp - 0xd0]
mov edx, dword [ecx + 0x64]
call edx
nop
jmp 0x101519bb
mov byte [ebp - 4], 0xf
lea ecx, [ebp - 0x3440]
call fcn.1007baa0
nop
mov byte [ebp - 4], 0xe
lea ecx, [ebp - 0x35f0]
call fcn.1007c260
nop
mov byte [ebp - 4], 0xd
lea ecx, [ebp - 0x3608]
call fcn.1007c260
nop
mov byte [ebp - 4], 0xc
lea ecx, [ebp - 0x344c]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 2
push 0x18
lea eax, [ebp - 0x3cf4]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x2e8
mov dword [ebp - 0x94], ecx
mov edx, dword [ebp - 0x94]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x94]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x94]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x94]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x94]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x272c], ecx
lea edx, [ebp - 0x94]
push edx
mov ecx, dword [ebp - 0x272c]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x390
mov dword [ebp - 0xe8], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x102a34b8]
mov word [ebp - 0x243c], ax
movzx ecx, word [ebp - 0x243c]
xor ecx, 0x34
mov word [ebp - 0x2436], cx
mov dx, word [ebp - 0x2436]
mov word [ebp - 0x25fc], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x102a34b8]
mov word [ebp - 0x24fc], cx
movzx edx, word [ebp - 0x24fc]
xor edx, 0x34
mov word [ebp - 0x24c0], dx
mov ax, word [ebp - 0x24c0]
mov word [ebp - 0x25fa], ax
mov ecx, 2
shl ecx, 1
mov dx, word [ecx + 0x102a34b8]
mov word [ebp - 0x2344], dx
movzx eax, word [ebp - 0x2344]
xor eax, 0x34
mov word [ebp - 0x23ba], ax
mov cx, word [ebp - 0x23ba]
mov word [ebp - 0x25f8], cx
lea edx, [ebp - 0x25fc]
mov dword [ebp - 0x2730], edx
mov eax, dword [ebp - 0x2730]
mov dword [ebp - 0x24f8], eax
mov dword [ebp - 0x1e60], 0
jmp 0x10151d1a
mov ecx, dword [ebp - 0x1e60]
add ecx, 1
mov dword [ebp - 0x1e60], ecx
cmp dword [ebp - 0x1e60], 3
jae 0x10151dad
mov edx, dword [ebp - 0x24f8]
mov dword [ebp - 0x2734], edx
mov eax, dword [ebp - 0x1e60]
mov ecx, dword [ebp - 0x2734]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2738], edx
mov eax, dword [ebp - 0x2738]
mov cx, word [eax]
mov word [ebp - 0x2494], cx
movzx edx, word [ebp - 0x2494]
xor edx, 0x34
mov word [ebp - 0x24be], dx
mov ax, word [ebp - 0x24be]
mov word [ebp - 0x24ca], ax
mov ecx, dword [ebp - 0x24f8]
mov dword [ebp - 0x273c], ecx
mov edx, dword [ebp - 0x1e60]
mov eax, dword [ebp - 0x273c]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2740], ecx
mov edx, dword [ebp - 0x2740]
mov ax, word [ebp - 0x24ca]
mov word [edx], ax
jmp 0x10151d0b
mov ecx, dword [ebp - 0x24f8]
mov dword [ebp - 0x2744], ecx
mov edx, dword [ebp - 0x2744]
mov dword [ebp - 0x2748], edx
mov eax, dword [ebp - 0x2748]
mov dword [ebp - 0x274c], eax
mov ecx, dword [ebp - 0x274c]
push ecx
lea ecx, [ebp - 0x3650]
call fcn.101ed710
mov dword [ebp - 4], 0x11
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.molly_radius]
mov byte [ebp - 0x678], cl
movsx edx, byte [ebp - 0x678]
xor edx, 0x34
mov byte [ebp - 0x679], dl
mov al, byte [ebp - 0x679]
mov byte [ebp - 0x2160], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.molly_radius]
mov byte [ebp - 0x680], dl
movsx eax, byte [ebp - 0x680]
xor eax, 0x34
mov byte [ebp - 0x681], al
mov cl, byte [ebp - 0x681]
mov byte [ebp - 0x215f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.molly_radius]
mov byte [ebp - 0x688], al
movsx ecx, byte [ebp - 0x688]
xor ecx, 0x34
mov byte [ebp - 0x689], cl
mov dl, byte [ebp - 0x689]
mov byte [ebp - 0x215e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.molly_radius]
mov byte [ebp - 0x690], dl
movsx eax, byte [ebp - 0x690]
xor eax, 0x34
mov byte [ebp - 0x691], al
mov cl, byte [ebp - 0x691]
mov byte [ebp - 0x215d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.molly_radius]
mov byte [ebp - 0x698], al
movsx ecx, byte [ebp - 0x698]
xor ecx, 0x34
mov byte [ebp - 0x699], cl
mov dl, byte [ebp - 0x699]
mov byte [ebp - 0x215c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.molly_radius]
mov byte [ebp - 0x6a0], dl
movsx eax, byte [ebp - 0x6a0]
xor eax, 0x34
mov byte [ebp - 0x6a1], al
mov cl, byte [ebp - 0x6a1]
mov byte [ebp - 0x215b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.molly_radius]
mov byte [ebp - 0x6a8], cl
movsx edx, byte [ebp - 0x6a8]
xor edx, 0x34
mov byte [ebp - 0x6a9], dl
mov al, byte [ebp - 0x6a9]
mov byte [ebp - 0x215a], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.molly_radius]
mov byte [ebp - 0x6b0], al
movsx ecx, byte [ebp - 0x6b0]
xor ecx, 0x34
mov byte [ebp - 0x6b1], cl
mov dl, byte [ebp - 0x6b1]
mov byte [ebp - 0x2159], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.molly_radius]
mov byte [ebp - 0x6b8], cl
movsx edx, byte [ebp - 0x6b8]
xor edx, 0x34
mov byte [ebp - 0x6b9], dl
mov al, byte [ebp - 0x6b9]
mov byte [ebp - 0x2158], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.molly_radius]
mov byte [ebp - 0x6c0], al
movsx ecx, byte [ebp - 0x6c0]
xor ecx, 0x34
mov byte [ebp - 0x6c1], cl
mov dl, byte [ebp - 0x6c1]
mov byte [ebp - 0x2157], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.molly_radius]
mov byte [ebp - 0x6c8], dl
movsx eax, byte [ebp - 0x6c8]
xor eax, 0x34
mov byte [ebp - 0x6c9], al
mov cl, byte [ebp - 0x6c9]
mov byte [ebp - 0x2156], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.molly_radius]
mov byte [ebp - 0x6d0], cl
movsx edx, byte [ebp - 0x6d0]
xor edx, 0x34
mov byte [ebp - 0x6d1], dl
mov al, byte [ebp - 0x6d1]
mov byte [ebp - 0x2155], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.molly_radius]
mov byte [ebp - 0x6d8], al
movsx ecx, byte [ebp - 0x6d8]
xor ecx, 0x34
mov byte [ebp - 0x6d9], cl
mov dl, byte [ebp - 0x6d9]
mov byte [ebp - 0x2154], dl
lea eax, [ebp - 0x2160]
mov dword [ebp - 0x2750], eax
mov ecx, dword [ebp - 0x2750]
mov dword [ebp - 0x24f4], ecx
mov dword [ebp - 0x1e64], 0
jmp 0x1015208c
mov edx, dword [ebp - 0x1e64]
add edx, 1
mov dword [ebp - 0x1e64], edx
cmp dword [ebp - 0x1e64], 0xd
jae 0x1015210e
mov eax, dword [ebp - 0x24f4]
mov dword [ebp - 0x2754], eax
mov ecx, dword [ebp - 0x2754]
add ecx, dword [ebp - 0x1e64]
mov dword [ebp - 0x2758], ecx
mov edx, dword [ebp - 0x2758]
mov al, byte [edx]
mov byte [ebp - 0x6e0], al
movsx ecx, byte [ebp - 0x6e0]
xor ecx, 0x34
mov byte [ebp - 0x6e1], cl
mov dl, byte [ebp - 0x6e1]
mov byte [ebp - 0x6e2], dl
mov eax, dword [ebp - 0x24f4]
mov dword [ebp - 0x275c], eax
mov ecx, dword [ebp - 0x275c]
add ecx, dword [ebp - 0x1e64]
mov dword [ebp - 0x2760], ecx
mov edx, dword [ebp - 0x2760]
mov al, byte [ebp - 0x6e2]
mov byte [edx], al
jmp 0x1015207d
mov ecx, dword [ebp - 0x24f4]
mov dword [ebp - 0x2764], ecx
mov edx, dword [ebp - 0x2764]
mov dword [ebp - 0x2768], edx
mov eax, dword [ebp - 0x2768]
mov dword [ebp - 0x276c], eax
mov ecx, dword [ebp - 0x276c]
push ecx
lea ecx, [ebp - 0x3638]
call fcn.1007b880
mov byte [ebp - 4], 0x12
push 0x102a34d4
lea ecx, [ebp - 0x3620]
call fcn.1007b880
mov byte [ebp - 4], 0x13
lea edx, [ebp - 0x3638]
push edx
mov ecx, dword [ebp - 0xe8]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0xe8]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0xe8]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x101521a2
lea eax, [ebp - 0x3620]
push eax
mov ecx, dword [ebp - 0xe8]
add ecx, 0x88
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0xe8]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x101521bc
mov dword [ebp - 0x2570], 0xf
jmp 0x101521c6
mov dword [ebp - 0x2570], 0
mov eax, dword [ebp - 0xe8]
mov ecx, dword [ebp - 0x2570]
mov dword [eax + 0xb8], ecx
mov edx, dword [ebp - 0xe8]
mov eax, dword [edx + 0xb8]
add eax, 8
mov ecx, dword [ebp - 0xe8]
mov dword [ecx + 0x10], eax
mov edx, dword [ebp - 0xe8]
mov eax, dword [ebp - 0xe8]
mov ecx, dword [eax + 0x10]
mov dword [edx + 0x14], ecx
mov edx, dword [ebp - 0xe8]
movss xmm0, dword [0x102a60fc]
movss dword [edx + 0x74], xmm0
mov eax, dword [ebp - 0xe8]
movss xmm0, dword [0x102a61bc]
movss dword [eax + 0x78], xmm0
mov ecx, dword [ebp - 0xe8]
movss xmm0, dword [0x102a6194]
movss dword [ecx + 0x70], xmm0
mov edx, dword [ebp - 0xe8]
mov dword [edx + 0x84], 0
mov eax, dword [ebp - 0xe8]
movss xmm0, dword [0x102a6038]
movss dword [eax + 0x7c], xmm0
lea ecx, [ebp - 0x3650]
push ecx
mov ecx, dword [ebp - 0xe8]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x12
lea ecx, [ebp - 0x3620]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x11
lea ecx, [ebp - 0x3638]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3650]
call fcn.100d2140
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x390
mov dword [ebp - 0x6c], edx
mov eax, dword [ebp - 0x6c]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x6c]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x6c]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x6c]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x6c]
mov eax, dword [ebp - 0xc0]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0xc0]
add edx, 0x18
mov dword [ebp - 0x2770], edx
lea eax, [ebp - 0x6c]
push eax
mov ecx, dword [ebp - 0x2770]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x44c
mov dword [ebp - 0x1ca4], ecx
mov edx, dword [0x103f85cc]
mov dword [ebp - 0x2774], edx
mov eax, dword [ebp - 0x2774]
mov dword [ebp - 0x2778], eax
mov ecx, dword [ebp - 0x2778]
mov dword [ebp - 0x27bc], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x6e8], cl
movsx edx, byte [ebp - 0x6e8]
xor edx, 0x34
mov byte [ebp - 0x6e9], dl
mov al, byte [ebp - 0x6e9]
mov byte [ebp - 0x21e8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.proj_range_color]
mov byte [ebp - 0x6f0], dl
movsx eax, byte [ebp - 0x6f0]
xor eax, 0x34
mov byte [ebp - 0x6f1], al
mov cl, byte [ebp - 0x6f1]
mov byte [ebp - 0x21e7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x6f8], al
movsx ecx, byte [ebp - 0x6f8]
xor ecx, 0x34
mov byte [ebp - 0x6f9], cl
mov dl, byte [ebp - 0x6f9]
mov byte [ebp - 0x21e6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.proj_range_color]
mov byte [ebp - 0x700], dl
movsx eax, byte [ebp - 0x700]
xor eax, 0x34
mov byte [ebp - 0x701], al
mov cl, byte [ebp - 0x701]
mov byte [ebp - 0x21e5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x708], al
movsx ecx, byte [ebp - 0x708]
xor ecx, 0x34
mov byte [ebp - 0x709], cl
mov dl, byte [ebp - 0x709]
mov byte [ebp - 0x21e4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.proj_range_color]
mov byte [ebp - 0x710], dl
movsx eax, byte [ebp - 0x710]
xor eax, 0x34
mov byte [ebp - 0x711], al
mov cl, byte [ebp - 0x711]
mov byte [ebp - 0x21e3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x718], cl
movsx edx, byte [ebp - 0x718]
xor edx, 0x34
mov byte [ebp - 0x719], dl
mov al, byte [ebp - 0x719]
mov byte [ebp - 0x21e2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x720], al
movsx ecx, byte [ebp - 0x720]
xor ecx, 0x34
mov byte [ebp - 0x721], cl
mov dl, byte [ebp - 0x721]
mov byte [ebp - 0x21e1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x728], cl
movsx edx, byte [ebp - 0x728]
xor edx, 0x34
mov byte [ebp - 0x729], dl
mov al, byte [ebp - 0x729]
mov byte [ebp - 0x21e0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x730], al
movsx ecx, byte [ebp - 0x730]
xor ecx, 0x34
mov byte [ebp - 0x731], cl
mov dl, byte [ebp - 0x731]
mov byte [ebp - 0x21df], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.proj_range_color]
mov byte [ebp - 0x738], dl
movsx eax, byte [ebp - 0x738]
xor eax, 0x34
mov byte [ebp - 0x739], al
mov cl, byte [ebp - 0x739]
mov byte [ebp - 0x21de], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x740], cl
movsx edx, byte [ebp - 0x740]
xor edx, 0x34
mov byte [ebp - 0x741], dl
mov al, byte [ebp - 0x741]
mov byte [ebp - 0x21dd], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x748], al
movsx ecx, byte [ebp - 0x748]
xor ecx, 0x34
mov byte [ebp - 0x749], cl
mov dl, byte [ebp - 0x749]
mov byte [ebp - 0x21dc], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.proj_range_color]
mov byte [ebp - 0x750], dl
movsx eax, byte [ebp - 0x750]
xor eax, 0x34
mov byte [ebp - 0x751], al
mov cl, byte [ebp - 0x751]
mov byte [ebp - 0x21db], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x758], cl
movsx edx, byte [ebp - 0x758]
xor edx, 0x34
mov byte [ebp - 0x759], dl
mov al, byte [ebp - 0x759]
mov byte [ebp - 0x21da], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.proj_range_color]
mov byte [ebp - 0x760], al
movsx ecx, byte [ebp - 0x760]
xor ecx, 0x34
mov byte [ebp - 0x761], cl
mov dl, byte [ebp - 0x761]
mov byte [ebp - 0x21d9], dl
mov eax, 1
shl eax, 4
mov cl, byte [eax + str.proj_range_color]
mov byte [ebp - 0x768], cl
movsx edx, byte [ebp - 0x768]
xor edx, 0x34
mov byte [ebp - 0x769], dl
mov al, byte [ebp - 0x769]
mov byte [ebp - 0x21d8], al
lea ecx, [ebp - 0x21e8]
mov dword [ebp - 0x277c], ecx
mov edx, dword [ebp - 0x277c]
mov dword [ebp - 0x24f0], edx
mov dword [ebp - 0x1e68], 0
jmp 0x101526a6
mov eax, dword [ebp - 0x1e68]
add eax, 1
mov dword [ebp - 0x1e68], eax
cmp dword [ebp - 0x1e68], 0x11
jae 0x10152728
mov ecx, dword [ebp - 0x24f0]
mov dword [ebp - 0x2780], ecx
mov edx, dword [ebp - 0x2780]
add edx, dword [ebp - 0x1e68]
mov dword [ebp - 0x2784], edx
mov eax, dword [ebp - 0x2784]
mov cl, byte [eax]
mov byte [ebp - 0x770], cl
movsx edx, byte [ebp - 0x770]
xor edx, 0x34
mov byte [ebp - 0x771], dl
mov al, byte [ebp - 0x771]
mov byte [ebp - 0x772], al
mov ecx, dword [ebp - 0x24f0]
mov dword [ebp - 0x2788], ecx
mov edx, dword [ebp - 0x2788]
add edx, dword [ebp - 0x1e68]
mov dword [ebp - 0x278c], edx
mov eax, dword [ebp - 0x278c]
mov cl, byte [ebp - 0x772]
mov byte [eax], cl
jmp 0x10152697
mov edx, dword [ebp - 0x24f0]
mov dword [ebp - 0x2790], edx
mov eax, dword [ebp - 0x2790]
mov dword [ebp - 0x2794], eax
mov ecx, dword [ebp - 0x2794]
mov dword [ebp - 0x2798], ecx
mov edx, dword [ebp - 0x2798]
push edx
lea ecx, [ebp - 0x3680]
call fcn.1007b880
mov dword [ebp - 4], 0x14
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.color]
mov byte [ebp - 0x778], dl
movsx eax, byte [ebp - 0x778]
xor eax, 0x34
mov byte [ebp - 0x779], al
mov cl, byte [ebp - 0x779]
mov byte [ebp - 0x2018], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.color]
mov byte [ebp - 0x780], al
movsx ecx, byte [ebp - 0x780]
xor ecx, 0x34
mov byte [ebp - 0x781], cl
mov dl, byte [ebp - 0x781]
mov byte [ebp - 0x2017], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.color]
mov byte [ebp - 0x788], cl
movsx edx, byte [ebp - 0x788]
xor edx, 0x34
mov byte [ebp - 0x789], dl
mov al, byte [ebp - 0x789]
mov byte [ebp - 0x2016], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.color]
mov byte [ebp - 0x790], al
movsx ecx, byte [ebp - 0x790]
xor ecx, 0x34
mov byte [ebp - 0x791], cl
mov dl, byte [ebp - 0x791]
mov byte [ebp - 0x2015], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.color]
mov byte [ebp - 0x798], cl
movsx edx, byte [ebp - 0x798]
xor edx, 0x34
mov byte [ebp - 0x799], dl
mov al, byte [ebp - 0x799]
mov byte [ebp - 0x2014], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.color]
mov byte [ebp - 0x7a0], al
movsx ecx, byte [ebp - 0x7a0]
xor ecx, 0x34
mov byte [ebp - 0x7a1], cl
mov dl, byte [ebp - 0x7a1]
mov byte [ebp - 0x2013], dl
lea eax, [ebp - 0x2018]
mov dword [ebp - 0x279c], eax
mov ecx, dword [ebp - 0x279c]
mov dword [ebp - 0x24e4], ecx
mov dword [ebp - 0x1e6c], 0
jmp 0x101528b7
mov edx, dword [ebp - 0x1e6c]
add edx, 1
mov dword [ebp - 0x1e6c], edx
cmp dword [ebp - 0x1e6c], 6
jae 0x10152939
mov eax, dword [ebp - 0x24e4]
mov dword [ebp - 0x27a0], eax
mov ecx, dword [ebp - 0x27a0]
add ecx, dword [ebp - 0x1e6c]
mov dword [ebp - 0x27a4], ecx
mov edx, dword [ebp - 0x27a4]
mov al, byte [edx]
mov byte [ebp - 0x7a8], al
movsx ecx, byte [ebp - 0x7a8]
xor ecx, 0x34
mov byte [ebp - 0x7a9], cl
mov dl, byte [ebp - 0x7a9]
mov byte [ebp - 0x7aa], dl
mov eax, dword [ebp - 0x24e4]
mov dword [ebp - 0x27a8], eax
mov ecx, dword [ebp - 0x27a8]
add ecx, dword [ebp - 0x1e6c]
mov dword [ebp - 0x27ac], ecx
mov edx, dword [ebp - 0x27ac]
mov al, byte [ebp - 0x7aa]
mov byte [edx], al
jmp 0x101528a8
mov ecx, dword [ebp - 0x24e4]
mov dword [ebp - 0x27b0], ecx
mov edx, dword [ebp - 0x27b0]
mov dword [ebp - 0x27b4], edx
mov eax, dword [ebp - 0x27b4]
mov dword [ebp - 0x27b8], eax
mov ecx, dword [ebp - 0x27b8]
push ecx
lea ecx, [ebp - 0x3668]
call fcn.1007b880
mov byte [ebp - 4], 0x15
lea edx, [ebp - 0x3668]
push edx
mov ecx, dword [ebp - 0x1ca4]
add ecx, 0x70
call fcn.1008d0b0
lea eax, [ebp - 0x3680]
push eax
mov ecx, dword [ebp - 0x1ca4]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x1ca4]
mov edx, dword [ebp - 0x27bc]
mov dword [ecx + 0x88], edx
mov eax, dword [ebp - 0x1ca4]
mov dword [eax + 0x8c], 0
mov ecx, dword [ebp - 0x1ca4]
cmp dword [ecx + 0x8c], 0
je 0x101529e8
mov edx, dword [ebp - 0x1ca4]
mov eax, dword [edx + 0x88]
mov ecx, dword [ebp - 0x1ca4]
mov edx, dword [ecx + 0x8c]
mov dword [edx], eax
mov byte [ebp - 4], 0x14
lea ecx, [ebp - 0x3668]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3680]
call fcn.1007c260
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x44c
mov dword [ebp - 0x70], eax
mov ecx, dword [ebp - 0x70]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x70]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x70]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x70]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x70]
mov ecx, dword [ebp - 0xc0]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0xc0]
add eax, 0x18
mov dword [ebp - 0x27c0], eax
lea ecx, [ebp - 0x70]
push ecx
mov ecx, dword [ebp - 0x27c0]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x4dc
mov dword [ebp - 0xcc], edx
lea eax, [ebp - 0x2448]
mov dword [ebp - 0x27c4], eax
mov ecx, dword [ebp - 0x27c4]
mov dword [ebp - 0x280c], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.on_screen__2D_]
mov byte [ebp - 0x7b0], cl
movsx edx, byte [ebp - 0x7b0]
xor edx, 0x34
mov byte [ebp - 0x7b1], dl
mov al, byte [ebp - 0x7b1]
mov byte [ebp - 0x2190], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.on_screen__2D_]
mov byte [ebp - 0x7b8], dl
movsx eax, byte [ebp - 0x7b8]
xor eax, 0x34
mov byte [ebp - 0x7b9], al
mov cl, byte [ebp - 0x7b9]
mov byte [ebp - 0x218f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.on_screen__2D_]
mov byte [ebp - 0x7c0], al
movsx ecx, byte [ebp - 0x7c0]
xor ecx, 0x34
mov byte [ebp - 0x7c1], cl
mov dl, byte [ebp - 0x7c1]
mov byte [ebp - 0x218e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.on_screen__2D_]
mov byte [ebp - 0x7c8], dl
movsx eax, byte [ebp - 0x7c8]
xor eax, 0x34
mov byte [ebp - 0x7c9], al
mov cl, byte [ebp - 0x7c9]
mov byte [ebp - 0x218d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.on_screen__2D_]
mov byte [ebp - 0x7d0], al
movsx ecx, byte [ebp - 0x7d0]
xor ecx, 0x34
mov byte [ebp - 0x7d1], cl
mov dl, byte [ebp - 0x7d1]
mov byte [ebp - 0x218c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.on_screen__2D_]
mov byte [ebp - 0x7d8], dl
movsx eax, byte [ebp - 0x7d8]
xor eax, 0x34
mov byte [ebp - 0x7d9], al
mov cl, byte [ebp - 0x7d9]
mov byte [ebp - 0x218b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.on_screen__2D_]
mov byte [ebp - 0x7e0], cl
movsx edx, byte [ebp - 0x7e0]
xor edx, 0x34
mov byte [ebp - 0x7e1], dl
mov al, byte [ebp - 0x7e1]
mov byte [ebp - 0x218a], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.on_screen__2D_]
mov byte [ebp - 0x7e8], al
movsx ecx, byte [ebp - 0x7e8]
xor ecx, 0x34
mov byte [ebp - 0x7e9], cl
mov dl, byte [ebp - 0x7e9]
mov byte [ebp - 0x2189], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.on_screen__2D_]
mov byte [ebp - 0x7f0], cl
movsx edx, byte [ebp - 0x7f0]
xor edx, 0x34
mov byte [ebp - 0x7f1], dl
mov al, byte [ebp - 0x7f1]
mov byte [ebp - 0x2188], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.on_screen__2D_]
mov byte [ebp - 0x7f8], al
movsx ecx, byte [ebp - 0x7f8]
xor ecx, 0x34
mov byte [ebp - 0x7f9], cl
mov dl, byte [ebp - 0x7f9]
mov byte [ebp - 0x2187], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.on_screen__2D_]
mov byte [ebp - 0x800], dl
movsx eax, byte [ebp - 0x800]
xor eax, 0x34
mov byte [ebp - 0x801], al
mov cl, byte [ebp - 0x801]
mov byte [ebp - 0x2186], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.on_screen__2D_]
mov byte [ebp - 0x808], cl
movsx edx, byte [ebp - 0x808]
xor edx, 0x34
mov byte [ebp - 0x809], dl
mov al, byte [ebp - 0x809]
mov byte [ebp - 0x2185], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.on_screen__2D_]
mov byte [ebp - 0x810], al
movsx ecx, byte [ebp - 0x810]
xor ecx, 0x34
mov byte [ebp - 0x811], cl
mov dl, byte [ebp - 0x811]
mov byte [ebp - 0x2184], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.on_screen__2D_]
mov byte [ebp - 0x818], dl
movsx eax, byte [ebp - 0x818]
xor eax, 0x34
mov byte [ebp - 0x819], al
mov cl, byte [ebp - 0x819]
mov byte [ebp - 0x2183], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.on_screen__2D_]
mov byte [ebp - 0x820], cl
movsx edx, byte [ebp - 0x820]
xor edx, 0x34
mov byte [ebp - 0x821], dl
mov al, byte [ebp - 0x821]
mov byte [ebp - 0x2182], al
lea ecx, [ebp - 0x2190]
mov dword [ebp - 0x27c8], ecx
mov edx, dword [ebp - 0x27c8]
mov dword [ebp - 0x24e0], edx
mov dword [ebp - 0x1e70], 0
jmp 0x10152d9a
mov eax, dword [ebp - 0x1e70]
add eax, 1
mov dword [ebp - 0x1e70], eax
cmp dword [ebp - 0x1e70], 0xf
jae 0x10152e1c
mov ecx, dword [ebp - 0x24e0]
mov dword [ebp - 0x27cc], ecx
mov edx, dword [ebp - 0x27cc]
add edx, dword [ebp - 0x1e70]
mov dword [ebp - 0x27d0], edx
mov eax, dword [ebp - 0x27d0]
mov cl, byte [eax]
mov byte [ebp - 0x828], cl
movsx edx, byte [ebp - 0x828]
xor edx, 0x34
mov byte [ebp - 0x829], dl
mov al, byte [ebp - 0x829]
mov byte [ebp - 0x82a], al
mov ecx, dword [ebp - 0x24e0]
mov dword [ebp - 0x27d4], ecx
mov edx, dword [ebp - 0x27d4]
add edx, dword [ebp - 0x1e70]
mov dword [ebp - 0x27d8], edx
mov eax, dword [ebp - 0x27d8]
mov cl, byte [ebp - 0x82a]
mov byte [eax], cl
jmp 0x10152d8b
mov edx, dword [ebp - 0x24e0]
mov dword [ebp - 0x27dc], edx
mov eax, dword [ebp - 0x27dc]
mov dword [ebp - 0x27e0], eax
mov ecx, dword [ebp - 0x27e0]
mov dword [ebp - 0x27e4], ecx
mov edx, dword [ebp - 0x27e4]
push edx
lea ecx, [ebp - 0x3d28]
call fcn.1007b880
mov dword [ebp - 4], 0x16
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.on_bomb__3D_]
mov byte [ebp - 0x830], dl
movsx eax, byte [ebp - 0x830]
xor eax, 0x34
mov byte [ebp - 0x831], al
mov cl, byte [ebp - 0x831]
mov byte [ebp - 0x2150], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.on_bomb__3D_]
mov byte [ebp - 0x838], al
movsx ecx, byte [ebp - 0x838]
xor ecx, 0x34
mov byte [ebp - 0x839], cl
mov dl, byte [ebp - 0x839]
mov byte [ebp - 0x214f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.on_bomb__3D_]
mov byte [ebp - 0x840], cl
movsx edx, byte [ebp - 0x840]
xor edx, 0x34
mov byte [ebp - 0x841], dl
mov al, byte [ebp - 0x841]
mov byte [ebp - 0x214e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.on_bomb__3D_]
mov byte [ebp - 0x848], al
movsx ecx, byte [ebp - 0x848]
xor ecx, 0x34
mov byte [ebp - 0x849], cl
mov dl, byte [ebp - 0x849]
mov byte [ebp - 0x214d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.on_bomb__3D_]
mov byte [ebp - 0x850], cl
movsx edx, byte [ebp - 0x850]
xor edx, 0x34
mov byte [ebp - 0x851], dl
mov al, byte [ebp - 0x851]
mov byte [ebp - 0x214c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.on_bomb__3D_]
mov byte [ebp - 0x858], al
movsx ecx, byte [ebp - 0x858]
xor ecx, 0x34
mov byte [ebp - 0x859], cl
mov dl, byte [ebp - 0x859]
mov byte [ebp - 0x214b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.on_bomb__3D_]
mov byte [ebp - 0x860], dl
movsx eax, byte [ebp - 0x860]
xor eax, 0x34
mov byte [ebp - 0x861], al
mov cl, byte [ebp - 0x861]
mov byte [ebp - 0x214a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.on_bomb__3D_]
mov byte [ebp - 0x868], cl
movsx edx, byte [ebp - 0x868]
xor edx, 0x34
mov byte [ebp - 0x869], dl
mov al, byte [ebp - 0x869]
mov byte [ebp - 0x2149], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.on_bomb__3D_]
mov byte [ebp - 0x870], dl
movsx eax, byte [ebp - 0x870]
xor eax, 0x34
mov byte [ebp - 0x871], al
mov cl, byte [ebp - 0x871]
mov byte [ebp - 0x2148], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.on_bomb__3D_]
mov byte [ebp - 0x878], cl
movsx edx, byte [ebp - 0x878]
xor edx, 0x34
mov byte [ebp - 0x879], dl
mov al, byte [ebp - 0x879]
mov byte [ebp - 0x2147], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.on_bomb__3D_]
mov byte [ebp - 0x880], al
movsx ecx, byte [ebp - 0x880]
xor ecx, 0x34
mov byte [ebp - 0x881], cl
mov dl, byte [ebp - 0x881]
mov byte [ebp - 0x2146], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.on_bomb__3D_]
mov byte [ebp - 0x888], dl
movsx eax, byte [ebp - 0x888]
xor eax, 0x34
mov byte [ebp - 0x889], al
mov cl, byte [ebp - 0x889]
mov byte [ebp - 0x2145], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.on_bomb__3D_]
mov byte [ebp - 0x890], cl
movsx edx, byte [ebp - 0x890]
xor edx, 0x34
mov byte [ebp - 0x891], dl
mov al, byte [ebp - 0x891]
mov byte [ebp - 0x2144], al
lea ecx, [ebp - 0x2150]
mov dword [ebp - 0x27e8], ecx
mov edx, dword [ebp - 0x27e8]
mov dword [ebp - 0x24d4], edx
mov dword [ebp - 0x1e74], 0
jmp 0x101530fb
mov eax, dword [ebp - 0x1e74]
add eax, 1
mov dword [ebp - 0x1e74], eax
cmp dword [ebp - 0x1e74], 0xd
jae 0x1015317d
mov ecx, dword [ebp - 0x24d4]
mov dword [ebp - 0x27ec], ecx
mov edx, dword [ebp - 0x27ec]
add edx, dword [ebp - 0x1e74]
mov dword [ebp - 0x27f0], edx
mov eax, dword [ebp - 0x27f0]
mov cl, byte [eax]
mov byte [ebp - 0x898], cl
movsx edx, byte [ebp - 0x898]
xor edx, 0x34
mov byte [ebp - 0x899], dl
mov al, byte [ebp - 0x899]
mov byte [ebp - 0x89a], al
mov ecx, dword [ebp - 0x24d4]
mov dword [ebp - 0x27f4], ecx
mov edx, dword [ebp - 0x27f4]
add edx, dword [ebp - 0x1e74]
mov dword [ebp - 0x27f8], edx
mov eax, dword [ebp - 0x27f8]
mov cl, byte [ebp - 0x89a]
mov byte [eax], cl
jmp 0x101530ec
mov edx, dword [ebp - 0x24d4]
mov dword [ebp - 0x27fc], edx
mov eax, dword [ebp - 0x27fc]
mov dword [ebp - 0x2800], eax
mov ecx, dword [ebp - 0x2800]
mov dword [ebp - 0x2804], ecx
mov edx, dword [ebp - 0x2804]
push edx
lea ecx, [ebp - 0x3d10]
call fcn.1007b880
mov dword [ebp - 4], 0x17
lea eax, [ebp - 0x3d28]
mov dword [ebp - 0x33d8], eax
lea ecx, [ebp - 0x3cf8]
mov dword [ebp - 0x33d4], ecx
lea edx, [ebp - 0x33d8]
mov dword [ebp - 0x2808], edx
mov eax, dword [ebp - 0x2808]
mov ecx, dword [eax]
mov edx, dword [eax + 4]
mov dword [ebp - 0x3290], ecx
mov dword [ebp - 0x328c], edx
mov eax, dword [ebp - 0x280c]
push eax
mov ecx, dword [ebp - 0x328c]
push ecx
mov edx, dword [ebp - 0x3290]
push edx
lea ecx, [ebp - 0x346c]
call fcn.101ed250
mov byte [ebp - 4], 0x18
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x102a3518]
mov byte [ebp - 0x8a0], dl
movsx eax, byte [ebp - 0x8a0]
xor eax, 0x34
mov byte [ebp - 0x8a1], al
mov cl, byte [ebp - 0x8a1]
mov byte [ebp - 0x2098], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x102a3518]
mov byte [ebp - 0x8a8], al
movsx ecx, byte [ebp - 0x8a8]
xor ecx, 0x34
mov byte [ebp - 0x8a9], cl
mov dl, byte [ebp - 0x8a9]
mov byte [ebp - 0x2097], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x102a3518]
mov byte [ebp - 0x8b0], cl
movsx edx, byte [ebp - 0x8b0]
xor edx, 0x34
mov byte [ebp - 0x8b1], dl
mov al, byte [ebp - 0x8b1]
mov byte [ebp - 0x2096], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x102a3518]
mov byte [ebp - 0x8b8], al
movsx ecx, byte [ebp - 0x8b8]
xor ecx, 0x34
mov byte [ebp - 0x8b9], cl
mov dl, byte [ebp - 0x8b9]
mov byte [ebp - 0x2095], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x102a3518]
mov byte [ebp - 0x8c0], cl
movsx edx, byte [ebp - 0x8c0]
xor edx, 0x34
mov byte [ebp - 0x8c1], dl
mov al, byte [ebp - 0x8c1]
mov byte [ebp - 0x2094], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x102a3518]
mov byte [ebp - 0x8c8], al
movsx ecx, byte [ebp - 0x8c8]
xor ecx, 0x34
mov byte [ebp - 0x8c9], cl
mov dl, byte [ebp - 0x8c9]
mov byte [ebp - 0x2093], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x102a3518]
mov byte [ebp - 0x8d0], dl
movsx eax, byte [ebp - 0x8d0]
xor eax, 0x34
mov byte [ebp - 0x8d1], al
mov cl, byte [ebp - 0x8d1]
mov byte [ebp - 0x2092], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x102a3518]
mov byte [ebp - 0x8d8], cl
movsx edx, byte [ebp - 0x8d8]
xor edx, 0x34
mov byte [ebp - 0x8d9], dl
mov al, byte [ebp - 0x8d9]
mov byte [ebp - 0x2091], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x102a3518]
mov byte [ebp - 0x8e0], dl
movsx eax, byte [ebp - 0x8e0]
xor eax, 0x34
mov byte [ebp - 0x8e1], al
mov cl, byte [ebp - 0x8e1]
mov byte [ebp - 0x2090], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + 0x102a3518]
mov byte [ebp - 0x8e8], cl
movsx edx, byte [ebp - 0x8e8]
xor edx, 0x34
mov byte [ebp - 0x8e9], dl
mov al, byte [ebp - 0x8e9]
mov byte [ebp - 0x208f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + 0x102a3518]
mov byte [ebp - 0x8f0], al
movsx ecx, byte [ebp - 0x8f0]
xor ecx, 0x34
mov byte [ebp - 0x8f1], cl
mov dl, byte [ebp - 0x8f1]
mov byte [ebp - 0x208e], dl
lea eax, [ebp - 0x2098]
mov dword [ebp - 0x2810], eax
mov ecx, dword [ebp - 0x2810]
mov dword [ebp - 0x24d0], ecx
mov dword [ebp - 0x1e78], 0
jmp 0x1015345b
mov edx, dword [ebp - 0x1e78]
add edx, 1
mov dword [ebp - 0x1e78], edx
cmp dword [ebp - 0x1e78], 0xb
jae 0x101534dd
mov eax, dword [ebp - 0x24d0]
mov dword [ebp - 0x2814], eax
mov ecx, dword [ebp - 0x2814]
add ecx, dword [ebp - 0x1e78]
mov dword [ebp - 0x2818], ecx
mov edx, dword [ebp - 0x2818]
mov al, byte [edx]
mov byte [ebp - 0x8f8], al
movsx ecx, byte [ebp - 0x8f8]
xor ecx, 0x34
mov byte [ebp - 0x8f9], cl
mov dl, byte [ebp - 0x8f9]
mov byte [ebp - 0x8fa], dl
mov eax, dword [ebp - 0x24d0]
mov dword [ebp - 0x281c], eax
mov ecx, dword [ebp - 0x281c]
add ecx, dword [ebp - 0x1e78]
mov dword [ebp - 0x2820], ecx
mov edx, dword [ebp - 0x2820]
mov al, byte [ebp - 0x8fa]
mov byte [edx], al
jmp 0x1015344c
mov ecx, dword [ebp - 0x24d0]
mov dword [ebp - 0x2824], ecx
mov edx, dword [ebp - 0x2824]
mov dword [ebp - 0x2828], edx
mov eax, dword [ebp - 0x2828]
mov dword [ebp - 0x282c], eax
mov ecx, dword [ebp - 0x282c]
push ecx
lea ecx, [ebp - 0x36b0]
call fcn.1007b880
mov byte [ebp - 4], 0x19
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.planted_c4]
mov byte [ebp - 0x900], cl
movsx edx, byte [ebp - 0x900]
xor edx, 0x34
mov byte [ebp - 0x901], dl
mov al, byte [ebp - 0x901]
mov byte [ebp - 0x20c8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.planted_c4]
mov byte [ebp - 0x908], dl
movsx eax, byte [ebp - 0x908]
xor eax, 0x34
mov byte [ebp - 0x909], al
mov cl, byte [ebp - 0x909]
mov byte [ebp - 0x20c7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.planted_c4]
mov byte [ebp - 0x910], al
movsx ecx, byte [ebp - 0x910]
xor ecx, 0x34
mov byte [ebp - 0x911], cl
mov dl, byte [ebp - 0x911]
mov byte [ebp - 0x20c6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.planted_c4]
mov byte [ebp - 0x918], dl
movsx eax, byte [ebp - 0x918]
xor eax, 0x34
mov byte [ebp - 0x919], al
mov cl, byte [ebp - 0x919]
mov byte [ebp - 0x20c5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.planted_c4]
mov byte [ebp - 0x920], al
movsx ecx, byte [ebp - 0x920]
xor ecx, 0x34
mov byte [ebp - 0x921], cl
mov dl, byte [ebp - 0x921]
mov byte [ebp - 0x20c4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.planted_c4]
mov byte [ebp - 0x928], dl
movsx eax, byte [ebp - 0x928]
xor eax, 0x34
mov byte [ebp - 0x929], al
mov cl, byte [ebp - 0x929]
mov byte [ebp - 0x20c3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.planted_c4]
mov byte [ebp - 0x930], cl
movsx edx, byte [ebp - 0x930]
xor edx, 0x34
mov byte [ebp - 0x931], dl
mov al, byte [ebp - 0x931]
mov byte [ebp - 0x20c2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.planted_c4]
mov byte [ebp - 0x938], al
movsx ecx, byte [ebp - 0x938]
xor ecx, 0x34
mov byte [ebp - 0x939], cl
mov dl, byte [ebp - 0x939]
mov byte [ebp - 0x20c1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.planted_c4]
mov byte [ebp - 0x940], cl
movsx edx, byte [ebp - 0x940]
xor edx, 0x34
mov byte [ebp - 0x941], dl
mov al, byte [ebp - 0x941]
mov byte [ebp - 0x20c0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.planted_c4]
mov byte [ebp - 0x948], al
movsx ecx, byte [ebp - 0x948]
xor ecx, 0x34
mov byte [ebp - 0x949], cl
mov dl, byte [ebp - 0x949]
mov byte [ebp - 0x20bf], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.planted_c4]
mov byte [ebp - 0x950], dl
movsx eax, byte [ebp - 0x950]
xor eax, 0x34
mov byte [ebp - 0x951], al
mov cl, byte [ebp - 0x951]
mov byte [ebp - 0x20be], cl
lea edx, [ebp - 0x20c8]
mov dword [ebp - 0x2830], edx
mov eax, dword [ebp - 0x2830]
mov dword [ebp - 0x24c8], eax
mov dword [ebp - 0x1e7c], 0
jmp 0x10153759
mov ecx, dword [ebp - 0x1e7c]
add ecx, 1
mov dword [ebp - 0x1e7c], ecx
cmp dword [ebp - 0x1e7c], 0xb
jae 0x101537db
mov edx, dword [ebp - 0x24c8]
mov dword [ebp - 0x2834], edx
mov eax, dword [ebp - 0x2834]
add eax, dword [ebp - 0x1e7c]
mov dword [ebp - 0x2838], eax
mov ecx, dword [ebp - 0x2838]
mov dl, byte [ecx]
mov byte [ebp - 0x958], dl
movsx eax, byte [ebp - 0x958]
xor eax, 0x34
mov byte [ebp - 0x959], al
mov cl, byte [ebp - 0x959]
mov byte [ebp - 0x95a], cl
mov edx, dword [ebp - 0x24c8]
mov dword [ebp - 0x283c], edx
mov eax, dword [ebp - 0x283c]
add eax, dword [ebp - 0x1e7c]
mov dword [ebp - 0x2840], eax
mov ecx, dword [ebp - 0x2840]
mov dl, byte [ebp - 0x95a]
mov byte [ecx], dl
jmp 0x1015374a
mov eax, dword [ebp - 0x24c8]
mov dword [ebp - 0x2844], eax
mov ecx, dword [ebp - 0x2844]
mov dword [ebp - 0x2848], ecx
mov edx, dword [ebp - 0x2848]
mov dword [ebp - 0x284c], edx
mov eax, dword [ebp - 0x284c]
push eax
lea ecx, [ebp - 0x3698]
call fcn.1007b880
mov byte [ebp - 4], 0x1a
lea ecx, [ebp - 0x3460]
mov dword [ebp - 0x24c4], ecx
mov edx, dword [ebp - 0x24c4]
mov dword [ebp - 0x2850], edx
mov ecx, dword [ebp - 0x2850]
call fcn.1007e520
nop
mov eax, dword [ebp - 0x24c4]
mov dword [ebp - 0x33e4], eax
mov ecx, dword [ebp - 0x24c4]
mov dword [ebp - 0x2854], ecx
mov edx, dword [ebp - 0x2854]
mov dword [ebp - 0x33e8], edx
mov byte [ebp - 4], 0x1b
lea eax, [ebp - 0x36b0]
push eax
mov ecx, dword [ebp - 0xcc]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0xcc]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0xcc]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x101538a4
lea ecx, [ebp - 0x3698]
push ecx
mov ecx, dword [ebp - 0xcc]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0xcc]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x101538be
mov dword [ebp - 0x2574], 0xf
jmp 0x101538c8
mov dword [ebp - 0x2574], 0
mov ecx, dword [ebp - 0xcc]
mov edx, dword [ebp - 0x2574]
mov dword [ecx + 0xa4], edx
mov eax, dword [ebp - 0xcc]
mov ecx, dword [eax + 0xa4]
add ecx, 0x14
mov dword [ebp - 0x2578], ecx
mov edx, dword [ebp - 0xcc]
mov eax, dword [ebp - 0x2578]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0xcc]
mov edx, dword [ebp - 0x2578]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x346c]
mov dword [ebp - 0x257c], eax
mov ecx, dword [ebp - 0x257c]
mov edx, dword [ecx]
mov dword [ebp - 0x2858], edx
mov eax, dword [ebp - 0x2858]
mov dword [ebp - 0x285c], eax
mov ecx, dword [ebp - 0x285c]
mov dword [ebp - 0x2860], ecx
mov edx, dword [ebp - 0x2860]
mov dword [ebp - 0x1fa4], edx
mov eax, dword [ebp - 0x257c]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x2864], ecx
mov edx, dword [ebp - 0x2864]
mov dword [ebp - 0x2868], edx
mov eax, dword [ebp - 0x2868]
mov dword [ebp - 0x286c], eax
mov ecx, dword [ebp - 0x286c]
mov dword [ebp - 0x2870], ecx
jmp 0x1015398f
mov edx, dword [ebp - 0x1fa4]
add edx, 0x18
mov dword [ebp - 0x1fa4], edx
mov eax, dword [ebp - 0x1fa4]
cmp eax, dword [ebp - 0x2870]
je 0x101539d0
mov ecx, dword [ebp - 0x1fa4]
mov dword [ebp - 0x2874], ecx
mov edx, dword [ebp - 0xcc]
add edx, 0x88
mov dword [ebp - 0x2878], edx
mov eax, dword [ebp - 0x2874]
push eax
mov ecx, dword [ebp - 0x2878]
call fcn.100d29a0
nop
jmp 0x10153980
lea ecx, [ebp - 0x3460]
mov dword [ebp - 0x2580], ecx
mov edx, dword [ebp - 0x2580]
mov eax, dword [edx]
mov dword [ebp - 0x287c], eax
mov ecx, dword [ebp - 0x287c]
mov dword [ebp - 0x2880], ecx
mov edx, dword [ebp - 0x2880]
mov dword [ebp - 0x2884], edx
mov eax, dword [ebp - 0x2884]
mov dword [ebp - 0x1fa8], eax
mov ecx, dword [ebp - 0x2580]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x2888], edx
mov eax, dword [ebp - 0x2888]
mov dword [ebp - 0x288c], eax
mov ecx, dword [ebp - 0x288c]
mov dword [ebp - 0x2890], ecx
mov edx, dword [ebp - 0x2890]
mov dword [ebp - 0x2894], edx
jmp 0x10153a52
mov eax, dword [ebp - 0x1fa8]
add eax, 4
mov dword [ebp - 0x1fa8], eax
mov ecx, dword [ebp - 0x1fa8]
cmp ecx, dword [ebp - 0x2894]
je 0x10153bea
mov edx, dword [ebp - 0x1fa8]
mov dword [ebp - 0x2898], edx
mov eax, dword [ebp - 0x2898]
mov ecx, dword [eax]
mov dword [ebp - 0x20], ecx
mov edx, dword [ebp - 0xcc]
add edx, 0x98
mov dword [ebp - 0x289c], edx
lea eax, [ebp - 0x33ec]
push eax
mov ecx, dword [ebp - 0x289c]
call fcn.1007a250
mov ecx, dword [eax]
mov dword [ebp - 0x28a4], ecx
mov edx, dword [ebp - 0xcc]
add edx, 0x98
mov dword [ebp - 0x28a0], edx
lea eax, [ebp - 0x33f0]
push eax
mov ecx, dword [ebp - 0x28a0]
call fcn.1007a290
mov ecx, dword [eax]
mov dword [ebp - 0x28a8], ecx
lea edx, [ebp - 0x20]
push edx
mov eax, dword [ebp - 0x28a4]
push eax
mov ecx, dword [ebp - 0x28a8]
push ecx
lea edx, [ebp - 0x33f4]
push edx
call fcn.1007d760
add esp, 0x10
mov dword [ebp - 0x28b0], eax
mov eax, dword [ebp - 0xcc]
add eax, 0x98
mov dword [ebp - 0x28ac], eax
lea ecx, [ebp - 0x33f8]
push ecx
mov ecx, dword [ebp - 0x28ac]
call fcn.1007a250
mov dword [ebp - 0x28b4], eax
mov edx, dword [ebp - 0x28b0]
mov eax, dword [ebp - 0x28b4]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x10153b41
mov dword [ebp - 0x2584], 1
jmp 0x10153b4b
mov dword [ebp - 0x2584], 0
mov dl, byte [ebp - 0x2584]
mov byte [ebp - 0x95b], dl
mov al, byte [ebp - 0x95b]
mov byte [ebp - 0x95c], al
mov ecx, dword [ebp - 0xcc]
add ecx, 0x88
mov dword [ebp - 0x2588], ecx
mov edx, dword [ebp - 0x2588]
mov eax, dword [ebp - 0x2588]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x28b8], eax
mov edx, dword [ebp - 0x28b8]
cmp dword [ebp - 0x20], edx
jae 0x10153bc2
mov eax, dword [ebp - 0xcc]
add eax, 0x98
mov dword [ebp - 0x28bc], eax
lea ecx, [ebp - 0x20]
push ecx
mov ecx, dword [ebp - 0x28bc]
call fcn.1007d7f0
nop
movzx edx, byte [ebp - 0x95c]
test edx, edx
je 0x10153be5
mov eax, dword [ebp - 0xcc]
cmp dword [eax + 0x64], 0
je 0x10153be5
mov ecx, dword [ebp - 0xcc]
mov edx, dword [ecx + 0x64]
call edx
nop
jmp 0x10153a43
mov byte [ebp - 4], 0x1a
lea ecx, [ebp - 0x3460]
call fcn.1007baa0
nop
mov byte [ebp - 4], 0x19
lea ecx, [ebp - 0x3698]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x18
lea ecx, [ebp - 0x36b0]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x17
lea ecx, [ebp - 0x346c]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 2
push 0x18
lea eax, [ebp - 0x3d28]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x4dc
mov dword [ebp - 0x74], ecx
mov edx, dword [ebp - 0x74]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x74]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x74]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x74]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x74]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x28c0], ecx
lea edx, [ebp - 0x74]
push edx
mov ecx, dword [ebp - 0x28c0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x584
mov dword [ebp - 0x1e88], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.disableteam]
mov byte [ebp - 0x960], al
movsx ecx, byte [ebp - 0x960]
xor ecx, 0x34
mov byte [ebp - 0x961], cl
mov dl, byte [ebp - 0x961]
mov byte [ebp - 0x2104], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.disableteam]
mov byte [ebp - 0x968], cl
movsx edx, byte [ebp - 0x968]
xor edx, 0x34
mov byte [ebp - 0x969], dl
mov al, byte [ebp - 0x969]
mov byte [ebp - 0x2103], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.disableteam]
mov byte [ebp - 0x970], dl
movsx eax, byte [ebp - 0x970]
xor eax, 0x34
mov byte [ebp - 0x971], al
mov cl, byte [ebp - 0x971]
mov byte [ebp - 0x2102], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.disableteam]
mov byte [ebp - 0x978], cl
movsx edx, byte [ebp - 0x978]
xor edx, 0x34
mov byte [ebp - 0x979], dl
mov al, byte [ebp - 0x979]
mov byte [ebp - 0x2101], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.disableteam]
mov byte [ebp - 0x980], dl
movsx eax, byte [ebp - 0x980]
xor eax, 0x34
mov byte [ebp - 0x981], al
mov cl, byte [ebp - 0x981]
mov byte [ebp - 0x2100], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.disableteam]
mov byte [ebp - 0x988], cl
movsx edx, byte [ebp - 0x988]
xor edx, 0x34
mov byte [ebp - 0x989], dl
mov al, byte [ebp - 0x989]
mov byte [ebp - 0x20ff], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.disableteam]
mov byte [ebp - 0x990], al
movsx ecx, byte [ebp - 0x990]
xor ecx, 0x34
mov byte [ebp - 0x991], cl
mov dl, byte [ebp - 0x991]
mov byte [ebp - 0x20fe], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.disableteam]
mov byte [ebp - 0x998], dl
movsx eax, byte [ebp - 0x998]
xor eax, 0x34
mov byte [ebp - 0x999], al
mov cl, byte [ebp - 0x999]
mov byte [ebp - 0x20fd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.disableteam]
mov byte [ebp - 0x9a0], al
movsx ecx, byte [ebp - 0x9a0]
xor ecx, 0x34
mov byte [ebp - 0x9a1], cl
mov dl, byte [ebp - 0x9a1]
mov byte [ebp - 0x20fc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.disableteam]
mov byte [ebp - 0x9a8], dl
movsx eax, byte [ebp - 0x9a8]
xor eax, 0x34
mov byte [ebp - 0x9a9], al
mov cl, byte [ebp - 0x9a9]
mov byte [ebp - 0x20fb], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.disableteam]
mov byte [ebp - 0x9b0], cl
movsx edx, byte [ebp - 0x9b0]
xor edx, 0x34
mov byte [ebp - 0x9b1], dl
mov al, byte [ebp - 0x9b1]
mov byte [ebp - 0x20fa], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.disableteam]
mov byte [ebp - 0x9b8], al
movsx ecx, byte [ebp - 0x9b8]
xor ecx, 0x34
mov byte [ebp - 0x9b9], cl
mov dl, byte [ebp - 0x9b9]
mov byte [ebp - 0x20f9], dl
lea eax, [ebp - 0x2104]
mov dword [ebp - 0x28c4], eax
mov ecx, dword [ebp - 0x28c4]
mov dword [ebp - 0x24bc], ecx
mov dword [ebp - 0x1e80], 0
jmp 0x10153f2e
mov edx, dword [ebp - 0x1e80]
add edx, 1
mov dword [ebp - 0x1e80], edx
cmp dword [ebp - 0x1e80], 0xc
jae 0x10153fb0
mov eax, dword [ebp - 0x24bc]
mov dword [ebp - 0x28c8], eax
mov ecx, dword [ebp - 0x28c8]
add ecx, dword [ebp - 0x1e80]
mov dword [ebp - 0x28cc], ecx
mov edx, dword [ebp - 0x28cc]
mov al, byte [edx]
mov byte [ebp - 0x9c0], al
movsx ecx, byte [ebp - 0x9c0]
xor ecx, 0x34
mov byte [ebp - 0x9c1], cl
mov dl, byte [ebp - 0x9c1]
mov byte [ebp - 0x9c2], dl
mov eax, dword [ebp - 0x24bc]
mov dword [ebp - 0x28d0], eax
mov ecx, dword [ebp - 0x28d0]
add ecx, dword [ebp - 0x1e80]
mov dword [ebp - 0x28d4], ecx
mov edx, dword [ebp - 0x28d4]
mov al, byte [ebp - 0x9c2]
mov byte [edx], al
jmp 0x10153f1f
mov ecx, dword [ebp - 0x24bc]
mov dword [ebp - 0x28d8], ecx
mov edx, dword [ebp - 0x28d8]
mov dword [ebp - 0x28dc], edx
mov eax, dword [ebp - 0x28dc]
mov dword [ebp - 0x28e0], eax
mov ecx, dword [ebp - 0x28e0]
push ecx
lea ecx, [ebp - 0x36e0]
call fcn.1007b880
mov dword [ebp - 4], 0x1c
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0x9c8], cl
movsx edx, byte [ebp - 0x9c8]
xor edx, 0x34
mov byte [ebp - 0x9c9], dl
mov al, byte [ebp - 0x9c9]
mov byte [ebp - 0x2304], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0x9d0], dl
movsx eax, byte [ebp - 0x9d0]
xor eax, 0x34
mov byte [ebp - 0x9d1], al
mov cl, byte [ebp - 0x9d1]
mov byte [ebp - 0x2303], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0x9d8], al
movsx ecx, byte [ebp - 0x9d8]
xor ecx, 0x34
mov byte [ebp - 0x9d9], cl
mov dl, byte [ebp - 0x9d9]
mov byte [ebp - 0x2302], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0x9e0], dl
movsx eax, byte [ebp - 0x9e0]
xor eax, 0x34
mov byte [ebp - 0x9e1], al
mov cl, byte [ebp - 0x9e1]
mov byte [ebp - 0x2301], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0x9e8], al
movsx ecx, byte [ebp - 0x9e8]
xor ecx, 0x34
mov byte [ebp - 0x9e9], cl
mov dl, byte [ebp - 0x9e9]
mov byte [ebp - 0x2300], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0x9f0], dl
movsx eax, byte [ebp - 0x9f0]
xor eax, 0x34
mov byte [ebp - 0x9f1], al
mov cl, byte [ebp - 0x9f1]
mov byte [ebp - 0x22ff], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0x9f8], cl
movsx edx, byte [ebp - 0x9f8]
xor edx, 0x34
mov byte [ebp - 0x9f9], dl
mov al, byte [ebp - 0x9f9]
mov byte [ebp - 0x22fe], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa00], al
movsx ecx, byte [ebp - 0xa00]
xor ecx, 0x34
mov byte [ebp - 0xa01], cl
mov dl, byte [ebp - 0xa01]
mov byte [ebp - 0x22fd], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa08], cl
movsx edx, byte [ebp - 0xa08]
xor edx, 0x34
mov byte [ebp - 0xa09], dl
mov al, byte [ebp - 0xa09]
mov byte [ebp - 0x22fc], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa10], al
movsx ecx, byte [ebp - 0xa10]
xor ecx, 0x34
mov byte [ebp - 0xa11], cl
mov dl, byte [ebp - 0xa11]
mov byte [ebp - 0x22fb], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0xa18], dl
movsx eax, byte [ebp - 0xa18]
xor eax, 0x34
mov byte [ebp - 0xa19], al
mov cl, byte [ebp - 0xa19]
mov byte [ebp - 0x22fa], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa20], cl
movsx edx, byte [ebp - 0xa20]
xor edx, 0x34
mov byte [ebp - 0xa21], dl
mov al, byte [ebp - 0xa21]
mov byte [ebp - 0x22f9], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa28], al
movsx ecx, byte [ebp - 0xa28]
xor ecx, 0x34
mov byte [ebp - 0xa29], cl
mov dl, byte [ebp - 0xa29]
mov byte [ebp - 0x22f8], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0xa30], dl
movsx eax, byte [ebp - 0xa30]
xor eax, 0x34
mov byte [ebp - 0xa31], al
mov cl, byte [ebp - 0xa31]
mov byte [ebp - 0x22f7], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa38], cl
movsx edx, byte [ebp - 0xa38]
xor edx, 0x34
mov byte [ebp - 0xa39], dl
mov al, byte [ebp - 0xa39]
mov byte [ebp - 0x22f6], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa40], al
movsx ecx, byte [ebp - 0xa40]
xor ecx, 0x34
mov byte [ebp - 0xa41], cl
mov dl, byte [ebp - 0xa41]
mov byte [ebp - 0x22f5], dl
mov eax, 1
shl eax, 4
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa48], cl
movsx edx, byte [ebp - 0xa48]
xor edx, 0x34
mov byte [ebp - 0xa49], dl
mov al, byte [ebp - 0xa49]
mov byte [ebp - 0x22f4], al
mov ecx, 1
imul edx, ecx, 0x11
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa50], al
movsx ecx, byte [ebp - 0xa50]
xor ecx, 0x34
mov byte [ebp - 0xa51], cl
mov dl, byte [ebp - 0xa51]
mov byte [ebp - 0x22f3], dl
mov eax, 1
imul ecx, eax, 0x12
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0xa58], dl
movsx eax, byte [ebp - 0xa58]
xor eax, 0x34
mov byte [ebp - 0xa59], al
mov cl, byte [ebp - 0xa59]
mov byte [ebp - 0x22f2], cl
mov edx, 1
imul eax, edx, 0x13
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa60], cl
movsx edx, byte [ebp - 0xa60]
xor edx, 0x34
mov byte [ebp - 0xa61], dl
mov al, byte [ebp - 0xa61]
mov byte [ebp - 0x22f1], al
mov ecx, 1
imul edx, ecx, 0x14
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa68], al
movsx ecx, byte [ebp - 0xa68]
xor ecx, 0x34
mov byte [ebp - 0xa69], cl
mov dl, byte [ebp - 0xa69]
mov byte [ebp - 0x22f0], dl
mov eax, 1
imul ecx, eax, 0x15
mov dl, byte [ecx + str.do_not_render_teammates]
mov byte [ebp - 0xa70], dl
movsx eax, byte [ebp - 0xa70]
xor eax, 0x34
mov byte [ebp - 0xa71], al
mov cl, byte [ebp - 0xa71]
mov byte [ebp - 0x22ef], cl
mov edx, 1
imul eax, edx, 0x16
mov cl, byte [eax + str.do_not_render_teammates]
mov byte [ebp - 0xa78], cl
movsx edx, byte [ebp - 0xa78]
xor edx, 0x34
mov byte [ebp - 0xa79], dl
mov al, byte [ebp - 0xa79]
mov byte [ebp - 0x22ee], al
mov ecx, 1
imul edx, ecx, 0x17
mov al, byte [edx + str.do_not_render_teammates]
mov byte [ebp - 0xa80], al
movsx ecx, byte [ebp - 0xa80]
xor ecx, 0x34
mov byte [ebp - 0xa81], cl
mov dl, byte [ebp - 0xa81]
mov byte [ebp - 0x22ed], dl
lea eax, [ebp - 0x2304]
mov dword [ebp - 0x28e4], eax
mov ecx, dword [ebp - 0x28e4]
mov dword [ebp - 0x24b8], ecx
mov dword [ebp - 0x1dcc], 0
jmp 0x1015449f
mov edx, dword [ebp - 0x1dcc]
add edx, 1
mov dword [ebp - 0x1dcc], edx
cmp dword [ebp - 0x1dcc], 0x18
jae 0x10154521
mov eax, dword [ebp - 0x24b8]
mov dword [ebp - 0x28e8], eax
mov ecx, dword [ebp - 0x28e8]
add ecx, dword [ebp - 0x1dcc]
mov dword [ebp - 0x28ec], ecx
mov edx, dword [ebp - 0x28ec]
mov al, byte [edx]
mov byte [ebp - 0xa88], al
movsx ecx, byte [ebp - 0xa88]
xor ecx, 0x34
mov byte [ebp - 0xa89], cl
mov dl, byte [ebp - 0xa89]
mov byte [ebp - 0xa8a], dl
mov eax, dword [ebp - 0x24b8]
mov dword [ebp - 0x28f0], eax
mov ecx, dword [ebp - 0x28f0]
add ecx, dword [ebp - 0x1dcc]
mov dword [ebp - 0x28f4], ecx
mov edx, dword [ebp - 0x28f4]
mov al, byte [ebp - 0xa8a]
mov byte [edx], al
jmp 0x10154490
mov ecx, dword [ebp - 0x24b8]
mov dword [ebp - 0x28f8], ecx
mov edx, dword [ebp - 0x28f8]
mov dword [ebp - 0x28fc], edx
mov eax, dword [ebp - 0x28fc]
mov dword [ebp - 0x2900], eax
mov ecx, dword [ebp - 0x2900]
push ecx
lea ecx, [ebp - 0x36c8]
call fcn.1007b880
mov byte [ebp - 4], 0x1d
lea edx, [ebp - 0x36e0]
push edx
mov ecx, dword [ebp - 0x1e88]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x1e88]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x1e88]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1015459e
lea eax, [ebp - 0x36c8]
push eax
mov ecx, dword [ebp - 0x1e88]
add ecx, 0x70
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x1e88]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 0x1c
lea ecx, [ebp - 0x36c8]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x36e0]
call fcn.1007c260
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x584
mov dword [ebp - 0x78], edx
mov eax, dword [ebp - 0x78]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x78]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x78]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x78]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x78]
mov eax, dword [ebp - 0xc0]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0xc0]
add edx, 0x18
mov dword [ebp - 0x2904], edx
lea eax, [ebp - 0x78]
push eax
mov ecx, dword [ebp - 0x2904]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x60c
mov dword [ebp - 0xf4], ecx
lea edx, [ebp - 0x2447]
mov dword [ebp - 0x2908], edx
mov eax, dword [ebp - 0x2908]
mov dword [ebp - 0x2970], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0xa90], al
movsx ecx, byte [ebp - 0xa90]
xor ecx, 0x34
mov byte [ebp - 0xa91], cl
mov dl, byte [ebp - 0xa91]
mov byte [ebp - 0x1fa0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x102a28c0]
mov byte [ebp - 0xa98], cl
movsx edx, byte [ebp - 0xa98]
xor edx, 0x34
mov byte [ebp - 0xa99], dl
mov al, byte [ebp - 0xa99]
mov byte [ebp - 0x1f9f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x102a28c0]
mov byte [ebp - 0xaa0], dl
movsx eax, byte [ebp - 0xaa0]
xor eax, 0x34
mov byte [ebp - 0xaa1], al
mov cl, byte [ebp - 0xaa1]
mov byte [ebp - 0x1f9e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x102a28c0]
mov byte [ebp - 0xaa8], cl
movsx edx, byte [ebp - 0xaa8]
xor edx, 0x34
mov byte [ebp - 0xaa9], dl
mov al, byte [ebp - 0xaa9]
mov byte [ebp - 0x1f9d], al
lea ecx, [ebp - 0x1fa0]
mov dword [ebp - 0x290c], ecx
mov edx, dword [ebp - 0x290c]
mov dword [ebp - 0x24b4], edx
mov dword [ebp - 0x1e8c], 0
jmp 0x1015474b
mov eax, dword [ebp - 0x1e8c]
add eax, 1
mov dword [ebp - 0x1e8c], eax
cmp dword [ebp - 0x1e8c], 4
jae 0x101547cd
mov ecx, dword [ebp - 0x24b4]
mov dword [ebp - 0x2910], ecx
mov edx, dword [ebp - 0x2910]
add edx, dword [ebp - 0x1e8c]
mov dword [ebp - 0x2914], edx
mov eax, dword [ebp - 0x2914]
mov cl, byte [eax]
mov byte [ebp - 0xab0], cl
movsx edx, byte [ebp - 0xab0]
xor edx, 0x34
mov byte [ebp - 0xab1], dl
mov al, byte [ebp - 0xab1]
mov byte [ebp - 0xab2], al
mov ecx, dword [ebp - 0x24b4]
mov dword [ebp - 0x2918], ecx
mov edx, dword [ebp - 0x2918]
add edx, dword [ebp - 0x1e8c]
mov dword [ebp - 0x291c], edx
mov eax, dword [ebp - 0x291c]
mov cl, byte [ebp - 0xab2]
mov byte [eax], cl
jmp 0x1015473c
mov edx, dword [ebp - 0x24b4]
mov dword [ebp - 0x2920], edx
mov eax, dword [ebp - 0x2920]
mov dword [ebp - 0x2924], eax
mov ecx, dword [ebp - 0x2924]
mov dword [ebp - 0x2928], ecx
mov edx, dword [ebp - 0x2928]
push edx
lea ecx, [ebp - 0x3d78]
call fcn.1007b880
mov dword [ebp - 4], 0x1e
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.night]
mov byte [ebp - 0xab8], dl
movsx eax, byte [ebp - 0xab8]
xor eax, 0x34
mov byte [ebp - 0xab9], al
mov cl, byte [ebp - 0xab9]
mov byte [ebp - 0x2020], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.night]
mov byte [ebp - 0xac0], al
movsx ecx, byte [ebp - 0xac0]
xor ecx, 0x34
mov byte [ebp - 0xac1], cl
mov dl, byte [ebp - 0xac1]
mov byte [ebp - 0x201f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.night]
mov byte [ebp - 0xac8], cl
movsx edx, byte [ebp - 0xac8]
xor edx, 0x34
mov byte [ebp - 0xac9], dl
mov al, byte [ebp - 0xac9]
mov byte [ebp - 0x201e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.night]
mov byte [ebp - 0xad0], al
movsx ecx, byte [ebp - 0xad0]
xor ecx, 0x34
mov byte [ebp - 0xad1], cl
mov dl, byte [ebp - 0xad1]
mov byte [ebp - 0x201d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.night]
mov byte [ebp - 0xad8], cl
movsx edx, byte [ebp - 0xad8]
xor edx, 0x34
mov byte [ebp - 0xad9], dl
mov al, byte [ebp - 0xad9]
mov byte [ebp - 0x201c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.night]
mov byte [ebp - 0xae0], al
movsx ecx, byte [ebp - 0xae0]
xor ecx, 0x34
mov byte [ebp - 0xae1], cl
mov dl, byte [ebp - 0xae1]
mov byte [ebp - 0x201b], dl
lea eax, [ebp - 0x2020]
mov dword [ebp - 0x292c], eax
mov ecx, dword [ebp - 0x292c]
mov dword [ebp - 0x24b0], ecx
mov dword [ebp - 0x1e90], 0
jmp 0x1015495c
mov edx, dword [ebp - 0x1e90]
add edx, 1
mov dword [ebp - 0x1e90], edx
cmp dword [ebp - 0x1e90], 6
jae 0x101549de
mov eax, dword [ebp - 0x24b0]
mov dword [ebp - 0x2930], eax
mov ecx, dword [ebp - 0x2930]
add ecx, dword [ebp - 0x1e90]
mov dword [ebp - 0x2934], ecx
mov edx, dword [ebp - 0x2934]
mov al, byte [edx]
mov byte [ebp - 0xae8], al
movsx ecx, byte [ebp - 0xae8]
xor ecx, 0x34
mov byte [ebp - 0xae9], cl
mov dl, byte [ebp - 0xae9]
mov byte [ebp - 0xaea], dl
mov eax, dword [ebp - 0x24b0]
mov dword [ebp - 0x2938], eax
mov ecx, dword [ebp - 0x2938]
add ecx, dword [ebp - 0x1e90]
mov dword [ebp - 0x293c], ecx
mov edx, dword [ebp - 0x293c]
mov al, byte [ebp - 0xaea]
mov byte [edx], al
jmp 0x1015494d
mov ecx, dword [ebp - 0x24b0]
mov dword [ebp - 0x2940], ecx
mov edx, dword [ebp - 0x2940]
mov dword [ebp - 0x2944], edx
mov eax, dword [ebp - 0x2944]
mov dword [ebp - 0x2948], eax
mov ecx, dword [ebp - 0x2948]
push ecx
lea ecx, [ebp - 0x3d60]
call fcn.1007b880
mov byte [ebp - 4], 0x1f
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.fullbright]
mov byte [ebp - 0xaf0], cl
movsx edx, byte [ebp - 0xaf0]
xor edx, 0x34
mov byte [ebp - 0xaf1], dl
mov al, byte [ebp - 0xaf1]
mov byte [ebp - 0x20bc], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.fullbright]
mov byte [ebp - 0xaf8], dl
movsx eax, byte [ebp - 0xaf8]
xor eax, 0x34
mov byte [ebp - 0xaf9], al
mov cl, byte [ebp - 0xaf9]
mov byte [ebp - 0x20bb], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.fullbright]
mov byte [ebp - 0xb00], al
movsx ecx, byte [ebp - 0xb00]
xor ecx, 0x34
mov byte [ebp - 0xb01], cl
mov dl, byte [ebp - 0xb01]
mov byte [ebp - 0x20ba], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.fullbright]
mov byte [ebp - 0xb08], dl
movsx eax, byte [ebp - 0xb08]
xor eax, 0x34
mov byte [ebp - 0xb09], al
mov cl, byte [ebp - 0xb09]
mov byte [ebp - 0x20b9], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.fullbright]
mov byte [ebp - 0xb10], al
movsx ecx, byte [ebp - 0xb10]
xor ecx, 0x34
mov byte [ebp - 0xb11], cl
mov dl, byte [ebp - 0xb11]
mov byte [ebp - 0x20b8], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.fullbright]
mov byte [ebp - 0xb18], dl
movsx eax, byte [ebp - 0xb18]
xor eax, 0x34
mov byte [ebp - 0xb19], al
mov cl, byte [ebp - 0xb19]
mov byte [ebp - 0x20b7], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.fullbright]
mov byte [ebp - 0xb20], cl
movsx edx, byte [ebp - 0xb20]
xor edx, 0x34
mov byte [ebp - 0xb21], dl
mov al, byte [ebp - 0xb21]
mov byte [ebp - 0x20b6], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.fullbright]
mov byte [ebp - 0xb28], al
movsx ecx, byte [ebp - 0xb28]
xor ecx, 0x34
mov byte [ebp - 0xb29], cl
mov dl, byte [ebp - 0xb29]
mov byte [ebp - 0x20b5], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.fullbright]
mov byte [ebp - 0xb30], cl
movsx edx, byte [ebp - 0xb30]
xor edx, 0x34
mov byte [ebp - 0xb31], dl
mov al, byte [ebp - 0xb31]
mov byte [ebp - 0x20b4], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.fullbright]
mov byte [ebp - 0xb38], al
movsx ecx, byte [ebp - 0xb38]
xor ecx, 0x34
mov byte [ebp - 0xb39], cl
mov dl, byte [ebp - 0xb39]
mov byte [ebp - 0x20b3], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.fullbright]
mov byte [ebp - 0xb40], dl
movsx eax, byte [ebp - 0xb40]
xor eax, 0x34
mov byte [ebp - 0xb41], al
mov cl, byte [ebp - 0xb41]
mov byte [ebp - 0x20b2], cl
lea edx, [ebp - 0x20bc]
mov dword [ebp - 0x294c], edx
mov eax, dword [ebp - 0x294c]
mov dword [ebp - 0x24ac], eax
mov dword [ebp - 0x1e94], 0
jmp 0x10154c5a
mov ecx, dword [ebp - 0x1e94]
add ecx, 1
mov dword [ebp - 0x1e94], ecx
cmp dword [ebp - 0x1e94], 0xb
jae 0x10154cdc
mov edx, dword [ebp - 0x24ac]
mov dword [ebp - 0x2950], edx
mov eax, dword [ebp - 0x2950]
add eax, dword [ebp - 0x1e94]
mov dword [ebp - 0x2954], eax
mov ecx, dword [ebp - 0x2954]
mov dl, byte [ecx]
mov byte [ebp - 0xb48], dl
movsx eax, byte [ebp - 0xb48]
xor eax, 0x34
mov byte [ebp - 0xb49], al
mov cl, byte [ebp - 0xb49]
mov byte [ebp - 0xb4a], cl
mov edx, dword [ebp - 0x24ac]
mov dword [ebp - 0x2958], edx
mov eax, dword [ebp - 0x2958]
add eax, dword [ebp - 0x1e94]
mov dword [ebp - 0x295c], eax
mov ecx, dword [ebp - 0x295c]
mov dl, byte [ebp - 0xb4a]
mov byte [ecx], dl
jmp 0x10154c4b
mov eax, dword [ebp - 0x24ac]
mov dword [ebp - 0x2960], eax
mov ecx, dword [ebp - 0x2960]
mov dword [ebp - 0x2964], ecx
mov edx, dword [ebp - 0x2964]
mov dword [ebp - 0x2968], edx
mov eax, dword [ebp - 0x2968]
push eax
lea ecx, [ebp - 0x3d48]
call fcn.1007b880
mov dword [ebp - 4], 0x20
lea ecx, [ebp - 0x3d78]
mov dword [ebp - 0x33e0], ecx
lea edx, [ebp - 0x3d30]
mov dword [ebp - 0x33dc], edx
lea eax, [ebp - 0x33e0]
mov dword [ebp - 0x296c], eax
mov ecx, dword [ebp - 0x296c]
mov edx, dword [ecx]
mov eax, dword [ecx + 4]
mov dword [ebp - 0x3298], edx
mov dword [ebp - 0x3294], eax
mov ecx, dword [ebp - 0x2970]
push ecx
mov edx, dword [ebp - 0x3294]
push edx
mov eax, dword [ebp - 0x3298]
push eax
lea ecx, [ebp - 0x3478]
call fcn.101ed250
mov byte [ebp - 4], 0x21
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.world]
mov byte [ebp - 0xb50], al
movsx ecx, byte [ebp - 0xb50]
xor ecx, 0x34
mov byte [ebp - 0xb51], cl
mov dl, byte [ebp - 0xb51]
mov byte [ebp - 0x1ff0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.world]
mov byte [ebp - 0xb58], cl
movsx edx, byte [ebp - 0xb58]
xor edx, 0x34
mov byte [ebp - 0xb59], dl
mov al, byte [ebp - 0xb59]
mov byte [ebp - 0x1fef], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.world]
mov byte [ebp - 0xb60], dl
movsx eax, byte [ebp - 0xb60]
xor eax, 0x34
mov byte [ebp - 0xb61], al
mov cl, byte [ebp - 0xb61]
mov byte [ebp - 0x1fee], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.world]
mov byte [ebp - 0xb68], cl
movsx edx, byte [ebp - 0xb68]
xor edx, 0x34
mov byte [ebp - 0xb69], dl
mov al, byte [ebp - 0xb69]
mov byte [ebp - 0x1fed], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.world]
mov byte [ebp - 0xb70], dl
movsx eax, byte [ebp - 0xb70]
xor eax, 0x34
mov byte [ebp - 0xb71], al
mov cl, byte [ebp - 0xb71]
mov byte [ebp - 0x1fec], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.world]
mov byte [ebp - 0xb78], cl
movsx edx, byte [ebp - 0xb78]
xor edx, 0x34
mov byte [ebp - 0xb79], dl
mov al, byte [ebp - 0xb79]
mov byte [ebp - 0x1feb], al
lea ecx, [ebp - 0x1ff0]
mov dword [ebp - 0x2974], ecx
mov edx, dword [ebp - 0x2974]
mov dword [ebp - 0x24a8], edx
mov dword [ebp - 0x1e98], 0
jmp 0x10154eca
mov eax, dword [ebp - 0x1e98]
add eax, 1
mov dword [ebp - 0x1e98], eax
cmp dword [ebp - 0x1e98], 6
jae 0x10154f4c
mov ecx, dword [ebp - 0x24a8]
mov dword [ebp - 0x2978], ecx
mov edx, dword [ebp - 0x2978]
add edx, dword [ebp - 0x1e98]
mov dword [ebp - 0x297c], edx
mov eax, dword [ebp - 0x297c]
mov cl, byte [eax]
mov byte [ebp - 0xb80], cl
movsx edx, byte [ebp - 0xb80]
xor edx, 0x34
mov byte [ebp - 0xb81], dl
mov al, byte [ebp - 0xb81]
mov byte [ebp - 0xb82], al
mov ecx, dword [ebp - 0x24a8]
mov dword [ebp - 0x2980], ecx
mov edx, dword [ebp - 0x2980]
add edx, dword [ebp - 0x1e98]
mov dword [ebp - 0x2984], edx
mov eax, dword [ebp - 0x2984]
mov cl, byte [ebp - 0xb82]
mov byte [eax], cl
jmp 0x10154ebb
mov edx, dword [ebp - 0x24a8]
mov dword [ebp - 0x2988], edx
mov eax, dword [ebp - 0x2988]
mov dword [ebp - 0x298c], eax
mov ecx, dword [ebp - 0x298c]
mov dword [ebp - 0x2990], ecx
mov edx, dword [ebp - 0x2990]
push edx
lea ecx, [ebp - 0x3710]
call fcn.1007b880
mov byte [ebp - 4], 0x22
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.world]
mov byte [ebp - 0xb88], dl
movsx eax, byte [ebp - 0xb88]
xor eax, 0x34
mov byte [ebp - 0xb89], al
mov cl, byte [ebp - 0xb89]
mov byte [ebp - 0x2028], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.world]
mov byte [ebp - 0xb90], al
movsx ecx, byte [ebp - 0xb90]
xor ecx, 0x34
mov byte [ebp - 0xb91], cl
mov dl, byte [ebp - 0xb91]
mov byte [ebp - 0x2027], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.world]
mov byte [ebp - 0xb98], cl
movsx edx, byte [ebp - 0xb98]
xor edx, 0x34
mov byte [ebp - 0xb99], dl
mov al, byte [ebp - 0xb99]
mov byte [ebp - 0x2026], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.world]
mov byte [ebp - 0xba0], al
movsx ecx, byte [ebp - 0xba0]
xor ecx, 0x34
mov byte [ebp - 0xba1], cl
mov dl, byte [ebp - 0xba1]
mov byte [ebp - 0x2025], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.world]
mov byte [ebp - 0xba8], cl
movsx edx, byte [ebp - 0xba8]
xor edx, 0x34
mov byte [ebp - 0xba9], dl
mov al, byte [ebp - 0xba9]
mov byte [ebp - 0x2024], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.world]
mov byte [ebp - 0xbb0], al
movsx ecx, byte [ebp - 0xbb0]
xor ecx, 0x34
mov byte [ebp - 0xbb1], cl
mov dl, byte [ebp - 0xbb1]
mov byte [ebp - 0x2023], dl
lea eax, [ebp - 0x2028]
mov dword [ebp - 0x2994], eax
mov ecx, dword [ebp - 0x2994]
mov dword [ebp - 0x24a4], ecx
mov dword [ebp - 0x1e9c], 0
jmp 0x101550d8
mov edx, dword [ebp - 0x1e9c]
add edx, 1
mov dword [ebp - 0x1e9c], edx
cmp dword [ebp - 0x1e9c], 6
jae 0x1015515a
mov eax, dword [ebp - 0x24a4]
mov dword [ebp - 0x2998], eax
mov ecx, dword [ebp - 0x2998]
add ecx, dword [ebp - 0x1e9c]
mov dword [ebp - 0x299c], ecx
mov edx, dword [ebp - 0x299c]
mov al, byte [edx]
mov byte [ebp - 0xbb8], al
movsx ecx, byte [ebp - 0xbb8]
xor ecx, 0x34
mov byte [ebp - 0xbb9], cl
mov dl, byte [ebp - 0xbb9]
mov byte [ebp - 0xbba], dl
mov eax, dword [ebp - 0x24a4]
mov dword [ebp - 0x29a0], eax
mov ecx, dword [ebp - 0x29a0]
add ecx, dword [ebp - 0x1e9c]
mov dword [ebp - 0x29a4], ecx
mov edx, dword [ebp - 0x29a4]
mov al, byte [ebp - 0xbba]
mov byte [edx], al
jmp 0x101550c9
mov ecx, dword [ebp - 0x24a4]
mov dword [ebp - 0x29a8], ecx
mov edx, dword [ebp - 0x29a8]
mov dword [ebp - 0x29ac], edx
mov eax, dword [ebp - 0x29ac]
mov dword [ebp - 0x29b0], eax
mov ecx, dword [ebp - 0x29b0]
push ecx
lea ecx, [ebp - 0x36f8]
call fcn.1007b880
mov byte [ebp - 4], 0x23
lea edx, [ebp - 0x3710]
push edx
mov ecx, dword [ebp - 0xf4]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0xf4]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0xf4]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x101551d7
lea eax, [ebp - 0x36f8]
push eax
mov ecx, dword [ebp - 0xf4]
add ecx, 0x70
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0xf4]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x101551f1
mov dword [ebp - 0x258c], 0xf
jmp 0x101551fb
mov dword [ebp - 0x258c], 0
mov eax, dword [ebp - 0xf4]
mov ecx, dword [ebp - 0x258c]
mov dword [eax + 0x9c], ecx
mov edx, dword [ebp - 0xf4]
mov eax, dword [edx + 0x9c]
add eax, 0x14
mov dword [ebp - 0x2590], eax
mov ecx, dword [ebp - 0xf4]
mov edx, dword [ebp - 0x2590]
mov dword [ecx + 0x10], edx
mov eax, dword [ebp - 0xf4]
mov ecx, dword [ebp - 0x2590]
mov dword [eax + 0x14], ecx
lea edx, [ebp - 0x3478]
mov dword [ebp - 0x2594], edx
mov eax, dword [ebp - 0x2594]
mov ecx, dword [eax]
mov dword [ebp - 0x29b4], ecx
mov edx, dword [ebp - 0x29b4]
mov dword [ebp - 0x29b8], edx
mov eax, dword [ebp - 0x29b8]
mov dword [ebp - 0x29bc], eax
mov ecx, dword [ebp - 0x29bc]
mov dword [ebp - 0x1fb0], ecx
mov edx, dword [ebp - 0x2594]
mov eax, dword [edx + 4]
mov dword [ebp - 0x29c0], eax
mov ecx, dword [ebp - 0x29c0]
mov dword [ebp - 0x29c4], ecx
mov edx, dword [ebp - 0x29c4]
mov dword [ebp - 0x29c8], edx
mov eax, dword [ebp - 0x29c8]
mov dword [ebp - 0x29cc], eax
jmp 0x101552c2
mov ecx, dword [ebp - 0x1fb0]
add ecx, 0x18
mov dword [ebp - 0x1fb0], ecx
mov edx, dword [ebp - 0x1fb0]
cmp edx, dword [ebp - 0x29cc]
je 0x10155303
mov eax, dword [ebp - 0x1fb0]
mov dword [ebp - 0x29d0], eax
mov ecx, dword [ebp - 0xf4]
add ecx, 0x88
mov dword [ebp - 0x29d4], ecx
mov edx, dword [ebp - 0x29d0]
push edx
mov ecx, dword [ebp - 0x29d4]
call fcn.100d29a0
nop
jmp 0x101552b3
mov eax, dword [ebp - 0xf4]
add eax, 0x88
mov dword [ebp - 0x2598], eax
mov ecx, dword [ebp - 0x2598]
mov edx, dword [ebp - 0x2598]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x29d8], eax
cmp dword [ebp - 0x29d8], 0
jbe 0x1015534c
mov edx, dword [ebp - 0xf4]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x22
lea ecx, [ebp - 0x36f8]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x21
lea ecx, [ebp - 0x3710]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x20
lea ecx, [ebp - 0x3478]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 3
push 0x18
lea eax, [ebp - 0x3d78]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x60c
mov dword [ebp - 0x29dc], ecx
mov edx, dword [ebp - 0x29dc]
mov dword [edx + 0x64], fcn.10270480
mov eax, dword [ebp - 0xc0]
add eax, 0x60c
mov dword [ebp - 0x7c], eax
mov ecx, dword [ebp - 0x7c]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x7c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x7c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x7c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x7c]
mov ecx, dword [ebp - 0xc0]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0xc0]
add eax, 0x18
mov dword [ebp - 0x29e0], eax
lea ecx, [ebp - 0x7c]
push ecx
mov ecx, dword [ebp - 0x29e0]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x6ac
mov dword [ebp - 0x1ea8], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xbc0], dl
movsx eax, byte [ebp - 0xbc0]
xor eax, 0x34
mov byte [ebp - 0xbc1], al
mov cl, byte [ebp - 0xbc1]
mov byte [ebp - 0x2238], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.transparent_props]
mov byte [ebp - 0xbc8], al
movsx ecx, byte [ebp - 0xbc8]
xor ecx, 0x34
mov byte [ebp - 0xbc9], cl
mov dl, byte [ebp - 0xbc9]
mov byte [ebp - 0x2237], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xbd0], cl
movsx edx, byte [ebp - 0xbd0]
xor edx, 0x34
mov byte [ebp - 0xbd1], dl
mov al, byte [ebp - 0xbd1]
mov byte [ebp - 0x2236], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.transparent_props]
mov byte [ebp - 0xbd8], al
movsx ecx, byte [ebp - 0xbd8]
xor ecx, 0x34
mov byte [ebp - 0xbd9], cl
mov dl, byte [ebp - 0xbd9]
mov byte [ebp - 0x2235], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xbe0], cl
movsx edx, byte [ebp - 0xbe0]
xor edx, 0x34
mov byte [ebp - 0xbe1], dl
mov al, byte [ebp - 0xbe1]
mov byte [ebp - 0x2234], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.transparent_props]
mov byte [ebp - 0xbe8], al
movsx ecx, byte [ebp - 0xbe8]
xor ecx, 0x34
mov byte [ebp - 0xbe9], cl
mov dl, byte [ebp - 0xbe9]
mov byte [ebp - 0x2233], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xbf0], dl
movsx eax, byte [ebp - 0xbf0]
xor eax, 0x34
mov byte [ebp - 0xbf1], al
mov cl, byte [ebp - 0xbf1]
mov byte [ebp - 0x2232], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xbf8], cl
movsx edx, byte [ebp - 0xbf8]
xor edx, 0x34
mov byte [ebp - 0xbf9], dl
mov al, byte [ebp - 0xbf9]
mov byte [ebp - 0x2231], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xc00], dl
movsx eax, byte [ebp - 0xc00]
xor eax, 0x34
mov byte [ebp - 0xc01], al
mov cl, byte [ebp - 0xc01]
mov byte [ebp - 0x2230], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xc08], cl
movsx edx, byte [ebp - 0xc08]
xor edx, 0x34
mov byte [ebp - 0xc09], dl
mov al, byte [ebp - 0xc09]
mov byte [ebp - 0x222f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.transparent_props]
mov byte [ebp - 0xc10], al
movsx ecx, byte [ebp - 0xc10]
xor ecx, 0x34
mov byte [ebp - 0xc11], cl
mov dl, byte [ebp - 0xc11]
mov byte [ebp - 0x222e], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xc18], dl
movsx eax, byte [ebp - 0xc18]
xor eax, 0x34
mov byte [ebp - 0xc19], al
mov cl, byte [ebp - 0xc19]
mov byte [ebp - 0x222d], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xc20], cl
movsx edx, byte [ebp - 0xc20]
xor edx, 0x34
mov byte [ebp - 0xc21], dl
mov al, byte [ebp - 0xc21]
mov byte [ebp - 0x222c], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.transparent_props]
mov byte [ebp - 0xc28], al
movsx ecx, byte [ebp - 0xc28]
xor ecx, 0x34
mov byte [ebp - 0xc29], cl
mov dl, byte [ebp - 0xc29]
mov byte [ebp - 0x222b], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xc30], dl
movsx eax, byte [ebp - 0xc30]
xor eax, 0x34
mov byte [ebp - 0xc31], al
mov cl, byte [ebp - 0xc31]
mov byte [ebp - 0x222a], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xc38], cl
movsx edx, byte [ebp - 0xc38]
xor edx, 0x34
mov byte [ebp - 0xc39], dl
mov al, byte [ebp - 0xc39]
mov byte [ebp - 0x2229], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.transparent_props]
mov byte [ebp - 0xc40], dl
movsx eax, byte [ebp - 0xc40]
xor eax, 0x34
mov byte [ebp - 0xc41], al
mov cl, byte [ebp - 0xc41]
mov byte [ebp - 0x2228], cl
mov edx, 1
imul eax, edx, 0x11
mov cl, byte [eax + str.transparent_props]
mov byte [ebp - 0xc48], cl
movsx edx, byte [ebp - 0xc48]
xor edx, 0x34
mov byte [ebp - 0xc49], dl
mov al, byte [ebp - 0xc49]
mov byte [ebp - 0x2227], al
lea ecx, [ebp - 0x2238]
mov dword [ebp - 0x29e4], ecx
mov edx, dword [ebp - 0x29e4]
mov dword [ebp - 0x24a0], edx
mov dword [ebp - 0x1ea0], 0
jmp 0x101557bf
mov eax, dword [ebp - 0x1ea0]
add eax, 1
mov dword [ebp - 0x1ea0], eax
cmp dword [ebp - 0x1ea0], 0x12
jae 0x10155841
mov ecx, dword [ebp - 0x24a0]
mov dword [ebp - 0x29e8], ecx
mov edx, dword [ebp - 0x29e8]
add edx, dword [ebp - 0x1ea0]
mov dword [ebp - 0x29ec], edx
mov eax, dword [ebp - 0x29ec]
mov cl, byte [eax]
mov byte [ebp - 0xc50], cl
movsx edx, byte [ebp - 0xc50]
xor edx, 0x34
mov byte [ebp - 0xc51], dl
mov al, byte [ebp - 0xc51]
mov byte [ebp - 0xc52], al
mov ecx, dword [ebp - 0x24a0]
mov dword [ebp - 0x29f0], ecx
mov edx, dword [ebp - 0x29f0]
add edx, dword [ebp - 0x1ea0]
mov dword [ebp - 0x29f4], edx
mov eax, dword [ebp - 0x29f4]
mov cl, byte [ebp - 0xc52]
mov byte [eax], cl
jmp 0x101557b0
mov edx, dword [ebp - 0x24a0]
mov dword [ebp - 0x29f8], edx
mov eax, dword [ebp - 0x29f8]
mov dword [ebp - 0x29fc], eax
mov ecx, dword [ebp - 0x29fc]
mov dword [ebp - 0x2a00], ecx
mov edx, dword [ebp - 0x2a00]
push edx
lea ecx, [ebp - 0x3740]
call fcn.1007b880
mov dword [ebp - 4], 0x24
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xc58], dl
movsx eax, byte [ebp - 0xc58]
xor eax, 0x34
mov byte [ebp - 0xc59], al
mov cl, byte [ebp - 0xc59]
mov byte [ebp - 0x224c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x102a3580]
mov byte [ebp - 0xc60], al
movsx ecx, byte [ebp - 0xc60]
xor ecx, 0x34
mov byte [ebp - 0xc61], cl
mov dl, byte [ebp - 0xc61]
mov byte [ebp - 0x224b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xc68], cl
movsx edx, byte [ebp - 0xc68]
xor edx, 0x34
mov byte [ebp - 0xc69], dl
mov al, byte [ebp - 0xc69]
mov byte [ebp - 0x224a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x102a3580]
mov byte [ebp - 0xc70], al
movsx ecx, byte [ebp - 0xc70]
xor ecx, 0x34
mov byte [ebp - 0xc71], cl
mov dl, byte [ebp - 0xc71]
mov byte [ebp - 0x2249], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xc78], cl
movsx edx, byte [ebp - 0xc78]
xor edx, 0x34
mov byte [ebp - 0xc79], dl
mov al, byte [ebp - 0xc79]
mov byte [ebp - 0x2248], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + 0x102a3580]
mov byte [ebp - 0xc80], al
movsx ecx, byte [ebp - 0xc80]
xor ecx, 0x34
mov byte [ebp - 0xc81], cl
mov dl, byte [ebp - 0xc81]
mov byte [ebp - 0x2247], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xc88], dl
movsx eax, byte [ebp - 0xc88]
xor eax, 0x34
mov byte [ebp - 0xc89], al
mov cl, byte [ebp - 0xc89]
mov byte [ebp - 0x2246], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xc90], cl
movsx edx, byte [ebp - 0xc90]
xor edx, 0x34
mov byte [ebp - 0xc91], dl
mov al, byte [ebp - 0xc91]
mov byte [ebp - 0x2245], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xc98], dl
movsx eax, byte [ebp - 0xc98]
xor eax, 0x34
mov byte [ebp - 0xc99], al
mov cl, byte [ebp - 0xc99]
mov byte [ebp - 0x2244], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xca0], cl
movsx edx, byte [ebp - 0xca0]
xor edx, 0x34
mov byte [ebp - 0xca1], dl
mov al, byte [ebp - 0xca1]
mov byte [ebp - 0x2243], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + 0x102a3580]
mov byte [ebp - 0xca8], al
movsx ecx, byte [ebp - 0xca8]
xor ecx, 0x34
mov byte [ebp - 0xca9], cl
mov dl, byte [ebp - 0xca9]
mov byte [ebp - 0x2242], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xcb0], dl
movsx eax, byte [ebp - 0xcb0]
xor eax, 0x34
mov byte [ebp - 0xcb1], al
mov cl, byte [ebp - 0xcb1]
mov byte [ebp - 0x2241], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xcb8], cl
movsx edx, byte [ebp - 0xcb8]
xor edx, 0x34
mov byte [ebp - 0xcb9], dl
mov al, byte [ebp - 0xcb9]
mov byte [ebp - 0x2240], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + 0x102a3580]
mov byte [ebp - 0xcc0], al
movsx ecx, byte [ebp - 0xcc0]
xor ecx, 0x34
mov byte [ebp - 0xcc1], cl
mov dl, byte [ebp - 0xcc1]
mov byte [ebp - 0x223f], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xcc8], dl
movsx eax, byte [ebp - 0xcc8]
xor eax, 0x34
mov byte [ebp - 0xcc9], al
mov cl, byte [ebp - 0xcc9]
mov byte [ebp - 0x223e], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xcd0], cl
movsx edx, byte [ebp - 0xcd0]
xor edx, 0x34
mov byte [ebp - 0xcd1], dl
mov al, byte [ebp - 0xcd1]
mov byte [ebp - 0x223d], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + 0x102a3580]
mov byte [ebp - 0xcd8], dl
movsx eax, byte [ebp - 0xcd8]
xor eax, 0x34
mov byte [ebp - 0xcd9], al
mov cl, byte [ebp - 0xcd9]
mov byte [ebp - 0x223c], cl
mov edx, 1
imul eax, edx, 0x11
mov cl, byte [eax + 0x102a3580]
mov byte [ebp - 0xce0], cl
movsx edx, byte [ebp - 0xce0]
xor edx, 0x34
mov byte [ebp - 0xce1], dl
mov al, byte [ebp - 0xce1]
mov byte [ebp - 0x223b], al
lea ecx, [ebp - 0x224c]
mov dword [ebp - 0x2a04], ecx
mov edx, dword [ebp - 0x2a04]
mov dword [ebp - 0x249c], edx
mov dword [ebp - 0x1ea4], 0
jmp 0x10155c10
mov eax, dword [ebp - 0x1ea4]
add eax, 1
mov dword [ebp - 0x1ea4], eax
cmp dword [ebp - 0x1ea4], 0x12
jae 0x10155c92
mov ecx, dword [ebp - 0x249c]
mov dword [ebp - 0x2a08], ecx
mov edx, dword [ebp - 0x2a08]
add edx, dword [ebp - 0x1ea4]
mov dword [ebp - 0x2a0c], edx
mov eax, dword [ebp - 0x2a0c]
mov cl, byte [eax]
mov byte [ebp - 0xce8], cl
movsx edx, byte [ebp - 0xce8]
xor edx, 0x34
mov byte [ebp - 0xce9], dl
mov al, byte [ebp - 0xce9]
mov byte [ebp - 0xcea], al
mov ecx, dword [ebp - 0x249c]
mov dword [ebp - 0x2a10], ecx
mov edx, dword [ebp - 0x2a10]
add edx, dword [ebp - 0x1ea4]
mov dword [ebp - 0x2a14], edx
mov eax, dword [ebp - 0x2a14]
mov cl, byte [ebp - 0xcea]
mov byte [eax], cl
jmp 0x10155c01
mov edx, dword [ebp - 0x249c]
mov dword [ebp - 0x2a18], edx
mov eax, dword [ebp - 0x2a18]
mov dword [ebp - 0x2a1c], eax
mov ecx, dword [ebp - 0x2a1c]
mov dword [ebp - 0x2a20], ecx
mov edx, dword [ebp - 0x2a20]
push edx
lea ecx, [ebp - 0x3728]
call fcn.1007b880
mov byte [ebp - 4], 0x25
lea eax, [ebp - 0x3740]
push eax
mov ecx, dword [ebp - 0x1ea8]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x1ea8]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1ea8]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10155d0f
lea ecx, [ebp - 0x3728]
push ecx
mov ecx, dword [ebp - 0x1ea8]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x1ea8]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x24
lea ecx, [ebp - 0x3728]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3740]
call fcn.1007c260
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x6ac
mov dword [ebp - 0x2a24], eax
mov ecx, dword [ebp - 0x2a24]
mov dword [ecx + 0x64], fcn.10270480
mov edx, dword [ebp - 0xc0]
add edx, 0x6ac
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 - 0xc0]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0xc0]
add edx, 0x18
mov dword [ebp - 0x2a28], edx
lea eax, [ebp - 0x80]
push eax
mov ecx, dword [ebp - 0x2a28]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x734
mov dword [ebp - 0x1eb4], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.enemy_radar]
mov byte [ebp - 0xcf0], cl
movsx edx, byte [ebp - 0xcf0]
xor edx, 0x34
mov byte [ebp - 0xcf1], dl
mov al, byte [ebp - 0xcf1]
mov byte [ebp - 0x20f8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.enemy_radar]
mov byte [ebp - 0xcf8], dl
movsx eax, byte [ebp - 0xcf8]
xor eax, 0x34
mov byte [ebp - 0xcf9], al
mov cl, byte [ebp - 0xcf9]
mov byte [ebp - 0x20f7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.enemy_radar]
mov byte [ebp - 0xd00], al
movsx ecx, byte [ebp - 0xd00]
xor ecx, 0x34
mov byte [ebp - 0xd01], cl
mov dl, byte [ebp - 0xd01]
mov byte [ebp - 0x20f6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.enemy_radar]
mov byte [ebp - 0xd08], dl
movsx eax, byte [ebp - 0xd08]
xor eax, 0x34
mov byte [ebp - 0xd09], al
mov cl, byte [ebp - 0xd09]
mov byte [ebp - 0x20f5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.enemy_radar]
mov byte [ebp - 0xd10], al
movsx ecx, byte [ebp - 0xd10]
xor ecx, 0x34
mov byte [ebp - 0xd11], cl
mov dl, byte [ebp - 0xd11]
mov byte [ebp - 0x20f4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.enemy_radar]
mov byte [ebp - 0xd18], dl
movsx eax, byte [ebp - 0xd18]
xor eax, 0x34
mov byte [ebp - 0xd19], al
mov cl, byte [ebp - 0xd19]
mov byte [ebp - 0x20f3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.enemy_radar]
mov byte [ebp - 0xd20], cl
movsx edx, byte [ebp - 0xd20]
xor edx, 0x34
mov byte [ebp - 0xd21], dl
mov al, byte [ebp - 0xd21]
mov byte [ebp - 0x20f2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.enemy_radar]
mov byte [ebp - 0xd28], al
movsx ecx, byte [ebp - 0xd28]
xor ecx, 0x34
mov byte [ebp - 0xd29], cl
mov dl, byte [ebp - 0xd29]
mov byte [ebp - 0x20f1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.enemy_radar]
mov byte [ebp - 0xd30], cl
movsx edx, byte [ebp - 0xd30]
xor edx, 0x34
mov byte [ebp - 0xd31], dl
mov al, byte [ebp - 0xd31]
mov byte [ebp - 0x20f0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.enemy_radar]
mov byte [ebp - 0xd38], al
movsx ecx, byte [ebp - 0xd38]
xor ecx, 0x34
mov byte [ebp - 0xd39], cl
mov dl, byte [ebp - 0xd39]
mov byte [ebp - 0x20ef], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.enemy_radar]
mov byte [ebp - 0xd40], dl
movsx eax, byte [ebp - 0xd40]
xor eax, 0x34
mov byte [ebp - 0xd41], al
mov cl, byte [ebp - 0xd41]
mov byte [ebp - 0x20ee], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.enemy_radar]
mov byte [ebp - 0xd48], cl
movsx edx, byte [ebp - 0xd48]
xor edx, 0x34
mov byte [ebp - 0xd49], dl
mov al, byte [ebp - 0xd49]
mov byte [ebp - 0x20ed], al
lea ecx, [ebp - 0x20f8]
mov dword [ebp - 0x2a2c], ecx
mov edx, dword [ebp - 0x2a2c]
mov dword [ebp - 0x2498], edx
mov dword [ebp - 0x1eac], 0
jmp 0x10156042
mov eax, dword [ebp - 0x1eac]
add eax, 1
mov dword [ebp - 0x1eac], eax
cmp dword [ebp - 0x1eac], 0xc
jae 0x101560c4
mov ecx, dword [ebp - 0x2498]
mov dword [ebp - 0x2a30], ecx
mov edx, dword [ebp - 0x2a30]
add edx, dword [ebp - 0x1eac]
mov dword [ebp - 0x2a34], edx
mov eax, dword [ebp - 0x2a34]
mov cl, byte [eax]
mov byte [ebp - 0xd50], cl
movsx edx, byte [ebp - 0xd50]
xor edx, 0x34
mov byte [ebp - 0xd51], dl
mov al, byte [ebp - 0xd51]
mov byte [ebp - 0xd52], al
mov ecx, dword [ebp - 0x2498]
mov dword [ebp - 0x2a38], ecx
mov edx, dword [ebp - 0x2a38]
add edx, dword [ebp - 0x1eac]
mov dword [ebp - 0x2a3c], edx
mov eax, dword [ebp - 0x2a3c]
mov cl, byte [ebp - 0xd52]
mov byte [eax], cl
jmp 0x10156033
mov edx, dword [ebp - 0x2498]
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
lea ecx, [ebp - 0x3770]
call fcn.1007b880
mov dword [ebp - 4], 0x26
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xd58], dl
movsx eax, byte [ebp - 0xd58]
xor eax, 0x34
mov byte [ebp - 0xd59], al
mov cl, byte [ebp - 0xd59]
mov byte [ebp - 0x22d4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xd60], al
movsx ecx, byte [ebp - 0xd60]
xor ecx, 0x34
mov byte [ebp - 0xd61], cl
mov dl, byte [ebp - 0xd61]
mov byte [ebp - 0x22d3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xd68], cl
movsx edx, byte [ebp - 0xd68]
xor edx, 0x34
mov byte [ebp - 0xd69], dl
mov al, byte [ebp - 0xd69]
mov byte [ebp - 0x22d2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xd70], al
movsx ecx, byte [ebp - 0xd70]
xor ecx, 0x34
mov byte [ebp - 0xd71], cl
mov dl, byte [ebp - 0xd71]
mov byte [ebp - 0x22d1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xd78], cl
movsx edx, byte [ebp - 0xd78]
xor edx, 0x34
mov byte [ebp - 0xd79], dl
mov al, byte [ebp - 0xd79]
mov byte [ebp - 0x22d0], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xd80], al
movsx ecx, byte [ebp - 0xd80]
xor ecx, 0x34
mov byte [ebp - 0xd81], cl
mov dl, byte [ebp - 0xd81]
mov byte [ebp - 0x22cf], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xd88], dl
movsx eax, byte [ebp - 0xd88]
xor eax, 0x34
mov byte [ebp - 0xd89], al
mov cl, byte [ebp - 0xd89]
mov byte [ebp - 0x22ce], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xd90], cl
movsx edx, byte [ebp - 0xd90]
xor edx, 0x34
mov byte [ebp - 0xd91], dl
mov al, byte [ebp - 0xd91]
mov byte [ebp - 0x22cd], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xd98], dl
movsx eax, byte [ebp - 0xd98]
xor eax, 0x34
mov byte [ebp - 0xd99], al
mov cl, byte [ebp - 0xd99]
mov byte [ebp - 0x22cc], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xda0], cl
movsx edx, byte [ebp - 0xda0]
xor edx, 0x34
mov byte [ebp - 0xda1], dl
mov al, byte [ebp - 0xda1]
mov byte [ebp - 0x22cb], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xda8], al
movsx ecx, byte [ebp - 0xda8]
xor ecx, 0x34
mov byte [ebp - 0xda9], cl
mov dl, byte [ebp - 0xda9]
mov byte [ebp - 0x22ca], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xdb0], dl
movsx eax, byte [ebp - 0xdb0]
xor eax, 0x34
mov byte [ebp - 0xdb1], al
mov cl, byte [ebp - 0xdb1]
mov byte [ebp - 0x22c9], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xdb8], cl
movsx edx, byte [ebp - 0xdb8]
xor edx, 0x34
mov byte [ebp - 0xdb9], dl
mov al, byte [ebp - 0xdb9]
mov byte [ebp - 0x22c8], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xdc0], al
movsx ecx, byte [ebp - 0xdc0]
xor ecx, 0x34
mov byte [ebp - 0xdc1], cl
mov dl, byte [ebp - 0xdc1]
mov byte [ebp - 0x22c7], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xdc8], dl
movsx eax, byte [ebp - 0xdc8]
xor eax, 0x34
mov byte [ebp - 0xdc9], al
mov cl, byte [ebp - 0xdc9]
mov byte [ebp - 0x22c6], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xdd0], cl
movsx edx, byte [ebp - 0xdd0]
xor edx, 0x34
mov byte [ebp - 0xdd1], dl
mov al, byte [ebp - 0xdd1]
mov byte [ebp - 0x22c5], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xdd8], dl
movsx eax, byte [ebp - 0xdd8]
xor eax, 0x34
mov byte [ebp - 0xdd9], al
mov cl, byte [ebp - 0xdd9]
mov byte [ebp - 0x22c4], cl
mov edx, 1
imul eax, edx, 0x11
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xde0], cl
movsx edx, byte [ebp - 0xde0]
xor edx, 0x34
mov byte [ebp - 0xde1], dl
mov al, byte [ebp - 0xde1]
mov byte [ebp - 0x22c3], al
mov ecx, 1
imul edx, ecx, 0x12
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xde8], al
movsx ecx, byte [ebp - 0xde8]
xor ecx, 0x34
mov byte [ebp - 0xde9], cl
mov dl, byte [ebp - 0xde9]
mov byte [ebp - 0x22c2], dl
mov eax, 1
imul ecx, eax, 0x13
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xdf0], dl
movsx eax, byte [ebp - 0xdf0]
xor eax, 0x34
mov byte [ebp - 0xdf1], al
mov cl, byte [ebp - 0xdf1]
mov byte [ebp - 0x22c1], cl
mov edx, 1
imul eax, edx, 0x14
mov cl, byte [eax + str.force_enemies_on_radar]
mov byte [ebp - 0xdf8], cl
movsx edx, byte [ebp - 0xdf8]
xor edx, 0x34
mov byte [ebp - 0xdf9], dl
mov al, byte [ebp - 0xdf9]
mov byte [ebp - 0x22c0], al
mov ecx, 1
imul edx, ecx, 0x15
mov al, byte [edx + str.force_enemies_on_radar]
mov byte [ebp - 0xe00], al
movsx ecx, byte [ebp - 0xe00]
xor ecx, 0x34
mov byte [ebp - 0xe01], cl
mov dl, byte [ebp - 0xe01]
mov byte [ebp - 0x22bf], dl
mov eax, 1
imul ecx, eax, 0x16
mov dl, byte [ecx + str.force_enemies_on_radar]
mov byte [ebp - 0xe08], dl
movsx eax, byte [ebp - 0xe08]
xor eax, 0x34
mov byte [ebp - 0xe09], al
mov cl, byte [ebp - 0xe09]
mov byte [ebp - 0x22be], cl
lea edx, [ebp - 0x22d4]
mov dword [ebp - 0x2a4c], edx
mov eax, dword [ebp - 0x2a4c]
mov dword [ebp - 0x2490], eax
mov dword [ebp - 0x1eb0], 0
jmp 0x10156583
mov ecx, dword [ebp - 0x1eb0]
add ecx, 1
mov dword [ebp - 0x1eb0], ecx
cmp dword [ebp - 0x1eb0], 0x17
jae 0x10156605
mov edx, dword [ebp - 0x2490]
mov dword [ebp - 0x2a50], edx
mov eax, dword [ebp - 0x2a50]
add eax, dword [ebp - 0x1eb0]
mov dword [ebp - 0x2a54], eax
mov ecx, dword [ebp - 0x2a54]
mov dl, byte [ecx]
mov byte [ebp - 0xe10], dl
movsx eax, byte [ebp - 0xe10]
xor eax, 0x34
mov byte [ebp - 0xe11], al
mov cl, byte [ebp - 0xe11]
mov byte [ebp - 0xe12], cl
mov edx, dword [ebp - 0x2490]
mov dword [ebp - 0x2a58], edx
mov eax, dword [ebp - 0x2a58]
add eax, dword [ebp - 0x1eb0]
mov dword [ebp - 0x2a5c], eax
mov ecx, dword [ebp - 0x2a5c]
mov dl, byte [ebp - 0xe12]
mov byte [ecx], dl
jmp 0x10156574
mov eax, dword [ebp - 0x2490]
mov dword [ebp - 0x2a60], eax
mov ecx, dword [ebp - 0x2a60]
mov dword [ebp - 0x2a64], ecx
mov edx, dword [ebp - 0x2a64]
mov dword [ebp - 0x2a68], edx
mov eax, dword [ebp - 0x2a68]
push eax
lea ecx, [ebp - 0x3758]
call fcn.1007b880
mov byte [ebp - 4], 0x27
lea ecx, [ebp - 0x3770]
push ecx
mov ecx, dword [ebp - 0x1eb4]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x1eb4]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1eb4]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10156682
lea edx, [ebp - 0x3758]
push edx
mov ecx, dword [ebp - 0x1eb4]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x1eb4]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 0x26
lea ecx, [ebp - 0x3758]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3770]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x734
mov dword [ebp - 0x84], ecx
mov edx, dword [ebp - 0x84]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x84]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x84]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x84]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x84]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x2a6c], ecx
lea edx, [ebp - 0x84]
push edx
mov ecx, dword [ebp - 0x2a6c]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x7bc
mov dword [ebp - 0x1ec0], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.impacts]
mov byte [ebp - 0xe18], al
movsx ecx, byte [ebp - 0xe18]
xor ecx, 0x34
mov byte [ebp - 0xe19], cl
mov dl, byte [ebp - 0xe19]
mov byte [ebp - 0x2040], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.impacts]
mov byte [ebp - 0xe20], cl
movsx edx, byte [ebp - 0xe20]
xor edx, 0x34
mov byte [ebp - 0xe21], dl
mov al, byte [ebp - 0xe21]
mov byte [ebp - 0x203f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.impacts]
mov byte [ebp - 0xe28], dl
movsx eax, byte [ebp - 0xe28]
xor eax, 0x34
mov byte [ebp - 0xe29], al
mov cl, byte [ebp - 0xe29]
mov byte [ebp - 0x203e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.impacts]
mov byte [ebp - 0xe30], cl
movsx edx, byte [ebp - 0xe30]
xor edx, 0x34
mov byte [ebp - 0xe31], dl
mov al, byte [ebp - 0xe31]
mov byte [ebp - 0x203d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.impacts]
mov byte [ebp - 0xe38], dl
movsx eax, byte [ebp - 0xe38]
xor eax, 0x34
mov byte [ebp - 0xe39], al
mov cl, byte [ebp - 0xe39]
mov byte [ebp - 0x203c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.impacts]
mov byte [ebp - 0xe40], cl
movsx edx, byte [ebp - 0xe40]
xor edx, 0x34
mov byte [ebp - 0xe41], dl
mov al, byte [ebp - 0xe41]
mov byte [ebp - 0x203b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.impacts]
mov byte [ebp - 0xe48], al
movsx ecx, byte [ebp - 0xe48]
xor ecx, 0x34
mov byte [ebp - 0xe49], cl
mov dl, byte [ebp - 0xe49]
mov byte [ebp - 0x203a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.impacts]
mov byte [ebp - 0xe50], dl
movsx eax, byte [ebp - 0xe50]
xor eax, 0x34
mov byte [ebp - 0xe51], al
mov cl, byte [ebp - 0xe51]
mov byte [ebp - 0x2039], cl
lea edx, [ebp - 0x2040]
mov dword [ebp - 0x2a70], edx
mov eax, dword [ebp - 0x2a70]
mov dword [ebp - 0x248c], eax
mov dword [ebp - 0x1eb8], 0
jmp 0x101568eb
mov ecx, dword [ebp - 0x1eb8]
add ecx, 1
mov dword [ebp - 0x1eb8], ecx
cmp dword [ebp - 0x1eb8], 8
jae 0x1015696d
mov edx, dword [ebp - 0x248c]
mov dword [ebp - 0x2a74], edx
mov eax, dword [ebp - 0x2a74]
add eax, dword [ebp - 0x1eb8]
mov dword [ebp - 0x2a78], eax
mov ecx, dword [ebp - 0x2a78]
mov dl, byte [ecx]
mov byte [ebp - 0xe58], dl
movsx eax, byte [ebp - 0xe58]
xor eax, 0x34
mov byte [ebp - 0xe59], al
mov cl, byte [ebp - 0xe59]
mov byte [ebp - 0xe5a], cl
mov edx, dword [ebp - 0x248c]
mov dword [ebp - 0x2a7c], edx
mov eax, dword [ebp - 0x2a7c]
add eax, dword [ebp - 0x1eb8]
mov dword [ebp - 0x2a80], eax
mov ecx, dword [ebp - 0x2a80]
mov dl, byte [ebp - 0xe5a]
mov byte [ecx], dl
jmp 0x101568dc
mov eax, dword [ebp - 0x248c]
mov dword [ebp - 0x2a84], eax
mov ecx, dword [ebp - 0x2a84]
mov dword [ebp - 0x2a88], ecx
mov edx, dword [ebp - 0x2a88]
mov dword [ebp - 0x2a8c], edx
mov eax, dword [ebp - 0x2a8c]
push eax
lea ecx, [ebp - 0x37a0]
call fcn.1007b880
mov dword [ebp - 4], 0x28
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.draw_impacts]
mov byte [ebp - 0xe60], al
movsx ecx, byte [ebp - 0xe60]
xor ecx, 0x34
mov byte [ebp - 0xe61], cl
mov dl, byte [ebp - 0xe61]
mov byte [ebp - 0x2140], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.draw_impacts]
mov byte [ebp - 0xe68], cl
movsx edx, byte [ebp - 0xe68]
xor edx, 0x34
mov byte [ebp - 0xe69], dl
mov al, byte [ebp - 0xe69]
mov byte [ebp - 0x213f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.draw_impacts]
mov byte [ebp - 0xe70], dl
movsx eax, byte [ebp - 0xe70]
xor eax, 0x34
mov byte [ebp - 0xe71], al
mov cl, byte [ebp - 0xe71]
mov byte [ebp - 0x213e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.draw_impacts]
mov byte [ebp - 0xe78], cl
movsx edx, byte [ebp - 0xe78]
xor edx, 0x34
mov byte [ebp - 0xe79], dl
mov al, byte [ebp - 0xe79]
mov byte [ebp - 0x213d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.draw_impacts]
mov byte [ebp - 0xe80], dl
movsx eax, byte [ebp - 0xe80]
xor eax, 0x34
mov byte [ebp - 0xe81], al
mov cl, byte [ebp - 0xe81]
mov byte [ebp - 0x213c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.draw_impacts]
mov byte [ebp - 0xe88], cl
movsx edx, byte [ebp - 0xe88]
xor edx, 0x34
mov byte [ebp - 0xe89], dl
mov al, byte [ebp - 0xe89]
mov byte [ebp - 0x213b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.draw_impacts]
mov byte [ebp - 0xe90], al
movsx ecx, byte [ebp - 0xe90]
xor ecx, 0x34
mov byte [ebp - 0xe91], cl
mov dl, byte [ebp - 0xe91]
mov byte [ebp - 0x213a], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.draw_impacts]
mov byte [ebp - 0xe98], dl
movsx eax, byte [ebp - 0xe98]
xor eax, 0x34
mov byte [ebp - 0xe99], al
mov cl, byte [ebp - 0xe99]
mov byte [ebp - 0x2139], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.draw_impacts]
mov byte [ebp - 0xea0], al
movsx ecx, byte [ebp - 0xea0]
xor ecx, 0x34
mov byte [ebp - 0xea1], cl
mov dl, byte [ebp - 0xea1]
mov byte [ebp - 0x2138], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.draw_impacts]
mov byte [ebp - 0xea8], dl
movsx eax, byte [ebp - 0xea8]
xor eax, 0x34
mov byte [ebp - 0xea9], al
mov cl, byte [ebp - 0xea9]
mov byte [ebp - 0x2137], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.draw_impacts]
mov byte [ebp - 0xeb0], cl
movsx edx, byte [ebp - 0xeb0]
xor edx, 0x34
mov byte [ebp - 0xeb1], dl
mov al, byte [ebp - 0xeb1]
mov byte [ebp - 0x2136], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.draw_impacts]
mov byte [ebp - 0xeb8], al
movsx ecx, byte [ebp - 0xeb8]
xor ecx, 0x34
mov byte [ebp - 0xeb9], cl
mov dl, byte [ebp - 0xeb9]
mov byte [ebp - 0x2135], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.draw_impacts]
mov byte [ebp - 0xec0], dl
movsx eax, byte [ebp - 0xec0]
xor eax, 0x34
mov byte [ebp - 0xec1], al
mov cl, byte [ebp - 0xec1]
mov byte [ebp - 0x2134], cl
lea edx, [ebp - 0x2140]
mov dword [ebp - 0x2a90], edx
mov eax, dword [ebp - 0x2a90]
mov dword [ebp - 0x2488], eax
mov dword [ebp - 0x1ebc], 0
jmp 0x10156c4c
mov ecx, dword [ebp - 0x1ebc]
add ecx, 1
mov dword [ebp - 0x1ebc], ecx
cmp dword [ebp - 0x1ebc], 0xd
jae 0x10156cce
mov edx, dword [ebp - 0x2488]
mov dword [ebp - 0x2a94], edx
mov eax, dword [ebp - 0x2a94]
add eax, dword [ebp - 0x1ebc]
mov dword [ebp - 0x2a98], eax
mov ecx, dword [ebp - 0x2a98]
mov dl, byte [ecx]
mov byte [ebp - 0xec8], dl
movsx eax, byte [ebp - 0xec8]
xor eax, 0x34
mov byte [ebp - 0xec9], al
mov cl, byte [ebp - 0xec9]
mov byte [ebp - 0xeca], cl
mov edx, dword [ebp - 0x2488]
mov dword [ebp - 0x2a9c], edx
mov eax, dword [ebp - 0x2a9c]
add eax, dword [ebp - 0x1ebc]
mov dword [ebp - 0x2aa0], eax
mov ecx, dword [ebp - 0x2aa0]
mov dl, byte [ebp - 0xeca]
mov byte [ecx], dl
jmp 0x10156c3d
mov eax, dword [ebp - 0x2488]
mov dword [ebp - 0x2aa4], eax
mov ecx, dword [ebp - 0x2aa4]
mov dword [ebp - 0x2aa8], ecx
mov edx, dword [ebp - 0x2aa8]
mov dword [ebp - 0x2aac], edx
mov eax, dword [ebp - 0x2aac]
push eax
lea ecx, [ebp - 0x3788]
call fcn.1007b880
mov byte [ebp - 4], 0x29
lea ecx, [ebp - 0x37a0]
push ecx
mov ecx, dword [ebp - 0x1ec0]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x1ec0]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x1ec0]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10156d4b
lea edx, [ebp - 0x3788]
push edx
mov ecx, dword [ebp - 0x1ec0]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x1ec0]
mov byte [eax + 0x6c], 0
mov byte [ebp - 4], 0x28
lea ecx, [ebp - 0x3788]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x37a0]
call fcn.1007c260
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x7bc
mov dword [ebp - 0x88], ecx
mov edx, dword [ebp - 0x88]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x88]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x88]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x88]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x88]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x2ab0], ecx
lea edx, [ebp - 0x88]
push edx
mov ecx, dword [ebp - 0x2ab0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x844
mov dword [ebp - 0xc8], eax
lea ecx, [ebp - 0x243e]
mov dword [ebp - 0x2ab4], ecx
mov edx, dword [ebp - 0x2ab4]
mov dword [ebp - 0x2b7c], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.visual_recoil]
mov byte [ebp - 0xed0], dl
movsx eax, byte [ebp - 0xed0]
xor eax, 0x34
mov byte [ebp - 0xed1], al
mov cl, byte [ebp - 0xed1]
mov byte [ebp - 0x2170], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.visual_recoil]
mov byte [ebp - 0xed8], al
movsx ecx, byte [ebp - 0xed8]
xor ecx, 0x34
mov byte [ebp - 0xed9], cl
mov dl, byte [ebp - 0xed9]
mov byte [ebp - 0x216f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.visual_recoil]
mov byte [ebp - 0xee0], cl
movsx edx, byte [ebp - 0xee0]
xor edx, 0x34
mov byte [ebp - 0xee1], dl
mov al, byte [ebp - 0xee1]
mov byte [ebp - 0x216e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.visual_recoil]
mov byte [ebp - 0xee8], al
movsx ecx, byte [ebp - 0xee8]
xor ecx, 0x34
mov byte [ebp - 0xee9], cl
mov dl, byte [ebp - 0xee9]
mov byte [ebp - 0x216d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.visual_recoil]
mov byte [ebp - 0xef0], cl
movsx edx, byte [ebp - 0xef0]
xor edx, 0x34
mov byte [ebp - 0xef1], dl
mov al, byte [ebp - 0xef1]
mov byte [ebp - 0x216c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.visual_recoil]
mov byte [ebp - 0xef8], al
movsx ecx, byte [ebp - 0xef8]
xor ecx, 0x34
mov byte [ebp - 0xef9], cl
mov dl, byte [ebp - 0xef9]
mov byte [ebp - 0x216b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.visual_recoil]
mov byte [ebp - 0xf00], dl
movsx eax, byte [ebp - 0xf00]
xor eax, 0x34
mov byte [ebp - 0xf01], al
mov cl, byte [ebp - 0xf01]
mov byte [ebp - 0x216a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.visual_recoil]
mov byte [ebp - 0xf08], cl
movsx edx, byte [ebp - 0xf08]
xor edx, 0x34
mov byte [ebp - 0xf09], dl
mov al, byte [ebp - 0xf09]
mov byte [ebp - 0x2169], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.visual_recoil]
mov byte [ebp - 0xf10], dl
movsx eax, byte [ebp - 0xf10]
xor eax, 0x34
mov byte [ebp - 0xf11], al
mov cl, byte [ebp - 0xf11]
mov byte [ebp - 0x2168], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.visual_recoil]
mov byte [ebp - 0xf18], cl
movsx edx, byte [ebp - 0xf18]
xor edx, 0x34
mov byte [ebp - 0xf19], dl
mov al, byte [ebp - 0xf19]
mov byte [ebp - 0x2167], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.visual_recoil]
mov byte [ebp - 0xf20], al
movsx ecx, byte [ebp - 0xf20]
xor ecx, 0x34
mov byte [ebp - 0xf21], cl
mov dl, byte [ebp - 0xf21]
mov byte [ebp - 0x2166], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.visual_recoil]
mov byte [ebp - 0xf28], dl
movsx eax, byte [ebp - 0xf28]
xor eax, 0x34
mov byte [ebp - 0xf29], al
mov cl, byte [ebp - 0xf29]
mov byte [ebp - 0x2165], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.visual_recoil]
mov byte [ebp - 0xf30], cl
movsx edx, byte [ebp - 0xf30]
xor edx, 0x34
mov byte [ebp - 0xf31], dl
mov al, byte [ebp - 0xf31]
mov byte [ebp - 0x2164], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.visual_recoil]
mov byte [ebp - 0xf38], al
movsx ecx, byte [ebp - 0xf38]
xor ecx, 0x34
mov byte [ebp - 0xf39], cl
mov dl, byte [ebp - 0xf39]
mov byte [ebp - 0x2163], dl
lea eax, [ebp - 0x2170]
mov dword [ebp - 0x2ab8], eax
mov ecx, dword [ebp - 0x2ab8]
mov dword [ebp - 0x2484], ecx
mov dword [ebp - 0x1ec4], 0
jmp 0x101570ec
mov edx, dword [ebp - 0x1ec4]
add edx, 1
mov dword [ebp - 0x1ec4], edx
cmp dword [ebp - 0x1ec4], 0xe
jae 0x1015716e
mov eax, dword [ebp - 0x2484]
mov dword [ebp - 0x2abc], eax
mov ecx, dword [ebp - 0x2abc]
add ecx, dword [ebp - 0x1ec4]
mov dword [ebp - 0x2ac0], ecx
mov edx, dword [ebp - 0x2ac0]
mov al, byte [edx]
mov byte [ebp - 0xf40], al
movsx ecx, byte [ebp - 0xf40]
xor ecx, 0x34
mov byte [ebp - 0xf41], cl
mov dl, byte [ebp - 0xf41]
mov byte [ebp - 0xf42], dl
mov eax, dword [ebp - 0x2484]
mov dword [ebp - 0x2ac4], eax
mov ecx, dword [ebp - 0x2ac4]
add ecx, dword [ebp - 0x1ec4]
mov dword [ebp - 0x2ac8], ecx
mov edx, dword [ebp - 0x2ac8]
mov al, byte [ebp - 0xf42]
mov byte [edx], al
jmp 0x101570dd
mov ecx, dword [ebp - 0x2484]
mov dword [ebp - 0x2acc], ecx
mov edx, dword [ebp - 0x2acc]
mov dword [ebp - 0x2ad0], edx
mov eax, dword [ebp - 0x2ad0]
mov dword [ebp - 0x2ad4], eax
mov ecx, dword [ebp - 0x2ad4]
push ecx
lea ecx, [ebp - 0x3eb0]
call fcn.1007b880
mov dword [ebp - 4], 0x2a
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.smoke]
mov byte [ebp - 0xf48], cl
movsx edx, byte [ebp - 0xf48]
xor edx, 0x34
mov byte [ebp - 0xf49], dl
mov al, byte [ebp - 0xf49]
mov byte [ebp - 0x2030], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.smoke]
mov byte [ebp - 0xf50], dl
movsx eax, byte [ebp - 0xf50]
xor eax, 0x34
mov byte [ebp - 0xf51], al
mov cl, byte [ebp - 0xf51]
mov byte [ebp - 0x202f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.smoke]
mov byte [ebp - 0xf58], al
movsx ecx, byte [ebp - 0xf58]
xor ecx, 0x34
mov byte [ebp - 0xf59], cl
mov dl, byte [ebp - 0xf59]
mov byte [ebp - 0x202e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.smoke]
mov byte [ebp - 0xf60], dl
movsx eax, byte [ebp - 0xf60]
xor eax, 0x34
mov byte [ebp - 0xf61], al
mov cl, byte [ebp - 0xf61]
mov byte [ebp - 0x202d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.smoke]
mov byte [ebp - 0xf68], al
movsx ecx, byte [ebp - 0xf68]
xor ecx, 0x34
mov byte [ebp - 0xf69], cl
mov dl, byte [ebp - 0xf69]
mov byte [ebp - 0x202c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.smoke]
mov byte [ebp - 0xf70], dl
movsx eax, byte [ebp - 0xf70]
xor eax, 0x34
mov byte [ebp - 0xf71], al
mov cl, byte [ebp - 0xf71]
mov byte [ebp - 0x202b], cl
lea edx, [ebp - 0x2030]
mov dword [ebp - 0x2ad8], edx
mov eax, dword [ebp - 0x2ad8]
mov dword [ebp - 0x251c], eax
mov dword [ebp - 0x1ec8], 0
jmp 0x101572fd
mov ecx, dword [ebp - 0x1ec8]
add ecx, 1
mov dword [ebp - 0x1ec8], ecx
cmp dword [ebp - 0x1ec8], 6
jae 0x1015737f
mov edx, dword [ebp - 0x251c]
mov dword [ebp - 0x2adc], edx
mov eax, dword [ebp - 0x2adc]
add eax, dword [ebp - 0x1ec8]
mov dword [ebp - 0x2ae0], eax
mov ecx, dword [ebp - 0x2ae0]
mov dl, byte [ecx]
mov byte [ebp - 0xf78], dl
movsx eax, byte [ebp - 0xf78]
xor eax, 0x34
mov byte [ebp - 0xf79], al
mov cl, byte [ebp - 0xf79]
mov byte [ebp - 0xf7a], cl
mov edx, dword [ebp - 0x251c]
mov dword [ebp - 0x2ae4], edx
mov eax, dword [ebp - 0x2ae4]
add eax, dword [ebp - 0x1ec8]
mov dword [ebp - 0x2ae8], eax
mov ecx, dword [ebp - 0x2ae8]
mov dl, byte [ebp - 0xf7a]
mov byte [ecx], dl
jmp 0x101572ee
mov eax, dword [ebp - 0x251c]
mov dword [ebp - 0x2aec], eax
mov ecx, dword [ebp - 0x2aec]
mov dword [ebp - 0x2af0], ecx
mov edx, dword [ebp - 0x2af0]
mov dword [ebp - 0x2af4], edx
mov eax, dword [ebp - 0x2af4]
push eax
lea ecx, [ebp - 0x3e98]
call fcn.1007b880
mov byte [ebp - 4], 0x2b
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x102a3608]
mov byte [ebp - 0xf80], al
movsx ecx, byte [ebp - 0xf80]
xor ecx, 0x34
mov byte [ebp - 0xf81], cl
mov dl, byte [ebp - 0xf81]
mov byte [ebp - 0x1fb4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x102a3608]
mov byte [ebp - 0xf88], cl
movsx edx, byte [ebp - 0xf88]
xor edx, 0x34
mov byte [ebp - 0xf89], dl
mov al, byte [ebp - 0xf89]
mov byte [ebp - 0x1fb3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x102a3608]
mov byte [ebp - 0xf90], dl
movsx eax, byte [ebp - 0xf90]
xor eax, 0x34
mov byte [ebp - 0xf91], al
mov cl, byte [ebp - 0xf91]
mov byte [ebp - 0x1fb2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x102a3608]
mov byte [ebp - 0xf98], cl
movsx edx, byte [ebp - 0xf98]
xor edx, 0x34
mov byte [ebp - 0xf99], dl
mov al, byte [ebp - 0xf99]
mov byte [ebp - 0x1fb1], al
lea ecx, [ebp - 0x1fb4]
mov dword [ebp - 0x2af8], ecx
mov edx, dword [ebp - 0x2af8]
mov dword [ebp - 0x2328], edx
mov dword [ebp - 0x1ecc], 0
jmp 0x101574ab
mov eax, dword [ebp - 0x1ecc]
add eax, 1
mov dword [ebp - 0x1ecc], eax
cmp dword [ebp - 0x1ecc], 4
jae 0x1015752d
mov ecx, dword [ebp - 0x2328]
mov dword [ebp - 0x2afc], ecx
mov edx, dword [ebp - 0x2afc]
add edx, dword [ebp - 0x1ecc]
mov dword [ebp - 0x2b00], edx
mov eax, dword [ebp - 0x2b00]
mov cl, byte [eax]
mov byte [ebp - 0xfa0], cl
movsx edx, byte [ebp - 0xfa0]
xor edx, 0x34
mov byte [ebp - 0xfa1], dl
mov al, byte [ebp - 0xfa1]
mov byte [ebp - 0xfa2], al
mov ecx, dword [ebp - 0x2328]
mov dword [ebp - 0x2b04], ecx
mov edx, dword [ebp - 0x2b04]
add edx, dword [ebp - 0x1ecc]
mov dword [ebp - 0x2b08], edx
mov eax, dword [ebp - 0x2b08]
mov cl, byte [ebp - 0xfa2]
mov byte [eax], cl
jmp 0x1015749c
mov edx, dword [ebp - 0x2328]
mov dword [ebp - 0x2b0c], edx
mov eax, dword [ebp - 0x2b0c]
mov dword [ebp - 0x2b10], eax
mov ecx, dword [ebp - 0x2b10]
mov dword [ebp - 0x2b14], ecx
mov edx, dword [ebp - 0x2b14]
push edx
lea ecx, [ebp - 0x3e80]
call fcn.1007b880
mov byte [ebp - 4], 0x2c
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.flashbang]
mov byte [ebp - 0xfa8], dl
movsx eax, byte [ebp - 0xfa8]
xor eax, 0x34
mov byte [ebp - 0xfa9], al
mov cl, byte [ebp - 0xfa9]
mov byte [ebp - 0x2080], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.flashbang]
mov byte [ebp - 0xfb0], al
movsx ecx, byte [ebp - 0xfb0]
xor ecx, 0x34
mov byte [ebp - 0xfb1], cl
mov dl, byte [ebp - 0xfb1]
mov byte [ebp - 0x207f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.flashbang]
mov byte [ebp - 0xfb8], cl
movsx edx, byte [ebp - 0xfb8]
xor edx, 0x34
mov byte [ebp - 0xfb9], dl
mov al, byte [ebp - 0xfb9]
mov byte [ebp - 0x207e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.flashbang]
mov byte [ebp - 0xfc0], al
movsx ecx, byte [ebp - 0xfc0]
xor ecx, 0x34
mov byte [ebp - 0xfc1], cl
mov dl, byte [ebp - 0xfc1]
mov byte [ebp - 0x207d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.flashbang]
mov byte [ebp - 0xfc8], cl
movsx edx, byte [ebp - 0xfc8]
xor edx, 0x34
mov byte [ebp - 0xfc9], dl
mov al, byte [ebp - 0xfc9]
mov byte [ebp - 0x207c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.flashbang]
mov byte [ebp - 0xfd0], al
movsx ecx, byte [ebp - 0xfd0]
xor ecx, 0x34
mov byte [ebp - 0xfd1], cl
mov dl, byte [ebp - 0xfd1]
mov byte [ebp - 0x207b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.flashbang]
mov byte [ebp - 0xfd8], dl
movsx eax, byte [ebp - 0xfd8]
xor eax, 0x34
mov byte [ebp - 0xfd9], al
mov cl, byte [ebp - 0xfd9]
mov byte [ebp - 0x207a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.flashbang]
mov byte [ebp - 0xfe0], cl
movsx edx, byte [ebp - 0xfe0]
xor edx, 0x34
mov byte [ebp - 0xfe1], dl
mov al, byte [ebp - 0xfe1]
mov byte [ebp - 0x2079], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.flashbang]
mov byte [ebp - 0xfe8], dl
movsx eax, byte [ebp - 0xfe8]
xor eax, 0x34
mov byte [ebp - 0xfe9], al
mov cl, byte [ebp - 0xfe9]
mov byte [ebp - 0x2078], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.flashbang]
mov byte [ebp - 0xff0], cl
movsx edx, byte [ebp - 0xff0]
xor edx, 0x34
mov byte [ebp - 0xff1], dl
mov al, byte [ebp - 0xff1]
mov byte [ebp - 0x2077], al
lea ecx, [ebp - 0x2080]
mov dword [ebp - 0x2b18], ecx
mov edx, dword [ebp - 0x2b18]
mov dword [ebp - 0x232c], edx
mov dword [ebp - 0x1ed0], 0
jmp 0x10157779
mov eax, dword [ebp - 0x1ed0]
add eax, 1
mov dword [ebp - 0x1ed0], eax
cmp dword [ebp - 0x1ed0], 0xa
jae 0x101577fb
mov ecx, dword [ebp - 0x232c]
mov dword [ebp - 0x2b1c], ecx
mov edx, dword [ebp - 0x2b1c]
add edx, dword [ebp - 0x1ed0]
mov dword [ebp - 0x2b20], edx
mov eax, dword [ebp - 0x2b20]
mov cl, byte [eax]
mov byte [ebp - 0xff8], cl
movsx edx, byte [ebp - 0xff8]
xor edx, 0x34
mov byte [ebp - 0xff9], dl
mov al, byte [ebp - 0xff9]
mov byte [ebp - 0xffa], al
mov ecx, dword [ebp - 0x232c]
mov dword [ebp - 0x2b24], ecx
mov edx, dword [ebp - 0x2b24]
add edx, dword [ebp - 0x1ed0]
mov dword [ebp - 0x2b28], edx
mov eax, dword [ebp - 0x2b28]
mov cl, byte [ebp - 0xffa]
mov byte [eax], cl
jmp 0x1015776a
mov edx, dword [ebp - 0x232c]
mov dword [ebp - 0x2b2c], edx
mov eax, dword [ebp - 0x2b2c]
mov dword [ebp - 0x2b30], eax
mov ecx, dword [ebp - 0x2b30]
mov dword [ebp - 0x2b34], ecx
mov edx, dword [ebp - 0x2b34]
push edx
lea ecx, [ebp - 0x3e68]
call fcn.1007b880
mov byte [ebp - 4], 0x2d
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.scope]
mov byte [ebp - 0x1000], dl
movsx eax, byte [ebp - 0x1000]
xor eax, 0x34
mov byte [ebp - 0x1001], al
mov cl, byte [ebp - 0x1001]
mov byte [ebp - 0x2038], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.scope]
mov byte [ebp - 0x1008], al
movsx ecx, byte [ebp - 0x1008]
xor ecx, 0x34
mov byte [ebp - 0x1009], cl
mov dl, byte [ebp - 0x1009]
mov byte [ebp - 0x2037], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.scope]
mov byte [ebp - 0x1010], cl
movsx edx, byte [ebp - 0x1010]
xor edx, 0x34
mov byte [ebp - 0x1011], dl
mov al, byte [ebp - 0x1011]
mov byte [ebp - 0x2036], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.scope]
mov byte [ebp - 0x1018], al
movsx ecx, byte [ebp - 0x1018]
xor ecx, 0x34
mov byte [ebp - 0x1019], cl
mov dl, byte [ebp - 0x1019]
mov byte [ebp - 0x2035], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.scope]
mov byte [ebp - 0x1020], cl
movsx edx, byte [ebp - 0x1020]
xor edx, 0x34
mov byte [ebp - 0x1021], dl
mov al, byte [ebp - 0x1021]
mov byte [ebp - 0x2034], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.scope]
mov byte [ebp - 0x1028], al
movsx ecx, byte [ebp - 0x1028]
xor ecx, 0x34
mov byte [ebp - 0x1029], cl
mov dl, byte [ebp - 0x1029]
mov byte [ebp - 0x2033], dl
lea eax, [ebp - 0x2038]
mov dword [ebp - 0x2b38], eax
mov ecx, dword [ebp - 0x2b38]
mov dword [ebp - 0x2330], ecx
mov dword [ebp - 0x1ed4], 0
jmp 0x10157987
mov edx, dword [ebp - 0x1ed4]
add edx, 1
mov dword [ebp - 0x1ed4], edx
cmp dword [ebp - 0x1ed4], 6
jae 0x10157a09
mov eax, dword [ebp - 0x2330]
mov dword [ebp - 0x2b3c], eax
mov ecx, dword [ebp - 0x2b3c]
add ecx, dword [ebp - 0x1ed4]
mov dword [ebp - 0x2b40], ecx
mov edx, dword [ebp - 0x2b40]
mov al, byte [edx]
mov byte [ebp - 0x1030], al
movsx ecx, byte [ebp - 0x1030]
xor ecx, 0x34
mov byte [ebp - 0x1031], cl
mov dl, byte [ebp - 0x1031]
mov byte [ebp - 0x1032], dl
mov eax, dword [ebp - 0x2330]
mov dword [ebp - 0x2b44], eax
mov ecx, dword [ebp - 0x2b44]
add ecx, dword [ebp - 0x1ed4]
mov dword [ebp - 0x2b48], ecx
mov edx, dword [ebp - 0x2b48]
mov al, byte [ebp - 0x1032]
mov byte [edx], al
jmp 0x10157978
mov ecx, dword [ebp - 0x2330]
mov dword [ebp - 0x2b4c], ecx
mov edx, dword [ebp - 0x2b4c]
mov dword [ebp - 0x2b50], edx
mov eax, dword [ebp - 0x2b50]
mov dword [ebp - 0x2b54], eax
mov ecx, dword [ebp - 0x2b54]
push ecx
lea ecx, [ebp - 0x3e50]
call fcn.1007b880
mov byte [ebp - 4], 0x2e
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.post_processing]
mov byte [ebp - 0x1038], cl
movsx edx, byte [ebp - 0x1038]
xor edx, 0x34
mov byte [ebp - 0x1039], dl
mov al, byte [ebp - 0x1039]
mov byte [ebp - 0x21b0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.post_processing]
mov byte [ebp - 0x1040], dl
movsx eax, byte [ebp - 0x1040]
xor eax, 0x34
mov byte [ebp - 0x1041], al
mov cl, byte [ebp - 0x1041]
mov byte [ebp - 0x21af], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x1048], al
movsx ecx, byte [ebp - 0x1048]
xor ecx, 0x34
mov byte [ebp - 0x1049], cl
mov dl, byte [ebp - 0x1049]
mov byte [ebp - 0x21ae], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.post_processing]
mov byte [ebp - 0x1050], dl
movsx eax, byte [ebp - 0x1050]
xor eax, 0x34
mov byte [ebp - 0x1051], al
mov cl, byte [ebp - 0x1051]
mov byte [ebp - 0x21ad], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x1058], al
movsx ecx, byte [ebp - 0x1058]
xor ecx, 0x34
mov byte [ebp - 0x1059], cl
mov dl, byte [ebp - 0x1059]
mov byte [ebp - 0x21ac], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.post_processing]
mov byte [ebp - 0x1060], dl
movsx eax, byte [ebp - 0x1060]
xor eax, 0x34
mov byte [ebp - 0x1061], al
mov cl, byte [ebp - 0x1061]
mov byte [ebp - 0x21ab], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.post_processing]
mov byte [ebp - 0x1068], cl
movsx edx, byte [ebp - 0x1068]
xor edx, 0x34
mov byte [ebp - 0x1069], dl
mov al, byte [ebp - 0x1069]
mov byte [ebp - 0x21aa], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x1070], al
movsx ecx, byte [ebp - 0x1070]
xor ecx, 0x34
mov byte [ebp - 0x1071], cl
mov dl, byte [ebp - 0x1071]
mov byte [ebp - 0x21a9], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.post_processing]
mov byte [ebp - 0x1078], cl
movsx edx, byte [ebp - 0x1078]
xor edx, 0x34
mov byte [ebp - 0x1079], dl
mov al, byte [ebp - 0x1079]
mov byte [ebp - 0x21a8], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x1080], al
movsx ecx, byte [ebp - 0x1080]
xor ecx, 0x34
mov byte [ebp - 0x1081], cl
mov dl, byte [ebp - 0x1081]
mov byte [ebp - 0x21a7], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.post_processing]
mov byte [ebp - 0x1088], dl
movsx eax, byte [ebp - 0x1088]
xor eax, 0x34
mov byte [ebp - 0x1089], al
mov cl, byte [ebp - 0x1089]
mov byte [ebp - 0x21a6], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.post_processing]
mov byte [ebp - 0x1090], cl
movsx edx, byte [ebp - 0x1090]
xor edx, 0x34
mov byte [ebp - 0x1091], dl
mov al, byte [ebp - 0x1091]
mov byte [ebp - 0x21a5], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x1098], al
movsx ecx, byte [ebp - 0x1098]
xor ecx, 0x34
mov byte [ebp - 0x1099], cl
mov dl, byte [ebp - 0x1099]
mov byte [ebp - 0x21a4], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.post_processing]
mov byte [ebp - 0x10a0], dl
movsx eax, byte [ebp - 0x10a0]
xor eax, 0x34
mov byte [ebp - 0x10a1], al
mov cl, byte [ebp - 0x10a1]
mov byte [ebp - 0x21a3], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.post_processing]
mov byte [ebp - 0x10a8], cl
movsx edx, byte [ebp - 0x10a8]
xor edx, 0x34
mov byte [ebp - 0x10a9], dl
mov al, byte [ebp - 0x10a9]
mov byte [ebp - 0x21a2], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.post_processing]
mov byte [ebp - 0x10b0], al
movsx ecx, byte [ebp - 0x10b0]
xor ecx, 0x34
mov byte [ebp - 0x10b1], cl
mov dl, byte [ebp - 0x10b1]
mov byte [ebp - 0x21a1], dl
lea eax, [ebp - 0x21b0]
mov dword [ebp - 0x2b58], eax
mov ecx, dword [ebp - 0x2b58]
mov dword [ebp - 0x2334], ecx
mov dword [ebp - 0x1ed8], 0
jmp 0x10157d75
mov edx, dword [ebp - 0x1ed8]
add edx, 1
mov dword [ebp - 0x1ed8], edx
cmp dword [ebp - 0x1ed8], 0x10
jae 0x10157df7
mov eax, dword [ebp - 0x2334]
mov dword [ebp - 0x2b5c], eax
mov ecx, dword [ebp - 0x2b5c]
add ecx, dword [ebp - 0x1ed8]
mov dword [ebp - 0x2b60], ecx
mov edx, dword [ebp - 0x2b60]
mov al, byte [edx]
mov byte [ebp - 0x10b8], al
movsx ecx, byte [ebp - 0x10b8]
xor ecx, 0x34
mov byte [ebp - 0x10b9], cl
mov dl, byte [ebp - 0x10b9]
mov byte [ebp - 0x10ba], dl
mov eax, dword [ebp - 0x2334]
mov dword [ebp - 0x2b64], eax
mov ecx, dword [ebp - 0x2b64]
add ecx, dword [ebp - 0x1ed8]
mov dword [ebp - 0x2b68], ecx
mov edx, dword [ebp - 0x2b68]
mov al, byte [ebp - 0x10ba]
mov byte [edx], al
jmp 0x10157d66
mov ecx, dword [ebp - 0x2334]
mov dword [ebp - 0x2b6c], ecx
mov edx, dword [ebp - 0x2b6c]
mov dword [ebp - 0x2b70], edx
mov eax, dword [ebp - 0x2b70]
mov dword [ebp - 0x2b74], eax
mov ecx, dword [ebp - 0x2b74]
push ecx
lea ecx, [ebp - 0x3e38]
call fcn.1007b880
mov dword [ebp - 4], 0x2f
lea edx, [ebp - 0x3eb0]
mov dword [ebp - 0x33c8], edx
lea eax, [ebp - 0x3e20]
mov dword [ebp - 0x33c4], eax
lea ecx, [ebp - 0x33c8]
mov dword [ebp - 0x2b78], ecx
mov edx, dword [ebp - 0x2b78]
mov eax, dword [edx]
mov ecx, dword [edx + 4]
mov dword [ebp - 0x32a0], eax
mov dword [ebp - 0x329c], ecx
mov edx, dword [ebp - 0x2b7c]
push edx
mov eax, dword [ebp - 0x329c]
push eax
mov ecx, dword [ebp - 0x32a0]
push ecx
lea ecx, [ebp - 0x3494]
call fcn.101ed250
mov byte [ebp - 4], 0x30
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x10c0], cl
movsx edx, byte [ebp - 0x10c0]
xor edx, 0x34
mov byte [ebp - 0x10c1], dl
mov al, byte [ebp - 0x10c1]
mov byte [ebp - 0x205c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x10c8], dl
movsx eax, byte [ebp - 0x10c8]
xor eax, 0x34
mov byte [ebp - 0x10c9], al
mov cl, byte [ebp - 0x10c9]
mov byte [ebp - 0x205b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.removals]
mov byte [ebp - 0x10d0], al
movsx ecx, byte [ebp - 0x10d0]
xor ecx, 0x34
mov byte [ebp - 0x10d1], cl
mov dl, byte [ebp - 0x10d1]
mov byte [ebp - 0x205a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x10d8], dl
movsx eax, byte [ebp - 0x10d8]
xor eax, 0x34
mov byte [ebp - 0x10d9], al
mov cl, byte [ebp - 0x10d9]
mov byte [ebp - 0x2059], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.removals]
mov byte [ebp - 0x10e0], al
movsx ecx, byte [ebp - 0x10e0]
xor ecx, 0x34
mov byte [ebp - 0x10e1], cl
mov dl, byte [ebp - 0x10e1]
mov byte [ebp - 0x2058], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x10e8], dl
movsx eax, byte [ebp - 0x10e8]
xor eax, 0x34
mov byte [ebp - 0x10e9], al
mov cl, byte [ebp - 0x10e9]
mov byte [ebp - 0x2057], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x10f0], cl
movsx edx, byte [ebp - 0x10f0]
xor edx, 0x34
mov byte [ebp - 0x10f1], dl
mov al, byte [ebp - 0x10f1]
mov byte [ebp - 0x2056], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.removals]
mov byte [ebp - 0x10f8], al
movsx ecx, byte [ebp - 0x10f8]
xor ecx, 0x34
mov byte [ebp - 0x10f9], cl
mov dl, byte [ebp - 0x10f9]
mov byte [ebp - 0x2055], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x1100], cl
movsx edx, byte [ebp - 0x1100]
xor edx, 0x34
mov byte [ebp - 0x1101], dl
mov al, byte [ebp - 0x1101]
mov byte [ebp - 0x2054], al
lea ecx, [ebp - 0x205c]
mov dword [ebp - 0x2b80], ecx
mov edx, dword [ebp - 0x2b80]
mov dword [ebp - 0x2338], edx
mov dword [ebp - 0x1edc], 0
jmp 0x10158075
mov eax, dword [ebp - 0x1edc]
add eax, 1
mov dword [ebp - 0x1edc], eax
cmp dword [ebp - 0x1edc], 9
jae 0x101580f7
mov ecx, dword [ebp - 0x2338]
mov dword [ebp - 0x2b84], ecx
mov edx, dword [ebp - 0x2b84]
add edx, dword [ebp - 0x1edc]
mov dword [ebp - 0x2b88], edx
mov eax, dword [ebp - 0x2b88]
mov cl, byte [eax]
mov byte [ebp - 0x1108], cl
movsx edx, byte [ebp - 0x1108]
xor edx, 0x34
mov byte [ebp - 0x1109], dl
mov al, byte [ebp - 0x1109]
mov byte [ebp - 0x110a], al
mov ecx, dword [ebp - 0x2338]
mov dword [ebp - 0x2b8c], ecx
mov edx, dword [ebp - 0x2b8c]
add edx, dword [ebp - 0x1edc]
mov dword [ebp - 0x2b90], edx
mov eax, dword [ebp - 0x2b90]
mov cl, byte [ebp - 0x110a]
mov byte [eax], cl
jmp 0x10158066
mov edx, dword [ebp - 0x2338]
mov dword [ebp - 0x2b94], edx
mov eax, dword [ebp - 0x2b94]
mov dword [ebp - 0x2b98], eax
mov ecx, dword [ebp - 0x2b98]
mov dword [ebp - 0x2b9c], ecx
mov edx, dword [ebp - 0x2b9c]
push edx
lea ecx, [ebp - 0x37d0]
call fcn.1007b880
mov byte [ebp - 4], 0x31
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x1110], dl
movsx eax, byte [ebp - 0x1110]
xor eax, 0x34
mov byte [ebp - 0x1111], al
mov cl, byte [ebp - 0x1111]
mov byte [ebp - 0x2068], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.removals]
mov byte [ebp - 0x1118], al
movsx ecx, byte [ebp - 0x1118]
xor ecx, 0x34
mov byte [ebp - 0x1119], cl
mov dl, byte [ebp - 0x1119]
mov byte [ebp - 0x2067], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x1120], cl
movsx edx, byte [ebp - 0x1120]
xor edx, 0x34
mov byte [ebp - 0x1121], dl
mov al, byte [ebp - 0x1121]
mov byte [ebp - 0x2066], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.removals]
mov byte [ebp - 0x1128], al
movsx ecx, byte [ebp - 0x1128]
xor ecx, 0x34
mov byte [ebp - 0x1129], cl
mov dl, byte [ebp - 0x1129]
mov byte [ebp - 0x2065], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x1130], cl
movsx edx, byte [ebp - 0x1130]
xor edx, 0x34
mov byte [ebp - 0x1131], dl
mov al, byte [ebp - 0x1131]
mov byte [ebp - 0x2064], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.removals]
mov byte [ebp - 0x1138], al
movsx ecx, byte [ebp - 0x1138]
xor ecx, 0x34
mov byte [ebp - 0x1139], cl
mov dl, byte [ebp - 0x1139]
mov byte [ebp - 0x2063], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x1140], dl
movsx eax, byte [ebp - 0x1140]
xor eax, 0x34
mov byte [ebp - 0x1141], al
mov cl, byte [ebp - 0x1141]
mov byte [ebp - 0x2062], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.removals]
mov byte [ebp - 0x1148], cl
movsx edx, byte [ebp - 0x1148]
xor edx, 0x34
mov byte [ebp - 0x1149], dl
mov al, byte [ebp - 0x1149]
mov byte [ebp - 0x2061], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.removals]
mov byte [ebp - 0x1150], dl
movsx eax, byte [ebp - 0x1150]
xor eax, 0x34
mov byte [ebp - 0x1151], al
mov cl, byte [ebp - 0x1151]
mov byte [ebp - 0x2060], cl
lea edx, [ebp - 0x2068]
mov dword [ebp - 0x2ba0], edx
mov eax, dword [ebp - 0x2ba0]
mov dword [ebp - 0x233c], eax
mov dword [ebp - 0x1ee0], 0
jmp 0x10158313
mov ecx, dword [ebp - 0x1ee0]
add ecx, 1
mov dword [ebp - 0x1ee0], ecx
cmp dword [ebp - 0x1ee0], 9
jae 0x10158395
mov edx, dword [ebp - 0x233c]
mov dword [ebp - 0x2ba4], edx
mov eax, dword [ebp - 0x2ba4]
add eax, dword [ebp - 0x1ee0]
mov dword [ebp - 0x2ba8], eax
mov ecx, dword [ebp - 0x2ba8]
mov dl, byte [ecx]
mov byte [ebp - 0x1158], dl
movsx eax, byte [ebp - 0x1158]
xor eax, 0x34
mov byte [ebp - 0x1159], al
mov cl, byte [ebp - 0x1159]
mov byte [ebp - 0x115a], cl
mov edx, dword [ebp - 0x233c]
mov dword [ebp - 0x2bac], edx
mov eax, dword [ebp - 0x2bac]
add eax, dword [ebp - 0x1ee0]
mov dword [ebp - 0x2bb0], eax
mov ecx, dword [ebp - 0x2bb0]
mov dl, byte [ebp - 0x115a]
mov byte [ecx], dl
jmp 0x10158304
mov eax, dword [ebp - 0x233c]
mov dword [ebp - 0x2bb4], eax
mov ecx, dword [ebp - 0x2bb4]
mov dword [ebp - 0x2bb8], ecx
mov edx, dword [ebp - 0x2bb8]
mov dword [ebp - 0x2bbc], edx
mov eax, dword [ebp - 0x2bbc]
push eax
lea ecx, [ebp - 0x37b8]
call fcn.1007b880
mov byte [ebp - 4], 0x32
lea ecx, [ebp - 0x3488]
mov dword [ebp - 0x2340], ecx
mov edx, dword [ebp - 0x2340]
mov dword [ebp - 0x2bc0], edx
mov ecx, dword [ebp - 0x2bc0]
call fcn.1007e520
nop
mov eax, dword [ebp - 0x2340]
mov dword [ebp - 0x33fc], eax
mov ecx, dword [ebp - 0x2340]
mov dword [ebp - 0x2bc4], ecx
mov edx, dword [ebp - 0x2bc4]
mov dword [ebp - 0x3400], edx
mov byte [ebp - 4], 0x33
lea eax, [ebp - 0x37d0]
push eax
mov ecx, dword [ebp - 0xc8]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0xc8]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0xc8]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1015845e
lea ecx, [ebp - 0x37b8]
push ecx
mov ecx, dword [ebp - 0xc8]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0xc8]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10158478
mov dword [ebp - 0x259c], 0xf
jmp 0x10158482
mov dword [ebp - 0x259c], 0
mov ecx, dword [ebp - 0xc8]
mov edx, dword [ebp - 0x259c]
mov dword [ecx + 0xa4], edx
mov eax, dword [ebp - 0xc8]
mov ecx, dword [eax + 0xa4]
add ecx, 0x14
mov dword [ebp - 0x25a0], ecx
mov edx, dword [ebp - 0xc8]
mov eax, dword [ebp - 0x25a0]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0xc8]
mov edx, dword [ebp - 0x25a0]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x3494]
mov dword [ebp - 0x25a4], eax
mov ecx, dword [ebp - 0x25a4]
mov edx, dword [ecx]
mov dword [ebp - 0x2bc8], edx
mov eax, dword [ebp - 0x2bc8]
mov dword [ebp - 0x2bcc], eax
mov ecx, dword [ebp - 0x2bcc]
mov dword [ebp - 0x2bd0], ecx
mov edx, dword [ebp - 0x2bd0]
mov dword [ebp - 0x1fb8], edx
mov eax, dword [ebp - 0x25a4]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x2bd4], ecx
mov edx, dword [ebp - 0x2bd4]
mov dword [ebp - 0x2bd8], edx
mov eax, dword [ebp - 0x2bd8]
mov dword [ebp - 0x2bdc], eax
mov ecx, dword [ebp - 0x2bdc]
mov dword [ebp - 0x2be0], ecx
jmp 0x10158549
mov edx, dword [ebp - 0x1fb8]
add edx, 0x18
mov dword [ebp - 0x1fb8], edx
mov eax, dword [ebp - 0x1fb8]
cmp eax, dword [ebp - 0x2be0]
je 0x1015858a
mov ecx, dword [ebp - 0x1fb8]
mov dword [ebp - 0x2be4], ecx
mov edx, dword [ebp - 0xc8]
add edx, 0x88
mov dword [ebp - 0x2be8], edx
mov eax, dword [ebp - 0x2be4]
push eax
mov ecx, dword [ebp - 0x2be8]
call fcn.100d29a0
nop
jmp 0x1015853a
lea ecx, [ebp - 0x3488]
mov dword [ebp - 0x25a8], ecx
mov edx, dword [ebp - 0x25a8]
mov eax, dword [edx]
mov dword [ebp - 0x2bec], eax
mov ecx, dword [ebp - 0x2bec]
mov dword [ebp - 0x2bf0], ecx
mov edx, dword [ebp - 0x2bf0]
mov dword [ebp - 0x2bf4], edx
mov eax, dword [ebp - 0x2bf4]
mov dword [ebp - 0x1fbc], eax
mov ecx, dword [ebp - 0x25a8]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x2bf8], edx
mov eax, dword [ebp - 0x2bf8]
mov dword [ebp - 0x2bfc], eax
mov ecx, dword [ebp - 0x2bfc]
mov dword [ebp - 0x2c00], ecx
mov edx, dword [ebp - 0x2c00]
mov dword [ebp - 0x2c04], edx
jmp 0x1015860c
mov eax, dword [ebp - 0x1fbc]
add eax, 4
mov dword [ebp - 0x1fbc], eax
mov ecx, dword [ebp - 0x1fbc]
cmp ecx, dword [ebp - 0x2c04]
je 0x101587a4
mov edx, dword [ebp - 0x1fbc]
mov dword [ebp - 0x2c08], edx
mov eax, dword [ebp - 0x2c08]
mov ecx, dword [eax]
mov dword [ebp - 0x1c], ecx
mov edx, dword [ebp - 0xc8]
add edx, 0x98
mov dword [ebp - 0x2c0c], edx
lea eax, [ebp - 0x3404]
push eax
mov ecx, dword [ebp - 0x2c0c]
call fcn.1007a250
mov ecx, dword [eax]
mov dword [ebp - 0x2c14], ecx
mov edx, dword [ebp - 0xc8]
add edx, 0x98
mov dword [ebp - 0x2c10], edx
lea eax, [ebp - 0x3408]
push eax
mov ecx, dword [ebp - 0x2c10]
call fcn.1007a290
mov ecx, dword [eax]
mov dword [ebp - 0x2c18], ecx
lea edx, [ebp - 0x1c]
push edx
mov eax, dword [ebp - 0x2c14]
push eax
mov ecx, dword [ebp - 0x2c18]
push ecx
lea edx, [ebp - 0x340c]
push edx
call fcn.1007d760
add esp, 0x10
mov dword [ebp - 0x2c20], eax
mov eax, dword [ebp - 0xc8]
add eax, 0x98
mov dword [ebp - 0x2c1c], eax
lea ecx, [ebp - 0x3410]
push ecx
mov ecx, dword [ebp - 0x2c1c]
call fcn.1007a250
mov dword [ebp - 0x2c24], eax
mov edx, dword [ebp - 0x2c20]
mov eax, dword [ebp - 0x2c24]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x101586fb
mov dword [ebp - 0x25ac], 1
jmp 0x10158705
mov dword [ebp - 0x25ac], 0
mov dl, byte [ebp - 0x25ac]
mov byte [ebp - 0x115b], dl
mov al, byte [ebp - 0x115b]
mov byte [ebp - 0x115c], al
mov ecx, dword [ebp - 0xc8]
add ecx, 0x88
mov dword [ebp - 0x25b0], ecx
mov edx, dword [ebp - 0x25b0]
mov eax, dword [ebp - 0x25b0]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x2c28], eax
mov edx, dword [ebp - 0x2c28]
cmp dword [ebp - 0x1c], edx
jae 0x1015877c
mov eax, dword [ebp - 0xc8]
add eax, 0x98
mov dword [ebp - 0x2c2c], eax
lea ecx, [ebp - 0x1c]
push ecx
mov ecx, dword [ebp - 0x2c2c]
call fcn.1007d7f0
nop
movzx edx, byte [ebp - 0x115c]
test edx, edx
je 0x1015879f
mov eax, dword [ebp - 0xc8]
cmp dword [eax + 0x64], 0
je 0x1015879f
mov ecx, dword [ebp - 0xc8]
mov edx, dword [ecx + 0x64]
call edx
nop
jmp 0x101585fd
mov byte [ebp - 4], 0x32
lea ecx, [ebp - 0x3488]
call fcn.1007baa0
nop
mov byte [ebp - 4], 0x31
lea ecx, [ebp - 0x37b8]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x30
lea ecx, [ebp - 0x37d0]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x2f
lea ecx, [ebp - 0x3494]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 6
push 0x18
lea eax, [ebp - 0x3eb0]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0xc0]
add ecx, 0x844
mov dword [ebp - 0x8c], ecx
mov edx, dword [ebp - 0x8c]
mov dword [edx + 0x18], 1
mov eax, dword [ebp - 0x8c]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x8c]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x8c]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x8c]
mov edx, dword [ebp - 0xc0]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0xc0]
add ecx, 0x18
mov dword [ebp - 0x2c30], ecx
lea edx, [ebp - 0x8c]
push edx
mov ecx, dword [ebp - 0x2c30]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x8ec
mov dword [ebp - 0x1eec], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + 0x102a3624]
mov byte [ebp - 0x1160], al
movsx ecx, byte [ebp - 0x1160]
xor ecx, 0x34
mov byte [ebp - 0x1161], cl
mov dl, byte [ebp - 0x1161]
mov byte [ebp - 0x1fc0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + 0x102a3624]
mov byte [ebp - 0x1168], cl
movsx edx, byte [ebp - 0x1168]
xor edx, 0x34
mov byte [ebp - 0x1169], dl
mov al, byte [ebp - 0x1169]
mov byte [ebp - 0x1fbf], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + 0x102a3624]
mov byte [ebp - 0x1170], dl
movsx eax, byte [ebp - 0x1170]
xor eax, 0x34
mov byte [ebp - 0x1171], al
mov cl, byte [ebp - 0x1171]
mov byte [ebp - 0x1fbe], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + 0x102a3624]
mov byte [ebp - 0x1178], cl
movsx edx, byte [ebp - 0x1178]
xor edx, 0x34
mov byte [ebp - 0x1179], dl
mov al, byte [ebp - 0x1179]
mov byte [ebp - 0x1fbd], al
lea ecx, [ebp - 0x1fc0]
mov dword [ebp - 0x2c34], ecx
mov edx, dword [ebp - 0x2c34]
mov dword [ebp - 0x2348], edx
mov dword [ebp - 0x1ee4], 0
jmp 0x1015897d
mov eax, dword [ebp - 0x1ee4]
add eax, 1
mov dword [ebp - 0x1ee4], eax
cmp dword [ebp - 0x1ee4], 4
jae 0x101589ff
mov ecx, dword [ebp - 0x2348]
mov dword [ebp - 0x2c38], ecx
mov edx, dword [ebp - 0x2c38]
add edx, dword [ebp - 0x1ee4]
mov dword [ebp - 0x2c3c], edx
mov eax, dword [ebp - 0x2c3c]
mov cl, byte [eax]
mov byte [ebp - 0x1180], cl
movsx edx, byte [ebp - 0x1180]
xor edx, 0x34
mov byte [ebp - 0x1181], dl
mov al, byte [ebp - 0x1181]
mov byte [ebp - 0x1182], al
mov ecx, dword [ebp - 0x2348]
mov dword [ebp - 0x2c40], ecx
mov edx, dword [ebp - 0x2c40]
add edx, dword [ebp - 0x1ee4]
mov dword [ebp - 0x2c44], edx
mov eax, dword [ebp - 0x2c44]
mov cl, byte [ebp - 0x1182]
mov byte [eax], cl
jmp 0x1015896e
mov edx, dword [ebp - 0x2348]
mov dword [ebp - 0x2c48], edx
mov eax, dword [ebp - 0x2c48]
mov dword [ebp - 0x2c4c], eax
mov ecx, dword [ebp - 0x2c4c]
mov dword [ebp - 0x2c50], ecx
mov edx, dword [ebp - 0x2c50]
push edx
lea ecx, [ebp - 0x3800]
call fcn.1007b880
mov dword [ebp - 4], 0x34
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.override_fov]
mov byte [ebp - 0x1188], dl
movsx eax, byte [ebp - 0x1188]
xor eax, 0x34
mov byte [ebp - 0x1189], al
mov cl, byte [ebp - 0x1189]
mov byte [ebp - 0x2120], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.override_fov]
mov byte [ebp - 0x1190], al
movsx ecx, byte [ebp - 0x1190]
xor ecx, 0x34
mov byte [ebp - 0x1191], cl
mov dl, byte [ebp - 0x1191]
mov byte [ebp - 0x211f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.override_fov]
mov byte [ebp - 0x1198], cl
movsx edx, byte [ebp - 0x1198]
xor edx, 0x34
mov byte [ebp - 0x1199], dl
mov al, byte [ebp - 0x1199]
mov byte [ebp - 0x211e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.override_fov]
mov byte [ebp - 0x11a0], al
movsx ecx, byte [ebp - 0x11a0]
xor ecx, 0x34
mov byte [ebp - 0x11a1], cl
mov dl, byte [ebp - 0x11a1]
mov byte [ebp - 0x211d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.override_fov]
mov byte [ebp - 0x11a8], cl
movsx edx, byte [ebp - 0x11a8]
xor edx, 0x34
mov byte [ebp - 0x11a9], dl
mov al, byte [ebp - 0x11a9]
mov byte [ebp - 0x211c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.override_fov]
mov byte [ebp - 0x11b0], al
movsx ecx, byte [ebp - 0x11b0]
xor ecx, 0x34
mov byte [ebp - 0x11b1], cl
mov dl, byte [ebp - 0x11b1]
mov byte [ebp - 0x211b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.override_fov]
mov byte [ebp - 0x11b8], dl
movsx eax, byte [ebp - 0x11b8]
xor eax, 0x34
mov byte [ebp - 0x11b9], al
mov cl, byte [ebp - 0x11b9]
mov byte [ebp - 0x211a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.override_fov]
mov byte [ebp - 0x11c0], cl
movsx edx, byte [ebp - 0x11c0]
xor edx, 0x34
mov byte [ebp - 0x11c1], dl
mov al, byte [ebp - 0x11c1]
mov byte [ebp - 0x2119], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.override_fov]
mov byte [ebp - 0x11c8], dl
movsx eax, byte [ebp - 0x11c8]
xor eax, 0x34
mov byte [ebp - 0x11c9], al
mov cl, byte [ebp - 0x11c9]
mov byte [ebp - 0x2118], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.override_fov]
mov byte [ebp - 0x11d0], cl
movsx edx, byte [ebp - 0x11d0]
xor edx, 0x34
mov byte [ebp - 0x11d1], dl
mov al, byte [ebp - 0x11d1]
mov byte [ebp - 0x2117], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.override_fov]
mov byte [ebp - 0x11d8], al
movsx ecx, byte [ebp - 0x11d8]
xor ecx, 0x34
mov byte [ebp - 0x11d9], cl
mov dl, byte [ebp - 0x11d9]
mov byte [ebp - 0x2116], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.override_fov]
mov byte [ebp - 0x11e0], dl
movsx eax, byte [ebp - 0x11e0]
xor eax, 0x34
mov byte [ebp - 0x11e1], al
mov cl, byte [ebp - 0x11e1]
mov byte [ebp - 0x2115], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.override_fov]
mov byte [ebp - 0x11e8], cl
movsx edx, byte [ebp - 0x11e8]
xor edx, 0x34
mov byte [ebp - 0x11e9], dl
mov al, byte [ebp - 0x11e9]
mov byte [ebp - 0x2114], al
lea ecx, [ebp - 0x2120]
mov dword [ebp - 0x2c54], ecx
mov edx, dword [ebp - 0x2c54]
mov dword [ebp - 0x234c], edx
mov dword [ebp - 0x1ee8], 0
jmp 0x10158cde
mov eax, dword [ebp - 0x1ee8]
add eax, 1
mov dword [ebp - 0x1ee8], eax
cmp dword [ebp - 0x1ee8], 0xd
jae 0x10158d60
mov ecx, dword [ebp - 0x234c]
mov dword [ebp - 0x2c58], ecx
mov edx, dword [ebp - 0x2c58]
add edx, dword [ebp - 0x1ee8]
mov dword [ebp - 0x2c5c], edx
mov eax, dword [ebp - 0x2c5c]
mov cl, byte [eax]
mov byte [ebp - 0x11f0], cl
movsx edx, byte [ebp - 0x11f0]
xor edx, 0x34
mov byte [ebp - 0x11f1], dl
mov al, byte [ebp - 0x11f1]
mov byte [ebp - 0x11f2], al
mov ecx, dword [ebp - 0x234c]
mov dword [ebp - 0x2c60], ecx
mov edx, dword [ebp - 0x2c60]
add edx, dword [ebp - 0x1ee8]
mov dword [ebp - 0x2c64], edx
mov eax, dword [ebp - 0x2c64]
mov cl, byte [ebp - 0x11f2]
mov byte [eax], cl
jmp 0x10158ccf
mov edx, dword [ebp - 0x234c]
mov dword [ebp - 0x2c68], edx
mov eax, dword [ebp - 0x2c68]
mov dword [ebp - 0x2c6c], eax
mov ecx, dword [ebp - 0x2c6c]
mov dword [ebp - 0x2c70], ecx
mov edx, dword [ebp - 0x2c70]
push edx
lea ecx, [ebp - 0x37e8]
call fcn.1007b880
mov byte [ebp - 4], 0x35
lea eax, [ebp - 0x3800]
push eax
mov ecx, dword [ebp - 0x1eec]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x1eec]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x1eec]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10158ddd
lea ecx, [ebp - 0x37e8]
push ecx
mov ecx, dword [ebp - 0x1eec]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x1eec]
mov byte [edx + 0x6c], 0
mov byte [ebp - 4], 0x34
lea ecx, [ebp - 0x37e8]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x3800]
call fcn.1007c260
nop
mov eax, dword [ebp - 0xc0]
add eax, 0x8ec
mov dword [ebp - 0x90], eax
mov ecx, dword [ebp - 0x90]
mov dword [ecx + 0x18], 1
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 - 0xc0]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0xc0]
add eax, 0x18
mov dword [ebp - 0x2c74], eax
lea ecx, [ebp - 0x90]
push ecx
mov ecx, dword [ebp - 0x2c74]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0xc0]
add edx, 0x974
mov dword [ebp - 0xe4], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x102a2a9c]
mov word [ebp - 0x24d8], dx
movzx eax, word [ebp - 0x24d8]
xor eax, 0x34
mov word [ebp - 0x24da], ax
mov cx, word [ebp - 0x24da]
mov word [ebp - 0x25b4], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x102a2a9c]
mov word [ebp - 0x24e8], ax
movzx ecx, word [ebp - 0x24e8]
xor ecx, 0x34
mov word [ebp - 0x24ea], cx
mov dx, word [ebp - 0x24ea]
mov word [ebp - 0x25b2], dx
lea eax, [ebp - 0x25b4]
mov dword [ebp - 0x2c78], eax
mov ecx, dword [ebp - 0x2c78]
mov dword [ebp - 0x2350], ecx
mov dword [ebp - 0x1ef0], 0
jmp 0x10158f31