
.intel_syntax noprefix

.global GetToken
.global Tokenize

.extern CurrEnum
.extern UseSavedState
.extern GetStdAssume
.extern CondPrepare
.extern CurrIfState
.extern InputExtend
.extern GetTextLine
.extern max_resw_len
.extern resw_table
.extern ResWordTable
.extern optable_idx
.extern tstrstart
.extern asmerr
.extern Options
.extern Parse_Pass
.extern CommentBuffer
.extern StringBuffer
.extern SymFindID
.extern SymFind
.extern tstrcpy
.extern tstrchr
.extern tstrlen


.SECTION .text
	.ALIGN	16

$_001:	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	byte ptr [rcx+0x20], 3
	jnz	$_002
	cmp	dword ptr [rcx+0x24], 620
	jnz	$_002
	xor	eax, eax
	jmp	$_014

$_002:	cmp	byte ptr [rcx+0x20], 58
	jnz	$_003
	add	rcx, 64
$_003:	movzx	eax, byte ptr [rcx]
	jmp	$_012

$_004:	mov	ecx, dword ptr [rcx+0x4]
	jmp	$_006

$_005:	xor	eax, eax
	jmp	$_014

	jmp	$_007

$_006:	cmp	ecx, 618
	jz	$_005
	cmp	ecx, 575
	jz	$_005
	cmp	ecx, 564
	jz	$_005
	cmp	ecx, 566
	jz	$_005
$_007:	jmp	$_013

$_008:	xor	eax, eax
	jmp	$_014

$_009:	cmp	qword ptr [CurrEnum+rip], 0
	jz	$_010
	xor	eax, eax
	jmp	$_014

$_010:	call	SymFindID@PLT
	test	rax, rax
	jz	$_011
	cmp	byte ptr [rax+0x1D], 9
	jnz	$_011
	test	byte ptr [rax+0x48], 0x08
	jnz	$_011
	xor	eax, eax
	jmp	$_014

$_011:	jmp	$_013

$_012:	cmp	eax, 3
	jz	$_004
	cmp	eax, 1
	jz	$_008
	cmp	eax, 8
	jz	$_009
$_013:	mov	eax, 1
$_014:	leave
	ret

$_015:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, r8
	mov	rbx, r9
	lea	rcx, [rsi+0x1]
	call	tstrstart@PLT
	test	ecx, ecx
	jz	$_016
	cmp	ecx, 59
	jz	$_016
	mov	rax, -2
	jmp	$_020

$_016:	mov	rcx, rdi
	call	GetTextLine@PLT
	test	rax, rax
	jnz	$_017
	mov	rax, -2
	jmp	$_020

$_017:	mov	rcx, rdi
	call	tstrstart@PLT
	mov	rdi, rax
	mov	rcx, rdi
	call	tstrlen@PLT
	cmp	dword ptr [rbp+0x30], 0
	jnz	$_018
	mov	byte ptr [rsi], 32
	inc	rsi
$_018:	mov	rcx, rsi
	sub	rcx, qword ptr [rbx+0x10]
	add	ecx, eax
	cmp	ecx, dword ptr [r14+0x234]
	jc	$_019
	mov	ecx, 2039
	call	asmerr@PLT
	mov	rcx, rsi
	sub	rcx, qword ptr [rbx+0x10]
	inc	ecx
	mov	eax, dword ptr [r14+0x234]
	sub	eax, ecx
	mov	byte ptr [rdi+rax], 0
$_019:	lea	ecx, [rax+0x1]
	xchg	rdi, rsi
	rep movsb
	xor	eax, eax
$_020:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_021:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 88
	mov	qword ptr [rbp-0x30], rdx
	mov	rbx, rcx
	mov	rsi, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	movzx	eax, byte ptr [rsi]
	mov	byte ptr [rbp-0x2], al
	xor	ecx, ecx
	jmp	$_089

$_022:	mov	ecx, dword ptr [r14+0x234]
	sub	ecx, 32
	mov	dword ptr [rbp-0x20], ecx
	xor	ecx, ecx
	mov	byte ptr [rbx+0x1], al
	mov	ah, al
	movsb
$_023:	mov	al, byte ptr [rsi]
	jmp	$_033

$_024:	mov	byte ptr [rbx+0x1], al
	inc	ecx
	jmp	$_036

$_025:	cmp	byte ptr [rsi-0x1], 92
	jnz	$_027
	cmp	word ptr [rsi-0x3], 23644
	jz	$_026
	cmp	byte ptr [rsi-0x2], 92
	jz	$_027
$_026:	stosb
	inc	rsi
	inc	ecx
	jmp	$_035

$_027:	lea	rax, [rsi+0x1]
	jmp	$_029

$_028:	add	rax, 1
$_029:	cmp	byte ptr [rax], 32
	jz	$_028
	cmp	byte ptr [rax], 9
	jz	$_028
	cmp	byte ptr [rax], 34
	jnz	$_030
	lea	rsi, [rax+0x1]
	mov	eax, 8738
	jmp	$_035

$_030:	mov	eax, 8738
$_031:	stosb
	inc	rsi
	cmp	byte ptr [rsi], al
	jnz	$_036
	dec	rdi
$_032:	mov	byte ptr [rdi], al
	inc	rdi
	inc	rsi
	inc	ecx
	jmp	$_035

$_033:	test	al, al
	jz	$_024
	cmp	ax, 8738
	jnz	$_034
	cmp	byte ptr [rdx+0x30], 0
	jnz	$_025
$_034:	cmp	al, ah
	jz	$_031
	jmp	$_032

$_035:	cmp	ecx, dword ptr [rbp-0x20]
	jc	$_023
$_036:	jmp	$_090

$_037:	test	byte ptr [rdx+0x1C], 0x02
	jne	$_078
	mov	byte ptr [rbp-0x1], 125
$_038:	mov	byte ptr [rbx+0x1], al
	mov	dword ptr [rbp-0x8], ecx
	cmp	al, 60
	jnz	$_039
	mov	byte ptr [rbp-0x1], 62
$_039:	inc	rsi
$_040:	mov	eax, dword ptr [r14+0x234]
	sub	eax, 32
	mov	dword ptr [rbp-0x20], eax
	dec	eax
	mov	dword ptr [rbp-0x24], eax
	jmp	$_076

$_041:	mov	ax, word ptr [rsi]
	jmp	$_071

$_042:	inc	dword ptr [rbp-0x8]
	jmp	$_075

$_043:	cmp	dword ptr [rbp-0x8], 0
	jz	$_044
	dec	dword ptr [rbp-0x8]
	jmp	$_045

$_044:	inc	rsi
	jmp	$_077

$_045:	jmp	$_075

$_046:	mov	byte ptr [rbp-0x3], al
	movsb
	inc	ecx
	mov	qword ptr [rbp-0x10], rdi
	mov	qword ptr [rbp-0x18], rsi
	mov	dword ptr [rbp-0x1C], ecx
	mov	ax, word ptr [rsi]
	jmp	$_049

$_047:	cmp	byte ptr [rbp-0x2], 60
	jnz	$_048
	cmp	al, 33
	jnz	$_048
	test	ah, ah
	jz	$_048
	inc	rsi
$_048:	movsb
	inc	ecx
	mov	ax, word ptr [rsi]
$_049:	cmp	al, byte ptr [rbp-0x3]
	jz	$_050
	test	al, al
	jz	$_050
	cmp	ecx, dword ptr [rbp-0x24]
	jc	$_047
$_050:	cmp	al, byte ptr [rbp-0x3]
	jz	$_051
	mov	rsi, qword ptr [rbp-0x18]
	mov	rdi, qword ptr [rbp-0x10]
	mov	ecx, dword ptr [rbp-0x1C]
	jmp	$_076

$_051:	jmp	$_075

$_052:	inc	rsi
	jmp	$_075

$_053:	mov	dword ptr [rbp-0x1C], ecx
	mov	r9, rdx
	mov	r8, rdi
	mov	edx, ecx
	mov	rcx, rsi
	call	$_015
	mov	ecx, dword ptr [rbp-0x1C]
	mov	rdx, qword ptr [rbp-0x30]
	cmp	eax, -2
	jz	$_054
	or	byte ptr [rdx+0x1E], 0x01
	jmp	$_076

$_054:	jmp	$_075

$_055:	cmp	byte ptr [rdx+0x1C], 0
	jne	$_070
	test	byte ptr [rdx+0x1D], 0x20
	jne	$_070
	mov	qword ptr [rbp-0x10], rdi
	mov	dword ptr [rbp-0x1C], ecx
	test	al, al
	jz	$_056
	cmp	al, 59
	jnz	$_057
$_056:	cmp	byte ptr [rbp-0x2], 123
	jnz	$_057
	mov	eax, 1
	jmp	$_061

$_057:	dec	rdi
	jmp	$_059

$_058:	cmp	rdi, qword ptr [rdx+0x8]
	jbe	$_060
	dec	rdi
$_059:	movzx	eax, byte ptr [rdi]
	test	byte ptr [r15+rax], 0x08
	jnz	$_058
$_060:	cmp	al, 44
	mov	al, 0
	sete	al
$_061:	test	eax, eax
	je	$_070
	mov	rcx, qword ptr [rdx+0x8]
	call	tstrlen@PLT
	mov	edi, eax
	mov	rdx, qword ptr [rbp-0x30]
	add	edi, 8
	and	edi, 0xFFFFFFF8
	add	rdi, qword ptr [rdx+0x8]
	mov	rcx, qword ptr [rdx+0x20]
	mov	eax, dword ptr [rcx+0x4]
	mov	edx, dword ptr [rcx+0x24]
	mov	ecx, dword ptr [rcx+0x64]
	cmp	eax, 501
	jz	$_062
	cmp	eax, 499
	jz	$_062
	cmp	eax, 500
	jz	$_062
	cmp	edx, 604
	jz	$_062
	cmp	ecx, 604
	jnz	$_066
$_062:	jmp	$_064

$_063:	cmp	byte ptr [rdi+0x1], 0
	jz	$_064
	inc	rdi
	mov	rcx, rdi
	call	tstrstart@PLT
	mov	rdi, rax
	dec	rdi
	mov	byte ptr [rdi], 10
	jmp	$_065

$_064:	lea	rcx, [rdi+0x1]
	call	GetTextLine@PLT
	test	rax, rax
	jnz	$_063
$_065:	jmp	$_067

$_066:	mov	rcx, rdi
	call	GetTextLine@PLT
	test	rax, rax
	jz	$_067
	mov	rcx, rdi
	call	tstrstart@PLT
	mov	rdi, rax
$_067:	test	rax, rax
	jz	$_070
	mov	rcx, rdi
	call	tstrlen@PLT
	add	eax, dword ptr [rbp-0x1C]
	cmp	eax, dword ptr [r14+0x234]
	jc	$_069
	mov	rdx, qword ptr [rbp-0x30]
	sub	rsi, qword ptr [rdx]
	sub	rdi, qword ptr [rdx+0x8]
	sub	rbx, qword ptr [rdx+0x20]
	mov	rax, qword ptr [rbp-0x10]
	sub	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rbp-0x10], rax
	mov	rcx, rdx
	call	InputExtend@PLT
	test	rax, rax
	jnz	$_068
	mov	ecx, 2039
	call	asmerr@PLT
	jmp	$_092

$_068:	mov	rdx, qword ptr [rbp-0x30]
	add	rbx, qword ptr [rdx+0x20]
	add	rsi, qword ptr [rdx]
	mov	rax, qword ptr [rdx+0x8]
	add	rdi, rax
	add	qword ptr [rbp-0x10], rax
$_069:	mov	rdx, rdi
	mov	rcx, rsi
	call	tstrcpy@PLT
	mov	rdx, qword ptr [rbp-0x30]
	mov	rdi, qword ptr [rbp-0x10]
	mov	ecx, dword ptr [rbp-0x1C]
	jmp	$_040

$_070:	mov	rdx, qword ptr [rbp-0x30]
	mov	rsi, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	movsb
	mov	ecx, 1
	jmp	$_078

	jmp	$_075

$_071:	cmp	al, byte ptr [rbp-0x2]
	je	$_042
	cmp	al, byte ptr [rbp-0x1]
	je	$_043
	cmp	al, 34
	jz	$_072
	cmp	al, 39
	jnz	$_073
$_072:	test	byte ptr [rdx+0x1D], 0x02
	je	$_046
$_073:	cmp	al, 33
	jnz	$_074
	cmp	byte ptr [rbp-0x2], 60
	jnz	$_074
	test	ah, ah
	jne	$_052
$_074:	cmp	al, 92
	je	$_053
	test	al, al
	je	$_055
	cmp	al, 59
	jnz	$_075
	cmp	byte ptr [rbp-0x2], 123
	je	$_055
$_075:	movsb
	inc	ecx
$_076:	cmp	ecx, dword ptr [rbp-0x20]
	jc	$_041
$_077:	jmp	$_090

$_078:	mov	eax, dword ptr [r14+0x234]
	sub	eax, 32
	mov	dword ptr [rbp-0x20], eax
	dec	eax
	mov	dword ptr [rbp-0x24], eax
	mov	byte ptr [rbx+0x1], 0
	jmp	$_087

$_079:	movzx	eax, byte ptr [rsi]
	test	eax, eax
	je	$_088
	test	byte ptr [r15+rax], 0x08
	jne	$_088
	cmp	eax, 44
	je	$_088
	cmp	eax, 40
	jnz	$_080
	inc	byte ptr [rdx+0x1F]
	jmp	$_081

$_080:	cmp	eax, 41
	jnz	$_081
	dec	byte ptr [rdx+0x1F]
	jmp	$_088

$_081:	cmp	eax, 37
	jz	$_088
	cmp	eax, 59
	jnz	$_082
	cmp	byte ptr [rdx+0x1C], 0
	jz	$_088
$_082:	cmp	eax, 92
	jnz	$_085
	cmp	byte ptr [rdx+0x1C], 0
	jz	$_083
	test	byte ptr [rdx+0x1C], 0x04
	jz	$_084
$_083:	mov	dword ptr [rbp-0x1C], ecx
	mov	r9, rdx
	mov	r8, rdi
	mov	edx, ecx
	mov	rcx, rsi
	call	$_015
	mov	ecx, dword ptr [rbp-0x1C]
	mov	rdx, qword ptr [rbp-0x30]
	cmp	eax, -2
	jz	$_084
	or	byte ptr [rdx+0x1E], 0x01
	test	ecx, ecx
	jnz	$_087
	mov	rax, -2
	jmp	$_092

$_084:	jmp	$_086

$_085:	cmp	eax, 33
	jnz	$_086
	cmp	byte ptr [rsi+0x1], 0
	jz	$_086
	cmp	ecx, dword ptr [rbp-0x24]
	jnc	$_086
	movsb
$_086:	movsb
	inc	ecx
$_087:	cmp	ecx, dword ptr [rbp-0x20]
	jc	$_079
$_088:	jmp	$_090

$_089:	cmp	eax, 34
	je	$_022
	cmp	eax, 39
	je	$_022
	cmp	eax, 123
	je	$_037
	cmp	eax, 60
	je	$_038
	jmp	$_078

$_090:	cmp	ecx, dword ptr [rbp-0x20]
	jnz	$_091
	mov	ecx, 2041
	call	asmerr@PLT
	jmp	$_092

$_091:	xor	eax, eax
	mov	byte ptr [rdi], al
	inc	rdi
	mov	byte ptr [rbx], 9
	mov	dword ptr [rbx+0x4], ecx
	mov	qword ptr [rdx], rsi
	mov	qword ptr [rdx+0x8], rdi
$_092:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_093:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rsi, rdx
	mov	rdi, qword ptr [rsi]
	mov	eax, dword ptr [rdi]
	jmp	$_154

$_094:	inc	qword ptr [rsi]
	lea	rcx, [__dcolon+rip]
	cmp	ah, 58
	jnz	$_095
	inc	qword ptr [rsi]
	mov	byte ptr [rbx], 13
	mov	qword ptr [rbx+0x10], rcx
	jmp	$_096

$_095:	inc	rcx
	mov	byte ptr [rbx], 58
	mov	qword ptr [rbx+0x10], rcx
$_096:	jmp	$_156

$_097:	shr	eax, 8
	or	eax, 0x202020
	cmp	eax, 7632239
	jnz	$_098
	mov	rax, qword ptr [rsi]
	movzx	eax, byte ptr [rax+0x4]
	test	byte ptr [r15+rax], 0x44
	jnz	$_098
	mov	byte ptr [rbx], 3
	mov	dword ptr [rbx+0x4], 618
	mov	byte ptr [rbx+0x1], 46
	mov	rdi, qword ptr [rsi+0x8]
	mov	rcx, qword ptr [rsi]
	add	qword ptr [rsi], 4
	add	qword ptr [rsi+0x8], 5
	mov	eax, dword ptr [rcx]
	mov	dword ptr [rdi], eax
	xor	eax, eax
	mov	byte ptr [rdi+0x4], al
	jmp	$_156

$_098:	inc	qword ptr [rsi]
	cmp	byte ptr [rsi+0x1C], 0
	jnz	$_099
	cmp	dword ptr [rsi+0x18], 0
	jnz	$_099
	or	byte ptr [rsi+0x1E], 0x02
	mov	rax, -2
	jmp	$_157

$_099:	lea	rax, [__percent+rip]
	mov	byte ptr [rbx], 37
	mov	qword ptr [rbx+0x10], rax
	jmp	$_156

$_100:	inc	byte ptr [rsi+0x1F]
	xor	ecx, ecx
	cmp	dword ptr [rsi+0x18], 2
	jnz	$_101
	cmp	dword ptr [rbx-0x3C], 516
	jnz	$_101
	inc	byte ptr [rsi+0x30]
	jmp	$_134

$_101:	cmp	ah, 41
	jnz	$_102
	cmp	byte ptr [rbx-0x20], 2
	jnz	$_102
	or	byte ptr [rbx-0x1E], 0x08
	jmp	$_134

$_102:	cmp	dword ptr [rsi+0x18], 0
	jz	$_104
	cmp	byte ptr [rbx-0x20], 2
	jnz	$_104
	mov	ecx, dword ptr [rbx-0x1C]
	mov	eax, ecx
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x0E
	jz	$_103
	mov	eax, ecx
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	call	GetStdAssume@PLT
	test	rax, rax
	jz	$_103
	or	byte ptr [rbx-0x1E], 0x08
$_103:	mov	eax, dword ptr [rdi]
	xor	ecx, ecx
	jmp	$_134

$_104:	cmp	dword ptr [rsi+0x18], 0
	je	$_134
	cmp	byte ptr [rbx-0x20], 8
	jz	$_105
	cmp	byte ptr [rbx-0x20], 2
	jne	$_134
$_105:	xor	eax, eax
	lea	rdi, [rbx-0x20]
	cmp	byte ptr [rdi], 8
	jnz	$_106
	mov	rcx, rdi
	call	SymFindID@PLT
$_106:	test	rax, rax
	jz	$_107
	cmp	byte ptr [rax+0x1D], 10
	jnz	$_107
	mov	rcx, qword ptr [rax+0x30]
	call	SymFind@PLT
$_107:	xor	edx, edx
	xor	ecx, ecx
	cmp	dword ptr [rsi+0x18], 2
	jbe	$_109
	cmp	byte ptr [rbx-0x40], 46
	jnz	$_109
	test	rax, rax
	jz	$_108
	cmp	byte ptr [rax+0x1D], 9
	jz	$_109
$_108:	mov	eax, 1
	mov	edx, 7
$_109:	test	rax, rax
	je	$_132
	test	edx, edx
	jnz	$_110
	movzx	edx, byte ptr [rax+0x1D]
$_110:	jmp	$_130

$_111:	cmp	edx, 9
	jne	$_131
	test	byte ptr [rax+0x48], 0x02
	je	$_131
	and	byte ptr [rsi+0x1D], 0xFE
	jmp	$_131

$_112:	test	byte ptr [rax+0x48], 0x02
	jz	$_114
	and	byte ptr [rsi+0x1D], 0xFE
	test	byte ptr [rax+0x10], 0x08
	jz	$_113
	cmp	dword ptr [rax+0x18], -635545745
	jnz	$_113
	inc	byte ptr [rsi+0x30]
	jmp	$_131

$_113:	or	byte ptr [rdi+0x2], 0x04
	jmp	$_131

$_114:	test	byte ptr [rax+0x10], 0x08
	jne	$_131
	cmp	qword ptr [rax+0x30], 0
	je	$_131
	mov	rcx, qword ptr [rax+0x30]
	call	SymFind@PLT
	xor	ecx, ecx
	test	rax, rax
	jz	$_115
	test	byte ptr [rax+0x10], 0x02
	jz	$_115
	or	byte ptr [rdi+0x2], 0x08
	inc	byte ptr [rsi+0x30]
$_115:	jmp	$_131

$_116:	mov	eax, dword ptr [rsi+0x18]
	cmp	eax, 1
	jz	$_117
	cmp	byte ptr [rdi-0x20], 46
	jz	$_118
$_117:	cmp	byte ptr [rdi-0x20], 8
	je	$_131
	cmp	qword ptr [r14+0x38], 0
	je	$_131
	mov	rdx, qword ptr [r14+0x38]
	mov	rdx, qword ptr [rdx+0x78]
	cmp	dword ptr [rdx+0x48], 1
	jne	$_131
	jmp	$_127

$_118:	sub	rdi, 32
	xor	edx, edx
$_119:	cmp	eax, 0
	jle	$_127
	mov	cl, byte ptr [rdi]
	mov	ch, byte ptr [rdi-0x20]
	jmp	$_125

$_120:	cmp	ch, 46
	jz	$_121
	test	edx, edx
	jz	$_127
$_121:	jmp	$_126

$_122:	inc	edx
	jmp	$_126

$_123:	dec	edx
	cmp	ch, 46
	jz	$_124
	cmp	ch, 8
	jz	$_124
	test	edx, edx
	jz	$_127
$_124:	jmp	$_126

$_125:	cmp	cl, 8
	jz	$_120
	cmp	cl, 93
	jz	$_122
	cmp	cl, 91
	jz	$_123
$_126:	dec	eax
	sub	rdi, 32
	jmp	$_119

$_127:	or	byte ptr [rdi+0x2], 0x08
	inc	byte ptr [rsi+0x30]
	jmp	$_131

$_128:	mov	rdx, qword ptr [rsi]
	cmp	byte ptr [rdx+0x1], 41
	jnz	$_129
	or	byte ptr [rdi+0x2], 0x08
$_129:	jmp	$_131

$_130:	test	byte ptr [Options+0x6+rip], 0x10
	jne	$_111
	cmp	edx, 9
	je	$_112
	cmp	edx, 7
	je	$_116
	cmp	edx, 5
	jz	$_127
	cmp	edx, 1
	jz	$_127
	cmp	edx, 2
	jz	$_127
	test	byte ptr [rax+0x10], 0x02
	jnz	$_127
	test	edx, edx
	jz	$_128
$_131:	movzx	ecx, byte ptr [rdi+0x2]
	and	ecx, 0x08
	shr	ecx, 3
	jmp	$_133

$_132:	mov	rdi, qword ptr [rsi]
	cmp	byte ptr [rdi+0x1], 41
	jnz	$_133
	or	byte ptr [rbx-0x1E], 0x08
$_133:	mov	rdi, qword ptr [rsi]
	mov	eax, dword ptr [rdi]
$_134:	test	ecx, ecx
	jnz	$_135
	test	byte ptr [rbx-0x1E], 0x08
	jz	$_141
$_135:	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_141
	mov	rcx, qword ptr [rsi+0x20]
	or	byte ptr [rcx+0x2], 0x40
	cmp	byte ptr [rcx], 91
	jz	$_136
	cmp	byte ptr [rcx+0x20], 91
	jnz	$_141
$_136:	test	byte ptr [rbx-0x1E], 0x08
	jz	$_141
	mov	rdx, rbx
$_137:	cmp	byte ptr [rdx-0x40], 46
	jnz	$_138
	sub	rdx, 64
	jmp	$_137

$_138:	cmp	byte ptr [rdx], 46
	jnz	$_141
	cmp	byte ptr [rdx-0x20], 93
	jnz	$_141
	sub	rdx, 64
$_139:	cmp	rdx, rcx
	jbe	$_140
	cmp	byte ptr [rdx], 91
	jz	$_140
	sub	rdx, 32
	jmp	$_139

$_140:	cmp	byte ptr [rdx], 91
	jnz	$_141
	or	byte ptr [rdx+0x2], 0x08
$_141:	cmp	al, 41
	jnz	$_142
	cmp	byte ptr [rsi+0x1F], 0
	jz	$_142
	dec	byte ptr [rsi+0x1F]
	dec	byte ptr [rsi+0x30]
$_142:	inc	qword ptr [rsi]
	mov	byte ptr [rbx], al
	mov	byte ptr [rbx+0x1], 0
	movzx	eax, al
	sub	al, 40
	lea	rcx, [stokstr1+rip]
	lea	rax, [rcx+rax*2]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_156

$_143:	inc	qword ptr [rsi]
	mov	byte ptr [rbx], al
	movzx	eax, al
	sub	al, 91
	lea	rcx, [stokstr2+rip]
	lea	rax, [rcx+rax*2]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_156

$_144:	cmp	ah, 61
	jz	$_145
	mov	byte ptr [rbx], 3
	mov	dword ptr [rbx+0x4], 620
	mov	byte ptr [rbx+0x1], 48
	lea	rax, [__equ+rip]
	mov	qword ptr [rbx+0x10], rax
	inc	qword ptr [rsi]
	jmp	$_156

$_145:	mov	edx, eax
	lea	rcx, [DS0000+rip]
	call	tstrchr@PLT
	mov	edx, dword ptr [rdi]
	test	rax, rax
	je	$_152
	test	byte ptr [rsi+0x1D], 0x01
	je	$_152
	mov	al, byte ptr [rax]
	mov	rcx, qword ptr [rsi+0x8]
	inc	qword ptr [rsi+0x8]
	mov	byte ptr [rcx], al
	inc	qword ptr [rsi]
	mov	dword ptr [rbx+0x4], 1
	mov	rdx, qword ptr [rsi]
	cmp	al, 38
	jz	$_146
	cmp	al, 124
	jnz	$_150
$_146:	cmp	byte ptr [rdx], al
	jnz	$_147
	inc	rcx
	mov	byte ptr [rcx], al
	inc	qword ptr [rsi+0x8]
	inc	qword ptr [rsi]
	mov	dword ptr [rbx+0x4], 2
	jmp	$_149

$_147:	cmp	al, 38
	jnz	$_149
	cmp	byte ptr [rbx-0x20], 44
	jz	$_148
	cmp	byte ptr [rbx-0x20], 40
	jnz	$_149
$_148:	mov	byte ptr [rbx], al
	lea	rax, [__amp+rip]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_156

$_149:	jmp	$_151

$_150:	cmp	byte ptr [rdx], 61
	jnz	$_151
	inc	rcx
	mov	byte ptr [rcx], 61
	inc	qword ptr [rsi+0x8]
	inc	qword ptr [rsi]
	mov	dword ptr [rbx+0x4], 2
$_151:	xor	eax, eax
	mov	byte ptr [rbx], 9
	mov	byte ptr [rbx+0x1], al
	mov	byte ptr [rcx+0x1], al
	inc	qword ptr [rsi+0x8]
	jmp	$_156

$_152:	cmp	dl, 38
	jnz	$_153
	inc	qword ptr [rsi]
	mov	byte ptr [rbx], dl
	lea	rax, [__amp+rip]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_156

$_153:	mov	rdx, rsi
	mov	rcx, rbx
	call	$_021
	jmp	$_157

	jmp	$_156

$_154:	cmp	al, 58
	je	$_094
	cmp	al, 37
	je	$_097
	cmp	al, 40
	je	$_100
	cmp	al, 41
	je	$_141
	cmp	al, 42
	jc	$_155
	cmp	al, 47
	jbe	$_142
$_155:	cmp	al, 91
	je	$_143
	cmp	al, 93
	je	$_143
	cmp	al, 61
	je	$_144
	jmp	$_145

$_156:	xor	eax, eax
$_157:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_158:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rsi, rdx
	mov	rdx, qword ptr [rsi]
	xor	edi, edi
	mov	byte ptr [rbp-0x1], 0
	mov	eax, dword ptr [rdx]
	or	eax, 0x2000
	cmp	ax, 30768
	jnz	$_159
	add	rdx, 2
	inc	byte ptr [rbp-0x1]
$_159:	movzx	eax, byte ptr [rdx]
	test	byte ptr [r15+rax], 0x04
	jz	$_160
	sub	eax, 48
	mov	ecx, eax
	mov	eax, 1
	shl	eax, cl
	or	edi, eax
	jmp	$_162

$_160:	test	byte ptr [r15+rax], 0x80
	jz	$_161
	or	eax, 0x20
	add	eax, -87
	mov	ecx, eax
	mov	eax, 1
	shl	eax, cl
	or	edi, eax
	jmp	$_162

$_161:	or	eax, 0x20
	jmp	$_163

$_162:	inc	rdx
	jmp	$_159

$_163:
	mov	rcx, rdx
	cmp	byte ptr [rbp-0x1], 0
	jz	$_165
	cmp	al, 46
	jz	$_165
	mov	eax, 16
	test	edi, edi
	jnz	$_164
	xor	eax, eax
$_164:	jmp	$_198

$_165:	jmp	$_197

$_166:	xor	edi, edi
	mov	eax, 1
	jmp	$_176

$_167:	mov	al, byte ptr [rdx]
	cmp	eax, 46
	jnz	$_168
	add	ah, 1
	jmp	$_175

$_168:	cmp	al, 48
	jc	$_169
	cmp	al, 57
	jbe	$_175
$_169:	or	al, 0x20
	cmp	byte ptr [rbp-0x1], 0
	jz	$_170
	cmp	al, 97
	jc	$_170
	cmp	al, 102
	jbe	$_175
$_170:	cmp	al, 101
	jz	$_171
	cmp	al, 112
	jnz	$_172
$_171:	test	edi, edi
	jz	$_173
$_172:	jmp	$_177

$_173:	inc	edi
	mov	al, byte ptr [rdx+0x1]
	cmp	al, 43
	jz	$_174
	cmp	al, 45
	jnz	$_175
$_174:	inc	rdx
$_175:	inc	rdx
$_176:	test	al, al
	jnz	$_167
$_177:	cmp	byte ptr [rbp-0x1], 0
	jz	$_178
	cmp	al, 102
	jz	$_179
	cmp	al, 108
	jz	$_179
$_178:	xor	eax, eax
	dec	rdx
$_179:	mov	byte ptr [rbx], 11
	mov	byte ptr [rbx+0x1], al
	inc	rdx
	jmp	$_202

$_180:	mov	eax, 16
	inc	rdx
	jmp	$_198

$_181:	xor	eax, eax
	test	edi, 0x3
	jz	$_182
	mov	eax, 2
	inc	rdx
$_182:	jmp	$_198

$_183:	xor	eax, eax
	test	edi, 0x3FF
	jz	$_184
	mov	eax, 10
	inc	rdx
$_184:	jmp	$_198

$_185:	test	edi, 0xFF
	jnz	$_186
	mov	byte ptr [rbx], 11
	mov	byte ptr [rbx+0x1], 113
	inc	rdx
	jmp	$_202

$_186:	xor	eax, eax
	test	edi, 0xFF
	jz	$_187
	mov	eax, 8
	inc	rdx
$_187:	jmp	$_198

$_188:	mov	cl, byte ptr [r14+0x8]
	mov	eax, 1
	shl	eax, cl
	dec	rdx
	mov	cl, byte ptr [rdx]
	or	cl, 0x20
	cmp	cl, 98
	jz	$_189
	cmp	cl, 100
	jnz	$_195
$_189:	cmp	edi, eax
	jc	$_195
	mov	rax, qword ptr [rsi]
	mov	ch, 49
	cmp	cl, 98
	jz	$_190
	mov	ch, 57
$_190:	jmp	$_192

$_191:	inc	rax
$_192:	cmp	rax, rdx
	jnc	$_193
	cmp	byte ptr [rax], ch
	jbe	$_191
$_193:	cmp	rax, rdx
	jnz	$_195
	mov	eax, 2
	cmp	cl, 98
	jz	$_194
	mov	eax, 10
$_194:	mov	rcx, rdx
	inc	rdx
	jmp	$_198

$_195:	inc	rdx
	mov	cl, byte ptr [r14+0x8]
	mov	eax, 1
	shl	eax, cl
	cmp	edi, eax
	mov	eax, 0
	mov	rcx, rdx
	jnc	$_196
	movzx	eax, byte ptr [r14+0x8]
$_196:	jmp	$_198

$_197:	cmp	eax, 46
	je	$_166
	cmp	eax, 114
	je	$_179
	cmp	eax, 104
	je	$_180
	cmp	eax, 121
	je	$_181
	cmp	eax, 116
	je	$_183
	cmp	eax, 113
	je	$_185
	cmp	eax, 111
	je	$_186
	jmp	$_188

$_198:	test	eax, eax
	jz	$_199
	mov	byte ptr [rbx], 10
	mov	byte ptr [rbx+0x1], al
	sub	rcx, qword ptr [rsi]
	mov	dword ptr [rbx+0x4], ecx
	jmp	$_202

$_199:	mov	byte ptr [rbx], 12
	jmp	$_201

$_200:	inc	rdx
$_201:	movzx	eax, byte ptr [rdx]
	test	byte ptr [r15+rax], 0x44
	jnz	$_200
$_202:	mov	rcx, rdx
	mov	rdx, rsi
	mov	rdi, qword ptr [rdx+0x8]
	mov	rsi, qword ptr [rdx]
	sub	rcx, rsi
	rep movsb
	xor	eax, eax
	mov	byte ptr [rdi], al
	inc	rdi
	mov	qword ptr [rdx], rsi
	mov	qword ptr [rdx+0x8], rdi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_203:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	byte ptr [rbp-0x1], 1
	mov	rbx, rcx
	mov	rsi, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	movzx	eax, word ptr [rsi]
	jmp	$_207

$_204:	cmp	byte ptr [rdx+0x1F], 0
	jz	$_208
	stosb
	inc	qword ptr [rdx]
	inc	qword ptr [rdx+0x8]
	mov	rcx, rbx
	call	$_021
	jmp	$_244

$_205:	or	byte ptr [rbx+0x2], 0x80
$_206:	mov	byte ptr [rbp-0x1], 0
	jmp	$_208

$_207:	cmp	eax, 8780
	jz	$_204
	cmp	al, 64
	jz	$_205
	cmp	al, 95
	jz	$_206
$_208:	stosb
	inc	rsi
	mov	r10, rbx
	movzx	ecx, al
	movzx	ebx, al
	or	cl, 0x20
	xor	ecx, 0x50C5D1F
	xor	ebx, 0x50C5D1F
	jmp	$_210

$_209:	stosb
	inc	rsi
	imul	ebx, ebx, 16777619
	imul	ecx, ecx, 16777619
	xor	bl, al
	or	al, 0x20
	xor	cl, al
$_210:	movzx	eax, byte ptr [rsi]
	test	byte ptr [r15+rax], 0x44
	jnz	$_209
	mov	eax, ebx
	mov	rbx, r10
	mov	dword ptr [rbx+0x8], ecx
	mov	dword ptr [rbx+0xC], eax
	mov	rcx, rdi
	sub	rcx, qword ptr [rdx+0x8]
	mov	byte ptr [rbx+0x3], cl
	cmp	ecx, dword ptr [max_resw_len+rip]
	jle	$_211
	mov	byte ptr [rbp-0x1], 0
	cmp	ecx, 247
	jbe	$_211
	mov	rdi, rdx
	mov	ecx, 2043
	call	asmerr@PLT
	mov	rdx, rdi
	mov	rdi, qword ptr [rdx+0x8]
	add	rdi, 247
	mov	ecx, 247
$_211:	xor	eax, eax
	stosb
	cmp	ecx, 1
	jnz	$_213
	mov	byte ptr [rbp-0x1], al
	mov	rax, qword ptr [rdx+0x8]
	cmp	byte ptr [rax], 63
	jnz	$_212
	inc	qword ptr [rdx]
	mov	byte ptr [rbx], 63
	lea	rax, [__quest+rip]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_244

$_212:	xor	eax, eax
$_213:	cmp	byte ptr [rbp-0x1], 0
	jz	$_215
	mov	eax, dword ptr [rbx+0x8]
	mov	ecx, dword ptr [rbx+0x8]
	and	eax, 0x3FFF
	lea	r10, [resw_table+rip]
	lea	r8, [ResWordTable+rip]
	mov	ax, word ptr [r10+rax*2]
$_214:	test	eax, eax
	jz	$_215
	cmp	ecx, dword ptr [r8+rax*8+0x4]
	jz	$_215
	mov	ax, word ptr [r8+rax*8]
	jmp	$_214

$_215:	mov	rcx, qword ptr [rdx+0x8]
	mov	qword ptr [rdx+0x8], rdi
	mov	rdi, qword ptr [rdx]
	mov	qword ptr [rdx], rsi
	mov	dword ptr [rbx+0x4], eax
	jmp	$_242

$_216:	cmp	byte ptr [rcx], 46
	jnz	$_217
	test	byte ptr [r14], 0x04
	jnz	$_217
	inc	rdi
	mov	qword ptr [rdx+0x8], rcx
	mov	qword ptr [rdx], rdi
	mov	ecx, 46
	lea	rax, [stokstr1+0xC+rip]
	mov	qword ptr [rbx+0x10], rax
	jmp	$_243

$_217:	mov	ecx, 8
	jmp	$_243

$_218:	inc	byte ptr [rdx+0x30]
	jmp	$_231

$_219:	or	byte ptr [rbx+0x2], 0x01
	jmp	$_231

$_220:	cmp	dword ptr [rdx+0x18], 0
	jz	$_221
	jmp	$_231

$_221:	mov	eax, 1340
	mov	dword ptr [rbx+0x4], eax
$_222:	test	byte ptr [r14+0x2], 0x80
	je	$_230
	lea	r11, [optable_idx+rip]
	movzx	eax, word ptr [r11+rax*2-0x4E8]
	lea	rax, [r12+rax*8+0x2740]
	movzx	ecx, byte ptr [rax+0x3]
	movzx	eax, cl
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_223
	mov	eax, 128
	jmp	$_224

$_223:	cmp	eax, 6
	jc	$_224
	mov	eax, 6
$_224:	mov	edx, eax
	movzx	eax, cl
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_225
	xor	eax, eax
$_225:	mov	ecx, eax
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_226
	mov	eax, 128
	jmp	$_227

$_226:	cmp	eax, 6
	jc	$_227
	mov	eax, 6
$_227:	mov	edi, eax
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_228
	xor	eax, eax
$_228:	mov	esi, eax
	cmp	edx, edi
	ja	$_229
	cmp	ecx, esi
	jbe	$_230
$_229:	mov	ecx, 8
	mov	dword ptr [rbx+0x4], 0
	jmp	$_243

$_230:	mov	ecx, 1
	jmp	$_243

$_231:	add	eax, eax
	lea	rax, [r12+rax*8]
	mov	rcx, rax
	mov	al, byte ptr [rcx+0xC]
	mov	byte ptr [rbx+0x1], al
	movzx	eax, byte ptr [rcx+0xD]
	jmp	$_240

$_232:	mov	ecx, 2
	jmp	$_241

$_233:	cmp	byte ptr [rdx+0x1D], 0
	jnz	$_234
	mov	eax, dword ptr [rcx]
	mov	byte ptr [rdx+0x1D], al
$_234:	mov	ecx, 3
	jmp	$_241

$_235:	mov	ecx, 4
	jmp	$_241

$_236:	mov	ecx, 5
	jmp	$_241

$_237:	mov	ecx, 6
	jmp	$_241

$_238:	mov	ecx, 7
	jmp	$_241

$_239:	mov	ecx, 8
	mov	dword ptr [rbx+0x4], 0
	jmp	$_241

$_240:	cmp	eax, 2
	jz	$_232
	cmp	eax, 3
	jz	$_233
	cmp	eax, 4
	jz	$_235
	cmp	eax, 5
	jz	$_236
	cmp	eax, 6
	jz	$_237
	cmp	eax, 7
	jz	$_238
	jmp	$_239

$_241:	jmp	$_243

$_242:	test	eax, eax
	je	$_216
	cmp	eax, 504
	je	$_218
	cmp	eax, 415
	je	$_219
	cmp	eax, 411
	je	$_219
	cmp	eax, 510
	je	$_219
	cmp	eax, 344
	je	$_220
	cmp	eax, 628
	jnc	$_222
	jmp	$_231

$_243:	mov	byte ptr [rbx], cl
	xor	eax, eax
$_244:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_245:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	inc	rsi
	mov	r10, rcx
	mov	ecx, 2166136261
	mov	ebx, 2166136261
$_246:	lodsb
	cmp	al, 96
	jz	$_249
	test	al, al
	jz	$_247
	cmp	al, 59
	jnz	$_248
$_247:	mov	byte ptr [rdi], 0
	mov	ecx, 2046
	call	asmerr@PLT
	jmp	$_250

$_248:	stosb
	imul	ebx, ebx, 16777619
	imul	ecx, ecx, 16777619
	xor	bl, al
	or	al, 0x20
	xor	cl, al
	jmp	$_246

$_249:	mov	eax, ebx
	mov	rbx, r10
	mov	byte ptr [rbx], 8
	mov	dword ptr [rbx+0x8], ecx
	mov	dword ptr [rbx+0xC], eax
	mov	rcx, rdi
	sub	rcx, qword ptr [rdx+0x8]
	mov	byte ptr [rbx+0x3], cl
	mov	qword ptr [rdx], rsi
	xor	eax, eax
	stosb
	mov	qword ptr [rdx+0x8], rdi
$_250:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_251:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	call	tstrstart@PLT
	test	ecx, ecx
	jz	$_253
	mov	byte ptr [r14+0x18], cl
	inc	rax
	mov	edx, ecx
	mov	rcx, rax
	call	tstrchr@PLT
	test	rax, rax
	jz	$_252
	mov	byte ptr [r14+0x18], 0
$_252:	jmp	$_254

$_253:	mov	ecx, 2110
	call	asmerr@PLT
$_254:	leave
	ret

GetToken:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	xor	eax, eax
	mov	qword ptr [rcx], rax
	mov	rax, qword ptr [rdx]
	jmp	$_272

$_255:	call	$_158
	jmp	$_274

$_256:	call	$_203
	jmp	$_274

$_257:	test	byte ptr [Options+0x6+rip], 0x10
	jne	$_273
	call	$_245
	jmp	$_274

$_258:	mov	rax, qword ptr [rdx]
	movzx	eax, byte ptr [rax+0x1]
	test	byte ptr [r15+rax], 0x44
	je	$_273
	xor	eax, eax
	cmp	eax, dword ptr [rdx+0x18]
	jz	$_259
	movzx	eax, byte ptr [rcx-0x20]
$_259:	cmp	dword ptr [rdx+0x18], 0
	jz	$_260
	cmp	eax, 2
	jz	$_261
	cmp	eax, 41
	jz	$_261
	cmp	eax, 93
	jz	$_261
	cmp	eax, 8
	jz	$_261
$_260:	call	$_203
	jmp	$_274

$_261:	cmp	eax, 41
	jnz	$_268
	mov	rsi, rcx
	lea	rbx, [rcx-0x40]
	mov	eax, 1
	mov	ecx, dword ptr [rdx+0x18]
	sub	ecx, 2
$_262:	cmp	ecx, 1
	jle	$_265
	cmp	byte ptr [rbx], 40
	jnz	$_263
	dec	eax
	jz	$_265
	jmp	$_264

$_263:	cmp	byte ptr [rbx], 41
	jnz	$_264
	inc	eax
$_264:	dec	ecx
	sub	rbx, 32
	jmp	$_262

$_265:	cmp	ecx, 1
	jbe	$_267
	sub	ecx, 1
	sub	rbx, 32
	cmp	byte ptr [rbx-0x20], 46
	jnz	$_267
	sub	ecx, 2
	sub	rbx, 64
	cmp	byte ptr [rbx], 93
	jnz	$_267
	sub	rbx, 32
	dec	ecx
$_266:	test	ecx, ecx
	jz	$_267
	cmp	byte ptr [rbx], 91
	jz	$_267
	dec	ecx
	sub	rbx, 32
	jmp	$_266

$_267:	mov	eax, dword ptr [rbx-0x1C]
	mov	rcx, rsi
	jmp	$_269

$_268:	xor	eax, eax
	cmp	dword ptr [rdx+0x18], 1
	jbe	$_269
	mov	eax, dword ptr [rcx-0x3C]
$_269:	cmp	eax, 412
	jz	$_270
	cmp	eax, 512
	jz	$_270
	cmp	eax, 413
	jz	$_270
	cmp	eax, 515
	jnz	$_271
$_270:	call	$_203
	jmp	$_274

$_271:	jmp	$_273

$_272:	movzx	eax, byte ptr [rax]
	test	byte ptr [r15+rax], 0x04
	jne	$_255
	test	byte ptr [r15+rax], 0x40
	jne	$_256
	cmp	al, 96
	je	$_257
	cmp	al, 46
	je	$_258
$_273:	call	$_093
$_274:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

Tokenize:
	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, 104
	mov	qword ptr [rbp-0x40], rcx
	mov	qword ptr [rbp-0x30], rcx
	mov	qword ptr [rbp-0x20], r8
	mov	rax, qword ptr [StringBuffer+rip]
	mov	qword ptr [rbp-0x18], rax
	mov	eax, dword ptr [rbp+0x40]
	mov	byte ptr [rbp-0x24], al
	mov	dword ptr [rbp-0x28], edx
	mov	byte ptr [rbp-0x23], 0
	mov	byte ptr [rbp-0x22], 0
	mov	byte ptr [rbp-0x10], 0
	mov	byte ptr [rbp-0x21], 0
	test	edx, edx
	jnz	$_277
	mov	rax, qword ptr [StringBuffer+rip]
	mov	qword ptr [rbp-0x38], rax
	cmp	byte ptr [r14+0x18], 0
	jz	$_276
	movzx	edx, byte ptr [r14+0x18]
	mov	rcx, qword ptr [rbp-0x30]
	call	tstrchr@PLT
	test	rax, rax
	jz	$_275
	mov	byte ptr [r14+0x18], 0
$_275:	jmp	$_315

$_276:	jmp	$_278

$_277:	mov	rax, qword ptr [r14+0x1E0]
	mov	qword ptr [rbp-0x38], rax
$_278:	mov	rsi, qword ptr [rbp-0x40]
	jmp	$_280

$_279:	inc	rsi
$_280:	movzx	eax, byte ptr [rsi]
	test	byte ptr [r15+rax], 0x08
	jnz	$_279
	mov	qword ptr [rbp-0x40], rsi
	cmp	al, 59
	jnz	$_284
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_284
	jmp	$_282

$_281:	movzx	eax, byte ptr [rsi-0x1]
	test	byte ptr [r15+rax], 0x08
	jz	$_283
	dec	rsi
$_282:	cmp	rsi, qword ptr [rbp-0x30]
	ja	$_281
$_283:	mov	qword ptr [rbp-0x40], rsi
	mov	rdx, rsi
	mov	rcx, qword ptr [CommentBuffer+rip]
	call	tstrcpy@PLT
	mov	qword ptr [r14+0x48], rax
	mov	byte ptr [rsi], 0
$_284:	imul	ebx, dword ptr [rbp-0x28], 32
	add	rbx, qword ptr [rbp-0x20]
	mov	qword ptr [rbx+0x18], rsi
	cmp	byte ptr [rsi], 0
	jne	$_292
	cmp	dword ptr [rbp-0x28], 1
	jbe	$_291
	cmp	byte ptr [rbx-0x20], 44
	jz	$_285
	cmp	byte ptr [rbp-0x21], 0
	je	$_291
$_285:	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_286
	cmp	dword ptr [UseSavedState+rip], 0
	jne	$_291
$_286:	cmp	dword ptr [rbp+0x30], 0
	jne	$_291
	mov	rcx, qword ptr [rbp-0x20]
	call	$_001
	test	rax, rax
	jnz	$_287
	cmp	byte ptr [rbp-0x21], 0
	je	$_291
$_287:	mov	rcx, qword ptr [rbp-0x38]
	call	tstrlen@PLT
	mov	edi, eax
	add	edi, 8
	and	edi, 0xFFFFFFF8
	add	rdi, qword ptr [rbp-0x38]
	mov	rcx, rdi
	call	GetTextLine@PLT
	test	rax, rax
	jz	$_291
	mov	rcx, rdi
	jmp	$_289

$_288:	add	rcx, 1
$_289:	movzx	eax, byte ptr [rcx]
	test	byte ptr [r15+rax], 0x08
	jnz	$_288
	xchg	rcx, rax
	mov	rdi, rax
	test	ecx, ecx
	jz	$_291
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp-0x40]
	call	tstrcpy@PLT
	mov	rcx, qword ptr [rbp-0x30]
	call	tstrlen@PLT
	mov	ecx, dword ptr [r14+0x234]
	sub	ecx, 32
	cmp	eax, ecx
	jc	$_290
	lea	rcx, [rbp-0x40]
	call	InputExtend@PLT
	test	rax, rax
	jnz	$_290
	mov	ecx, 2039
	call	asmerr@PLT
	mov	eax, dword ptr [rbp+0x30]
	mov	dword ptr [rbp-0x28], eax
	jmp	$_314

$_290:	jmp	$_278

$_291:	jmp	$_314

$_292:	mov	rax, qword ptr [rbp-0x38]
	mov	qword ptr [rbx+0x10], rax
	lea	rdx, [rbp-0x40]
	mov	rcx, rbx
	call	GetToken
	mov	dword ptr [rbp-0x4], eax
	imul	ebx, dword ptr [rbp-0x28], 32
	add	rbx, qword ptr [rbp-0x20]
	jmp	$_297

$_293:	jmp	$_278

$_294:	mov	eax, dword ptr [rbp+0x30]
	mov	dword ptr [rbp-0x28], eax
	jmp	$_314

$_295:	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_296
	mov	rax, qword ptr [rbp-0x20]
	or	byte ptr [rax+0x2], 0x40
$_296:	jmp	$_298

$_297:	cmp	eax, -2
	jz	$_293
	cmp	eax, -1
	jz	$_294
	cmp	byte ptr [rbx], 13
	jz	$_295
$_298:	test	byte ptr [rbp+0x40], 0x01
	jne	$_311
	mov	rax, qword ptr [rbp-0x20]
	mov	cl, byte ptr [rax+0x20]
	mov	eax, dword ptr [rbp-0x28]
	test	eax, eax
	jz	$_299
	cmp	eax, 2
	jne	$_311
	cmp	cl, 58
	jz	$_299
	cmp	cl, 13
	jne	$_311
$_299:	mov	ecx, dword ptr [rbx+0x4]
	cmp	byte ptr [rbx], 3
	jne	$_310
	cmp	byte ptr [rbx+0x1], 0
	jz	$_300
	cmp	ecx, 488
	jne	$_310
$_300:	cmp	ecx, 536
	jnz	$_301
	mov	rcx, qword ptr [rbp-0x40]
	call	$_251
	jmp	$_314

$_301:	mov	edx, 1
	cmp	ecx, 488
	jnz	$_306
	dec	edx
	test	byte ptr [r14+0x2], 0x02
	jnz	$_306
	mov	rax, qword ptr [rbp-0x40]
	mov	cl, byte ptr [rax]
	jmp	$_303

$_302:	inc	rax
	mov	cl, byte ptr [rax]
$_303:	cmp	cl, 32
	jz	$_302
	cmp	cl, 9
	jz	$_302
	cmp	cl, 58
	jnz	$_306
	inc	rax
	mov	cl, byte ptr [rax]
	jmp	$_305

$_304:	inc	rax
	mov	cl, byte ptr [rax]
$_305:	cmp	cl, 32
	jz	$_304
	cmp	cl, 9
	jz	$_304
	mov	eax, dword ptr [rax]
	or	eax, 0x20202020
	cmp	eax, 1935961701
	jnz	$_306
	mov	ecx, 562
	inc	edx
$_306:	test	edx, edx
	jz	$_308
	call	CondPrepare@PLT
	cmp	dword ptr [CurrIfState+rip], 0
	jz	$_307
	inc	dword ptr [rbp-0x28]
	jmp	$_314

$_307:	jmp	$_309

$_308:	cmp	dword ptr [CurrIfState+rip], 0
	jnz	$_314
$_309:	jmp	$_311

$_310:	cmp	dword ptr [CurrIfState+rip], 0
	jz	$_311
	jmp	$_314

$_311:	inc	dword ptr [rbp-0x28]
	mov	eax, dword ptr [r14+0x234]
	shr	eax, 2
	cmp	dword ptr [rbp-0x28], eax
	jl	$_313
	dec	dword ptr [rbp-0x28]
	lea	rcx, [rbp-0x40]
	call	InputExtend@PLT
	test	rax, rax
	jnz	$_312
	mov	ecx, 2141
	call	asmerr@PLT
	mov	eax, dword ptr [rbp+0x30]
	mov	dword ptr [rbp-0x28], eax
	jmp	$_315

$_312:	inc	dword ptr [rbp-0x28]
$_313:	mov	rax, qword ptr [rbp-0x38]
	sub	rax, qword ptr [StringBuffer+rip]
	add	rax, 8
	and	rax, 0xFFFFFFFFFFFFFFF8
	add	rax, qword ptr [StringBuffer+rip]
	mov	qword ptr [rbp-0x38], rax
	jmp	$_278

$_314:	mov	rax, qword ptr [rbp-0x38]
	sub	rax, qword ptr [StringBuffer+rip]
	add	rax, 8
	and	rax, 0xFFFFFFFFFFFFFFF8
	add	rax, qword ptr [StringBuffer+rip]
	mov	qword ptr [rbp-0x38], rax
	mov	qword ptr [r14+0x1E0], rax
	cmp	byte ptr [rbp-0x21], 0
	jz	$_315
	cmp	dword ptr [rbp+0x40], 1
	jz	$_315
	cmp	dword ptr [CurrIfState+rip], 0
	jnz	$_315
	mov	ecx, 2157
	call	asmerr@PLT
$_315:	mov	rbx, qword ptr [rbp-0x20]
	imul	eax, dword ptr [rbp-0x28], 32
	add	rbx, rax
	mov	byte ptr [rbx], 0
	mov	al, byte ptr [rbp-0x22]
	mov	byte ptr [rbx+0x1], al
	lea	rax, [__null+rip]
	mov	qword ptr [rbx+0x10], rax
	mov	eax, dword ptr [rbp-0x28]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret


.SECTION .data
	.ALIGN	16

stokstr1:
	.byte  0x28, 0x00, 0x29, 0x00, 0x2A, 0x00, 0x2B, 0x00
	.byte  0x2C, 0x00, 0x2D, 0x00, 0x2E, 0x00, 0x2F, 0x00

stokstr2:
	.byte  0x5B, 0x00, 0x00, 0x00, 0x5D, 0x00

__equ:
	.byte  0x3D, 0x00

__dcolon:
	.byte  0x3A, 0x3A, 0x00

__amp:
	.byte  0x26, 0x00

__percent:
	.byte  0x25, 0x00

__quest:
	.byte  0x3F, 0x00

__null:
	.byte  0x00

DS0000:
	.byte  0x3D, 0x21, 0x3C, 0x3E, 0x26, 0x7C, 0x00


.att_syntax prefix
