

.intel_syntax noprefix

.global GetLabelStr
.global ExpandCStrings
.global ExpandHllProc
.global ExpandHllProcEx
.global EvaluateHllExpression
.global ExpandHllExpression
.global HllStartDir
.global HllEndDir
.global HllContinueIf
.global HllExitDir
.global HllCheckOpen
.global HllInit

.extern ExpandLine
.extern RunLineQueue
.extern AddLineQueueX
.extern AddLineQueue
.extern GetResWName
.extern LstWrite
.extern Tokenize
.extern CurrProc
.extern StoreState
.extern NoLineStore
.extern GetStdAssume
.extern SearchNameInStruct
.extern GetCurrOffset
.extern EmitConstError
.extern EvalOperand
.extern SizeFromRegister
.extern SizeFromMemtype
.extern LclDup
.extern LclAlloc
.extern DefaultConstructor
.extern GenerateCString
.extern tsprintf
.extern asmerr
.extern Options
.extern Parse_Pass
.extern SymFindID
.extern SymFind
.extern tstrstr
.extern tstrcmp
.extern tstrcat
.extern tstrcpy
.extern tstrchr
.extern tstrlen
.extern tmemicmp
.extern tmemcpy


.SECTION .text
	.ALIGN	16

$_001:	mov	rdx, qword ptr [rcx+0x10]
	cmp	byte ptr [rcx], 9
	jne	$_017
	cmp	dword ptr [rcx+0x4], 2
	jnz	$_010
	movzx	eax, word ptr [rdx]
	jmp	$_008

$_002:	mov	eax, 1
	jmp	$_032

$_003:	mov	eax, 2
	jmp	$_032

$_004:	mov	eax, 5
	jmp	$_032

$_005:	mov	eax, 6
	jmp	$_032

$_006:	mov	eax, 7
	jmp	$_032

$_007:	mov	eax, 8
	jmp	$_032

	jmp	$_009

$_008:	cmp	eax, 15677
	jz	$_002
	cmp	eax, 15649
	jz	$_003
	cmp	eax, 15678
	jz	$_004
	cmp	eax, 15676
	jz	$_005
	cmp	eax, 9766
	jz	$_006
	cmp	eax, 31868
	jz	$_007
$_009:	jmp	$_016

$_010:	cmp	dword ptr [rcx+0x4], 1
	jnz	$_016
	movzx	eax, byte ptr [rdx]
	jmp	$_015

$_011:	mov	eax, 3
	jmp	$_032

$_012:	mov	eax, 4
	jmp	$_032

$_013:	mov	eax, 9
	jmp	$_032

$_014:	mov	eax, 10
	jmp	$_032

	jmp	$_016

$_015:	cmp	eax, 62
	jz	$_011
	cmp	eax, 60
	jz	$_012
	cmp	eax, 38
	jz	$_013
	cmp	eax, 33
	jz	$_014
$_016:	jmp	$_018

$_017:	cmp	byte ptr [rcx], 8
	jz	$_018
	xor	eax, eax
	jmp	$_032

$_018:	xor	eax, eax
$_019:	cmp	byte ptr [rdx+rax], 0
	jz	$_020
	inc	eax
	jmp	$_019

$_020:	cmp	byte ptr [rdx+rax-0x1], 63
	jne	$_031
	mov	ecx, dword ptr [rdx]
	and	ecx, 0xDFDFDFDF
	jmp	$_030

$_021:	cmp	ecx, 1330791770
	jnz	$_022
	mov	eax, 11
	jmp	$_032

$_022:	cmp	ecx, 1313294675
	jnz	$_023
	mov	eax, 13
	jmp	$_032

$_023:	jmp	$_031

$_024:	mov	al, byte ptr [rdx+0x4]
	and	eax, 0xFFFFFFDF
	cmp	eax, 89
	jnz	$_025
	cmp	ecx, 1381122371
	jnz	$_025
	mov	eax, 12
	jmp	$_032

$_025:	jmp	$_031

$_026:	mov	ax, word ptr [rdx+0x4]
	and	eax, 0xFFFFDFDF
	cmp	eax, 22868
	jnz	$_027
	cmp	ecx, 1230127440
	jnz	$_027
	mov	eax, 14
	jmp	$_032

$_027:	jmp	$_031

$_028:	mov	eax, dword ptr [rdx+0x4]
	and	eax, 0xDFDFDFDF
	cmp	eax, 1464814662
	jnz	$_029
	cmp	ecx, 1380275791
	jnz	$_029
	mov	eax, 15
	jmp	$_032

$_029:	jmp	$_031

$_030:	cmp	eax, 5
	je	$_021
	cmp	eax, 6
	jz	$_024
	cmp	eax, 7
	jz	$_026
	cmp	eax, 9
	jz	$_028
$_031:	xor	eax, eax
$_032:	ret

$_033:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	dword ptr [rbp-0x4], 0
	mov	rdi, rcx
	mov	rbx, qword ptr [rbp+0x58]
	mov	ecx, dword ptr [rbp+0x48]
	cmp	ecx, -2
	jz	$_034
	cmp	byte ptr [r14+0x4], 0
	jz	$_034
	imul	ecx, ecx, 32
	cmp	byte ptr [rbx+rcx], 9
	jnz	$_034
	mov	rax, qword ptr [rbx+rcx+0x10]
	cmp	word ptr [rax], 38
	jnz	$_034
	mov	eax, dword ptr [r14+0x5C]
	mov	dword ptr [rbp-0x4], eax
	imul	edx, dword ptr [rbp+0x50], 32
	mov	rsi, qword ptr [rbx+rdx+0x18]
	mov	dl, byte ptr [rsi]
	mov	byte ptr [rbp-0x5], dl
	mov	byte ptr [rsi], 0
	mov	r9, qword ptr [rbx+rcx+0x38]
	mov	r8d, eax
	lea	rdx, [DS0000+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
	add	rdi, rax
	mov	al, byte ptr [rbp-0x5]
	mov	byte ptr [rsi], al
$_034:	mov	r8d, dword ptr [rbp+0x30]
	lea	rdx, [DS0001+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
	add	rdi, rax
	imul	ecx, dword ptr [rbp+0x40], 32
	imul	eax, dword ptr [rbp+0x38], 32
	mov	rcx, qword ptr [rbx+rcx+0x18]
	mov	rsi, qword ptr [rbx+rax+0x18]
	sub	rcx, rsi
	rep movsb
	mov	ecx, dword ptr [rbp+0x50]
	mov	eax, dword ptr [rbp+0x48]
	cmp	eax, -2
	jz	$_037
	cmp	dword ptr [rbp-0x4], 0
	jz	$_035
	mov	r8d, dword ptr [rbp-0x4]
	lea	rdx, [DS0002+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
	add	rdi, rax
	jmp	$_036

$_035:
	mov	word ptr [rdi], 8236
	add	rdi, 2
	imul	ecx, ecx, 32
	imul	eax, eax, 32
	mov	rcx, qword ptr [rbx+rcx+0x18]
	mov	rsi, qword ptr [rbx+rax+0x18]
	sub	rcx, rsi
	rep movsb
$_036:	jmp	$_038

$_037:	cmp	ecx, -2
	jz	$_038
	mov	r8d, ecx
	lea	rdx, [DS0003+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
	add	rdi, rax
$_038:
	mov	word ptr [rdi], 10
	lea	rax, [rdi+0x1]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

GetLabelStr:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	r8d, dword ptr [rbp+0x10]
	lea	rdx, [DS0004+rip]
	mov	rcx, qword ptr [rbp+0x18]
	call	tsprintf@PLT
	mov	rax, qword ptr [rbp+0x18]
	leave
	ret

$_039:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rdi, rcx
	mov	eax, 106
	stosb
	mov	ecx, dword ptr [rbp+0x28]
	test	ecx, ecx
	jz	$_040
	mov	eax, 110
	stosb
$_040:	mov	eax, dword ptr [rbp+0x20]
	stosb
	mov	eax, 32
	test	ecx, ecx
	jnz	$_041
	stosb
$_041:	stosb
	mov	r8d, dword ptr [rbp+0x30]
	lea	rdx, [DS0004+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
	lea	rax, [rdi+rax+0x1]
	mov	word ptr [rax-0x1], 10
	leave
	pop	rdi
	ret

$_042:
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	rsi, rdx
	mov	edi, dword ptr [rsi]
	imul	ebx, edi, 32
	add	rbx, qword ptr [rbp+0x38]
$_043:	cmp	edi, dword ptr [r14+0x64]
	jge	$_044
	mov	rcx, rbx
	call	$_001
	test	rax, rax
	jnz	$_044
	add	rbx, 32
	inc	edi
	jmp	$_043

$_044:
	cmp	edi, dword ptr [rsi]
	jnz	$_045
	mov	rax, qword ptr [rbp+0x40]
	mov	dword ptr [rax+0x3C], -2
	mov	eax, 0
	jmp	$_046

$_045:	mov	byte ptr [rsp+0x20], 0
	mov	r9, qword ptr [rbp+0x40]
	mov	r8d, edi
	mov	rdx, qword ptr [rbp+0x38]
	mov	rcx, rsi
	call	EvalOperand@PLT
	cmp	eax, -1
	jz	$_046
	mov	eax, 0
	cmp	dword ptr [rsi], edi
	jbe	$_046
	mov	ecx, 2154
	call	asmerr@PLT
$_046:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_047:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 328
	mov	rsi, rdx
	mov	edi, dword ptr [rsi]
	imul	ebx, edi, 32
	add	rbx, qword ptr [rbp+0x38]
	mov	rax, qword ptr [rbx+0x10]
$_048:	cmp	word ptr [rax], 33
	jnz	$_049
	inc	edi
	add	rbx, 32
	mov	eax, 1
	sub	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rbp+0x48], eax
	mov	rax, qword ptr [rbx+0x10]
	jmp	$_048

$_049:
	mov	dword ptr [rsi], edi
	cmp	byte ptr [rbx], 40
	jne	$_057
	mov	edi, 1
	add	rbx, 32
	mov	al, byte ptr [rbx]
$_050:	test	al, al
	jz	$_054
	cmp	al, 40
	jnz	$_051
	inc	edi
	jmp	$_053

$_051:	cmp	al, 41
	jnz	$_052
	dec	edi
	jz	$_054
	jmp	$_053

$_052:	mov	rcx, rbx
	call	$_001
	test	rax, rax
	jnz	$_054
$_053:	add	rbx, 32
	mov	al, byte ptr [rbx]
	jmp	$_050

$_054:	test	edi, edi
	jz	$_057
	inc	dword ptr [rsi]
	mov	rax, qword ptr [rbp+0x58]
	mov	qword ptr [rsp+0x30], rax
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	$_127
	cmp	eax, -1
	jnz	$_055
	jmp	$_107

$_055:	imul	ebx, dword ptr [rsi], 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 41
	jz	$_056
	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_107

$_056:	inc	dword ptr [rsi]
	xor	eax, eax
	jmp	$_107

$_057:	mov	edi, dword ptr [rsi]
	mov	rbx, qword ptr [rbp+0x38]
	mov	byte ptr [rbp-0x1], 0
	mov	dword ptr [rbp-0x8], 685
	mov	dword ptr [rbp-0xC], edi
	lea	r9, [rbp-0x78]
	mov	r8, rbx
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	$_042
	cmp	eax, -1
	jnz	$_058
	jmp	$_107

$_058:	cmp	dword ptr [rbp-0x3C], 2
	jnz	$_060
	test	byte ptr [rbp-0x38], 0x01
	jnz	$_060
	mov	rax, qword ptr [rbp-0x60]
	test	rax, rax
	jz	$_060
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x70
	jz	$_060
	mov	eax, 1101
	cmp	byte ptr [r14+0x2A], 4
	jnz	$_059
	mov	eax, 1102
$_059:	mov	dword ptr [rbp-0x8], eax
	inc	byte ptr [rbp-0x1]
$_060:	mov	edi, dword ptr [rsi]
	mov	dword ptr [rbp-0x7C], edi
	imul	eax, edi, 32
	add	rax, rbx
	mov	rcx, rax
	call	$_001
	cmp	rax, 7
	jz	$_061
	cmp	eax, 8
	jnz	$_062
$_061:	mov	eax, 0
	jmp	$_063

$_062:	test	eax, eax
	jz	$_063
	inc	edi
	mov	dword ptr [rsi], edi
$_063:	mov	dword ptr [rbp-0x80], eax
	mov	edx, dword ptr [rbp+0x40]
	mov	rax, qword ptr [rbp+0x28]
	mov	eax, dword ptr [rax+rdx*4+0x10]
	mov	dword ptr [rbp-0x84], eax
	mov	edx, dword ptr [rbp-0x80]
	cmp	edx, 11
	jc	$_068
	cmp	dword ptr [rbp-0x3C], -2
	jz	$_064
	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_107

$_064:	mov	rcx, qword ptr [rbp+0x58]
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rcx], rax
	lea	rcx, [flaginstr+rip]
	movzx	ecx, byte ptr [rcx+rdx-0xB]
	mov	edx, dword ptr [rbp+0x48]
	xor	edx, 0x01
	mov	dword ptr [rbp-0x88], ecx
	mov	dword ptr [rbp-0x8C], edx
	lea	eax, [rdi+0x1]
	cmp	eax, dword ptr [r14+0x64]
	jge	$_067
	cmp	dword ptr [rbp-0x80], 11
	jz	$_065
	cmp	dword ptr [rbp-0x80], 12
	jnz	$_067
$_065:	imul	eax, eax, 32
	add	rax, rbx
	mov	rcx, rax
	call	$_001
	mov	ecx, dword ptr [rbp-0x88]
	mov	edx, dword ptr [rbp-0x8C]
	cmp	eax, 11
	jz	$_066
	cmp	eax, 12
	jnz	$_067
$_066:	mov	ecx, 97
	xor	edx, 0x01
	add	edi, 2
	mov	dword ptr [rsi], edi
$_067:	mov	r9d, dword ptr [rbp-0x84]
	mov	r8d, edx
	mov	edx, ecx
	mov	rcx, qword ptr [rbp+0x50]
	call	$_039
	xor	eax, eax
	jmp	$_107

$_068:	mov	eax, dword ptr [rbp-0x3C]
	jmp	$_071

$_069:	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_107

$_070:	mov	ecx, 2050
	call	asmerr@PLT
	jmp	$_107

	jmp	$_072

$_071:	cmp	eax, -2
	jz	$_069
	cmp	eax, 3
	jz	$_070
$_072:	cmp	dword ptr [rbp-0x80], 0
	jne	$_084
	jmp	$_082

$_073:	test	byte ptr [rbp-0x38], 0x01
	jnz	$_075
	cmp	byte ptr [rbp-0x1], 0
	jnz	$_075
	mov	edx, 834
	test	byte ptr [r14+0x1], 0x08
	jz	$_074
	mov	edx, 679
$_074:	mov	qword ptr [rsp+0x30], rbx
	mov	eax, dword ptr [rbp-0x7C]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0xC]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x7C]
	mov	r8d, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_033
	mov	rdx, qword ptr [rbp+0x58]
	mov	qword ptr [rdx], rax
	mov	r9d, dword ptr [rbp-0x84]
	mov	r8d, dword ptr [rbp+0x48]
	mov	edx, 122
	mov	rcx, rax
	call	$_039
	jmp	$_083

$_075:	mov	qword ptr [rsp+0x30], rbx
	mov	dword ptr [rsp+0x28], 0
	mov	dword ptr [rsp+0x20], -2
	mov	r9d, dword ptr [rbp-0x7C]
	mov	r8d, dword ptr [rbp-0xC]
	mov	edx, dword ptr [rbp-0x8]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_033
	mov	rdx, qword ptr [rbp+0x58]
	mov	qword ptr [rdx], rax
	mov	r9d, dword ptr [rbp-0x84]
	mov	r8d, dword ptr [rbp+0x48]
	mov	edx, 122
	mov	rcx, rax
	call	$_039
	jmp	$_083

$_076:	cmp	dword ptr [rbp-0x74], 0
	jz	$_077
	cmp	dword ptr [rbp-0x74], -1
	jz	$_077
	call	EmitConstError@PLT
	jmp	$_107

$_077:	mov	rcx, qword ptr [rbp+0x58]
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rcx], rax
	mov	edx, dword ptr [rbp+0x48]
	xor	edx, 0x01
	cmp	dword ptr [rbp+0x48], 0
	jz	$_078
	cmp	dword ptr [rbp-0x78], 0
	jnz	$_079
$_078:	test	edx, edx
	jz	$_080
	cmp	dword ptr [rbp-0x78], 0
	jnz	$_080
$_079:	lea	r9, [EOLSTR+rip]
	mov	r8d, dword ptr [rbp-0x84]
	lea	rdx, [DS0005+rip]
	mov	rcx, qword ptr [rbp+0x50]
	call	tsprintf@PLT
	jmp	$_081

$_080:	mov	byte ptr [rax], 0
$_081:	jmp	$_083

$_082:	cmp	eax, 2
	je	$_073
	cmp	eax, 1
	je	$_075
	cmp	eax, 0
	jz	$_076
$_083:	xor	eax, eax
	jmp	$_107

$_084:	mov	edi, dword ptr [rsi]
	mov	dword ptr [rbp-0x90], edi
	imul	eax, edi, 32
	cmp	byte ptr [rbx+rax], 9
	jnz	$_085
	mov	rax, qword ptr [rbx+rax+0x10]
	cmp	word ptr [rax], 38
	jnz	$_085
	inc	dword ptr [rsi]
$_085:	lea	r9, [rbp-0xF8]
	mov	r8, rbx
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	$_042
	cmp	eax, -1
	je	$_107
	mov	eax, dword ptr [rbp-0xBC]
	test	eax, eax
	jz	$_091
	cmp	eax, 1
	jz	$_091
	cmp	eax, 2
	jz	$_091
	cmp	eax, 3
	jnz	$_089
	cmp	byte ptr [rbp-0x1], 0
	jz	$_086
	mov	dword ptr [rbp-0xBC], 1
	jmp	$_088

$_086:	cmp	dword ptr [rbp-0x3C], 1
	jnz	$_088
	cmp	byte ptr [rbp-0x34], 35
	jnz	$_087
	mov	dword ptr [rbp-0x8], 1102
	jmp	$_088

$_087:	cmp	byte ptr [rbp-0x34], 39
	jnz	$_088
	mov	dword ptr [rbp-0x8], 1101
$_088:	jmp	$_090

$_089:	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_107

$_090:	jmp	$_093

$_091:	cmp	eax, 1
	jnz	$_093
	cmp	byte ptr [rbp-0x1], 0
	jz	$_093
	cmp	byte ptr [rbp-0xB4], 35
	jnz	$_092
	mov	dword ptr [rbp-0x8], 1102
	jmp	$_093

$_092:	cmp	byte ptr [rbp-0xB4], 39
	jnz	$_093
	mov	dword ptr [rbp-0x8], 1101
$_093:	mov	edi, dword ptr [rsi]
	mov	dword ptr [rbp-0xFC], edi
	mov	ecx, dword ptr [rbp-0x80]
	cmp	ecx, 9
	jnz	$_095
	mov	edx, 834
	test	byte ptr [r14+0x1], 0x08
	jz	$_094
	mov	edx, 679
$_094:	mov	qword ptr [rsp+0x30], rbx
	mov	eax, dword ptr [rbp-0xFC]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0x90]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x7C]
	mov	r8d, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_033
	mov	rcx, qword ptr [rbp+0x58]
	mov	qword ptr [rcx], rax
	mov	r9d, dword ptr [rbp-0x84]
	mov	r8d, dword ptr [rbp+0x48]
	mov	edx, 101
	mov	rcx, rax
	call	$_039
	jmp	$_106

$_095:	cmp	ecx, 6
	ja	$_105
	cmp	dword ptr [rbp-0xF8], 0
	jnz	$_098
	cmp	dword ptr [rbp-0xF4], 0
	jnz	$_098
	cmp	ecx, 1
	jz	$_096
	cmp	ecx, 2
	jnz	$_098
$_096:	cmp	dword ptr [rbp-0x3C], 2
	jnz	$_098
	test	byte ptr [rbp-0x38], 0x01
	jnz	$_098
	cmp	dword ptr [rbp-0xBC], 0
	jnz	$_098
	cmp	byte ptr [rbp-0x1], 0
	jnz	$_098
	mov	edx, 834
	test	byte ptr [r14+0x1], 0x08
	jz	$_097
	mov	edx, 679
$_097:	mov	qword ptr [rsp+0x30], rbx
	mov	eax, dword ptr [rbp-0x7C]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0xC]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x7C]
	mov	r8d, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_033
	jmp	$_100

$_098:	cmp	byte ptr [rbp-0x34], 193
	jnz	$_099
	mov	rcx, qword ptr [rbp-0x20]
	test	rcx, rcx
	jz	$_099
	test	byte ptr [rcx+0x11], 0x40
	jz	$_099
	cmp	byte ptr [rcx+0x5A], 1
	jnz	$_099
	cmp	dword ptr [rbp-0xF8], 1
	jnz	$_099
	xor	dword ptr [rbp+0x48], 0x01
	or	byte ptr [rcx+0x13], 0x10
$_099:	mov	qword ptr [rsp+0x30], rbx
	mov	eax, dword ptr [rbp-0xFC]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0x90]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x7C]
	mov	r8d, dword ptr [rbp-0xC]
	mov	edx, dword ptr [rbp-0x8]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_033
$_100:	mov	rbx, qword ptr [rbp+0x58]
	mov	qword ptr [rbx], rax
	mov	rdx, qword ptr [rbp+0x28]
	movzx	edi, byte ptr [rdx+0x32]
	and	edi, 0x04
	shr	edi, 2
	mov	ecx, dword ptr [rbp-0x80]
	movzx	edx, byte ptr [rbp-0x34]
	movzx	eax, byte ptr [rbp-0xB4]
	and	edx, 0xC0
	and	eax, 0xC0
	test	edi, edi
	jnz	$_101
	cmp	edx, 64
	jz	$_101
	cmp	eax, 64
	jnz	$_102
$_101:	lea	rdi, [signed_cjmptype+rip]
	movzx	edx, byte ptr [rdi+rcx-0x1]
	jmp	$_103

$_102:	lea	rdi, [unsign_cjmptype+rip]
	movzx	edx, byte ptr [rdi+rcx-0x1]
$_103:	mov	eax, dword ptr [rbp+0x48]
	lea	rdi, [neg_cjmptype+rip]
	cmp	byte ptr [rdi+rcx-0x1], 0
	jnz	$_104
	xor	eax, 0x01
$_104:	mov	r9d, dword ptr [rbp-0x84]
	mov	r8d, eax
	mov	rcx, qword ptr [rbx]
	call	$_039
	jmp	$_106

$_105:	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_107

$_106:	xor	eax, eax
$_107:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_108:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	byte ptr [rcx], 0
	jnz	$_109
	lea	rdx, [DS0006+rip]
	call	tstrcpy@PLT
	jmp	$_114

$_109:	inc	rcx
	mov	eax, dword ptr [rcx]
	jmp	$_111

	mov	byte ptr [rcx+0x1], al
	mov	byte ptr [rcx], 110
	jmp	$_114

	mov	byte ptr [rcx], ah
	mov	byte ptr [rcx+0x1], 32
	jmp	$_114

	mov	byte ptr [rcx], 98
	jmp	$_112

	mov	byte ptr [rcx], 97
	jmp	$_112

	mov	byte ptr [rcx], 108
	jmp	$_112

	mov	byte ptr [rcx], 103
	jmp	$_112

LC0099: cmp	al, 109
	jnz	$_110
	dec	rcx
	mov	byte ptr [rcx], 0
$_110:	jmp	$_114

	jmp	$_112

$_111:	cmp	al, 97
	jl	LC0099
	cmp	al, 122
	jg	LC0099
	movsx	r10, al
	lea	r11, [LC009B+rip]
	movzx	r10, byte ptr [r11+r10-0x5A]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC0099+rip]
	sub	r11, r10
	jmp	r11

$_112:	cmp	ah, 101
	jnz	$_113
	mov	byte ptr [rcx+0x1], 32
	jmp	$_114

$_113:	mov	byte ptr [rcx+0x1], 101
$_114:	leave
	ret

$_115:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	rbx, rcx
	lea	rsi, [rbp-0x10]
	lea	rdi, [rbp-0x20]
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp+0x30]
	call	GetLabelStr
	mov	rdx, rdi
	mov	ecx, dword ptr [rbp+0x38]
	call	GetLabelStr
	mov	rcx, rdi
	call	tstrlen@PLT
	mov	ebx, eax
	mov	rax, qword ptr [rbp+0x28]
	jmp	$_117

$_116:	mov	r8d, ebx
	mov	rdx, rdi
	mov	rcx, rax
	call	tmemcpy@PLT
	add	rax, rbx
$_117:	mov	rdx, rsi
	mov	rcx, rax
	call	tstrstr@PLT
	test	rax, rax
	jnz	$_116
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_118:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 104
	mov	rdi, qword ptr [rbp+0x58]
	mov	rsi, qword ptr [rbp+0x50]
	mov	dword ptr [rbp-0x4], 0
$_119:	mov	qword ptr [rsp+0x30], rdi
	mov	qword ptr [rsp+0x28], rsi
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp+0x28]
	call	$_047
	cmp	eax, -1
	je	$_126
	mov	rbx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rbx]
	imul	eax, eax, 32
	add	rax, qword ptr [rbp+0x38]
	mov	rcx, rax
	call	$_001
	cmp	rax, 7
	jne	$_124
	inc	dword ptr [rbx]
	mov	rbx, qword ptr [rdi]
	test	rbx, rbx
	je	$_123
	cmp	dword ptr [rbp+0x48], 0
	je	$_123
	mov	rcx, rbx
	call	$_108
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_120
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rbp-0x4], eax
$_120:	cmp	byte ptr [rbx], 0
	jz	$_121
	lea	rdx, [rbx+0x4]
	mov	ecx, dword ptr [rbp-0x4]
	call	GetLabelStr
	lea	rdx, [EOLSTR+rip]
	mov	rcx, rax
	call	tstrcat@PLT
$_121:	mov	rbx, rsi
	cmp	dword ptr [rdi+0x8], 0
	jz	$_122
	mov	r8d, dword ptr [rbp-0x4]
	mov	edx, dword ptr [rdi+0x8]
	mov	rcx, rbx
	call	$_115
$_122:	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rbp-0x8], eax
	mov	edx, dword ptr [rbp+0x40]
	mov	rax, qword ptr [rbp+0x28]
	mov	eax, dword ptr [rax+rdx*4+0x10]
	mov	dword ptr [rbp-0xC], eax
	mov	rcx, rbx
	call	tstrlen@PLT
	add	rbx, rax
	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rbp-0xC]
	call	GetLabelStr
	mov	rcx, rax
	lea	rax, [EOLSTR+rip]
	mov	qword ptr [rsp+0x20], rax
	lea	r9, [DS0008+rip]
	mov	r8, rcx
	lea	rdx, [DS0007+rip]
	mov	rcx, rbx
	call	tsprintf@PLT
	mov	r8d, dword ptr [rbp-0x8]
	mov	edx, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_115
	mov	qword ptr [rdi], 0
$_123:	mov	rcx, rsi
	call	tstrlen@PLT
	add	rsi, rax
	mov	dword ptr [rdi+0x8], 0
	jmp	$_119

$_124:	cmp	dword ptr [rbp-0x4], 0
	jz	$_125
	mov	rcx, rsi
	call	tstrlen@PLT
	add	rsi, rax
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	GetLabelStr
	lea	rdx, [DS0008+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	lea	rdx, [EOLSTR+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	qword ptr [rdi], 0
$_125:	mov	eax, 0
$_126:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_127:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 104
	mov	rsi, qword ptr [rbp+0x50]
	mov	rdi, qword ptr [rbp+0x58]
	mov	dword ptr [rbp-0x4], 0
$_128:	mov	qword ptr [rsp+0x30], rdi
	mov	qword ptr [rsp+0x28], rsi
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp+0x28]
	call	$_118
	cmp	eax, -1
	je	$_137
	mov	rbx, qword ptr [rbp+0x30]
	imul	eax, dword ptr [rbx], 32
	add	rax, qword ptr [rbp+0x38]
	mov	rcx, rax
	call	$_001
	cmp	rax, 8
	jne	$_134
	inc	dword ptr [rbx]
	mov	rbx, qword ptr [rdi]
	test	rbx, rbx
	je	$_133
	cmp	dword ptr [rbp+0x48], 0
	jne	$_133
	mov	rcx, rbx
	call	$_108
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_129
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rbp-0x4], eax
$_129:	cmp	byte ptr [rbx], 0
	jz	$_130
	lea	rdx, [rbx+0x4]
	mov	ecx, dword ptr [rbp-0x4]
	call	GetLabelStr
	lea	rdx, [EOLSTR+rip]
	mov	rcx, rax
	call	tstrcat@PLT
$_130:	mov	rbx, rsi
	cmp	dword ptr [rdi+0x8], 0
	jz	$_131
	mov	r8d, dword ptr [rbp-0x4]
	mov	edx, dword ptr [rdi+0x8]
	mov	rcx, rbx
	call	$_115
$_131:	mov	qword ptr [rdi], 0
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rbp-0x8], eax
	mov	edx, dword ptr [rbp+0x40]
	mov	rax, qword ptr [rbp+0x28]
	mov	eax, dword ptr [rax+rdx*4+0x10]
	mov	dword ptr [rbp-0xC], eax
	mov	rcx, rbx
	call	tstrlen@PLT
	add	rbx, rax
	mov	rax, qword ptr [rbp+0x28]
	cmp	dword ptr [rax+0x28], 2
	jnz	$_132
	mov	r8d, dword ptr [rbp-0x8]
	mov	edx, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_115
	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rbp-0x8]
	call	GetLabelStr
	mov	rcx, rax
	lea	rax, [EOLSTR+rip]
	mov	qword ptr [rsp+0x20], rax
	lea	r9, [DS0008+rip]
	mov	r8, rcx
	lea	rdx, [DS0007+rip]
	mov	rcx, rbx
	call	tsprintf@PLT
	jmp	$_133

$_132:	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rbp-0xC]
	call	GetLabelStr
	mov	rcx, rax
	lea	rax, [EOLSTR+rip]
	mov	qword ptr [rsp+0x20], rax
	lea	r9, [DS0008+rip]
	mov	r8, rcx
	lea	rdx, [DS0007+rip]
	mov	rcx, rbx
	call	tsprintf@PLT
	mov	r8d, dword ptr [rbp-0x8]
	mov	edx, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp+0x50]
	call	$_115
$_133:	mov	rcx, rsi
	call	tstrlen@PLT
	add	rsi, rax
	mov	dword ptr [rdi+0x8], 0
	jmp	$_128

$_134:	cmp	dword ptr [rbp-0x4], 0
	jz	$_136
	mov	rbx, qword ptr [rdi]
	test	rbx, rbx
	jz	$_135
	cmp	dword ptr [rdi+0x8], 0
	jz	$_135
	mov	r8d, dword ptr [rbp-0x4]
	mov	edx, dword ptr [rdi+0x8]
	mov	rcx, rsi
	call	$_115
	mov	edx, 10
	mov	rcx, rbx
	call	tstrchr@PLT
	mov	byte ptr [rax+0x1], 0
$_135:	mov	rcx, rsi
	call	tstrlen@PLT
	add	rsi, rax
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	GetLabelStr
	lea	rdx, [DS0008+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	lea	rdx, [EOLSTR+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rdi+0x8], eax
$_136:	mov	eax, 0
$_137:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ExpandCStrings:
	mov	qword ptr [rsp+0x8], rcx
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	xor	eax, eax
	test	byte ptr [rcx+0x2], 0x40
	je	$_156
	test	byte ptr [Options+0x6+rip], 0x10
	jne	$_156
	xor	edi, edi
	mov	rbx, rcx
$_138:	cmp	byte ptr [rbx], 0
	je	$_156
	test	byte ptr [rbx+0x2], 0x08
	je	$_155
	xor	edx, edx
	xor	ecx, ecx
	mov	al, byte ptr [rbx]
$_139:	test	al, al
	jz	$_146
	jmp	$_144

$_140:	test	edx, edx
	jz	$_146
	inc	ecx
	jmp	$_145

$_141:	dec	ecx
	jmp	$_145

$_142:	inc	edx
	jmp	$_145

$_143:	dec	edx
	jmp	$_145

$_144:	cmp	al, 40
	jz	$_140
	cmp	al, 41
	jz	$_141
	cmp	al, 91
	jz	$_142
	cmp	al, 93
	jz	$_143
$_145:	add	rbx, 32
	inc	edi
	mov	al, byte ptr [rbx]
	jmp	$_139

$_146:	cmp	al, 40
	jz	$_147
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_156

$_147:	mov	rdx, qword ptr [rbp+0x20]
	mov	ecx, edi
	call	GenerateCString@PLT
	test	eax, eax
	jnz	$_156
	mov	ecx, 1
	add	rbx, 32
$_148:	cmp	byte ptr [rbx], 0
	jz	$_154
	mov	rdx, qword ptr [rbx+0x10]
	movzx	eax, byte ptr [rdx]
	jmp	$_152

$_149:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2004
	call	asmerr@PLT
	jmp	$_156

	jmp	$_153

$_150:	dec	ecx
	jz	$_154
	jmp	$_153

$_151:	inc	ecx
	jmp	$_153

$_152:	cmp	eax, 34
	jz	$_149
	cmp	eax, 41
	jz	$_150
	cmp	eax, 40
	jz	$_151
$_153:	add	rbx, 32
	jmp	$_148

$_154:	xor	eax, eax
	jmp	$_156

$_155:	add	rbx, 32
	inc	edi
	jmp	$_138

$_156:
	leave
	pop	rbx
	pop	rdi
	ret

$_157:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	imul	ebx, ecx, 32
	add	rbx, rdx
	cmp	byte ptr [rbx], 91
	jnz	$_162
$_158:	cmp	byte ptr [rbx], 0
	jz	$_159
	cmp	byte ptr [rbx], 93
	jz	$_159
	add	rbx, 32
	inc	ecx
	jmp	$_158

$_159:	add	ecx, 3
	add	rbx, 64
	cmp	byte ptr [rbx+0x20], 46
	jz	$_160
	xor	eax, eax
	jmp	$_175

$_160:	mov	byte ptr [rsp+0x20], 0
	mov	r9, qword ptr [rbp+0x38]
	mov	r8d, ecx
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	jnz	$_161
	xor	eax, eax
	jmp	$_175

$_161:	mov	rcx, qword ptr [rbp+0x38]
	mov	rax, qword ptr [rcx+0x60]
	jmp	$_164

$_162:	cmp	byte ptr [rbx], 2
	jnz	$_163
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	call	GetStdAssume@PLT
	jmp	$_164

$_163:	mov	rcx, rbx
	call	SymFindID@PLT
$_164:	test	rax, rax
	je	$_175
	test	byte ptr [rax+0x10], 0x02
	jne	$_175
	cmp	byte ptr [rbx], 8
	jnz	$_169
	cmp	byte ptr [rbx+0x20], 46
	jnz	$_169
	cmp	byte ptr [rbx+0x40], 8
	jnz	$_169
	mov	rcx, rax
	xor	eax, eax
	cmp	byte ptr [rcx+0x1E], 196
	jnz	$_165
	cmp	qword ptr [rcx+0x28], 0
	jz	$_165
	mov	rcx, qword ptr [rcx+0x28]
$_165:	cmp	qword ptr [rcx+0x50], 0
	jz	$_167
	cmp	byte ptr [rcx+0x1E], 195
	jz	$_166
	cmp	byte ptr [rcx+0x4A], 196
	jnz	$_167
$_166:	mov	rcx, qword ptr [rcx+0x50]
$_167:	test	byte ptr [rcx+0x12], 0x02
	jz	$_168
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, qword ptr [rbx+0x50]
	mov	rcx, qword ptr [rcx+0x40]
	call	SearchNameInStruct@PLT
$_168:	jmp	$_175

$_169:	mov	rcx, qword ptr [rax+0x50]
	mov	dl, byte ptr [rax+0x1E]
	cmp	dl, 195
	jnz	$_170
	test	rcx, rcx
	jz	$_170
	test	byte ptr [rcx+0x10], 0x02
	jz	$_170
	mov	rax, rcx
	jmp	$_175

$_170:	cmp	dl, 195
	jnz	$_171
	test	rcx, rcx
	jz	$_171
	cmp	byte ptr [rcx+0x1E], 128
	jnz	$_171
	mov	rax, qword ptr [rax+0x50]
	jmp	$_173

$_171:	mov	rcx, qword ptr [rax+0x28]
	cmp	dl, 196
	jnz	$_173
	cmp	byte ptr [rcx+0x1E], 195
	jz	$_172
	cmp	byte ptr [rcx+0x1E], 128
	jnz	$_173
$_172:	mov	rax, rcx
	cmp	byte ptr [rax+0x1E], 128
	jnz	$_174
$_173:	cmp	byte ptr [rax+0x1E], 128
	jz	$_174
	xor	eax, eax
	jmp	$_175

$_174:	mov	rax, qword ptr [rax+0x50]
$_175:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_176:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, qword ptr [rdx+0x78]
	mov	rax, qword ptr [rsi+0x18]
	test	rax, rax
	jnz	$_177
	jmp	$_189

$_177:	xor	edi, edi
	jmp	$_179

$_178:	mov	rax, qword ptr [rax+0x88]
	inc	edi
$_179:	cmp	qword ptr [rax+0x88], 0
	jnz	$_178
	cmp	edi, ecx
	jnc	$_180
	xor	eax, eax
	jmp	$_189

$_180:	mov	bl, byte ptr [rdx+0x1F]
	cmp	bl, 3
	jz	$_181
	cmp	bl, 1
	jz	$_181
	cmp	bl, 2
	jz	$_181
	cmp	bl, 8
	jz	$_181
	cmp	bl, 7
	jnz	$_186
	cmp	byte ptr [r14+0x4], 0
	jz	$_186
$_181:	mov	rbx, rax
	jmp	$_185

$_182:	mov	rax, qword ptr [rsi+0x18]
$_183:	cmp	rbx, qword ptr [rax+0x88]
	jz	$_184
	mov	rax, qword ptr [rax+0x88]
	jmp	$_183

$_184:	mov	rbx, rax
	dec	ecx
$_185:	test	ecx, ecx
	jnz	$_182
	jmp	$_188

$_186:	mov	rax, qword ptr [rsi+0x18]
$_187:	test	ecx, ecx
	jz	$_188
	dec	ecx
	mov	rax, qword ptr [rax+0x88]
	jmp	$_187

$_188:	test	rax, rax
	jz	$_189
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_189
	mov	rax, qword ptr [rax+0x28]
$_189:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_190:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 656
	lea	r8, [rbp-0x68]
	call	$_157
	test	rax, rax
	je	$_205
	cmp	byte ptr [rax+0x1D], 6
	jne	$_197
	mov	rsi, rax
	imul	ebx, dword ptr [rbp+0x20], 32
	add	rbx, qword ptr [rbp+0x28]
	cmp	byte ptr [rbx], 91
	jnz	$_191
	mov	rcx, qword ptr [rbp-0x8]
	jmp	$_193

$_191:	mov	rcx, rbx
	call	SymFindID@PLT
	test	rax, rax
	je	$_205
	xor	ecx, ecx
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_192
	mov	rcx, qword ptr [rax+0x28]
	jmp	$_193

$_192:	cmp	byte ptr [rax+0x1E], 195
	jnz	$_193
	mov	rcx, qword ptr [rax+0x50]
$_193:	test	rcx, rcx
	jz	$_194
	cmp	word ptr [rcx+0x6E], 1
	jz	$_195
$_194:	xor	eax, eax
	jmp	$_205

$_195:	mov	rdx, qword ptr [rcx+0x8]
	lea	rcx, [rbp-0x268]
	call	tstrcpy@PLT
	lea	rdx, [DS0009+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rdx, qword ptr [rsi+0x8]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rcx, rax
	call	SymFind@PLT
	test	rax, rax
	je	$_205
	cmp	byte ptr [rax+0x1D], 10
	jnz	$_196
	mov	rcx, qword ptr [rax+0x30]
	call	SymFind@PLT
	test	rax, rax
	je	$_205
$_196:	or	byte ptr [rsi+0x13], 0x08
	mov	qword ptr [rsi+0x40], rax
	mov	rcx, rax
	xor	eax, eax
	jmp	$_199

$_197:	mov	rcx, qword ptr [rax+0x50]
	mov	rdx, rax
	xor	eax, eax
	cmp	byte ptr [rdx+0x1D], 2
	jz	$_198
	cmp	byte ptr [rdx+0x1D], 5
	jnz	$_205
$_198:	test	rcx, rcx
	jz	$_205
$_199:	cmp	byte ptr [rcx+0x1D], 9
	jnz	$_205
	mov	rcx, qword ptr [rcx+0x78]
	mov	rcx, qword ptr [rcx+0x10]
	test	rcx, rcx
	jz	$_205
	jmp	$_201

$_200:	mov	rcx, qword ptr [rcx]
$_201:	cmp	qword ptr [rcx], 0
	jnz	$_200
	lea	rcx, [rcx+0x9]
	mov	edx, dword ptr [rcx]
	cmp	edx, 1836344690
	jnz	$_205
	add	rcx, 4
	mov	dl, byte ptr [rcx]
$_202:	test	dl, dl
	jz	$_203
	cmp	dl, 60
	jz	$_203
	inc	rcx
	mov	dl, byte ptr [rcx]
	jmp	$_202

$_203:	cmp	dl, 60
	jnz	$_205
$_204:	inc	rcx
	mov	dl, byte ptr [rcx]
	cmp	dl, 32
	jz	$_204
	cmp	dl, 9
	jz	$_204
	test	dl, dl
	jz	$_205
	cmp	dl, 62
	jz	$_205
	mov	rax, rcx
$_205:	leave
	pop	rbx
	pop	rsi
	ret

$_206:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rdi, rcx
	mov	rbx, r8
	xor	ecx, ecx
	mov	edx, edx
	mov	rsi, qword ptr [rbx+0x18]
$_207:	test	edx, edx
	jz	$_216
	movzx	eax, byte ptr [rbx]
	jmp	$_214

$_208:	jmp	$_216

$_209:	inc	ecx
	jmp	$_215

$_210:	test	ecx, ecx
	jz	$_211
	dec	ecx
	jmp	$_215

$_211:	mov	rax, qword ptr [rbx+0x18]
	sub	rax, rsi
	mov	ecx, eax
	rep movsb
	jmp	$_217

$_212:	dec	edx
	jnz	$_213
	mov	rax, qword ptr [rbx+0x18]
	sub	rax, rsi
	mov	ecx, eax
	rep movsb
	jmp	$_217

$_213:	mov	rsi, qword ptr [rbx+0x38]
	jmp	$_215

$_214:	cmp	eax, 0
	jz	$_208
	cmp	eax, 40
	jz	$_209
	cmp	eax, 41
	jz	$_210
	cmp	eax, 44
	jz	$_212
$_215:	add	rbx, 32
	jmp	$_207

$_216:	xor	eax, eax
$_217:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_218:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2280
	mov	qword ptr [rbp-0x8], 0
	mov	qword ptr [rbp-0x18], 0
	mov	dword ptr [rbp-0x1C], 0
	mov	dword ptr [rbp-0x8C], 0
	mov	dword ptr [rbp-0x90], 0
	lea	rdi, [rbp-0x894]
	mov	rbx, r8
	xor	edx, edx
$_219:	cmp	edx, dword ptr [rbp+0x28]
	jge	$_227
	test	edx, edx
	jz	$_226
	test	byte ptr [rbx+0x2], 0x08
	jz	$_220
	mov	qword ptr [rbp-0x18], rbx
	mov	dword ptr [rbp-0x1C], 0
$_220:	jmp	$_225

$_221:	dec	dword ptr [rbp-0x8C]
	jmp	$_226

$_222:	inc	dword ptr [rbp-0x8C]
	jmp	$_226

$_223:	cmp	qword ptr [rbp-0x18], 0
	jz	$_224
	inc	dword ptr [rbp-0x1C]
$_224:	jmp	$_226

$_225:	cmp	byte ptr [rbx], 41
	jz	$_221
	cmp	byte ptr [rbx], 40
	jz	$_222
	cmp	byte ptr [rbx], 44
	jz	$_223
$_226:	mov	rsi, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rbx+0x38]
	sub	rcx, rsi
	rep movsb
	inc	edx
	add	rbx, 32
	jmp	$_219

$_227:
	mov	byte ptr [rdi], 0
	mov	rdi, qword ptr [rbp+0x38]
	xor	esi, esi
	cmp	dword ptr [rbp-0x8C], 0
	jnz	$_228
	mov	qword ptr [rbp-0x18], rsi
$_228:	mov	rdx, rdi
	mov	ecx, dword ptr [rbp+0x28]
	call	$_190
	test	rax, rax
	jz	$_229
	mov	qword ptr [rbp-0x8], rax
	jmp	$_296

$_229:	mov	rax, qword ptr [rbp-0x18]
	cmp	rax, qword ptr [rbp+0x38]
	jbe	$_230
	cmp	byte ptr [rax-0x20], 91
	jnz	$_230
	xor	eax, eax
$_230:	test	rax, rax
	je	$_257
	sub	rax, qword ptr [rbp+0x38]
	mov	ecx, 32
	xor	edx, edx
	div	ecx
	mov	ecx, eax
	lea	r8, [rbp-0x88]
	mov	rdx, qword ptr [rbp+0x38]
	call	$_157
	test	rax, rax
	je	$_257
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_233
	test	byte ptr [rax+0x13], 0x08
	jz	$_231
	mov	rax, qword ptr [rax+0x40]
	jmp	$_232

$_231:	mov	rax, qword ptr [rax+0x28]
$_232:	cmp	byte ptr [rax+0x1E], 195
	jnz	$_233
	cmp	byte ptr [rax+0x49], 0
	jz	$_233
	mov	rax, qword ptr [rax+0x50]
$_233:	mov	rdx, rax
	mov	ecx, dword ptr [rbp-0x1C]
	call	$_176
	mov	rcx, rax
	test	rcx, rcx
	je	$_257
	mov	eax, dword ptr [rcx+0x60]
	jmp	$_256

$_234:	mov	esi, 1
	jmp	$_257

$_235:	mov	esi, 9
	jmp	$_257

$_236:	mov	esi, 17
	cmp	byte ptr [r14+0x4], 2
	jnz	$_238
	test	byte ptr [rcx+0x1E], 0x20
	jz	$_237
	mov	esi, 40
$_237:	jmp	$_242

$_238:	cmp	byte ptr [r14+0x4], 0
	jnz	$_242
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_239
	mov	eax, 128
	jmp	$_240

$_239:	cmp	eax, 6
	jc	$_240
	mov	eax, 6
$_240:	cmp	eax, 3
	jnc	$_242
	cmp	byte ptr [rbx-0x20], 13
	jnz	$_241
	mov	esi, 9
	jmp	$_242

$_241:	mov	esi, 11
	mov	dword ptr [rbp-0x90], 9
$_242:	jmp	$_257

$_243:	cmp	byte ptr [r14+0x4], 2
	jnz	$_246
	test	byte ptr [rcx+0x1E], 0x20
	jz	$_244
	mov	esi, 40
	jmp	$_245

$_244:	mov	esi, 163
$_245:	jmp	$_248

$_246:	cmp	byte ptr [rbx-0x20], 13
	jnz	$_247
	mov	esi, 17
	jmp	$_248

$_247:	mov	esi, 19
	mov	dword ptr [rbp-0x90], 17
$_248:	jmp	$_257

$_249:	test	byte ptr [rcx+0x1E], 0x20
	jz	$_250
	mov	esi, 40
	jmp	$_251

$_250:	cmp	byte ptr [r14+0x4], 2
	jnz	$_251
	mov	esi, 165
	mov	dword ptr [rbp-0x90], 163
$_251:	jmp	$_257

$_252:	cmp	byte ptr [rcx+0x1E], 31
	jnz	$_253
	mov	esi, 48
$_253:	jmp	$_257

$_254:	cmp	byte ptr [rcx+0x1E], 63
	jnz	$_255
	mov	esi, 64
$_255:	jmp	$_257

$_256:	cmp	eax, 1
	je	$_234
	cmp	eax, 2
	je	$_235
	cmp	eax, 4
	je	$_236
	cmp	eax, 8
	je	$_243
	cmp	eax, 16
	jz	$_249
	cmp	eax, 32
	jz	$_252
	cmp	eax, 64
	jz	$_254
$_257:	test	esi, esi
	jne	$_295
	mov	esi, dword ptr [r14+0x5C]
	mov	eax, dword ptr [rbp+0x28]
	cmp	qword ptr [rbp-0x18], 0
	jne	$_295
	cmp	eax, 1
	jbe	$_295
	imul	eax, eax, 32
	lea	rbx, [rdi+rax-0x40]
	cmp	byte ptr [rbx+0x20], 44
	jne	$_294
	cmp	byte ptr [rbx], 93
	je	$_294
	xor	eax, eax
	cmp	byte ptr [rbx], 2
	jnz	$_258
	mov	ecx, dword ptr [rbx+0x4]
	call	SizeFromRegister@PLT
	jmp	$_280

$_258:	mov	rcx, qword ptr [rbx+0x10]
	call	SymFind@PLT
	test	rax, rax
	jz	$_262
	cmp	byte ptr [r14+0x4], 2
	jnz	$_260
	cmp	byte ptr [rax+0x1E], 35
	jz	$_259
	cmp	byte ptr [rax+0x1E], 39
	jnz	$_260
$_259:	mov	eax, 16
	jmp	$_261

$_260:	mov	r8, qword ptr [rax+0x28]
	mov	edx, 254
	movzx	ecx, byte ptr [rax+0x1E]
	call	SizeFromMemtype@PLT
$_261:	jmp	$_280

$_262:	cmp	byte ptr [rbx-0x20], 46
	jne	$_280
$_263:	mov	eax, dword ptr [rbp+0x28]
	sub	eax, 2
	xor	edx, edx
$_264:	cmp	eax, 0
	jle	$_272
	mov	cl, byte ptr [rbx]
	mov	ch, byte ptr [rbx-0x20]
	jmp	$_270

$_265:	cmp	ch, 46
	jz	$_266
	test	edx, edx
	jz	$_272
$_266:	jmp	$_271

$_267:	inc	edx
	jmp	$_271

$_268:	dec	edx
	cmp	ch, 46
	jz	$_269
	cmp	ch, 8
	jz	$_269
	test	edx, edx
	jz	$_272
$_269:	jmp	$_271

$_270:	cmp	cl, 8
	jz	$_265
	cmp	cl, 93
	jz	$_267
	cmp	cl, 91
	jz	$_268
$_271:	dec	eax
	sub	rbx, 32
	jmp	$_264

$_272:	cmp	ch, 5
	jnz	$_273
	cmp	eax, 1
	jbe	$_273
	cmp	dword ptr [rbx-0x1C], 335
	jnz	$_273
	sub	eax, 2
$_273:	mov	edx, dword ptr [rbp+0x28]
	sub	edx, 2
	mov	dword ptr [rbp+0x28], eax
	mov	byte ptr [rsp+0x20], 1
	lea	r9, [rbp-0x88]
	mov	r8d, edx
	mov	rdx, qword ptr [rbp+0x38]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	jz	$_279
	xor	eax, eax
	cmp	dword ptr [rbp-0x4C], 1
	jz	$_274
	test	byte ptr [rbp-0x48], 0x01
	jz	$_278
$_274:	cmp	byte ptr [r14+0x4], 2
	jnz	$_276
	cmp	byte ptr [rbp-0x44], 35
	jz	$_275
	cmp	byte ptr [rbp-0x44], 39
	jnz	$_276
$_275:	mov	eax, 16
	jmp	$_277

$_276:	mov	r8, qword ptr [rbp-0x28]
	mov	edx, 254
	movzx	ecx, byte ptr [rbp-0x44]
	call	SizeFromMemtype@PLT
$_277:	cmp	eax, 10
	jnz	$_278
	mov	eax, 16
$_278:	jmp	$_280

$_279:	xor	eax, eax
$_280:	mov	dword ptr [rbp-0x94], eax
	jmp	$_292

$_281:	mov	esi, 1
	jmp	$_293

$_282:	mov	esi, 9
	jmp	$_293

$_283:	mov	esi, 17
	cmp	byte ptr [r14+0x4], 0
	jnz	$_284
	mov	esi, 11
	mov	dword ptr [rbp-0x90], 9
$_284:	jmp	$_293

$_285:	cmp	byte ptr [r14+0x4], 2
	jnz	$_286
	mov	esi, 163
	jmp	$_287

$_286:	cmp	byte ptr [r14+0x4], 1
	jnz	$_287
	mov	esi, 19
	mov	dword ptr [rbp-0x90], 17
$_287:	jmp	$_293

$_288:	mov	esi, 40
	cmp	dword ptr [rdi+0x4], 779
	jnz	$_289
	mov	esi, 165
	mov	dword ptr [rbp-0x90], 163
$_289:	jmp	$_293

$_290:	mov	esi, 48
	jmp	$_293

$_291:	mov	esi, 64
	jmp	$_293

$_292:	cmp	eax, 1
	je	$_281
	cmp	eax, 2
	je	$_282
	cmp	eax, 4
	je	$_283
	cmp	eax, 8
	jz	$_285
	cmp	eax, 16
	jz	$_288
	cmp	eax, 32
	jz	$_290
	cmp	eax, 64
	jz	$_291
$_293:	jmp	$_295

$_294:	cmp	byte ptr [rbx+0x20], 44
	jnz	$_295
	cmp	byte ptr [rbx], 93
	jnz	$_295
	jmp	$_263

$_295:	xor	edx, edx
	mov	ecx, esi
	call	GetResWName@PLT
	mov	rbx, rax
$_296:	lea	rsi, [rbp-0x894]
	lea	rdx, [DS0006+0x3+rip]
	mov	rcx, rsi
	call	tstrcat@PLT
	cmp	qword ptr [rbp-0x8], 0
	jz	$_301
	mov	rcx, rsi
	call	tstrlen@PLT
	lea	rdi, [rsi+rax]
	mov	rsi, qword ptr [rbp-0x8]
$_297:	lodsb
	mov	ah, byte ptr [rsi]
	test	al, al
	jz	$_300
	cmp	ax, 15393
	jz	$_297
	cmp	ax, 15905
	jz	$_297
	cmp	al, 10
	jnz	$_298
	movzx	edx, ah
	inc	rsi
	lea	r8, [rbx+0x40]
	mov	rcx, rdi
	call	$_206
	add	rdi, rax
	jmp	$_299

$_298:	stosb
$_299:	jmp	$_297

$_300:	mov	byte ptr [rdi-0x1], al
	lea	rsi, [rbp-0x894]
	mov	rdi, qword ptr [rbp+0x38]
	jmp	$_302

$_301:	mov	rdx, rbx
	mov	rcx, rsi
	call	tstrcat@PLT
$_302:	cmp	dword ptr [rbp-0x90], 0
	je	$_309
	imul	ebx, dword ptr [rbp+0x30], 32
	cmp	byte ptr [rbx+rdi], 0
	jne	$_308
	cmp	dword ptr [rdi+0x4], 779
	jne	$_308
	mov	ebx, 64
$_303:	cmp	byte ptr [rbx+rdi], 0
	jz	$_304
	cmp	byte ptr [rbx+rdi], 44
	jz	$_304
	add	ebx, 32
	jmp	$_303

$_304:	cmp	byte ptr [rbx+rdi], 44
	jz	$_305
	mov	rdx, rsi
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_311

$_305:	mov	rbx, qword ptr [rbx+rdi+0x18]
	mov	byte ptr [rbx], 0
	mov	edx, dword ptr [rbp-0x94]
	shr	edx, 1
	mov	ecx, 271
	mov	eax, 11
	cmp	dword ptr [rbp-0x90], 17
	jnz	$_306
	mov	ecx, 274
	mov	eax, 19
	jmp	$_307

$_306:	cmp	dword ptr [rbp-0x90], 163
	jnz	$_307
	mov	ecx, 278
	mov	eax, 165
$_307:	mov	dword ptr [rsp+0x40], eax
	mov	dword ptr [rsp+0x38], edx
	mov	rax, qword ptr [rdi+0x38]
	mov	qword ptr [rsp+0x30], rax
	mov	dword ptr [rsp+0x28], ecx
	mov	eax, dword ptr [rbp-0x90]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, qword ptr [rdi+0x38]
	mov	r8d, ecx
	lea	rdx, [DS000A+rip]
	mov	rcx, rsi
	call	tsprintf@PLT
	mov	byte ptr [rbx], 44
	jmp	$_309

$_308:	lea	rdx, [DS000B+rip]
	mov	rcx, rsi
	call	tstrcat@PLT
	xor	edx, edx
	mov	ecx, dword ptr [rbp-0x90]
	call	GetResWName@PLT
	mov	rdx, rax
	mov	rcx, rsi
	call	tstrcat@PLT
$_309:	imul	ebx, dword ptr [rbp+0x30], 32
	cmp	byte ptr [rbx+rdi], 0
	jz	$_310
	lea	rdx, [DS0006+0x3+rip]
	mov	rcx, rsi
	call	tstrcat@PLT
	mov	rdx, qword ptr [rbx+rdi+0x18]
	mov	rcx, rsi
	call	tstrcat@PLT
$_310:	mov	rcx, rsi
	call	tstrlen@PLT
	lea	ecx, [rax+0x1]
	call	LclAlloc@PLT
	mov	rdx, rsi
	mov	rcx, rax
	call	tstrcpy@PLT
	xor	r9d, r9d
	mov	r8, rdi
	xor	edx, edx
	mov	rcx, rax
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
	mov	eax, 1
$_311:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_312:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2664
	mov	rbx, r8
	lea	rdi, [rbp-0x71]
	lea	rcx, [rbp-0x20]
	xor	eax, eax
	sub	rcx, rdi
	rep stosb
	mov	dword ptr [rbp-0x78], edx
	imul	eax, edx, 32
	add	rbx, rax
	mov	qword ptr [rbp-0x10], rbx
$_313:	cmp	byte ptr [rbx], 0
	je	$_325
	cmp	byte ptr [rbx], 91
	jne	$_322
	inc	dword ptr [rbp-0x5C]
	add	rbx, 32
	inc	dword ptr [rbp-0x78]
$_314:	cmp	dword ptr [rbp-0x5C], 0
	jz	$_321
	cmp	byte ptr [rbx], 0
	jz	$_321
	test	byte ptr [rbx+0x2], 0x08
	jz	$_315
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp-0x78]
	mov	rcx, qword ptr [rbp+0x28]
	call	$_312
	cmp	eax, -1
	je	$_416
	jmp	$_320

$_315:	cmp	byte ptr [rbx], 40
	jnz	$_316
	inc	dword ptr [rbp-0x58]
	jmp	$_320

$_316:	cmp	byte ptr [rbx], 41
	jnz	$_317
	dec	dword ptr [rbp-0x58]
	jmp	$_320

$_317:	cmp	dword ptr [rbp-0x58], 0
	jnz	$_318
	cmp	byte ptr [rbx], 91
	jnz	$_318
	inc	dword ptr [rbp-0x5C]
	jmp	$_320

$_318:	cmp	dword ptr [rbp-0x58], 0
	jnz	$_320
	cmp	byte ptr [rbx], 93
	jnz	$_320
	dec	dword ptr [rbp-0x5C]
	jnz	$_320
	cmp	qword ptr [rbp-0x68], 0
	jnz	$_319
	mov	qword ptr [rbp-0x68], rbx
$_319:	jmp	$_321

$_320:	add	rbx, 32
	inc	dword ptr [rbp-0x78]
	jmp	$_314

$_321:	jmp	$_324

$_322:	cmp	byte ptr [rbx], 46
	jnz	$_323
	mov	eax, dword ptr [rbp-0x60]
	mov	qword ptr [rbp+rax*8-0x130], rbx
	inc	dword ptr [rbp-0x60]
	jmp	$_324

$_323:	cmp	byte ptr [rbx], 40
	jnz	$_324
	jmp	$_325

$_324:	add	rbx, 32
	inc	dword ptr [rbp-0x78]
	jmp	$_313

$_325:	cmp	byte ptr [rbx], 40
	jz	$_326
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_416

$_326:	mov	qword ptr [rbp-0x18], rbx
	mov	rax, qword ptr [rbx-0x10]
	mov	qword ptr [rbp-0x8], rax
	mov	rbx, qword ptr [rbp-0x10]
	cmp	byte ptr [rbx], 91
	jne	$_335
	xor	eax, eax
	cmp	dword ptr [rbp-0x60], 0
	je	$_334
	mov	rdx, qword ptr [rbp-0x130]
	cmp	dword ptr [rbp-0x60], 1
	jle	$_330
	mov	rdi, qword ptr [rbp-0x8]
	lea	rcx, [rdx+0x20]
	call	SymFindID@PLT
	test	rax, rax
	jz	$_328
	cmp	dword ptr [rbp-0x60], 2
	jle	$_327
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_327
	cmp	word ptr [rax+0x6E], 1
	jnz	$_327
	mov	qword ptr [rbp-0x20], rax
	inc	byte ptr [rbp-0x71]
	mov	edi, dword ptr [rbp-0x60]
	sub	edi, 2
	mov	esi, 1
	jmp	$_338

$_327:	jmp	$_329

$_328:	mov	eax, dword ptr [rbx+0x24]
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	call	GetStdAssume@PLT
	test	rax, rax
	jz	$_329
	mov	qword ptr [rbp-0x20], rax
	mov	byte ptr [rbp-0x71], 2
	mov	edi, dword ptr [rbp-0x60]
	inc	dword ptr [rbp-0x60]
	dec	edi
	xor	esi, esi
	jmp	$_338

$_329:	jmp	$_332

$_330:	cmp	byte ptr [rdx+0x40], 40
	jnz	$_332
	mov	rdi, qword ptr [rdx+0x30]
	mov	eax, dword ptr [rbp+0x30]
	mov	dword ptr [rbp-0x58], eax
	mov	rax, qword ptr [rbp-0x130]
	sub	rax, qword ptr [rbp+0x38]
	mov	ecx, 32
	xor	edx, edx
	div	ecx
	mov	ecx, eax
	mov	byte ptr [rsp+0x20], 0
	lea	r9, [rbp-0xE0]
	mov	r8d, ecx
	mov	rdx, qword ptr [rbp+0x38]
	lea	rcx, [rbp-0x58]
	call	EvalOperand@PLT
	cmp	eax, -1
	jz	$_331
	mov	rax, qword ptr [rbp-0x80]
	jmp	$_332

$_331:	xor	eax, eax
$_332:	test	rax, rax
	jz	$_334
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_333
	cmp	word ptr [rax+0x6E], 1
	jnz	$_333
	jmp	$_349

	jmp	$_334

$_333:	xor	eax, eax
$_334:	mov	rcx, rax
	jmp	$_355

$_335:	mov	rcx, rbx
	call	SymFindID@PLT
	mov	qword ptr [rbp-0x20], rax
	mov	edi, dword ptr [rbp-0x60]
	test	edi, edi
	jz	$_336
	dec	edi
$_336:	xor	esi, esi
$_337:	test	rax, rax
	jz	$_341
	test	edi, edi
	jz	$_341
$_338:	mov	rcx, rax
	cmp	byte ptr [rcx+0x1E], 196
	jnz	$_339
	mov	rcx, qword ptr [rcx+0x28]
$_339:	cmp	byte ptr [rcx+0x1E], 195
	jnz	$_340
	mov	rcx, qword ptr [rcx+0x50]
$_340:	test	rcx, rcx
	jz	$_341
	mov	rbx, qword ptr [rbp+rsi*8-0x130]
	add	rbx, 32
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, qword ptr [rbx+0x10]
	call	SearchNameInStruct@PLT
	mov	qword ptr [rbp-0x70], rax
	inc	esi
	dec	edi
	jmp	$_337

$_341:	mov	qword ptr [rbp-0x30], rax
	xor	ecx, ecx
	cmp	qword ptr [rbp-0x70], 0
	jz	$_344
	mov	rdx, qword ptr [rbp-0x20]
	cmp	rdx, rax
	jz	$_342
	cmp	byte ptr [rdx+0x1E], 196
	jnz	$_342
	mov	rdx, qword ptr [rdx+0x28]
$_342:	cmp	rdx, rax
	jz	$_344
	cmp	byte ptr [rdx+0x1E], 195
	jz	$_344
	cmp	dword ptr [rbp-0x60], 2
	jnz	$_343
	mov	qword ptr [rbp-0x70], 0
	jmp	$_344

$_343:	inc	dword ptr [rbp-0x24]
$_344:	cmp	dword ptr [rbp-0x60], 0
	jz	$_345
	mov	rdi, qword ptr [rbp-0x8]
	jmp	$_347

$_345:	test	rax, rax
	jz	$_346
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_346
	cmp	byte ptr [rbx+0x20], 40
	jnz	$_346
	mov	rdi, qword ptr [rbx+0x10]
	mov	rcx, rax
	mov	qword ptr [rbp-0x38], rdi
	jmp	$_347

$_346:	xor	eax, eax
$_347:	mov	rbx, qword ptr [rbp-0x10]
	test	rax, rax
	je	$_355
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_353
	cmp	qword ptr [rax+0x28], 0
	jz	$_353
	mov	rax, qword ptr [rax+0x28]
	cmp	word ptr [rax+0x6E], 3
	jnz	$_348
	mov	rcx, qword ptr [rax+0x50]
	jmp	$_352

$_348:	cmp	word ptr [rax+0x6E], 1
	jnz	$_352
	inc	dword ptr [rbp-0x24]
$_349:	mov	qword ptr [rbp-0x30], rax
	mov	rcx, rax
	xor	eax, eax
	test	byte ptr [rcx+0x12], 0x02
	jz	$_350
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, qword ptr [rcx+0x40]
	call	SearchNameInStruct@PLT
$_350:	test	rax, rax
	jnz	$_351
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp-0x30]
	call	SearchNameInStruct@PLT
	test	rax, rax
	jz	$_351
	mov	qword ptr [rbp-0x40], rax
	mov	qword ptr [rbp-0x30], 0
$_351:	mov	rcx, qword ptr [rbp-0x30]
$_352:	jmp	$_355

$_353:	cmp	byte ptr [rax+0x1E], 195
	jnz	$_355
	cmp	byte ptr [rax+0x1D], 5
	jz	$_354
	cmp	byte ptr [rax+0x1D], 2
	jnz	$_355
$_354:	mov	rcx, qword ptr [rax+0x50]
$_355:	mov	qword ptr [rbp-0x8], rdi
	mov	rdx, rcx
	lea	rdi, [rbp-0xA30]
	mov	eax, 1870032489
	stosd
	mov	eax, 2123115
	stosd
	dec	rdi
	test	rdx, rdx
	je	$_360
	cmp	byte ptr [rdx+0x1D], 7
	jne	$_360
	cmp	word ptr [rdx+0x6E], 1
	jne	$_360
	mov	rsi, rdx
	mov	rax, qword ptr [rsi+0x8]
	mov	qword ptr [rbp-0x48], rax
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, rsi
	call	SearchNameInStruct@PLT
	test	rax, rax
	jz	$_356
	mov	qword ptr [rbp-0x40], rax
$_356:	test	byte ptr [rsi+0x12], 0x02
	jz	$_357
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, qword ptr [rsi+0x40]
	call	SearchNameInStruct@PLT
	test	rax, rax
	jz	$_357
	inc	dword ptr [rbp-0x54]
	mov	qword ptr [rbp-0x40], rax
	mov	rsi, qword ptr [rsi+0x40]
	mov	rax, qword ptr [rsi+0x8]
	mov	qword ptr [rbp-0x48], rax
$_357:	cmp	qword ptr [rbp-0x40], 0
	jnz	$_359
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, qword ptr [rsi+0x8]
	call	tstrcmp@PLT
	test	rax, rax
	jnz	$_358
	inc	dword ptr [rbp-0x54]
	inc	dword ptr [rbp-0x4C]
	cmp	qword ptr [rbp-0x38], 0
	jz	$_358
	mov	rdx, qword ptr [rbp-0x8]
	lea	rcx, [rbp-0x230]
	call	tstrcpy@PLT
	lea	rdx, [DS0009+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rcx, rax
	call	SymFind@PLT
	test	rax, rax
	jnz	$_358
	inc	dword ptr [rbp-0x50]
	mov	qword ptr [rbp-0x30], rsi
$_358:	jmp	$_360

$_359:	cmp	qword ptr [rbp-0x70], 0
	jz	$_360
	mov	rax, qword ptr [rbp-0x40]
	or	byte ptr [rax+0x13], 0x04
$_360:	cmp	qword ptr [rbp-0x48], 0
	je	$_381
	cmp	byte ptr [r14+0x4], 2
	jnz	$_366
	cmp	dword ptr [rbp-0x4C], 0
	jnz	$_366
	mov	rax, qword ptr [rbp-0x40]
	test	rax, rax
	jz	$_364
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_361
	cmp	qword ptr [rax+0x28], 0
	jz	$_361
	mov	rax, qword ptr [rax+0x28]
	cmp	word ptr [rax+0x6E], 3
	jnz	$_361
	mov	rax, qword ptr [rax+0x50]
$_361:	cmp	byte ptr [rax+0x1F], 2
	jnz	$_362
	mov	eax, 808546907
	jmp	$_363

$_362:	mov	eax, 2019652187
$_363:	jmp	$_365

$_364:	mov	eax, 2019652187
$_365:	jmp	$_367

$_366:	mov	eax, 2019648859
$_367:	cmp	dword ptr [rbp-0x4C], 0
	jnz	$_368
	stosd
	mov	eax, 11869
	stosw
$_368:	mov	rsi, qword ptr [rbp-0x48]
	jmp	$_370

$_369:	movsb
$_370:	cmp	byte ptr [rsi], 0
	jnz	$_369
	cmp	qword ptr [rbp-0x38], 0
	jz	$_374
	mov	al, 46
	cmp	dword ptr [rbp-0x4C], 0
	jz	$_371
	mov	al, 95
$_371:	stosb
	mov	rsi, qword ptr [rbp-0x38]
	jmp	$_373

$_372:	movsb
$_373:	cmp	byte ptr [rsi], 0
	jnz	$_372
$_374:	cmp	byte ptr [rbx], 91
	jnz	$_378
	cmp	byte ptr [rbp-0x71], 0
	jnz	$_378
	cmp	byte ptr [rbx+0x40], 93
	jnz	$_375
	mov	rax, qword ptr [rbx+0x30]
	jmp	$_377

$_375:	lea	rdx, [DS000C+rip]
	lea	rcx, [rbp-0x230]
	call	tstrcpy@PLT
	lea	rsi, [rbx+0x20]
$_376:	cmp	rsi, qword ptr [rbp-0x68]
	jnc	$_377
	mov	rdx, qword ptr [rsi+0x10]
	mov	rcx, rax
	call	tstrcat@PLT
	add	rsi, 32
	jmp	$_376

$_377:	jmp	$_380

$_378:	cmp	dword ptr [rbp-0x60], 0
	jz	$_379
	lea	rax, [rbp-0x230]
	mov	rsi, qword ptr [rbx+0x18]
	mov	rdx, qword ptr [rbp-0x18]
	sub	rdx, 64
	mov	rcx, qword ptr [rdx+0x18]
	sub	rcx, rsi
	mov	rdx, rdi
	mov	rdi, rax
	rep movsb
	mov	byte ptr [rdi], 0
	mov	rdi, rdx
	jmp	$_380

$_379:	mov	rax, qword ptr [rbx+0x10]
$_380:	mov	qword ptr [rbp-0x48], rax
	mov	rax, qword ptr [rbp-0x40]
	test	rax, rax
	jz	$_381
	or	byte ptr [rax+0x11], 0x01
	cmp	dword ptr [rbp-0x54], 0
	jnz	$_381
	or	byte ptr [rax+0x13], 0x04
$_381:	inc	dword ptr [rbp-0x78]
	cmp	qword ptr [rbp-0x48], 0
	jz	$_382
	mov	rbx, qword ptr [rbp-0x18]
	sub	rbx, 64
	cmp	rbx, qword ptr [rbp-0x10]
	ja	$_382
	add	rbx, 64
$_382:	mov	rsi, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rbp-0x18]
	lea	rbx, [rcx+0x20]
	mov	rcx, qword ptr [rcx+0x18]
	sub	rcx, rsi
	rep movsb
	mov	byte ptr [rdi], 0
	cmp	qword ptr [rbp-0x38], 0
	jz	$_383
	mov	eax, 3153964
	stosd
	dec	rdi
	jmp	$_392

$_383:	cmp	qword ptr [rbp-0x48], 0
	je	$_392
	cmp	dword ptr [rbp-0x54], 0
	je	$_392
	mov	eax, 8236
	stosw
	mov	rsi, qword ptr [rbp-0x48]
	cmp	byte ptr [rbp-0x71], 0
	jz	$_387
	mov	dword ptr [rbp-0x54], 0
	inc	rsi
$_384:	cmp	byte ptr [rsi], 0
	jz	$_385
	mov	al, byte ptr [rsi]
	cmp	al, 93
	jz	$_385
	stosb
	inc	rsi
	jmp	$_384

$_385:	cmp	byte ptr [rbp-0x71], 2
	jnz	$_386
	mov	rdx, rdi
	lea	rdi, [rbp-0x230]
	mov	rax, qword ptr [rbp-0x10]
	mov	rsi, qword ptr [rax+0x18]
	mov	rax, qword ptr [rbp-0x130]
	mov	rcx, qword ptr [rax+0x38]
	sub	rcx, rsi
	rep movsb
	mov	rax, qword ptr [rbp-0x20]
	mov	rsi, qword ptr [rax+0x8]
	mov	ecx, dword ptr [rax+0x14]
	rep movsb
	mov	rax, qword ptr [rbp-0x130]
	mov	rsi, qword ptr [rax+0x18]
	mov	rax, qword ptr [rbp-0x18]
	sub	rax, 64
	mov	rcx, qword ptr [rax+0x18]
	sub	rcx, rsi
	rep movsb
	mov	byte ptr [rdi], 0
	mov	rdi, rdx
$_386:	jmp	$_392

$_387:	cmp	dword ptr [rbp-0x24], 0
	jz	$_388
	mov	eax, 1919181921
	stosd
	mov	eax, 32
	stosb
$_388:	jmp	$_391

$_389:	lodsb
	cmp	al, 46
	jnz	$_390
	cmp	qword ptr [rbp-0x70], 0
	jz	$_390
	mov	dword ptr [rbp-0x54], 0
	jmp	$_392

$_390:	stosb
$_391:	cmp	byte ptr [rsi], 0
	jnz	$_389
$_392:	mov	byte ptr [rdi], 0
	cmp	byte ptr [rbx], 41
	jnz	$_393
	inc	dword ptr [rbp-0x78]
	lea	rsi, [rbp-0xA30]
	jmp	$_402

$_393:	mov	eax, 8236
	stosw
	mov	dword ptr [rbp-0x58], 1
$_394:	cmp	byte ptr [rbx], 0
	jz	$_401
	test	byte ptr [rbx+0x2], 0x08
	jz	$_395
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp-0x78]
	mov	rcx, qword ptr [rbp+0x28]
	call	$_312
	cmp	eax, -1
	je	$_416
$_395:	mov	al, byte ptr [rbx]
	cmp	al, 41
	jnz	$_396
	dec	dword ptr [rbp-0x58]
	jz	$_401
	jmp	$_397

$_396:	cmp	al, 40
	jnz	$_397
	inc	dword ptr [rbp-0x58]
$_397:	cmp	al, 38
	jnz	$_398
	lea	rsi, [DS000D+rip]
	mov	ecx, 5
	jmp	$_400

$_398:	cmp	al, 44
	jnz	$_399
	cmp	byte ptr [rbx+0x20], 41
	jnz	$_399
	cmp	dword ptr [rbp-0x58], 1
	jnz	$_399
	inc	dword ptr [rbp-0x78]
	add	rbx, 32
	jmp	$_401

	jmp	$_400

$_399:	mov	rsi, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rbx+0x38]
	sub	rcx, rsi
$_400:	rep movsb
	inc	dword ptr [rbp-0x78]
	add	rbx, 32
	jmp	$_394

$_401:	inc	dword ptr [rbp-0x78]
	mov	byte ptr [rdi], 0
$_402:	cmp	qword ptr [rbp-0x48], 0
	jz	$_405
	cmp	dword ptr [rbp-0x54], 0
	jnz	$_405
	mov	eax, 8236
	stosw
	mov	rsi, qword ptr [rbp-0x48]
	jmp	$_404

$_403:	movsb
$_404:	cmp	byte ptr [rsi], 0
	jnz	$_403
	mov	byte ptr [rdi], 0
$_405:	mov	eax, dword ptr [rbp+0x30]
	lea	ecx, [rax+0x3]
	inc	eax
	cmp	qword ptr [rbp-0x48], 0
	jne	$_413
	cmp	dword ptr [rbp-0x78], eax
	jnz	$_406
	cmp	eax, 1
	ja	$_407
$_406:	cmp	dword ptr [rbp-0x78], ecx
	jne	$_413
$_407:	xor	eax, eax
	mov	rcx, qword ptr [rbp-0x30]
	test	rcx, rcx
	jz	$_410
	test	byte ptr [rcx+0x12], 0x08
	jnz	$_408
	cmp	byte ptr [rcx+0x1D], 2
	jnz	$_410
$_408:	cmp	qword ptr [rcx+0x60], 0
	jz	$_409
	mov	rax, rcx
	jmp	$_410

$_409:	test	byte ptr [rcx+0x11], 0x02
	jz	$_410
	mov	rcx, qword ptr [rcx+0x50]
	test	rcx, rcx
	jz	$_410
	cmp	byte ptr [rcx+0x1D], 9
	jnz	$_410
	mov	rax, rcx
$_410:	test	rax, rax
	jnz	$_413
	test	rcx, rcx
	jz	$_412
	cmp	byte ptr [rcx+0x1F], 7
	jz	$_411
	cmp	byte ptr [rcx+0x1F], 8
	jnz	$_412
$_411:	cmp	byte ptr [r14+0x4], 2
	jnz	$_412
	test	byte ptr [r14+0x2D], 0x02
	jz	$_412
	mov	rdx, qword ptr [CurrProc+rip]
	test	rdx, rdx
	jz	$_412
	mov	rcx, qword ptr [rdx+0x78]
	or	byte ptr [rcx+0x1], 0x01
$_412:	lea	rdx, [rbp-0xA30]
	mov	eax, 1819042147
	mov	dword ptr [rdx], eax
	mov	rcx, rdi
	lea	rdi, [rdx+0x4]
	lea	rsi, [rdx+0x6]
	sub	rcx, rsi
	inc	ecx
	rep movsb
$_413:	mov	rax, qword ptr [rbp+0x28]
	cmp	byte ptr [rax], 0
	jz	$_414
	lea	rdx, [EOLSTR+rip]
	mov	rcx, rax
	call	tstrcat@PLT
$_414:	cmp	dword ptr [rbp-0x50], 0
	jz	$_415
	mov	eax, dword ptr [rbp-0x78]
	sub	eax, dword ptr [rbp+0x30]
	cmp	eax, 3
	jnz	$_415
	mov	byte ptr [rbp-0xA30], 0
	xor	edx, edx
	mov	rcx, qword ptr [rbp-0x30]
	call	DefaultConstructor@PLT
$_415:	lea	rdx, [rbp-0xA30]
	mov	rcx, qword ptr [rbp+0x28]
	call	tstrcat@PLT
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp-0x78]
	mov	ecx, dword ptr [rbp+0x30]
	call	$_218
$_416:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_417:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	bl, byte ptr [r14+0x16]
	call	$_312
	mov	byte ptr [r14+0x16], bl
	leave
	pop	rbx
	ret

ExpandHllProc:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, r8
	mov	rdi, rcx
	xor	eax, eax
	mov	byte ptr [rdi], al
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_420
	mov	esi, edx
$_418:	cmp	esi, dword ptr [r14+0x64]
	jge	$_420
	imul	ecx, esi, 32
	test	byte ptr [rbx+rcx+0x2], 0x08
	jz	$_419
	mov	rcx, rbx
	call	ExpandCStrings
	mov	r8, rbx
	mov	edx, esi
	mov	rcx, rdi
	call	$_417
$_419:	inc	esi
	jmp	$_418

$_420:
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ExpandHllProcEx:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rbx, r8
	mov	r8, rbx
	mov	rcx, rsi
	call	ExpandHllProc
	mov	edi, eax
	cmp	eax, -1
	jz	$_421
	cmp	byte ptr [rsi], 0
	jz	$_421
	mov	r8, qword ptr [rbx+0x18]
	mov	rdx, rsi
	lea	rcx, [DS000E+rip]
	call	AddLineQueueX@PLT
	mov	edi, 1
$_421:	test	byte ptr [r14], 0x08
	jz	$_422
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_422:	cmp	qword ptr [r14+0x2B0], 0
	jz	$_423
	call	RunLineQueue@PLT
$_423:	mov	eax, edi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

EvaluateHllExpression:
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2136
	mov	rdi, rdx
	mov	rbx, r8
	mov	rsi, rcx
	mov	qword ptr [rbp-0x10], 0
	mov	dword ptr [rbp-0x8], 0
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_429
	test	byte ptr [rsi+0x30], 0x04
	jnz	$_429
	test	byte ptr [rbx+0x2], 0x01
	jz	$_429
	xor	edx, edx
	cmp	dword ptr [r14+0x58], 0
	jz	$_424
	inc	edx
	jmp	$_427

$_424:	mov	ecx, dword ptr [rdi]
$_425:	cmp	ecx, dword ptr [r14+0x64]
	jge	$_427
	imul	eax, ecx, 32
	test	byte ptr [rbx+rax+0x2], 0x04
	jz	$_426
	inc	edx
	jmp	$_427

$_426:	inc	ecx
	jmp	$_425

$_427:	test	edx, edx
	jz	$_429
	or	byte ptr [rsi+0x30], 0x04
	test	byte ptr [rbx+0x2], 0x02
	jz	$_428
	or	byte ptr [rsi+0x30], 0x10
$_428:	mov	rdx, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rbp+0x50]
	call	tstrcpy@PLT
	xor	eax, eax
	jmp	$_454

$_429:	mov	r8, rbx
	mov	edx, dword ptr [rdi]
	lea	rcx, [rbp-0x810]
	call	ExpandHllProc
	cmp	eax, -1
	je	$_454
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 0
	lea	rax, [rbp-0x10]
	mov	qword ptr [rsp+0x30], rax
	mov	qword ptr [rsp+0x28], rcx
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, rbx
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_127
	cmp	eax, -1
	je	$_454
	imul	eax, dword ptr [rdi], 32
	add	rbx, rax
	cmp	byte ptr [rbx], 0
	jz	$_430
	mov	ecx, 2154
	call	asmerr@PLT
	jmp	$_454

$_430:	cmp	byte ptr [rbp-0x810], 0
	je	$_452
	test	byte ptr [rsi+0x31], 0x80
	jnz	$_431
	test	byte ptr [rsi+0x32], 0x01
	jnz	$_431
	test	byte ptr [rsi+0x32], 0x02
	je	$_452
$_431:	mov	rdx, qword ptr [rbp+0x50]
	mov	ecx, dword ptr [rdx]
	jmp	$_433

$_432:	add	rdx, 1
$_433:	cmp	byte ptr [rdx], 32
	ja	$_432
	jmp	$_435

$_434:	add	rdx, 1
$_435:	cmp	byte ptr [rdx], 32
	jz	$_434
	mov	ebx, dword ptr [rdx]
	cmp	bl, 101
	jz	$_436
	cmp	bl, 114
	jnz	$_437
$_436:	shr	ebx, 8
$_437:	cmp	bh, 120
	jne	$_452
	cmp	ecx, 1953719668
	jnz	$_438
	xor	ecx, ecx
$_438:	lea	rbx, [rdx+0x4]
	jmp	$_440

$_439:	inc	rbx
$_440:	cmp	byte ptr [rbx], 32
	jz	$_439
	cmp	byte ptr [rbx], 44
	jz	$_439
	test	byte ptr [rsi+0x32], 0x02
	jz	$_447
	mov	ax, word ptr [rdx]
	cmp	byte ptr [r14+0x4], 2
	jnz	$_442
	mov	byte ptr [rdx], 101
	test	ecx, ecx
	jnz	$_441
	cmp	ax, word ptr [rbx]
	jnz	$_441
	mov	byte ptr [rbx], 101
$_441:	jmp	$_446

$_442:	cmp	byte ptr [r14+0x4], 0
	jnz	$_446
	cmp	byte ptr [rdx+0x2], 32
	jz	$_445
	test	ecx, ecx
	jz	$_443
	mov	dword ptr [rdx-0x4], 7499552
	jmp	$_444

$_443:	mov	dword ptr [rdx-0x5], 543452769
$_444:	dec	rdx
$_445:	mov	word ptr [rdx+0x1], ax
	mov	byte ptr [rdx], 101
	test	ecx, ecx
	jnz	$_446
	mov	byte ptr [rbx-0x1], 101
$_446:	jmp	$_452

$_447:	test	byte ptr [rsi+0x32], 0x01
	jz	$_449
	cmp	byte ptr [r14+0x4], 0
	jz	$_448
	mov	ax, word ptr [rdx]
	mov	byte ptr [rdx], 32
	test	ecx, ecx
	jnz	$_448
	cmp	ax, word ptr [rbx]
	jnz	$_448
	mov	byte ptr [rbx], 32
$_448:	jmp	$_452

$_449:	test	byte ptr [rsi+0x31], 0x80
	jz	$_452
	mov	ax, word ptr [rdx]
	cmp	byte ptr [r14+0x4], 0
	jnz	$_451
	mov	byte ptr [rdx+0x1], 108
	test	ecx, ecx
	jnz	$_450
	cmp	ax, word ptr [rbx]
	jnz	$_450
	mov	byte ptr [rbx+0x1], 108
$_450:	jmp	$_452

$_451:	mov	byte ptr [rdx], 32
	mov	byte ptr [rdx+0x2], 108
	test	ecx, ecx
	jnz	$_452
	cmp	ax, word ptr [rbx]
	jnz	$_452
	mov	byte ptr [rbx], 32
	mov	byte ptr [rbx+0x2], 108
$_452:	cmp	byte ptr [rbp-0x810], 0
	jz	$_453
	lea	rdi, [rbp-0x810]
	mov	rcx, rdi
	call	tstrlen@PLT
	mov	word ptr [rdi+rax], 10
	mov	rdx, qword ptr [rbp+0x50]
	mov	rcx, rdi
	call	tstrcat@PLT
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp+0x50]
	call	tstrcpy@PLT
$_453:	mov	eax, 0
$_454:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ExpandHllExpression:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	dword ptr [rbp-0x8], 0
	mov	rsi, rcx
	mov	rbx, r8
	test	byte ptr [rsi+0x30], 0x10
	jnz	$_455
	cmp	byte ptr [rbx], 3
	jnz	$_456
	cmp	dword ptr [rbx+0x4], 415
	jnz	$_456
$_455:	inc	dword ptr [rbp-0x8]
$_456:	xor	ecx, ecx
	test	byte ptr [rsi+0x30], 0x02
	jz	$_457
	mov	rcx, qword ptr [rsi+0x20]
	inc	dword ptr [rbp-0x8]
	jmp	$_458

$_457:	cmp	dword ptr [StoreState+rip], 0
	jnz	$_458
	mov	rcx, qword ptr [rbx+0x18]
$_458:	test	rcx, rcx
	jz	$_459
	mov	rdx, rcx
	mov	rcx, qword ptr [r14+0x1D8]
	call	tstrcpy@PLT
	xor	r9d, r9d
	mov	r8, rbx
	xor	edx, edx
	mov	rcx, rax
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
$_459:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_462
	cmp	qword ptr [r14+0x2B0], 0
	jz	$_460
	call	RunLineQueue@PLT
$_460:	mov	dword ptr [rbp-0x4], 0
	cmp	dword ptr [rbp-0x8], 0
	jz	$_461
	mov	dword ptr [NoLineStore+rip], 1
	mov	rdx, rbx
	mov	rcx, qword ptr [r14+0x1D8]
	call	ExpandLine@PLT
	mov	dword ptr [rbp-0x4], eax
	mov	dword ptr [NoLineStore+rip], 0
$_461:	jmp	$_464

$_462:	test	byte ptr [r14], 0x08
	jz	$_463
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_463:	call	RunLineQueue@PLT
	mov	rdx, rbx
	mov	rcx, qword ptr [r14+0x1D8]
	call	ExpandLine@PLT
	mov	dword ptr [rbp-0x4], eax
$_464:	cmp	dword ptr [rbp-0x4], 0
	jnz	$_465
	and	byte ptr [rsi+0x30], 0xFD
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, rbx
	mov	rdx, qword ptr [rbp+0x30]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	mov	rcx, qword ptr [rbp+0x50]
	call	AddLineQueue@PLT
$_465:	and	byte ptr [rsi+0x30], 0xFB
	mov	eax, dword ptr [rbp-0x4]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_466:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, qword ptr [rbp+0x28]
	mov	edi, 1
	xor	ebx, ebx
	mov	eax, dword ptr [rsi]
	jmp	$_476

$_467:	cmp	al, 10
	jnz	$_468
	mov	edi, 1
	add	ebx, edi
	jmp	$_475

$_468:	test	edi, edi
	jz	$_475
	xor	edi, edi
	cmp	al, 106
	jnz	$_475
	shr	eax, 8
	cmp	al, 109
	jnz	$_469
	test	ebx, ebx
	jnz	$_469
	mov	edi, 2
	jmp	$_472

$_469:	cmp	ebx, 1
	jnz	$_471
	cmp	al, 122
	jz	$_470
	cmp	ax, 31342
	jnz	$_471
$_470:	mov	edi, 3
	jmp	$_472

$_471:	mov	ebx, 3
	jmp	$_477

$_472:	mov	rcx, rsi
	call	tstrlen@PLT
	jmp	$_474

$_473:	add	rsi, rax
	mov	cl, byte ptr [rsi]
	mov	byte ptr [rsi+rdi], cl
	sub	rsi, rax
	dec	eax
$_474:	cmp	eax, 0
	jge	$_473
	xor	edi, edi
	mov	eax, 1886351212
	mov	dword ptr [rsi], eax
	cmp	edx, 2
	jnz	$_475
	mov	byte ptr [rsi+0x4], 101
$_475:	inc	rsi
	mov	eax, dword ptr [rsi]
$_476:	test	al, al
	jnz	$_467
$_477:	mov	eax, 0
	cmp	ebx, 2
	jbe	$_478
	mov	eax, 4294967295
$_478:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_479:
	mov	qword ptr [rsp+0x8], rcx
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	eax, edx
	mov	ecx, 1
	add	ecx, dword ptr [r14+0x5C]
	mov	r8d, ecx
	mov	edx, 773
	lea	rcx, [DS000F+rip]
	call	AddLineQueueX@PLT
	mov	rdx, qword ptr [rbp+0x18]
	mov	ecx, dword ptr [rdx+0x18]
	lea	rdx, [rbp-0x20]
	call	GetLabelStr
	mov	rdx, rax
	lea	rcx, [DS0010+rip]
	call	AddLineQueueX@PLT
	leave
	pop	rdi
	ret

$_480:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 64
	mov	eax, ecx
	xor	ecx, ecx
	jmp	$_481

	mov	ecx, 633
	jmp	$_482

	mov	ecx, 631
	jmp	$_482

	mov	ecx, 639
	jmp	$_482

	mov	ecx, 637
	jmp	$_482

	mov	ecx, 650
	jmp	$_482

	mov	ecx, 651
	jmp	$_482

	mov	ecx, 652
	jmp	$_482

	mov	ecx, 645
	jmp	$_482

	mov	ecx, 630
	jmp	$_482

	mov	ecx, 632
	jmp	$_482

	mov	ecx, 636
	jmp	$_482

	mov	ecx, 638
	jmp	$_482

	mov	ecx, 654
	jmp	$_482

	mov	ecx, 655
	jmp	$_482

	mov	ecx, 658
	jmp	$_482

	mov	ecx, 659
	jmp	$_482

LC02A7: mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_482

$_481:	cmp	eax, 420
	jl	LC02A7
	cmp	eax, 482
	jg	LC02A7
	lea	r11, [LC02A8+rip]
	movzx	r10, byte ptr [r11+rax-0x193]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC02A7+rip]
	sub	r11, r10
	jmp	r11

$_482:
	lea	rdx, [rbp-0x20]
	call	GetResWName@PLT
	cmp	byte ptr [rax+0x2], 0
	jnz	$_483
	mov	word ptr [rax+0x2], 32
$_483:	leave
	ret

HllStartDir:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2136
	mov	dword ptr [rbp-0x4], 0
	mov	rbx, rdx
	lea	rdi, [rbp-0x81C]
	imul	eax, dword ptr [rbp+0x28], 32
	movzx	ecx, byte ptr [rbx+rax+0x20]
	mov	dword ptr [rbp-0xC], ecx
	mov	eax, dword ptr [rbx+rax+0x4]
	mov	dword ptr [rbp-0x8], eax
	inc	dword ptr [rbp+0x28]
	mov	rsi, qword ptr [r14+0x2E8]
	test	rsi, rsi
	jnz	$_484
	mov	ecx, 56
	call	LclAlloc@PLT
	mov	rsi, rax
$_484:	mov	rcx, qword ptr [rbp+0x30]
	call	ExpandCStrings
	xor	eax, eax
	mov	dword ptr [rsi+0x14], eax
	mov	dword ptr [rsi+0x30], eax
	mov	eax, dword ptr [rbp-0x8]
	mov	ecx, dword ptr [rbp-0xC]
	jmp	$_509

$_485:	mov	dword ptr [rsi+0x28], 0
	mov	dword ptr [rsi+0x18], 0
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x10], eax
	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 0
	xor	r9d, r9d
	mov	r8, rbx
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	test	eax, eax
	jnz	$_486
	mov	rcx, rdi
	call	AddLineQueue@PLT
	cmp	byte ptr [rdi], 0
	jnz	$_486
	mov	dword ptr [rsi+0x10], 0
$_486:	jmp	LC02AF

$_487:	or	byte ptr [rsi+0x30], 0x02
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x18], eax
	mov	dword ptr [rsi+0x10], 0
	cmp	dword ptr [rbp-0x8], 410
	je	$_502
	mov	dword ptr [rsi+0x28], 1
	mov	qword ptr [rsi+0x20], 0
	imul	eax, dword ptr [rbp+0x28], 32
	cmp	byte ptr [rbx+rax], 0
	je	$_497
	mov	eax, dword ptr [rbp-0x8]
	jmp	$_495

$_488:	or	byte ptr [rsi+0x32], 0x04
$_489:	or	byte ptr [rsi+0x31], 0x80
	jmp	$_496

$_490:	or	byte ptr [rsi+0x32], 0x04
$_491:	or	byte ptr [rsi+0x32], 0x01
	jmp	$_496

$_492:	or	byte ptr [rsi+0x32], 0x04
$_493:	or	byte ptr [rsi+0x32], 0x02
	jmp	$_496

$_494:	or	byte ptr [rsi+0x32], 0x04
	jmp	$_496

$_495:	cmp	eax, 464
	jz	$_488
	cmp	eax, 460
	jz	$_489
	cmp	eax, 465
	jz	$_490
	cmp	eax, 462
	jz	$_491
	cmp	eax, 466
	jz	$_492
	cmp	eax, 463
	jz	$_493
	cmp	eax, 461
	jz	$_494
$_496:	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 1
	mov	r9d, 2
	mov	r8, rbx
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	jmp	$_499

$_497:	cmp	dword ptr [rbp-0x8], 411
	jz	$_498
	lea	rdx, [rdi+0x14]
	mov	ecx, dword ptr [rsi+0x18]
	call	GetLabelStr
	mov	ecx, dword ptr [rbp-0x8]
	call	$_480
	mov	rdx, rax
	mov	rcx, rdi
	call	tstrcpy@PLT
	lea	rdx, [DS000D+0x4+rip]
	mov	rcx, rdi
	call	tstrcat@PLT
	lea	rdx, [rdi+0x14]
	mov	rcx, rdi
	call	tstrcat@PLT
	mov	rcx, rdi
	call	$_108
	mov	eax, 0
	jmp	$_499

$_498:	mov	byte ptr [rdi], 0
	mov	eax, 4294967295
$_499:	test	eax, eax
	jnz	$_500
	mov	rcx, rdi
	call	LclDup@PLT
	mov	qword ptr [rsi+0x20], rax
$_500:	mov	r8d, 3
	lea	rdx, [DS0011+rip]
	mov	rcx, rdi
	call	tmemicmp@PLT
	test	eax, eax
	jz	$_501
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x10], eax
	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rsi+0x10]
	call	GetLabelStr
	mov	rdx, rax
	lea	rcx, [DS0012+rip]
	call	AddLineQueueX@PLT
$_501:	jmp	$_503

$_502:	mov	dword ptr [rsi+0x28], 2
$_503:	mov	cl, byte ptr [r14+0x27]
	test	cl, cl
	jz	$_504
	mov	edx, 1
	shl	edx, cl
	lea	rcx, [DS0013+rip]
	call	AddLineQueueX@PLT
$_504:	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rsi+0x18]
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
	jmp	LC02AF

	test	ecx, ecx
	jz	$_505
	or	byte ptr [rsi+0x32], 0x04
	jmp	$_485

$_505:	test	ecx, ecx
	jz	$_506
	or	byte ptr [rsi+0x31], 0x80
	jmp	$_485

$_506:	mov	dword ptr [rsi+0x28], 0
	mov	dword ptr [rsi+0x18], 0
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x10], eax
	lea	rdx, [rbp-0x1C]
	mov	ecx, dword ptr [rsi+0x10]
	call	GetLabelStr
	mov	ecx, dword ptr [rbp-0x8]
	call	$_480
	test	rax, rax
	jz	$_507
	mov	rdx, rax
	lea	rcx, [rbp-0x81C]
	call	tstrcpy@PLT
	lea	rdx, [DS000D+0x4+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	lea	rcx, [rbp-0x1C]
	mov	rdx, rcx
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rcx, rax
	call	AddLineQueue@PLT
$_507:	jmp	LC02AF

	or	byte ptr [rsi+0x32], 0x04
	or	byte ptr [rsi+0x32], 0x02
	jmp	$_485

	or	byte ptr [rsi+0x32], 0x04
	or	byte ptr [rsi+0x32], 0x01
	jmp	$_485

	or	byte ptr [rsi+0x32], 0x04
	or	byte ptr [rsi+0x31], 0x80
	jmp	$_485

$_508:	jmp	$_487

$_509:
	cmp	eax, 420
	jc	$_510
	cmp	eax, 434
	jbe	$_506
$_510:	cmp	eax, 446
	jc	$_511
	cmp	eax, 466
	jbe	$_508
$_511:	cmp	eax, 409
	jl	LC02AF
	cmp	eax, 442
	jg	LC02AF
	lea	r11, [LC02D2+rip]
	movzx	r10, byte ptr [r11+rax-0x183]
	movzx	r10, word ptr [r11+r10*2]
	lea	r11, [LC02AF+rip]
	sub	r11, r10
	jmp	r11

LC02AF:
	imul	eax, dword ptr [rbp+0x28], 32
	cmp	dword ptr [rsi+0x30], 0
	jnz	$_512
	cmp	byte ptr [rbx+rax], 0
	jz	$_512
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_512
	mov	rdx, qword ptr [rbx+rax+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	mov	dword ptr [rbp-0x4], eax
$_512:	cmp	rsi, qword ptr [r14+0x2E8]
	jnz	$_513
	mov	rax, qword ptr [rsi]
	mov	qword ptr [r14+0x2E8], rax
$_513:	mov	rax, qword ptr [r14+0x2E0]
	mov	qword ptr [rsi], rax
	mov	qword ptr [r14+0x2E0], rsi
	test	byte ptr [r14], 0x08
	jz	$_514
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_514:	cmp	qword ptr [r14+0x2B0], 0
	jz	$_515
	call	RunLineQueue@PLT
$_515:	mov	eax, dword ptr [rbp-0x4]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

HllEndDir:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2104
	mov	dword ptr [rbp-0x4], 0
	mov	rsi, qword ptr [r14+0x2E0]
	test	rsi, rsi
	jnz	$_516
	mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_559

$_516:	mov	rax, qword ptr [rsi]
	mov	rcx, qword ptr [r14+0x2E8]
	mov	qword ptr [r14+0x2E0], rax
	mov	qword ptr [rsi], rcx
	mov	qword ptr [r14+0x2E8], rsi
	lea	rdi, [rbp-0x808]
	mov	rbx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rsi+0x28]
	imul	edx, dword ptr [rbp+0x28], 32
	mov	eax, dword ptr [rbx+rdx+0x4]
	mov	dword ptr [rbp-0x8], eax
	jmp	$_552

$_517:	test	ecx, ecx
	jz	$_518
	mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_559

$_518:	inc	dword ptr [rbp+0x28]
	mov	eax, dword ptr [rsi+0x10]
	test	eax, eax
	jz	$_519
	mov	rdx, rdi
	mov	ecx, eax
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
$_519:	jmp	$_554

$_520:	cmp	ecx, 1
	jz	$_521
	mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_559

$_521:	mov	eax, dword ptr [rsi+0x10]
	test	eax, eax
	jz	$_522
	mov	rdx, rdi
	mov	ecx, eax
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
$_522:	inc	dword ptr [rbp+0x28]
	test	byte ptr [rsi+0x30], 0x04
	jz	$_523
	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 1
	mov	r9d, 2
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	ExpandHllExpression
	jmp	$_524

$_523:	cmp	qword ptr [rsi+0x20], 0
	jz	$_524
	mov	rcx, qword ptr [rsi+0x20]
	call	AddLineQueue@PLT
$_524:	jmp	$_554

$_525:	cmp	ecx, 2
	jz	$_526
	mov	rdx, qword ptr [rbx+rdx+0x10]
	mov	ecx, 1010
	call	asmerr@PLT
	jmp	$_559

$_526:	inc	dword ptr [rbp+0x28]
	lea	rbx, [rbx+rdx+0x20]
	mov	eax, dword ptr [rsi+0x10]
	test	eax, eax
	jz	$_527
	mov	rdx, rdi
	mov	ecx, eax
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
$_527:	cmp	byte ptr [rbx], 0
	je	$_534
	mov	ecx, 2
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_529
	cmp	dword ptr [rsi+0x14], 0
	jnz	$_528
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x14], eax
$_528:	mov	ecx, 1
$_529:	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 0
	mov	r9d, ecx
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	test	eax, eax
	jnz	$_533
	test	byte ptr [r14+0x1], 0x08
	jz	$_530
	cmp	dword ptr [rbp-0x8], 419
	jnz	$_530
	mov	rcx, rdi
	call	$_466
	mov	dword ptr [rbp-0x4], eax
$_530:	test	eax, eax
	jnz	$_532
	mov	rcx, rdi
	call	AddLineQueue@PLT
	test	byte ptr [r14+0x1], 0x08
	jnz	$_531
	mov	edx, dword ptr [rbp-0x8]
	mov	rcx, rsi
	call	$_479
$_531:	jmp	$_533

$_532:	mov	ecx, 2062
	call	asmerr@PLT
$_533:	jmp	$_536

$_534:	test	byte ptr [r14+0x1], 0x08
	jz	$_535
	mov	rdx, rdi
	mov	ecx, dword ptr [rsi+0x18]
	call	GetLabelStr
	mov	rdx, rax
	lea	rcx, [DS0014+rip]
	call	AddLineQueueX@PLT
	jmp	$_536

$_535:	mov	edx, dword ptr [rbp-0x8]
	mov	rcx, rsi
	call	$_479
$_536:	jmp	$_554

$_537:	cmp	ecx, 2
	jz	$_538
	mov	rdx, qword ptr [rbx+rdx+0x10]
	mov	ecx, 1010
	call	asmerr@PLT
	jmp	$_559

$_538:	inc	dword ptr [rbp+0x28]
	lea	rbx, [rbx+rdx+0x20]
	mov	eax, dword ptr [rsi+0x10]
	test	eax, eax
	jz	$_539
	mov	rdx, rdi
	mov	ecx, eax
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
$_539:	cmp	byte ptr [rbx], 0
	je	$_550
	mov	eax, dword ptr [rbp-0x8]
	jmp	$_547

$_540:	or	byte ptr [rsi+0x32], 0x04
$_541:	or	byte ptr [rsi+0x31], 0x80
	jmp	$_548

$_542:	or	byte ptr [rsi+0x32], 0x04
$_543:	or	byte ptr [rsi+0x32], 0x01
	jmp	$_548

$_544:	or	byte ptr [rsi+0x32], 0x04
$_545:	or	byte ptr [rsi+0x32], 0x02
	jmp	$_548

$_546:	or	byte ptr [rsi+0x32], 0x04
	jmp	$_548

$_547:	cmp	eax, 485
	jz	$_540
	cmp	eax, 481
	jz	$_541
	cmp	eax, 486
	jz	$_542
	cmp	eax, 483
	jz	$_543
	cmp	eax, 487
	jz	$_544
	cmp	eax, 484
	jz	$_545
	cmp	eax, 482
	jz	$_546
$_548:	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 0
	mov	r9d, 2
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	test	eax, eax
	jnz	$_549
	mov	rcx, rdi
	call	AddLineQueue@PLT
$_549:	jmp	$_551

$_550:	cmp	dword ptr [rbp-0x8], 418
	jz	$_551
	lea	rdx, [rdi+0x14]
	mov	ecx, dword ptr [rsi+0x18]
	call	GetLabelStr
	mov	ecx, dword ptr [rbp-0x8]
	call	$_480
	mov	rdx, rax
	mov	rcx, rdi
	call	tstrcpy@PLT
	lea	rdx, [DS000D+0x4+rip]
	mov	rcx, rdi
	call	tstrcat@PLT
	lea	rdx, [rdi+0x14]
	mov	rcx, rdi
	call	tstrcat@PLT
	mov	rcx, rdi
	call	AddLineQueue@PLT
$_551:	jmp	$_554

$_552:	cmp	eax, 416
	je	$_517
	cmp	eax, 417
	je	$_520
	cmp	eax, 419
	je	$_525
	cmp	eax, 467
	jc	$_553
	cmp	eax, 487
	jbe	$_537
$_553:	cmp	eax, 418
	je	$_537
$_554:	mov	eax, dword ptr [rsi+0x14]
	test	eax, eax
	jz	$_555
	mov	rdx, rdi
	mov	ecx, eax
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
$_555:	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	cmp	byte ptr [rbx], 0
	jz	$_556
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_556
	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	mov	dword ptr [rbp-0x4], -1
$_556:	test	byte ptr [r14], 0x08
	jz	$_557
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_557:	cmp	qword ptr [r14+0x2B0], 0
	jz	$_558
	call	RunLineQueue@PLT
$_558:	mov	eax, dword ptr [rbp-0x4]
$_559:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

HllContinueIf:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 344
	mov	dword ptr [rbp-0x14], 0
	lea	rdi, [rbp-0x124]
	mov	ecx, dword ptr [rbp+0x40]
	mov	rsi, qword ptr [rbp+0x28]
	mov	rax, qword ptr [rbp+0x30]
	imul	ebx, dword ptr [rax], 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 0
	je	$_575
	cmp	byte ptr [rbx], 3
	jne	$_574
	mov	eax, dword ptr [rsi+0x30]
	mov	dword ptr [rbp-0x4], eax
	mov	dword ptr [rsi+0x30], 0
	mov	eax, dword ptr [rbx+0x4]
	jmp	$_571

$_560:	or	byte ptr [rsi+0x32], 0x04
$_561:	or	byte ptr [rsi+0x32], 0x02
$_562:	mov	eax, dword ptr [rsi+0x28]
	mov	dword ptr [rbp-0x8], eax
	mov	rax, qword ptr [rsi+0x20]
	mov	qword ptr [rbp-0x10], rax
	mov	dword ptr [rsi+0x28], 3
	mov	rdx, qword ptr [rbp+0x30]
	inc	dword ptr [rdx]
	mov	qword ptr [rsp+0x28], rdi
	mov	eax, dword ptr [rbp+0x50]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x14], eax
	test	eax, eax
	jnz	$_563
	mov	rcx, rdi
	call	AddLineQueue@PLT
$_563:	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsi+0x28], eax
	mov	rax, qword ptr [rbp-0x10]
	mov	qword ptr [rsi+0x20], rax
	jmp	$_573

$_564:	or	byte ptr [rsi+0x32], 0x04
	or	byte ptr [rsi+0x31], 0x80
	jmp	$_562

$_565:	or	byte ptr [rsi+0x32], 0x04
$_566:	or	byte ptr [rsi+0x32], 0x01
	jmp	$_562

$_567:	cmp	byte ptr [rbx+0x20], 0
	jz	$_568
	or	byte ptr [rsi+0x32], 0x04
	jmp	$_562

$_568:	cmp	byte ptr [rbx+0x20], 0
	jz	$_569
	or	byte ptr [rsi+0x31], 0x80
	jmp	$_562

$_569:	mov	rax, qword ptr [rbp+0x30]
	inc	dword ptr [rax]
	lea	rdx, [rbp-0x24]
	mov	ecx, dword ptr [rsi+rcx*4+0x10]
	call	GetLabelStr
	mov	ecx, dword ptr [rbx+0x4]
	call	$_480
	mov	rdx, rax
	mov	rcx, rdi
	call	tstrcpy@PLT
	lea	rdx, [DS000D+0x4+rip]
	mov	rcx, rdi
	call	tstrcat@PLT
	lea	rdx, [rbp-0x24]
	mov	rcx, rdi
	call	tstrcat@PLT
	cmp	dword ptr [rbp+0x50], 0
	jz	$_570
	mov	rcx, rdi
	call	$_108
$_570:	mov	rcx, rdi
	call	AddLineQueue@PLT
	jmp	$_573

$_571:	cmp	eax, 420
	jc	$_572
	cmp	eax, 434
	jbe	$_569
$_572:	cmp	eax, 442
	je	$_560
	cmp	eax, 439
	je	$_561
	cmp	eax, 409
	je	$_562
	cmp	eax, 440
	je	$_564
	cmp	eax, 441
	je	$_565
	cmp	eax, 438
	je	$_566
	cmp	eax, 437
	je	$_567
	cmp	eax, 435
	je	$_568
	cmp	eax, 436
	je	$_568
$_573:	mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rsi+0x30], eax
$_574:	jmp	$_578

$_575:	mov	rdx, rdi
	mov	ecx, dword ptr [rsi+rcx*4+0x10]
	call	GetLabelStr
	mov	rdx, rax
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
	mov	rdx, qword ptr [rbp+0x48]
	cmp	dword ptr [rdx+0x28], 4
	jnz	$_578
	mov	rsi, rdx
	mov	rax, rsi
	jmp	$_577

$_576:	mov	rsi, qword ptr [rsi+0x8]
$_577:	cmp	qword ptr [rsi+0x8], 0
	jnz	$_576
	cmp	rax, rsi
	jz	$_578
	or	byte ptr [rsi+0x31], 0x40
$_578:	mov	eax, dword ptr [rbp-0x14]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

HllExitDir:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2136
	mov	dword ptr [rbp-0x4], 0
	mov	dword ptr [rbp-0x8], 0
	mov	rax, qword ptr [r14+0x2E0]
	mov	qword ptr [rbp-0x28], rax
	mov	rsi, rax
	test	rsi, rsi
	jnz	$_579
	mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_615

$_579:	mov	rcx, qword ptr [rbp+0x30]
	call	ExpandCStrings
	lea	rdi, [rbp-0x828]
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rbx+0x4]
	mov	dword ptr [rbp-0xC], eax
	xor	ecx, ecx
	jmp	$_610

$_580:	or	byte ptr [rsi+0x32], 0x02
$_581:	or	byte ptr [rsi+0x32], 0x04
$_582:	cmp	dword ptr [rsi+0x28], 0
	jz	$_583
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 1010
	call	asmerr@PLT
	jmp	$_615

$_583:	test	byte ptr [rsi+0x30], 0x01
	jz	$_584
	mov	ecx, 2142
	call	asmerr@PLT
	jmp	$_615

$_584:	cmp	dword ptr [rsi+0x14], 0
	jnz	$_585
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x14], eax
$_585:	mov	rdx, rdi
	mov	ecx, dword ptr [rsi+0x14]
	call	GetLabelStr
	mov	rdx, rax
	lea	rcx, [DS0015+0x1+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rsi+0x10], 0
	jbe	$_586
	mov	rdx, rdi
	mov	ecx, dword ptr [rsi+0x10]
	call	GetLabelStr
	lea	r8, [DS000B+0x1+rip]
	mov	rdx, rax
	lea	rcx, [DS0007+0x2+rip]
	call	AddLineQueueX@PLT
	mov	dword ptr [rsi+0x10], 0
$_586:	inc	dword ptr [rbp+0x28]
	cmp	dword ptr [rbp-0xC], 414
	jnz	$_587
	or	byte ptr [rsi+0x30], 0x01
	jmp	$_589

$_587:	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x10], eax
	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 0
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	EvaluateHllExpression
	mov	dword ptr [rbp-0x4], eax
	test	eax, eax
	jnz	$_589
	test	byte ptr [rsi+0x30], 0x04
	jz	$_588
	mov	qword ptr [rsp+0x28], rdi
	mov	dword ptr [rsp+0x20], 0
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	ExpandHllExpression
	mov	eax, dword ptr [r14+0x64]
	mov	dword ptr [rbp+0x28], eax
	jmp	$_589

$_588:	mov	rcx, rdi
	call	AddLineQueue@PLT
$_589:	jmp	$_611

$_590:	or	byte ptr [rsi+0x32], 0x02
	jmp	$_582

$_591:	cmp	byte ptr [rbx+0x20], 40
	jnz	$_595
	cmp	byte ptr [rbx+0x60], 41
	jnz	$_595
	mov	rcx, qword ptr [rbx+0x50]
	mov	eax, dword ptr [rcx]
	cmp	dword ptr [rbp-0xC], 413
	jnz	$_592
	cmp	al, 48
	jnz	$_592
	mov	dword ptr [rbp-0x8], 1
$_592:	xor	ecx, ecx
	jmp	$_594

$_593:	imul	ecx, ecx, 10
	sub	al, 48
	movzx	edx, al
	add	ecx, edx
	shr	eax, 8
$_594:	test	al, al
	jnz	$_593
	add	dword ptr [rbp+0x28], 3
	add	rbx, 96
	mov	eax, dword ptr [rbp-0xC]
$_595:	test	rsi, rsi
	jz	$_597
	cmp	dword ptr [rsi+0x28], 0
	jz	$_596
	cmp	dword ptr [rsi+0x28], 4
	jnz	$_597
$_596:	mov	rsi, qword ptr [rsi]
	jmp	$_595

$_597:	jmp	$_602

$_598:	mov	rsi, qword ptr [rsi]
$_599:	test	rsi, rsi
	jz	$_601
	cmp	dword ptr [rsi+0x28], 0
	jz	$_600
	cmp	dword ptr [rsi+0x28], 4
	jnz	$_601
$_600:	mov	rsi, qword ptr [rsi]
	jmp	$_599

$_601:	dec	ecx
$_602:	test	rsi, rsi
	jz	$_603
	test	ecx, ecx
	jnz	$_598
$_603:	test	rsi, rsi
	jnz	$_604
	mov	ecx, 1011
	call	asmerr@PLT
	jmp	$_615

$_604:	cmp	eax, 412
	jnz	$_606
	cmp	dword ptr [rsi+0x14], 0
	jnz	$_605
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x14], eax
$_605:	mov	ecx, 1
	jmp	$_609

$_606:	cmp	dword ptr [rsi+0x28], 2
	jnz	$_607
	cmp	dword ptr [rsi+0x10], 0
	jnz	$_607
	inc	dword ptr [r14+0x36C]
	mov	eax, dword ptr [r14+0x36C]
	mov	dword ptr [rsi+0x10], eax
$_607:	mov	ecx, 0
	cmp	dword ptr [rbp-0x8], 1
	jz	$_608
	cmp	dword ptr [rsi+0x10], 0
	jnz	$_609
$_608:	mov	ecx, 2
$_609:	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	mov	dword ptr [rsp+0x28], 1
	mov	rax, qword ptr [rbp-0x28]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, ecx
	mov	r8, qword ptr [rbp+0x30]
	lea	rdx, [rbp+0x28]
	mov	rcx, rsi
	call	HllContinueIf
	mov	dword ptr [rbp-0x4], eax
	jmp	$_611

$_610:	cmp	eax, 445
	je	$_580
	cmp	eax, 443
	je	$_581
	cmp	eax, 415
	je	$_582
	cmp	eax, 414
	je	$_582
	cmp	eax, 444
	je	$_590
	cmp	eax, 412
	je	$_591
	cmp	eax, 413
	je	$_591
$_611:	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	cmp	byte ptr [rbx], 0
	jz	$_612
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_612
	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	mov	dword ptr [rbp-0x4], -1
$_612:	test	byte ptr [r14], 0x08
	jz	$_613
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_613:	cmp	qword ptr [r14+0x2B0], 0
	jz	$_614
	call	RunLineQueue@PLT
$_614:	mov	eax, dword ptr [rbp-0x4]
$_615:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

HllCheckOpen:
	sub	rsp, 40
	cmp	qword ptr [r14+0x2E0], 0
	jz	$_616
	lea	rdx, [DS0016+rip]
	mov	ecx, 1010
	call	asmerr@PLT
$_616:	cmp	qword ptr [r14+0x308], 0
	jz	$_617
	lea	rdx, [DS0017+rip]
	mov	ecx, 1010
	call	asmerr@PLT
$_617:	add	rsp, 40
	ret

HllInit:
	mov	dword ptr [r14+0x36C], 0
	ret


.SECTION .data
	.ALIGN	16

EOLSTR:
	.byte  0x0A, 0x00

flaginstr:
	.byte  0x7A, 0x63, 0x73, 0x70, 0x6F

unsign_cjmptype:
	.byte  0x7A, 0x7A, 0x61, 0x62, 0x62, 0x61

signed_cjmptype:
	.byte  0x7A, 0x7A, 0x67, 0x6C, 0x6C, 0x67

neg_cjmptype:
	.byte  0x00, 0x01, 0x00, 0x00, 0x01, 0x01

DS0000:
	.byte  0x6C, 0x65, 0x61, 0x20, 0x25, 0x72, 0x2C, 0x20
	.byte  0x25, 0x73, 0x0A, 0x00

DS0001:
	.byte  0x25, 0x72, 0x20, 0x00

DS0002:
	.byte  0x2C, 0x20, 0x25, 0x72, 0x00

DS0003:
	.byte  0x2C, 0x20, 0x25, 0x64, 0x00

DS0004:
	.byte  0x40, 0x43, 0x25, 0x30, 0x34, 0x58, 0x00

DS0005:
	.byte  0x6A, 0x6D, 0x70, 0x20, 0x40, 0x43, 0x25, 0x30
	.byte  0x34, 0x58, 0x25, 0x73, 0x00

DS0006:
	.byte  0x6A, 0x6D, 0x70, 0x20, 0x00

LC009B:
	.byte  0x24, 0x1C, 0x14, 0x0F, 0x0A, 0x05, 0x00, 0x02
	.byte  0x03, 0x00, 0x06, 0x00, 0x06, 0x04, 0x06, 0x06
	.byte  0x06, 0x06, 0x05, 0x06, 0x01, 0x00, 0x00, 0x06
	.byte  0x06, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
	.byte  0x00

DS0007:
	.byte  0x25, 0x73, 0x25, 0x73, 0x25, 0x73, 0x00

DS0008:
	.byte  0x3A, 0x00

DS0009:
	.byte  0x5F, 0x00

DS000A:
	.byte  0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x20, 0x70
	.byte  0x74, 0x72, 0x20, 0x25, 0x73, 0x2C, 0x25, 0x72
	.byte  0x0A, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x20
	.byte  0x70, 0x74, 0x72, 0x20, 0x25, 0x73, 0x2B, 0x25
	.byte  0x64, 0x2C, 0x25, 0x72, 0x00

DS000B:
	.byte  0x3A, 0x3A, 0x00

DS000C:
	.byte  0x61, 0x64, 0x64, 0x72, 0x20, 0x5B, 0x00

DS000D:
	.byte  0x61, 0x64, 0x64, 0x72, 0x20, 0x00

DS000E:
	.byte  0x25, 0x73, 0x0A, 0x25, 0x73, 0x00

DS000F:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x00

DS0010:
	.byte  0x20, 0x6A, 0x6E, 0x7A, 0x20, 0x25, 0x73, 0x00

LC02A8:
	.byte  0x82, 0x78, 0x6E, 0x64, 0x5A, 0x50, 0x46, 0x3F
	.byte  0x38, 0x31, 0x2A, 0x23, 0x1C, 0x15, 0x0E, 0x07
	.byte  0x00, 0x00, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08
	.byte  0x09, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
	.byte  0x01, 0x01, 0x06, 0x10, 0x10, 0x10, 0x10, 0x10
	.byte  0x10, 0x10, 0x10, 0x00, 0x02, 0x03, 0x04, 0x05
	.byte  0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E
	.byte  0x0F, 0x01, 0x06, 0x10, 0x10, 0x10, 0x10, 0x10
	.byte  0x00, 0x02, 0x03, 0x04, 0x05, 0x07, 0x08, 0x09
	.byte  0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x01, 0x06

DS0011:
	.byte  0x6A, 0x6D, 0x70, 0x00

DS0012:
	.byte  0x6A, 0x6D, 0x70, 0x20, 0x25, 0x73, 0x00

DS0013:
	.byte  0x41, 0x4C, 0x49, 0x47, 0x4E, 0x20, 0x25, 0x64
	.byte  0x00

LC02D2:
	.byte  0x24, 0x03, 0xC6, 0x02, 0xC2, 0x02, 0x05, 0x01
	.byte  0xF8, 0x00, 0x7C, 0x00, 0x78, 0x00, 0x6F, 0x00
	.byte  0x6B, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00, 0x02
	.byte  0x01, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A
	.byte  0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A
	.byte  0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A
	.byte  0x04, 0x04, 0x03, 0x08, 0x06, 0x09, 0x07, 0x05

DS0014:
	.byte  0x6C, 0x6F, 0x6F, 0x70, 0x20, 0x25, 0x73, 0x00

DS0015:
	.byte  0x20, 0x6A, 0x6D, 0x70, 0x20, 0x25, 0x73, 0x00

DS0016:
	.byte  0x2E, 0x69, 0x66, 0x2D, 0x2E, 0x72, 0x65, 0x70
	.byte  0x65, 0x61, 0x74, 0x2D, 0x2E, 0x77, 0x68, 0x69
	.byte  0x6C, 0x65, 0x00

DS0017:
	.byte  0x2E, 0x6E, 0x61, 0x6D, 0x65, 0x73, 0x70, 0x61
	.byte  0x63, 0x65, 0x00


.att_syntax prefix
