Function at 0x101132b0
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 0x1029a520
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x6190
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 - 0x290], ecx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x1944], dl
movsx eax, byte [ebp - 0x1944]
xor eax, 0x34
mov byte [ebp - 0x1945], al
mov cl, byte [ebp - 0x1945]
mov byte [ebp - 0x23bc], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x194c], al
movsx ecx, byte [ebp - 0x194c]
xor ecx, 0x34
mov byte [ebp - 0x194d], cl
mov dl, byte [ebp - 0x194d]
mov byte [ebp - 0x23bb], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x1954], cl
movsx edx, byte [ebp - 0x1954]
xor edx, 0x34
mov byte [ebp - 0x1955], dl
mov al, byte [ebp - 0x1955]
mov byte [ebp - 0x23ba], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x195c], al
movsx ecx, byte [ebp - 0x195c]
xor ecx, 0x34
mov byte [ebp - 0x195d], cl
mov dl, byte [ebp - 0x195d]
mov byte [ebp - 0x23b9], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x1964], cl
movsx edx, byte [ebp - 0x1964]
xor edx, 0x34
mov byte [ebp - 0x1965], dl
mov al, byte [ebp - 0x1965]
mov byte [ebp - 0x23b8], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.anti_aim]
mov byte [ebp - 0x196c], al
movsx ecx, byte [ebp - 0x196c]
xor ecx, 0x34
mov byte [ebp - 0x196d], cl
mov dl, byte [ebp - 0x196d]
mov byte [ebp - 0x23b7], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x1974], dl
movsx eax, byte [ebp - 0x1974]
xor eax, 0x34
mov byte [ebp - 0x1975], al
mov cl, byte [ebp - 0x1975]
mov byte [ebp - 0x23b6], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.anti_aim]
mov byte [ebp - 0x197c], cl
movsx edx, byte [ebp - 0x197c]
xor edx, 0x34
mov byte [ebp - 0x197d], dl
mov al, byte [ebp - 0x197d]
mov byte [ebp - 0x23b5], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.anti_aim]
mov byte [ebp - 0x1984], dl
movsx eax, byte [ebp - 0x1984]
xor eax, 0x34
mov byte [ebp - 0x1985], al
mov cl, byte [ebp - 0x1985]
mov byte [ebp - 0x23b4], cl
lea edx, [ebp - 0x23bc]
mov dword [ebp - 0x4444], edx
mov eax, dword [ebp - 0x4444]
mov dword [ebp - 0x2784], eax
mov dword [ebp - 0x2190], 0
jmp 0x101134db
mov ecx, dword [ebp - 0x2190]
add ecx, 1
mov dword [ebp - 0x2190], ecx
cmp dword [ebp - 0x2190], 9
jae 0x1011355d
mov edx, dword [ebp - 0x2784]
mov dword [ebp - 0x4630], edx
mov eax, dword [ebp - 0x4630]
add eax, dword [ebp - 0x2190]
mov dword [ebp - 0x4680], eax
mov ecx, dword [ebp - 0x4680]
mov dl, byte [ecx]
mov byte [ebp - 0x198c], dl
movsx eax, byte [ebp - 0x198c]
xor eax, 0x34
mov byte [ebp - 0x198d], al
mov cl, byte [ebp - 0x198d]
mov byte [ebp - 0x198e], cl
mov edx, dword [ebp - 0x2784]
mov dword [ebp - 0x468c], edx
mov eax, dword [ebp - 0x468c]
add eax, dword [ebp - 0x2190]
mov dword [ebp - 0x2ba8], eax
mov ecx, dword [ebp - 0x2ba8]
mov dl, byte [ebp - 0x198e]
mov byte [ecx], dl
jmp 0x101134cc
mov eax, dword [ebp - 0x2784]
mov dword [ebp - 0x2bb4], eax
mov ecx, dword [ebp - 0x2bb4]
mov dword [ebp - 0x2c04], ecx
mov edx, dword [ebp - 0x2c04]
mov dword [ebp - 0x2c10], edx
mov eax, dword [ebp - 0x2c10]
push eax
lea ecx, [ebp - 0x4888]
call fcn.1007b880
mov dword [ebp - 4], 0
lea ecx, [ebp - 0x4888]
push ecx
mov ecx, dword [ebp - 0x290]
call fcn.1008d0b0
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4888]
call fcn.1007c260
nop
mov edx, dword [ebp - 0x290]
add edx, 0x30
mov dword [ebp - 0x2184], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x1994], dl
movsx eax, byte [ebp - 0x1994]
xor eax, 0x34
mov byte [ebp - 0x1995], al
mov cl, byte [ebp - 0x1995]
mov byte [ebp - 0x2378], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.enable]
mov byte [ebp - 0x199c], al
movsx ecx, byte [ebp - 0x199c]
xor ecx, 0x34
mov byte [ebp - 0x199d], cl
mov dl, byte [ebp - 0x199d]
mov byte [ebp - 0x2377], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x19a4], cl
movsx edx, byte [ebp - 0x19a4]
xor edx, 0x34
mov byte [ebp - 0x19a5], dl
mov al, byte [ebp - 0x19a5]
mov byte [ebp - 0x2376], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.enable]
mov byte [ebp - 0x19ac], al
movsx ecx, byte [ebp - 0x19ac]
xor ecx, 0x34
mov byte [ebp - 0x19ad], cl
mov dl, byte [ebp - 0x19ad]
mov byte [ebp - 0x2375], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x19b4], cl
movsx edx, byte [ebp - 0x19b4]
xor edx, 0x34
mov byte [ebp - 0x19b5], dl
mov al, byte [ebp - 0x19b5]
mov byte [ebp - 0x2374], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.enable]
mov byte [ebp - 0x19bc], al
movsx ecx, byte [ebp - 0x19bc]
xor ecx, 0x34
mov byte [ebp - 0x19bd], cl
mov dl, byte [ebp - 0x19bd]
mov byte [ebp - 0x2373], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x19c4], dl
movsx eax, byte [ebp - 0x19c4]
xor eax, 0x34
mov byte [ebp - 0x19c5], al
mov cl, byte [ebp - 0x19c5]
mov byte [ebp - 0x2372], cl
lea edx, [ebp - 0x2378]
mov dword [ebp - 0x2c60], edx
mov eax, dword [ebp - 0x2c60]
mov dword [ebp - 0x2788], eax
mov dword [ebp - 0x218c], 0
jmp 0x10113751
mov ecx, dword [ebp - 0x218c]
add ecx, 1
mov dword [ebp - 0x218c], ecx
cmp dword [ebp - 0x218c], 7
jae 0x101137d3
mov edx, dword [ebp - 0x2788]
mov dword [ebp - 0x2c6c], edx
mov eax, dword [ebp - 0x2c6c]
add eax, dword [ebp - 0x218c]
mov dword [ebp - 0x2c9c], eax
mov ecx, dword [ebp - 0x2c9c]
mov dl, byte [ecx]
mov byte [ebp - 0x19cc], dl
movsx eax, byte [ebp - 0x19cc]
xor eax, 0x34
mov byte [ebp - 0x19cd], al
mov cl, byte [ebp - 0x19cd]
mov byte [ebp - 0x19ce], cl
mov edx, dword [ebp - 0x2788]
mov dword [ebp - 0x2ca8], edx
mov eax, dword [ebp - 0x2ca8]
add eax, dword [ebp - 0x218c]
mov dword [ebp - 0x2dcc], eax
mov ecx, dword [ebp - 0x2dcc]
mov dl, byte [ebp - 0x19ce]
mov byte [ecx], dl
jmp 0x10113742
mov eax, dword [ebp - 0x2788]
mov dword [ebp - 0x2dd8], eax
mov ecx, dword [ebp - 0x2dd8]
mov dword [ebp - 0x2e28], ecx
mov edx, dword [ebp - 0x2e28]
mov dword [ebp - 0x2e34], edx
mov eax, dword [ebp - 0x2e34]
push eax
lea ecx, [ebp - 0x48b8]
call fcn.1007b880
mov dword [ebp - 4], 1
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.enable]
mov byte [ebp - 0x19d4], al
movsx ecx, byte [ebp - 0x19d4]
xor ecx, 0x34
mov byte [ebp - 0x19d5], cl
mov dl, byte [ebp - 0x19d5]
mov byte [ebp - 0x2380], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x19dc], cl
movsx edx, byte [ebp - 0x19dc]
xor edx, 0x34
mov byte [ebp - 0x19dd], dl
mov al, byte [ebp - 0x19dd]
mov byte [ebp - 0x237f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x19e4], dl
movsx eax, byte [ebp - 0x19e4]
xor eax, 0x34
mov byte [ebp - 0x19e5], al
mov cl, byte [ebp - 0x19e5]
mov byte [ebp - 0x237e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x19ec], cl
movsx edx, byte [ebp - 0x19ec]
xor edx, 0x34
mov byte [ebp - 0x19ed], dl
mov al, byte [ebp - 0x19ed]
mov byte [ebp - 0x237d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.enable]
mov byte [ebp - 0x19f4], dl
movsx eax, byte [ebp - 0x19f4]
xor eax, 0x34
mov byte [ebp - 0x19f5], al
mov cl, byte [ebp - 0x19f5]
mov byte [ebp - 0x237c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.enable]
mov byte [ebp - 0x19fc], cl
movsx edx, byte [ebp - 0x19fc]
xor edx, 0x34
mov byte [ebp - 0x19fd], dl
mov al, byte [ebp - 0x19fd]
mov byte [ebp - 0x237b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.enable]
mov byte [ebp - 0x1a04], al
movsx ecx, byte [ebp - 0x1a04]
xor ecx, 0x34
mov byte [ebp - 0x1a05], cl
mov dl, byte [ebp - 0x1a05]
mov byte [ebp - 0x237a], dl
lea eax, [ebp - 0x2380]
mov dword [ebp - 0x2e40], eax
mov ecx, dword [ebp - 0x2e40]
mov dword [ebp - 0x2790], ecx
mov dword [ebp - 0x2188], 0
jmp 0x10113992
mov edx, dword [ebp - 0x2188]
add edx, 1
mov dword [ebp - 0x2188], edx
cmp dword [ebp - 0x2188], 7
jae 0x10113a14
mov eax, dword [ebp - 0x2790]
mov dword [ebp - 0x2e90], eax
mov ecx, dword [ebp - 0x2e90]
add ecx, dword [ebp - 0x2188]
mov dword [ebp - 0x2e9c], ecx
mov edx, dword [ebp - 0x2e9c]
mov al, byte [edx]
mov byte [ebp - 0x1a0c], al
movsx ecx, byte [ebp - 0x1a0c]
xor ecx, 0x34
mov byte [ebp - 0x1a0d], cl
mov dl, byte [ebp - 0x1a0d]
mov byte [ebp - 0x1a0e], dl
mov eax, dword [ebp - 0x2790]
mov dword [ebp - 0x2ea8], eax
mov ecx, dword [ebp - 0x2ea8]
add ecx, dword [ebp - 0x2188]
mov dword [ebp - 0x2fac], ecx
mov edx, dword [ebp - 0x2fac]
mov al, byte [ebp - 0x1a0e]
mov byte [edx], al
jmp 0x10113983
mov ecx, dword [ebp - 0x2790]
mov dword [ebp - 0x2fb8], ecx
mov edx, dword [ebp - 0x2fb8]
mov dword [ebp - 0x3008], edx
mov eax, dword [ebp - 0x3008]
mov dword [ebp - 0x3014], eax
mov ecx, dword [ebp - 0x3014]
push ecx
lea ecx, [ebp - 0x48a0]
call fcn.1007b880
mov byte [ebp - 4], 2
lea edx, [ebp - 0x48b8]
push edx
mov ecx, dword [ebp - 0x2184]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x2184]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x2184]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10113a91
lea eax, [ebp - 0x48a0]
push eax
mov ecx, dword [ebp - 0x2184]
add ecx, 0x70
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x2184]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 1
lea ecx, [ebp - 0x48a0]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x48b8]
call fcn.1007c260
nop
mov edx, dword [ebp - 0x290]
add edx, 0x30
mov dword [ebp - 0xc4], edx
mov eax, dword [ebp - 0xc4]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0xc4]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0xc4]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0xc4]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0xc4]
mov eax, dword [ebp - 0x290]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x290]
add edx, 0x18
mov dword [ebp - 0x3110], edx
lea eax, [ebp - 0xc4]
push eax
mov ecx, dword [ebp - 0x3110]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0xb8
mov dword [ebp - 0x2178], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.edge]
mov byte [ebp - 0x1a14], cl
movsx edx, byte [ebp - 0x1a14]
xor edx, 0x34
mov byte [ebp - 0x1a15], dl
mov al, byte [ebp - 0x1a15]
mov byte [ebp - 0x2338], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x1a1c], dl
movsx eax, byte [ebp - 0x1a1c]
xor eax, 0x34
mov byte [ebp - 0x1a1d], al
mov cl, byte [ebp - 0x1a1d]
mov byte [ebp - 0x2337], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.edge]
mov byte [ebp - 0x1a24], al
movsx ecx, byte [ebp - 0x1a24]
xor ecx, 0x34
mov byte [ebp - 0x1a25], cl
mov dl, byte [ebp - 0x1a25]
mov byte [ebp - 0x2336], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x1a2c], dl
movsx eax, byte [ebp - 0x1a2c]
xor eax, 0x34
mov byte [ebp - 0x1a2d], al
mov cl, byte [ebp - 0x1a2d]
mov byte [ebp - 0x2335], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.edge]
mov byte [ebp - 0x1a34], al
movsx ecx, byte [ebp - 0x1a34]
xor ecx, 0x34
mov byte [ebp - 0x1a35], cl
mov dl, byte [ebp - 0x1a35]
mov byte [ebp - 0x2334], dl
lea eax, [ebp - 0x2338]
mov dword [ebp - 0x311c], eax
mov ecx, dword [ebp - 0x311c]
mov dword [ebp - 0x2794], ecx
mov dword [ebp - 0x2180], 0
jmp 0x10113c68
mov edx, dword [ebp - 0x2180]
add edx, 1
mov dword [ebp - 0x2180], edx
cmp dword [ebp - 0x2180], 5
jae 0x10113cea
mov eax, dword [ebp - 0x2794]
mov dword [ebp - 0x31c8], eax
mov ecx, dword [ebp - 0x31c8]
add ecx, dword [ebp - 0x2180]
mov dword [ebp - 0x3288], ecx
mov edx, dword [ebp - 0x3288]
mov al, byte [edx]
mov byte [ebp - 0x1a3c], al
movsx ecx, byte [ebp - 0x1a3c]
xor ecx, 0x34
mov byte [ebp - 0x1a3d], cl
mov dl, byte [ebp - 0x1a3d]
mov byte [ebp - 0x1a3e], dl
mov eax, dword [ebp - 0x2794]
mov dword [ebp - 0x32c0], eax
mov ecx, dword [ebp - 0x32c0]
add ecx, dword [ebp - 0x2180]
mov dword [ebp - 0x32cc], ecx
mov edx, dword [ebp - 0x32cc]
mov al, byte [ebp - 0x1a3e]
mov byte [edx], al
jmp 0x10113c59
mov ecx, dword [ebp - 0x2794]
mov dword [ebp - 0x3304], ecx
mov edx, dword [ebp - 0x3304]
mov dword [ebp - 0x3310], edx
mov eax, dword [ebp - 0x3310]
mov dword [ebp - 0x3348], eax
mov ecx, dword [ebp - 0x3348]
push ecx
lea ecx, [ebp - 0x48e8]
call fcn.1007b880
mov dword [ebp - 4], 3
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.edge]
mov byte [ebp - 0x1a44], cl
movsx edx, byte [ebp - 0x1a44]
xor edx, 0x34
mov byte [ebp - 0x1a49], dl
mov al, byte [ebp - 0x1a49]
mov byte [ebp - 0x2330], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x1a50], dl
movsx eax, byte [ebp - 0x1a50]
xor eax, 0x34
mov byte [ebp - 0x1a51], al
mov cl, byte [ebp - 0x1a51]
mov byte [ebp - 0x232f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.edge]
mov byte [ebp - 0x1a58], al
movsx ecx, byte [ebp - 0x1a58]
xor ecx, 0x34
mov byte [ebp - 0x1a59], cl
mov dl, byte [ebp - 0x1a59]
mov byte [ebp - 0x232e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.edge]
mov byte [ebp - 0x1a60], dl
movsx eax, byte [ebp - 0x1a60]
xor eax, 0x34
mov byte [ebp - 0x1a61], al
mov cl, byte [ebp - 0x1a61]
mov byte [ebp - 0x232d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.edge]
mov byte [ebp - 0x1a68], al
movsx ecx, byte [ebp - 0x1a68]
xor ecx, 0x34
mov byte [ebp - 0x1a69], cl
mov dl, byte [ebp - 0x1a69]
mov byte [ebp - 0x232c], dl
lea eax, [ebp - 0x2330]
mov dword [ebp - 0x3354], eax
mov ecx, dword [ebp - 0x3354]
mov dword [ebp - 0x2798], ecx
mov dword [ebp - 0x217c], 0
jmp 0x10113e49
mov edx, dword [ebp - 0x217c]
add edx, 1
mov dword [ebp - 0x217c], edx
cmp dword [ebp - 0x217c], 5
jae 0x10113ecb
mov eax, dword [ebp - 0x2798]
mov dword [ebp - 0x338c], eax
mov ecx, dword [ebp - 0x338c]
add ecx, dword [ebp - 0x217c]
mov dword [ebp - 0x3398], ecx
mov edx, dword [ebp - 0x3398]
mov al, byte [edx]
mov byte [ebp - 0x1a70], al
movsx ecx, byte [ebp - 0x1a70]
xor ecx, 0x34
mov byte [ebp - 0x1a71], cl
mov dl, byte [ebp - 0x1a71]
mov byte [ebp - 0x1a72], dl
mov eax, dword [ebp - 0x2798]
mov dword [ebp - 0x33bc], eax
mov ecx, dword [ebp - 0x33bc]
add ecx, dword [ebp - 0x217c]
mov dword [ebp - 0x33c8], ecx
mov edx, dword [ebp - 0x33c8]
mov al, byte [ebp - 0x1a72]
mov byte [edx], al
jmp 0x10113e3a
mov ecx, dword [ebp - 0x2798]
mov dword [ebp - 0x3474], ecx
mov edx, dword [ebp - 0x3474]
mov dword [ebp - 0x3480], edx
mov eax, dword [ebp - 0x3480]
mov dword [ebp - 0x34b8], eax
mov ecx, dword [ebp - 0x34b8]
push ecx
lea ecx, [ebp - 0x48d0]
call fcn.1007b880
mov byte [ebp - 4], 4
lea edx, [ebp - 0x48e8]
push edx
mov ecx, dword [ebp - 0x2178]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x2178]
mov byte [eax + 0x69], 1
mov ecx, dword [ebp - 0x2178]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10113f48
lea eax, [ebp - 0x48d0]
push eax
mov ecx, dword [ebp - 0x2178]
add ecx, 0x70
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x2178]
mov byte [ecx + 0x6c], 0
mov byte [ebp - 4], 3
lea ecx, [ebp - 0x48d0]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x48e8]
call fcn.1007c260
nop
mov edx, dword [ebp - 0x290]
add edx, 0xb8
mov dword [ebp - 0xc8], edx
mov eax, dword [ebp - 0xc8]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0xc8]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0xc8]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0xc8]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0xc8]
mov eax, dword [ebp - 0x290]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x290]
add edx, 0x18
mov dword [ebp - 0x34c4], edx
lea eax, [ebp - 0xc8]
push eax
mov ecx, dword [ebp - 0x34c4]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x140
mov dword [ebp - 0x33c], ecx
lea edx, [ebp - 0x2741]
mov dword [ebp - 0x34d0], edx
mov eax, dword [ebp - 0x34d0]
mov dword [ebp - 0x3a60], eax
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.stand]
mov byte [ebp - 0x1a78], al
movsx ecx, byte [ebp - 0x1a78]
xor ecx, 0x34
mov byte [ebp - 0x1a79], cl
mov dl, byte [ebp - 0x1a79]
mov byte [ebp - 0x2350], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.stand]
mov byte [ebp - 0x1a80], cl
movsx edx, byte [ebp - 0x1a80]
xor edx, 0x34
mov byte [ebp - 0x1a81], dl
mov al, byte [ebp - 0x1a81]
mov byte [ebp - 0x234f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.stand]
mov byte [ebp - 0x1a88], dl
movsx eax, byte [ebp - 0x1a88]
xor eax, 0x34
mov byte [ebp - 0x1a89], al
mov cl, byte [ebp - 0x1a89]
mov byte [ebp - 0x234e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.stand]
mov byte [ebp - 0x1a90], cl
movsx edx, byte [ebp - 0x1a90]
xor edx, 0x34
mov byte [ebp - 0x1a91], dl
mov al, byte [ebp - 0x1a91]
mov byte [ebp - 0x234d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.stand]
mov byte [ebp - 0x1a98], dl
movsx eax, byte [ebp - 0x1a98]
xor eax, 0x34
mov byte [ebp - 0x1a99], al
mov cl, byte [ebp - 0x1a99]
mov byte [ebp - 0x234c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.stand]
mov byte [ebp - 0x1aa0], cl
movsx edx, byte [ebp - 0x1aa0]
xor edx, 0x34
mov byte [ebp - 0x1aa1], dl
mov al, byte [ebp - 0x1aa1]
mov byte [ebp - 0x234b], al
lea ecx, [ebp - 0x2350]
mov dword [ebp - 0x3508], ecx
mov edx, dword [ebp - 0x3508]
mov dword [ebp - 0x27ec], edx
mov dword [ebp - 0x2174], 0
jmp 0x1011416a
mov eax, dword [ebp - 0x2174]
add eax, 1
mov dword [ebp - 0x2174], eax
cmp dword [ebp - 0x2174], 6
jae 0x101141ec
mov ecx, dword [ebp - 0x27ec]
mov dword [ebp - 0x3514], ecx
mov edx, dword [ebp - 0x3514]
add edx, dword [ebp - 0x2174]
mov dword [ebp - 0x3520], edx
mov eax, dword [ebp - 0x3520]
mov cl, byte [eax]
mov byte [ebp - 0x1aa8], cl
movsx edx, byte [ebp - 0x1aa8]
xor edx, 0x34
mov byte [ebp - 0x1aa9], dl
mov al, byte [ebp - 0x1aa9]
mov byte [ebp - 0x1aaa], al
mov ecx, dword [ebp - 0x27ec]
mov dword [ebp - 0x35b8], ecx
mov edx, dword [ebp - 0x35b8]
add edx, dword [ebp - 0x2174]
mov dword [ebp - 0x35c4], edx
mov eax, dword [ebp - 0x35c4]
mov cl, byte [ebp - 0x1aaa]
mov byte [eax], cl
jmp 0x1011415b
mov edx, dword [ebp - 0x27ec]
mov dword [ebp - 0x3670], edx
mov eax, dword [ebp - 0x3670]
mov dword [ebp - 0x3730], eax
mov ecx, dword [ebp - 0x3730]
mov dword [ebp - 0x3768], ecx
mov edx, dword [ebp - 0x3768]
push edx
lea ecx, [ebp - 0x58b8]
call fcn.1007b880
mov dword [ebp - 4], 5
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.walk]
mov byte [ebp - 0x1ab0], dl
movsx eax, byte [ebp - 0x1ab0]
xor eax, 0x34
mov byte [ebp - 0x1ab1], al
mov cl, byte [ebp - 0x1ab1]
mov byte [ebp - 0x2340], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.walk]
mov byte [ebp - 0x1ab8], al
movsx ecx, byte [ebp - 0x1ab8]
xor ecx, 0x34
mov byte [ebp - 0x1ab9], cl
mov dl, byte [ebp - 0x1ab9]
mov byte [ebp - 0x233f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.walk]
mov byte [ebp - 0x1ac0], cl
movsx edx, byte [ebp - 0x1ac0]
xor edx, 0x34
mov byte [ebp - 0x1ac1], dl
mov al, byte [ebp - 0x1ac1]
mov byte [ebp - 0x233e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.walk]
mov byte [ebp - 0x1ac8], al
movsx ecx, byte [ebp - 0x1ac8]
xor ecx, 0x34
mov byte [ebp - 0x1ac9], cl
mov dl, byte [ebp - 0x1ac9]
mov byte [ebp - 0x233d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.walk]
mov byte [ebp - 0x1ad0], cl
movsx edx, byte [ebp - 0x1ad0]
xor edx, 0x34
mov byte [ebp - 0x1ad1], dl
mov al, byte [ebp - 0x1ad1]
mov byte [ebp - 0x233c], al
lea ecx, [ebp - 0x2340]
mov dword [ebp - 0x3774], ecx
mov edx, dword [ebp - 0x3774]
mov dword [ebp - 0x27f0], edx
mov dword [ebp - 0x2170], 0
jmp 0x1011434b
mov eax, dword [ebp - 0x2170]
add eax, 1
mov dword [ebp - 0x2170], eax
cmp dword [ebp - 0x2170], 5
jae 0x101143cd
mov ecx, dword [ebp - 0x27f0]
mov dword [ebp - 0x37ac], ecx
mov edx, dword [ebp - 0x37ac]
add edx, dword [ebp - 0x2170]
mov dword [ebp - 0x37b8], edx
mov eax, dword [ebp - 0x37b8]
mov cl, byte [eax]
mov byte [ebp - 0x1ad8], cl
movsx edx, byte [ebp - 0x1ad8]
xor edx, 0x34
mov byte [ebp - 0x1ad9], dl
mov al, byte [ebp - 0x1ad9]
mov byte [ebp - 0x1ada], al
mov ecx, dword [ebp - 0x27f0]
mov dword [ebp - 0x37f0], ecx
mov edx, dword [ebp - 0x37f0]
add edx, dword [ebp - 0x2170]
mov dword [ebp - 0x37fc], edx
mov eax, dword [ebp - 0x37fc]
mov cl, byte [ebp - 0x1ada]
mov byte [eax], cl
jmp 0x1011433c
mov edx, dword [ebp - 0x27f0]
mov dword [ebp - 0x3834], edx
mov eax, dword [ebp - 0x3834]
mov dword [ebp - 0x3840], eax
mov ecx, dword [ebp - 0x3840]
mov dword [ebp - 0x3864], ecx
mov edx, dword [ebp - 0x3864]
push edx
lea ecx, [ebp - 0x58a0]
call fcn.1007b880
mov byte [ebp - 4], 6
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x102a2a28]
mov byte [ebp - 0x1ae0], dl
movsx eax, byte [ebp - 0x1ae0]
xor eax, 0x34
mov byte [ebp - 0x1ae1], al
mov cl, byte [ebp - 0x1ae1]
mov byte [ebp - 0x2250], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x102a2a28]
mov byte [ebp - 0x1ae8], al
movsx ecx, byte [ebp - 0x1ae8]
xor ecx, 0x34
mov byte [ebp - 0x1ae9], cl
mov dl, byte [ebp - 0x1ae9]
mov byte [ebp - 0x224f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x102a2a28]
mov byte [ebp - 0x1af0], cl
movsx edx, byte [ebp - 0x1af0]
xor edx, 0x34
mov byte [ebp - 0x1af1], dl
mov al, byte [ebp - 0x1af1]
mov byte [ebp - 0x224e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x102a2a28]
mov byte [ebp - 0x1af8], al
movsx ecx, byte [ebp - 0x1af8]
xor ecx, 0x34
mov byte [ebp - 0x1af9], cl
mov dl, byte [ebp - 0x1af9]
mov byte [ebp - 0x224d], dl
lea eax, [ebp - 0x2250]
mov dword [ebp - 0x3870], eax
mov ecx, dword [ebp - 0x3870]
mov dword [ebp - 0x27f4], ecx
mov dword [ebp - 0x216c], 0
jmp 0x101144f9
mov edx, dword [ebp - 0x216c]
add edx, 1
mov dword [ebp - 0x216c], edx
cmp dword [ebp - 0x216c], 4
jae 0x1011457b
mov eax, dword [ebp - 0x27f4]
mov dword [ebp - 0x391c], eax
mov ecx, dword [ebp - 0x391c]
add ecx, dword [ebp - 0x216c]
mov dword [ebp - 0x3928], ecx
mov edx, dword [ebp - 0x3928]
mov al, byte [edx]
mov byte [ebp - 0x1b00], al
movsx ecx, byte [ebp - 0x1b00]
xor ecx, 0x34
mov byte [ebp - 0x1b01], cl
mov dl, byte [ebp - 0x1b01]
mov byte [ebp - 0x1b02], dl
mov eax, dword [ebp - 0x27f4]
mov dword [ebp - 0x3960], eax
mov ecx, dword [ebp - 0x3960]
add ecx, dword [ebp - 0x216c]
mov dword [ebp - 0x396c], ecx
mov edx, dword [ebp - 0x396c]
mov al, byte [ebp - 0x1b02]
mov byte [edx], al
jmp 0x101144ea
mov ecx, dword [ebp - 0x27f4]
mov dword [ebp - 0x3978], ecx
mov edx, dword [ebp - 0x3978]
mov dword [ebp - 0x39b0], edx
mov eax, dword [ebp - 0x39b0]
mov dword [ebp - 0x39bc], eax
mov ecx, dword [ebp - 0x39bc]
push ecx
lea ecx, [ebp - 0x5888]
call fcn.1007b880
mov dword [ebp - 4], 7
lea edx, [ebp - 0x58b8]
mov dword [ebp - 0x46ac], edx
lea eax, [ebp - 0x5870]
mov dword [ebp - 0x46a8], eax
lea ecx, [ebp - 0x46ac]
mov dword [ebp - 0x39c8], ecx
mov edx, dword [ebp - 0x39c8]
mov eax, dword [edx]
mov ecx, dword [edx + 4]
mov dword [ebp - 0x4460], eax
mov dword [ebp - 0x445c], ecx
mov edx, dword [ebp - 0x3a60]
push edx
mov eax, dword [ebp - 0x445c]
push eax
mov ecx, dword [ebp - 0x4460]
push ecx
lea ecx, [ebp - 0x4744]
call fcn.101ed250
mov byte [ebp - 4], 8
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.mode]
mov byte [ebp - 0x1b08], cl
movsx edx, byte [ebp - 0x1b08]
xor edx, 0x34
mov byte [ebp - 0x1b09], dl
mov al, byte [ebp - 0x1b09]
mov byte [ebp - 0x2308], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.mode]
mov byte [ebp - 0x1b10], dl
movsx eax, byte [ebp - 0x1b10]
xor eax, 0x34
mov byte [ebp - 0x1b11], al
mov cl, byte [ebp - 0x1b11]
mov byte [ebp - 0x2307], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.mode]
mov byte [ebp - 0x1b18], al
movsx ecx, byte [ebp - 0x1b18]
xor ecx, 0x34
mov byte [ebp - 0x1b19], cl
mov dl, byte [ebp - 0x1b19]
mov byte [ebp - 0x2306], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.mode]
mov byte [ebp - 0x1b20], dl
movsx eax, byte [ebp - 0x1b20]
xor eax, 0x34
mov byte [ebp - 0x1b21], al
mov cl, byte [ebp - 0x1b21]
mov byte [ebp - 0x2305], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.mode]
mov byte [ebp - 0x1b28], al
movsx ecx, byte [ebp - 0x1b28]
xor ecx, 0x34
mov byte [ebp - 0x1b29], cl
mov dl, byte [ebp - 0x1b29]
mov byte [ebp - 0x2304], dl
lea eax, [ebp - 0x2308]
mov dword [ebp - 0x3a6c], eax
mov ecx, dword [ebp - 0x3a6c]
mov dword [ebp - 0x27f8], ecx
mov dword [ebp - 0x2168], 0
jmp 0x10114739
mov edx, dword [ebp - 0x2168]
add edx, 1
mov dword [ebp - 0x2168], edx
cmp dword [ebp - 0x2168], 5
jae 0x101147bb
mov eax, dword [ebp - 0x27f8]
mov dword [ebp - 0x3b04], eax
mov ecx, dword [ebp - 0x3b04]
add ecx, dword [ebp - 0x2168]
mov dword [ebp - 0x3b10], ecx
mov edx, dword [ebp - 0x3b10]
mov al, byte [edx]
mov byte [ebp - 0x1b30], al
movsx ecx, byte [ebp - 0x1b30]
xor ecx, 0x34
mov byte [ebp - 0x1b31], cl
mov dl, byte [ebp - 0x1b31]
mov byte [ebp - 0x1b32], dl
mov eax, dword [ebp - 0x27f8]
mov dword [ebp - 0x3c10], eax
mov ecx, dword [ebp - 0x3c10]
add ecx, dword [ebp - 0x2168]
mov dword [ebp - 0x3c48], ecx
mov edx, dword [ebp - 0x3c48]
mov al, byte [ebp - 0x1b32]
mov byte [edx], al
jmp 0x1011472a
mov ecx, dword [ebp - 0x27f8]
mov dword [ebp - 0x3f1c], ecx
mov edx, dword [ebp - 0x3f1c]
mov dword [ebp - 0x3f58], edx
mov eax, dword [ebp - 0x3f58]
mov dword [ebp - 0x3f94], eax
mov ecx, dword [ebp - 0x3f94]
push ecx
lea ecx, [ebp - 0x4918]
call fcn.1007b880
mov byte [ebp - 4], 9
push 0x102a0e2e
lea ecx, [ebp - 0x4900]
call fcn.1007b880
mov byte [ebp - 4], 0xa
lea edx, [ebp - 0x4918]
push edx
mov ecx, dword [ebp - 0x33c]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x33c]
mov byte [eax + 0x69], 0
mov ecx, dword [ebp - 0x33c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x1011484c
lea eax, [ebp - 0x4900]
push eax
mov ecx, dword [ebp - 0x33c]
add ecx, 0x70
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x33c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10114866
mov dword [ebp - 0x2a90], 0xf
jmp 0x10114870
mov dword [ebp - 0x2a90], 0
mov eax, dword [ebp - 0x33c]
mov ecx, dword [ebp - 0x2a90]
mov dword [eax + 0x9c], ecx
mov edx, dword [ebp - 0x33c]
mov eax, dword [edx + 0x9c]
add eax, 0x14
mov dword [ebp - 0x2a94], eax
mov ecx, dword [ebp - 0x33c]
mov edx, dword [ebp - 0x2a94]
mov dword [ecx + 0x10], edx
mov eax, dword [ebp - 0x33c]
mov ecx, dword [ebp - 0x2a94]
mov dword [eax + 0x14], ecx
lea edx, [ebp - 0x4744]
mov dword [ebp - 0x2a98], edx
mov eax, dword [ebp - 0x2a98]
mov ecx, dword [eax]
mov dword [ebp - 0x3fd0], ecx
mov edx, dword [ebp - 0x3fd0]
mov dword [ebp - 0x400c], edx
mov eax, dword [ebp - 0x400c]
mov dword [ebp - 0x410c], eax
mov ecx, dword [ebp - 0x410c]
mov dword [ebp - 0x2254], ecx
mov edx, dword [ebp - 0x2a98]
mov eax, dword [edx + 4]
mov dword [ebp - 0x4144], eax
mov ecx, dword [ebp - 0x4144]
mov dword [ebp - 0x41b4], ecx
mov edx, dword [ebp - 0x41b4]
mov dword [ebp - 0x41c0], edx
mov eax, dword [ebp - 0x41c0]
mov dword [ebp - 0x41f8], eax
jmp 0x10114937
mov ecx, dword [ebp - 0x2254]
add ecx, 0x18
mov dword [ebp - 0x2254], ecx
mov edx, dword [ebp - 0x2254]
cmp edx, dword [ebp - 0x41f8]
je 0x10114978
mov eax, dword [ebp - 0x2254]
mov dword [ebp - 0x4204], eax
mov ecx, dword [ebp - 0x33c]
add ecx, 0x88
mov dword [ebp - 0x423c], ecx
mov edx, dword [ebp - 0x4204]
push edx
mov ecx, dword [ebp - 0x423c]
call fcn.100d29a0
nop
jmp 0x10114928
mov eax, dword [ebp - 0x33c]
add eax, 0x88
mov dword [ebp - 0x2a9c], eax
mov ecx, dword [ebp - 0x2a9c]
mov edx, dword [ebp - 0x2a9c]
mov eax, dword [ecx + 4]
sub eax, dword [edx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x4274], eax
cmp dword [ebp - 0x4274], 0
jbe 0x101149c1
mov edx, dword [ebp - 0x33c]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 9
lea ecx, [ebp - 0x4900]
call fcn.1007c260
nop
mov byte [ebp - 4], 8
lea ecx, [ebp - 0x4918]
call fcn.1007c260
nop
mov byte [ebp - 4], 7
lea ecx, [ebp - 0x4744]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 3
push 0x18
lea eax, [ebp - 0x58b8]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x140
mov dword [ebp - 0xcc], ecx
mov edx, dword [ebp - 0xcc]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xcc]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xcc]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xcc]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xcc]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x42ac], ecx
lea edx, [ebp - 0xcc]
push edx
mov ecx, dword [ebp - 0x42ac]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x1e0
mov dword [ebp - 0x340], eax
lea ecx, [ebp - 0x2742]
mov dword [ebp - 0x42f0], ecx
mov edx, dword [ebp - 0x42f0]
mov dword [ebp - 0x43d4], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x102a28c0]
mov byte [ebp - 0x1b38], dl
movsx eax, byte [ebp - 0x1b38]
xor eax, 0x34
mov byte [ebp - 0x1b39], al
mov cl, byte [ebp - 0x1b39]
mov byte [ebp - 0x2258], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0x1b40], al
movsx ecx, byte [ebp - 0x1b40]
xor ecx, 0x34
mov byte [ebp - 0x1b41], cl
mov dl, byte [ebp - 0x1b41]
mov byte [ebp - 0x2257], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x102a28c0]
mov byte [ebp - 0x1b48], cl
movsx edx, byte [ebp - 0x1b48]
xor edx, 0x34
mov byte [ebp - 0x1b49], dl
mov al, byte [ebp - 0x1b49]
mov byte [ebp - 0x2256], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0x1b50], al
movsx ecx, byte [ebp - 0x1b50]
xor ecx, 0x34
mov byte [ebp - 0x1b51], cl
mov dl, byte [ebp - 0x1b51]
mov byte [ebp - 0x2255], dl
lea eax, [ebp - 0x2258]
mov dword [ebp - 0x4328], eax
mov ecx, dword [ebp - 0x4328]
mov dword [ebp - 0x27fc], ecx
mov dword [ebp - 0x2164], 0
jmp 0x10114ba2
mov edx, dword [ebp - 0x2164]
add edx, 1
mov dword [ebp - 0x2164], edx
cmp dword [ebp - 0x2164], 4
jae 0x10114c24
mov eax, dword [ebp - 0x27fc]
mov dword [ebp - 0x4334], eax
mov ecx, dword [ebp - 0x4334]
add ecx, dword [ebp - 0x2164]
mov dword [ebp - 0x4338], ecx
mov edx, dword [ebp - 0x4338]
mov al, byte [edx]
mov byte [ebp - 0x1b58], al
movsx ecx, byte [ebp - 0x1b58]
xor ecx, 0x34
mov byte [ebp - 0x1b59], cl
mov dl, byte [ebp - 0x1b59]
mov byte [ebp - 0x1b5a], dl
mov eax, dword [ebp - 0x27fc]
mov dword [ebp - 0x433c], eax
mov ecx, dword [ebp - 0x433c]
add ecx, dword [ebp - 0x2164]
mov dword [ebp - 0x4340], ecx
mov edx, dword [ebp - 0x4340]
mov al, byte [ebp - 0x1b5a]
mov byte [edx], al
jmp 0x10114b93
mov ecx, dword [ebp - 0x27fc]
mov dword [ebp - 0x4344], ecx
mov edx, dword [ebp - 0x4344]
mov dword [ebp - 0x4348], edx
mov eax, dword [ebp - 0x4348]
mov dword [ebp - 0x434c], eax
mov ecx, dword [ebp - 0x434c]
push ecx
lea ecx, [ebp - 0x5b90]
call fcn.1007b880
mov dword [ebp - 4], 0xb
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.down]
mov byte [ebp - 0x1b60], cl
movsx edx, byte [ebp - 0x1b60]
xor edx, 0x34
mov byte [ebp - 0x1b61], dl
mov al, byte [ebp - 0x1b61]
mov byte [ebp - 0x2310], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.down]
mov byte [ebp - 0x1b68], dl
movsx eax, byte [ebp - 0x1b68]
xor eax, 0x34
mov byte [ebp - 0x1b69], al
mov cl, byte [ebp - 0x1b69]
mov byte [ebp - 0x230f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.down]
mov byte [ebp - 0x1b70], al
movsx ecx, byte [ebp - 0x1b70]
xor ecx, 0x34
mov byte [ebp - 0x1b71], cl
mov dl, byte [ebp - 0x1b71]
mov byte [ebp - 0x230e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.down]
mov byte [ebp - 0x1b78], dl
movsx eax, byte [ebp - 0x1b78]
xor eax, 0x34
mov byte [ebp - 0x1b79], al
mov cl, byte [ebp - 0x1b79]
mov byte [ebp - 0x230d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.down]
mov byte [ebp - 0x1b80], al
movsx ecx, byte [ebp - 0x1b80]
xor ecx, 0x34
mov byte [ebp - 0x1b81], cl
mov dl, byte [ebp - 0x1b81]
mov byte [ebp - 0x230c], dl
lea eax, [ebp - 0x2310]
mov dword [ebp - 0x4350], eax
mov ecx, dword [ebp - 0x4350]
mov dword [ebp - 0x2800], ecx
mov dword [ebp - 0x2160], 0
jmp 0x10114d83
mov edx, dword [ebp - 0x2160]
add edx, 1
mov dword [ebp - 0x2160], edx
cmp dword [ebp - 0x2160], 5
jae 0x10114e05
mov eax, dword [ebp - 0x2800]
mov dword [ebp - 0x4354], eax
mov ecx, dword [ebp - 0x4354]
add ecx, dword [ebp - 0x2160]
mov dword [ebp - 0x4358], ecx
mov edx, dword [ebp - 0x4358]
mov al, byte [edx]
mov byte [ebp - 0x1b88], al
movsx ecx, byte [ebp - 0x1b88]
xor ecx, 0x34
mov byte [ebp - 0x1b89], cl
mov dl, byte [ebp - 0x1b89]
mov byte [ebp - 0x1b8a], dl
mov eax, dword [ebp - 0x2800]
mov dword [ebp - 0x435c], eax
mov ecx, dword [ebp - 0x435c]
add ecx, dword [ebp - 0x2160]
mov dword [ebp - 0x4360], ecx
mov edx, dword [ebp - 0x4360]
mov al, byte [ebp - 0x1b8a]
mov byte [edx], al
jmp 0x10114d74
mov ecx, dword [ebp - 0x2800]
mov dword [ebp - 0x4364], ecx
mov edx, dword [ebp - 0x4364]
mov dword [ebp - 0x4368], edx
mov eax, dword [ebp - 0x4368]
mov dword [ebp - 0x436c], eax
mov ecx, dword [ebp - 0x436c]
push ecx
lea ecx, [ebp - 0x5b78]
call fcn.1007b880
mov byte [ebp - 4], 0xc
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + 0x102a2a4c]
mov byte [ebp - 0x1b90], cl
movsx edx, byte [ebp - 0x1b90]
xor edx, 0x34
mov byte [ebp - 0x1b91], dl
mov al, byte [ebp - 0x1b91]
mov byte [ebp - 0x224c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + 0x102a2a4c]
mov byte [ebp - 0x1b98], dl
movsx eax, byte [ebp - 0x1b98]
xor eax, 0x34
mov byte [ebp - 0x1b99], al
mov cl, byte [ebp - 0x1b99]
mov byte [ebp - 0x224b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + 0x102a2a4c]
mov byte [ebp - 0x1ba0], al
movsx ecx, byte [ebp - 0x1ba0]
xor ecx, 0x34
mov byte [ebp - 0x1ba1], cl
mov dl, byte [ebp - 0x1ba1]
mov byte [ebp - 0x224a], dl
lea eax, [ebp - 0x224c]
mov dword [ebp - 0x4370], eax
mov ecx, dword [ebp - 0x4370]
mov dword [ebp - 0x2804], ecx
mov dword [ebp - 0x215c], 0
jmp 0x10114f01
mov edx, dword [ebp - 0x215c]
add edx, 1
mov dword [ebp - 0x215c], edx
cmp dword [ebp - 0x215c], 3
jae 0x10114f83
mov eax, dword [ebp - 0x2804]
mov dword [ebp - 0x4374], eax
mov ecx, dword [ebp - 0x4374]
add ecx, dword [ebp - 0x215c]
mov dword [ebp - 0x4378], ecx
mov edx, dword [ebp - 0x4378]
mov al, byte [edx]
mov byte [ebp - 0x1ba8], al
movsx ecx, byte [ebp - 0x1ba8]
xor ecx, 0x34
mov byte [ebp - 0x1ba9], cl
mov dl, byte [ebp - 0x1ba9]
mov byte [ebp - 0x1baa], dl
mov eax, dword [ebp - 0x2804]
mov dword [ebp - 0x437c], eax
mov ecx, dword [ebp - 0x437c]
add ecx, dword [ebp - 0x215c]
mov dword [ebp - 0x4380], ecx
mov edx, dword [ebp - 0x4380]
mov al, byte [ebp - 0x1baa]
mov byte [edx], al
jmp 0x10114ef2
mov ecx, dword [ebp - 0x2804]
mov dword [ebp - 0x4384], ecx
mov edx, dword [ebp - 0x4384]
mov dword [ebp - 0x4388], edx
mov eax, dword [ebp - 0x4388]
mov dword [ebp - 0x438c], eax
mov ecx, dword [ebp - 0x438c]
push ecx
lea ecx, [ebp - 0x5b60]
call fcn.1007b880
mov byte [ebp - 4], 0xd
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.random]
mov byte [ebp - 0x1bb0], cl
movsx edx, byte [ebp - 0x1bb0]
xor edx, 0x34
mov byte [ebp - 0x1bb1], dl
mov al, byte [ebp - 0x1bb1]
mov byte [ebp - 0x2388], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x1bb8], dl
movsx eax, byte [ebp - 0x1bb8]
xor eax, 0x34
mov byte [ebp - 0x1bb9], al
mov cl, byte [ebp - 0x1bb9]
mov byte [ebp - 0x2387], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.random]
mov byte [ebp - 0x1bc0], al
movsx ecx, byte [ebp - 0x1bc0]
xor ecx, 0x34
mov byte [ebp - 0x1bc1], cl
mov dl, byte [ebp - 0x1bc1]
mov byte [ebp - 0x2386], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x1bc8], dl
movsx eax, byte [ebp - 0x1bc8]
xor eax, 0x34
mov byte [ebp - 0x1bc9], al
mov cl, byte [ebp - 0x1bc9]
mov byte [ebp - 0x2385], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.random]
mov byte [ebp - 0x1bd0], al
movsx ecx, byte [ebp - 0x1bd0]
xor ecx, 0x34
mov byte [ebp - 0x1bd1], cl
mov dl, byte [ebp - 0x1bd1]
mov byte [ebp - 0x2384], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x1bd8], dl
movsx eax, byte [ebp - 0x1bd8]
xor eax, 0x34
mov byte [ebp - 0x1bd9], al
mov cl, byte [ebp - 0x1bd9]
mov byte [ebp - 0x2383], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.random]
mov byte [ebp - 0x1be0], cl
movsx edx, byte [ebp - 0x1be0]
xor edx, 0x34
mov byte [ebp - 0x1be1], dl
mov al, byte [ebp - 0x1be1]
mov byte [ebp - 0x2382], al
lea ecx, [ebp - 0x2388]
mov dword [ebp - 0x4390], ecx
mov edx, dword [ebp - 0x4390]
mov dword [ebp - 0x2808], edx
mov dword [ebp - 0x2158], 0
jmp 0x1011513f
mov eax, dword [ebp - 0x2158]
add eax, 1
mov dword [ebp - 0x2158], eax
cmp dword [ebp - 0x2158], 7
jae 0x101151c1
mov ecx, dword [ebp - 0x2808]
mov dword [ebp - 0x4394], ecx
mov edx, dword [ebp - 0x4394]
add edx, dword [ebp - 0x2158]
mov dword [ebp - 0x4398], edx
mov eax, dword [ebp - 0x4398]
mov cl, byte [eax]
mov byte [ebp - 0x1be8], cl
movsx edx, byte [ebp - 0x1be8]
xor edx, 0x34
mov byte [ebp - 0x1be9], dl
mov al, byte [ebp - 0x1be9]
mov byte [ebp - 0x1bea], al
mov ecx, dword [ebp - 0x2808]
mov dword [ebp - 0x439c], ecx
mov edx, dword [ebp - 0x439c]
add edx, dword [ebp - 0x2158]
mov dword [ebp - 0x43a0], edx
mov eax, dword [ebp - 0x43a0]
mov cl, byte [ebp - 0x1bea]
mov byte [eax], cl
jmp 0x10115130
mov edx, dword [ebp - 0x2808]
mov dword [ebp - 0x43a4], edx
mov eax, dword [ebp - 0x43a4]
mov dword [ebp - 0x43a8], eax
mov ecx, dword [ebp - 0x43a8]
mov dword [ebp - 0x43ac], ecx
mov edx, dword [ebp - 0x43ac]
push edx
lea ecx, [ebp - 0x5b48]
call fcn.1007b880
mov byte [ebp - 4], 0xe
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.ideal]
mov byte [ebp - 0x1bf0], dl
movsx eax, byte [ebp - 0x1bf0]
xor eax, 0x34
mov byte [ebp - 0x1bf1], al
mov cl, byte [ebp - 0x1bf1]
mov byte [ebp - 0x2358], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.ideal]
mov byte [ebp - 0x1bf8], al
movsx ecx, byte [ebp - 0x1bf8]
xor ecx, 0x34
mov byte [ebp - 0x1bf9], cl
mov dl, byte [ebp - 0x1bf9]
mov byte [ebp - 0x2357], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.ideal]
mov byte [ebp - 0x1c00], cl
movsx edx, byte [ebp - 0x1c00]
xor edx, 0x34
mov byte [ebp - 0x1c01], dl
mov al, byte [ebp - 0x1c01]
mov byte [ebp - 0x2356], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.ideal]
mov byte [ebp - 0x1c08], al
movsx ecx, byte [ebp - 0x1c08]
xor ecx, 0x34
mov byte [ebp - 0x1c09], cl
mov dl, byte [ebp - 0x1c09]
mov byte [ebp - 0x2355], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.ideal]
mov byte [ebp - 0x1c10], cl
movsx edx, byte [ebp - 0x1c10]
xor edx, 0x34
mov byte [ebp - 0x1c11], dl
mov al, byte [ebp - 0x1c11]
mov byte [ebp - 0x2354], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.ideal]
mov byte [ebp - 0x1c18], al
movsx ecx, byte [ebp - 0x1c18]
xor ecx, 0x34
mov byte [ebp - 0x1c19], cl
mov dl, byte [ebp - 0x1c19]
mov byte [ebp - 0x2353], dl
lea eax, [ebp - 0x2358]
mov dword [ebp - 0x43b0], eax
mov ecx, dword [ebp - 0x43b0]
mov dword [ebp - 0x2854], ecx
mov dword [ebp - 0x2154], 0
jmp 0x1011534d
mov edx, dword [ebp - 0x2154]
add edx, 1
mov dword [ebp - 0x2154], edx
cmp dword [ebp - 0x2154], 6
jae 0x101153cf
mov eax, dword [ebp - 0x2854]
mov dword [ebp - 0x43b4], eax
mov ecx, dword [ebp - 0x43b4]
add ecx, dword [ebp - 0x2154]
mov dword [ebp - 0x43b8], ecx
mov edx, dword [ebp - 0x43b8]
mov al, byte [edx]
mov byte [ebp - 0x1c20], al
movsx ecx, byte [ebp - 0x1c20]
xor ecx, 0x34
mov byte [ebp - 0x1c21], cl
mov dl, byte [ebp - 0x1c21]
mov byte [ebp - 0x1c22], dl
mov eax, dword [ebp - 0x2854]
mov dword [ebp - 0x43bc], eax
mov ecx, dword [ebp - 0x43bc]
add ecx, dword [ebp - 0x2154]
mov dword [ebp - 0x43c0], ecx
mov edx, dword [ebp - 0x43c0]
mov al, byte [ebp - 0x1c22]
mov byte [edx], al
jmp 0x1011533e
mov ecx, dword [ebp - 0x2854]
mov dword [ebp - 0x43c4], ecx
mov edx, dword [ebp - 0x43c4]
mov dword [ebp - 0x43c8], edx
mov eax, dword [ebp - 0x43c8]
mov dword [ebp - 0x43cc], eax
mov ecx, dword [ebp - 0x43cc]
push ecx
lea ecx, [ebp - 0x5b30]
call fcn.1007b880
mov dword [ebp - 4], 0xf
lea edx, [ebp - 0x5b90]
mov dword [ebp - 0x46b4], edx
lea eax, [ebp - 0x5b18]
mov dword [ebp - 0x46b0], eax
lea ecx, [ebp - 0x46b4]
mov dword [ebp - 0x43d0], ecx
mov edx, dword [ebp - 0x43d0]
mov eax, dword [edx]
mov ecx, dword [edx + 4]
mov dword [ebp - 0x4468], eax
mov dword [ebp - 0x4464], ecx
mov edx, dword [ebp - 0x43d4]
push edx
mov eax, dword [ebp - 0x4464]
push eax
mov ecx, dword [ebp - 0x4468]
push ecx
lea ecx, [ebp - 0x4750]
call fcn.101ed250
mov byte [ebp - 4], 0x10
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.pitch_stnd]
mov byte [ebp - 0x1c28], cl
movsx edx, byte [ebp - 0x1c28]
xor edx, 0x34
mov byte [ebp - 0x1c29], dl
mov al, byte [ebp - 0x1c29]
mov byte [ebp - 0x241c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.pitch_stnd]
mov byte [ebp - 0x1c30], dl
movsx eax, byte [ebp - 0x1c30]
xor eax, 0x34
mov byte [ebp - 0x1c31], al
mov cl, byte [ebp - 0x1c31]
mov byte [ebp - 0x241b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.pitch_stnd]
mov byte [ebp - 0x1c38], al
movsx ecx, byte [ebp - 0x1c38]
xor ecx, 0x34
mov byte [ebp - 0x1c39], cl
mov dl, byte [ebp - 0x1c39]
mov byte [ebp - 0x241a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.pitch_stnd]
mov byte [ebp - 0x1c40], dl
movsx eax, byte [ebp - 0x1c40]
xor eax, 0x34
mov byte [ebp - 0x1c41], al
mov cl, byte [ebp - 0x1c41]
mov byte [ebp - 0x2419], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.pitch_stnd]
mov byte [ebp - 0x1c48], al
movsx ecx, byte [ebp - 0x1c48]
xor ecx, 0x34
mov byte [ebp - 0x1c49], cl
mov dl, byte [ebp - 0x1c49]
mov byte [ebp - 0x2418], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.pitch_stnd]
mov byte [ebp - 0x1c50], dl
movsx eax, byte [ebp - 0x1c50]
xor eax, 0x34
mov byte [ebp - 0x1c51], al
mov cl, byte [ebp - 0x1c51]
mov byte [ebp - 0x2417], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.pitch_stnd]
mov byte [ebp - 0x1c58], cl
movsx edx, byte [ebp - 0x1c58]
xor edx, 0x34
mov byte [ebp - 0x1c59], dl
mov al, byte [ebp - 0x1c59]
mov byte [ebp - 0x2416], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.pitch_stnd]
mov byte [ebp - 0x1c60], al
movsx ecx, byte [ebp - 0x1c60]
xor ecx, 0x34
mov byte [ebp - 0x1c61], cl
mov dl, byte [ebp - 0x1c61]
mov byte [ebp - 0x2415], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.pitch_stnd]
mov byte [ebp - 0x1c68], cl
movsx edx, byte [ebp - 0x1c68]
xor edx, 0x34
mov byte [ebp - 0x1c69], dl
mov al, byte [ebp - 0x1c69]
mov byte [ebp - 0x2414], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.pitch_stnd]
mov byte [ebp - 0x1c70], al
movsx ecx, byte [ebp - 0x1c70]
xor ecx, 0x34
mov byte [ebp - 0x1c71], cl
mov dl, byte [ebp - 0x1c71]
mov byte [ebp - 0x2413], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.pitch_stnd]
mov byte [ebp - 0x1c78], dl
movsx eax, byte [ebp - 0x1c78]
xor eax, 0x34
mov byte [ebp - 0x1c79], al
mov cl, byte [ebp - 0x1c79]
mov byte [ebp - 0x2412], cl
lea edx, [ebp - 0x241c]
mov dword [ebp - 0x43d8], edx
mov eax, dword [ebp - 0x43d8]
mov dword [ebp - 0x2858], eax
mov dword [ebp - 0x2150], 0
jmp 0x101156ad
mov ecx, dword [ebp - 0x2150]
add ecx, 1
mov dword [ebp - 0x2150], ecx
cmp dword [ebp - 0x2150], 0xb
jae 0x1011572f
mov edx, dword [ebp - 0x2858]
mov dword [ebp - 0x43dc], edx
mov eax, dword [ebp - 0x43dc]
add eax, dword [ebp - 0x2150]
mov dword [ebp - 0x43e0], eax
mov ecx, dword [ebp - 0x43e0]
mov dl, byte [ecx]
mov byte [ebp - 0x1c80], dl
movsx eax, byte [ebp - 0x1c80]
xor eax, 0x34
mov byte [ebp - 0x1c81], al
mov cl, byte [ebp - 0x1c81]
mov byte [ebp - 0x1c82], cl
mov edx, dword [ebp - 0x2858]
mov dword [ebp - 0x43e4], edx
mov eax, dword [ebp - 0x43e4]
add eax, dword [ebp - 0x2150]
mov dword [ebp - 0x43e8], eax
mov ecx, dword [ebp - 0x43e8]
mov dl, byte [ebp - 0x1c82]
mov byte [ecx], dl
jmp 0x1011569e
mov eax, dword [ebp - 0x2858]
mov dword [ebp - 0x43ec], eax
mov ecx, dword [ebp - 0x43ec]
mov dword [ebp - 0x43f0], ecx
mov edx, dword [ebp - 0x43f0]
mov dword [ebp - 0x43f4], edx
mov eax, dword [ebp - 0x43f4]
push eax
lea ecx, [ebp - 0x4948]
call fcn.1007b880
mov byte [ebp - 4], 0x11
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.pitch]
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 - 0x2348], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x1c90], cl
movsx edx, byte [ebp - 0x1c90]
xor edx, 0x34
mov byte [ebp - 0x1c91], dl
mov al, byte [ebp - 0x1c91]
mov byte [ebp - 0x2347], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.pitch]
mov byte [ebp - 0x1c98], dl
movsx eax, byte [ebp - 0x1c98]
xor eax, 0x34
mov byte [ebp - 0x1c99], al
mov cl, byte [ebp - 0x1c99]
mov byte [ebp - 0x2346], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x1ca0], cl
movsx edx, byte [ebp - 0x1ca0]
xor edx, 0x34
mov byte [ebp - 0x1ca1], dl
mov al, byte [ebp - 0x1ca1]
mov byte [ebp - 0x2345], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.pitch]
mov byte [ebp - 0x1ca8], dl
movsx eax, byte [ebp - 0x1ca8]
xor eax, 0x34
mov byte [ebp - 0x1ca9], al
mov cl, byte [ebp - 0x1ca9]
mov byte [ebp - 0x2344], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.pitch]
mov byte [ebp - 0x1cb0], cl
movsx edx, byte [ebp - 0x1cb0]
xor edx, 0x34
mov byte [ebp - 0x1cb1], dl
mov al, byte [ebp - 0x1cb1]
mov byte [ebp - 0x2343], al
lea ecx, [ebp - 0x2348]
mov dword [ebp - 0x43f8], ecx
mov edx, dword [ebp - 0x43f8]
mov dword [ebp - 0x285c], edx
mov dword [ebp - 0x214c], 0
jmp 0x101158bb
mov eax, dword [ebp - 0x214c]
add eax, 1
mov dword [ebp - 0x214c], eax
cmp dword [ebp - 0x214c], 6
jae 0x1011593d
mov ecx, dword [ebp - 0x285c]
mov dword [ebp - 0x43fc], ecx
mov edx, dword [ebp - 0x43fc]
add edx, dword [ebp - 0x214c]
mov dword [ebp - 0x4400], edx
mov eax, dword [ebp - 0x4400]
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 - 0x285c]
mov dword [ebp - 0x4404], ecx
mov edx, dword [ebp - 0x4404]
add edx, dword [ebp - 0x214c]
mov dword [ebp - 0x4408], edx
mov eax, dword [ebp - 0x4408]
mov cl, byte [ebp - 0x1cba]
mov byte [eax], cl
jmp 0x101158ac
mov edx, dword [ebp - 0x285c]
mov dword [ebp - 0x440c], edx
mov eax, dword [ebp - 0x440c]
mov dword [ebp - 0x4410], eax
mov ecx, dword [ebp - 0x4410]
mov dword [ebp - 0x4414], ecx
mov edx, dword [ebp - 0x4414]
push edx
lea ecx, [ebp - 0x4930]
call fcn.1007b880
mov byte [ebp - 4], 0x12
lea eax, [ebp - 0x4948]
push eax
mov ecx, dword [ebp - 0x340]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x340]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x340]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x101159ba
lea ecx, [ebp - 0x4930]
push ecx
mov ecx, dword [ebp - 0x340]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x340]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x101159d4
mov dword [ebp - 0x2aa0], 0xf
jmp 0x101159de
mov dword [ebp - 0x2aa0], 0
mov ecx, dword [ebp - 0x340]
mov edx, dword [ebp - 0x2aa0]
mov dword [ecx + 0x9c], edx
mov eax, dword [ebp - 0x340]
mov ecx, dword [eax + 0x9c]
add ecx, 0x14
mov dword [ebp - 0x2aa4], ecx
mov edx, dword [ebp - 0x340]
mov eax, dword [ebp - 0x2aa4]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0x340]
mov edx, dword [ebp - 0x2aa4]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x4750]
mov dword [ebp - 0x2aa8], eax
mov ecx, dword [ebp - 0x2aa8]
mov edx, dword [ecx]
mov dword [ebp - 0x4418], edx
mov eax, dword [ebp - 0x4418]
mov dword [ebp - 0x441c], eax
mov ecx, dword [ebp - 0x441c]
mov dword [ebp - 0x4420], ecx
mov edx, dword [ebp - 0x4420]
mov dword [ebp - 0x225c], edx
mov eax, dword [ebp - 0x2aa8]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x4424], ecx
mov edx, dword [ebp - 0x4424]
mov dword [ebp - 0x4428], edx
mov eax, dword [ebp - 0x4428]
mov dword [ebp - 0x442c], eax
mov ecx, dword [ebp - 0x442c]
mov dword [ebp - 0x4430], ecx
jmp 0x10115aa5
mov edx, dword [ebp - 0x225c]
add edx, 0x18
mov dword [ebp - 0x225c], edx
mov eax, dword [ebp - 0x225c]
cmp eax, dword [ebp - 0x4430]
je 0x10115ae6
mov ecx, dword [ebp - 0x225c]
mov dword [ebp - 0x4434], ecx
mov edx, dword [ebp - 0x340]
add edx, 0x88
mov dword [ebp - 0x4438], edx
mov eax, dword [ebp - 0x4434]
push eax
mov ecx, dword [ebp - 0x4438]
call fcn.100d29a0
nop
jmp 0x10115a96
mov ecx, dword [ebp - 0x340]
add ecx, 0x88
mov dword [ebp - 0x2aac], ecx
mov edx, dword [ebp - 0x2aac]
mov eax, dword [ebp - 0x2aac]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x443c], eax
cmp dword [ebp - 0x443c], 0
jbe 0x10115b32
mov edx, dword [ebp - 0x340]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x11
lea ecx, [ebp - 0x4930]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x10
lea ecx, [ebp - 0x4948]
call fcn.1007c260
nop
mov byte [ebp - 4], 0xf
lea ecx, [ebp - 0x4750]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 5
push 0x18
lea eax, [ebp - 0x5b90]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x1e0
mov dword [ebp - 0x4440], ecx
mov dword [ebp - 0x1bc], 0x1008a930
mov edx, dword [ebp - 0x4440]
add edx, 0x58
mov dword [ebp - 0x4448], edx
lea eax, [ebp - 0x1bc]
push eax
mov ecx, dword [ebp - 0x4448]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x1e0
mov dword [ebp - 0xd4], ecx
mov edx, dword [ebp - 0xd4]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xd4]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xd4]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xd4]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xd4]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x444c], ecx
lea edx, [ebp - 0xd4]
push edx
mov ecx, dword [ebp - 0x444c]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x280
mov dword [ebp - 0x344], eax
lea ecx, [ebp - 0x2749]
mov dword [ebp - 0x4450], ecx
mov edx, dword [ebp - 0x4450]
mov dword [ebp - 0x45c0], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + 0x102a28c0]
mov byte [ebp - 0x1cc0], dl
movsx eax, byte [ebp - 0x1cc0]
xor eax, 0x34
mov byte [ebp - 0x1cc1], al
mov cl, byte [ebp - 0x1cc1]
mov byte [ebp - 0x2260], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0x1cc8], al
movsx ecx, byte [ebp - 0x1cc8]
xor ecx, 0x34
mov byte [ebp - 0x1cc9], cl
mov dl, byte [ebp - 0x1cc9]
mov byte [ebp - 0x225f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + 0x102a28c0]
mov byte [ebp - 0x1cd0], cl
movsx edx, byte [ebp - 0x1cd0]
xor edx, 0x34
mov byte [ebp - 0x1cd1], dl
mov al, byte [ebp - 0x1cd1]
mov byte [ebp - 0x225e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0x1cd8], al
movsx ecx, byte [ebp - 0x1cd8]
xor ecx, 0x34
mov byte [ebp - 0x1cd9], cl
mov dl, byte [ebp - 0x1cd9]
mov byte [ebp - 0x225d], dl
lea eax, [ebp - 0x2260]
mov dword [ebp - 0x4454], eax
mov ecx, dword [ebp - 0x4454]
mov dword [ebp - 0x2860], ecx
mov dword [ebp - 0x2148], 0
jmp 0x10115d51
mov edx, dword [ebp - 0x2148]
add edx, 1
mov dword [ebp - 0x2148], edx
cmp dword [ebp - 0x2148], 4
jae 0x10115dd3
mov eax, dword [ebp - 0x2860]
mov dword [ebp - 0x4458], eax
mov ecx, dword [ebp - 0x4458]
add ecx, dword [ebp - 0x2148]
mov dword [ebp - 0x4504], ecx
mov edx, dword [ebp - 0x4504]
mov al, byte [edx]
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 - 0x1ce2], dl
mov eax, dword [ebp - 0x2860]
mov dword [ebp - 0x4508], eax
mov ecx, dword [ebp - 0x4508]
add ecx, dword [ebp - 0x2148]
mov dword [ebp - 0x450c], ecx
mov edx, dword [ebp - 0x450c]
mov al, byte [ebp - 0x1ce2]
mov byte [edx], al
jmp 0x10115d42
mov ecx, dword [ebp - 0x2860]
mov dword [ebp - 0x4510], ecx
mov edx, dword [ebp - 0x4510]
mov dword [ebp - 0x4514], edx
mov eax, dword [ebp - 0x4514]
mov dword [ebp - 0x4518], eax
mov ecx, dword [ebp - 0x4518]
push ecx
lea ecx, [ebp - 0x5f28]
call fcn.1007b880
mov dword [ebp - 4], 0x13
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.direction]
mov byte [ebp - 0x1ce8], cl
movsx edx, byte [ebp - 0x1ce8]
xor edx, 0x34
mov byte [ebp - 0x1ce9], dl
mov al, byte [ebp - 0x1ce9]
mov byte [ebp - 0x23f8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.direction]
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 - 0x23f7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.direction]
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 - 0x23f6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.direction]
mov byte [ebp - 0x1d00], dl
movsx eax, byte [ebp - 0x1d00]
xor eax, 0x34
mov byte [ebp - 0x1d01], al
mov cl, byte [ebp - 0x1d01]
mov byte [ebp - 0x23f5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.direction]
mov byte [ebp - 0x1d08], al
movsx ecx, byte [ebp - 0x1d08]
xor ecx, 0x34
mov byte [ebp - 0x1d09], cl
mov dl, byte [ebp - 0x1d09]
mov byte [ebp - 0x23f4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.direction]
mov byte [ebp - 0x1d10], dl
movsx eax, byte [ebp - 0x1d10]
xor eax, 0x34
mov byte [ebp - 0x1d11], al
mov cl, byte [ebp - 0x1d11]
mov byte [ebp - 0x23f3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.direction]
mov byte [ebp - 0x1d18], cl
movsx edx, byte [ebp - 0x1d18]
xor edx, 0x34
mov byte [ebp - 0x1d19], dl
mov al, byte [ebp - 0x1d19]
mov byte [ebp - 0x23f2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.direction]
mov byte [ebp - 0x1d20], al
movsx ecx, byte [ebp - 0x1d20]
xor ecx, 0x34
mov byte [ebp - 0x1d21], cl
mov dl, byte [ebp - 0x1d21]
mov byte [ebp - 0x23f1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.direction]
mov byte [ebp - 0x1d28], cl
movsx edx, byte [ebp - 0x1d28]
xor edx, 0x34
mov byte [ebp - 0x1d29], dl
mov al, byte [ebp - 0x1d29]
mov byte [ebp - 0x23f0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.direction]
mov byte [ebp - 0x1d30], al
movsx ecx, byte [ebp - 0x1d30]
xor ecx, 0x34
mov byte [ebp - 0x1d31], cl
mov dl, byte [ebp - 0x1d31]
mov byte [ebp - 0x23ef], dl
lea eax, [ebp - 0x23f8]
mov dword [ebp - 0x451c], eax
mov ecx, dword [ebp - 0x451c]
mov dword [ebp - 0x2864], ecx
mov dword [ebp - 0x2144], 0
jmp 0x10116022
mov edx, dword [ebp - 0x2144]
add edx, 1
mov dword [ebp - 0x2144], edx
cmp dword [ebp - 0x2144], 0xa
jae 0x101160a4
mov eax, dword [ebp - 0x2864]
mov dword [ebp - 0x4520], eax
mov ecx, dword [ebp - 0x4520]
add ecx, dword [ebp - 0x2144]
mov dword [ebp - 0x4524], ecx
mov edx, dword [ebp - 0x4524]
mov al, byte [edx]
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 - 0x1d3a], dl
mov eax, dword [ebp - 0x2864]
mov dword [ebp - 0x4528], eax
mov ecx, dword [ebp - 0x4528]
add ecx, dword [ebp - 0x2144]
mov dword [ebp - 0x452c], ecx
mov edx, dword [ebp - 0x452c]
mov al, byte [ebp - 0x1d3a]
mov byte [edx], al
jmp 0x10116013
mov ecx, dword [ebp - 0x2864]
mov dword [ebp - 0x4530], ecx
mov edx, dword [ebp - 0x4530]
mov dword [ebp - 0x4534], edx
mov eax, dword [ebp - 0x4534]
mov dword [ebp - 0x4538], eax
mov ecx, dword [ebp - 0x4538]
push ecx
lea ecx, [ebp - 0x5f10]
call fcn.1007b880
mov byte [ebp - 4], 0x14
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.jitter]
mov byte [ebp - 0x1d40], cl
movsx edx, byte [ebp - 0x1d40]
xor edx, 0x34
mov byte [ebp - 0x1d41], dl
mov al, byte [ebp - 0x1d41]
mov byte [ebp - 0x2390], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.jitter]
mov byte [ebp - 0x1d48], dl
movsx eax, byte [ebp - 0x1d48]
xor eax, 0x34
mov byte [ebp - 0x1d49], al
mov cl, byte [ebp - 0x1d49]
mov byte [ebp - 0x238f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.jitter]
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 - 0x238e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.jitter]
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 - 0x238d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.jitter]
mov byte [ebp - 0x1d60], al
movsx ecx, byte [ebp - 0x1d60]
xor ecx, 0x34
mov byte [ebp - 0x1d61], cl
mov dl, byte [ebp - 0x1d61]
mov byte [ebp - 0x238c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.jitter]
mov byte [ebp - 0x1d68], dl
movsx eax, byte [ebp - 0x1d68]
xor eax, 0x34
mov byte [ebp - 0x1d69], al
mov cl, byte [ebp - 0x1d69]
mov byte [ebp - 0x238b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.jitter]
mov byte [ebp - 0x1d70], cl
movsx edx, byte [ebp - 0x1d70]
xor edx, 0x34
mov byte [ebp - 0x1d71], dl
mov al, byte [ebp - 0x1d71]
mov byte [ebp - 0x238a], al
lea ecx, [ebp - 0x2390]
mov dword [ebp - 0x453c], ecx
mov edx, dword [ebp - 0x453c]
mov dword [ebp - 0x2898], edx
mov dword [ebp - 0x2140], 0
jmp 0x10116260
mov eax, dword [ebp - 0x2140]
add eax, 1
mov dword [ebp - 0x2140], eax
cmp dword [ebp - 0x2140], 7
jae 0x101162e2
mov ecx, dword [ebp - 0x2898]
mov dword [ebp - 0x4540], ecx
mov edx, dword [ebp - 0x4540]
add edx, dword [ebp - 0x2140]
mov dword [ebp - 0x4544], edx
mov eax, dword [ebp - 0x4544]
mov cl, byte [eax]
mov byte [ebp - 0x1d78], cl
movsx edx, byte [ebp - 0x1d78]
xor edx, 0x34
mov byte [ebp - 0x1d79], dl
mov al, byte [ebp - 0x1d79]
mov byte [ebp - 0x1d7a], al
mov ecx, dword [ebp - 0x2898]
mov dword [ebp - 0x4548], ecx
mov edx, dword [ebp - 0x4548]
add edx, dword [ebp - 0x2140]
mov dword [ebp - 0x454c], edx
mov eax, dword [ebp - 0x454c]
mov cl, byte [ebp - 0x1d7a]
mov byte [eax], cl
jmp 0x10116251
mov edx, dword [ebp - 0x2898]
mov dword [ebp - 0x4550], edx
mov eax, dword [ebp - 0x4550]
mov dword [ebp - 0x4554], eax
mov ecx, dword [ebp - 0x4554]
mov dword [ebp - 0x4558], ecx
mov edx, dword [ebp - 0x4558]
push edx
lea ecx, [ebp - 0x5ef8]
call fcn.1007b880
mov byte [ebp - 4], 0x15
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.rotate]
mov byte [ebp - 0x1d80], dl
movsx eax, byte [ebp - 0x1d80]
xor eax, 0x34
mov byte [ebp - 0x1d81], al
mov cl, byte [ebp - 0x1d81]
mov byte [ebp - 0x2398], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.rotate]
mov byte [ebp - 0x1d88], al
movsx ecx, byte [ebp - 0x1d88]
xor ecx, 0x34
mov byte [ebp - 0x1d89], cl
mov dl, byte [ebp - 0x1d89]
mov byte [ebp - 0x2397], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.rotate]
mov byte [ebp - 0x1d90], cl
movsx edx, byte [ebp - 0x1d90]
xor edx, 0x34
mov byte [ebp - 0x1d91], dl
mov al, byte [ebp - 0x1d91]
mov byte [ebp - 0x2396], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.rotate]
mov byte [ebp - 0x1d98], al
movsx ecx, byte [ebp - 0x1d98]
xor ecx, 0x34
mov byte [ebp - 0x1d99], cl
mov dl, byte [ebp - 0x1d99]
mov byte [ebp - 0x2395], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.rotate]
mov byte [ebp - 0x1da0], cl
movsx edx, byte [ebp - 0x1da0]
xor edx, 0x34
mov byte [ebp - 0x1da1], dl
mov al, byte [ebp - 0x1da1]
mov byte [ebp - 0x2394], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.rotate]
mov byte [ebp - 0x1da8], al
movsx ecx, byte [ebp - 0x1da8]
xor ecx, 0x34
mov byte [ebp - 0x1da9], cl
mov dl, byte [ebp - 0x1da9]
mov byte [ebp - 0x2393], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.rotate]
mov byte [ebp - 0x1db0], dl
movsx eax, byte [ebp - 0x1db0]
xor eax, 0x34
mov byte [ebp - 0x1db1], al
mov cl, byte [ebp - 0x1db1]
mov byte [ebp - 0x2392], cl
lea edx, [ebp - 0x2398]
mov dword [ebp - 0x455c], edx
mov eax, dword [ebp - 0x455c]
mov dword [ebp - 0x289c], eax
mov dword [ebp - 0x213c], 0
jmp 0x1011649e
mov ecx, dword [ebp - 0x213c]
add ecx, 1
mov dword [ebp - 0x213c], ecx
cmp dword [ebp - 0x213c], 7
jae 0x10116520
mov edx, dword [ebp - 0x289c]
mov dword [ebp - 0x4560], edx
mov eax, dword [ebp - 0x4560]
add eax, dword [ebp - 0x213c]
mov dword [ebp - 0x4564], eax
mov ecx, dword [ebp - 0x4564]
mov dl, byte [ecx]
mov byte [ebp - 0x1db8], dl
movsx eax, byte [ebp - 0x1db8]
xor eax, 0x34
mov byte [ebp - 0x1db9], al
mov cl, byte [ebp - 0x1db9]
mov byte [ebp - 0x1dba], cl
mov edx, dword [ebp - 0x289c]
mov dword [ebp - 0x4568], edx
mov eax, dword [ebp - 0x4568]
add eax, dword [ebp - 0x213c]
mov dword [ebp - 0x456c], eax
mov ecx, dword [ebp - 0x456c]
mov dl, byte [ebp - 0x1dba]
mov byte [ecx], dl
jmp 0x1011648f
mov eax, dword [ebp - 0x289c]
mov dword [ebp - 0x4570], eax
mov ecx, dword [ebp - 0x4570]
mov dword [ebp - 0x4574], ecx
mov edx, dword [ebp - 0x4574]
mov dword [ebp - 0x4578], edx
mov eax, dword [ebp - 0x4578]
push eax
lea ecx, [ebp - 0x5ee0]
call fcn.1007b880
mov byte [ebp - 4], 0x16
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.random]
mov byte [ebp - 0x1dc0], al
movsx ecx, byte [ebp - 0x1dc0]
xor ecx, 0x34
mov byte [ebp - 0x1dc1], cl
mov dl, byte [ebp - 0x1dc1]
mov byte [ebp - 0x23a0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.random]
mov byte [ebp - 0x1dc8], cl
movsx edx, byte [ebp - 0x1dc8]
xor edx, 0x34
mov byte [ebp - 0x1dc9], dl
mov al, byte [ebp - 0x1dc9]
mov byte [ebp - 0x239f], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x1dd0], dl
movsx eax, byte [ebp - 0x1dd0]
xor eax, 0x34
mov byte [ebp - 0x1dd1], al
mov cl, byte [ebp - 0x1dd1]
mov byte [ebp - 0x239e], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.random]
mov byte [ebp - 0x1dd8], cl
movsx edx, byte [ebp - 0x1dd8]
xor edx, 0x34
mov byte [ebp - 0x1dd9], dl
mov al, byte [ebp - 0x1dd9]
mov byte [ebp - 0x239d], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.random]
mov byte [ebp - 0x1de0], dl
movsx eax, byte [ebp - 0x1de0]
xor eax, 0x34
mov byte [ebp - 0x1de1], al
mov cl, byte [ebp - 0x1de1]
mov byte [ebp - 0x239c], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.random]
mov byte [ebp - 0x1de8], cl
movsx edx, byte [ebp - 0x1de8]
xor edx, 0x34
mov byte [ebp - 0x1de9], dl
mov al, byte [ebp - 0x1de9]
mov byte [ebp - 0x239b], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.random]
mov byte [ebp - 0x1df0], al
movsx ecx, byte [ebp - 0x1df0]
xor ecx, 0x34
mov byte [ebp - 0x1df1], cl
mov dl, byte [ebp - 0x1df1]
mov byte [ebp - 0x239a], dl
lea eax, [ebp - 0x23a0]
mov dword [ebp - 0x457c], eax
mov ecx, dword [ebp - 0x457c]
mov dword [ebp - 0x28a0], ecx
mov dword [ebp - 0x2138], 0
jmp 0x101166dc
mov edx, dword [ebp - 0x2138]
add edx, 1
mov dword [ebp - 0x2138], edx
cmp dword [ebp - 0x2138], 7
jae 0x1011675e
mov eax, dword [ebp - 0x28a0]
mov dword [ebp - 0x4580], eax
mov ecx, dword [ebp - 0x4580]
add ecx, dword [ebp - 0x2138]
mov dword [ebp - 0x4584], ecx
mov edx, dword [ebp - 0x4584]
mov al, byte [edx]
mov byte [ebp - 0x1df8], al
movsx ecx, byte [ebp - 0x1df8]
xor ecx, 0x34
mov byte [ebp - 0x1df9], cl
mov dl, byte [ebp - 0x1df9]
mov byte [ebp - 0x1dfa], dl
mov eax, dword [ebp - 0x28a0]
mov dword [ebp - 0x4588], eax
mov ecx, dword [ebp - 0x4588]
add ecx, dword [ebp - 0x2138]
mov dword [ebp - 0x458c], ecx
mov edx, dword [ebp - 0x458c]
mov al, byte [ebp - 0x1dfa]
mov byte [edx], al
jmp 0x101166cd
mov ecx, dword [ebp - 0x28a0]
mov dword [ebp - 0x4590], ecx
mov edx, dword [ebp - 0x4590]
mov dword [ebp - 0x4594], edx
mov eax, dword [ebp - 0x4594]
mov dword [ebp - 0x4598], eax
mov ecx, dword [ebp - 0x4598]
push ecx
lea ecx, [ebp - 0x5ec8]
call fcn.1007b880
mov byte [ebp - 4], 0x17
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.6_way]
mov byte [ebp - 0x1e00], cl
movsx edx, byte [ebp - 0x1e00]
xor edx, 0x34
mov byte [ebp - 0x1e01], dl
mov al, byte [ebp - 0x1e01]
mov byte [ebp - 0x2360], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x1e08], dl
movsx eax, byte [ebp - 0x1e08]
xor eax, 0x34
mov byte [ebp - 0x1e09], al
mov cl, byte [ebp - 0x1e09]
mov byte [ebp - 0x235f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.6_way]
mov byte [ebp - 0x1e10], al
movsx ecx, byte [ebp - 0x1e10]
xor ecx, 0x34
mov byte [ebp - 0x1e11], cl
mov dl, byte [ebp - 0x1e11]
mov byte [ebp - 0x235e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x1e18], dl
movsx eax, byte [ebp - 0x1e18]
xor eax, 0x34
mov byte [ebp - 0x1e19], al
mov cl, byte [ebp - 0x1e19]
mov byte [ebp - 0x235d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.6_way]
mov byte [ebp - 0x1e20], al
movsx ecx, byte [ebp - 0x1e20]
xor ecx, 0x34
mov byte [ebp - 0x1e21], cl
mov dl, byte [ebp - 0x1e21]
mov byte [ebp - 0x235c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.6_way]
mov byte [ebp - 0x1e28], dl
movsx eax, byte [ebp - 0x1e28]
xor eax, 0x34
mov byte [ebp - 0x1e29], al
mov cl, byte [ebp - 0x1e29]
mov byte [ebp - 0x235b], cl
lea edx, [ebp - 0x2360]
mov dword [ebp - 0x459c], edx
mov eax, dword [ebp - 0x459c]
mov dword [ebp - 0x28c4], eax
mov dword [ebp - 0x2134], 0
jmp 0x101168ea
mov ecx, dword [ebp - 0x2134]
add ecx, 1
mov dword [ebp - 0x2134], ecx
cmp dword [ebp - 0x2134], 6
jae 0x1011696c
mov edx, dword [ebp - 0x28c4]
mov dword [ebp - 0x45a0], edx
mov eax, dword [ebp - 0x45a0]
add eax, dword [ebp - 0x2134]
mov dword [ebp - 0x45a4], eax
mov ecx, dword [ebp - 0x45a4]
mov dl, byte [ecx]
mov byte [ebp - 0x1e30], dl
movsx eax, byte [ebp - 0x1e30]
xor eax, 0x34
mov byte [ebp - 0x1e31], al
mov cl, byte [ebp - 0x1e31]
mov byte [ebp - 0x1e32], cl
mov edx, dword [ebp - 0x28c4]
mov dword [ebp - 0x45a8], edx
mov eax, dword [ebp - 0x45a8]
add eax, dword [ebp - 0x2134]
mov dword [ebp - 0x45ac], eax
mov ecx, dword [ebp - 0x45ac]
mov dl, byte [ebp - 0x1e32]
mov byte [ecx], dl
jmp 0x101168db
mov eax, dword [ebp - 0x28c4]
mov dword [ebp - 0x45b0], eax
mov ecx, dword [ebp - 0x45b0]
mov dword [ebp - 0x45b4], ecx
mov edx, dword [ebp - 0x45b4]
mov dword [ebp - 0x45b8], edx
mov eax, dword [ebp - 0x45b8]
push eax
lea ecx, [ebp - 0x5eb0]
call fcn.1007b880
mov dword [ebp - 4], 0x18
lea ecx, [ebp - 0x5f28]
mov dword [ebp - 0x46bc], ecx
lea edx, [ebp - 0x5e98]
mov dword [ebp - 0x46b8], edx
lea eax, [ebp - 0x46bc]
mov dword [ebp - 0x45bc], eax
mov ecx, dword [ebp - 0x45bc]
mov edx, dword [ecx]
mov eax, dword [ecx + 4]
mov dword [ebp - 0x4470], edx
mov dword [ebp - 0x446c], eax
mov ecx, dword [ebp - 0x45c0]
push ecx
mov edx, dword [ebp - 0x446c]
push edx
mov eax, dword [ebp - 0x4470]
push eax
lea ecx, [ebp - 0x475c]
call fcn.101ed250
mov byte [ebp - 4], 0x19
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0x1e38], al
movsx ecx, byte [ebp - 0x1e38]
xor ecx, 0x34
mov byte [ebp - 0x1e39], cl
mov dl, byte [ebp - 0x1e39]
mov byte [ebp - 0x23c8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0x1e40], cl
movsx edx, byte [ebp - 0x1e40]
xor edx, 0x34
mov byte [ebp - 0x1e41], dl
mov al, byte [ebp - 0x1e41]
mov byte [ebp - 0x23c7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0x1e48], dl
movsx eax, byte [ebp - 0x1e48]
xor eax, 0x34
mov byte [ebp - 0x1e49], al
mov cl, byte [ebp - 0x1e49]
mov byte [ebp - 0x23c6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0x1e50], cl
movsx edx, byte [ebp - 0x1e50]
xor edx, 0x34
mov byte [ebp - 0x1e51], dl
mov al, byte [ebp - 0x1e51]
mov byte [ebp - 0x23c5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0x1e58], dl
movsx eax, byte [ebp - 0x1e58]
xor eax, 0x34
mov byte [ebp - 0x1e59], al
mov cl, byte [ebp - 0x1e59]
mov byte [ebp - 0x23c4], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.yaw_stnd]
mov byte [ebp - 0x1e60], cl
movsx edx, byte [ebp - 0x1e60]
xor edx, 0x34
mov byte [ebp - 0x1e61], dl
mov al, byte [ebp - 0x1e61]
mov byte [ebp - 0x23c3], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0x1e68], al
movsx ecx, byte [ebp - 0x1e68]
xor ecx, 0x34
mov byte [ebp - 0x1e69], cl
mov dl, byte [ebp - 0x1e69]
mov byte [ebp - 0x23c2], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.yaw_stnd]
mov byte [ebp - 0x1e70], dl
movsx eax, byte [ebp - 0x1e70]
xor eax, 0x34
mov byte [ebp - 0x1e71], al
mov cl, byte [ebp - 0x1e71]
mov byte [ebp - 0x23c1], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.yaw_stnd]
mov byte [ebp - 0x1e78], al
movsx ecx, byte [ebp - 0x1e78]
xor ecx, 0x34
mov byte [ebp - 0x1e79], cl
mov dl, byte [ebp - 0x1e79]
mov byte [ebp - 0x23c0], dl
lea eax, [ebp - 0x23c8]
mov dword [ebp - 0x45c4], eax
mov ecx, dword [ebp - 0x45c4]
mov dword [ebp - 0x28c8], ecx
mov dword [ebp - 0x2130], 0
jmp 0x10116bea
mov edx, dword [ebp - 0x2130]
add edx, 1
mov dword [ebp - 0x2130], edx
cmp dword [ebp - 0x2130], 9
jae 0x10116c6c
mov eax, dword [ebp - 0x28c8]
mov dword [ebp - 0x45c8], eax
mov ecx, dword [ebp - 0x45c8]
add ecx, dword [ebp - 0x2130]
mov dword [ebp - 0x45cc], ecx
mov edx, dword [ebp - 0x45cc]
mov al, byte [edx]
mov byte [ebp - 0x1e80], al
movsx ecx, byte [ebp - 0x1e80]
xor ecx, 0x34
mov byte [ebp - 0x1e81], cl
mov dl, byte [ebp - 0x1e81]
mov byte [ebp - 0x1e82], dl
mov eax, dword [ebp - 0x28c8]
mov dword [ebp - 0x45d0], eax
mov ecx, dword [ebp - 0x45d0]
add ecx, dword [ebp - 0x2130]
mov dword [ebp - 0x45d4], ecx
mov edx, dword [ebp - 0x45d4]
mov al, byte [ebp - 0x1e82]
mov byte [edx], al
jmp 0x10116bdb
mov ecx, dword [ebp - 0x28c8]
mov dword [ebp - 0x45d8], ecx
mov edx, dword [ebp - 0x45d8]
mov dword [ebp - 0x45dc], edx
mov eax, dword [ebp - 0x45dc]
mov dword [ebp - 0x45e0], eax
mov ecx, dword [ebp - 0x45e0]
push ecx
lea ecx, [ebp - 0x4978]
call fcn.1007b880
mov byte [ebp - 4], 0x1a
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + 0x102a2aa0]
mov byte [ebp - 0x1e88], cl
movsx edx, byte [ebp - 0x1e88]
xor edx, 0x34
mov byte [ebp - 0x1e89], dl
mov al, byte [ebp - 0x1e89]
mov byte [ebp - 0x2264], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + 0x102a2aa0]
mov byte [ebp - 0xa04], dl
movsx eax, byte [ebp - 0xa04]
xor eax, 0x34
mov byte [ebp - 0xa05], al
mov cl, byte [ebp - 0xa05]
mov byte [ebp - 0x2263], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + 0x102a2aa0]
mov byte [ebp - 0xa0c], al
movsx ecx, byte [ebp - 0xa0c]
xor ecx, 0x34
mov byte [ebp - 0xa0d], cl
mov dl, byte [ebp - 0xa0d]
mov byte [ebp - 0x2262], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + 0x102a2aa0]
mov byte [ebp - 0xa14], dl
movsx eax, byte [ebp - 0xa14]
xor eax, 0x34
mov byte [ebp - 0xa15], al
mov cl, byte [ebp - 0xa15]
mov byte [ebp - 0x2261], cl
lea edx, [ebp - 0x2264]
mov dword [ebp - 0x45e4], edx
mov eax, dword [ebp - 0x45e4]
mov dword [ebp - 0x293c], eax
mov dword [ebp - 0x212c], 0
jmp 0x10116d98
mov ecx, dword [ebp - 0x212c]
add ecx, 1
mov dword [ebp - 0x212c], ecx
cmp dword [ebp - 0x212c], 4
jae 0x10116e1a
mov edx, dword [ebp - 0x293c]
mov dword [ebp - 0x45e8], edx
mov eax, dword [ebp - 0x45e8]
add eax, dword [ebp - 0x212c]
mov dword [ebp - 0x45ec], eax
mov ecx, dword [ebp - 0x45ec]
mov dl, byte [ecx]
mov byte [ebp - 0xa1c], dl
movsx eax, byte [ebp - 0xa1c]
xor eax, 0x34
mov byte [ebp - 0xa1d], al
mov cl, byte [ebp - 0xa1d]
mov byte [ebp - 0xa1e], cl
mov edx, dword [ebp - 0x293c]
mov dword [ebp - 0x45f0], edx
mov eax, dword [ebp - 0x45f0]
add eax, dword [ebp - 0x212c]
mov dword [ebp - 0x45f4], eax
mov ecx, dword [ebp - 0x45f4]
mov dl, byte [ebp - 0xa1e]
mov byte [ecx], dl
jmp 0x10116d89
mov eax, dword [ebp - 0x293c]
mov dword [ebp - 0x45f8], eax
mov ecx, dword [ebp - 0x45f8]
mov dword [ebp - 0x45fc], ecx
mov edx, dword [ebp - 0x45fc]
mov dword [ebp - 0x4600], edx
mov eax, dword [ebp - 0x4600]
push eax
lea ecx, [ebp - 0x4960]
call fcn.1007b880
mov byte [ebp - 4], 0x1b
lea ecx, [ebp - 0x4978]
push ecx
mov ecx, dword [ebp - 0x344]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x344]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x344]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10116e97
lea edx, [ebp - 0x4960]
push edx
mov ecx, dword [ebp - 0x344]
add ecx, 0x70
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x344]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10116eb1
mov dword [ebp - 0x2ab0], 0xf
jmp 0x10116ebb
mov dword [ebp - 0x2ab0], 0
mov edx, dword [ebp - 0x344]
mov eax, dword [ebp - 0x2ab0]
mov dword [edx + 0x9c], eax
mov ecx, dword [ebp - 0x344]
mov edx, dword [ecx + 0x9c]
add edx, 0x14
mov dword [ebp - 0x2ab4], edx
mov eax, dword [ebp - 0x344]
mov ecx, dword [ebp - 0x2ab4]
mov dword [eax + 0x10], ecx
mov edx, dword [ebp - 0x344]
mov eax, dword [ebp - 0x2ab4]
mov dword [edx + 0x14], eax
lea ecx, [ebp - 0x475c]
mov dword [ebp - 0x2ab8], ecx
mov edx, dword [ebp - 0x2ab8]
mov eax, dword [edx]
mov dword [ebp - 0x4604], eax
mov ecx, dword [ebp - 0x4604]
mov dword [ebp - 0x4608], ecx
mov edx, dword [ebp - 0x4608]
mov dword [ebp - 0x460c], edx
mov eax, dword [ebp - 0x460c]
mov dword [ebp - 0x2268], eax
mov ecx, dword [ebp - 0x2ab8]
mov edx, dword [ecx + 4]
mov dword [ebp - 0x4610], edx
mov eax, dword [ebp - 0x4610]
mov dword [ebp - 0x4614], eax
mov ecx, dword [ebp - 0x4614]
mov dword [ebp - 0x4618], ecx
mov edx, dword [ebp - 0x4618]
mov dword [ebp - 0x461c], edx
jmp 0x10116f82
mov eax, dword [ebp - 0x2268]
add eax, 0x18
mov dword [ebp - 0x2268], eax
mov ecx, dword [ebp - 0x2268]
cmp ecx, dword [ebp - 0x461c]
je 0x10116fc2
mov edx, dword [ebp - 0x2268]
mov dword [ebp - 0x4620], edx
mov eax, dword [ebp - 0x344]
add eax, 0x88
mov dword [ebp - 0x4624], eax
mov ecx, dword [ebp - 0x4620]
push ecx
mov ecx, dword [ebp - 0x4624]
call fcn.100d29a0
nop
jmp 0x10116f73
mov edx, dword [ebp - 0x344]
add edx, 0x88
mov dword [ebp - 0x2abc], edx
mov eax, dword [ebp - 0x2abc]
mov ecx, dword [ebp - 0x2abc]
mov eax, dword [eax + 4]
sub eax, dword [ecx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x4628], eax
cmp dword [ebp - 0x4628], 0
jbe 0x1011700c
mov edx, dword [ebp - 0x344]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x1a
lea ecx, [ebp - 0x4960]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x19
lea ecx, [ebp - 0x4978]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x18
lea ecx, [ebp - 0x475c]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 6
push 0x18
lea eax, [ebp - 0x5f28]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x280
mov dword [ebp - 0x462c], ecx
mov dword [ebp - 0x1c0], 0x1008a930
mov edx, dword [ebp - 0x462c]
add edx, 0x58
mov dword [ebp - 0x4634], edx
lea eax, [ebp - 0x1c0]
push eax
mov ecx, dword [ebp - 0x4634]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x280
mov dword [ebp - 0xd8], ecx
mov edx, dword [ebp - 0xd8]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xd8]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xd8]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xd8]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xd8]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x4638], ecx
lea edx, [ebp - 0xd8]
push edx
mov ecx, dword [ebp - 0x4638]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x320
mov dword [ebp - 0x29c], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x102a2a9c]
mov word [ebp - 0x2750], ax
movzx ecx, word [ebp - 0x2750]
xor ecx, 0x34
mov word [ebp - 0x262e], cx
mov dx, word [ebp - 0x262e]
mov word [ebp - 0x2ac0], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x102a2a9c]
mov word [ebp - 0x2634], cx
movzx edx, word [ebp - 0x2634]
xor edx, 0x34
mov word [ebp - 0x2636], dx
mov ax, word [ebp - 0x2636]
mov word [ebp - 0x2abe], ax
lea ecx, [ebp - 0x2ac0]
mov dword [ebp - 0x463c], ecx
mov edx, dword [ebp - 0x463c]
mov dword [ebp - 0x2940], edx
mov dword [ebp - 0x2128], 0
jmp 0x101171be
mov eax, dword [ebp - 0x2128]
add eax, 1
mov dword [ebp - 0x2128], eax
cmp dword [ebp - 0x2128], 2
jae 0x10117251
mov ecx, dword [ebp - 0x2940]
mov dword [ebp - 0x4640], ecx
mov edx, dword [ebp - 0x2128]
mov eax, dword [ebp - 0x4640]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x4644], ecx
mov edx, dword [ebp - 0x4644]
mov ax, word [edx]
mov word [ebp - 0x263c], ax
movzx ecx, word [ebp - 0x263c]
xor ecx, 0x34
mov word [ebp - 0x263e], cx
mov dx, word [ebp - 0x263e]
mov word [ebp - 0x2640], dx
mov eax, dword [ebp - 0x2940]
mov dword [ebp - 0x4648], eax
mov ecx, dword [ebp - 0x2128]
mov edx, dword [ebp - 0x4648]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x464c], eax
mov ecx, dword [ebp - 0x464c]
mov dx, word [ebp - 0x2640]
mov word [ecx], dx
jmp 0x101171af
mov eax, dword [ebp - 0x2940]
mov dword [ebp - 0x4650], eax
mov ecx, dword [ebp - 0x4650]
mov dword [ebp - 0x4654], ecx
mov edx, dword [ebp - 0x4654]
mov dword [ebp - 0x4658], edx
mov eax, dword [ebp - 0x4658]
push eax
lea ecx, [ebp - 0x49c0]
call fcn.101ed710
mov dword [ebp - 4], 0x1c
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xa24], al
movsx ecx, byte [ebp - 0xa24]
xor ecx, 0x34
mov byte [ebp - 0xa25], cl
mov dl, byte [ebp - 0xa25]
mov byte [ebp - 0x24e4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xa2c], cl
movsx edx, byte [ebp - 0xa2c]
xor edx, 0x34
mov byte [ebp - 0xa2d], dl
mov al, byte [ebp - 0xa2d]
mov byte [ebp - 0x24e3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa34], dl
movsx eax, byte [ebp - 0xa34]
xor eax, 0x34
mov byte [ebp - 0xa35], al
mov cl, byte [ebp - 0xa35]
mov byte [ebp - 0x24e2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xa3c], cl
movsx edx, byte [ebp - 0xa3c]
xor edx, 0x34
mov byte [ebp - 0xa3d], dl
mov al, byte [ebp - 0xa3d]
mov byte [ebp - 0x24e1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa44], dl
movsx eax, byte [ebp - 0xa44]
xor eax, 0x34
mov byte [ebp - 0xa45], al
mov cl, byte [ebp - 0xa45]
mov byte [ebp - 0x24e0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xa4c], cl
movsx edx, byte [ebp - 0xa4c]
xor edx, 0x34
mov byte [ebp - 0xa4d], dl
mov al, byte [ebp - 0xa4d]
mov byte [ebp - 0x24df], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xa54], al
movsx ecx, byte [ebp - 0xa54]
xor ecx, 0x34
mov byte [ebp - 0xa55], cl
mov dl, byte [ebp - 0xa55]
mov byte [ebp - 0x24de], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa5c], dl
movsx eax, byte [ebp - 0xa5c]
xor eax, 0x34
mov byte [ebp - 0xa5d], al
mov cl, byte [ebp - 0xa5d]
mov byte [ebp - 0x24dd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xa64], al
movsx ecx, byte [ebp - 0xa64]
xor ecx, 0x34
mov byte [ebp - 0xa65], cl
mov dl, byte [ebp - 0xa65]
mov byte [ebp - 0x24dc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa6c], dl
movsx eax, byte [ebp - 0xa6c]
xor eax, 0x34
mov byte [ebp - 0xa6d], al
mov cl, byte [ebp - 0xa6d]
mov byte [ebp - 0x24db], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xa74], cl
movsx edx, byte [ebp - 0xa74]
xor edx, 0x34
mov byte [ebp - 0xa75], dl
mov al, byte [ebp - 0xa75]
mov byte [ebp - 0x24da], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xa7c], al
movsx ecx, byte [ebp - 0xa7c]
xor ecx, 0x34
mov byte [ebp - 0xa7d], cl
mov dl, byte [ebp - 0xa7d]
mov byte [ebp - 0x24d9], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa84], dl
movsx eax, byte [ebp - 0xa84]
xor eax, 0x34
mov byte [ebp - 0xa85], al
mov cl, byte [ebp - 0xa85]
mov byte [ebp - 0x24d8], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.jitter_range_stnd]
mov byte [ebp - 0xa8c], cl
movsx edx, byte [ebp - 0xa8c]
xor edx, 0x34
mov byte [ebp - 0xa8d], dl
mov al, byte [ebp - 0xa8d]
mov byte [ebp - 0x24d7], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xa94], al
movsx ecx, byte [ebp - 0xa94]
xor ecx, 0x34
mov byte [ebp - 0xa95], cl
mov dl, byte [ebp - 0xa95]
mov byte [ebp - 0x24d6], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xa9c], dl
movsx eax, byte [ebp - 0xa9c]
xor eax, 0x34
mov byte [ebp - 0xa9d], al
mov cl, byte [ebp - 0xa9d]
mov byte [ebp - 0x24d5], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.jitter_range_stnd]
mov byte [ebp - 0xaa4], al
movsx ecx, byte [ebp - 0xaa4]
xor ecx, 0x34
mov byte [ebp - 0xaa5], cl
mov dl, byte [ebp - 0xaa5]
mov byte [ebp - 0x24d4], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.jitter_range_stnd]
mov byte [ebp - 0xaac], dl
movsx eax, byte [ebp - 0xaac]
xor eax, 0x34
mov byte [ebp - 0xaad], al
mov cl, byte [ebp - 0xaad]
mov byte [ebp - 0x24d3], cl
lea edx, [ebp - 0x24e4]
mov dword [ebp - 0x465c], edx
mov eax, dword [ebp - 0x465c]
mov dword [ebp - 0x2960], eax
mov dword [ebp - 0x2124], 0
jmp 0x10117620
mov ecx, dword [ebp - 0x2124]
add ecx, 1
mov dword [ebp - 0x2124], ecx
cmp dword [ebp - 0x2124], 0x12
jae 0x101176a2
mov edx, dword [ebp - 0x2960]
mov dword [ebp - 0x4660], edx
mov eax, dword [ebp - 0x4660]
add eax, dword [ebp - 0x2124]
mov dword [ebp - 0x4664], eax
mov ecx, dword [ebp - 0x4664]
mov dl, byte [ecx]
mov byte [ebp - 0xab4], dl
movsx eax, byte [ebp - 0xab4]
xor eax, 0x34
mov byte [ebp - 0xab5], al
mov cl, byte [ebp - 0xab5]
mov byte [ebp - 0xab6], cl
mov edx, dword [ebp - 0x2960]
mov dword [ebp - 0x4668], edx
mov eax, dword [ebp - 0x4668]
add eax, dword [ebp - 0x2124]
mov dword [ebp - 0x466c], eax
mov ecx, dword [ebp - 0x466c]
mov dl, byte [ebp - 0xab6]
mov byte [ecx], dl
jmp 0x10117611
mov eax, dword [ebp - 0x2960]
mov dword [ebp - 0x4670], eax
mov ecx, dword [ebp - 0x4670]
mov dword [ebp - 0x4674], ecx
mov edx, dword [ebp - 0x4674]
mov dword [ebp - 0x4678], edx
mov eax, dword [ebp - 0x4678]
push eax
lea ecx, [ebp - 0x49a8]
call fcn.1007b880
mov byte [ebp - 4], 0x1d
push 0x102a0e2e
lea ecx, [ebp - 0x4990]
call fcn.1007b880
mov byte [ebp - 4], 0x1e
lea ecx, [ebp - 0x49a8]
push ecx
mov ecx, dword [ebp - 0x29c]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x29c]
mov byte [edx + 0x69], 0
mov eax, dword [ebp - 0x29c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10117736
lea edx, [ebp - 0x4990]
push edx
mov ecx, dword [ebp - 0x29c]
add ecx, 0x88
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x29c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10117750
mov dword [ebp - 0x2ac4], 0xf
jmp 0x1011775a
mov dword [ebp - 0x2ac4], 0
mov edx, dword [ebp - 0x29c]
mov eax, dword [ebp - 0x2ac4]
mov dword [edx + 0xb8], eax
mov ecx, dword [ebp - 0x29c]
mov edx, dword [ecx + 0xb8]
add edx, 8
mov eax, dword [ebp - 0x29c]
mov dword [eax + 0x10], edx
mov ecx, dword [ebp - 0x29c]
mov edx, dword [ebp - 0x29c]
mov eax, dword [edx + 0x10]
mov dword [ecx + 0x14], eax
mov ecx, dword [ebp - 0x29c]
movss xmm0, dword [0x102a6038]
movss dword [ecx + 0x74], xmm0
mov edx, dword [ebp - 0x29c]
movss xmm0, dword [0x102a61a8]
movss dword [edx + 0x78], xmm0
mov eax, dword [ebp - 0x29c]
movss xmm0, dword [0x102a612c]
movss dword [eax + 0x70], xmm0
mov ecx, dword [ebp - 0x29c]
mov dword [ecx + 0x84], 0
mov edx, dword [ebp - 0x29c]
movss xmm0, dword [0x102a60dc]
movss dword [edx + 0x7c], xmm0
lea eax, [ebp - 0x49c0]
push eax
mov ecx, dword [ebp - 0x29c]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x1d
lea ecx, [ebp - 0x4990]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x1c
lea ecx, [ebp - 0x49a8]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x49c0]
call fcn.100d2140
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x320
mov dword [ebp - 0x467c], ecx
mov dword [ebp - 0x1c4], 0x1008a930
mov edx, dword [ebp - 0x467c]
add edx, 0x58
mov dword [ebp - 0x4684], edx
lea eax, [ebp - 0x1c4]
push eax
mov ecx, dword [ebp - 0x4684]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x320
mov dword [ebp - 0x4688], ecx
mov dword [ebp - 0x1c8], 0x1008a990
mov edx, dword [ebp - 0x4688]
add edx, 0x58
mov dword [ebp - 0x4690], edx
lea eax, [ebp - 0x1c8]
push eax
mov ecx, dword [ebp - 0x4690]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x320
mov dword [ebp - 0xdc], ecx
mov edx, dword [ebp - 0xdc]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xdc]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xdc]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xdc]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xdc]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x4694], ecx
lea edx, [ebp - 0xdc]
push edx
mov ecx, dword [ebp - 0x4694]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x3dc
mov dword [ebp - 0x298], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x102a2a9c]
mov word [ebp - 0x2644], ax
movzx ecx, word [ebp - 0x2644]
xor ecx, 0x34
mov word [ebp - 0x2646], cx
mov dx, word [ebp - 0x2646]
mov word [ebp - 0x2ac8], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x102a2a9c]
mov word [ebp - 0x264c], cx
movzx edx, word [ebp - 0x264c]
xor edx, 0x34
mov word [ebp - 0x264e], dx
mov ax, word [ebp - 0x264e]
mov word [ebp - 0x2ac6], ax
lea ecx, [ebp - 0x2ac8]
mov dword [ebp - 0x4698], ecx
mov edx, dword [ebp - 0x4698]
mov dword [ebp - 0x2964], edx
mov dword [ebp - 0x2120], 0
jmp 0x101179e1
mov eax, dword [ebp - 0x2120]
add eax, 1
mov dword [ebp - 0x2120], eax
cmp dword [ebp - 0x2120], 2
jae 0x10117a74
mov ecx, dword [ebp - 0x2964]
mov dword [ebp - 0x469c], ecx
mov edx, dword [ebp - 0x2120]
mov eax, dword [ebp - 0x469c]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x46a0], ecx
mov edx, dword [ebp - 0x46a0]
mov ax, word [edx]
mov word [ebp - 0x2654], ax
movzx ecx, word [ebp - 0x2654]
xor ecx, 0x34
mov word [ebp - 0x2656], cx
mov dx, word [ebp - 0x2656]
mov word [ebp - 0x2658], dx
mov eax, dword [ebp - 0x2964]
mov dword [ebp - 0x46a4], eax
mov ecx, dword [ebp - 0x2120]
mov edx, dword [ebp - 0x46a4]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x2b74], eax
mov ecx, dword [ebp - 0x2b74]
mov dx, word [ebp - 0x2658]
mov word [ecx], dx
jmp 0x101179d2
mov eax, dword [ebp - 0x2964]
mov dword [ebp - 0x2b78], eax
mov ecx, dword [ebp - 0x2b78]
mov dword [ebp - 0x2b7c], ecx
mov edx, dword [ebp - 0x2b7c]
mov dword [ebp - 0x2b80], edx
mov eax, dword [ebp - 0x2b80]
push eax
lea ecx, [ebp - 0x4a08]
call fcn.101ed710
mov dword [ebp - 4], 0x1f
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xabc], al
movsx ecx, byte [ebp - 0xabc]
xor ecx, 0x34
mov byte [ebp - 0xabd], cl
mov dl, byte [ebp - 0xabd]
mov byte [ebp - 0x2458], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xac4], cl
movsx edx, byte [ebp - 0xac4]
xor edx, 0x34
mov byte [ebp - 0xac5], dl
mov al, byte [ebp - 0xac5]
mov byte [ebp - 0x2457], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xacc], dl
movsx eax, byte [ebp - 0xacc]
xor eax, 0x34
mov byte [ebp - 0xacd], al
mov cl, byte [ebp - 0xacd]
mov byte [ebp - 0x2456], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xad4], cl
movsx edx, byte [ebp - 0xad4]
xor edx, 0x34
mov byte [ebp - 0xad5], dl
mov al, byte [ebp - 0xad5]
mov byte [ebp - 0x2455], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xadc], dl
movsx eax, byte [ebp - 0xadc]
xor eax, 0x34
mov byte [ebp - 0xadd], al
mov cl, byte [ebp - 0xadd]
mov byte [ebp - 0x2454], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xae4], cl
movsx edx, byte [ebp - 0xae4]
xor edx, 0x34
mov byte [ebp - 0xae5], dl
mov al, byte [ebp - 0xae5]
mov byte [ebp - 0x2453], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xaec], al
movsx ecx, byte [ebp - 0xaec]
xor ecx, 0x34
mov byte [ebp - 0xaed], cl
mov dl, byte [ebp - 0xaed]
mov byte [ebp - 0x2452], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xaf4], dl
movsx eax, byte [ebp - 0xaf4]
xor eax, 0x34
mov byte [ebp - 0xaf5], al
mov cl, byte [ebp - 0xaf5]
mov byte [ebp - 0x2451], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xafc], al
movsx ecx, byte [ebp - 0xafc]
xor ecx, 0x34
mov byte [ebp - 0xafd], cl
mov dl, byte [ebp - 0xafd]
mov byte [ebp - 0x2450], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xb04], dl
movsx eax, byte [ebp - 0xb04]
xor eax, 0x34
mov byte [ebp - 0xb05], al
mov cl, byte [ebp - 0xb05]
mov byte [ebp - 0x244f], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xb0c], cl
movsx edx, byte [ebp - 0xb0c]
xor edx, 0x34
mov byte [ebp - 0xb0d], dl
mov al, byte [ebp - 0xb0d]
mov byte [ebp - 0x244e], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xb14], al
movsx ecx, byte [ebp - 0xb14]
xor ecx, 0x34
mov byte [ebp - 0xb15], cl
mov dl, byte [ebp - 0xb15]
mov byte [ebp - 0x244d], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.rot_range_stnd]
mov byte [ebp - 0xb1c], dl
movsx eax, byte [ebp - 0xb1c]
xor eax, 0x34
mov byte [ebp - 0xb1d], al
mov cl, byte [ebp - 0xb1d]
mov byte [ebp - 0x244c], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.rot_range_stnd]
mov byte [ebp - 0xb24], cl
movsx edx, byte [ebp - 0xb24]
xor edx, 0x34
mov byte [ebp - 0xb25], dl
mov al, byte [ebp - 0xb25]
mov byte [ebp - 0x244b], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.rot_range_stnd]
mov byte [ebp - 0xb2c], al
movsx ecx, byte [ebp - 0xb2c]
xor ecx, 0x34
mov byte [ebp - 0xb2d], cl
mov dl, byte [ebp - 0xb2d]
mov byte [ebp - 0x244a], dl
lea eax, [ebp - 0x2458]
mov dword [ebp - 0x2b84], eax
mov ecx, dword [ebp - 0x2b84]
mov dword [ebp - 0x2968], ecx
mov dword [ebp - 0x211c], 0
jmp 0x10117db3
mov edx, dword [ebp - 0x211c]
add edx, 1
mov dword [ebp - 0x211c], edx
cmp dword [ebp - 0x211c], 0xf
jae 0x10117e35
mov eax, dword [ebp - 0x2968]
mov dword [ebp - 0x2b88], eax
mov ecx, dword [ebp - 0x2b88]
add ecx, dword [ebp - 0x211c]
mov dword [ebp - 0x2b8c], ecx
mov edx, dword [ebp - 0x2b8c]
mov al, byte [edx]
mov byte [ebp - 0xb34], al
movsx ecx, byte [ebp - 0xb34]
xor ecx, 0x34
mov byte [ebp - 0xb35], cl
mov dl, byte [ebp - 0xb35]
mov byte [ebp - 0xb36], dl
mov eax, dword [ebp - 0x2968]
mov dword [ebp - 0x2b90], eax
mov ecx, dword [ebp - 0x2b90]
add ecx, dword [ebp - 0x211c]
mov dword [ebp - 0x2b94], ecx
mov edx, dword [ebp - 0x2b94]
mov al, byte [ebp - 0xb36]
mov byte [edx], al
jmp 0x10117da4
mov ecx, dword [ebp - 0x2968]
mov dword [ebp - 0x2b98], ecx
mov edx, dword [ebp - 0x2b98]
mov dword [ebp - 0x2b9c], edx
mov eax, dword [ebp - 0x2b9c]
mov dword [ebp - 0x2ba0], eax
mov ecx, dword [ebp - 0x2ba0]
push ecx
lea ecx, [ebp - 0x49f0]
call fcn.1007b880
mov byte [ebp - 4], 0x20
push 0x102a0e2e
lea ecx, [ebp - 0x49d8]
call fcn.1007b880
mov byte [ebp - 4], 0x21
lea edx, [ebp - 0x49f0]
push edx
mov ecx, dword [ebp - 0x298]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x298]
mov byte [eax + 0x69], 0
mov ecx, dword [ebp - 0x298]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10117ec9
lea eax, [ebp - 0x49d8]
push eax
mov ecx, dword [ebp - 0x298]
add ecx, 0x88
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x298]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10117ee3
mov dword [ebp - 0x2acc], 0xf
jmp 0x10117eed
mov dword [ebp - 0x2acc], 0
mov eax, dword [ebp - 0x298]
mov ecx, dword [ebp - 0x2acc]
mov dword [eax + 0xb8], ecx
mov edx, dword [ebp - 0x298]
mov eax, dword [edx + 0xb8]
add eax, 8
mov ecx, dword [ebp - 0x298]
mov dword [ecx + 0x10], eax
mov edx, dword [ebp - 0x298]
mov eax, dword [ebp - 0x298]
mov ecx, dword [eax + 0x10]
mov dword [edx + 0x14], ecx
mov edx, dword [ebp - 0x298]
xorps xmm0, xmm0
movss dword [edx + 0x74], xmm0
mov eax, dword [ebp - 0x298]
movss xmm0, dword [0x102a61d8]
movss dword [eax + 0x78], xmm0
mov ecx, dword [ebp - 0x298]
movss xmm0, dword [0x102a61d8]
movss dword [ecx + 0x70], xmm0
mov edx, dword [ebp - 0x298]
mov dword [edx + 0x84], 0
mov eax, dword [ebp - 0x298]
movss xmm0, dword [0x102a60dc]
movss dword [eax + 0x7c], xmm0
lea ecx, [ebp - 0x4a08]
push ecx
mov ecx, dword [ebp - 0x298]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x20
lea ecx, [ebp - 0x49d8]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x1f
lea ecx, [ebp - 0x49f0]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4a08]
call fcn.100d2140
nop
mov edx, dword [ebp - 0x290]
add edx, 0x3dc
mov dword [ebp - 0x2ba4], edx
mov dword [ebp - 0x1cc], 0x1008a930
mov eax, dword [ebp - 0x2ba4]
add eax, 0x58
mov dword [ebp - 0x2bac], eax
lea ecx, [ebp - 0x1cc]
push ecx
mov ecx, dword [ebp - 0x2bac]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x3dc
mov dword [ebp - 0x2bb0], edx
mov dword [ebp - 0x1d0], 0x1008a9c0
mov eax, dword [ebp - 0x2bb0]
add eax, 0x58
mov dword [ebp - 0x2bb8], eax
lea ecx, [ebp - 0x1d0]
push ecx
mov ecx, dword [ebp - 0x2bb8]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x3dc
mov dword [ebp - 0xe0], edx
mov eax, dword [ebp - 0xe0]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0xe0]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0xe0]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0xe0]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0xe0]
mov eax, dword [ebp - 0x290]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x290]
add edx, 0x18
mov dword [ebp - 0x2bbc], edx
lea eax, [ebp - 0xe0]
push eax
mov ecx, dword [ebp - 0x2bbc]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x498
mov dword [ebp - 0x310], ecx
mov edx, 2
imul eax, edx, 0
mov cx, word [eax + 0x102a2a9c]
mov word [ebp - 0x265c], cx
movzx edx, word [ebp - 0x265c]
xor edx, 0x34
mov word [ebp - 0x265e], dx
mov ax, word [ebp - 0x265e]
mov word [ebp - 0x2ad0], ax
mov ecx, 2
shl ecx, 0
mov dx, word [ecx + 0x102a2a9c]
mov word [ebp - 0x2664], dx
movzx eax, word [ebp - 0x2664]
xor eax, 0x34
mov word [ebp - 0x2666], ax
mov cx, word [ebp - 0x2666]
mov word [ebp - 0x2ace], cx
lea edx, [ebp - 0x2ad0]
mov dword [ebp - 0x2bc0], edx
mov eax, dword [ebp - 0x2bc0]
mov dword [ebp - 0x296c], eax
mov dword [ebp - 0x2118], 0
jmp 0x10118170
mov ecx, dword [ebp - 0x2118]
add ecx, 1
mov dword [ebp - 0x2118], ecx
cmp dword [ebp - 0x2118], 2
jae 0x10118203
mov edx, dword [ebp - 0x296c]
mov dword [ebp - 0x2bc4], edx
mov eax, dword [ebp - 0x2118]
mov ecx, dword [ebp - 0x2bc4]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2bc8], edx
mov eax, dword [ebp - 0x2bc8]
mov cx, word [eax]
mov word [ebp - 0x266c], cx
movzx edx, word [ebp - 0x266c]
xor edx, 0x34
mov word [ebp - 0x266e], dx
mov ax, word [ebp - 0x266e]
mov word [ebp - 0x2670], ax
mov ecx, dword [ebp - 0x296c]
mov dword [ebp - 0x2bcc], ecx
mov edx, dword [ebp - 0x2118]
mov eax, dword [ebp - 0x2bcc]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2bd0], ecx
mov edx, dword [ebp - 0x2bd0]
mov ax, word [ebp - 0x2670]
mov word [edx], ax
jmp 0x10118161
mov ecx, dword [ebp - 0x296c]
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]
push ecx
lea ecx, [ebp - 0x4a50]
call fcn.101ed710
mov dword [ebp - 4], 0x22
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xb3c], cl
movsx edx, byte [ebp - 0xb3c]
xor edx, 0x34
mov byte [ebp - 0xb3d], dl
mov al, byte [ebp - 0xb3d]
mov byte [ebp - 0x24f8], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xb44], dl
movsx eax, byte [ebp - 0xb44]
xor eax, 0x34
mov byte [ebp - 0xb45], al
mov cl, byte [ebp - 0xb45]
mov byte [ebp - 0x24f7], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xb4c], al
movsx ecx, byte [ebp - 0xb4c]
xor ecx, 0x34
mov byte [ebp - 0xb4d], cl
mov dl, byte [ebp - 0xb4d]
mov byte [ebp - 0x24f6], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xb54], dl
movsx eax, byte [ebp - 0xb54]
xor eax, 0x34
mov byte [ebp - 0xb55], al
mov cl, byte [ebp - 0xb55]
mov byte [ebp - 0x24f5], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xb5c], al
movsx ecx, byte [ebp - 0xb5c]
xor ecx, 0x34
mov byte [ebp - 0xb5d], cl
mov dl, byte [ebp - 0xb5d]
mov byte [ebp - 0x24f4], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xb64], dl
movsx eax, byte [ebp - 0xb64]
xor eax, 0x34
mov byte [ebp - 0xb65], al
mov cl, byte [ebp - 0xb65]
mov byte [ebp - 0x24f3], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xb6c], cl
movsx edx, byte [ebp - 0xb6c]
xor edx, 0x34
mov byte [ebp - 0xb6d], dl
mov al, byte [ebp - 0xb6d]
mov byte [ebp - 0x24f2], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xb74], al
movsx ecx, byte [ebp - 0xb74]
xor ecx, 0x34
mov byte [ebp - 0xb75], cl
mov dl, byte [ebp - 0xb75]
mov byte [ebp - 0x24f1], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xb7c], cl
movsx edx, byte [ebp - 0xb7c]
xor edx, 0x34
mov byte [ebp - 0xb7d], dl
mov al, byte [ebp - 0xb7d]
mov byte [ebp - 0x24f0], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xb84], al
movsx ecx, byte [ebp - 0xb84]
xor ecx, 0x34
mov byte [ebp - 0xb85], cl
mov dl, byte [ebp - 0xb85]
mov byte [ebp - 0x24ef], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xb8c], dl
movsx eax, byte [ebp - 0xb8c]
xor eax, 0x34
mov byte [ebp - 0xb8d], al
mov cl, byte [ebp - 0xb8d]
mov byte [ebp - 0x24ee], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xb94], cl
movsx edx, byte [ebp - 0xb94]
xor edx, 0x34
mov byte [ebp - 0xb95], dl
mov al, byte [ebp - 0xb95]
mov byte [ebp - 0x24ed], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xb9c], al
movsx ecx, byte [ebp - 0xb9c]
xor ecx, 0x34
mov byte [ebp - 0xb9d], cl
mov dl, byte [ebp - 0xb9d]
mov byte [ebp - 0x24ec], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xba4], dl
movsx eax, byte [ebp - 0xba4]
xor eax, 0x34
mov byte [ebp - 0xba5], al
mov cl, byte [ebp - 0xba5]
mov byte [ebp - 0x24eb], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xbac], cl
movsx edx, byte [ebp - 0xbac]
xor edx, 0x34
mov byte [ebp - 0xbad], dl
mov al, byte [ebp - 0xbad]
mov byte [ebp - 0x24ea], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xbb4], al
movsx ecx, byte [ebp - 0xbb4]
xor ecx, 0x34
mov byte [ebp - 0xbb5], cl
mov dl, byte [ebp - 0xbb5]
mov byte [ebp - 0x24e9], dl
mov eax, 1
shl eax, 4
mov cl, byte [eax + str.sixway_range_stand]
mov byte [ebp - 0xbbc], cl
movsx edx, byte [ebp - 0xbbc]
xor edx, 0x34
mov byte [ebp - 0xbbd], dl
mov al, byte [ebp - 0xbbd]
mov byte [ebp - 0x24e8], al
mov ecx, 1
imul edx, ecx, 0x11
mov al, byte [edx + str.sixway_range_stand]
mov byte [ebp - 0xbc4], al
movsx ecx, byte [ebp - 0xbc4]
xor ecx, 0x34
mov byte [ebp - 0xbc5], cl
mov dl, byte [ebp - 0xbc5]
mov byte [ebp - 0x24e7], dl
mov eax, 1
imul ecx, eax, 0x12
mov dl, byte [ecx + str.sixway_range_stand]
mov byte [ebp - 0xbcc], dl
movsx eax, byte [ebp - 0xbcc]
xor eax, 0x34
mov byte [ebp - 0xbcd], al
mov cl, byte [ebp - 0xbcd]
mov byte [ebp - 0x24e6], cl
lea edx, [ebp - 0x24f8]
mov dword [ebp - 0x2be0], edx
mov eax, dword [ebp - 0x2be0]
mov dword [ebp - 0x2970], eax
mov dword [ebp - 0x2114], 0
jmp 0x10118602
mov ecx, dword [ebp - 0x2114]
add ecx, 1
mov dword [ebp - 0x2114], ecx
cmp dword [ebp - 0x2114], 0x13
jae 0x10118684
mov edx, dword [ebp - 0x2970]
mov dword [ebp - 0x2be4], edx
mov eax, dword [ebp - 0x2be4]
add eax, dword [ebp - 0x2114]
mov dword [ebp - 0x2be8], eax
mov ecx, dword [ebp - 0x2be8]
mov dl, byte [ecx]
mov byte [ebp - 0xbd4], dl
movsx eax, byte [ebp - 0xbd4]
xor eax, 0x34
mov byte [ebp - 0xbd5], al
mov cl, byte [ebp - 0xbd5]
mov byte [ebp - 0xbd6], cl
mov edx, dword [ebp - 0x2970]
mov dword [ebp - 0x2bec], edx
mov eax, dword [ebp - 0x2bec]
add eax, dword [ebp - 0x2114]
mov dword [ebp - 0x2bf0], eax
mov ecx, dword [ebp - 0x2bf0]
mov dl, byte [ebp - 0xbd6]
mov byte [ecx], dl
jmp 0x101185f3
mov eax, dword [ebp - 0x2970]
mov dword [ebp - 0x2bf4], eax
mov ecx, dword [ebp - 0x2bf4]
mov dword [ebp - 0x2bf8], ecx
mov edx, dword [ebp - 0x2bf8]
mov dword [ebp - 0x2bfc], edx
mov eax, dword [ebp - 0x2bfc]
push eax
lea ecx, [ebp - 0x4a38]
call fcn.1007b880
mov byte [ebp - 4], 0x23
push 0x102a0e2e
lea ecx, [ebp - 0x4a20]
call fcn.1007b880
mov byte [ebp - 4], 0x24
lea ecx, [ebp - 0x4a38]
push ecx
mov ecx, dword [ebp - 0x310]
add ecx, 0x38
call fcn.1008d0b0
mov edx, dword [ebp - 0x310]
mov byte [edx + 0x69], 0
mov eax, dword [ebp - 0x310]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10118718
lea edx, [ebp - 0x4a20]
push edx
mov ecx, dword [ebp - 0x310]
add ecx, 0x88
call fcn.1008d0b0
nop
mov eax, dword [ebp - 0x310]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x10118732
mov dword [ebp - 0x2ad4], 0xf
jmp 0x1011873c
mov dword [ebp - 0x2ad4], 0
mov edx, dword [ebp - 0x310]
mov eax, dword [ebp - 0x2ad4]
mov dword [edx + 0xb8], eax
mov ecx, dword [ebp - 0x310]
mov edx, dword [ecx + 0xb8]
add edx, 8
mov eax, dword [ebp - 0x310]
mov dword [eax + 0x10], edx
mov ecx, dword [ebp - 0x310]
mov edx, dword [ebp - 0x310]
mov eax, dword [edx + 0x10]
mov dword [ecx + 0x14], eax
mov ecx, dword [ebp - 0x310]
movss xmm0, dword [0x102a6038]
movss dword [ecx + 0x74], xmm0
mov edx, dword [ebp - 0x310]
movss xmm0, dword [0x102a61a8]
movss dword [edx + 0x78], xmm0
mov eax, dword [ebp - 0x310]
movss xmm0, dword [0x102a612c]
movss dword [eax + 0x70], xmm0
mov ecx, dword [ebp - 0x310]
mov dword [ecx + 0x84], 0
mov edx, dword [ebp - 0x310]
movss xmm0, dword [0x102a60dc]
movss dword [edx + 0x7c], xmm0
lea eax, [ebp - 0x4a50]
push eax
mov ecx, dword [ebp - 0x310]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x23
lea ecx, [ebp - 0x4a20]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x22
lea ecx, [ebp - 0x4a38]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4a50]
call fcn.100d2140
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x498
mov dword [ebp - 0x2c00], ecx
mov dword [ebp - 0x1d4], 0x1008a930
mov edx, dword [ebp - 0x2c00]
add edx, 0x58
mov dword [ebp - 0x2c08], edx
lea eax, [ebp - 0x1d4]
push eax
mov ecx, dword [ebp - 0x2c08]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x498
mov dword [ebp - 0x2c0c], ecx
mov dword [ebp - 0x1d8], 0x1008aa20
mov edx, dword [ebp - 0x2c0c]
add edx, 0x58
mov dword [ebp - 0x2c14], edx
lea eax, [ebp - 0x1d8]
push eax
mov ecx, dword [ebp - 0x2c14]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x498
mov dword [ebp - 0x104], ecx
mov edx, dword [ebp - 0x104]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x104]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x104]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x104]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x104]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x2c18], ecx
lea edx, [ebp - 0x104]
push edx
mov ecx, dword [ebp - 0x2c18]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x554
mov dword [ebp - 0x30c], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x102a2790]
mov word [ebp - 0x2674], ax
movzx ecx, word [ebp - 0x2674]
xor ecx, 0x34
mov word [ebp - 0x2676], cx
mov dx, word [ebp - 0x2676]
mov word [ebp - 0x2ad8], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x102a2790]
mov word [ebp - 0x267c], cx
movzx edx, word [ebp - 0x267c]
xor edx, 0x34
mov word [ebp - 0x267e], dx
mov ax, word [ebp - 0x267e]
mov word [ebp - 0x2ad6], ax
lea ecx, [ebp - 0x2ad8]
mov dword [ebp - 0x2c1c], ecx
mov edx, dword [ebp - 0x2c1c]
mov dword [ebp - 0x2988], edx
mov dword [ebp - 0x2110], 0
jmp 0x101189c3
mov eax, dword [ebp - 0x2110]
add eax, 1
mov dword [ebp - 0x2110], eax
cmp dword [ebp - 0x2110], 2
jae 0x10118a56
mov ecx, dword [ebp - 0x2988]
mov dword [ebp - 0x2c20], ecx
mov edx, dword [ebp - 0x2110]
mov eax, dword [ebp - 0x2c20]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2c24], ecx
mov edx, dword [ebp - 0x2c24]
mov ax, word [edx]
mov word [ebp - 0x2684], ax
movzx ecx, word [ebp - 0x2684]
xor ecx, 0x34
mov word [ebp - 0x2686], cx
mov dx, word [ebp - 0x2686]
mov word [ebp - 0x2688], dx
mov eax, dword [ebp - 0x2988]
mov dword [ebp - 0x2c28], eax
mov ecx, dword [ebp - 0x2110]
mov edx, dword [ebp - 0x2c28]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x2c2c], eax
mov ecx, dword [ebp - 0x2c2c]
mov dx, word [ebp - 0x2688]
mov word [ecx], dx
jmp 0x101189b4
mov eax, dword [ebp - 0x2988]
mov dword [ebp - 0x2c30], eax
mov ecx, dword [ebp - 0x2c30]
mov dword [ebp - 0x2c34], ecx
mov edx, dword [ebp - 0x2c34]
mov dword [ebp - 0x2c38], edx
mov eax, dword [ebp - 0x2c38]
push eax
lea ecx, [ebp - 0x4a98]
call fcn.101ed710
mov dword [ebp - 4], 0x25
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.rot_speed_stnd]
mov byte [ebp - 0xbdc], al
movsx ecx, byte [ebp - 0xbdc]
xor ecx, 0x34
mov byte [ebp - 0xbdd], cl
mov dl, byte [ebp - 0xbdd]
mov byte [ebp - 0x2468], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.rot_speed_stnd]
mov byte [ebp - 0xbe4], cl
movsx edx, byte [ebp - 0xbe4]
xor edx, 0x34
mov byte [ebp - 0xbe5], dl
mov al, byte [ebp - 0xbe5]
mov byte [ebp - 0x2467], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.rot_speed_stnd]
mov byte [ebp - 0xbec], dl
movsx eax, byte [ebp - 0xbec]
xor eax, 0x34
mov byte [ebp - 0xbed], al
mov cl, byte [ebp - 0xbed]
mov byte [ebp - 0x2466], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.rot_speed_stnd]
mov byte [ebp - 0xbf4], cl
movsx edx, byte [ebp - 0xbf4]
xor edx, 0x34
mov byte [ebp - 0xbf5], dl
mov al, byte [ebp - 0xbf5]
mov byte [ebp - 0x2465], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.rot_speed_stnd]
mov byte [ebp - 0xbfc], dl
movsx eax, byte [ebp - 0xbfc]
xor eax, 0x34
mov byte [ebp - 0xbfd], al
mov cl, byte [ebp - 0xbfd]
mov byte [ebp - 0x2464], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.rot_speed_stnd]
mov byte [ebp - 0xc04], cl
movsx edx, byte [ebp - 0xc04]
xor edx, 0x34
mov byte [ebp - 0xc05], dl
mov al, byte [ebp - 0xc05]
mov byte [ebp - 0x2463], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.rot_speed_stnd]
mov byte [ebp - 0xc0c], al
movsx ecx, byte [ebp - 0xc0c]
xor ecx, 0x34
mov byte [ebp - 0xc0d], cl
mov dl, byte [ebp - 0xc0d]
mov byte [ebp - 0x2462], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.rot_speed_stnd]
mov byte [ebp - 0xc14], dl
movsx eax, byte [ebp - 0xc14]
xor eax, 0x34
mov byte [ebp - 0xc15], al
mov cl, byte [ebp - 0xc15]
mov byte [ebp - 0x2461], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.rot_speed_stnd]
mov byte [ebp - 0xc1c], al
movsx ecx, byte [ebp - 0xc1c]
xor ecx, 0x34
mov byte [ebp - 0xc1d], cl
mov dl, byte [ebp - 0xc1d]
mov byte [ebp - 0x2460], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.rot_speed_stnd]
mov byte [ebp - 0xc24], dl
movsx eax, byte [ebp - 0xc24]
xor eax, 0x34
mov byte [ebp - 0xc25], al
mov cl, byte [ebp - 0xc25]
mov byte [ebp - 0x245f], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.rot_speed_stnd]
mov byte [ebp - 0xc2c], cl
movsx edx, byte [ebp - 0xc2c]
xor edx, 0x34
mov byte [ebp - 0xc2d], dl
mov al, byte [ebp - 0xc2d]
mov byte [ebp - 0x245e], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.rot_speed_stnd]
mov byte [ebp - 0xc34], al
movsx ecx, byte [ebp - 0xc34]
xor ecx, 0x34
mov byte [ebp - 0xc35], cl
mov dl, byte [ebp - 0xc35]
mov byte [ebp - 0x245d], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.rot_speed_stnd]
mov byte [ebp - 0xc3c], dl
movsx eax, byte [ebp - 0xc3c]
xor eax, 0x34
mov byte [ebp - 0xc3d], al
mov cl, byte [ebp - 0xc3d]
mov byte [ebp - 0x245c], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.rot_speed_stnd]
mov byte [ebp - 0xc44], cl
movsx edx, byte [ebp - 0xc44]
xor edx, 0x34
mov byte [ebp - 0xc45], dl
mov al, byte [ebp - 0xc45]
mov byte [ebp - 0x245b], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.rot_speed_stnd]
mov byte [ebp - 0xc4c], al
movsx ecx, byte [ebp - 0xc4c]
xor ecx, 0x34
mov byte [ebp - 0xc4d], cl
mov dl, byte [ebp - 0xc4d]
mov byte [ebp - 0x245a], dl
lea eax, [ebp - 0x2468]
mov dword [ebp - 0x2c3c], eax
mov ecx, dword [ebp - 0x2c3c]
mov dword [ebp - 0x299c], ecx
mov dword [ebp - 0x210c], 0
jmp 0x10118d95
mov edx, dword [ebp - 0x210c]
add edx, 1
mov dword [ebp - 0x210c], edx
cmp dword [ebp - 0x210c], 0xf
jae 0x10118e17
mov eax, dword [ebp - 0x299c]
mov dword [ebp - 0x2c40], eax
mov ecx, dword [ebp - 0x2c40]
add ecx, dword [ebp - 0x210c]
mov dword [ebp - 0x2c44], ecx
mov edx, dword [ebp - 0x2c44]
mov al, byte [edx]
mov byte [ebp - 0xc54], al
movsx ecx, byte [ebp - 0xc54]
xor ecx, 0x34
mov byte [ebp - 0xc55], cl
mov dl, byte [ebp - 0xc55]
mov byte [ebp - 0xc56], dl
mov eax, dword [ebp - 0x299c]
mov dword [ebp - 0x2c48], eax
mov ecx, dword [ebp - 0x2c48]
add ecx, dword [ebp - 0x210c]
mov dword [ebp - 0x2c4c], ecx
mov edx, dword [ebp - 0x2c4c]
mov al, byte [ebp - 0xc56]
mov byte [edx], al
jmp 0x10118d86
mov ecx, dword [ebp - 0x299c]
mov dword [ebp - 0x2c50], ecx
mov edx, dword [ebp - 0x2c50]
mov dword [ebp - 0x2c54], edx
mov eax, dword [ebp - 0x2c54]
mov dword [ebp - 0x2c58], eax
mov ecx, dword [ebp - 0x2c58]
push ecx
lea ecx, [ebp - 0x4a80]
call fcn.1007b880
mov byte [ebp - 4], 0x26
push 0x102a0e2e
lea ecx, [ebp - 0x4a68]
call fcn.1007b880
mov byte [ebp - 4], 0x27
lea edx, [ebp - 0x4a80]
push edx
mov ecx, dword [ebp - 0x30c]
add ecx, 0x38
call fcn.1008d0b0
mov eax, dword [ebp - 0x30c]
mov byte [eax + 0x69], 0
mov ecx, dword [ebp - 0x30c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10118eab
lea eax, [ebp - 0x4a68]
push eax
mov ecx, dword [ebp - 0x30c]
add ecx, 0x88
call fcn.1008d0b0
nop
mov ecx, dword [ebp - 0x30c]
movzx edx, byte [ecx + 0x69]
test edx, edx
je 0x10118ec5
mov dword [ebp - 0x2adc], 0xf
jmp 0x10118ecf
mov dword [ebp - 0x2adc], 0
mov eax, dword [ebp - 0x30c]
mov ecx, dword [ebp - 0x2adc]
mov dword [eax + 0xb8], ecx
mov edx, dword [ebp - 0x30c]
mov eax, dword [edx + 0xb8]
add eax, 8
mov ecx, dword [ebp - 0x30c]
mov dword [ecx + 0x10], eax
mov edx, dword [ebp - 0x30c]
mov eax, dword [ebp - 0x30c]
mov ecx, dword [eax + 0x10]
mov dword [edx + 0x14], ecx
mov edx, dword [ebp - 0x30c]
movss xmm0, dword [0x102a6038]
movss dword [edx + 0x74], xmm0
mov eax, dword [ebp - 0x30c]
movss xmm0, dword [0x102a6174]
movss dword [eax + 0x78], xmm0
mov ecx, dword [ebp - 0x30c]
movss xmm0, dword [0x102a60f0]
movss dword [ecx + 0x70], xmm0
mov edx, dword [ebp - 0x30c]
mov dword [edx + 0x84], 0
mov eax, dword [ebp - 0x30c]
movss xmm0, dword [0x102a6038]
movss dword [eax + 0x7c], xmm0
lea ecx, [ebp - 0x4a98]
push ecx
mov ecx, dword [ebp - 0x30c]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x26
lea ecx, [ebp - 0x4a68]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x25
lea ecx, [ebp - 0x4a80]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4a98]
call fcn.100d2140
nop
mov edx, dword [ebp - 0x290]
add edx, 0x554
mov dword [ebp - 0x2c5c], edx
mov dword [ebp - 0x1dc], 0x1008a930
mov eax, dword [ebp - 0x2c5c]
add eax, 0x58
mov dword [ebp - 0x2c64], eax
lea ecx, [ebp - 0x1dc]
push ecx
mov ecx, dword [ebp - 0x2c64]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x554
mov dword [ebp - 0x2c68], edx
mov dword [ebp - 0x1e0], 0x1008a9c0
mov eax, dword [ebp - 0x2c68]
add eax, 0x58
mov dword [ebp - 0x2c70], eax
lea ecx, [ebp - 0x1e0]
push ecx
mov ecx, dword [ebp - 0x2c70]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x554
mov dword [ebp - 0xe8], edx
mov eax, dword [ebp - 0xe8]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0xe8]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0xe8]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0xe8]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0xe8]
mov eax, dword [ebp - 0x290]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x290]
add edx, 0x18
mov dword [ebp - 0x2c74], edx
lea eax, [ebp - 0xe8]
push eax
mov ecx, dword [ebp - 0x2c74]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x610
mov dword [ebp - 0x308], ecx
push 0x102a27cc
lea ecx, [ebp - 0x4ae0]
call fcn.101ed710
mov dword [ebp - 4], 0x28
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xc5c], cl
movsx edx, byte [ebp - 0xc5c]
xor edx, 0x34
mov byte [ebp - 0xc5d], dl
mov al, byte [ebp - 0xc5d]
mov byte [ebp - 0x24bc], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.rand_update_stnd]
mov byte [ebp - 0xc64], dl
movsx eax, byte [ebp - 0xc64]
xor eax, 0x34
mov byte [ebp - 0xc65], al
mov cl, byte [ebp - 0xc65]
mov byte [ebp - 0x24bb], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xc6c], al
movsx ecx, byte [ebp - 0xc6c]
xor ecx, 0x34
mov byte [ebp - 0xc6d], cl
mov dl, byte [ebp - 0xc6d]
mov byte [ebp - 0x24ba], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.rand_update_stnd]
mov byte [ebp - 0xc74], dl
movsx eax, byte [ebp - 0xc74]
xor eax, 0x34
mov byte [ebp - 0xc75], al
mov cl, byte [ebp - 0xc75]
mov byte [ebp - 0x24b9], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xc7c], al
movsx ecx, byte [ebp - 0xc7c]
xor ecx, 0x34
mov byte [ebp - 0xc7d], cl
mov dl, byte [ebp - 0xc7d]
mov byte [ebp - 0x24b8], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.rand_update_stnd]
mov byte [ebp - 0xc84], dl
movsx eax, byte [ebp - 0xc84]
xor eax, 0x34
mov byte [ebp - 0xc85], al
mov cl, byte [ebp - 0xc85]
mov byte [ebp - 0x24b7], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xc8c], cl
movsx edx, byte [ebp - 0xc8c]
xor edx, 0x34
mov byte [ebp - 0xc8d], dl
mov al, byte [ebp - 0xc8d]
mov byte [ebp - 0x24b6], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xc94], al
movsx ecx, byte [ebp - 0xc94]
xor ecx, 0x34
mov byte [ebp - 0xc95], cl
mov dl, byte [ebp - 0xc95]
mov byte [ebp - 0x24b5], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xc9c], cl
movsx edx, byte [ebp - 0xc9c]
xor edx, 0x34
mov byte [ebp - 0xc9d], dl
mov al, byte [ebp - 0xc9d]
mov byte [ebp - 0x24b4], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xca4], al
movsx ecx, byte [ebp - 0xca4]
xor ecx, 0x34
mov byte [ebp - 0xca5], cl
mov dl, byte [ebp - 0xca5]
mov byte [ebp - 0x24b3], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.rand_update_stnd]
mov byte [ebp - 0xcac], dl
movsx eax, byte [ebp - 0xcac]
xor eax, 0x34
mov byte [ebp - 0xcad], al
mov cl, byte [ebp - 0xcad]
mov byte [ebp - 0x24b2], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xcb4], cl
movsx edx, byte [ebp - 0xcb4]
xor edx, 0x34
mov byte [ebp - 0xcb5], dl
mov al, byte [ebp - 0xcb5]
mov byte [ebp - 0x24b1], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xcbc], al
movsx ecx, byte [ebp - 0xcbc]
xor ecx, 0x34
mov byte [ebp - 0xcbd], cl
mov dl, byte [ebp - 0xcbd]
mov byte [ebp - 0x24b0], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.rand_update_stnd]
mov byte [ebp - 0xcc4], dl
movsx eax, byte [ebp - 0xcc4]
xor eax, 0x34
mov byte [ebp - 0xcc5], al
mov cl, byte [ebp - 0xcc5]
mov byte [ebp - 0x24af], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xccc], cl
movsx edx, byte [ebp - 0xccc]
xor edx, 0x34
mov byte [ebp - 0xccd], dl
mov al, byte [ebp - 0xccd]
mov byte [ebp - 0x24ae], al
mov ecx, 1
imul edx, ecx, 0xf
mov al, byte [edx + str.rand_update_stnd]
mov byte [ebp - 0xcd4], al
movsx ecx, byte [ebp - 0xcd4]
xor ecx, 0x34
mov byte [ebp - 0xcd5], cl
mov dl, byte [ebp - 0xcd5]
mov byte [ebp - 0x24ad], dl
mov eax, 1
shl eax, 4
mov cl, byte [eax + str.rand_update_stnd]
mov byte [ebp - 0xcdc], cl
movsx edx, byte [ebp - 0xcdc]
xor edx, 0x34
mov byte [ebp - 0xcdd], dl
mov al, byte [ebp - 0xcdd]
mov byte [ebp - 0x24ac], al
lea ecx, [ebp - 0x24bc]
mov dword [ebp - 0x2c78], ecx
mov edx, dword [ebp - 0x2c78]
mov dword [ebp - 0x29a0], edx
mov dword [ebp - 0x2108], 0
jmp 0x10119433
mov eax, dword [ebp - 0x2108]
add eax, 1
mov dword [ebp - 0x2108], eax
cmp dword [ebp - 0x2108], 0x11
jae 0x101194b5
mov ecx, dword [ebp - 0x29a0]
mov dword [ebp - 0x2c7c], ecx
mov edx, dword [ebp - 0x2c7c]
add edx, dword [ebp - 0x2108]
mov dword [ebp - 0x2c80], edx
mov eax, dword [ebp - 0x2c80]
mov cl, byte [eax]
mov byte [ebp - 0xce4], cl
movsx edx, byte [ebp - 0xce4]
xor edx, 0x34
mov byte [ebp - 0xce5], dl
mov al, byte [ebp - 0xce5]
mov byte [ebp - 0xce6], al
mov ecx, dword [ebp - 0x29a0]
mov dword [ebp - 0x2c84], ecx
mov edx, dword [ebp - 0x2c84]
add edx, dword [ebp - 0x2108]
mov dword [ebp - 0x2c88], edx
mov eax, dword [ebp - 0x2c88]
mov cl, byte [ebp - 0xce6]
mov byte [eax], cl
jmp 0x10119424
mov edx, dword [ebp - 0x29a0]
mov dword [ebp - 0x2c8c], edx
mov eax, dword [ebp - 0x2c8c]
mov dword [ebp - 0x2c90], eax
mov ecx, dword [ebp - 0x2c90]
mov dword [ebp - 0x2c94], ecx
mov edx, dword [ebp - 0x2c94]
push edx
lea ecx, [ebp - 0x4ac8]
call fcn.1007b880
mov byte [ebp - 4], 0x29
push 0x102a0e2e
lea ecx, [ebp - 0x4ab0]
call fcn.1007b880
mov byte [ebp - 4], 0x2a
lea eax, [ebp - 0x4ac8]
push eax
mov ecx, dword [ebp - 0x308]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x308]
mov byte [ecx + 0x69], 0
mov edx, dword [ebp - 0x308]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10119549
lea ecx, [ebp - 0x4ab0]
push ecx
mov ecx, dword [ebp - 0x308]
add ecx, 0x88
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x308]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x10119563
mov dword [ebp - 0x2ae0], 0xf
jmp 0x1011956d
mov dword [ebp - 0x2ae0], 0
mov ecx, dword [ebp - 0x308]
mov edx, dword [ebp - 0x2ae0]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x308]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x308]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x308]
mov ecx, dword [ebp - 0x308]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x308]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x308]
movss xmm0, dword [0x102a6038]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x308]
xorps xmm0, xmm0
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x308]
mov dword [eax + 0x84], 1
mov ecx, dword [ebp - 0x308]
movss xmm0, dword [0x102a5fa8]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x4ae0]
push edx
mov ecx, dword [ebp - 0x308]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x29
lea ecx, [ebp - 0x4ab0]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x28
lea ecx, [ebp - 0x4ac8]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4ae0]
call fcn.100d2140
nop
mov eax, dword [ebp - 0x290]
add eax, 0x610
mov dword [ebp - 0x2c98], eax
mov dword [ebp - 0x1e4], 0x1008a930
mov ecx, dword [ebp - 0x2c98]
add ecx, 0x58
mov dword [ebp - 0x2ca0], ecx
lea edx, [ebp - 0x1e4]
push edx
mov ecx, dword [ebp - 0x2ca0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x610
mov dword [ebp - 0x2ca4], eax
mov dword [ebp - 0x1e8], 0x1008a9f0
mov ecx, dword [ebp - 0x2ca4]
add ecx, 0x58
mov dword [ebp - 0x2cac], ecx
lea edx, [ebp - 0x1e8]
push edx
mov ecx, dword [ebp - 0x2cac]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x610
mov dword [ebp - 0xec], eax
mov ecx, dword [ebp - 0xec]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0xec]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0xec]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0xec]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0xec]
mov ecx, dword [ebp - 0x290]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x290]
add eax, 0x18
mov dword [ebp - 0x2cb0], eax
lea ecx, [ebp - 0xec]
push ecx
mov ecx, dword [ebp - 0x2cb0]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x6cc
mov dword [ebp - 0x348], edx
lea eax, [ebp - 0x274a]
mov dword [ebp - 0x2cb4], eax
mov ecx, dword [ebp - 0x2cb4]
mov dword [ebp - 0x2d5c], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.auto]
mov byte [ebp - 0xcec], cl
movsx edx, byte [ebp - 0xcec]
xor edx, 0x34
mov byte [ebp - 0xced], dl
mov al, byte [ebp - 0xced]
mov byte [ebp - 0x2318], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.auto]
mov byte [ebp - 0xcf4], dl
movsx eax, byte [ebp - 0xcf4]
xor eax, 0x34
mov byte [ebp - 0xcf5], al
mov cl, byte [ebp - 0xcf5]
mov byte [ebp - 0x2317], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.auto]
mov byte [ebp - 0xcfc], al
movsx ecx, byte [ebp - 0xcfc]
xor ecx, 0x34
mov byte [ebp - 0xcfd], cl
mov dl, byte [ebp - 0xcfd]
mov byte [ebp - 0x2316], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.auto]
mov byte [ebp - 0xd04], dl
movsx eax, byte [ebp - 0xd04]
xor eax, 0x34
mov byte [ebp - 0xd05], al
mov cl, byte [ebp - 0xd05]
mov byte [ebp - 0x2315], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.auto]
mov byte [ebp - 0xd0c], al
movsx ecx, byte [ebp - 0xd0c]
xor ecx, 0x34
mov byte [ebp - 0xd0d], cl
mov dl, byte [ebp - 0xd0d]
mov byte [ebp - 0x2314], dl
lea eax, [ebp - 0x2318]
mov dword [ebp - 0x2cb8], eax
mov ecx, dword [ebp - 0x2cb8]
mov dword [ebp - 0x29c0], ecx
mov dword [ebp - 0x2104], 0
jmp 0x10119885
mov edx, dword [ebp - 0x2104]
add edx, 1
mov dword [ebp - 0x2104], edx
cmp dword [ebp - 0x2104], 5
jae 0x10119907
mov eax, dword [ebp - 0x29c0]
mov dword [ebp - 0x2cbc], eax
mov ecx, dword [ebp - 0x2cbc]
add ecx, dword [ebp - 0x2104]
mov dword [ebp - 0x2cc0], ecx
mov edx, dword [ebp - 0x2cc0]
mov al, byte [edx]
mov byte [ebp - 0xd14], al
movsx ecx, byte [ebp - 0xd14]
xor ecx, 0x34
mov byte [ebp - 0xd15], cl
mov dl, byte [ebp - 0xd15]
mov byte [ebp - 0xd16], dl
mov eax, dword [ebp - 0x29c0]
mov dword [ebp - 0x2cc4], eax
mov ecx, dword [ebp - 0x2cc4]
add ecx, dword [ebp - 0x2104]
mov dword [ebp - 0x2cc8], ecx
mov edx, dword [ebp - 0x2cc8]
mov al, byte [ebp - 0xd16]
mov byte [edx], al
jmp 0x10119876
mov ecx, dword [ebp - 0x29c0]
mov dword [ebp - 0x2ccc], ecx
mov edx, dword [ebp - 0x2ccc]
mov dword [ebp - 0x2cd0], edx
mov eax, dword [ebp - 0x2cd0]
mov dword [ebp - 0x2cd4], eax
mov ecx, dword [ebp - 0x2cd4]
push ecx
lea ecx, [ebp - 0x5c10]
call fcn.1007b880
mov dword [ebp - 4], 0x2b
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.backwards]
mov byte [ebp - 0xd1c], cl
movsx edx, byte [ebp - 0xd1c]
xor edx, 0x34
mov byte [ebp - 0xd1d], dl
mov al, byte [ebp - 0xd1d]
mov byte [ebp - 0x2404], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.backwards]
mov byte [ebp - 0xd24], dl
movsx eax, byte [ebp - 0xd24]
xor eax, 0x34
mov byte [ebp - 0xd25], al
mov cl, byte [ebp - 0xd25]
mov byte [ebp - 0x2403], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.backwards]
mov byte [ebp - 0xd2c], al
movsx ecx, byte [ebp - 0xd2c]
xor ecx, 0x34
mov byte [ebp - 0xd2d], cl
mov dl, byte [ebp - 0xd2d]
mov byte [ebp - 0x2402], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.backwards]
mov byte [ebp - 0xd34], dl
movsx eax, byte [ebp - 0xd34]
xor eax, 0x34
mov byte [ebp - 0xd35], al
mov cl, byte [ebp - 0xd35]
mov byte [ebp - 0x2401], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.backwards]
mov byte [ebp - 0xd3c], al
movsx ecx, byte [ebp - 0xd3c]
xor ecx, 0x34
mov byte [ebp - 0xd3d], cl
mov dl, byte [ebp - 0xd3d]
mov byte [ebp - 0x2400], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.backwards]
mov byte [ebp - 0xd44], dl
movsx eax, byte [ebp - 0xd44]
xor eax, 0x34
mov byte [ebp - 0xd45], al
mov cl, byte [ebp - 0xd45]
mov byte [ebp - 0x23ff], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.backwards]
mov byte [ebp - 0xd4c], cl
movsx edx, byte [ebp - 0xd4c]
xor edx, 0x34
mov byte [ebp - 0xd4d], dl
mov al, byte [ebp - 0xd4d]
mov byte [ebp - 0x23fe], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.backwards]
mov byte [ebp - 0xd54], al
movsx ecx, byte [ebp - 0xd54]
xor ecx, 0x34
mov byte [ebp - 0xd55], cl
mov dl, byte [ebp - 0xd55]
mov byte [ebp - 0x23fd], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.backwards]
mov byte [ebp - 0xd5c], cl
movsx edx, byte [ebp - 0xd5c]
xor edx, 0x34
mov byte [ebp - 0xd5d], dl
mov al, byte [ebp - 0xd5d]
mov byte [ebp - 0x23fc], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.backwards]
mov byte [ebp - 0xd64], al
movsx ecx, byte [ebp - 0xd64]
xor ecx, 0x34
mov byte [ebp - 0xd65], cl
mov dl, byte [ebp - 0xd65]
mov byte [ebp - 0x23fb], dl
lea eax, [ebp - 0x2404]
mov dword [ebp - 0x2cd8], eax
mov ecx, dword [ebp - 0x2cd8]
mov dword [ebp - 0x29c4], ecx
mov dword [ebp - 0x2100], 0
jmp 0x10119b56
mov edx, dword [ebp - 0x2100]
add edx, 1
mov dword [ebp - 0x2100], edx
cmp dword [ebp - 0x2100], 0xa
jae 0x10119bd8
mov eax, dword [ebp - 0x29c4]
mov dword [ebp - 0x2cdc], eax
mov ecx, dword [ebp - 0x2cdc]
add ecx, dword [ebp - 0x2100]
mov dword [ebp - 0x2ce0], ecx
mov edx, dword [ebp - 0x2ce0]
mov al, byte [edx]
mov byte [ebp - 0xd6c], al
movsx ecx, byte [ebp - 0xd6c]
xor ecx, 0x34
mov byte [ebp - 0xd6d], cl
mov dl, byte [ebp - 0xd6d]
mov byte [ebp - 0xd6e], dl
mov eax, dword [ebp - 0x29c4]
mov dword [ebp - 0x2ce4], eax
mov ecx, dword [ebp - 0x2ce4]
add ecx, dword [ebp - 0x2100]
mov dword [ebp - 0x2ce8], ecx
mov edx, dword [ebp - 0x2ce8]
mov al, byte [ebp - 0xd6e]
mov byte [edx], al
jmp 0x10119b47
mov ecx, dword [ebp - 0x29c4]
mov dword [ebp - 0x2cec], ecx
mov edx, dword [ebp - 0x2cec]
mov dword [ebp - 0x2cf0], edx
mov eax, dword [ebp - 0x2cf0]
mov dword [ebp - 0x2cf4], eax
mov ecx, dword [ebp - 0x2cf4]
push ecx
lea ecx, [ebp - 0x5bf8]
call fcn.1007b880
mov byte [ebp - 4], 0x2c
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.left]
mov byte [ebp - 0xd74], cl
movsx edx, byte [ebp - 0xd74]
xor edx, 0x34
mov byte [ebp - 0xd75], dl
mov al, byte [ebp - 0xd75]
mov byte [ebp - 0x2320], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.left]
mov byte [ebp - 0xd7c], dl
movsx eax, byte [ebp - 0xd7c]
xor eax, 0x34
mov byte [ebp - 0xd7d], al
mov cl, byte [ebp - 0xd7d]
mov byte [ebp - 0x231f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.left]
mov byte [ebp - 0xd84], al
movsx ecx, byte [ebp - 0xd84]
xor ecx, 0x34
mov byte [ebp - 0xd85], cl
mov dl, byte [ebp - 0xd85]
mov byte [ebp - 0x231e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.left]
mov byte [ebp - 0xd8c], dl
movsx eax, byte [ebp - 0xd8c]
xor eax, 0x34
mov byte [ebp - 0xd8d], al
mov cl, byte [ebp - 0xd8d]
mov byte [ebp - 0x231d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.left]
mov byte [ebp - 0xd94], al
movsx ecx, byte [ebp - 0xd94]
xor ecx, 0x34
mov byte [ebp - 0xd95], cl
mov dl, byte [ebp - 0xd95]
mov byte [ebp - 0x231c], dl
lea eax, [ebp - 0x2320]
mov dword [ebp - 0x2cf8], eax
mov ecx, dword [ebp - 0x2cf8]
mov dword [ebp - 0x24fc], ecx
mov dword [ebp - 0x20fc], 0
jmp 0x10119d34
mov edx, dword [ebp - 0x20fc]
add edx, 1
mov dword [ebp - 0x20fc], edx
cmp dword [ebp - 0x20fc], 5
jae 0x10119db6
mov eax, dword [ebp - 0x24fc]
mov dword [ebp - 0x2cfc], eax
mov ecx, dword [ebp - 0x2cfc]
add ecx, dword [ebp - 0x20fc]
mov dword [ebp - 0x2d00], ecx
mov edx, dword [ebp - 0x2d00]
mov al, byte [edx]
mov byte [ebp - 0xd9c], al
movsx ecx, byte [ebp - 0xd9c]
xor ecx, 0x34
mov byte [ebp - 0xd9d], cl
mov dl, byte [ebp - 0xd9d]
mov byte [ebp - 0xd9e], dl
mov eax, dword [ebp - 0x24fc]
mov dword [ebp - 0x2d04], eax
mov ecx, dword [ebp - 0x2d04]
add ecx, dword [ebp - 0x20fc]
mov dword [ebp - 0x2d08], ecx
mov edx, dword [ebp - 0x2d08]
mov al, byte [ebp - 0xd9e]
mov byte [edx], al
jmp 0x10119d25
mov ecx, dword [ebp - 0x24fc]
mov dword [ebp - 0x2d0c], ecx
mov edx, dword [ebp - 0x2d0c]
mov dword [ebp - 0x2d10], edx
mov eax, dword [ebp - 0x2d10]
mov dword [ebp - 0x2d14], eax
mov ecx, dword [ebp - 0x2d14]
push ecx
lea ecx, [ebp - 0x5be0]
call fcn.1007b880
mov byte [ebp - 4], 0x2d
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.right]
mov byte [ebp - 0xda4], cl
movsx edx, byte [ebp - 0xda4]
xor edx, 0x34
mov byte [ebp - 0xda5], dl
mov al, byte [ebp - 0xda5]
mov byte [ebp - 0x2368], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.right]
mov byte [ebp - 0xdac], dl
movsx eax, byte [ebp - 0xdac]
xor eax, 0x34
mov byte [ebp - 0xdad], al
mov cl, byte [ebp - 0xdad]
mov byte [ebp - 0x2367], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.right]
mov byte [ebp - 0xdb4], al
movsx ecx, byte [ebp - 0xdb4]
xor ecx, 0x34
mov byte [ebp - 0xdb5], cl
mov dl, byte [ebp - 0xdb5]
mov byte [ebp - 0x2366], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.right]
mov byte [ebp - 0xdbc], dl
movsx eax, byte [ebp - 0xdbc]
xor eax, 0x34
mov byte [ebp - 0xdbd], al
mov cl, byte [ebp - 0xdbd]
mov byte [ebp - 0x2365], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.right]
mov byte [ebp - 0xdc4], al
movsx ecx, byte [ebp - 0xdc4]
xor ecx, 0x34
mov byte [ebp - 0xdc5], cl
mov dl, byte [ebp - 0xdc5]
mov byte [ebp - 0x2364], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.right]
mov byte [ebp - 0xdcc], dl
movsx eax, byte [ebp - 0xdcc]
xor eax, 0x34
mov byte [ebp - 0xdcd], al
mov cl, byte [ebp - 0xdcd]
mov byte [ebp - 0x2363], cl
lea edx, [ebp - 0x2368]
mov dword [ebp - 0x2d18], edx
mov eax, dword [ebp - 0x2d18]
mov dword [ebp - 0x2500], eax
mov dword [ebp - 0x20f8], 0
jmp 0x10119f42
mov ecx, dword [ebp - 0x20f8]
add ecx, 1
mov dword [ebp - 0x20f8], ecx
cmp dword [ebp - 0x20f8], 6
jae 0x10119fc4
mov edx, dword [ebp - 0x2500]
mov dword [ebp - 0x2d1c], edx
mov eax, dword [ebp - 0x2d1c]
add eax, dword [ebp - 0x20f8]
mov dword [ebp - 0x2d20], eax
mov ecx, dword [ebp - 0x2d20]
mov dl, byte [ecx]
mov byte [ebp - 0xdd4], dl
movsx eax, byte [ebp - 0xdd4]
xor eax, 0x34
mov byte [ebp - 0xdd5], al
mov cl, byte [ebp - 0xdd5]
mov byte [ebp - 0xdd6], cl
mov edx, dword [ebp - 0x2500]
mov dword [ebp - 0x2d24], edx
mov eax, dword [ebp - 0x2d24]
add eax, dword [ebp - 0x20f8]
mov dword [ebp - 0x2d28], eax
mov ecx, dword [ebp - 0x2d28]
mov dl, byte [ebp - 0xdd6]
mov byte [ecx], dl
jmp 0x10119f33
mov eax, dword [ebp - 0x2500]
mov dword [ebp - 0x2d2c], eax
mov ecx, dword [ebp - 0x2d2c]
mov dword [ebp - 0x2d30], ecx
mov edx, dword [ebp - 0x2d30]
mov dword [ebp - 0x2d34], edx
mov eax, dword [ebp - 0x2d34]
push eax
lea ecx, [ebp - 0x5bc8]
call fcn.1007b880
mov byte [ebp - 4], 0x2e
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.custom]
mov byte [ebp - 0xddc], al
movsx ecx, byte [ebp - 0xddc]
xor ecx, 0x34
mov byte [ebp - 0xddd], cl
mov dl, byte [ebp - 0xddd]
mov byte [ebp - 0x23a8], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.custom]
mov byte [ebp - 0xde4], cl
movsx edx, byte [ebp - 0xde4]
xor edx, 0x34
mov byte [ebp - 0xde5], dl
mov al, byte [ebp - 0xde5]
mov byte [ebp - 0x23a7], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.custom]
mov byte [ebp - 0xdec], dl
movsx eax, byte [ebp - 0xdec]
xor eax, 0x34
mov byte [ebp - 0xded], al
mov cl, byte [ebp - 0xded]
mov byte [ebp - 0x23a6], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.custom]
mov byte [ebp - 0xdf4], cl
movsx edx, byte [ebp - 0xdf4]
xor edx, 0x34
mov byte [ebp - 0xdf5], dl
mov al, byte [ebp - 0xdf5]
mov byte [ebp - 0x23a5], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.custom]
mov byte [ebp - 0xdfc], dl
movsx eax, byte [ebp - 0xdfc]
xor eax, 0x34
mov byte [ebp - 0xdfd], al
mov cl, byte [ebp - 0xdfd]
mov byte [ebp - 0x23a4], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.custom]
mov byte [ebp - 0xe04], cl
movsx edx, byte [ebp - 0xe04]
xor edx, 0x34
mov byte [ebp - 0xe05], dl
mov al, byte [ebp - 0xe05]
mov byte [ebp - 0x23a3], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.custom]
mov byte [ebp - 0xe0c], al
movsx ecx, byte [ebp - 0xe0c]
xor ecx, 0x34
mov byte [ebp - 0xe0d], cl
mov dl, byte [ebp - 0xe0d]
mov byte [ebp - 0x23a2], dl
lea eax, [ebp - 0x23a8]
mov dword [ebp - 0x2d38], eax
mov ecx, dword [ebp - 0x2d38]
mov dword [ebp - 0x2504], ecx
mov dword [ebp - 0x20f4], 0
jmp 0x1011a180
mov edx, dword [ebp - 0x20f4]
add edx, 1
mov dword [ebp - 0x20f4], edx
cmp dword [ebp - 0x20f4], 7
jae 0x1011a202
mov eax, dword [ebp - 0x2504]
mov dword [ebp - 0x2d3c], eax
mov ecx, dword [ebp - 0x2d3c]
add ecx, dword [ebp - 0x20f4]
mov dword [ebp - 0x2d40], ecx
mov edx, dword [ebp - 0x2d40]
mov al, byte [edx]
mov byte [ebp - 0xe14], al
movsx ecx, byte [ebp - 0xe14]
xor ecx, 0x34
mov byte [ebp - 0xe15], cl
mov dl, byte [ebp - 0xe15]
mov byte [ebp - 0xe16], dl
mov eax, dword [ebp - 0x2504]
mov dword [ebp - 0x2d44], eax
mov ecx, dword [ebp - 0x2d44]
add ecx, dword [ebp - 0x20f4]
mov dword [ebp - 0x2d48], ecx
mov edx, dword [ebp - 0x2d48]
mov al, byte [ebp - 0xe16]
mov byte [edx], al
jmp 0x1011a171
mov ecx, dword [ebp - 0x2504]
mov dword [ebp - 0x2d4c], ecx
mov edx, dword [ebp - 0x2d4c]
mov dword [ebp - 0x2d50], edx
mov eax, dword [ebp - 0x2d50]
mov dword [ebp - 0x2d54], eax
mov ecx, dword [ebp - 0x2d54]
push ecx
lea ecx, [ebp - 0x5bb0]
call fcn.1007b880
mov dword [ebp - 4], 0x2f
lea edx, [ebp - 0x5c10]
mov dword [ebp - 0x46c4], edx
lea eax, [ebp - 0x5b98]
mov dword [ebp - 0x46c0], eax
lea ecx, [ebp - 0x46c4]
mov dword [ebp - 0x2d58], ecx
mov edx, dword [ebp - 0x2d58]
mov eax, dword [edx]
mov ecx, dword [edx + 4]
mov dword [ebp - 0x4478], eax
mov dword [ebp - 0x4474], ecx
mov edx, dword [ebp - 0x2d5c]
push edx
mov eax, dword [ebp - 0x4474]
push eax
mov ecx, dword [ebp - 0x4478]
push ecx
lea ecx, [ebp - 0x4768]
call fcn.101ed250
mov byte [ebp - 4], 0x30
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.dir_stnd]
mov byte [ebp - 0xe1c], cl
movsx edx, byte [ebp - 0xe1c]
xor edx, 0x34
mov byte [ebp - 0xe1d], dl
mov al, byte [ebp - 0xe1d]
mov byte [ebp - 0x23d4], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.dir_stnd]
mov byte [ebp - 0xe24], dl
movsx eax, byte [ebp - 0xe24]
xor eax, 0x34
mov byte [ebp - 0xe25], al
mov cl, byte [ebp - 0xe25]
mov byte [ebp - 0x23d3], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.dir_stnd]
mov byte [ebp - 0xe2c], al
movsx ecx, byte [ebp - 0xe2c]
xor ecx, 0x34
mov byte [ebp - 0xe2d], cl
mov dl, byte [ebp - 0xe2d]
mov byte [ebp - 0x23d2], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.dir_stnd]
mov byte [ebp - 0xe34], dl
movsx eax, byte [ebp - 0xe34]
xor eax, 0x34
mov byte [ebp - 0xe35], al
mov cl, byte [ebp - 0xe35]
mov byte [ebp - 0x23d1], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.dir_stnd]
mov byte [ebp - 0xe3c], al
movsx ecx, byte [ebp - 0xe3c]
xor ecx, 0x34
mov byte [ebp - 0xe3d], cl
mov dl, byte [ebp - 0xe3d]
mov byte [ebp - 0x23d0], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.dir_stnd]
mov byte [ebp - 0xe44], dl
movsx eax, byte [ebp - 0xe44]
xor eax, 0x34
mov byte [ebp - 0xe45], al
mov cl, byte [ebp - 0xe45]
mov byte [ebp - 0x23cf], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.dir_stnd]
mov byte [ebp - 0xe4c], cl
movsx edx, byte [ebp - 0xe4c]
xor edx, 0x34
mov byte [ebp - 0xe4d], dl
mov al, byte [ebp - 0xe4d]
mov byte [ebp - 0x23ce], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.dir_stnd]
mov byte [ebp - 0xe54], al
movsx ecx, byte [ebp - 0xe54]
xor ecx, 0x34
mov byte [ebp - 0xe55], cl
mov dl, byte [ebp - 0xe55]
mov byte [ebp - 0x23cd], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.dir_stnd]
mov byte [ebp - 0xe5c], cl
movsx edx, byte [ebp - 0xe5c]
xor edx, 0x34
mov byte [ebp - 0xe5d], dl
mov al, byte [ebp - 0xe5d]
mov byte [ebp - 0x23cc], al
lea ecx, [ebp - 0x23d4]
mov dword [ebp - 0x2d60], ecx
mov edx, dword [ebp - 0x2d60]
mov dword [ebp - 0x2508], edx
mov dword [ebp - 0x20f0], 0
jmp 0x1011a480
mov eax, dword [ebp - 0x20f0]
add eax, 1
mov dword [ebp - 0x20f0], eax
cmp dword [ebp - 0x20f0], 9
jae 0x1011a502
mov ecx, dword [ebp - 0x2508]
mov dword [ebp - 0x2d64], ecx
mov edx, dword [ebp - 0x2d64]
add edx, dword [ebp - 0x20f0]
mov dword [ebp - 0x2d68], edx
mov eax, dword [ebp - 0x2d68]
mov cl, byte [eax]
mov byte [ebp - 0xe64], cl
movsx edx, byte [ebp - 0xe64]
xor edx, 0x34
mov byte [ebp - 0xe65], dl
mov al, byte [ebp - 0xe65]
mov byte [ebp - 0xe66], al
mov ecx, dword [ebp - 0x2508]
mov dword [ebp - 0x2d6c], ecx
mov edx, dword [ebp - 0x2d6c]
add edx, dword [ebp - 0x20f0]
mov dword [ebp - 0x2d70], edx
mov eax, dword [ebp - 0x2d70]
mov cl, byte [ebp - 0xe66]
mov byte [eax], cl
jmp 0x1011a471
mov edx, dword [ebp - 0x2508]
mov dword [ebp - 0x2d74], edx
mov eax, dword [ebp - 0x2d74]
mov dword [ebp - 0x2d78], eax
mov ecx, dword [ebp - 0x2d78]
mov dword [ebp - 0x2d7c], ecx
mov edx, dword [ebp - 0x2d7c]
push edx
lea ecx, [ebp - 0x4b10]
call fcn.1007b880
mov byte [ebp - 4], 0x31
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.direction]
mov byte [ebp - 0xe6c], dl
movsx eax, byte [ebp - 0xe6c]
xor eax, 0x34
mov byte [ebp - 0xe6d], al
mov cl, byte [ebp - 0xe6d]
mov byte [ebp - 0x2410], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.direction]
mov byte [ebp - 0xe74], al
movsx ecx, byte [ebp - 0xe74]
xor ecx, 0x34
mov byte [ebp - 0xe75], cl
mov dl, byte [ebp - 0xe75]
mov byte [ebp - 0x240f], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.direction]
mov byte [ebp - 0xe7c], cl
movsx edx, byte [ebp - 0xe7c]
xor edx, 0x34
mov byte [ebp - 0xe7d], dl
mov al, byte [ebp - 0xe7d]
mov byte [ebp - 0x240e], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.direction]
mov byte [ebp - 0xe84], al
movsx ecx, byte [ebp - 0xe84]
xor ecx, 0x34
mov byte [ebp - 0xe85], cl
mov dl, byte [ebp - 0xe85]
mov byte [ebp - 0x240d], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.direction]
mov byte [ebp - 0xe8c], cl
movsx edx, byte [ebp - 0xe8c]
xor edx, 0x34
mov byte [ebp - 0xe8d], dl
mov al, byte [ebp - 0xe8d]
mov byte [ebp - 0x240c], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.direction]
mov byte [ebp - 0xe94], al
movsx ecx, byte [ebp - 0xe94]
xor ecx, 0x34
mov byte [ebp - 0xe95], cl
mov dl, byte [ebp - 0xe95]
mov byte [ebp - 0x240b], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.direction]
mov byte [ebp - 0xe9c], dl
movsx eax, byte [ebp - 0xe9c]
xor eax, 0x34
mov byte [ebp - 0xe9d], al
mov cl, byte [ebp - 0xe9d]
mov byte [ebp - 0x240a], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.direction]
mov byte [ebp - 0xea4], cl
movsx edx, byte [ebp - 0xea4]
xor edx, 0x34
mov byte [ebp - 0xea5], dl
mov al, byte [ebp - 0xea5]
mov byte [ebp - 0x2409], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.direction]
mov byte [ebp - 0xeac], dl
movsx eax, byte [ebp - 0xeac]
xor eax, 0x34
mov byte [ebp - 0xead], al
mov cl, byte [ebp - 0xead]
mov byte [ebp - 0x2408], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.direction]
mov byte [ebp - 0xeb4], cl
movsx edx, byte [ebp - 0xeb4]
xor edx, 0x34
mov byte [ebp - 0xeb5], dl
mov al, byte [ebp - 0xeb5]
mov byte [ebp - 0x2407], al
lea ecx, [ebp - 0x2410]
mov dword [ebp - 0x2d80], ecx
mov edx, dword [ebp - 0x2d80]
mov dword [ebp - 0x250c], edx
mov dword [ebp - 0x20ec], 0
jmp 0x1011a74e
mov eax, dword [ebp - 0x20ec]
add eax, 1
mov dword [ebp - 0x20ec], eax
cmp dword [ebp - 0x20ec], 0xa
jae 0x1011a7d0
mov ecx, dword [ebp - 0x250c]
mov dword [ebp - 0x2d84], ecx
mov edx, dword [ebp - 0x2d84]
add edx, dword [ebp - 0x20ec]
mov dword [ebp - 0x2d88], edx
mov eax, dword [ebp - 0x2d88]
mov cl, byte [eax]
mov byte [ebp - 0xebc], cl
movsx edx, byte [ebp - 0xebc]
xor edx, 0x34
mov byte [ebp - 0xebd], dl
mov al, byte [ebp - 0xebd]
mov byte [ebp - 0xebe], al
mov ecx, dword [ebp - 0x250c]
mov dword [ebp - 0x2d8c], ecx
mov edx, dword [ebp - 0x2d8c]
add edx, dword [ebp - 0x20ec]
mov dword [ebp - 0x2d90], edx
mov eax, dword [ebp - 0x2d90]
mov cl, byte [ebp - 0xebe]
mov byte [eax], cl
jmp 0x1011a73f
mov edx, dword [ebp - 0x250c]
mov dword [ebp - 0x2d94], edx
mov eax, dword [ebp - 0x2d94]
mov dword [ebp - 0x2d98], eax
mov ecx, dword [ebp - 0x2d98]
mov dword [ebp - 0x2d9c], ecx
mov edx, dword [ebp - 0x2d9c]
push edx
lea ecx, [ebp - 0x4af8]
call fcn.1007b880
mov byte [ebp - 4], 0x32
lea eax, [ebp - 0x4b10]
push eax
mov ecx, dword [ebp - 0x348]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x348]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x348]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011a84d
lea ecx, [ebp - 0x4af8]
push ecx
mov ecx, dword [ebp - 0x348]
add ecx, 0x70
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x348]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011a867
mov dword [ebp - 0x2ae4], 0xf
jmp 0x1011a871
mov dword [ebp - 0x2ae4], 0
mov ecx, dword [ebp - 0x348]
mov edx, dword [ebp - 0x2ae4]
mov dword [ecx + 0x9c], edx
mov eax, dword [ebp - 0x348]
mov ecx, dword [eax + 0x9c]
add ecx, 0x14
mov dword [ebp - 0x2ae8], ecx
mov edx, dword [ebp - 0x348]
mov eax, dword [ebp - 0x2ae8]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0x348]
mov edx, dword [ebp - 0x2ae8]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0x4768]
mov dword [ebp - 0x2aec], eax
mov ecx, dword [ebp - 0x2aec]
mov edx, dword [ecx]
mov dword [ebp - 0x2da0], edx
mov eax, dword [ebp - 0x2da0]
mov dword [ebp - 0x2da4], eax
mov ecx, dword [ebp - 0x2da4]
mov dword [ebp - 0x2da8], ecx
mov edx, dword [ebp - 0x2da8]
mov dword [ebp - 0x226c], edx
mov eax, dword [ebp - 0x2aec]
mov ecx, dword [eax + 4]
mov dword [ebp - 0x2dac], ecx
mov edx, dword [ebp - 0x2dac]
mov dword [ebp - 0x2db0], edx
mov eax, dword [ebp - 0x2db0]
mov dword [ebp - 0x2db4], eax
mov ecx, dword [ebp - 0x2db4]
mov dword [ebp - 0x2db8], ecx
jmp 0x1011a938
mov edx, dword [ebp - 0x226c]
add edx, 0x18
mov dword [ebp - 0x226c], edx
mov eax, dword [ebp - 0x226c]
cmp eax, dword [ebp - 0x2db8]
je 0x1011a979
mov ecx, dword [ebp - 0x226c]
mov dword [ebp - 0x2dbc], ecx
mov edx, dword [ebp - 0x348]
add edx, 0x88
mov dword [ebp - 0x2dc0], edx
mov eax, dword [ebp - 0x2dbc]
push eax
mov ecx, dword [ebp - 0x2dc0]
call fcn.100d29a0
nop
jmp 0x1011a929
mov ecx, dword [ebp - 0x348]
add ecx, 0x88
mov dword [ebp - 0x2af0], ecx
mov edx, dword [ebp - 0x2af0]
mov eax, dword [ebp - 0x2af0]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0x2dc4], eax
cmp dword [ebp - 0x2dc4], 0
jbe 0x1011a9c5
mov edx, dword [ebp - 0x348]
mov dword [edx + 0x98], 0
mov byte [ebp - 4], 0x31
lea ecx, [ebp - 0x4af8]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x30
lea ecx, [ebp - 0x4b10]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x2f
lea ecx, [ebp - 0x4768]
call fcn.100d1ff0
nop
mov dword [ebp - 4], 0xffffffff
push fcn.1007b7f0
push 5
push 0x18
lea eax, [ebp - 0x5c10]
push eax
call fcn.10293728
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x6cc
mov dword [ebp - 0x2dc8], ecx
mov dword [ebp - 0x1ec], 0x1008a930
mov edx, dword [ebp - 0x2dc8]
add edx, 0x58
mov dword [ebp - 0x2dd0], edx
lea eax, [ebp - 0x1ec]
push eax
mov ecx, dword [ebp - 0x2dd0]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x6cc
mov dword [ebp - 0x2dd4], ecx
mov dword [ebp - 0x1f0], 0x1008a960
mov edx, dword [ebp - 0x2dd4]
add edx, 0x58
mov dword [ebp - 0x2ddc], edx
lea eax, [ebp - 0x1f0]
push eax
mov ecx, dword [ebp - 0x2ddc]
call fcn.1007d7f0
nop
mov ecx, dword [ebp - 0x290]
add ecx, 0x6cc
mov dword [ebp - 0xf0], ecx
mov edx, dword [ebp - 0xf0]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0xf0]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0xf0]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0xf0]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0xf0]
mov edx, dword [ebp - 0x290]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x290]
add ecx, 0x18
mov dword [ebp - 0x2de0], ecx
lea edx, [ebp - 0xf0]
push edx
mov ecx, dword [ebp - 0x2de0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x76c
mov dword [ebp - 0x304], eax
mov ecx, 2
imul edx, ecx, 0
mov ax, word [edx + 0x102a2b2c]
mov word [ebp - 0x268c], ax
movzx ecx, word [ebp - 0x268c]
xor ecx, 0x34
mov word [ebp - 0x268e], cx
mov dx, word [ebp - 0x268e]
mov word [ebp - 0x2af4], dx
mov eax, 2
shl eax, 0
mov cx, word [eax + 0x102a2b2c]
mov word [ebp - 0x2694], cx
movzx edx, word [ebp - 0x2694]
xor edx, 0x34
mov word [ebp - 0x2696], dx
mov ax, word [ebp - 0x2696]
mov word [ebp - 0x2af2], ax
lea ecx, [ebp - 0x2af4]
mov dword [ebp - 0x2de4], ecx
mov edx, dword [ebp - 0x2de4]
mov dword [ebp - 0x2510], edx
mov dword [ebp - 0x20e8], 0
jmp 0x1011abb5
mov eax, dword [ebp - 0x20e8]
add eax, 1
mov dword [ebp - 0x20e8], eax
cmp dword [ebp - 0x20e8], 2
jae 0x1011ac48
mov ecx, dword [ebp - 0x2510]
mov dword [ebp - 0x2de8], ecx
mov edx, dword [ebp - 0x20e8]
mov eax, dword [ebp - 0x2de8]
lea ecx, [eax + edx*2]
mov dword [ebp - 0x2dec], ecx
mov edx, dword [ebp - 0x2dec]
mov ax, word [edx]
mov word [ebp - 0x271c], ax
movzx ecx, word [ebp - 0x271c]
xor ecx, 0x34
mov word [ebp - 0x2698], cx
mov dx, word [ebp - 0x2698]
mov word [ebp - 0x269a], dx
mov eax, dword [ebp - 0x2510]
mov dword [ebp - 0x2df0], eax
mov ecx, dword [ebp - 0x20e8]
mov edx, dword [ebp - 0x2df0]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x2df4], eax
mov ecx, dword [ebp - 0x2df4]
mov dx, word [ebp - 0x269a]
mov word [ecx], dx
jmp 0x1011aba6
mov eax, dword [ebp - 0x2510]
mov dword [ebp - 0x2df8], eax
mov ecx, dword [ebp - 0x2df8]
mov dword [ebp - 0x2dfc], ecx
mov edx, dword [ebp - 0x2dfc]
mov dword [ebp - 0x2e00], edx
mov eax, dword [ebp - 0x2e00]
push eax
lea ecx, [ebp - 0x4b58]
call fcn.101ed710
mov dword [ebp - 4], 0x33
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.dir_time_stnd]
mov byte [ebp - 0xec4], al
movsx ecx, byte [ebp - 0xec4]
xor ecx, 0x34
mov byte [ebp - 0xec5], cl
mov dl, byte [ebp - 0xec5]
mov byte [ebp - 0x2438], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.dir_time_stnd]
mov byte [ebp - 0xecc], cl
movsx edx, byte [ebp - 0xecc]
xor edx, 0x34
mov byte [ebp - 0xecd], dl
mov al, byte [ebp - 0xecd]
mov byte [ebp - 0x2437], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.dir_time_stnd]
mov byte [ebp - 0xed4], dl
movsx eax, byte [ebp - 0xed4]
xor eax, 0x34
mov byte [ebp - 0xed5], al
mov cl, byte [ebp - 0xed5]
mov byte [ebp - 0x2436], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.dir_time_stnd]
mov byte [ebp - 0xedc], cl
movsx edx, byte [ebp - 0xedc]
xor edx, 0x34
mov byte [ebp - 0xedd], dl
mov al, byte [ebp - 0xedd]
mov byte [ebp - 0x2435], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.dir_time_stnd]
mov byte [ebp - 0xee4], dl
movsx eax, byte [ebp - 0xee4]
xor eax, 0x34
mov byte [ebp - 0xee5], al
mov cl, byte [ebp - 0xee5]
mov byte [ebp - 0x2434], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.dir_time_stnd]
mov byte [ebp - 0xeec], cl
movsx edx, byte [ebp - 0xeec]
xor edx, 0x34
mov byte [ebp - 0xeed], dl
mov al, byte [ebp - 0xeed]
mov byte [ebp - 0x2433], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.dir_time_stnd]
mov byte [ebp - 0xef4], al
movsx ecx, byte [ebp - 0xef4]
xor ecx, 0x34
mov byte [ebp - 0xef5], cl
mov dl, byte [ebp - 0xef5]
mov byte [ebp - 0x2432], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.dir_time_stnd]
mov byte [ebp - 0xefc], dl
movsx eax, byte [ebp - 0xefc]
xor eax, 0x34
mov byte [ebp - 0xefd], al
mov cl, byte [ebp - 0xefd]
mov byte [ebp - 0x2431], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.dir_time_stnd]
mov byte [ebp - 0xf04], al
movsx ecx, byte [ebp - 0xf04]
xor ecx, 0x34
mov byte [ebp - 0xf05], cl
mov dl, byte [ebp - 0xf05]
mov byte [ebp - 0x2430], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.dir_time_stnd]
mov byte [ebp - 0xf0c], dl
movsx eax, byte [ebp - 0xf0c]
xor eax, 0x34
mov byte [ebp - 0xf0d], al
mov cl, byte [ebp - 0xf0d]
mov byte [ebp - 0x242f], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.dir_time_stnd]
mov byte [ebp - 0xf14], cl
movsx edx, byte [ebp - 0xf14]
xor edx, 0x34
mov byte [ebp - 0xf15], dl
mov al, byte [ebp - 0xf15]
mov byte [ebp - 0x242e], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.dir_time_stnd]
mov byte [ebp - 0xf1c], al
movsx ecx, byte [ebp - 0xf1c]
xor ecx, 0x34
mov byte [ebp - 0xf1d], cl
mov dl, byte [ebp - 0xf1d]
mov byte [ebp - 0x242d], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.dir_time_stnd]
mov byte [ebp - 0xf24], dl
movsx eax, byte [ebp - 0xf24]
xor eax, 0x34
mov byte [ebp - 0xf25], al
mov cl, byte [ebp - 0xf25]
mov byte [ebp - 0x242c], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.dir_time_stnd]
mov byte [ebp - 0xf2c], cl
movsx edx, byte [ebp - 0xf2c]
xor edx, 0x34
mov byte [ebp - 0xf2d], dl
mov al, byte [ebp - 0xf2d]
mov byte [ebp - 0x242b], al
lea ecx, [ebp - 0x2438]
mov dword [ebp - 0x2e04], ecx
mov edx, dword [ebp - 0x2e04]
mov dword [ebp - 0x2514], edx
mov dword [ebp - 0x2194], 0
jmp 0x1011af57
mov eax, dword [ebp - 0x2194]
add eax, 1
mov dword [ebp - 0x2194], eax
cmp dword [ebp - 0x2194], 0xe
jae 0x1011afd9
mov ecx, dword [ebp - 0x2514]
mov dword [ebp - 0x2e08], ecx
mov edx, dword [ebp - 0x2e08]
add edx, dword [ebp - 0x2194]
mov dword [ebp - 0x2e0c], edx
mov eax, dword [ebp - 0x2e0c]
mov cl, byte [eax]
mov byte [ebp - 0xf34], cl
movsx edx, byte [ebp - 0xf34]
xor edx, 0x34
mov byte [ebp - 0xf35], dl
mov al, byte [ebp - 0xf35]
mov byte [ebp - 0xf36], al
mov ecx, dword [ebp - 0x2514]
mov dword [ebp - 0x2e10], ecx
mov edx, dword [ebp - 0x2e10]
add edx, dword [ebp - 0x2194]
mov dword [ebp - 0x2e14], edx
mov eax, dword [ebp - 0x2e14]
mov cl, byte [ebp - 0xf36]
mov byte [eax], cl
jmp 0x1011af48
mov edx, dword [ebp - 0x2514]
mov dword [ebp - 0x2e18], edx
mov eax, dword [ebp - 0x2e18]
mov dword [ebp - 0x2e1c], eax
mov ecx, dword [ebp - 0x2e1c]
mov dword [ebp - 0x2e20], ecx
mov edx, dword [ebp - 0x2e20]
push edx
lea ecx, [ebp - 0x4b40]
call fcn.1007b880
mov byte [ebp - 4], 0x34
push 0x102a0e2e
lea ecx, [ebp - 0x4b28]
call fcn.1007b880
mov byte [ebp - 4], 0x35
lea eax, [ebp - 0x4b40]
push eax
mov ecx, dword [ebp - 0x304]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x304]
mov byte [ecx + 0x69], 0
mov edx, dword [ebp - 0x304]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011b06d
lea ecx, [ebp - 0x4b28]
push ecx
mov ecx, dword [ebp - 0x304]
add ecx, 0x88
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x304]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011b087
mov dword [ebp - 0x2af8], 0xf
jmp 0x1011b091
mov dword [ebp - 0x2af8], 0
mov ecx, dword [ebp - 0x304]
mov edx, dword [ebp - 0x2af8]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x304]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x304]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x304]
mov ecx, dword [ebp - 0x304]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x304]
xorps xmm0, xmm0
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x304]
movss xmm0, dword [0x102a60f0]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x304]
xorps xmm0, xmm0
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x304]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x304]
movss xmm0, dword [0x102a6038]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x4b58]
push edx
mov ecx, dword [ebp - 0x304]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x34
lea ecx, [ebp - 0x4b28]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x33
lea ecx, [ebp - 0x4b40]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4b58]
call fcn.100d2140
nop
mov eax, dword [ebp - 0x290]
add eax, 0x76c
mov dword [ebp - 0x2e24], eax
mov dword [ebp - 0x1f4], 0x1008a930
mov ecx, dword [ebp - 0x2e24]
add ecx, 0x58
mov dword [ebp - 0x2e2c], ecx
lea edx, [ebp - 0x1f4]
push edx
mov ecx, dword [ebp - 0x2e2c]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x76c
mov dword [ebp - 0x2e30], eax
mov dword [ebp - 0x1f8], 0x1008a960
mov ecx, dword [ebp - 0x2e30]
add ecx, 0x58
mov dword [ebp - 0x2e38], ecx
lea edx, [ebp - 0x1f8]
push edx
mov ecx, dword [ebp - 0x2e38]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x76c
mov dword [ebp - 0x2e3c], eax
mov dword [ebp - 0x1fc], 0x1008aa50
mov ecx, dword [ebp - 0x2e3c]
add ecx, 0x58
mov dword [ebp - 0x2e44], ecx
lea edx, [ebp - 0x1fc]
push edx
mov ecx, dword [ebp - 0x2e44]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x76c
mov dword [ebp - 0xf4], eax
mov ecx, dword [ebp - 0xf4]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0xf4]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0xf4]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0xf4]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0xf4]
mov ecx, dword [ebp - 0x290]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x290]
add eax, 0x18
mov dword [ebp - 0x2e48], eax
lea ecx, [ebp - 0xf4]
push ecx
mov ecx, dword [ebp - 0x2e48]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x828
mov dword [ebp - 0x300], edx
mov eax, 2
imul ecx, eax, 0
mov dx, word [ecx + 0x102a2a9c]
mov word [ebp - 0x26a0], dx
movzx eax, word [ebp - 0x26a0]
xor eax, 0x34
mov word [ebp - 0x26a2], ax
mov cx, word [ebp - 0x26a2]
mov word [ebp - 0x2afc], cx
mov edx, 2
shl edx, 0
mov ax, word [edx + 0x102a2a9c]
mov word [ebp - 0x26a8], ax
movzx ecx, word [ebp - 0x26a8]
xor ecx, 0x34
mov word [ebp - 0x26aa], cx
mov dx, word [ebp - 0x26aa]
mov word [ebp - 0x2afa], dx
lea eax, [ebp - 0x2afc]
mov dword [ebp - 0x2e4c], eax
mov ecx, dword [ebp - 0x2e4c]
mov dword [ebp - 0x2518], ecx
mov dword [ebp - 0x20e4], 0
jmp 0x1011b349
mov edx, dword [ebp - 0x20e4]
add edx, 1
mov dword [ebp - 0x20e4], edx
cmp dword [ebp - 0x20e4], 2
jae 0x1011b3dc
mov eax, dword [ebp - 0x2518]
mov dword [ebp - 0x2e50], eax
mov ecx, dword [ebp - 0x20e4]
mov edx, dword [ebp - 0x2e50]
lea eax, [edx + ecx*2]
mov dword [ebp - 0x2e54], eax
mov ecx, dword [ebp - 0x2e54]
mov dx, word [ecx]
mov word [ebp - 0x26b0], dx
movzx eax, word [ebp - 0x26b0]
xor eax, 0x34
mov word [ebp - 0x26b2], ax
mov cx, word [ebp - 0x26b2]
mov word [ebp - 0x26b4], cx
mov edx, dword [ebp - 0x2518]
mov dword [ebp - 0x2e58], edx
mov eax, dword [ebp - 0x20e4]
mov ecx, dword [ebp - 0x2e58]
lea edx, [ecx + eax*2]
mov dword [ebp - 0x2e5c], edx
mov eax, dword [ebp - 0x2e5c]
mov cx, word [ebp - 0x26b4]
mov word [eax], cx
jmp 0x1011b33a
mov edx, dword [ebp - 0x2518]
mov dword [ebp - 0x2e60], edx
mov eax, dword [ebp - 0x2e60]
mov dword [ebp - 0x2e64], eax
mov ecx, dword [ebp - 0x2e64]
mov dword [ebp - 0x2e68], ecx
mov edx, dword [ebp - 0x2e68]
push edx
lea ecx, [ebp - 0x4ba0]
call fcn.101ed710
mov dword [ebp - 4], 0x36
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.dir_custom_stnd]
mov byte [ebp - 0xf3c], dl
movsx eax, byte [ebp - 0xf3c]
xor eax, 0x34
mov byte [ebp - 0xf3d], al
mov cl, byte [ebp - 0xf3d]
mov byte [ebp - 0x24a8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.dir_custom_stnd]
mov byte [ebp - 0xf44], al
movsx ecx, byte [ebp - 0xf44]
xor ecx, 0x34
mov byte [ebp - 0xf45], cl
mov dl, byte [ebp - 0xf45]
mov byte [ebp - 0x24a7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xf4c], cl
movsx edx, byte [ebp - 0xf4c]
xor edx, 0x34
mov byte [ebp - 0xf4d], dl
mov al, byte [ebp - 0xf4d]
mov byte [ebp - 0x24a6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.dir_custom_stnd]
mov byte [ebp - 0xf54], al
movsx ecx, byte [ebp - 0xf54]
xor ecx, 0x34
mov byte [ebp - 0xf55], cl
mov dl, byte [ebp - 0xf55]
mov byte [ebp - 0x24a5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xf5c], cl
movsx edx, byte [ebp - 0xf5c]
xor edx, 0x34
mov byte [ebp - 0xf5d], dl
mov al, byte [ebp - 0xf5d]
mov byte [ebp - 0x24a4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.dir_custom_stnd]
mov byte [ebp - 0xf64], al
movsx ecx, byte [ebp - 0xf64]
xor ecx, 0x34
mov byte [ebp - 0xf65], cl
mov dl, byte [ebp - 0xf65]
mov byte [ebp - 0x24a3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.dir_custom_stnd]
mov byte [ebp - 0xf6c], dl
movsx eax, byte [ebp - 0xf6c]
xor eax, 0x34
mov byte [ebp - 0xf6d], al
mov cl, byte [ebp - 0xf6d]
mov byte [ebp - 0x24a2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xf74], cl
movsx edx, byte [ebp - 0xf74]
xor edx, 0x34
mov byte [ebp - 0xf75], dl
mov al, byte [ebp - 0xf75]
mov byte [ebp - 0x24a1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.dir_custom_stnd]
mov byte [ebp - 0xf7c], dl
movsx eax, byte [ebp - 0xf7c]
xor eax, 0x34
mov byte [ebp - 0xf7d], al
mov cl, byte [ebp - 0xf7d]
mov byte [ebp - 0x24a0], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xf84], cl
movsx edx, byte [ebp - 0xf84]
xor edx, 0x34
mov byte [ebp - 0xf85], dl
mov al, byte [ebp - 0xf85]
mov byte [ebp - 0x249f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.dir_custom_stnd]
mov byte [ebp - 0xf8c], al
movsx ecx, byte [ebp - 0xf8c]
xor ecx, 0x34
mov byte [ebp - 0xf8d], cl
mov dl, byte [ebp - 0xf8d]
mov byte [ebp - 0x249e], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.dir_custom_stnd]
mov byte [ebp - 0xf94], dl
movsx eax, byte [ebp - 0xf94]
xor eax, 0x34
mov byte [ebp - 0xf95], al
mov cl, byte [ebp - 0xf95]
mov byte [ebp - 0x249d], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xf9c], cl
movsx edx, byte [ebp - 0xf9c]
xor edx, 0x34
mov byte [ebp - 0xf9d], dl
mov al, byte [ebp - 0xf9d]
mov byte [ebp - 0x249c], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.dir_custom_stnd]
mov byte [ebp - 0xfa4], al
movsx ecx, byte [ebp - 0xfa4]
xor ecx, 0x34
mov byte [ebp - 0xfa5], cl
mov dl, byte [ebp - 0xfa5]
mov byte [ebp - 0x249b], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.dir_custom_stnd]
mov byte [ebp - 0xfac], dl
movsx eax, byte [ebp - 0xfac]
xor eax, 0x34
mov byte [ebp - 0xfad], al
mov cl, byte [ebp - 0xfad]
mov byte [ebp - 0x249a], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.dir_custom_stnd]
mov byte [ebp - 0xfb4], cl
movsx edx, byte [ebp - 0xfb4]
xor edx, 0x34
mov byte [ebp - 0xfb5], dl
mov al, byte [ebp - 0xfb5]
mov byte [ebp - 0x2499], al
lea ecx, [ebp - 0x24a8]
mov dword [ebp - 0x2e6c], ecx
mov edx, dword [ebp - 0x2e6c]
mov dword [ebp - 0x251c], edx
mov dword [ebp - 0x20c4], 0
jmp 0x1011b74b
mov eax, dword [ebp - 0x20c4]
add eax, 1
mov dword [ebp - 0x20c4], eax
cmp dword [ebp - 0x20c4], 0x10
jae 0x1011b7cd
mov ecx, dword [ebp - 0x251c]
mov dword [ebp - 0x2e70], ecx
mov edx, dword [ebp - 0x2e70]
add edx, dword [ebp - 0x20c4]
mov dword [ebp - 0x2e74], edx
mov eax, dword [ebp - 0x2e74]
mov cl, byte [eax]
mov byte [ebp - 0xfbc], cl
movsx edx, byte [ebp - 0xfbc]
xor edx, 0x34
mov byte [ebp - 0xfbd], dl
mov al, byte [ebp - 0xfbd]
mov byte [ebp - 0xfbe], al
mov ecx, dword [ebp - 0x251c]
mov dword [ebp - 0x2e78], ecx
mov edx, dword [ebp - 0x2e78]
add edx, dword [ebp - 0x20c4]
mov dword [ebp - 0x2e7c], edx
mov eax, dword [ebp - 0x2e7c]
mov cl, byte [ebp - 0xfbe]
mov byte [eax], cl
jmp 0x1011b73c
mov edx, dword [ebp - 0x251c]
mov dword [ebp - 0x2e80], edx
mov eax, dword [ebp - 0x2e80]
mov dword [ebp - 0x2e84], eax
mov ecx, dword [ebp - 0x2e84]
mov dword [ebp - 0x2e88], ecx
mov edx, dword [ebp - 0x2e88]
push edx
lea ecx, [ebp - 0x4b88]
call fcn.1007b880
mov byte [ebp - 4], 0x37
push 0x102a0e2e
lea ecx, [ebp - 0x4b70]
call fcn.1007b880
mov byte [ebp - 4], 0x38
lea eax, [ebp - 0x4b88]
push eax
mov ecx, dword [ebp - 0x300]
add ecx, 0x38
call fcn.1008d0b0
mov ecx, dword [ebp - 0x300]
mov byte [ecx + 0x69], 0
mov edx, dword [ebp - 0x300]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011b861
lea ecx, [ebp - 0x4b70]
push ecx
mov ecx, dword [ebp - 0x300]
add ecx, 0x88
call fcn.1008d0b0
nop
mov edx, dword [ebp - 0x300]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x1011b87b
mov dword [ebp - 0x2b00], 0xf
jmp 0x1011b885
mov dword [ebp - 0x2b00], 0
mov ecx, dword [ebp - 0x300]
mov edx, dword [ebp - 0x2b00]
mov dword [ecx + 0xb8], edx
mov eax, dword [ebp - 0x300]
mov ecx, dword [eax + 0xb8]
add ecx, 8
mov edx, dword [ebp - 0x300]
mov dword [edx + 0x10], ecx
mov eax, dword [ebp - 0x300]
mov ecx, dword [ebp - 0x300]
mov edx, dword [ecx + 0x10]
mov dword [eax + 0x14], edx
mov eax, dword [ebp - 0x300]
movss xmm0, dword [0x102a627c]
movss dword [eax + 0x74], xmm0
mov ecx, dword [ebp - 0x300]
movss xmm0, dword [0x102a61a8]
movss dword [ecx + 0x78], xmm0
mov edx, dword [ebp - 0x300]
xorps xmm0, xmm0
movss dword [edx + 0x70], xmm0
mov eax, dword [ebp - 0x300]
mov dword [eax + 0x84], 0
mov ecx, dword [ebp - 0x300]
movss xmm0, dword [0x102a60dc]
movss dword [ecx + 0x7c], xmm0
lea edx, [ebp - 0x4ba0]
push edx
mov ecx, dword [ebp - 0x300]
add ecx, 0xa0
call fcn.101ed650
nop
mov byte [ebp - 4], 0x37
lea ecx, [ebp - 0x4b70]
call fcn.1007c260
nop
mov byte [ebp - 4], 0x36
lea ecx, [ebp - 0x4b88]
call fcn.1007c260
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x4ba0]
call fcn.100d2140
nop
mov eax, dword [ebp - 0x290]
add eax, 0x828
mov dword [ebp - 0x2e8c], eax
mov dword [ebp - 0x200], 0x1008a930
mov ecx, dword [ebp - 0x2e8c]
add ecx, 0x58
mov dword [ebp - 0x2e94], ecx
lea edx, [ebp - 0x200]
push edx
mov ecx, dword [ebp - 0x2e94]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x828
mov dword [ebp - 0x2e98], eax
mov dword [ebp - 0x204], 0x1008a960
mov ecx, dword [ebp - 0x2e98]
add ecx, 0x58
mov dword [ebp - 0x2ea0], ecx
lea edx, [ebp - 0x204]
push edx
mov ecx, dword [ebp - 0x2ea0]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x828
mov dword [ebp - 0x2ea4], eax
mov dword [ebp - 0x208], 0x1008aa80
mov ecx, dword [ebp - 0x2ea4]
add ecx, 0x58
mov dword [ebp - 0x2eac], ecx
lea edx, [ebp - 0x208]
push edx
mov ecx, dword [ebp - 0x2eac]
call fcn.1007d7f0
nop
mov eax, dword [ebp - 0x290]
add eax, 0x828
mov dword [ebp - 0xf8], eax
mov ecx, dword [ebp - 0xf8]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0xf8]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0xf8]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0xf8]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0xf8]
mov ecx, dword [ebp - 0x290]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x290]
add eax, 0x18
mov dword [ebp - 0x2eb0], eax
lea ecx, [ebp - 0xf8]
push ecx
mov ecx, dword [ebp - 0x2eb0]
call fcn.1007d7f0
nop
mov edx, dword [ebp - 0x290]
add edx, 0x96c
mov dword [ebp - 0x34c], edx
lea eax, [ebp - 0x274b]
mov dword [ebp - 0x2eb4], eax
mov ecx, dword [ebp - 0x2eb4]
mov dword [ebp - 0x2f3c], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + 0x102a28c0]
mov byte [ebp - 0xfc4], cl
movsx edx, byte [ebp - 0xfc4]
xor edx, 0x34
mov byte [ebp - 0xfc5], dl
mov al, byte [ebp - 0xfc5]
mov byte [ebp - 0x2270], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + 0x102a28c0]
mov byte [ebp - 0xfcc], dl
movsx eax, byte [ebp - 0xfcc]
xor eax, 0x34
mov byte [ebp - 0xfcd], al
mov cl, byte [ebp - 0xfcd]
mov byte [ebp - 0x226f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + 0x102a28c0]
mov byte [ebp - 0xfd4], al
movsx ecx, byte [ebp - 0xfd4]
xor ecx, 0x34
mov byte [ebp - 0xfd5], cl
mov dl, byte [ebp - 0xfd5]
mov byte [ebp - 0x226e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + 0x102a28c0]
mov byte [ebp - 0xfdc], dl
movsx eax, byte [ebp - 0xfdc]
xor eax, 0x34
mov byte [ebp - 0xfdd], al
mov cl, byte [ebp - 0xfdd]
mov byte [ebp - 0x226d], cl
lea edx, [ebp - 0x2270]
mov dword [ebp - 0x2eb8], edx
mov eax, dword [ebp - 0x2eb8]
mov dword [ebp - 0x2520], eax
mov dword [ebp - 0x20e0], 0
jmp 0x1011bbaf
mov ecx, dword [ebp - 0x20e0]
add ecx, 1
mov dword [ebp - 0x20e0], ecx
cmp dword [ebp - 0x20e0], 4
jae 0x1011bc31
mov edx, dword [ebp - 0x2520]
mov dword [ebp - 0x2ebc], edx
mov eax, dword [ebp - 0x2ebc]
add eax, dword [ebp - 0x20e0]
mov dword [ebp - 0x2ec0], eax
mov ecx, dword [ebp - 0x2ec0]
mov dl, byte [ecx]
mov byte [ebp - 0xfe4], dl
movsx eax, byte [ebp - 0xfe4]
xor eax, 0x34
mov byte [ebp - 0xfe5], al
mov cl, byte [ebp - 0xfe5]
mov byte [ebp - 0xfe6], cl
mov edx, dword [ebp - 0x2520]
mov dword [ebp - 0x2ec4], edx
mov eax, dword [ebp - 0x2ec4]
add eax, dword [ebp - 0x20e0]
mov dword [ebp - 0x2ec8], eax
mov ecx, dword [ebp - 0x2ec8]
mov dl, byte [ebp - 0xfe6]
mov byte [ecx], dl
jmp 0x1011bba0
mov eax, dword [ebp - 0x2520]
mov dword [ebp - 0x2ecc], eax
mov ecx, dword [ebp - 0x2ecc]
mov dword [ebp - 0x2ed0], ecx
mov edx, dword [ebp - 0x2ed0]
mov dword [ebp - 0x2ed4], edx
mov eax, dword [ebp - 0x2ed4]
push eax
lea ecx, [ebp - 0x5970]
call fcn.1007b880
mov dword [ebp - 4], 0x39
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.static]
mov byte [ebp - 0xfec], al
movsx ecx, byte [ebp - 0xfec]
xor ecx, 0x34
mov byte [ebp - 0xfed], cl
mov dl, byte [ebp - 0xfed]
mov byte [ebp - 0x23b0], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.static]
mov byte [ebp - 0xff4], cl
movsx edx, byte [ebp - 0xff4]
xor edx, 0x34
mov byte [ebp - 0xff5], dl
mov al, byte [ebp - 0xff5]
mov byte [ebp - 0x23af], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.static]
mov byte [ebp - 0xffc], dl
movsx eax, byte [ebp - 0xffc]
xor eax, 0x34
mov byte [ebp - 0xffd], al
mov cl, byte [ebp - 0xffd]
mov byte [ebp - 0x23ae], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.static]
mov byte [ebp - 0x1004], cl
movsx edx, byte [ebp - 0x1004]
xor edx, 0x34
mov byte [ebp - 0x1005], dl
mov al, byte [ebp - 0x1005]
mov byte [ebp - 0x23ad], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.static]
mov byte [ebp - 0x100c], dl
movsx eax, byte [ebp - 0x100c]
xor eax, 0x34
mov byte [ebp - 0x100d], al
mov cl, byte [ebp - 0x100d]
mov byte [ebp - 0x23ac], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.static]
mov byte [ebp - 0x1014], cl
movsx edx, byte [ebp - 0x1014]
xor edx, 0x34
mov byte [ebp - 0x1015], dl
mov al, byte [ebp - 0x1015]
mov byte [ebp - 0x23ab], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.static]
mov byte [ebp - 0x101c], al
movsx ecx, byte [ebp - 0x101c]
xor ecx, 0x34
mov byte [ebp - 0x101d], cl
mov dl, byte [ebp - 0x101d]
mov byte [ebp - 0x23aa], dl
lea eax, [ebp - 0x23b0]
mov dword [ebp - 0x2ed8], eax
mov ecx, dword [ebp - 0x2ed8]
mov dword [ebp - 0x2524], ecx
mov dword [ebp - 0x20dc], 0
jmp 0x1011bdf0
cmp dword [ebp - 0x20dc], 7
jae 0x1011be72
mov eax, dword [ebp - 0x2524]
mov dword [ebp - 0x2edc], eax
mov ecx, dword [ebp - 0x2edc]
add ecx, dword [ebp - 0x20dc]
mov dword [ebp - 0x2ee0], ecx
mov edx, dword [ebp - 0x2ee0]
mov al, byte [edx]
mov byte [ebp - 0x1024], al
movsx ecx, byte [ebp - 0x1024]
xor ecx, 0x34
mov byte [ebp - 0x1025], cl
mov dl, byte [ebp - 0x1025]
mov byte [ebp - 0x1026], dl
mov eax, dword [ebp - 0x2524]
mov dword [ebp - 0x2ee4], eax
mov ecx, dword [ebp - 0x2ee4]
add ecx, dword [ebp - 0x20dc]
mov dword [ebp - 0x2ee8], ecx
mov edx, dword [ebp - 0x2ee8]
mov al, byte [ebp - 0x1026]
mov byte [edx], al
jmp 0x1011bde1
mov ecx, dword [ebp - 0x2524]
mov dword [ebp - 0x2eec], ecx
mov edx, dword [ebp - 0x2eec]
mov dword [ebp - 0x2ef0], edx
mov eax, dword [ebp - 0x2ef0]
mov dword [ebp - 0x2ef4], eax
mov ecx, dword [ebp - 0x2ef4]
push ecx
lea ecx, [ebp - 0x5958]
call fcn.1007b880
mov byte [ebp - 4], 0x3a
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.away_crosshair]
mov byte [ebp - 0x102c], cl
movsx edx, byte [ebp - 0x102c]
xor edx, 0x34
mov byte [ebp - 0x102d], dl
mov al, byte [ebp - 0x102d]
mov byte [ebp - 0x2478], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.away_crosshair]
mov byte [ebp - 0x1034], dl
movsx eax, byte [ebp - 0x1034]
xor eax, 0x34
mov byte [ebp - 0x1035], al
mov cl, byte [ebp - 0x1035]
mov byte [ebp - 0x2477], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.away_crosshair]
mov byte [ebp - 0x103c], al
movsx ecx, byte [ebp - 0x103c]
xor ecx, 0x34
mov byte [ebp - 0x103d], cl
mov dl, byte [ebp - 0x103d]
mov byte [ebp - 0x2476], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.away_crosshair]
mov byte [ebp - 0x1044], dl
movsx eax, byte [ebp - 0x1044]
xor eax, 0x34
mov byte [ebp - 0x1045], al
mov cl, byte [ebp - 0x1045]
mov byte [ebp - 0x2475], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.away_crosshair]
mov byte [ebp - 0x104c], al
movsx ecx, byte [ebp - 0x104c]
xor ecx, 0x34
mov byte [ebp - 0x104d], cl
mov dl, byte [ebp - 0x104d]
mov byte [ebp - 0x2474], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.away_crosshair]
mov byte [ebp - 0x1054], dl
movsx eax, byte [ebp - 0x1054]
xor eax, 0x34
mov byte [ebp - 0x1055], al
mov cl, byte [ebp - 0x1055]
mov byte [ebp - 0x2473], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.away_crosshair]
mov byte [ebp - 0x105c], cl
movsx edx, byte [ebp - 0x105c]
xor edx, 0x34
mov byte [ebp - 0x105d], dl
mov al, byte [ebp - 0x105d]
mov byte [ebp - 0x2472], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.away_crosshair]
mov byte [ebp - 0x1064], al
movsx ecx, byte [ebp - 0x1064]
xor ecx, 0x34
mov byte [ebp - 0x1065], cl
mov dl, byte [ebp - 0x1065]
mov byte [ebp - 0x2471], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.away_crosshair]
mov byte [ebp - 0x106c], cl
movsx edx, byte [ebp - 0x106c]
xor edx, 0x34
mov byte [ebp - 0x106d], dl
mov al, byte [ebp - 0x106d]
mov byte [ebp - 0x2470], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.away_crosshair]
mov byte [ebp - 0x1074], al
movsx ecx, byte [ebp - 0x1074]
xor ecx, 0x34
mov byte [ebp - 0x1075], cl
mov dl, byte [ebp - 0x1075]
mov byte [ebp - 0x246f], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.away_crosshair]
mov byte [ebp - 0x107c], dl
movsx eax, byte [ebp - 0x107c]
xor eax, 0x34
mov byte [ebp - 0x107d], al
mov cl, byte [ebp - 0x107d]
mov byte [ebp - 0x246e], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.away_crosshair]
mov byte [ebp - 0x1084], cl
movsx edx, byte [ebp - 0x1084]
xor edx, 0x34
mov byte [ebp - 0x1085], dl
mov al, byte [ebp - 0x1085]
mov byte [ebp - 0x246d], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.away_crosshair]
mov byte [ebp - 0x108c], al
movsx ecx, byte [ebp - 0x108c]
xor ecx, 0x34
mov byte [ebp - 0x108d], cl
mov dl, byte [ebp - 0x108d]
mov byte [ebp - 0x246c], dl
mov eax, 1
imul ecx, eax, 0xd
mov dl, byte [ecx + str.away_crosshair]
mov byte [ebp - 0x1094], dl
movsx eax, byte [ebp - 0x1094]
xor eax, 0x34
mov byte [ebp - 0x1095], al
mov cl, byte [ebp - 0x1095]
mov byte [ebp - 0x246b], cl
mov edx, 1
imul eax, edx, 0xe
mov cl, byte [eax + str.away_crosshair]
mov byte [ebp - 0x109c], cl
movsx edx, byte [ebp - 0x109c]
xor edx, 0x34
mov byte [ebp - 0x109d], dl
mov al, byte [ebp - 0x109d]
mov byte [ebp - 0x246a], al
lea ecx, [ebp - 0x2478]
mov dword [ebp - 0x2ef8], ecx
mov edx, dword [ebp - 0x2ef8]
mov dword [ebp - 0x2528], edx
mov dword [ebp - 0x20d8], 0
jmp 0x1011c1ae