Function at 0x100aa750
Capabilities:
Check os version

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 0x101353c9
mov eax, dword fs:[0]
push eax
push ebx
mov eax, 0x12f8
call fcn.1012e750
mov eax, dword [0x1014c040]
xor eax, ebp
mov dword [ebp - 0x14], eax
push eax
lea eax, [ebp - 0xc]
mov dword fs:[0], eax
mov dword [ebp - 0x34], ecx
push 0x1013fa88
lea ecx, [ebp - 0xf8c]
call fcn.10028b00
mov dword [ebp - 4], 0
lea eax, [ebp - 0xf8c]
push eax
mov ecx, dword [ebp - 0x34]
call fcn.1003b850
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0xf8c]
call fcn.10029670
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x30
mov dword [ebp - 0x38], ecx
lea edx, [ebp - 0xa5d]
mov dword [ebp - 0xdf8], edx
mov eax, dword [ebp - 0xdf8]
mov dword [ebp - 0xea0], eax
push 0x1013fa8c
lea ecx, [ebp - 0x1130]
call fcn.10028b00
mov dword [ebp - 4], 1
push str.lag_compensation
lea ecx, [ebp - 0x1118]
call fcn.10028b00
mov byte [ebp - 4], 2
push str.fake_latency
lea ecx, [ebp - 0x1100]
call fcn.10028b00
mov byte [ebp - 4], 3
push str.min_dmg_ovr
lea ecx, [ebp - 0x10e8]
call fcn.10028b00
mov byte [ebp - 4], 4
push str.force_baim
lea ecx, [ebp - 0x10d0]
call fcn.10028b00
mov dword [ebp - 4], 5
lea ecx, [ebp - 0x1130]
mov dword [ebp - 0xf14], ecx
lea edx, [ebp - 0x10b8]
mov dword [ebp - 0xf10], edx
lea eax, [ebp - 0xf14]
mov dword [ebp - 0xe98], eax
mov ecx, dword [ebp - 0xe98]
mov edx, dword [ecx]
mov eax, dword [ecx + 4]
mov dword [ebp - 0xec0], edx
mov dword [ebp - 0xebc], eax
mov ecx, dword [ebp - 0xea0]
push ecx
mov edx, dword [ebp - 0xebc]
push edx
mov eax, dword [ebp - 0xec0]
push eax
lea ecx, [ebp - 0xf44]
call fcn.100bc9a0
mov byte [ebp - 4], 6
push str.indicators
lea ecx, [ebp - 0xfbc]
call fcn.10028b00
mov byte [ebp - 4], 7
push str.indicators
lea ecx, [ebp - 0xfa4]
call fcn.10028b00
mov byte [ebp - 4], 8
lea ecx, [ebp - 0xf38]
mov dword [ebp - 0xa64], ecx
mov edx, dword [ebp - 0xa64]
mov dword [ebp - 0xea4], edx
mov ecx, dword [ebp - 0xea4]
call fcn.1002b7f0
nop
mov eax, dword [ebp - 0xa64]
mov dword [ebp - 0xf64], eax
mov ecx, dword [ebp - 0xa64]
mov dword [ebp - 0xea8], ecx
mov edx, dword [ebp - 0xea8]
mov dword [ebp - 0xf68], edx
mov byte [ebp - 4], 9
lea eax, [ebp - 0xfbc]
push eax
mov ecx, dword [ebp - 0x38]
add ecx, 0x38
call fcn.1003b850
mov ecx, dword [ebp - 0x38]
mov byte [ecx + 0x69], 1
mov edx, dword [ebp - 0x38]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x100aa965
lea ecx, [ebp - 0xfa4]
push ecx
mov ecx, dword [ebp - 0x38]
add ecx, 0x74
call fcn.1003b850
nop
mov edx, dword [ebp - 0x38]
movzx eax, byte [edx + 0x69]
test eax, eax
je 0x100aa97c
mov dword [ebp - 0xafc], 0xf
jmp 0x100aa986
mov dword [ebp - 0xafc], 0
mov ecx, dword [ebp - 0x38]
mov edx, dword [ebp - 0xafc]
mov dword [ecx + 0xa8], edx
mov eax, dword [ebp - 0x38]
mov ecx, dword [eax + 0xa8]
add ecx, 0x14
mov dword [ebp - 0xaf8], ecx
mov edx, dword [ebp - 0x38]
mov eax, dword [ebp - 0xaf8]
mov dword [edx + 0x10], eax
mov ecx, dword [ebp - 0x38]
mov edx, dword [ebp - 0xaf8]
mov dword [ecx + 0x14], edx
lea eax, [ebp - 0xf44]
mov dword [ebp - 0xaf4], eax
mov ecx, dword [ebp - 0xaf4]
mov edx, dword [ecx]
mov dword [ebp - 0xeac], edx
mov eax, dword [ebp - 0xeac]
mov dword [ebp - 0xeb0], eax
mov ecx, dword [ebp - 0xeb0]
mov dword [ebp - 0xeb4], ecx
mov edx, dword [ebp - 0xeb4]
mov dword [ebp - 0x930], edx
mov eax, dword [ebp - 0xaf4]
mov ecx, dword [eax + 4]
mov dword [ebp - 0xed4], ecx
mov edx, dword [ebp - 0xed4]
mov dword [ebp - 0xed8], edx
mov eax, dword [ebp - 0xed8]
mov dword [ebp - 0xedc], eax
mov ecx, dword [ebp - 0xedc]
mov dword [ebp - 0xee0], ecx
jmp 0x100aaa41
mov edx, dword [ebp - 0x930]
add edx, 0x18
mov dword [ebp - 0x930], edx
mov eax, dword [ebp - 0x930]
cmp eax, dword [ebp - 0xee0]
je 0x100aaa7f
mov ecx, dword [ebp - 0x930]
mov dword [ebp - 0xee4], ecx
mov edx, dword [ebp - 0x38]
add edx, 0x8c
mov dword [ebp - 0xee8], edx
mov eax, dword [ebp - 0xee4]
push eax
mov ecx, dword [ebp - 0xee8]
call fcn.10080760
nop
jmp 0x100aaa32
lea ecx, [ebp - 0xf38]
mov dword [ebp - 0xae8], ecx
mov edx, dword [ebp - 0xae8]
mov eax, dword [edx]
mov dword [ebp - 0xeec], eax
mov ecx, dword [ebp - 0xeec]
mov dword [ebp - 0xef0], ecx
mov edx, dword [ebp - 0xef0]
mov dword [ebp - 0xef4], edx
mov eax, dword [ebp - 0xef4]
mov dword [ebp - 0x934], eax
mov ecx, dword [ebp - 0xae8]
mov edx, dword [ecx + 4]
mov dword [ebp - 0xef8], edx
mov eax, dword [ebp - 0xef8]
mov dword [ebp - 0xefc], eax
mov ecx, dword [ebp - 0xefc]
mov dword [ebp - 0xf00], ecx
mov edx, dword [ebp - 0xf00]
mov dword [ebp - 0xf04], edx
jmp 0x100aab01
mov eax, dword [ebp - 0x934]
add eax, 4
mov dword [ebp - 0x934], eax
mov ecx, dword [ebp - 0x934]
cmp ecx, dword [ebp - 0xf04]
je 0x100aac84
mov edx, dword [ebp - 0x934]
mov dword [ebp - 0xf08], edx
mov eax, dword [ebp - 0xf08]
mov ecx, dword [eax]
mov dword [ebp - 0x18], ecx
mov edx, dword [ebp - 0x38]
add edx, 0x9c
mov dword [ebp - 0xf0c], edx
lea eax, [ebp - 0xf6c]
push eax
mov ecx, dword [ebp - 0xf0c]
call fcn.100307b0
mov ecx, dword [eax]
mov dword [ebp - 0xb08], ecx
mov edx, dword [ebp - 0x38]
add edx, 0x9c
mov dword [ebp - 0xb04], edx
lea eax, [ebp - 0xf70]
push eax
mov ecx, dword [ebp - 0xb04]
call fcn.100307f0
mov ecx, dword [eax]
mov dword [ebp - 0xb0c], ecx
lea edx, [ebp - 0x18]
push edx
mov eax, dword [ebp - 0xb08]
push eax
mov ecx, dword [ebp - 0xb0c]
push ecx
lea edx, [ebp - 0xf74]
push edx
call fcn.10031d70
add esp, 0x10
mov dword [ebp - 0xb14], eax
mov eax, dword [ebp - 0x38]
add eax, 0x9c
mov dword [ebp - 0xb10], eax
lea ecx, [ebp - 0xf60]
push ecx
mov ecx, dword [ebp - 0xb10]
call fcn.100307b0
mov dword [ebp - 0xb18], eax
mov edx, dword [ebp - 0xb14]
mov eax, dword [ebp - 0xb18]
mov ecx, dword [edx]
cmp ecx, dword [eax]
jne 0x100aabe7
mov dword [ebp - 0xaf0], 1
jmp 0x100aabf1
mov dword [ebp - 0xaf0], 0
mov dl, byte [ebp - 0xaf0]
mov byte [ebp - 0x8ab], dl
mov al, byte [ebp - 0x8ab]
mov byte [ebp - 0x8ac], al
mov ecx, dword [ebp - 0x38]
add ecx, 0x8c
mov dword [ebp - 0xaec], ecx
mov edx, dword [ebp - 0xaec]
mov eax, dword [ebp - 0xaec]
mov ecx, dword [edx + 4]
sub ecx, dword [eax]
mov eax, ecx
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0xb1c], eax
mov edx, dword [ebp - 0xb1c]
cmp dword [ebp - 0x18], edx
jae 0x100aac62
mov eax, dword [ebp - 0x38]
add eax, 0x9c
mov dword [ebp - 0xb20], eax
lea ecx, [ebp - 0x18]
push ecx
mov ecx, dword [ebp - 0xb20]
call fcn.1002a740
nop
movzx edx, byte [ebp - 0x8ac]
test edx, edx
je 0x100aac7f
mov eax, dword [ebp - 0x38]
cmp dword [eax + 0x64], 0
je 0x100aac7f
mov ecx, dword [ebp - 0x38]
mov edx, dword [ecx + 0x64]
call edx
nop
jmp 0x100aaaf2
mov byte [ebp - 4], 8
lea ecx, [ebp - 0xf38]
call fcn.100291e0
nop
mov byte [ebp - 4], 7
lea ecx, [ebp - 0xfa4]
call fcn.10029670
nop
mov byte [ebp - 4], 6
lea ecx, [ebp - 0xfbc]
call fcn.10029670
nop
mov byte [ebp - 4], 5
lea ecx, [ebp - 0xf44]
call fcn.10030d30
nop
mov dword [ebp - 4], 0xffffffff
push fcn.10028ae0
push 5
push 0x18
lea eax, [ebp - 0x1130]
push eax
call fcn.1012d1c5
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x30
mov dword [ebp - 0x1c], ecx
mov edx, dword [ebp - 0x1c]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x1c]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x1c]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x1c]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x1c]
mov edx, dword [ebp - 0x34]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x34]
add ecx, 0x18
mov dword [ebp - 0xb24], ecx
lea edx, [ebp - 0x1c]
push edx
mov ecx, dword [ebp - 0xb24]
call fcn.1002a740
nop
mov eax, dword [ebp - 0x34]
add eax, 0x214
mov dword [ebp - 0xa6c], eax
push str.min_dmg_ind
lea ecx, [ebp - 0xfec]
call fcn.10028b00
mov dword [ebp - 4], 0xa
push str.min_dmg_bind
lea ecx, [ebp - 0xfd4]
call fcn.10028b00
mov byte [ebp - 4], 0xb
lea ecx, [ebp - 0xfd4]
push ecx
mov ecx, dword [ebp - 0xa6c]
add ecx, 0x74
call fcn.1003b850
lea edx, [ebp - 0xfec]
push edx
mov ecx, dword [ebp - 0xa6c]
add ecx, 0x38
call fcn.1003b850
mov eax, dword [ebp - 0xa6c]
mov dword [eax + 0x70], 0xffffffff
mov byte [ebp - 4], 0xa
lea ecx, [ebp - 0xfd4]
call fcn.10029670
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0xfec]
call fcn.10029670
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x214
mov dword [ebp - 0xb28], ecx
mov edx, dword [ebp - 0xb28]
mov dword [edx + 0x90], 0x10038c70
mov eax, dword [ebp - 0x34]
add eax, 0x214
mov dword [ebp - 0x20], eax
mov ecx, dword [ebp - 0x20]
mov dword [ecx + 0x18], 0
mov edx, dword [ebp - 0x20]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x20]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x20]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x20]
mov ecx, dword [ebp - 0x34]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x34]
add eax, 0x18
mov dword [ebp - 0xb2c], eax
lea ecx, [ebp - 0x20]
push ecx
mov ecx, dword [ebp - 0xb2c]
call fcn.1002a740
nop
mov edx, dword [ebp - 0x34]
add edx, 0x2a8
mov dword [ebp - 0xa70], edx
push str.baim_ind
lea ecx, [ebp - 0x101c]
call fcn.10028b00
mov dword [ebp - 4], 0xc
push str.baim_bind
lea ecx, [ebp - 0x1004]
call fcn.10028b00
mov byte [ebp - 4], 0xd
lea eax, [ebp - 0x1004]
push eax
mov ecx, dword [ebp - 0xa70]
add ecx, 0x74
call fcn.1003b850
lea ecx, [ebp - 0x101c]
push ecx
mov ecx, dword [ebp - 0xa70]
add ecx, 0x38
call fcn.1003b850
mov edx, dword [ebp - 0xa70]
mov dword [edx + 0x70], 0xffffffff
mov byte [ebp - 4], 0xc
lea ecx, [ebp - 0x1004]
call fcn.10029670
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x101c]
call fcn.10029670
nop
mov eax, dword [ebp - 0x34]
add eax, 0x2a8
mov dword [ebp - 0xb30], eax
mov ecx, dword [ebp - 0xb30]
mov dword [ecx + 0x90], 0x10038ca0
mov edx, dword [ebp - 0x34]
add edx, 0x2a8
mov dword [ebp - 0x24], edx
mov eax, dword [ebp - 0x24]
mov dword [eax + 0x18], 0
mov ecx, dword [ebp - 0x24]
imul edx, dword [ecx + 0x18], 0xeb
add edx, 0x14
mov eax, dword [ebp - 0x24]
mov dword [eax + 4], edx
mov ecx, dword [ebp - 0x24]
mov dword [ecx + 0xc], 0xaf
mov edx, dword [ebp - 0x24]
mov eax, dword [ebp - 0x34]
mov ecx, dword [eax + 0x2c]
mov dword [edx + 0x1c], ecx
mov edx, dword [ebp - 0x34]
add edx, 0x18
mov dword [ebp - 0xb34], edx
lea eax, [ebp - 0x24]
push eax
mov ecx, dword [ebp - 0xb34]
call fcn.1002a740
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x33c
mov dword [ebp - 0xa9c], ecx
push str.ping_ind
lea ecx, [ebp - 0x104c]
call fcn.10028b00
mov dword [ebp - 4], 0xe
push str.ping_bind
lea ecx, [ebp - 0x1034]
call fcn.10028b00
mov byte [ebp - 4], 0xf
lea edx, [ebp - 0x1034]
push edx
mov ecx, dword [ebp - 0xa9c]
add ecx, 0x74
call fcn.1003b850
lea eax, [ebp - 0x104c]
push eax
mov ecx, dword [ebp - 0xa9c]
add ecx, 0x38
call fcn.1003b850
mov ecx, dword [ebp - 0xa9c]
mov dword [ecx + 0x70], 0xffffffff
mov byte [ebp - 4], 0xe
lea ecx, [ebp - 0x1034]
call fcn.10029670
nop
mov dword [ebp - 4], 0xffffffff
lea ecx, [ebp - 0x104c]
call fcn.10029670
nop
mov edx, dword [ebp - 0x34]
add edx, 0x33c
mov dword [ebp - 0xb38], edx
mov eax, dword [ebp - 0xb38]
mov dword [eax + 0x90], 0x10038cd0
mov ecx, dword [ebp - 0x34]
add ecx, 0x33c
mov dword [ebp - 0x28], ecx
mov edx, dword [ebp - 0x28]
mov dword [edx + 0x18], 0
mov eax, dword [ebp - 0x28]
imul ecx, dword [eax + 0x18], 0xeb
add ecx, 0x14
mov edx, dword [ebp - 0x28]
mov dword [edx + 4], ecx
mov eax, dword [ebp - 0x28]
mov dword [eax + 0xc], 0xaf
mov ecx, dword [ebp - 0x28]
mov edx, dword [ebp - 0x34]
mov eax, dword [edx + 0x2c]
mov dword [ecx + 0x1c], eax
mov ecx, dword [ebp - 0x34]
add ecx, 0x18
mov dword [ebp - 0xb3c], ecx
lea edx, [ebp - 0x28]
push edx
mov ecx, dword [ebp - 0xb3c]
call fcn.1002a740
nop
mov eax, dword [ebp - 0x34]
add eax, 0x3d0
mov dword [ebp - 0x3c], eax
lea ecx, [ebp - 0xa65]
mov dword [ebp - 0xb40], ecx
mov edx, dword [ebp - 0xb40]
mov dword [ebp - 0xc88], edx
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.verdana]
mov byte [ebp - 0x8b0], dl
movsx eax, byte [ebp - 0x8b0]
xor eax, 0xa
mov byte [ebp - 0x8b1], al
mov cl, byte [ebp - 0x8b1]
mov byte [ebp - 0x97c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x8b8], al
movsx ecx, byte [ebp - 0x8b8]
xor ecx, 0xa
mov byte [ebp - 0x8b9], cl
mov dl, byte [ebp - 0x8b9]
mov byte [ebp - 0x97b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.verdana]
mov byte [ebp - 0x8c0], cl
movsx edx, byte [ebp - 0x8c0]
xor edx, 0xa
mov byte [ebp - 0x8c1], dl
mov al, byte [ebp - 0x8c1]
mov byte [ebp - 0x97a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x8c8], al
movsx ecx, byte [ebp - 0x8c8]
xor ecx, 0xa
mov byte [ebp - 0x8c9], cl
mov dl, byte [ebp - 0x8c9]
mov byte [ebp - 0x979], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.verdana]
mov byte [ebp - 0x8d0], cl
movsx edx, byte [ebp - 0x8d0]
xor edx, 0xa
mov byte [ebp - 0x41], dl
mov al, byte [ebp - 0x41]
mov byte [ebp - 0x978], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x48], al
movsx ecx, byte [ebp - 0x48]
xor ecx, 0xa
mov byte [ebp - 0x49], cl
mov dl, byte [ebp - 0x49]
mov byte [ebp - 0x977], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.verdana]
mov byte [ebp - 0x50], dl
movsx eax, byte [ebp - 0x50]
xor eax, 0xa
mov byte [ebp - 0x51], al
mov cl, byte [ebp - 0x51]
mov byte [ebp - 0x976], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.verdana]
mov byte [ebp - 0x58], cl
movsx edx, byte [ebp - 0x58]
xor edx, 0xa
mov byte [ebp - 0x59], dl
mov al, byte [ebp - 0x59]
mov byte [ebp - 0x975], al
lea ecx, [ebp - 0x97c]
mov dword [ebp - 0xb44], ecx
mov edx, dword [ebp - 0xb44]
mov dword [ebp - 0xa74], edx
mov dword [ebp - 0x8dc], 0
jmp 0x100ab20b
mov eax, dword [ebp - 0x8dc]
add eax, 1
mov dword [ebp - 0x8dc], eax
cmp dword [ebp - 0x8dc], 8
jae 0x100ab278
mov ecx, dword [ebp - 0xa74]
mov dword [ebp - 0xb48], ecx
mov edx, dword [ebp - 0xb48]
add edx, dword [ebp - 0x8dc]
mov dword [ebp - 0xb4c], edx
mov eax, dword [ebp - 0xb4c]
mov cl, byte [eax]
mov byte [ebp - 0x60], cl
movsx edx, byte [ebp - 0x60]
xor edx, 0xa
mov byte [ebp - 0x61], dl
mov al, byte [ebp - 0x61]
mov byte [ebp - 0x62], al
mov ecx, dword [ebp - 0xa74]
mov dword [ebp - 0xb50], ecx
mov edx, dword [ebp - 0xb50]
add edx, dword [ebp - 0x8dc]
mov dword [ebp - 0xb54], edx
mov eax, dword [ebp - 0xb54]
mov cl, byte [ebp - 0x62]
mov byte [eax], cl
jmp 0x100ab1fc
mov edx, dword [ebp - 0xa74]
mov dword [ebp - 0xb58], edx
mov eax, dword [ebp - 0xb58]
mov dword [ebp - 0xb5c], eax
mov ecx, dword [ebp - 0xb5c]
mov dword [ebp - 0xb60], ecx
mov edx, dword [ebp - 0xb60]
push edx
lea ecx, [ebp - 0x1308]
call fcn.10028b00
mov dword [ebp - 4], 0x10
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x68], dl
movsx eax, byte [ebp - 0x68]
xor eax, 0xa
mov byte [ebp - 0x69], al
mov cl, byte [ebp - 0x69]
mov byte [ebp - 0x9f4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x70], al
movsx ecx, byte [ebp - 0x70]
xor ecx, 0xa
mov byte [ebp - 0x71], cl
mov dl, byte [ebp - 0x71]
mov byte [ebp - 0x9f3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x78], cl
movsx edx, byte [ebp - 0x78]
xor edx, 0xa
mov byte [ebp - 0x79], dl
mov al, byte [ebp - 0x79]
mov byte [ebp - 0x9f2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x80], al
movsx ecx, byte [ebp - 0x80]
xor ecx, 0xa
mov byte [ebp - 0x81], cl
mov dl, byte [ebp - 0x81]
mov byte [ebp - 0x9f1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x88], cl
movsx edx, byte [ebp - 0x88]
xor edx, 0xa
mov byte [ebp - 0x89], dl
mov al, byte [ebp - 0x89]
mov byte [ebp - 0x9f0], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x90], al
movsx ecx, byte [ebp - 0x90]
xor ecx, 0xa
mov byte [ebp - 0x91], cl
mov dl, byte [ebp - 0x91]
mov byte [ebp - 0x9ef], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x98], dl
movsx eax, byte [ebp - 0x98]
xor eax, 0xa
mov byte [ebp - 0x99], al
mov cl, byte [ebp - 0x99]
mov byte [ebp - 0x9ee], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0xa0], cl
movsx edx, byte [ebp - 0xa0]
xor edx, 0xa
mov byte [ebp - 0xa1], dl
mov al, byte [ebp - 0xa1]
mov byte [ebp - 0x9ed], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0xa8], dl
movsx eax, byte [ebp - 0xa8]
xor eax, 0xa
mov byte [ebp - 0xa9], al
mov cl, byte [ebp - 0xa9]
mov byte [ebp - 0x9ec], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0xb0], cl
movsx edx, byte [ebp - 0xb0]
xor edx, 0xa
mov byte [ebp - 0xb1], dl
mov al, byte [ebp - 0xb1]
mov byte [ebp - 0x9eb], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0xb8], al
movsx ecx, byte [ebp - 0xb8]
xor ecx, 0xa
mov byte [ebp - 0xb9], cl
mov dl, byte [ebp - 0xb9]
mov byte [ebp - 0x9ea], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0xc0], dl
movsx eax, byte [ebp - 0xc0]
xor eax, 0xa
mov byte [ebp - 0xc1], al
mov cl, byte [ebp - 0xc1]
mov byte [ebp - 0x9e9], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0xc8], cl
movsx edx, byte [ebp - 0xc8]
xor edx, 0xa
mov byte [ebp - 0xc9], dl
mov al, byte [ebp - 0xc9]
mov byte [ebp - 0x9e8], al
lea ecx, [ebp - 0x9f4]
mov dword [ebp - 0xb64], ecx
mov edx, dword [ebp - 0xb64]
mov dword [ebp - 0xad0], edx
mov dword [ebp - 0x8e0], 0
jmp 0x100ab52d
mov eax, dword [ebp - 0x8e0]
add eax, 1
mov dword [ebp - 0x8e0], eax
cmp dword [ebp - 0x8e0], 0xd
jae 0x100ab5af
mov ecx, dword [ebp - 0xad0]
mov dword [ebp - 0xb68], ecx
mov edx, dword [ebp - 0xb68]
add edx, dword [ebp - 0x8e0]
mov dword [ebp - 0xb6c], edx
mov eax, dword [ebp - 0xb6c]
mov cl, byte [eax]
mov byte [ebp - 0xd0], cl
movsx edx, byte [ebp - 0xd0]
xor edx, 0xa
mov byte [ebp - 0xd1], dl
mov al, byte [ebp - 0xd1]
mov byte [ebp - 0xd2], al
mov ecx, dword [ebp - 0xad0]
mov dword [ebp - 0xb70], ecx
mov edx, dword [ebp - 0xb70]
add edx, dword [ebp - 0x8e0]
mov dword [ebp - 0xb74], edx
mov eax, dword [ebp - 0xb74]
mov cl, byte [ebp - 0xd2]
mov byte [eax], cl
jmp 0x100ab51e
mov edx, dword [ebp - 0xad0]
mov dword [ebp - 0xb78], edx
mov eax, dword [ebp - 0xb78]
mov dword [ebp - 0xb7c], eax
mov ecx, dword [ebp - 0xb7c]
mov dword [ebp - 0xb80], ecx
mov edx, dword [ebp - 0xb80]
push edx
lea ecx, [ebp - 0x12f0]
call fcn.10028b00
mov byte [ebp - 4], 0x11
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.tahoma]
mov byte [ebp - 0xd8], dl
movsx eax, byte [ebp - 0xd8]
xor eax, 0xa
mov byte [ebp - 0xd9], al
mov cl, byte [ebp - 0xd9]
mov byte [ebp - 0x954], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.tahoma]
mov byte [ebp - 0xe0], al
movsx ecx, byte [ebp - 0xe0]
xor ecx, 0xa
mov byte [ebp - 0xe1], cl
mov dl, byte [ebp - 0xe1]
mov byte [ebp - 0x953], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.tahoma]
mov byte [ebp - 0xe8], cl
movsx edx, byte [ebp - 0xe8]
xor edx, 0xa
mov byte [ebp - 0xe9], dl
mov al, byte [ebp - 0xe9]
mov byte [ebp - 0x952], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.tahoma]
mov byte [ebp - 0xf0], al
movsx ecx, byte [ebp - 0xf0]
xor ecx, 0xa
mov byte [ebp - 0xf1], cl
mov dl, byte [ebp - 0xf1]
mov byte [ebp - 0x951], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.tahoma]
mov byte [ebp - 0xf8], cl
movsx edx, byte [ebp - 0xf8]
xor edx, 0xa
mov byte [ebp - 0xf9], dl
mov al, byte [ebp - 0xf9]
mov byte [ebp - 0x950], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.tahoma]
mov byte [ebp - 0x100], al
movsx ecx, byte [ebp - 0x100]
xor ecx, 0xa
mov byte [ebp - 0x101], cl
mov dl, byte [ebp - 0x101]
mov byte [ebp - 0x94f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.tahoma]
mov byte [ebp - 0x108], dl
movsx eax, byte [ebp - 0x108]
xor eax, 0xa
mov byte [ebp - 0x109], al
mov cl, byte [ebp - 0x109]
mov byte [ebp - 0x94e], cl
lea edx, [ebp - 0x954]
mov dword [ebp - 0xb84], edx
mov eax, dword [ebp - 0xb84]
mov dword [ebp - 0xac0], eax
mov dword [ebp - 0x8e4], 0
jmp 0x100ab76b
mov ecx, dword [ebp - 0x8e4]
add ecx, 1
mov dword [ebp - 0x8e4], ecx
cmp dword [ebp - 0x8e4], 7
jae 0x100ab7ed
mov edx, dword [ebp - 0xac0]
mov dword [ebp - 0xb88], edx
mov eax, dword [ebp - 0xb88]
add eax, dword [ebp - 0x8e4]
mov dword [ebp - 0xb8c], eax
mov ecx, dword [ebp - 0xb8c]
mov dl, byte [ecx]
mov byte [ebp - 0x110], dl
movsx eax, byte [ebp - 0x110]
xor eax, 0xa
mov byte [ebp - 0x111], al
mov cl, byte [ebp - 0x111]
mov byte [ebp - 0x112], cl
mov edx, dword [ebp - 0xac0]
mov dword [ebp - 0xb90], edx
mov eax, dword [ebp - 0xb90]
add eax, dword [ebp - 0x8e4]
mov dword [ebp - 0xb94], eax
mov ecx, dword [ebp - 0xb94]
mov dl, byte [ebp - 0x112]
mov byte [ecx], dl
jmp 0x100ab75c
mov eax, dword [ebp - 0xac0]
mov dword [ebp - 0xb98], eax
mov ecx, dword [ebp - 0xb98]
mov dword [ebp - 0xb9c], ecx
mov edx, dword [ebp - 0xb9c]
mov dword [ebp - 0xba0], edx
mov eax, dword [ebp - 0xba0]
push eax
lea ecx, [ebp - 0x12d8]
call fcn.10028b00
mov byte [ebp - 4], 0x12
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x118], al
movsx ecx, byte [ebp - 0x118]
xor ecx, 0xa
mov byte [ebp - 0x119], cl
mov dl, byte [ebp - 0x119]
mov byte [ebp - 0xa34], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x120], cl
movsx edx, byte [ebp - 0x120]
xor edx, 0xa
mov byte [ebp - 0x121], dl
mov al, byte [ebp - 0x121]
mov byte [ebp - 0xa33], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x128], dl
movsx eax, byte [ebp - 0x128]
xor eax, 0xa
mov byte [ebp - 0x129], al
mov cl, byte [ebp - 0x129]
mov byte [ebp - 0xa32], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x130], cl
movsx edx, byte [ebp - 0x130]
xor edx, 0xa
mov byte [ebp - 0x131], dl
mov al, byte [ebp - 0x131]
mov byte [ebp - 0xa31], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x138], dl
movsx eax, byte [ebp - 0x138]
xor eax, 0xa
mov byte [ebp - 0x139], al
mov cl, byte [ebp - 0x139]
mov byte [ebp - 0xa30], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x140], cl
movsx edx, byte [ebp - 0x140]
xor edx, 0xa
mov byte [ebp - 0x141], dl
mov al, byte [ebp - 0x141]
mov byte [ebp - 0xa2f], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x148], al
movsx ecx, byte [ebp - 0x148]
xor ecx, 0xa
mov byte [ebp - 0x149], cl
mov dl, byte [ebp - 0x149]
mov byte [ebp - 0xa2e], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x150], dl
movsx eax, byte [ebp - 0x150]
xor eax, 0xa
mov byte [ebp - 0x151], al
mov cl, byte [ebp - 0x151]
mov byte [ebp - 0xa2d], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x158], al
movsx ecx, byte [ebp - 0x158]
xor ecx, 0xa
mov byte [ebp - 0x159], cl
mov dl, byte [ebp - 0x159]
mov byte [ebp - 0xa2c], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x160], dl
movsx eax, byte [ebp - 0x160]
xor eax, 0xa
mov byte [ebp - 0x161], al
mov cl, byte [ebp - 0x161]
mov byte [ebp - 0xa2b], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x168], cl
movsx edx, byte [ebp - 0x168]
xor edx, 0xa
mov byte [ebp - 0x169], dl
mov al, byte [ebp - 0x169]
mov byte [ebp - 0xa2a], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x170], al
movsx ecx, byte [ebp - 0x170]
xor ecx, 0xa
mov byte [ebp - 0x171], cl
mov dl, byte [ebp - 0x171]
mov byte [ebp - 0xa29], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x178], dl
movsx eax, byte [ebp - 0x178]
xor eax, 0xa
mov byte [ebp - 0x179], al
mov cl, byte [ebp - 0x179]
mov byte [ebp - 0xa28], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x180], cl
movsx edx, byte [ebp - 0x180]
xor edx, 0xa
mov byte [ebp - 0x181], dl
mov al, byte [ebp - 0x181]
mov byte [ebp - 0xa27], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x188], al
movsx ecx, byte [ebp - 0x188]
xor ecx, 0xa
mov byte [ebp - 0x189], cl
mov dl, byte [ebp - 0x189]
mov byte [ebp - 0xa26], dl
lea eax, [ebp - 0xa34]
mov dword [ebp - 0xba4], eax
mov ecx, dword [ebp - 0xba4]
mov dword [ebp - 0xabc], ecx
mov dword [ebp - 0x8e8], 0
jmp 0x100abb29
mov edx, dword [ebp - 0x8e8]
add edx, 1
mov dword [ebp - 0x8e8], edx
cmp dword [ebp - 0x8e8], 0xf
jae 0x100abbab
mov eax, dword [ebp - 0xabc]
mov dword [ebp - 0xba8], eax
mov ecx, dword [ebp - 0xba8]
add ecx, dword [ebp - 0x8e8]
mov dword [ebp - 0xbac], ecx
mov edx, dword [ebp - 0xbac]
mov al, byte [edx]
mov byte [ebp - 0x190], al
movsx ecx, byte [ebp - 0x190]
xor ecx, 0xa
mov byte [ebp - 0x191], cl
mov dl, byte [ebp - 0x191]
mov byte [ebp - 0x192], dl
mov eax, dword [ebp - 0xabc]
mov dword [ebp - 0xbb0], eax
mov ecx, dword [ebp - 0xbb0]
add ecx, dword [ebp - 0x8e8]
mov dword [ebp - 0xbb4], ecx
mov edx, dword [ebp - 0xbb4]
mov al, byte [ebp - 0x192]
mov byte [edx], al
jmp 0x100abb1a
mov ecx, dword [ebp - 0xabc]
mov dword [ebp - 0xbb8], ecx
mov edx, dword [ebp - 0xbb8]
mov dword [ebp - 0xbbc], edx
mov eax, dword [ebp - 0xbbc]
mov dword [ebp - 0xbc0], eax
mov ecx, dword [ebp - 0xbc0]
push ecx
lea ecx, [ebp - 0x12c0]
call fcn.10028b00
mov byte [ebp - 4], 0x13
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.calibri]
mov byte [ebp - 0x198], cl
movsx edx, byte [ebp - 0x198]
xor edx, 0xa
mov byte [ebp - 0x199], dl
mov al, byte [ebp - 0x199]
mov byte [ebp - 0x974], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x1a0], dl
movsx eax, byte [ebp - 0x1a0]
xor eax, 0xa
mov byte [ebp - 0x1a1], al
mov cl, byte [ebp - 0x1a1]
mov byte [ebp - 0x973], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.calibri]
mov byte [ebp - 0x1a8], al
movsx ecx, byte [ebp - 0x1a8]
xor ecx, 0xa
mov byte [ebp - 0x1a9], cl
mov dl, byte [ebp - 0x1a9]
mov byte [ebp - 0x972], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x1b0], dl
movsx eax, byte [ebp - 0x1b0]
xor eax, 0xa
mov byte [ebp - 0x1b1], al
mov cl, byte [ebp - 0x1b1]
mov byte [ebp - 0x971], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.calibri]
mov byte [ebp - 0x1b8], al
movsx ecx, byte [ebp - 0x1b8]
xor ecx, 0xa
mov byte [ebp - 0x1b9], cl
mov dl, byte [ebp - 0x1b9]
mov byte [ebp - 0x970], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x1c0], dl
movsx eax, byte [ebp - 0x1c0]
xor eax, 0xa
mov byte [ebp - 0x1c1], al
mov cl, byte [ebp - 0x1c1]
mov byte [ebp - 0x96f], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.calibri]
mov byte [ebp - 0x1c8], cl
movsx edx, byte [ebp - 0x1c8]
xor edx, 0xa
mov byte [ebp - 0x1c9], dl
mov al, byte [ebp - 0x1c9]
mov byte [ebp - 0x96e], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.calibri]
mov byte [ebp - 0x1d0], al
movsx ecx, byte [ebp - 0x1d0]
xor ecx, 0xa
mov byte [ebp - 0x1d1], cl
mov dl, byte [ebp - 0x1d1]
mov byte [ebp - 0x96d], dl
lea eax, [ebp - 0x974]
mov dword [ebp - 0xbc4], eax
mov ecx, dword [ebp - 0xbc4]
mov dword [ebp - 0xab8], ecx
mov dword [ebp - 0x8ec], 0
jmp 0x100abd97
mov edx, dword [ebp - 0x8ec]
add edx, 1
mov dword [ebp - 0x8ec], edx
cmp dword [ebp - 0x8ec], 8
jae 0x100abe19
mov eax, dword [ebp - 0xab8]
mov dword [ebp - 0xbc8], eax
mov ecx, dword [ebp - 0xbc8]
add ecx, dword [ebp - 0x8ec]
mov dword [ebp - 0xbcc], ecx
mov edx, dword [ebp - 0xbcc]
mov al, byte [edx]
mov byte [ebp - 0x1d8], al
movsx ecx, byte [ebp - 0x1d8]
xor ecx, 0xa
mov byte [ebp - 0x1d9], cl
mov dl, byte [ebp - 0x1d9]
mov byte [ebp - 0x1da], dl
mov eax, dword [ebp - 0xab8]
mov dword [ebp - 0xbd0], eax
mov ecx, dword [ebp - 0xbd0]
add ecx, dword [ebp - 0x8ec]
mov dword [ebp - 0xbd4], ecx
mov edx, dword [ebp - 0xbd4]
mov al, byte [ebp - 0x1da]
mov byte [edx], al
jmp 0x100abd88
mov ecx, dword [ebp - 0xab8]
mov dword [ebp - 0xbd8], ecx
mov edx, dword [ebp - 0xbd8]
mov dword [ebp - 0xbdc], edx
mov eax, dword [ebp - 0xbdc]
mov dword [ebp - 0xbe0], eax
mov ecx, dword [ebp - 0xbe0]
push ecx
lea ecx, [ebp - 0x12a8]
call fcn.10028b00
mov byte [ebp - 4], 0x14
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x1e0], cl
movsx edx, byte [ebp - 0x1e0]
xor edx, 0xa
mov byte [ebp - 0x1e1], dl
mov al, byte [ebp - 0x1e1]
mov byte [ebp - 0x9a0], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x1e8], dl
movsx eax, byte [ebp - 0x1e8]
xor eax, 0xa
mov byte [ebp - 0x1e9], al
mov cl, byte [ebp - 0x1e9]
mov byte [ebp - 0x99f], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x1f0], al
movsx ecx, byte [ebp - 0x1f0]
xor ecx, 0xa
mov byte [ebp - 0x1f1], cl
mov dl, byte [ebp - 0x1f1]
mov byte [ebp - 0x99e], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x1f8], dl
movsx eax, byte [ebp - 0x1f8]
xor eax, 0xa
mov byte [ebp - 0x1f9], al
mov cl, byte [ebp - 0x1f9]
mov byte [ebp - 0x99d], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x200], al
movsx ecx, byte [ebp - 0x200]
xor ecx, 0xa
mov byte [ebp - 0x201], cl
mov dl, byte [ebp - 0x201]
mov byte [ebp - 0x99c], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x208], dl
movsx eax, byte [ebp - 0x208]
xor eax, 0xa
mov byte [ebp - 0x209], al
mov cl, byte [ebp - 0x209]
mov byte [ebp - 0x99b], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x210], cl
movsx edx, byte [ebp - 0x210]
xor edx, 0xa
mov byte [ebp - 0x211], dl
mov al, byte [ebp - 0x211]
mov byte [ebp - 0x99a], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x218], al
movsx ecx, byte [ebp - 0x218]
xor ecx, 0xa
mov byte [ebp - 0x219], cl
mov dl, byte [ebp - 0x219]
mov byte [ebp - 0x999], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x220], cl
movsx edx, byte [ebp - 0x220]
xor edx, 0xa
mov byte [ebp - 0x221], dl
mov al, byte [ebp - 0x221]
mov byte [ebp - 0x998], al
lea ecx, [ebp - 0x9a0]
mov dword [ebp - 0xbe4], ecx
mov edx, dword [ebp - 0xbe4]
mov dword [ebp - 0xab4], edx
mov dword [ebp - 0x8f0], 0
jmp 0x100ac035
mov eax, dword [ebp - 0x8f0]
add eax, 1
mov dword [ebp - 0x8f0], eax
cmp dword [ebp - 0x8f0], 9
jae 0x100ac0b7
mov ecx, dword [ebp - 0xab4]
mov dword [ebp - 0xbe8], ecx
mov edx, dword [ebp - 0xbe8]
add edx, dword [ebp - 0x8f0]
mov dword [ebp - 0xbec], edx
mov eax, dword [ebp - 0xbec]
mov cl, byte [eax]
mov byte [ebp - 0x228], cl
movsx edx, byte [ebp - 0x228]
xor edx, 0xa
mov byte [ebp - 0x229], dl
mov al, byte [ebp - 0x229]
mov byte [ebp - 0x22a], al
mov ecx, dword [ebp - 0xab4]
mov dword [ebp - 0xbf0], ecx
mov edx, dword [ebp - 0xbf0]
add edx, dword [ebp - 0x8f0]
mov dword [ebp - 0xbf4], edx
mov eax, dword [ebp - 0xbf4]
mov cl, byte [ebp - 0x22a]
mov byte [eax], cl
jmp 0x100ac026
mov edx, dword [ebp - 0xab4]
mov dword [ebp - 0xbf8], edx
mov eax, dword [ebp - 0xbf8]
mov dword [ebp - 0xbfc], eax
mov ecx, dword [ebp - 0xbfc]
mov dword [ebp - 0xc00], ecx
mov edx, dword [ebp - 0xc00]
push edx
lea ecx, [ebp - 0x1290]
call fcn.10028b00
mov byte [ebp - 4], 0x15
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.impact]
mov byte [ebp - 0x230], dl
movsx eax, byte [ebp - 0x230]
xor eax, 0xa
mov byte [ebp - 0x231], al
mov cl, byte [ebp - 0x231]
mov byte [ebp - 0x95c], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.impact]
mov byte [ebp - 0x238], al
movsx ecx, byte [ebp - 0x238]
xor ecx, 0xa
mov byte [ebp - 0x239], cl
mov dl, byte [ebp - 0x239]
mov byte [ebp - 0x95b], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.impact]
mov byte [ebp - 0x240], cl
movsx edx, byte [ebp - 0x240]
xor edx, 0xa
mov byte [ebp - 0x241], dl
mov al, byte [ebp - 0x241]
mov byte [ebp - 0x95a], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.impact]
mov byte [ebp - 0x248], al
movsx ecx, byte [ebp - 0x248]
xor ecx, 0xa
mov byte [ebp - 0x249], cl
mov dl, byte [ebp - 0x249]
mov byte [ebp - 0x959], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.impact]
mov byte [ebp - 0x250], cl
movsx edx, byte [ebp - 0x250]
xor edx, 0xa
mov byte [ebp - 0x251], dl
mov al, byte [ebp - 0x251]
mov byte [ebp - 0x958], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.impact]
mov byte [ebp - 0x258], al
movsx ecx, byte [ebp - 0x258]
xor ecx, 0xa
mov byte [ebp - 0x259], cl
mov dl, byte [ebp - 0x259]
mov byte [ebp - 0x957], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.impact]
mov byte [ebp - 0x260], dl
movsx eax, byte [ebp - 0x260]
xor eax, 0xa
mov byte [ebp - 0x261], al
mov cl, byte [ebp - 0x261]
mov byte [ebp - 0x956], cl
lea edx, [ebp - 0x95c]
mov dword [ebp - 0xc04], edx
mov eax, dword [ebp - 0xc04]
mov dword [ebp - 0xab0], eax
mov dword [ebp - 0x8f4], 0
jmp 0x100ac273
mov ecx, dword [ebp - 0x8f4]
add ecx, 1
mov dword [ebp - 0x8f4], ecx
cmp dword [ebp - 0x8f4], 7
jae 0x100ac2f5
mov edx, dword [ebp - 0xab0]
mov dword [ebp - 0xc08], edx
mov eax, dword [ebp - 0xc08]
add eax, dword [ebp - 0x8f4]
mov dword [ebp - 0xc0c], eax
mov ecx, dword [ebp - 0xc0c]
mov dl, byte [ecx]
mov byte [ebp - 0x268], dl
movsx eax, byte [ebp - 0x268]
xor eax, 0xa
mov byte [ebp - 0x269], al
mov cl, byte [ebp - 0x269]
mov byte [ebp - 0x26a], cl
mov edx, dword [ebp - 0xab0]
mov dword [ebp - 0xc10], edx
mov eax, dword [ebp - 0xc10]
add eax, dword [ebp - 0x8f4]
mov dword [ebp - 0xc14], eax
mov ecx, dword [ebp - 0xc14]
mov dl, byte [ebp - 0x26a]
mov byte [ecx], dl
jmp 0x100ac264
mov eax, dword [ebp - 0xab0]
mov dword [ebp - 0xc18], eax
mov ecx, dword [ebp - 0xc18]
mov dword [ebp - 0xc1c], ecx
mov edx, dword [ebp - 0xc1c]
mov dword [ebp - 0xc20], edx
mov eax, dword [ebp - 0xc20]
push eax
lea ecx, [ebp - 0x1278]
call fcn.10028b00
mov byte [ebp - 4], 0x16
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x270], al
movsx ecx, byte [ebp - 0x270]
xor ecx, 0xa
mov byte [ebp - 0x271], cl
mov dl, byte [ebp - 0x271]
mov byte [ebp - 0xa5c], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x278], cl
movsx edx, byte [ebp - 0x278]
xor edx, 0xa
mov byte [ebp - 0x279], dl
mov al, byte [ebp - 0x279]
mov byte [ebp - 0xa5b], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x280], dl
movsx eax, byte [ebp - 0x280]
xor eax, 0xa
mov byte [ebp - 0x281], al
mov cl, byte [ebp - 0x281]
mov byte [ebp - 0xa5a], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x288], cl
movsx edx, byte [ebp - 0x288]
xor edx, 0xa
mov byte [ebp - 0x289], dl
mov al, byte [ebp - 0x289]
mov byte [ebp - 0xa59], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x290], dl
movsx eax, byte [ebp - 0x290]
xor eax, 0xa
mov byte [ebp - 0x291], al
mov cl, byte [ebp - 0x291]
mov byte [ebp - 0xa58], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x298], cl
movsx edx, byte [ebp - 0x298]
xor edx, 0xa
mov byte [ebp - 0x299], dl
mov al, byte [ebp - 0x299]
mov byte [ebp - 0xa57], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x2a0], al
movsx ecx, byte [ebp - 0x2a0]
xor ecx, 0xa
mov byte [ebp - 0x2a1], cl
mov dl, byte [ebp - 0x2a1]
mov byte [ebp - 0xa56], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x2a8], dl
movsx eax, byte [ebp - 0x2a8]
xor eax, 0xa
mov byte [ebp - 0x2a9], al
mov cl, byte [ebp - 0x2a9]
mov byte [ebp - 0xa55], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x2b0], al
movsx ecx, byte [ebp - 0x2b0]
xor ecx, 0xa
mov byte [ebp - 0x2b1], cl
mov dl, byte [ebp - 0x2b1]
mov byte [ebp - 0xa54], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x2b8], dl
movsx eax, byte [ebp - 0x2b8]
xor eax, 0xa
mov byte [ebp - 0x2b9], al
mov cl, byte [ebp - 0x2b9]
mov byte [ebp - 0xa53], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x2c0], cl
movsx edx, byte [ebp - 0x2c0]
xor edx, 0xa
mov byte [ebp - 0x2c1], dl
mov al, byte [ebp - 0x2c1]
mov byte [ebp - 0xa52], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x2c8], al
movsx ecx, byte [ebp - 0x2c8]
xor ecx, 0xa
mov byte [ebp - 0x2c9], cl
mov dl, byte [ebp - 0x2c9]
mov byte [ebp - 0xa51], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x2d0], dl
movsx eax, byte [ebp - 0x2d0]
xor eax, 0xa
mov byte [ebp - 0x2d1], al
mov cl, byte [ebp - 0x2d1]
mov byte [ebp - 0xa50], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x2d8], cl
movsx edx, byte [ebp - 0x2d8]
xor edx, 0xa
mov byte [ebp - 0x2d9], dl
mov al, byte [ebp - 0x2d9]
mov byte [ebp - 0xa4f], al
mov ecx, 1
imul edx, ecx, 0xe
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x2e0], al
movsx ecx, byte [ebp - 0x2e0]
xor ecx, 0xa
mov byte [ebp - 0x2e1], cl
mov dl, byte [ebp - 0x2e1]
mov byte [ebp - 0xa4e], dl
mov eax, 1
imul ecx, eax, 0xf
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x2e8], dl
movsx eax, byte [ebp - 0x2e8]
xor eax, 0xa
mov byte [ebp - 0x2e9], al
mov cl, byte [ebp - 0x2e9]
mov byte [ebp - 0xa4d], cl
mov edx, 1
shl edx, 4
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x2f0], al
movsx ecx, byte [ebp - 0x2f0]
xor ecx, 0xa
mov byte [ebp - 0x2f1], cl
mov dl, byte [ebp - 0x2f1]
mov byte [ebp - 0xa4c], dl
mov eax, 1
imul ecx, eax, 0x11
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x2f8], dl
movsx eax, byte [ebp - 0x2f8]
xor eax, 0xa
mov byte [ebp - 0x2f9], al
mov cl, byte [ebp - 0x2f9]
mov byte [ebp - 0xa4b], cl
lea edx, [ebp - 0xa5c]
mov dword [ebp - 0xc24], edx
mov eax, dword [ebp - 0xc24]
mov dword [ebp - 0xaac], eax
mov dword [ebp - 0x8f8], 0
jmp 0x100ac6c1
mov ecx, dword [ebp - 0x8f8]
add ecx, 1
mov dword [ebp - 0x8f8], ecx
cmp dword [ebp - 0x8f8], 0x12
jae 0x100ac743
mov edx, dword [ebp - 0xaac]
mov dword [ebp - 0xc28], edx
mov eax, dword [ebp - 0xc28]
add eax, dword [ebp - 0x8f8]
mov dword [ebp - 0xc2c], eax
mov ecx, dword [ebp - 0xc2c]
mov dl, byte [ecx]
mov byte [ebp - 0x300], dl
movsx eax, byte [ebp - 0x300]
xor eax, 0xa
mov byte [ebp - 0x301], al
mov cl, byte [ebp - 0x301]
mov byte [ebp - 0x302], cl
mov edx, dword [ebp - 0xaac]
mov dword [ebp - 0xc30], edx
mov eax, dword [ebp - 0xc30]
add eax, dword [ebp - 0x8f8]
mov dword [ebp - 0xc34], eax
mov ecx, dword [ebp - 0xc34]
mov dl, byte [ebp - 0x302]
mov byte [ecx], dl
jmp 0x100ac6b2
mov eax, dword [ebp - 0xaac]
mov dword [ebp - 0xc38], eax
mov ecx, dword [ebp - 0xc38]
mov dword [ebp - 0xc3c], ecx
mov edx, dword [ebp - 0xc3c]
mov dword [ebp - 0xc40], edx
mov eax, dword [ebp - 0xc40]
push eax
lea ecx, [ebp - 0x1260]
call fcn.10028b00
mov byte [ebp - 4], 0x17
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x308], al
movsx ecx, byte [ebp - 0x308]
xor ecx, 0xa
mov byte [ebp - 0x309], cl
mov dl, byte [ebp - 0x309]
mov byte [ebp - 0x9c4], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x310], cl
movsx edx, byte [ebp - 0x310]
xor edx, 0xa
mov byte [ebp - 0x311], dl
mov al, byte [ebp - 0x311]
mov byte [ebp - 0x9c3], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x318], dl
movsx eax, byte [ebp - 0x318]
xor eax, 0xa
mov byte [ebp - 0x319], al
mov cl, byte [ebp - 0x319]
mov byte [ebp - 0x9c2], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x320], cl
movsx edx, byte [ebp - 0x320]
xor edx, 0xa
mov byte [ebp - 0x321], dl
mov al, byte [ebp - 0x321]
mov byte [ebp - 0x9c1], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x328], dl
movsx eax, byte [ebp - 0x328]
xor eax, 0xa
mov byte [ebp - 0x329], al
mov cl, byte [ebp - 0x329]
mov byte [ebp - 0x9c0], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x330], cl
movsx edx, byte [ebp - 0x330]
xor edx, 0xa
mov byte [ebp - 0x331], dl
mov al, byte [ebp - 0x331]
mov byte [ebp - 0x9bf], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x338], al
movsx ecx, byte [ebp - 0x338]
xor ecx, 0xa
mov byte [ebp - 0x339], cl
mov dl, byte [ebp - 0x339]
mov byte [ebp - 0x9be], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x340], dl
movsx eax, byte [ebp - 0x340]
xor eax, 0xa
mov byte [ebp - 0x341], al
mov cl, byte [ebp - 0x341]
mov byte [ebp - 0x9bd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x348], al
movsx ecx, byte [ebp - 0x348]
xor ecx, 0xa
mov byte [ebp - 0x349], cl
mov dl, byte [ebp - 0x349]
mov byte [ebp - 0x9bc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x350], dl
movsx eax, byte [ebp - 0x350]
xor eax, 0xa
mov byte [ebp - 0x351], al
mov cl, byte [ebp - 0x351]
mov byte [ebp - 0x9bb], cl
lea edx, [ebp - 0x9c4]
mov dword [ebp - 0xc44], edx
mov eax, dword [ebp - 0xc44]
mov dword [ebp - 0xa98], eax
mov dword [ebp - 0x8fc], 0
jmp 0x100ac98f
mov ecx, dword [ebp - 0x8fc]
add ecx, 1
mov dword [ebp - 0x8fc], ecx
cmp dword [ebp - 0x8fc], 0xa
jae 0x100aca11
mov edx, dword [ebp - 0xa98]
mov dword [ebp - 0xc48], edx
mov eax, dword [ebp - 0xc48]
add eax, dword [ebp - 0x8fc]
mov dword [ebp - 0xc4c], eax
mov ecx, dword [ebp - 0xc4c]
mov dl, byte [ecx]
mov byte [ebp - 0x358], dl
movsx eax, byte [ebp - 0x358]
xor eax, 0xa
mov byte [ebp - 0x359], al
mov cl, byte [ebp - 0x359]
mov byte [ebp - 0x35a], cl
mov edx, dword [ebp - 0xa98]
mov dword [ebp - 0xc50], edx
mov eax, dword [ebp - 0xc50]
add eax, dword [ebp - 0x8fc]
mov dword [ebp - 0xc54], eax
mov ecx, dword [ebp - 0xc54]
mov dl, byte [ebp - 0x35a]
mov byte [ecx], dl
jmp 0x100ac980
mov eax, dword [ebp - 0xa98]
mov dword [ebp - 0xc58], eax
mov ecx, dword [ebp - 0xc58]
mov dword [ebp - 0xc5c], ecx
mov edx, dword [ebp - 0xc5c]
mov dword [ebp - 0xc60], edx
mov eax, dword [ebp - 0xc60]
push eax
lea ecx, [ebp - 0x1248]
call fcn.10028b00
mov byte [ebp - 4], 0x18
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.tahoma_normal]
mov byte [ebp - 0x360], al
movsx ecx, byte [ebp - 0x360]
xor ecx, 0xa
mov byte [ebp - 0x361], cl
mov dl, byte [ebp - 0x361]
mov byte [ebp - 0xa04], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.tahoma_normal]
mov byte [ebp - 0x368], cl
movsx edx, byte [ebp - 0x368]
xor edx, 0xa
mov byte [ebp - 0x369], dl
mov al, byte [ebp - 0x369]
mov byte [ebp - 0xa03], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.tahoma_normal]
mov byte [ebp - 0x370], dl
movsx eax, byte [ebp - 0x370]
xor eax, 0xa
mov byte [ebp - 0x371], al
mov cl, byte [ebp - 0x371]
mov byte [ebp - 0xa02], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.tahoma_normal]
mov byte [ebp - 0x378], cl
movsx edx, byte [ebp - 0x378]
xor edx, 0xa
mov byte [ebp - 0x379], dl
mov al, byte [ebp - 0x379]
mov byte [ebp - 0xa01], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.tahoma_normal]
mov byte [ebp - 0x380], dl
movsx eax, byte [ebp - 0x380]
xor eax, 0xa
mov byte [ebp - 0x381], al
mov cl, byte [ebp - 0x381]
mov byte [ebp - 0xa00], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.tahoma_normal]
mov byte [ebp - 0x388], cl
movsx edx, byte [ebp - 0x388]
xor edx, 0xa
mov byte [ebp - 0x389], dl
mov al, byte [ebp - 0x389]
mov byte [ebp - 0x9ff], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.tahoma_normal]
mov byte [ebp - 0x390], al
movsx ecx, byte [ebp - 0x390]
xor ecx, 0xa
mov byte [ebp - 0x391], cl
mov dl, byte [ebp - 0x391]
mov byte [ebp - 0x9fe], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.tahoma_normal]
mov byte [ebp - 0x398], dl
movsx eax, byte [ebp - 0x398]
xor eax, 0xa
mov byte [ebp - 0x399], al
mov cl, byte [ebp - 0x399]
mov byte [ebp - 0x9fd], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.tahoma_normal]
mov byte [ebp - 0x3a0], al
movsx ecx, byte [ebp - 0x3a0]
xor ecx, 0xa
mov byte [ebp - 0x3a1], cl
mov dl, byte [ebp - 0x3a1]
mov byte [ebp - 0x9fc], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.tahoma_normal]
mov byte [ebp - 0x3a8], dl
movsx eax, byte [ebp - 0x3a8]
xor eax, 0xa
mov byte [ebp - 0x3a9], al
mov cl, byte [ebp - 0x3a9]
mov byte [ebp - 0x9fb], cl
mov edx, 1
imul eax, edx, 0xa
mov cl, byte [eax + str.tahoma_normal]
mov byte [ebp - 0x3b0], cl
movsx edx, byte [ebp - 0x3b0]
xor edx, 0xa
mov byte [ebp - 0x3b1], dl
mov al, byte [ebp - 0x3b1]
mov byte [ebp - 0x9fa], al
mov ecx, 1
imul edx, ecx, 0xb
mov al, byte [edx + str.tahoma_normal]
mov byte [ebp - 0x3b8], al
movsx ecx, byte [ebp - 0x3b8]
xor ecx, 0xa
mov byte [ebp - 0x3b9], cl
mov dl, byte [ebp - 0x3b9]
mov byte [ebp - 0x9f9], dl
mov eax, 1
imul ecx, eax, 0xc
mov dl, byte [ecx + str.tahoma_normal]
mov byte [ebp - 0x3c0], dl
movsx eax, byte [ebp - 0x3c0]
xor eax, 0xa
mov byte [ebp - 0x3c1], al
mov cl, byte [ebp - 0x3c1]
mov byte [ebp - 0x9f8], cl
mov edx, 1
imul eax, edx, 0xd
mov cl, byte [eax + str.tahoma_normal]
mov byte [ebp - 0x3c8], cl
movsx edx, byte [ebp - 0x3c8]
xor edx, 0xa
mov byte [ebp - 0x3c9], dl
mov al, byte [ebp - 0x3c9]
mov byte [ebp - 0x9f7], al
lea ecx, [ebp - 0xa04]
mov dword [ebp - 0xc64], ecx
mov edx, dword [ebp - 0xc64]
mov dword [ebp - 0xaa8], edx
mov dword [ebp - 0x8d4], 0
jmp 0x100acd1d
mov eax, dword [ebp - 0x8d4]
add eax, 1
mov dword [ebp - 0x8d4], eax
cmp dword [ebp - 0x8d4], 0xe
jae 0x100acd9f
mov ecx, dword [ebp - 0xaa8]
mov dword [ebp - 0xc68], ecx
mov edx, dword [ebp - 0xc68]
add edx, dword [ebp - 0x8d4]
mov dword [ebp - 0xc6c], edx
mov eax, dword [ebp - 0xc6c]
mov cl, byte [eax]
mov byte [ebp - 0x3d0], cl
movsx edx, byte [ebp - 0x3d0]
xor edx, 0xa
mov byte [ebp - 0x3d1], dl
mov al, byte [ebp - 0x3d1]
mov byte [ebp - 0x3d2], al
mov ecx, dword [ebp - 0xaa8]
mov dword [ebp - 0xc70], ecx
mov edx, dword [ebp - 0xc70]
add edx, dword [ebp - 0x8d4]
mov dword [ebp - 0xc74], edx
mov eax, dword [ebp - 0xc74]
mov cl, byte [ebp - 0x3d2]
mov byte [eax], cl
jmp 0x100acd0e
mov edx, dword [ebp - 0xaa8]
mov dword [ebp - 0xc78], edx
mov eax, dword [ebp - 0xc78]
mov dword [ebp - 0xc7c], eax
mov ecx, dword [ebp - 0xc7c]
mov dword [ebp - 0xc80], ecx
mov edx, dword [ebp - 0xc80]
push edx
lea ecx, [ebp - 0x1230]
call fcn.10028b00
mov dword [ebp - 4], 0x19
lea eax, [ebp - 0x1308]
mov dword [ebp - 0xf1c], eax
lea ecx, [ebp - 0x1218]
mov dword [ebp - 0xf18], ecx
lea edx, [ebp - 0xf1c]
mov dword [ebp - 0xc84], edx
mov eax, dword [ebp - 0xc84]
mov ecx, dword [eax]
mov edx, dword [eax + 4]
mov dword [ebp - 0xec8], ecx
mov dword [ebp - 0xec4], edx
mov eax, dword [ebp - 0xc88]
push eax
mov ecx, dword [ebp - 0xec4]
push ecx
mov edx, dword [ebp - 0xec8]
push edx
lea ecx, [ebp - 0xf50]
call fcn.100bc9a0
mov byte [ebp - 4], 0x1a
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.namefont]
mov byte [ebp - 0x3d8], dl
movsx eax, byte [ebp - 0x3d8]
xor eax, 0xa
mov byte [ebp - 0x3d9], al
mov cl, byte [ebp - 0x3d9]
mov byte [ebp - 0x994], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.namefont]
mov byte [ebp - 0x3e0], al
movsx ecx, byte [ebp - 0x3e0]
xor ecx, 0xa
mov byte [ebp - 0x3e1], cl
mov dl, byte [ebp - 0x3e1]
mov byte [ebp - 0x993], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.namefont]
mov byte [ebp - 0x3e8], cl
movsx edx, byte [ebp - 0x3e8]
xor edx, 0xa
mov byte [ebp - 0x3e9], dl
mov al, byte [ebp - 0x3e9]
mov byte [ebp - 0x992], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.namefont]
mov byte [ebp - 0x3f0], al
movsx ecx, byte [ebp - 0x3f0]
xor ecx, 0xa
mov byte [ebp - 0x3f1], cl
mov dl, byte [ebp - 0x3f1]
mov byte [ebp - 0x991], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.namefont]
mov byte [ebp - 0x3f8], cl
movsx edx, byte [ebp - 0x3f8]
xor edx, 0xa
mov byte [ebp - 0x3f9], dl
mov al, byte [ebp - 0x3f9]
mov byte [ebp - 0x990], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.namefont]
mov byte [ebp - 0x400], al
movsx ecx, byte [ebp - 0x400]
xor ecx, 0xa
mov byte [ebp - 0x401], cl
mov dl, byte [ebp - 0x401]
mov byte [ebp - 0x98f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.namefont]
mov byte [ebp - 0x408], dl
movsx eax, byte [ebp - 0x408]
xor eax, 0xa
mov byte [ebp - 0x409], al
mov cl, byte [ebp - 0x409]
mov byte [ebp - 0x98e], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.namefont]
mov byte [ebp - 0x410], cl
movsx edx, byte [ebp - 0x410]
xor edx, 0xa
mov byte [ebp - 0x411], dl
mov al, byte [ebp - 0x411]
mov byte [ebp - 0x98d], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.namefont]
mov byte [ebp - 0x418], dl
movsx eax, byte [ebp - 0x418]
xor eax, 0xa
mov byte [ebp - 0x419], al
mov cl, byte [ebp - 0x419]
mov byte [ebp - 0x98c], cl
lea edx, [ebp - 0x994]
mov dword [ebp - 0xc8c], edx
mov eax, dword [ebp - 0xc8c]
mov dword [ebp - 0xaa4], eax
mov dword [ebp - 0x904], 0
jmp 0x100ad01d
mov ecx, dword [ebp - 0x904]
add ecx, 1
mov dword [ebp - 0x904], ecx
cmp dword [ebp - 0x904], 9
jae 0x100ad09f
mov edx, dword [ebp - 0xaa4]
mov dword [ebp - 0xc90], edx
mov eax, dword [ebp - 0xc90]
add eax, dword [ebp - 0x904]
mov dword [ebp - 0xc94], eax
mov ecx, dword [ebp - 0xc94]
mov dl, byte [ecx]
mov byte [ebp - 0x420], dl
movsx eax, byte [ebp - 0x420]
xor eax, 0xa
mov byte [ebp - 0x421], al
mov cl, byte [ebp - 0x421]
mov byte [ebp - 0x422], cl
mov edx, dword [ebp - 0xaa4]
mov dword [ebp - 0xc98], edx
mov eax, dword [ebp - 0xc98]
add eax, dword [ebp - 0x904]
mov dword [ebp - 0xc9c], eax
mov ecx, dword [ebp - 0xc9c]
mov dl, byte [ebp - 0x422]
mov byte [ecx], dl
jmp 0x100ad00e
mov eax, dword [ebp - 0xaa4]
mov dword [ebp - 0xca0], eax
mov ecx, dword [ebp - 0xca0]
mov dword [ebp - 0xca4], ecx
mov edx, dword [ebp - 0xca4]
mov dword [ebp - 0xca8], edx
mov eax, dword [ebp - 0xca8]
push eax
lea ecx, [ebp - 0x107c]
call fcn.10028b00
mov byte [ebp - 4], 0x1b
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.name_font]
mov byte [ebp - 0x428], al
movsx ecx, byte [ebp - 0x428]
xor ecx, 0xa
mov byte [ebp - 0x429], cl
mov dl, byte [ebp - 0x429]
mov byte [ebp - 0x9ac], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.name_font]
mov byte [ebp - 0x430], cl
movsx edx, byte [ebp - 0x430]
xor edx, 0xa
mov byte [ebp - 0x431], dl
mov al, byte [ebp - 0x431]
mov byte [ebp - 0x9ab], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.name_font]
mov byte [ebp - 0x438], dl
movsx eax, byte [ebp - 0x438]
xor eax, 0xa
mov byte [ebp - 0x439], al
mov cl, byte [ebp - 0x439]
mov byte [ebp - 0x9aa], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.name_font]
mov byte [ebp - 0x440], cl
movsx edx, byte [ebp - 0x440]
xor edx, 0xa
mov byte [ebp - 0x441], dl
mov al, byte [ebp - 0x441]
mov byte [ebp - 0x9a9], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.name_font]
mov byte [ebp - 0x448], dl
movsx eax, byte [ebp - 0x448]
xor eax, 0xa
mov byte [ebp - 0x449], al
mov cl, byte [ebp - 0x449]
mov byte [ebp - 0x9a8], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.name_font]
mov byte [ebp - 0x450], cl
movsx edx, byte [ebp - 0x450]
xor edx, 0xa
mov byte [ebp - 0x451], dl
mov al, byte [ebp - 0x451]
mov byte [ebp - 0x9a7], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.name_font]
mov byte [ebp - 0x458], al
movsx ecx, byte [ebp - 0x458]
xor ecx, 0xa
mov byte [ebp - 0x459], cl
mov dl, byte [ebp - 0x459]
mov byte [ebp - 0x9a6], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.name_font]
mov byte [ebp - 0x460], dl
movsx eax, byte [ebp - 0x460]
xor eax, 0xa
mov byte [ebp - 0x461], al
mov cl, byte [ebp - 0x461]
mov byte [ebp - 0x9a5], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.name_font]
mov byte [ebp - 0x468], al
movsx ecx, byte [ebp - 0x468]
xor ecx, 0xa
mov byte [ebp - 0x469], cl
mov dl, byte [ebp - 0x469]
mov byte [ebp - 0x9a4], dl
mov eax, 1
imul ecx, eax, 9
mov dl, byte [ecx + str.name_font]
mov byte [ebp - 0x470], dl
movsx eax, byte [ebp - 0x470]
xor eax, 0xa
mov byte [ebp - 0x471], al
mov cl, byte [ebp - 0x471]
mov byte [ebp - 0x9a3], cl
lea edx, [ebp - 0x9ac]
mov dword [ebp - 0xcac], edx
mov eax, dword [ebp - 0xcac]
mov dword [ebp - 0xaa0], eax
mov dword [ebp - 0x908], 0
jmp 0x100ad2eb
mov ecx, dword [ebp - 0x908]
add ecx, 1
mov dword [ebp - 0x908], ecx
cmp dword [ebp - 0x908], 0xa
jae 0x100ad36d
mov edx, dword [ebp - 0xaa0]
mov dword [ebp - 0xcb0], edx
mov eax, dword [ebp - 0xcb0]
add eax, dword [ebp - 0x908]
mov dword [ebp - 0xcb4], eax
mov ecx, dword [ebp - 0xcb4]
mov dl, byte [ecx]
mov byte [ebp - 0x478], dl
movsx eax, byte [ebp - 0x478]
xor eax, 0xa
mov byte [ebp - 0x479], al
mov cl, byte [ebp - 0x479]
mov byte [ebp - 0x47a], cl
mov edx, dword [ebp - 0xaa0]
mov dword [ebp - 0xcb8], edx
mov eax, dword [ebp - 0xcb8]
add eax, dword [ebp - 0x908]
mov dword [ebp - 0xcbc], eax
mov ecx, dword [ebp - 0xcbc]
mov dl, byte [ebp - 0x47a]
mov byte [ecx], dl
jmp 0x100ad2dc
mov eax, dword [ebp - 0xaa0]
mov dword [ebp - 0xcc0], eax
mov ecx, dword [ebp - 0xcc0]
mov dword [ebp - 0xcc4], ecx
mov edx, dword [ebp - 0xcc4]
mov dword [ebp - 0xcc8], edx
mov eax, dword [ebp - 0xcc8]
push eax
lea ecx, [ebp - 0x1064]
call fcn.10028b00
mov byte [ebp - 4], 0x1c
lea ecx, [ebp - 0x107c]
push ecx
mov ecx, dword [ebp - 0x3c]
add ecx, 0x38
call fcn.1003b850
mov edx, dword [ebp - 0x3c]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x3c]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x100ad3de
lea edx, [ebp - 0x1064]
push edx
mov ecx, dword [ebp - 0x3c]
add ecx, 0x74
call fcn.1003b850
nop
mov eax, dword [ebp - 0x3c]
mov dword [eax + 0xa0], 0
mov ecx, dword [ebp - 0x3c]
mov edx, dword [ecx + 0xa0]
add edx, 0x14
mov dword [ebp - 0xae4], edx
mov eax, dword [ebp - 0x3c]
mov ecx, dword [ebp - 0xae4]
mov dword [eax + 0x10], ecx
mov edx, dword [ebp - 0x3c]
mov eax, dword [ebp - 0xae4]
mov dword [edx + 0x14], eax
lea ecx, [ebp - 0xf50]
mov dword [ebp - 0xae0], ecx
mov edx, dword [ebp - 0xae0]
mov eax, dword [edx]
mov dword [ebp - 0xccc], eax
mov ecx, dword [ebp - 0xccc]
mov dword [ebp - 0xcd0], ecx
mov edx, dword [ebp - 0xcd0]
mov dword [ebp - 0xcd4], edx
mov eax, dword [ebp - 0xcd4]
mov dword [ebp - 0x938], eax
mov ecx, dword [ebp - 0xae0]
mov edx, dword [ecx + 4]
mov dword [ebp - 0xcd8], edx
mov eax, dword [ebp - 0xcd8]
mov dword [ebp - 0xcdc], eax
mov ecx, dword [ebp - 0xcdc]
mov dword [ebp - 0xce0], ecx
mov edx, dword [ebp - 0xce0]
mov dword [ebp - 0xce4], edx
jmp 0x100ad497
mov eax, dword [ebp - 0x938]
add eax, 0x18
mov dword [ebp - 0x938], eax
mov ecx, dword [ebp - 0x938]
cmp ecx, dword [ebp - 0xce4]
je 0x100ad4d4
mov edx, dword [ebp - 0x938]
mov dword [ebp - 0xce8], edx
mov eax, dword [ebp - 0x3c]
add eax, 0x8c
mov dword [ebp - 0xcec], eax
mov ecx, dword [ebp - 0xce8]
push ecx
mov ecx, dword [ebp - 0xcec]
call fcn.10080760
nop
jmp 0x100ad488
mov edx, dword [ebp - 0x3c]
add edx, 0x8c
mov dword [ebp - 0xb00], edx
mov eax, dword [ebp - 0xb00]
mov ecx, dword [ebp - 0xb00]
mov eax, dword [eax + 4]
sub eax, dword [ecx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0xcf0], eax
cmp dword [ebp - 0xcf0], 0
jbe 0x100ad518
mov edx, dword [ebp - 0x3c]
mov dword [edx + 0x9c], 0
mov byte [ebp - 4], 0x1b
lea ecx, [ebp - 0x1064]
call fcn.10029670
nop
mov byte [ebp - 4], 0x1a
lea ecx, [ebp - 0x107c]
call fcn.10029670
nop
mov byte [ebp - 4], 0x19
lea ecx, [ebp - 0xf50]
call fcn.10030d30
nop
mov dword [ebp - 4], 0xffffffff
push fcn.10028ae0
push 0xa
push 0x18
lea eax, [ebp - 0x1308]
push eax
call fcn.1012d1c5
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x3d0
mov dword [ebp - 0xcf4], ecx
mov edx, dword [ebp - 0xcf4]
mov dword [edx + 0x64], 0x100374b0
mov eax, dword [ebp - 0x34]
add eax, 0x3d0
mov dword [ebp - 0x2c], eax
mov ecx, dword [ebp - 0x2c]
mov dword [ecx + 0x18], 1
mov edx, dword [ebp - 0x2c]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x2c]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x2c]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x2c]
mov ecx, dword [ebp - 0x34]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x34]
add eax, 0x18
mov dword [ebp - 0xcf8], eax
lea ecx, [ebp - 0x2c]
push ecx
mov ecx, dword [ebp - 0xcf8]
call fcn.1002a740
nop
mov edx, dword [ebp - 0x34]
add edx, 0x474
mov dword [ebp - 0x40], edx
lea eax, [ebp - 0xa5e]
mov dword [ebp - 0xcfc], eax
mov ecx, dword [ebp - 0xcfc]
mov dword [ebp - 0xe24], ecx
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.verdana]
mov byte [ebp - 0x480], cl
movsx edx, byte [ebp - 0x480]
xor edx, 0xa
mov byte [ebp - 0x481], dl
mov al, byte [ebp - 0x481]
mov byte [ebp - 0x96c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.verdana]
mov byte [ebp - 0x488], dl
movsx eax, byte [ebp - 0x488]
xor eax, 0xa
mov byte [ebp - 0x489], al
mov cl, byte [ebp - 0x489]
mov byte [ebp - 0x96b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x490], al
movsx ecx, byte [ebp - 0x490]
xor ecx, 0xa
mov byte [ebp - 0x491], cl
mov dl, byte [ebp - 0x491]
mov byte [ebp - 0x96a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.verdana]
mov byte [ebp - 0x498], dl
movsx eax, byte [ebp - 0x498]
xor eax, 0xa
mov byte [ebp - 0x499], al
mov cl, byte [ebp - 0x499]
mov byte [ebp - 0x969], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x4a0], al
movsx ecx, byte [ebp - 0x4a0]
xor ecx, 0xa
mov byte [ebp - 0x4a1], cl
mov dl, byte [ebp - 0x4a1]
mov byte [ebp - 0x968], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.verdana]
mov byte [ebp - 0x4a8], dl
movsx eax, byte [ebp - 0x4a8]
xor eax, 0xa
mov byte [ebp - 0x4a9], al
mov cl, byte [ebp - 0x4a9]
mov byte [ebp - 0x967], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.verdana]
mov byte [ebp - 0x4b0], cl
movsx edx, byte [ebp - 0x4b0]
xor edx, 0xa
mov byte [ebp - 0x4b1], dl
mov al, byte [ebp - 0x4b1]
mov byte [ebp - 0x966], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.verdana]
mov byte [ebp - 0x4b8], al
movsx ecx, byte [ebp - 0x4b8]
xor ecx, 0xa
mov byte [ebp - 0x4b9], cl
mov dl, byte [ebp - 0x4b9]
mov byte [ebp - 0x965], dl
lea eax, [ebp - 0x96c]
mov dword [ebp - 0xd00], eax
mov ecx, dword [ebp - 0xd00]
mov dword [ebp - 0xac4], ecx
mov dword [ebp - 0x90c], 0
jmp 0x100ad7b1
mov edx, dword [ebp - 0x90c]
add edx, 1
mov dword [ebp - 0x90c], edx
cmp dword [ebp - 0x90c], 8
jae 0x100ad833
mov eax, dword [ebp - 0xac4]
mov dword [ebp - 0xd04], eax
mov ecx, dword [ebp - 0xd04]
add ecx, dword [ebp - 0x90c]
mov dword [ebp - 0xd08], ecx
mov edx, dword [ebp - 0xd08]
mov al, byte [edx]
mov byte [ebp - 0x4c0], al
movsx ecx, byte [ebp - 0x4c0]
xor ecx, 0xa
mov byte [ebp - 0x4c1], cl
mov dl, byte [ebp - 0x4c1]
mov byte [ebp - 0x4c2], dl
mov eax, dword [ebp - 0xac4]
mov dword [ebp - 0xd0c], eax
mov ecx, dword [ebp - 0xd0c]
add ecx, dword [ebp - 0x90c]
mov dword [ebp - 0xd10], ecx
mov edx, dword [ebp - 0xd10]
mov al, byte [ebp - 0x4c2]
mov byte [edx], al
jmp 0x100ad7a2
mov ecx, dword [ebp - 0xac4]
mov dword [ebp - 0xd14], ecx
mov edx, dword [ebp - 0xd14]
mov dword [ebp - 0xd18], edx
mov eax, dword [ebp - 0xd18]
mov dword [ebp - 0xd1c], eax
mov ecx, dword [ebp - 0xd1c]
push ecx
lea ecx, [ebp - 0x1210]
call fcn.10028b00
mov dword [ebp - 4], 0x1d
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x4c8], cl
movsx edx, byte [ebp - 0x4c8]
xor edx, 0xa
mov byte [ebp - 0x4c9], dl
mov al, byte [ebp - 0x4c9]
mov byte [ebp - 0x9e4], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x4d0], dl
movsx eax, byte [ebp - 0x4d0]
xor eax, 0xa
mov byte [ebp - 0x4d1], al
mov cl, byte [ebp - 0x4d1]
mov byte [ebp - 0x9e3], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x4d8], al
movsx ecx, byte [ebp - 0x4d8]
xor ecx, 0xa
mov byte [ebp - 0x4d9], cl
mov dl, byte [ebp - 0x4d9]
mov byte [ebp - 0x9e2], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x4e0], dl
movsx eax, byte [ebp - 0x4e0]
xor eax, 0xa
mov byte [ebp - 0x4e1], al
mov cl, byte [ebp - 0x4e1]
mov byte [ebp - 0x9e1], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x4e8], al
movsx ecx, byte [ebp - 0x4e8]
xor ecx, 0xa
mov byte [ebp - 0x4e9], cl
mov dl, byte [ebp - 0x4e9]
mov byte [ebp - 0x9e0], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x4f0], dl
movsx eax, byte [ebp - 0x4f0]
xor eax, 0xa
mov byte [ebp - 0x4f1], al
mov cl, byte [ebp - 0x4f1]
mov byte [ebp - 0x9df], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x4f8], cl
movsx edx, byte [ebp - 0x4f8]
xor edx, 0xa
mov byte [ebp - 0x4f9], dl
mov al, byte [ebp - 0x4f9]
mov byte [ebp - 0x9de], al
mov ecx, 1
imul edx, ecx, 7
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x500], al
movsx ecx, byte [ebp - 0x500]
xor ecx, 0xa
mov byte [ebp - 0x501], cl
mov dl, byte [ebp - 0x501]
mov byte [ebp - 0x9dd], dl
mov eax, 1
shl eax, 3
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x508], cl
movsx edx, byte [ebp - 0x508]
xor edx, 0xa
mov byte [ebp - 0x509], dl
mov al, byte [ebp - 0x509]
mov byte [ebp - 0x9dc], al
mov ecx, 1
imul edx, ecx, 9
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x510], al
movsx ecx, byte [ebp - 0x510]
xor ecx, 0xa
mov byte [ebp - 0x511], cl
mov dl, byte [ebp - 0x511]
mov byte [ebp - 0x9db], dl
mov eax, 1
imul ecx, eax, 0xa
mov dl, byte [ecx + str.verdana_bold]
mov byte [ebp - 0x518], dl
movsx eax, byte [ebp - 0x518]
xor eax, 0xa
mov byte [ebp - 0x519], al
mov cl, byte [ebp - 0x519]
mov byte [ebp - 0x9da], cl
mov edx, 1
imul eax, edx, 0xb
mov cl, byte [eax + str.verdana_bold]
mov byte [ebp - 0x520], cl
movsx edx, byte [ebp - 0x520]
xor edx, 0xa
mov byte [ebp - 0x521], dl
mov al, byte [ebp - 0x521]
mov byte [ebp - 0x9d9], al
mov ecx, 1
imul edx, ecx, 0xc
mov al, byte [edx + str.verdana_bold]
mov byte [ebp - 0x528], al
movsx ecx, byte [ebp - 0x528]
xor ecx, 0xa
mov byte [ebp - 0x529], cl
mov dl, byte [ebp - 0x529]
mov byte [ebp - 0x9d8], dl
lea eax, [ebp - 0x9e4]
mov dword [ebp - 0xd20], eax
mov ecx, dword [ebp - 0xd20]
mov dword [ebp - 0xac8], ecx
mov dword [ebp - 0x910], 0
jmp 0x100adb12
mov edx, dword [ebp - 0x910]
add edx, 1
mov dword [ebp - 0x910], edx
cmp dword [ebp - 0x910], 0xd
jae 0x100adb94
mov eax, dword [ebp - 0xac8]
mov dword [ebp - 0xd24], eax
mov ecx, dword [ebp - 0xd24]
add ecx, dword [ebp - 0x910]
mov dword [ebp - 0xd28], ecx
mov edx, dword [ebp - 0xd28]
mov al, byte [edx]
mov byte [ebp - 0x530], al
movsx ecx, byte [ebp - 0x530]
xor ecx, 0xa
mov byte [ebp - 0x531], cl
mov dl, byte [ebp - 0x531]
mov byte [ebp - 0x532], dl
mov eax, dword [ebp - 0xac8]
mov dword [ebp - 0xd2c], eax
mov ecx, dword [ebp - 0xd2c]
add ecx, dword [ebp - 0x910]
mov dword [ebp - 0xd30], ecx
mov edx, dword [ebp - 0xd30]
mov al, byte [ebp - 0x532]
mov byte [edx], al
jmp 0x100adb03
mov ecx, dword [ebp - 0xac8]
mov dword [ebp - 0xd34], ecx
mov edx, dword [ebp - 0xd34]
mov dword [ebp - 0xd38], edx
mov eax, dword [ebp - 0xd38]
mov dword [ebp - 0xd3c], eax
mov ecx, dword [ebp - 0xd3c]
push ecx
lea ecx, [ebp - 0x11f8]
call fcn.10028b00
mov byte [ebp - 4], 0x1e
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.tahoma]
mov byte [ebp - 0x538], cl
movsx edx, byte [ebp - 0x538]
xor edx, 0xa
mov byte [ebp - 0x539], dl
mov al, byte [ebp - 0x539]
mov byte [ebp - 0x94c], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.tahoma]
mov byte [ebp - 0x540], dl
movsx eax, byte [ebp - 0x540]
xor eax, 0xa
mov byte [ebp - 0x541], al
mov cl, byte [ebp - 0x541]
mov byte [ebp - 0x94b], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.tahoma]
mov byte [ebp - 0x548], al
movsx ecx, byte [ebp - 0x548]
xor ecx, 0xa
mov byte [ebp - 0x549], cl
mov dl, byte [ebp - 0x549]
mov byte [ebp - 0x94a], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.tahoma]
mov byte [ebp - 0x550], dl
movsx eax, byte [ebp - 0x550]
xor eax, 0xa
mov byte [ebp - 0x551], al
mov cl, byte [ebp - 0x551]
mov byte [ebp - 0x949], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.tahoma]
mov byte [ebp - 0x558], al
movsx ecx, byte [ebp - 0x558]
xor ecx, 0xa
mov byte [ebp - 0x559], cl
mov dl, byte [ebp - 0x559]
mov byte [ebp - 0x948], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.tahoma]
mov byte [ebp - 0x560], dl
movsx eax, byte [ebp - 0x560]
xor eax, 0xa
mov byte [ebp - 0x561], al
mov cl, byte [ebp - 0x561]
mov byte [ebp - 0x947], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.tahoma]
mov byte [ebp - 0x568], cl
movsx edx, byte [ebp - 0x568]
xor edx, 0xa
mov byte [ebp - 0x569], dl
mov al, byte [ebp - 0x569]
mov byte [ebp - 0x946], al
lea ecx, [ebp - 0x94c]
mov dword [ebp - 0xd40], ecx
mov edx, dword [ebp - 0xd40]
mov dword [ebp - 0xacc], edx
mov dword [ebp - 0x914], 0
jmp 0x100add50
mov eax, dword [ebp - 0x914]
add eax, 1
mov dword [ebp - 0x914], eax
cmp dword [ebp - 0x914], 7
jae 0x100addd2
mov ecx, dword [ebp - 0xacc]
mov dword [ebp - 0xd44], ecx
mov edx, dword [ebp - 0xd44]
add edx, dword [ebp - 0x914]
mov dword [ebp - 0xd48], edx
mov eax, dword [ebp - 0xd48]
mov cl, byte [eax]
mov byte [ebp - 0x570], cl
movsx edx, byte [ebp - 0x570]
xor edx, 0xa
mov byte [ebp - 0x571], dl
mov al, byte [ebp - 0x571]
mov byte [ebp - 0x572], al
mov ecx, dword [ebp - 0xacc]
mov dword [ebp - 0xd4c], ecx
mov edx, dword [ebp - 0xd4c]
add edx, dword [ebp - 0x914]
mov dword [ebp - 0xd50], edx
mov eax, dword [ebp - 0xd50]
mov cl, byte [ebp - 0x572]
mov byte [eax], cl
jmp 0x100add41
mov edx, dword [ebp - 0xacc]
mov dword [ebp - 0xd54], edx
mov eax, dword [ebp - 0xd54]
mov dword [ebp - 0xd58], eax
mov ecx, dword [ebp - 0xd58]
mov dword [ebp - 0xd5c], ecx
mov edx, dword [ebp - 0xd5c]
push edx
lea ecx, [ebp - 0x11e0]
call fcn.10028b00
mov byte [ebp - 4], 0x1f
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x578], dl
movsx eax, byte [ebp - 0x578]
xor eax, 0xa
mov byte [ebp - 0x579], al
mov cl, byte [ebp - 0x579]
mov byte [ebp - 0xa24], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x580], al
movsx ecx, byte [ebp - 0x580]
xor ecx, 0xa
mov byte [ebp - 0x581], cl
mov dl, byte [ebp - 0x581]
mov byte [ebp - 0xa23], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x588], cl
movsx edx, byte [ebp - 0x588]
xor edx, 0xa
mov byte [ebp - 0x589], dl
mov al, byte [ebp - 0x589]
mov byte [ebp - 0xa22], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x590], al
movsx ecx, byte [ebp - 0x590]
xor ecx, 0xa
mov byte [ebp - 0x591], cl
mov dl, byte [ebp - 0x591]
mov byte [ebp - 0xa21], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x598], cl
movsx edx, byte [ebp - 0x598]
xor edx, 0xa
mov byte [ebp - 0x599], dl
mov al, byte [ebp - 0x599]
mov byte [ebp - 0xa20], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x5a0], al
movsx ecx, byte [ebp - 0x5a0]
xor ecx, 0xa
mov byte [ebp - 0x5a1], cl
mov dl, byte [ebp - 0x5a1]
mov byte [ebp - 0xa1f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x5a8], dl
movsx eax, byte [ebp - 0x5a8]
xor eax, 0xa
mov byte [ebp - 0x5a9], al
mov cl, byte [ebp - 0x5a9]
mov byte [ebp - 0xa1e], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x5b0], cl
movsx edx, byte [ebp - 0x5b0]
xor edx, 0xa
mov byte [ebp - 0x5b1], dl
mov al, byte [ebp - 0x5b1]
mov byte [ebp - 0xa1d], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x5b8], dl
movsx eax, byte [ebp - 0x5b8]
xor eax, 0xa
mov byte [ebp - 0x5b9], al
mov cl, byte [ebp - 0x5b9]
mov byte [ebp - 0xa1c], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x5c0], cl
movsx edx, byte [ebp - 0x5c0]
xor edx, 0xa
mov byte [ebp - 0x5c1], dl
mov al, byte [ebp - 0x5c1]
mov byte [ebp - 0xa1b], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x5c8], al
movsx ecx, byte [ebp - 0x5c8]
xor ecx, 0xa
mov byte [ebp - 0x5c9], cl
mov dl, byte [ebp - 0x5c9]
mov byte [ebp - 0xa1a], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x5d0], dl
movsx eax, byte [ebp - 0x5d0]
xor eax, 0xa
mov byte [ebp - 0x5d1], al
mov cl, byte [ebp - 0x5d1]
mov byte [ebp - 0xa19], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.lucida_console]
mov byte [ebp - 0x5d8], cl
movsx edx, byte [ebp - 0x5d8]
xor edx, 0xa
mov byte [ebp - 0x5d9], dl
mov al, byte [ebp - 0x5d9]
mov byte [ebp - 0xa18], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.lucida_console]
mov byte [ebp - 0x5e0], al
movsx ecx, byte [ebp - 0x5e0]
xor ecx, 0xa
mov byte [ebp - 0x5e1], cl
mov dl, byte [ebp - 0x5e1]
mov byte [ebp - 0xa17], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.lucida_console]
mov byte [ebp - 0x5e8], dl
movsx eax, byte [ebp - 0x5e8]
xor eax, 0xa
mov byte [ebp - 0x5e9], al
mov cl, byte [ebp - 0x5e9]
mov byte [ebp - 0xa16], cl
lea edx, [ebp - 0xa24]
mov dword [ebp - 0xd60], edx
mov eax, dword [ebp - 0xd60]
mov dword [ebp - 0xa78], eax
mov dword [ebp - 0x918], 0
jmp 0x100ae10e
mov ecx, dword [ebp - 0x918]
add ecx, 1
mov dword [ebp - 0x918], ecx
cmp dword [ebp - 0x918], 0xf
jae 0x100ae190
mov edx, dword [ebp - 0xa78]
mov dword [ebp - 0xd64], edx
mov eax, dword [ebp - 0xd64]
add eax, dword [ebp - 0x918]
mov dword [ebp - 0xd68], eax
mov ecx, dword [ebp - 0xd68]
mov dl, byte [ecx]
mov byte [ebp - 0x5f0], dl
movsx eax, byte [ebp - 0x5f0]
xor eax, 0xa
mov byte [ebp - 0x5f1], al
mov cl, byte [ebp - 0x5f1]
mov byte [ebp - 0x5f2], cl
mov edx, dword [ebp - 0xa78]
mov dword [ebp - 0xd6c], edx
mov eax, dword [ebp - 0xd6c]
add eax, dword [ebp - 0x918]
mov dword [ebp - 0xd70], eax
mov ecx, dword [ebp - 0xd70]
mov dl, byte [ebp - 0x5f2]
mov byte [ecx], dl
jmp 0x100ae0ff
mov eax, dword [ebp - 0xa78]
mov dword [ebp - 0xd74], eax
mov ecx, dword [ebp - 0xd74]
mov dword [ebp - 0xd78], ecx
mov edx, dword [ebp - 0xd78]
mov dword [ebp - 0xd7c], edx
mov eax, dword [ebp - 0xd7c]
push eax
lea ecx, [ebp - 0x11c8]
call fcn.10028b00
mov byte [ebp - 4], 0x20
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.calibri]
mov byte [ebp - 0x5f8], al
movsx ecx, byte [ebp - 0x5f8]
xor ecx, 0xa
mov byte [ebp - 0x5f9], cl
mov dl, byte [ebp - 0x5f9]
mov byte [ebp - 0x964], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.calibri]
mov byte [ebp - 0x600], cl
movsx edx, byte [ebp - 0x600]
xor edx, 0xa
mov byte [ebp - 0x601], dl
mov al, byte [ebp - 0x601]
mov byte [ebp - 0x963], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x608], dl
movsx eax, byte [ebp - 0x608]
xor eax, 0xa
mov byte [ebp - 0x609], al
mov cl, byte [ebp - 0x609]
mov byte [ebp - 0x962], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.calibri]
mov byte [ebp - 0x610], cl
movsx edx, byte [ebp - 0x610]
xor edx, 0xa
mov byte [ebp - 0x611], dl
mov al, byte [ebp - 0x611]
mov byte [ebp - 0x961], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x618], dl
movsx eax, byte [ebp - 0x618]
xor eax, 0xa
mov byte [ebp - 0x619], al
mov cl, byte [ebp - 0x619]
mov byte [ebp - 0x960], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.calibri]
mov byte [ebp - 0x620], cl
movsx edx, byte [ebp - 0x620]
xor edx, 0xa
mov byte [ebp - 0x621], dl
mov al, byte [ebp - 0x621]
mov byte [ebp - 0x95f], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.calibri]
mov byte [ebp - 0x628], al
movsx ecx, byte [ebp - 0x628]
xor ecx, 0xa
mov byte [ebp - 0x629], cl
mov dl, byte [ebp - 0x629]
mov byte [ebp - 0x95e], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.calibri]
mov byte [ebp - 0x630], dl
movsx eax, byte [ebp - 0x630]
xor eax, 0xa
mov byte [ebp - 0x631], al
mov cl, byte [ebp - 0x631]
mov byte [ebp - 0x95d], cl
lea edx, [ebp - 0x964]
mov dword [ebp - 0xd80], edx
mov eax, dword [ebp - 0xd80]
mov dword [ebp - 0xa7c], eax
mov dword [ebp - 0x91c], 0
jmp 0x100ae37c
mov ecx, dword [ebp - 0x91c]
add ecx, 1
mov dword [ebp - 0x91c], ecx
cmp dword [ebp - 0x91c], 8
jae 0x100ae3fe
mov edx, dword [ebp - 0xa7c]
mov dword [ebp - 0xd84], edx
mov eax, dword [ebp - 0xd84]
add eax, dword [ebp - 0x91c]
mov dword [ebp - 0xd88], eax
mov ecx, dword [ebp - 0xd88]
mov dl, byte [ecx]
mov byte [ebp - 0x638], dl
movsx eax, byte [ebp - 0x638]
xor eax, 0xa
mov byte [ebp - 0x639], al
mov cl, byte [ebp - 0x639]
mov byte [ebp - 0x63a], cl
mov edx, dword [ebp - 0xa7c]
mov dword [ebp - 0xd8c], edx
mov eax, dword [ebp - 0xd8c]
add eax, dword [ebp - 0x91c]
mov dword [ebp - 0xd90], eax
mov ecx, dword [ebp - 0xd90]
mov dl, byte [ebp - 0x63a]
mov byte [ecx], dl
jmp 0x100ae36d
mov eax, dword [ebp - 0xa7c]
mov dword [ebp - 0xd94], eax
mov ecx, dword [ebp - 0xd94]
mov dword [ebp - 0xd98], ecx
mov edx, dword [ebp - 0xd98]
mov dword [ebp - 0xd9c], edx
mov eax, dword [ebp - 0xd9c]
push eax
lea ecx, [ebp - 0x11b0]
call fcn.10028b00
mov byte [ebp - 4], 0x21
mov ecx, 1
imul edx, ecx, 0
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x640], al
movsx ecx, byte [ebp - 0x640]
xor ecx, 0xa
mov byte [ebp - 0x641], cl
mov dl, byte [ebp - 0x641]
mov byte [ebp - 0x988], dl
mov eax, 1
shl eax, 0
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x648], cl
movsx edx, byte [ebp - 0x648]
xor edx, 0xa
mov byte [ebp - 0x649], dl
mov al, byte [ebp - 0x649]
mov byte [ebp - 0x987], al
mov ecx, 1
shl ecx, 1
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x650], dl
movsx eax, byte [ebp - 0x650]
xor eax, 0xa
mov byte [ebp - 0x651], al
mov cl, byte [ebp - 0x651]
mov byte [ebp - 0x986], cl
mov edx, 1
imul eax, edx, 3
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x658], cl
movsx edx, byte [ebp - 0x658]
xor edx, 0xa
mov byte [ebp - 0x659], dl
mov al, byte [ebp - 0x659]
mov byte [ebp - 0x985], al
mov ecx, 1
shl ecx, 2
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x660], dl
movsx eax, byte [ebp - 0x660]
xor eax, 0xa
mov byte [ebp - 0x661], al
mov cl, byte [ebp - 0x661]
mov byte [ebp - 0x984], cl
mov edx, 1
imul eax, edx, 5
mov cl, byte [eax + str.segoe_ui]
mov byte [ebp - 0x668], cl
movsx edx, byte [ebp - 0x668]
xor edx, 0xa
mov byte [ebp - 0x669], dl
mov al, byte [ebp - 0x669]
mov byte [ebp - 0x983], al
mov ecx, 1
imul edx, ecx, 6
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x670], al
movsx ecx, byte [ebp - 0x670]
xor ecx, 0xa
mov byte [ebp - 0x671], cl
mov dl, byte [ebp - 0x671]
mov byte [ebp - 0x982], dl
mov eax, 1
imul ecx, eax, 7
mov dl, byte [ecx + str.segoe_ui]
mov byte [ebp - 0x678], dl
movsx eax, byte [ebp - 0x678]
xor eax, 0xa
mov byte [ebp - 0x679], al
mov cl, byte [ebp - 0x679]
mov byte [ebp - 0x981], cl
mov edx, 1
shl edx, 3
mov al, byte [edx + str.segoe_ui]
mov byte [ebp - 0x680], al
movsx ecx, byte [ebp - 0x680]
xor ecx, 0xa
mov byte [ebp - 0x681], cl
mov dl, byte [ebp - 0x681]
mov byte [ebp - 0x980], dl
lea eax, [ebp - 0x988]
mov dword [ebp - 0xda0], eax
mov ecx, dword [ebp - 0xda0]
mov dword [ebp - 0xa80], ecx
mov dword [ebp - 0x920], 0
jmp 0x100ae61a
mov edx, dword [ebp - 0x920]
add edx, 1
mov dword [ebp - 0x920], edx
cmp dword [ebp - 0x920], 9
jae 0x100ae69c
mov eax, dword [ebp - 0xa80]
mov dword [ebp - 0xda4], eax
mov ecx, dword [ebp - 0xda4]
add ecx, dword [ebp - 0x920]
mov dword [ebp - 0xda8], ecx
mov edx, dword [ebp - 0xda8]
mov al, byte [edx]
mov byte [ebp - 0x688], al
movsx ecx, byte [ebp - 0x688]
xor ecx, 0xa
mov byte [ebp - 0x689], cl
mov dl, byte [ebp - 0x689]
mov byte [ebp - 0x68a], dl
mov eax, dword [ebp - 0xa80]
mov dword [ebp - 0xdac], eax
mov ecx, dword [ebp - 0xdac]
add ecx, dword [ebp - 0x920]
mov dword [ebp - 0xdb0], ecx
mov edx, dword [ebp - 0xdb0]
mov al, byte [ebp - 0x68a]
mov byte [edx], al
jmp 0x100ae60b
mov ecx, dword [ebp - 0xa80]
mov dword [ebp - 0xdb4], ecx
mov edx, dword [ebp - 0xdb4]
mov dword [ebp - 0xdb8], edx
mov eax, dword [ebp - 0xdb8]
mov dword [ebp - 0xdbc], eax
mov ecx, dword [ebp - 0xdbc]
push ecx
lea ecx, [ebp - 0x1198]
call fcn.10028b00
mov byte [ebp - 4], 0x22
mov edx, 1
imul eax, edx, 0
mov cl, byte [eax + str.impact]
mov byte [ebp - 0x690], cl
movsx edx, byte [ebp - 0x690]
xor edx, 0xa
mov byte [ebp - 0x691], dl
mov al, byte [ebp - 0x691]
mov byte [ebp - 0x944], al
mov ecx, 1
shl ecx, 0
mov dl, byte [ecx + str.impact]
mov byte [ebp - 0x698], dl
movsx eax, byte [ebp - 0x698]
xor eax, 0xa
mov byte [ebp - 0x699], al
mov cl, byte [ebp - 0x699]
mov byte [ebp - 0x943], cl
mov edx, 1
shl edx, 1
mov al, byte [edx + str.impact]
mov byte [ebp - 0x6a0], al
movsx ecx, byte [ebp - 0x6a0]
xor ecx, 0xa
mov byte [ebp - 0x6a1], cl
mov dl, byte [ebp - 0x6a1]
mov byte [ebp - 0x942], dl
mov eax, 1
imul ecx, eax, 3
mov dl, byte [ecx + str.impact]
mov byte [ebp - 0x6a8], dl
movsx eax, byte [ebp - 0x6a8]
xor eax, 0xa
mov byte [ebp - 0x6a9], al
mov cl, byte [ebp - 0x6a9]
mov byte [ebp - 0x941], cl
mov edx, 1
shl edx, 2
mov al, byte [edx + str.impact]
mov byte [ebp - 0x6b0], al
movsx ecx, byte [ebp - 0x6b0]
xor ecx, 0xa
mov byte [ebp - 0x6b1], cl
mov dl, byte [ebp - 0x6b1]
mov byte [ebp - 0x940], dl
mov eax, 1
imul ecx, eax, 5
mov dl, byte [ecx + str.impact]
mov byte [ebp - 0x6b8], dl
movsx eax, byte [ebp - 0x6b8]
xor eax, 0xa
mov byte [ebp - 0x6b9], al
mov cl, byte [ebp - 0x6b9]
mov byte [ebp - 0x93f], cl
mov edx, 1
imul eax, edx, 6
mov cl, byte [eax + str.impact]
mov byte [ebp - 0x6c0], cl
movsx edx, byte [ebp - 0x6c0]
xor edx, 0xa
mov byte [ebp - 0x6c1], dl
mov al, byte [ebp - 0x6c1]
mov byte [ebp - 0x93e], al
lea ecx, [ebp - 0x944]
mov dword [ebp - 0xdc0], ecx
mov edx, dword [ebp - 0xdc0]
mov dword [ebp - 0xa84], edx
mov dword [ebp - 0x924], 0
jmp 0x100ae858
mov eax, dword [ebp - 0x924]
add eax, 1
mov dword [ebp - 0x924], eax
cmp dword [ebp - 0x924], 7
jae 0x100ae8da
mov ecx, dword [ebp - 0xa84]
mov dword [ebp - 0xdc4], ecx
mov edx, dword [ebp - 0xdc4]
add edx, dword [ebp - 0x924]
mov dword [ebp - 0xdc8], edx
mov eax, dword [ebp - 0xdc8]
mov cl, byte [eax]
mov byte [ebp - 0x6c8], cl
movsx edx, byte [ebp - 0x6c8]
xor edx, 0xa
mov byte [ebp - 0x6c9], dl
mov al, byte [ebp - 0x6c9]
mov byte [ebp - 0x6ca], al
mov ecx, dword [ebp - 0xa84]
mov dword [ebp - 0xdcc], ecx
mov edx, dword [ebp - 0xdcc]
add edx, dword [ebp - 0x924]
mov dword [ebp - 0xdd0], edx
mov eax, dword [ebp - 0xdd0]
mov cl, byte [ebp - 0x6ca]
mov byte [eax], cl
jmp 0x100ae849
mov edx, dword [ebp - 0xa84]
mov dword [ebp - 0xdd4], edx
mov eax, dword [ebp - 0xdd4]
mov dword [ebp - 0xdd8], eax
mov ecx, dword [ebp - 0xdd8]
mov dword [ebp - 0xddc], ecx
mov edx, dword [ebp - 0xddc]
push edx
lea ecx, [ebp - 0x1180]
call fcn.10028b00
mov byte [ebp - 4], 0x23
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x6d0], dl
movsx eax, byte [ebp - 0x6d0]
xor eax, 0xa
mov byte [ebp - 0x6d1], al
mov cl, byte [ebp - 0x6d1]
mov byte [ebp - 0xa48], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x6d8], al
movsx ecx, byte [ebp - 0x6d8]
xor ecx, 0xa
mov byte [ebp - 0x6d9], cl
mov dl, byte [ebp - 0x6d9]
mov byte [ebp - 0xa47], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x6e0], cl
movsx edx, byte [ebp - 0x6e0]
xor edx, 0xa
mov byte [ebp - 0x6e1], dl
mov al, byte [ebp - 0x6e1]
mov byte [ebp - 0xa46], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x6e8], al
movsx ecx, byte [ebp - 0x6e8]
xor ecx, 0xa
mov byte [ebp - 0x6e9], cl
mov dl, byte [ebp - 0x6e9]
mov byte [ebp - 0xa45], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x6f0], cl
movsx edx, byte [ebp - 0x6f0]
xor edx, 0xa
mov byte [ebp - 0x6f1], dl
mov al, byte [ebp - 0x6f1]
mov byte [ebp - 0xa44], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x6f8], al
movsx ecx, byte [ebp - 0x6f8]
xor ecx, 0xa
mov byte [ebp - 0x6f9], cl
mov dl, byte [ebp - 0x6f9]
mov byte [ebp - 0xa43], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x700], dl
movsx eax, byte [ebp - 0x700]
xor eax, 0xa
mov byte [ebp - 0x701], al
mov cl, byte [ebp - 0x701]
mov byte [ebp - 0xa42], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x708], cl
movsx edx, byte [ebp - 0x708]
xor edx, 0xa
mov byte [ebp - 0x709], dl
mov al, byte [ebp - 0x709]
mov byte [ebp - 0xa41], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x710], dl
movsx eax, byte [ebp - 0x710]
xor eax, 0xa
mov byte [ebp - 0x711], al
mov cl, byte [ebp - 0x711]
mov byte [ebp - 0xa40], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x718], cl
movsx edx, byte [ebp - 0x718]
xor edx, 0xa
mov byte [ebp - 0x719], dl
mov al, byte [ebp - 0x719]
mov byte [ebp - 0xa3f], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x720], al
movsx ecx, byte [ebp - 0x720]
xor ecx, 0xa
mov byte [ebp - 0x721], cl
mov dl, byte [ebp - 0x721]
mov byte [ebp - 0xa3e], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x728], dl
movsx eax, byte [ebp - 0x728]
xor eax, 0xa
mov byte [ebp - 0x729], al
mov cl, byte [ebp - 0x729]
mov byte [ebp - 0xa3d], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x730], cl
movsx edx, byte [ebp - 0x730]
xor edx, 0xa
mov byte [ebp - 0x731], dl
mov al, byte [ebp - 0x731]
mov byte [ebp - 0xa3c], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.enchantment_table]
mov byte [ebp - 0x738], al
movsx ecx, byte [ebp - 0x738]
xor ecx, 0xa
mov byte [ebp - 0x739], cl
mov dl, byte [ebp - 0x739]
mov byte [ebp - 0xa3b], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x740], dl
movsx eax, byte [ebp - 0x740]
xor eax, 0xa
mov byte [ebp - 0x741], al
mov cl, byte [ebp - 0x741]
mov byte [ebp - 0xa3a], cl
mov edx, 1
imul eax, edx, 0xf
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x748], cl
movsx edx, byte [ebp - 0x748]
xor edx, 0xa
mov byte [ebp - 0x749], dl
mov al, byte [ebp - 0x749]
mov byte [ebp - 0xa39], al
mov ecx, 1
shl ecx, 4
mov dl, byte [ecx + str.enchantment_table]
mov byte [ebp - 0x750], dl
movsx eax, byte [ebp - 0x750]
xor eax, 0xa
mov byte [ebp - 0x751], al
mov cl, byte [ebp - 0x751]
mov byte [ebp - 0xa38], cl
mov edx, 1
imul eax, edx, 0x11
mov cl, byte [eax + str.enchantment_table]
mov byte [ebp - 0x758], cl
movsx edx, byte [ebp - 0x758]
xor edx, 0xa
mov byte [ebp - 0x759], dl
mov al, byte [ebp - 0x759]
mov byte [ebp - 0xa37], al
lea ecx, [ebp - 0xa48]
mov dword [ebp - 0xde0], ecx
mov edx, dword [ebp - 0xde0]
mov dword [ebp - 0xa88], edx
mov dword [ebp - 0x928], 0
jmp 0x100aeca6
mov eax, dword [ebp - 0x928]
add eax, 1
mov dword [ebp - 0x928], eax
cmp dword [ebp - 0x928], 0x12
jae 0x100aed28
mov ecx, dword [ebp - 0xa88]
mov dword [ebp - 0xde4], ecx
mov edx, dword [ebp - 0xde4]
add edx, dword [ebp - 0x928]
mov dword [ebp - 0xde8], edx
mov eax, dword [ebp - 0xde8]
mov cl, byte [eax]
mov byte [ebp - 0x760], cl
movsx edx, byte [ebp - 0x760]
xor edx, 0xa
mov byte [ebp - 0x761], dl
mov al, byte [ebp - 0x761]
mov byte [ebp - 0x762], al
mov ecx, dword [ebp - 0xa88]
mov dword [ebp - 0xdec], ecx
mov edx, dword [ebp - 0xdec]
add edx, dword [ebp - 0x928]
mov dword [ebp - 0xdf0], edx
mov eax, dword [ebp - 0xdf0]
mov cl, byte [ebp - 0x762]
mov byte [eax], cl
jmp 0x100aec97
mov edx, dword [ebp - 0xa88]
mov dword [ebp - 0xdf4], edx
mov eax, dword [ebp - 0xdf4]
mov dword [ebp - 0xe9c], eax
mov ecx, dword [ebp - 0xe9c]
mov dword [ebp - 0xdfc], ecx
mov edx, dword [ebp - 0xdfc]
push edx
lea ecx, [ebp - 0x1168]
call fcn.10028b00
mov byte [ebp - 4], 0x24
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x768], dl
movsx eax, byte [ebp - 0x768]
xor eax, 0xa
mov byte [ebp - 0x769], al
mov cl, byte [ebp - 0x769]
mov byte [ebp - 0x9b8], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x770], al
movsx ecx, byte [ebp - 0x770]
xor ecx, 0xa
mov byte [ebp - 0x771], cl
mov dl, byte [ebp - 0x771]
mov byte [ebp - 0x9b7], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x778], cl
movsx edx, byte [ebp - 0x778]
xor edx, 0xa
mov byte [ebp - 0x779], dl
mov al, byte [ebp - 0x779]
mov byte [ebp - 0x9b6], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x780], al
movsx ecx, byte [ebp - 0x780]
xor ecx, 0xa
mov byte [ebp - 0x781], cl
mov dl, byte [ebp - 0x781]
mov byte [ebp - 0x9b5], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x788], cl
movsx edx, byte [ebp - 0x788]
xor edx, 0xa
mov byte [ebp - 0x789], dl
mov al, byte [ebp - 0x789]
mov byte [ebp - 0x9b4], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.minecraft]
mov byte [ebp - 0x790], al
movsx ecx, byte [ebp - 0x790]
xor ecx, 0xa
mov byte [ebp - 0x791], cl
mov dl, byte [ebp - 0x791]
mov byte [ebp - 0x9b3], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x798], dl
movsx eax, byte [ebp - 0x798]
xor eax, 0xa
mov byte [ebp - 0x799], al
mov cl, byte [ebp - 0x799]
mov byte [ebp - 0x9b2], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x7a0], cl
movsx edx, byte [ebp - 0x7a0]
xor edx, 0xa
mov byte [ebp - 0x7a1], dl
mov al, byte [ebp - 0x7a1]
mov byte [ebp - 0x9b1], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.minecraft]
mov byte [ebp - 0x7a8], dl
movsx eax, byte [ebp - 0x7a8]
xor eax, 0xa
mov byte [ebp - 0x7a9], al
mov cl, byte [ebp - 0x7a9]
mov byte [ebp - 0x9b0], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.minecraft]
mov byte [ebp - 0x7b0], cl
movsx edx, byte [ebp - 0x7b0]
xor edx, 0xa
mov byte [ebp - 0x7b1], dl
mov al, byte [ebp - 0x7b1]
mov byte [ebp - 0x9af], al
lea ecx, [ebp - 0x9b8]
mov dword [ebp - 0xe00], ecx
mov edx, dword [ebp - 0xe00]
mov dword [ebp - 0xa8c], edx
mov dword [ebp - 0x900], 0
jmp 0x100aef74
mov eax, dword [ebp - 0x900]
add eax, 1
mov dword [ebp - 0x900], eax
cmp dword [ebp - 0x900], 0xa
jae 0x100aeff6
mov ecx, dword [ebp - 0xa8c]
mov dword [ebp - 0xe04], ecx
mov edx, dword [ebp - 0xe04]
add edx, dword [ebp - 0x900]
mov dword [ebp - 0xe08], edx
mov eax, dword [ebp - 0xe08]
mov cl, byte [eax]
mov byte [ebp - 0x7b8], cl
movsx edx, byte [ebp - 0x7b8]
xor edx, 0xa
mov byte [ebp - 0x7b9], dl
mov al, byte [ebp - 0x7b9]
mov byte [ebp - 0x7ba], al
mov ecx, dword [ebp - 0xa8c]
mov dword [ebp - 0xe0c], ecx
mov edx, dword [ebp - 0xe0c]
add edx, dword [ebp - 0x900]
mov dword [ebp - 0xe10], edx
mov eax, dword [ebp - 0xe10]
mov cl, byte [ebp - 0x7ba]
mov byte [eax], cl
jmp 0x100aef65
mov edx, dword [ebp - 0xa8c]
mov dword [ebp - 0xe14], edx
mov eax, dword [ebp - 0xe14]
mov dword [ebp - 0xe18], eax
mov ecx, dword [ebp - 0xe18]
mov dword [ebp - 0xe1c], ecx
mov edx, dword [ebp - 0xe1c]
push edx
lea ecx, [ebp - 0x1150]
call fcn.10028b00
mov dword [ebp - 4], 0x25
lea eax, [ebp - 0x1210]
mov dword [ebp - 0xf24], eax
lea ecx, [ebp - 0x1138]
mov dword [ebp - 0xf20], ecx
lea edx, [ebp - 0xf24]
mov dword [ebp - 0xe20], edx
mov eax, dword [ebp - 0xe20]
mov ecx, dword [eax]
mov edx, dword [eax + 4]
mov dword [ebp - 0xed0], ecx
mov dword [ebp - 0xecc], edx
mov eax, dword [ebp - 0xe24]
push eax
mov ecx, dword [ebp - 0xecc]
push ecx
mov edx, dword [ebp - 0xed0]
push edx
lea ecx, [ebp - 0xf5c]
call fcn.100bc9a0
mov byte [ebp - 4], 0x26
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.logeventfont]
mov byte [ebp - 0x7c0], dl
movsx eax, byte [ebp - 0x7c0]
xor eax, 0xa
mov byte [ebp - 0x7c1], al
mov cl, byte [ebp - 0x7c1]
mov byte [ebp - 0x9d4], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.logeventfont]
mov byte [ebp - 0x7c8], al
movsx ecx, byte [ebp - 0x7c8]
xor ecx, 0xa
mov byte [ebp - 0x7c9], cl
mov dl, byte [ebp - 0x7c9]
mov byte [ebp - 0x9d3], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.logeventfont]
mov byte [ebp - 0x7d0], cl
movsx edx, byte [ebp - 0x7d0]
xor edx, 0xa
mov byte [ebp - 0x7d1], dl
mov al, byte [ebp - 0x7d1]
mov byte [ebp - 0x9d2], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.logeventfont]
mov byte [ebp - 0x7d8], al
movsx ecx, byte [ebp - 0x7d8]
xor ecx, 0xa
mov byte [ebp - 0x7d9], cl
mov dl, byte [ebp - 0x7d9]
mov byte [ebp - 0x9d1], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.logeventfont]
mov byte [ebp - 0x7e0], cl
movsx edx, byte [ebp - 0x7e0]
xor edx, 0xa
mov byte [ebp - 0x7e1], dl
mov al, byte [ebp - 0x7e1]
mov byte [ebp - 0x9d0], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.logeventfont]
mov byte [ebp - 0x7e8], al
movsx ecx, byte [ebp - 0x7e8]
xor ecx, 0xa
mov byte [ebp - 0x7e9], cl
mov dl, byte [ebp - 0x7e9]
mov byte [ebp - 0x9cf], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.logeventfont]
mov byte [ebp - 0x7f0], dl
movsx eax, byte [ebp - 0x7f0]
xor eax, 0xa
mov byte [ebp - 0x7f1], al
mov cl, byte [ebp - 0x7f1]
mov byte [ebp - 0x9ce], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.logeventfont]
mov byte [ebp - 0x7f8], cl
movsx edx, byte [ebp - 0x7f8]
xor edx, 0xa
mov byte [ebp - 0x7f9], dl
mov al, byte [ebp - 0x7f9]
mov byte [ebp - 0x9cd], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.logeventfont]
mov byte [ebp - 0x800], dl
movsx eax, byte [ebp - 0x800]
xor eax, 0xa
mov byte [ebp - 0x801], al
mov cl, byte [ebp - 0x801]
mov byte [ebp - 0x9cc], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.logeventfont]
mov byte [ebp - 0x808], cl
movsx edx, byte [ebp - 0x808]
xor edx, 0xa
mov byte [ebp - 0x809], dl
mov al, byte [ebp - 0x809]
mov byte [ebp - 0x9cb], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.logeventfont]
mov byte [ebp - 0x810], al
movsx ecx, byte [ebp - 0x810]
xor ecx, 0xa
mov byte [ebp - 0x811], cl
mov dl, byte [ebp - 0x811]
mov byte [ebp - 0x9ca], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.logeventfont]
mov byte [ebp - 0x818], dl
movsx eax, byte [ebp - 0x818]
xor eax, 0xa
mov byte [ebp - 0x819], al
mov cl, byte [ebp - 0x819]
mov byte [ebp - 0x9c9], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.logeventfont]
mov byte [ebp - 0x820], cl
movsx edx, byte [ebp - 0x820]
xor edx, 0xa
mov byte [ebp - 0x821], dl
mov al, byte [ebp - 0x821]
mov byte [ebp - 0x9c8], al
lea ecx, [ebp - 0x9d4]
mov dword [ebp - 0xe28], ecx
mov edx, dword [ebp - 0xe28]
mov dword [ebp - 0xa90], edx
mov dword [ebp - 0x92c], 0
jmp 0x100af334
mov eax, dword [ebp - 0x92c]
add eax, 1
mov dword [ebp - 0x92c], eax
cmp dword [ebp - 0x92c], 0xd
jae 0x100af3b6
mov ecx, dword [ebp - 0xa90]
mov dword [ebp - 0xe2c], ecx
mov edx, dword [ebp - 0xe2c]
add edx, dword [ebp - 0x92c]
mov dword [ebp - 0xe30], edx
mov eax, dword [ebp - 0xe30]
mov cl, byte [eax]
mov byte [ebp - 0x828], cl
movsx edx, byte [ebp - 0x828]
xor edx, 0xa
mov byte [ebp - 0x829], dl
mov al, byte [ebp - 0x829]
mov byte [ebp - 0x82a], al
mov ecx, dword [ebp - 0xa90]
mov dword [ebp - 0xe34], ecx
mov edx, dword [ebp - 0xe34]
add edx, dword [ebp - 0x92c]
mov dword [ebp - 0xe38], edx
mov eax, dword [ebp - 0xe38]
mov cl, byte [ebp - 0x82a]
mov byte [eax], cl
jmp 0x100af325
mov edx, dword [ebp - 0xa90]
mov dword [ebp - 0xe3c], edx
mov eax, dword [ebp - 0xe3c]
mov dword [ebp - 0xe40], eax
mov ecx, dword [ebp - 0xe40]
mov dword [ebp - 0xe44], ecx
mov edx, dword [ebp - 0xe44]
push edx
lea ecx, [ebp - 0x10ac]
call fcn.10028b00
mov byte [ebp - 4], 0x27
mov eax, 1
imul ecx, eax, 0
mov dl, byte [ecx + str.log_event_font]
mov byte [ebp - 0x830], dl
movsx eax, byte [ebp - 0x830]
xor eax, 0xa
mov byte [ebp - 0x831], al
mov cl, byte [ebp - 0x831]
mov byte [ebp - 0xa14], cl
mov edx, 1
shl edx, 0
mov al, byte [edx + str.log_event_font]
mov byte [ebp - 0x838], al
movsx ecx, byte [ebp - 0x838]
xor ecx, 0xa
mov byte [ebp - 0x839], cl
mov dl, byte [ebp - 0x839]
mov byte [ebp - 0xa13], dl
mov eax, 1
shl eax, 1
mov cl, byte [eax + str.log_event_font]
mov byte [ebp - 0x840], cl
movsx edx, byte [ebp - 0x840]
xor edx, 0xa
mov byte [ebp - 0x841], dl
mov al, byte [ebp - 0x841]
mov byte [ebp - 0xa12], al
mov ecx, 1
imul edx, ecx, 3
mov al, byte [edx + str.log_event_font]
mov byte [ebp - 0x848], al
movsx ecx, byte [ebp - 0x848]
xor ecx, 0xa
mov byte [ebp - 0x849], cl
mov dl, byte [ebp - 0x849]
mov byte [ebp - 0xa11], dl
mov eax, 1
shl eax, 2
mov cl, byte [eax + str.log_event_font]
mov byte [ebp - 0x850], cl
movsx edx, byte [ebp - 0x850]
xor edx, 0xa
mov byte [ebp - 0x851], dl
mov al, byte [ebp - 0x851]
mov byte [ebp - 0xa10], al
mov ecx, 1
imul edx, ecx, 5
mov al, byte [edx + str.log_event_font]
mov byte [ebp - 0x858], al
movsx ecx, byte [ebp - 0x858]
xor ecx, 0xa
mov byte [ebp - 0x859], cl
mov dl, byte [ebp - 0x859]
mov byte [ebp - 0xa0f], dl
mov eax, 1
imul ecx, eax, 6
mov dl, byte [ecx + str.log_event_font]
mov byte [ebp - 0x860], dl
movsx eax, byte [ebp - 0x860]
xor eax, 0xa
mov byte [ebp - 0x861], al
mov cl, byte [ebp - 0x861]
mov byte [ebp - 0xa0e], cl
mov edx, 1
imul eax, edx, 7
mov cl, byte [eax + str.log_event_font]
mov byte [ebp - 0x868], cl
movsx edx, byte [ebp - 0x868]
xor edx, 0xa
mov byte [ebp - 0x869], dl
mov al, byte [ebp - 0x869]
mov byte [ebp - 0xa0d], al
mov ecx, 1
shl ecx, 3
mov dl, byte [ecx + str.log_event_font]
mov byte [ebp - 0x870], dl
movsx eax, byte [ebp - 0x870]
xor eax, 0xa
mov byte [ebp - 0x871], al
mov cl, byte [ebp - 0x871]
mov byte [ebp - 0xa0c], cl
mov edx, 1
imul eax, edx, 9
mov cl, byte [eax + str.log_event_font]
mov byte [ebp - 0x878], cl
movsx edx, byte [ebp - 0x878]
xor edx, 0xa
mov byte [ebp - 0x879], dl
mov al, byte [ebp - 0x879]
mov byte [ebp - 0xa0b], al
mov ecx, 1
imul edx, ecx, 0xa
mov al, byte [edx + str.log_event_font]
mov byte [ebp - 0x880], al
movsx ecx, byte [ebp - 0x880]
xor ecx, 0xa
mov byte [ebp - 0x881], cl
mov dl, byte [ebp - 0x881]
mov byte [ebp - 0xa0a], dl
mov eax, 1
imul ecx, eax, 0xb
mov dl, byte [ecx + str.log_event_font]
mov byte [ebp - 0x888], dl
movsx eax, byte [ebp - 0x888]
xor eax, 0xa
mov byte [ebp - 0x889], al
mov cl, byte [ebp - 0x889]
mov byte [ebp - 0xa09], cl
mov edx, 1
imul eax, edx, 0xc
mov cl, byte [eax + str.log_event_font]
mov byte [ebp - 0x890], cl
movsx edx, byte [ebp - 0x890]
xor edx, 0xa
mov byte [ebp - 0x891], dl
mov al, byte [ebp - 0x891]
mov byte [ebp - 0xa08], al
mov ecx, 1
imul edx, ecx, 0xd
mov al, byte [edx + str.log_event_font]
mov byte [ebp - 0x898], al
movsx ecx, byte [ebp - 0x898]
xor ecx, 0xa
mov byte [ebp - 0x899], cl
mov dl, byte [ebp - 0x899]
mov byte [ebp - 0xa07], dl
mov eax, 1
imul ecx, eax, 0xe
mov dl, byte [ecx + str.log_event_font]
mov byte [ebp - 0x8a0], dl
movsx eax, byte [ebp - 0x8a0]
xor eax, 0xa
mov byte [ebp - 0x8a1], al
mov cl, byte [ebp - 0x8a1]
mov byte [ebp - 0xa06], cl
lea edx, [ebp - 0xa14]
mov dword [ebp - 0xe48], edx
mov eax, dword [ebp - 0xe48]
mov dword [ebp - 0xa94], eax
mov dword [ebp - 0x8d8], 0
jmp 0x100af6f2
mov ecx, dword [ebp - 0x8d8]
add ecx, 1
mov dword [ebp - 0x8d8], ecx
cmp dword [ebp - 0x8d8], 0xf
jae 0x100af774
mov edx, dword [ebp - 0xa94]
mov dword [ebp - 0xe4c], edx
mov eax, dword [ebp - 0xe4c]
add eax, dword [ebp - 0x8d8]
mov dword [ebp - 0xe50], eax
mov ecx, dword [ebp - 0xe50]
mov dl, byte [ecx]
mov byte [ebp - 0x8a8], dl
movsx eax, byte [ebp - 0x8a8]
xor eax, 0xa
mov byte [ebp - 0x8a9], al
mov cl, byte [ebp - 0x8a9]
mov byte [ebp - 0x8aa], cl
mov edx, dword [ebp - 0xa94]
mov dword [ebp - 0xe54], edx
mov eax, dword [ebp - 0xe54]
add eax, dword [ebp - 0x8d8]
mov dword [ebp - 0xe58], eax
mov ecx, dword [ebp - 0xe58]
mov dl, byte [ebp - 0x8aa]
mov byte [ecx], dl
jmp 0x100af6e3
mov eax, dword [ebp - 0xa94]
mov dword [ebp - 0xe5c], eax
mov ecx, dword [ebp - 0xe5c]
mov dword [ebp - 0xe60], ecx
mov edx, dword [ebp - 0xe60]
mov dword [ebp - 0xe64], edx
mov eax, dword [ebp - 0xe64]
push eax
lea ecx, [ebp - 0x1094]
call fcn.10028b00
mov byte [ebp - 4], 0x28
lea ecx, [ebp - 0x10ac]
push ecx
mov ecx, dword [ebp - 0x40]
add ecx, 0x38
call fcn.1003b850
mov edx, dword [ebp - 0x40]
mov byte [edx + 0x69], 1
mov eax, dword [ebp - 0x40]
movzx ecx, byte [eax + 0x69]
test ecx, ecx
je 0x100af7e5
lea edx, [ebp - 0x1094]
push edx
mov ecx, dword [ebp - 0x40]
add ecx, 0x74
call fcn.1003b850
nop
mov eax, dword [ebp - 0x40]
mov dword [eax + 0xa0], 0
mov ecx, dword [ebp - 0x40]
mov edx, dword [ecx + 0xa0]
add edx, 0x14
mov dword [ebp - 0xadc], edx
mov eax, dword [ebp - 0x40]
mov ecx, dword [ebp - 0xadc]
mov dword [eax + 0x10], ecx
mov edx, dword [ebp - 0x40]
mov eax, dword [ebp - 0xadc]
mov dword [edx + 0x14], eax
lea ecx, [ebp - 0xf5c]
mov dword [ebp - 0xad8], ecx
mov edx, dword [ebp - 0xad8]
mov eax, dword [edx]
mov dword [ebp - 0xe68], eax
mov ecx, dword [ebp - 0xe68]
mov dword [ebp - 0xe6c], ecx
mov edx, dword [ebp - 0xe6c]
mov dword [ebp - 0xe70], edx
mov eax, dword [ebp - 0xe70]
mov dword [ebp - 0x93c], eax
mov ecx, dword [ebp - 0xad8]
mov edx, dword [ecx + 4]
mov dword [ebp - 0xe74], edx
mov eax, dword [ebp - 0xe74]
mov dword [ebp - 0xe78], eax
mov ecx, dword [ebp - 0xe78]
mov dword [ebp - 0xe7c], ecx
mov edx, dword [ebp - 0xe7c]
mov dword [ebp - 0xe80], edx
jmp 0x100af89e
mov eax, dword [ebp - 0x93c]
add eax, 0x18
mov dword [ebp - 0x93c], eax
mov ecx, dword [ebp - 0x93c]
cmp ecx, dword [ebp - 0xe80]
je 0x100af8db
mov edx, dword [ebp - 0x93c]
mov dword [ebp - 0xe84], edx
mov eax, dword [ebp - 0x40]
add eax, 0x8c
mov dword [ebp - 0xe88], eax
mov ecx, dword [ebp - 0xe84]
push ecx
mov ecx, dword [ebp - 0xe88]
call fcn.10080760
nop
jmp 0x100af88f
mov edx, dword [ebp - 0x40]
add edx, 0x8c
mov dword [ebp - 0xad4], edx
mov eax, dword [ebp - 0xad4]
mov ecx, dword [ebp - 0xad4]
mov eax, dword [eax + 4]
sub eax, dword [ecx]
cdq
mov ecx, 0x18
idiv ecx
mov dword [ebp - 0xe8c], eax
cmp dword [ebp - 0xe8c], 0
jbe 0x100af91f
mov edx, dword [ebp - 0x40]
mov dword [edx + 0x9c], 0
mov byte [ebp - 4], 0x27
lea ecx, [ebp - 0x1094]
call fcn.10029670
nop
mov byte [ebp - 4], 0x26
lea ecx, [ebp - 0x10ac]
call fcn.10029670
nop
mov byte [ebp - 4], 0x25
lea ecx, [ebp - 0xf5c]
call fcn.10030d30
nop
mov dword [ebp - 4], 0xffffffff
push fcn.10028ae0
push 9
push 0x18
lea eax, [ebp - 0x1210]
push eax
call fcn.1012d1c5
nop
mov ecx, dword [ebp - 0x34]
add ecx, 0x474
mov dword [ebp - 0xe90], ecx
mov edx, dword [ebp - 0xe90]
mov dword [edx + 0x64], 0x100374b0
mov eax, dword [ebp - 0x34]
add eax, 0x474
mov dword [ebp - 0x30], eax
mov ecx, dword [ebp - 0x30]
mov dword [ecx + 0x18], 1
mov edx, dword [ebp - 0x30]
imul eax, dword [edx + 0x18], 0xeb
add eax, 0x14
mov ecx, dword [ebp - 0x30]
mov dword [ecx + 4], eax
mov edx, dword [ebp - 0x30]
mov dword [edx + 0xc], 0xaf
mov eax, dword [ebp - 0x30]
mov ecx, dword [ebp - 0x34]
mov edx, dword [ecx + 0x2c]
mov dword [eax + 0x1c], edx
mov eax, dword [ebp - 0x34]
add eax, 0x18
mov dword [ebp - 0xe94], eax
lea ecx, [ebp - 0x30]
push ecx
mov ecx, dword [ebp - 0xe94]
call fcn.1002a740
nop
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop ecx
mov ecx, dword [ebp - 0x14]
xor ecx, ebp
call fcn.1012d179
mov esp, ebp
pop ebp
mov esp, ebx
pop ebx
ret