
.intel_syntax noprefix

.global get_register
.global InvokeDirective

.extern AssignPointer
.extern RunLineQueue
.extern AddLineQueueX
.extern AddLineQueue
.extern ExpandHllProc
.extern GetResWName
.extern CreateFloat
.extern atofloat
.extern quad_resize
.extern __cvtq_sd
.extern EvalOperand
.extern get_fasttype
.extern sym_ReservedStack
.extern CurrProc
.extern LstWrite
.extern GetGroup
.extern GetCurrOffset
.extern GetSymOfssize
.extern GetOfssizeAssume
.extern GetStdAssume
.extern search_assume
.extern SizeFromRegister
.extern SizeFromMemtype
.extern LclDup
.extern tsprintf
.extern asmerr
.extern stackreg
.extern Options
.extern ModuleInfo
.extern Parse_Pass
.extern SymFindID
.extern SymFind
.extern tstrcat
.extern tstrcpy
.extern tstrlen
.extern tmemcpy


.SECTION .text
	.ALIGN	16

$_001:	mov	dword ptr [simd_scratch+rip], 0
	mov	dword ptr [wreg_scratch+rip], 0
	ret

get_register:
	mov	eax, ecx
	add	eax, eax
	lea	rax, [r12+rax*8]
	test	byte ptr [rax], 0x10
	jz	$_002
	mov	edx, 16
$_002:	movzx	eax, byte ptr [rax+0xC]
	xchg	ecx, eax
	cmp	ecx, 15
	ja	$_012
	jmp	$_011

$_003:	cmp	ecx, 4
	jnc	$_004
	lea	rax, [rcx+0x1]
	jmp	$_012

$_004:	lea	rax, [rcx+0x53]
	jmp	$_012

$_005:	cmp	ecx, 8
	jnc	$_006
	lea	rax, [rcx+0x9]
	jmp	$_012

$_006:	lea	rax, [rcx+0x6B]
	jmp	$_012

$_007:	cmp	ecx, 8
	jnc	$_008
	lea	rax, [rcx+0x11]
	jmp	$_012

$_008:	lea	rax, [rcx+0x83]
	jmp	$_012

$_009:	cmp	ecx, 8
	jnc	$_010
	lea	rax, [rcx+0xA3]
	jmp	$_012

$_010:	lea	rax, [rcx+0xA3]
	jmp	$_012

	jmp	$_012

$_011:	cmp	rdx, 1
	jz	$_003
	cmp	rdx, 2
	jz	$_005
	cmp	rdx, 4
	jz	$_007
	cmp	rdx, 8
	jz	$_009
$_012:	ret

$_013:
	mov	rdx, qword ptr [rdx]
	xchg	rdi, rdx
	mov	ecx, 31
	repne scasb
	movzx	eax, byte ptr [rdi]
	mov	rdi, rdx
	ret

$_014:
	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, 184
	mov	dword ptr [rbp-0x74], 0
	mov	dword ptr [rbp-0x78], 0
	mov	dword ptr [rbp-0x7C], 0
	mov	dword ptr [rbp-0x80], 0
	mov	byte ptr [rbp-0x85], 0
	mov	rbx, rcx
	mov	esi, edx
	mov	rcx, rbx
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	dword ptr [rbp-0x84], ecx
	mov	eax, 2
	shl	eax, cl
	mov	dword ptr [rbp-0x70], eax
	mov	rdx, qword ptr [rbx+0x78]
	mov	rdi, qword ptr [rdx+0x18]
$_015:	test	rdi, rdi
	jz	$_023
	test	byte ptr [rdi+0x11], 0x10
	jnz	$_016
	cmp	byte ptr [rdi+0x1E], 194
	jnz	$_018
$_016:	dec	esi
	cmp	byte ptr [rdi+0x1E], 194
	jnz	$_017
	inc	dword ptr [rbp-0x7C]
$_017:	jmp	$_022

$_018:	test	byte ptr [rdi+0x4B], 0x04
	jz	$_019
	dec	dword ptr [rbp+0x30]
	inc	byte ptr [rbp-0x85]
	jmp	$_022

$_019:	inc	dword ptr [rbp-0x74]
	mov	eax, dword ptr [rdi+0x60]
	mov	edx, dword ptr [rbp-0x70]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	add	dword ptr [rbp-0x80], eax
	mov	dl, byte ptr [rdi+0x1E]
	cmp	dl, 196
	jnz	$_020
	mov	rdx, qword ptr [rdi+0x28]
	mov	dl, byte ptr [rdx+0x1E]
$_020:	test	dl, 0x20
	jnz	$_021
	cmp	dl, 31
	jnz	$_022
$_021:	inc	dword ptr [rbp-0x78]
$_022:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_015

$_023:
	cmp	byte ptr [rbp-0x85], 0
	je	$_038
	imul	edi, dword ptr [rbp+0x38], 32
	add	rdi, qword ptr [rbp+0x40]
	xor	ecx, ecx
$_024:	cmp	ecx, dword ptr [rbp+0x30]
	jg	$_026
	cmp	byte ptr [rdi], 0
	jz	$_026
	inc	dword ptr [rbp+0x38]
	cmp	byte ptr [rdi], 44
	jnz	$_025
	inc	ecx
$_025:	add	rdi, 32
	jmp	$_024

$_026:	jmp	$_037

$_027:	movzx	eax, byte ptr [rdi]
	jmp	$_032

$_028:	mov	eax, dword ptr [rbp+0x38]
	mov	dword ptr [rbp-0x6C], eax
	mov	byte ptr [rsp+0x20], 1
	lea	r9, [rbp-0x68]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x40]
	lea	rcx, [rbp-0x6C]
	call	EvalOperand@PLT
	cmp	eax, -1
	jz	$_033
	cmp	byte ptr [rbp-0x24], 192
	jz	$_029
	test	byte ptr [rbp-0x24], 0x20
	jz	$_029
	inc	dword ptr [simd_scratch+rip]
$_029:	jmp	$_033

$_030:	mov	eax, dword ptr [rdi+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_033
$_031:	inc	dword ptr [simd_scratch+rip]
	jmp	$_033

$_032:	cmp	eax, 8
	jz	$_028
	cmp	eax, 6
	jz	$_028
	cmp	eax, 91
	jz	$_028
	cmp	eax, 2
	jz	$_030
	cmp	eax, 11
	jz	$_031
$_033:	jmp	$_035

$_034:	inc	dword ptr [rbp+0x38]
	add	rdi, 32
	cmp	byte ptr [rdi-0x20], 44
	jz	$_036
$_035:	cmp	byte ptr [rdi], 0
	jnz	$_034
$_036:	inc	dword ptr [wreg_scratch+rip]
$_037:	cmp	byte ptr [rdi], 0
	jne	$_027
	mov	eax, dword ptr [simd_scratch+rip]
	sub	dword ptr [wreg_scratch+rip], eax
$_038:	movzx	edx, byte ptr [rbx+0x1F]
	mov	ecx, dword ptr [rbp-0x84]
	call	get_fasttype@PLT
	mov	rdi, rax
	mov	rcx, qword ptr [rbp+0x48]
	mov	eax, dword ptr [simd_scratch+rip]
	add	eax, dword ptr [wreg_scratch+rip]
	mul	dword ptr [rbp-0x70]
	add	eax, dword ptr [rbp-0x80]
	mov	edx, eax
	test	byte ptr [rdi+0xF], 0x10
	je	$_048
	xor	eax, eax
	mov	dword ptr [rcx], eax
	mov	ecx, dword ptr [rbp-0x70]
	movzx	edx, byte ptr [rdi+0xD]
	movzx	eax, byte ptr [rbx+0x5A]
	cmp	dl, byte ptr [rdi+0xC]
	jbe	$_039
	add	ecx, ecx
$_039:	cmp	eax, ecx
	jbe	$_040
	mov	ecx, eax
$_040:	mov	byte ptr [rbx+0x5A], cl
	mov	eax, dword ptr [rbp+0x30]
	add	eax, dword ptr [simd_scratch+rip]
	add	eax, dword ptr [wreg_scratch+rip]
	sub	eax, dword ptr [rbp-0x7C]
	cmp	al, dl
	jnc	$_041
	mov	al, dl
$_041:	mov	edx, eax
	cmp	ecx, 8
	jnz	$_042
	test	eax, 0x1
	jz	$_042
	inc	eax
$_042:	test	byte ptr [rbx+0x11], 0x02
	jz	$_043
	cmp	dl, byte ptr [rdi+0xD]
	jnz	$_043
	xor	eax, eax
$_043:	mul	ecx
	test	byte ptr [r14+0x2D], 0x02
	jz	$_046
	mov	rdx, qword ptr [CurrProc+rip]
	test	eax, eax
	jz	$_044
	test	rdx, rdx
	jz	$_044
	mov	rcx, qword ptr [rdx+0x78]
	or	byte ptr [rcx+0x1], 0x01
$_044:	mov	rdx, qword ptr [sym_ReservedStack+rip]
	cmp	eax, dword ptr [rdx+0x30]
	jle	$_045
	mov	dword ptr [rdx+0x30], eax
$_045:	jmp	$_047

$_046:	test	eax, eax
	jz	$_047
	mov	rcx, qword ptr [rbp+0x48]
	mov	dword ptr [rcx], eax
	mov	edx, eax
	lea	rcx, [DS0000+rip]
	call	AddLineQueueX@PLT
$_047:	xor	eax, eax
	jmp	$_054

$_048:	test	byte ptr [rdi+0xF], 0x20
	jz	$_052
	movzx	edi, byte ptr [rbx+0x59]
	movzx	esi, byte ptr [rbx+0x58]
	add	edi, dword ptr [simd_scratch+rip]
	add	edi, dword ptr [rbp-0x78]
	add	esi, dword ptr [rbp-0x74]
	sub	esi, dword ptr [rbp-0x78]
	add	esi, dword ptr [wreg_scratch+rip]
	xor	eax, eax
	cmp	esi, 6
	jbe	$_049
	lea	eax, [rsi-0x6]
$_049:	cmp	edi, 8
	jbe	$_050
	lea	eax, [rax+rdi-0x8]
	mov	edi, 8
$_050:	mul	dword ptr [rbp-0x70]
	mov	dword ptr [rcx], eax
	test	eax, 0xF
	jz	$_051
	test	byte ptr [r14+0x2D], 0x02
	jz	$_051
	add	eax, 8
	mov	dword ptr [rcx], eax
	lea	rcx, [DS0001+rip]
	call	AddLineQueue@PLT
$_051:	mov	eax, edi
	jmp	$_054

$_052:	mov	eax, dword ptr [rbp-0x84]
	shr	eax, 1
	test	byte ptr [rdi+0xF], 0x02
	jz	$_053
	test	byte ptr [rbx+0x11], 0x02
	jnz	$_053
	xor	edx, edx
$_053:	mov	dword ptr [rcx], edx
$_054:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_055:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	edx, r8d
	test	edx, edx
	jz	$_056
	call	GetSymOfssize@PLT
	lea	rdx, [stackreg+rip]
	mov	edx, dword ptr [rdx+rax*4]
	mov	r8d, dword ptr [rbp+0x20]
	lea	rcx, [DS0002+rip]
	call	AddLineQueueX@PLT
$_056:	leave
	ret

$_057:
	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, 40
	mov	esi, 0
	mov	rdi, rcx
	mov	rax, qword ptr [rdi+0x50]
	mov	rdx, qword ptr [rdi+0x30]
	test	rdx, rdx
	jz	$_060
	cmp	byte ptr [rdx], 2
	jnz	$_058
	mov	esi, dword ptr [rdx+0x4]
	jmp	$_059

$_058:	mov	rdx, qword ptr [rdx+0x10]
	mov	rcx, rdi
	call	tstrcpy@PLT
$_059:	jmp	$_070

$_060:	test	rax, rax
	je	$_068
	cmp	qword ptr [rax+0x40], 0
	je	$_068
	mov	rbx, qword ptr [rax+0x40]
	mov	rcx, qword ptr [rbx+0x78]
	cmp	dword ptr [rcx+0x48], 2
	jz	$_061
	cmp	dword ptr [rcx+0x48], 3
	jnz	$_062
$_061:	mov	r8d, 1
	mov	edx, 3
	mov	rcx, rbx
	call	search_assume@PLT
	jmp	$_063

$_062:	mov	r8d, 1
	mov	edx, 1
	mov	rcx, rbx
	call	search_assume@PLT
$_063:	cmp	eax, -2
	jz	$_064
	lea	rsi, [rax+0x19]
	jmp	$_067

$_064:	mov	rcx, qword ptr [rdi+0x50]
	call	GetGroup@PLT
	test	rax, rax
	jnz	$_065
	mov	rax, rbx
$_065:	test	rax, rax
	jz	$_066
	mov	rdx, qword ptr [rax+0x8]
	mov	rcx, qword ptr [rbp+0x30]
	call	tstrcpy@PLT
	jmp	$_067

$_066:	lea	rdx, [DS0003+rip]
	mov	rcx, qword ptr [rbp+0x30]
	call	tstrcpy@PLT
	mov	rdx, qword ptr [rbp+0x38]
	mov	rcx, rax
	call	tstrcat@PLT
$_067:	jmp	$_070

$_068:	test	rax, rax
	jz	$_069
	cmp	byte ptr [rax+0x1D], 5
	jnz	$_069
	mov	esi, 27
	jmp	$_070

$_069:	lea	rdx, [DS0003+rip]
	mov	rcx, qword ptr [rbp+0x30]
	call	tstrcpy@PLT
	mov	rdx, qword ptr [rbp+0x38]
	mov	rcx, rax
	call	tstrcat@PLT
$_070:	mov	rax, rsi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_071:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	edx, 2
	jnz	$_072
	movzx	eax, word ptr [rcx]
	movzx	edx, word ptr [rcx+0x2]
	jmp	$_073

$_072:	mov	eax, dword ptr [rcx]
	mov	edx, dword ptr [rcx+0x4]
$_073:	mov	r8d, eax
	lea	rcx, [DS0004+rip]
	call	AddLineQueueX@PLT
	leave
	ret

$_074:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 48
	cmp	edx, 2
	jnz	$_075
	mov	eax, 2
	mov	edx, 271
	jmp	$_077

$_075:	cmp	edx, 4
	jnz	$_076
	mov	eax, 4
	mov	edx, 274
	jmp	$_077

$_076:	mov	eax, 8
	mov	edx, 278
$_077:	mov	qword ptr [rsp+0x28], rcx
	mov	dword ptr [rsp+0x20], edx
	mov	r9d, eax
	mov	r8, rcx
	lea	rcx, [DS0005+rip]
	call	AddLineQueueX@PLT
	leave
	ret

$_078:
	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, 184
	mov	dword ptr [rbp-0x8], 0
	mov	dword ptr [rbp-0xC], 0
	mov	dword ptr [rbp-0x20], 0
	mov	dword ptr [rbp-0x2C], 0
	mov	byte ptr [rbp-0x59], 0
	mov	byte ptr [rbp-0x5B], 0
	mov	byte ptr [rbp-0x5D], 0
	mov	byte ptr [rbp-0x6E], 0
	mov	rbx, rcx
	mov	rsi, r8
	mov	rdi, qword ptr [rbp+0x48]
	movzx	ecx, byte ptr [rbx+0x20]
	mov	byte ptr [rbp-0x5A], cl
	mov	eax, 2
	shl	eax, cl
	mov	dword ptr [rbp-0x38], eax
	mov	rdx, qword ptr [rbp+0x60]
	xor	eax, eax
	test	byte ptr [rdx+0xF], 0x10
	setne	al
	mov	byte ptr [rbp-0x5B], al
	test	byte ptr [rdx+0xF], 0x08
	setne	al
	add	eax, eax
	cmp	byte ptr [rbp-0x5A], 0
	setne	cl
	shl	eax, cl
	mov	dword ptr [rbp-0x28], eax
	mov	al, byte ptr [rdx+0xE]
	mov	dword ptr [rbp-0x40], eax
	mov	eax, dword ptr [rdx+0x8]
	mov	dword ptr [rbp-0x44], eax
	mov	al, byte ptr [rsi+0x1E]
	cmp	al, 196
	jnz	$_079
	mov	rax, qword ptr [rsi+0x28]
	mov	al, byte ptr [rax+0x1E]
$_079:	mov	byte ptr [rbp-0x5C], al
	mov	rcx, qword ptr [rbp+0x50]
	cmp	byte ptr [rcx], 0
	jz	$_080
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_081
	test	byte ptr [rbx+0x11], 0x02
	jz	$_081
$_080:	jmp	$_392

$_081:	mov	rdx, qword ptr [rbx+0x78]
	test	byte ptr [rdx], 0x01
	jz	$_082
	test	byte ptr [rbx+0x11], 0x02
	jz	$_082
	test	byte ptr [rbx+0x11], 0x01
	jz	$_082
	cmp	dword ptr [rbp+0x30], 0
	jnz	$_082
	jmp	$_392

$_082:	cmp	byte ptr [rbp-0x5C], 194
	jnz	$_083
	mov	rcx, qword ptr [rbp+0x50]
	call	LclDup@PLT
	mov	qword ptr [rsi+0x8], rax
	jmp	$_392

$_083:	mov	cl, byte ptr [rbp-0x5A]
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_084
	mov	eax, 128
	jmp	$_085

$_084:	cmp	eax, 6
	jc	$_085
	mov	eax, 6
$_085:	mov	byte ptr [rbp-0x2D], al
	movzx	edx, byte ptr [rbx+0x5A]
	mov	dword ptr [rbp-0x24], edx
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_087
	mov	eax, dword ptr [rbp-0x38]
	mov	ecx, dword ptr [rbp+0x30]
	cmp	al, dl
	jnc	$_086
	mov	al, dl
$_086:	mul	ecx
	mov	dword ptr [rbp-0x2C], eax
	mov	byte ptr [rsi+0x5B], al
$_087:	mov	eax, dword ptr [rbp-0x38]
	cmp	eax, 8
	jnz	$_088
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_088
	cmp	dword ptr [rdi+0x38], 313
	jz	$_088
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_088
	mov	eax, 4
$_088:	mov	dword ptr [rbp-0x4], eax
	mov	cl, byte ptr [rdi+0x44]
	cmp	cl, 240
	jnz	$_089
	mov	cl, 192
$_089:	xor	eax, eax
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_090
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_091
$_090:	jmp	$_101

$_091:	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_097
	test	byte ptr [rdi+0x40], 0x01
	jz	$_095
	cmp	cl, 192
	jz	$_092
	dec	eax
	jmp	$_094

$_092:	cmp	byte ptr [rbp-0x5C], 195
	jz	$_093
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_094
$_093:	mov	eax, dword ptr [rbp-0x38]
$_094:	jmp	$_096

$_095:	cmp	cl, 192
	jz	$_096
	dec	eax
$_096:	jmp	$_101

$_097:	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_101
	cmp	cl, 192
	jz	$_099
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_098
	cmp	byte ptr [rbp-0x5C], 192
	jnz	$_098
	mov	byte ptr [rbp-0x5C], cl
$_098:	dec	eax
	jmp	$_101

$_099:	cmp	byte ptr [rbp-0x5C], 195
	jz	$_100
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_101
$_100:	mov	eax, dword ptr [rbp-0x38]
$_101:	test	eax, eax
	jz	$_103
	cmp	eax, -1
	jnz	$_102
	mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rbp-0x5A]
	movzx	ecx, cl
	call	SizeFromMemtype@PLT
$_102:	mov	dword ptr [rbp-0x4], eax
$_103:	cmp	qword ptr [rdi+0x18], 0
	je	$_111
	mov	rax, qword ptr [rdi+0x18]
	mov	ecx, dword ptr [rax+0x4]
	mov	eax, ecx
	add	eax, eax
	lea	rax, [r12+rax*8]
	mov	rdx, rax
	mov	eax, dword ptr [rdx+0x4]
	and	eax, 0x7F
	mov	dword ptr [rbp-0xC], eax
	mov	eax, ecx
	movzx	ecx, byte ptr [rdx+0xC]
	mov	edx, dword ptr [rdx]
	mov	dword ptr [rbp-0x10], ecx
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_104
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_104
	mov	dword ptr [rbp-0x8], eax
$_104:	test	edx, 0x70
	jz	$_105
	inc	byte ptr [rbp-0x59]
	add	ecx, 16
$_105:	test	edx, 0xF
	jnz	$_106
	cmp	ecx, 32
	jnc	$_111
	test	edx, 0x70
	jz	$_111
$_106:	mov	dword ptr [rbp-0x54], eax
	mov	eax, 1
	shl	eax, cl
	and	eax, dword ptr [rbp-0x44]
	mov	rcx, qword ptr [rbp+0x58]
	test	eax, eax
	jz	$_108
	test	dword ptr [rcx], eax
	jz	$_107
	mov	byte ptr [rbp-0x6E], 1
$_107:	jmp	$_110

$_108:	test	byte ptr [rcx], 0x01
	jz	$_110
	test	edx, 0x80
	jnz	$_109
	cmp	dword ptr [rbp-0x54], 5
	jnz	$_110
$_109:	mov	byte ptr [rbp-0x6E], 1
$_110:	test	edx, 0xF
	jz	$_111
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_111
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_111
	mov	eax, dword ptr [rbp-0xC]
	mov	dword ptr [rbp-0x4], eax
$_111:	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_115
	cmp	qword ptr [rdi+0x20], 0
	jz	$_115
	mov	rax, qword ptr [rdi+0x20]
	mov	ecx, dword ptr [rax+0x4]
	mov	eax, ecx
	add	eax, eax
	lea	rax, [r12+rax*8]
	mov	dword ptr [rbp-0x54], ecx
	movzx	ecx, byte ptr [rax+0xC]
	mov	edx, dword ptr [rax]
	test	edx, 0xF
	jz	$_115
	mov	eax, 1
	shl	eax, cl
	and	eax, dword ptr [rbp-0x44]
	mov	rcx, qword ptr [rbp+0x58]
	test	eax, eax
	jz	$_113
	test	dword ptr [rcx], eax
	jz	$_112
	mov	byte ptr [rbp-0x6E], 1
$_112:	jmp	$_115

$_113:	test	byte ptr [rcx], 0x01
	jz	$_115
	test	edx, 0x80
	jnz	$_114
	cmp	dword ptr [rbp-0x54], 5
	jnz	$_115
$_114:	mov	byte ptr [rbp-0x6E], 1
$_115:	cmp	byte ptr [rbp-0x6E], 0
	jz	$_116
	mov	ecx, 2133
	call	asmerr@PLT
	inc	eax
	mov	rcx, qword ptr [rbp+0x58]
	mov	dword ptr [rcx], eax
$_116:	mov	eax, dword ptr [rbp-0x4]
	mov	byte ptr [rbp-0x6F], 1
	test	byte ptr [rsi+0x4B], 0x04
	jnz	$_117
	mov	r8, qword ptr [rsi+0x28]
	movzx	edx, byte ptr [rbp-0x5A]
	movzx	ecx, byte ptr [rsi+0x1E]
	call	SizeFromMemtype@PLT
	mov	byte ptr [rbp-0x6F], 0
$_117:	mov	dword ptr [rbp-0x14], eax
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_118
	cmp	byte ptr [rbp-0x5C], 192
	jz	$_119
	test	byte ptr [rbp-0x5C], 0x20
	jz	$_119
$_118:	inc	byte ptr [rbp-0x59]
$_119:	mov	rcx, rbx
	xor	ebx, ebx
	test	byte ptr [rsi+0x11], 0x10
	jz	$_120
	movzx	ebx, byte ptr [rsi+0x58]
	mov	dword ptr [rbp-0x18], ebx
	jmp	$_131

$_120:	test	byte ptr [rsi+0x4B], 0x04
	je	$_131
	cmp	byte ptr [rbp-0x5C], 192
	jnz	$_121
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rbp-0x5C], al
	and	al, 0xE0
	cmp	al, 32
	jnz	$_121
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_121
	inc	byte ptr [rbp-0x59]
$_121:	mov	rdx, qword ptr [rbp+0x60]
	test	byte ptr [rdx+0xF], 0x10
	jz	$_126
	mov	eax, dword ptr [rbp+0x30]
	cmp	byte ptr [rbp-0x59], 0
	jz	$_124
	cmp	al, byte ptr [rdx+0xD]
	jnc	$_123
	lea	ebx, [rax+0x28]
	cmp	al, 7
	jbe	$_122
	add	ebx, 156
$_122:	cmp	al, byte ptr [rdx+0xC]
	jnc	$_123
	movzx	ecx, byte ptr [rbp-0x5A]
	shl	ecx, 3
	add	ecx, eax
	add	rcx, qword ptr [rdx]
	movzx	eax, byte ptr [rcx+0x8]
	mov	dword ptr [rbp-0x20], eax
$_123:	jmp	$_125

$_124:	cmp	al, byte ptr [rdx+0xC]
	jnc	$_125
	movzx	ecx, byte ptr [rbp-0x5A]
	shl	ecx, 3
	add	ecx, eax
	add	rcx, qword ptr [rdx]
	movzx	ebx, byte ptr [rcx+0x8]
$_125:	jmp	$_129

$_126:	cmp	byte ptr [rbp-0x59], 0
	jz	$_128
	cmp	dword ptr [simd_scratch+rip], 0
	jz	$_127
	movzx	eax, byte ptr [rcx+0x59]
	dec	dword ptr [simd_scratch+rip]
	mov	ecx, dword ptr [simd_scratch+rip]
	add	ecx, eax
	cmp	cl, byte ptr [rdx+0xD]
	jnc	$_127
	lea	ebx, [rcx+0x28]
$_127:	jmp	$_129

$_128:	cmp	dword ptr [wreg_scratch+rip], 0
	jz	$_129
	movzx	eax, byte ptr [rcx+0x58]
	dec	dword ptr [wreg_scratch+rip]
	mov	ecx, dword ptr [wreg_scratch+rip]
	add	ecx, eax
	cmp	cl, byte ptr [rdx+0xC]
	jnc	$_129
	mov	eax, ecx
	movzx	ecx, byte ptr [rbp-0x5A]
	shl	ecx, 3
	add	ecx, eax
	add	rcx, qword ptr [rdx]
	movzx	ebx, byte ptr [rcx+0x8]
$_129:	test	ebx, ebx
	jz	$_131
	mov	ecx, ebx
	call	SizeFromRegister@PLT
	cmp	eax, 16
	jnc	$_130
	mov	edx, dword ptr [rbp-0x38]
	cmp	eax, dword ptr [rbp-0x14]
	jle	$_130
	shr	edx, 1
	cmp	edx, dword ptr [rbp-0x14]
	jl	$_130
	mov	ecx, ebx
	call	get_register
	mov	ebx, eax
$_130:	mov	dword ptr [rbp-0x18], ebx
$_131:	test	ebx, ebx
	jz	$_137
	mov	eax, ebx
	add	eax, eax
	lea	rax, [r12+rax*8]
	movzx	ecx, byte ptr [rax+0xC]
	cmp	dword ptr [rbp-0x20], 0
	jnz	$_132
	cmp	dword ptr [rbp-0x8], 0
	jz	$_132
	cmp	ecx, dword ptr [rbp-0x10]
	jz	$_136
$_132:	test	byte ptr [rax], 0x70
	jz	$_133
	add	ecx, 16
$_133:	xor	edx, edx
	cmp	ecx, 32
	jnc	$_134
	inc	edx
	shl	edx, cl
$_134:	mov	ecx, dword ptr [rbp-0x20]
	test	ecx, ecx
	jz	$_135
	mov	eax, ecx
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	mov	eax, 1
	shl	eax, cl
	or	edx, eax
$_135:	mov	rcx, qword ptr [rbp+0x58]
	or	dword ptr [rcx], edx
$_136:	jmp	$_140

$_137:	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_138
	mov	rdx, qword ptr [rbp+0x60]
	movzx	eax, byte ptr [rsi+0x59]
	sub	al, byte ptr [rdx+0xC]
	mul	dword ptr [rbp-0x38]
	mov	byte ptr [rsi+0x5B], al
$_138:	mov	byte ptr [rbp-0x5D], 1
	movzx	eax, byte ptr [rbp-0x5A]
	lea	rdx, [stackreg+rip]
	mov	eax, dword ptr [rdx+rax*4]
	mov	dword ptr [rbp-0x34], eax
	mov	ebx, dword ptr [r14+0x5C]
	mov	eax, ebx
	mov	edx, dword ptr [rbp-0x38]
	cmp	edx, dword ptr [rbp-0x14]
	jle	$_139
	shr	edx, 1
	cmp	edx, dword ptr [rbp-0x14]
	jl	$_139
	mov	ecx, ebx
	call	get_register
$_139:	mov	dword ptr [rbp-0x18], eax
$_140:	mov	eax, dword ptr [rbp-0x18]
	mov	dword ptr [rbp-0x3C], eax
	mov	ecx, dword ptr [rbp-0x18]
	call	SizeFromRegister@PLT
	mov	dword ptr [rbp-0x1C], eax
	cmp	byte ptr [rbp-0x5A], 0
	jz	$_141
	mov	edx, 4
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	dword ptr [rbp-0x3C], eax
$_141:	mov	eax, dword ptr [rbp-0x14]
	mov	ecx, dword ptr [rbp-0x38]
	mov	edx, ecx
	shr	edx, 1
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_142
	cmp	eax, ecx
	jbe	$_264
$_142:	cmp	eax, ecx
	jz	$_143
	cmp	eax, edx
	jnz	$_147
$_143:	mov	esi, ebx
	cmp	eax, edx
	jnz	$_144
	mov	esi, dword ptr [rbp-0x3C]
$_144:	mov	r8, qword ptr [rbp+0x50]
	mov	edx, esi
	lea	rcx, [DS0006+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_146
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_145
	mov	ebx, esi
$_145:	jmp	$_388

$_146:	jmp	$_392

$_147:	cmp	eax, ecx
	jc	$_391
	cmp	byte ptr [rbp-0x59], 0
	je	$_177
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_148
	or	byte ptr [Options+0x7+rip], 0x10
$_148:	cmp	eax, 8
	ja	$_156
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_152
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_152
	mov	ecx, 709
	cmp	eax, 4
	jnz	$_149
	mov	ecx, 1143
$_149:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_150
	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0x34]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, ecx
	mov	r8d, dword ptr [rbp-0x4]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0007+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_150:	cmp	ebx, dword ptr [rbp-0x8]
	jz	$_151
	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, ebx
	mov	edx, ecx
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
$_151:	jmp	$_392

$_152:	mov	rcx, qword ptr [rbp+0x50]
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_155
	xor	eax, eax
	test	byte ptr [rdi+0x40], 0x20
	jz	$_153
	inc	eax
$_153:	mov	rdx, qword ptr [rdi+0x10]
	test	rdx, rdx
	jz	$_154
	mov	rcx, qword ptr [rdx+0x10]
$_154:	mov	r9d, eax
	mov	r8d, 8
	mov	rdx, rcx
	mov	rcx, rdi
	call	atofloat@PLT
	mov	edx, 4
	mov	rcx, rdi
	call	$_071
	jmp	$_392

$_155:	mov	edx, 4
	call	$_074
	jmp	$_392

$_156:	cmp	dword ptr [rdi+0x3C], 3
	jne	$_164
	cmp	byte ptr [rbp-0x5D], 0
	je	$_162
$_157:	cmp	byte ptr [rbp-0x5A], 1
	jnz	$_158
	mov	edx, 4
	lea	rcx, [rdi+0x8]
	call	$_071
	mov	edx, 4
	mov	rcx, rdi
	call	$_071
	jmp	$_392

$_158:	mov	ebx, dword ptr [rbp-0x34]
	mov	esi, dword ptr [rbp-0x2C]
	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_159
	mov	edx, ebx
	lea	rcx, [DS0009+rip]
	call	AddLineQueueX@PLT
$_159:	cmp	byte ptr [rbp-0x5A], 2
	jnz	$_160
	cmp	dword ptr [rdi+0x4], 0
	jnz	$_160
	cmp	dword ptr [rdi], 0
	jnz	$_160
	mov	r8d, esi
	mov	edx, ebx
	lea	rcx, [DS000A+rip]
	call	AddLineQueueX@PLT
	jmp	$_161

$_160:	mov	eax, dword ptr [rdi+0x4]
	mov	dword ptr [rsp+0x30], eax
	mov	dword ptr [rsp+0x28], esi
	mov	dword ptr [rsp+0x20], ebx
	mov	r9d, dword ptr [rdi]
	mov	r8d, esi
	mov	edx, ebx
	lea	rcx, [DS000B+rip]
	call	AddLineQueueX@PLT
$_161:	mov	eax, dword ptr [rdi+0xC]
	mov	dword ptr [rsp+0x30], eax
	mov	dword ptr [rsp+0x28], esi
	mov	dword ptr [rsp+0x20], ebx
	mov	r9d, dword ptr [rdi+0x8]
	mov	r8d, esi
	mov	edx, ebx
	lea	rcx, [DS000C+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_162:	cmp	dword ptr [rdi], 0
	jnz	$_163
	cmp	dword ptr [rdi+0x4], 0
	jnz	$_163
	cmp	dword ptr [rdi+0x8], 0
	jnz	$_163
	cmp	dword ptr [rdi+0xC], 0
	jnz	$_163
	mov	r8d, ebx
	mov	edx, ebx
	lea	rcx, [DS000D+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_163:	lea	rsi, [rbp-0x6D]
	mov	r8, rsi
	mov	rdx, rdi
	mov	ecx, eax
	call	CreateFloat@PLT
	mov	r8, rsi
	mov	edx, ebx
	lea	rcx, [DS000E+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_164:	cmp	dword ptr [rbp-0x8], 0
	je	$_170
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_167
	mov	ebx, 1132
	cmp	eax, 16
	jbe	$_165
	mov	ebx, 1550
$_165:	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_166
	mov	r8d, eax
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS000F+rip]
	call	AddLineQueueX@PLT
$_166:	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x2C]
	mov	r8d, dword ptr [rbp-0x34]
	mov	edx, ebx
	lea	rcx, [DS0010+rip]
	call	AddLineQueueX@PLT
	jmp	$_169

$_167:	cmp	ebx, dword ptr [rbp-0x8]
	jz	$_169
	mov	ecx, 1550
	cmp	dword ptr [rbp-0x8], 204
	jge	$_168
	cmp	eax, 16
	jnz	$_168
	mov	ecx, 1132
$_168:	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, ebx
	mov	edx, ecx
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
$_169:	jmp	$_392

$_170:	cmp	byte ptr [rbp-0x5D], 0
	jne	$_176
	mov	eax, ebx
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	test	eax, 0x70
	jnz	$_171
	jmp	$_391

$_171:	mov	edx, 1550
	mov	esi, 297
	test	eax, 0x40
	jz	$_172
	mov	esi, 289
	jmp	$_174

$_172:	test	eax, 0x20
	jz	$_173
	mov	esi, 287
	jmp	$_174

$_173:	cmp	ebx, 204
	jnc	$_174
	mov	edx, 1132
$_174:	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, esi
	mov	r8d, ebx
	lea	rcx, [DS0011+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x20], 0
	jz	$_175
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, dword ptr [rbp-0x20]
	lea	rcx, [DS0006+rip]
	call	AddLineQueueX@PLT
$_175:	jmp	$_392

$_176:	jmp	$_242

$_177:	cmp	dword ptr [rbp-0x8], 0
	je	$_209
	mov	rdx, qword ptr [rdi+0x18]
	cmp	byte ptr [rdx-0x20], 13
	jnz	$_178
	mov	ecx, dword ptr [rdx-0x3C]
	mov	eax, dword ptr [rdx+0x4]
	jmp	$_193

$_178:	cmp	byte ptr [rbp-0x5D], 0
	je	$_188
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_181
	mov	edx, 271
	cmp	ecx, 4
	jnz	$_179
	mov	edx, 274
	jmp	$_180

$_179:	cmp	ecx, 8
	jnz	$_180
	mov	edx, 278
$_180:	mov	eax, dword ptr [rbp-0x38]
	mov	dword ptr [rsp+0x38], eax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x30], eax
	mov	eax, dword ptr [rbp-0x34]
	mov	dword ptr [rsp+0x28], eax
	mov	dword ptr [rsp+0x20], edx
	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0012+rip]
	call	AddLineQueueX@PLT
	jmp	$_187

$_181:	cmp	byte ptr [rbp-0x2D], 1
	jc	$_182
	mov	eax, dword ptr [rbp-0x38]
	cmp	dword ptr [rbp-0xC], eax
	jge	$_183
$_182:	mov	r9d, ebx
	mov	r8d, ebx
	mov	edx, ebx
	lea	rcx, [DS0013+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	jmp	$_184

$_183:	lea	rcx, [DS0014+rip]
	call	AddLineQueue@PLT
$_184:	mov	edx, dword ptr [rbp-0x8]
	mov	eax, dword ptr [rbp-0xC]
	cmp	dword ptr [rbp-0x38], eax
	jle	$_186
	mov	ecx, 1
	cmp	eax, 2
	jnz	$_185
	mov	ecx, 9
$_185:	mov	r8d, edx
	mov	edx, ecx
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
	mov	edx, ebx
$_186:	lea	rcx, [DS0013+0xC+rip]
	call	AddLineQueueX@PLT
$_187:	jmp	$_192

$_188:	cmp	ebx, dword ptr [rbp-0x8]
	jz	$_189
	mov	r8d, dword ptr [rbp-0x8]
	mov	edx, ebx
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_189:	mov	rdx, qword ptr [rbp+0x60]
	mov	eax, ebx
	call	$_013
	test	eax, eax
	jnz	$_190
	jmp	$_391

$_190:	cmp	dword ptr [rbp-0x38], 8
	jnz	$_191
	mov	edx, 4
	mov	ecx, eax
	call	get_register
$_191:	mov	r8d, eax
	mov	edx, eax
	lea	rcx, [DS0016+rip]
	call	AddLineQueueX@PLT
$_192:	jmp	$_392

$_193:	mov	dword ptr [rbp-0x54], ecx
	mov	dword ptr [rbp-0x50], eax
	mov	esi, 2
	cmp	byte ptr [rdx+0x20], 13
	jnz	$_194
	mov	ecx, dword ptr [rdx+0x44]
	mov	eax, dword ptr [rdx+0x84]
	mov	dword ptr [rbp-0x4C], ecx
	mov	dword ptr [rbp-0x48], eax
	mov	esi, 4
$_194:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_200
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_197
	mov	ebx, dword ptr [rbp-0x2C]
$_195:	test	esi, esi
	jz	$_196
	mov	r9d, dword ptr [rbp+rsi*4-0x58]
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	dec	esi
	add	ebx, dword ptr [rbp-0x38]
	jmp	$_195

$_196:	jmp	$_199

$_197:	xor	ebx, ebx
$_198:	cmp	ebx, esi
	jnc	$_199
	mov	edx, dword ptr [rbp+rbx*4-0x54]
	lea	rcx, [DS0013+0xC+rip]
	call	AddLineQueueX@PLT
	inc	ebx
	jmp	$_198

$_199:	jmp	$_208

$_200:	mov	rdx, qword ptr [rbp+0x60]
	mov	eax, ebx
	call	$_013
	test	eax, eax
	jnz	$_201
	jmp	$_391

$_201:	mov	edi, eax
	cmp	esi, 4
	jnz	$_206
	mov	rdx, qword ptr [rbp+0x60]
	mov	eax, edi
	call	$_013
	test	eax, eax
	jnz	$_202
	jmp	$_391

$_202:	mov	esi, eax
	mov	rdx, qword ptr [rbp+0x60]
	mov	eax, esi
	call	$_013
	test	eax, eax
	jnz	$_203
	jmp	$_391

$_203:	mov	ecx, eax
	cmp	eax, dword ptr [rbp-0x54]
	jz	$_204
	mov	r8d, dword ptr [rbp-0x54]
	mov	edx, ecx
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_204:	cmp	esi, dword ptr [rbp-0x50]
	jz	$_205
	mov	r8d, dword ptr [rbp-0x50]
	mov	edx, esi
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_205:	mov	eax, dword ptr [rbp-0x4C]
	mov	dword ptr [rbp-0x54], eax
	mov	eax, dword ptr [rbp-0x48]
	mov	dword ptr [rbp-0x50], eax
$_206:	cmp	edi, dword ptr [rbp-0x54]
	jz	$_207
	mov	r8d, dword ptr [rbp-0x54]
	mov	edx, edi
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_207:	cmp	ebx, dword ptr [rbp-0x50]
	jz	$_208
	mov	r8d, dword ptr [rbp-0x50]
	mov	edx, ebx
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_208:	jmp	$_392

$_209:	cmp	byte ptr [rbp-0x5D], 0
	je	$_220
	cmp	dword ptr [rdi+0x3C], 0
	jne	$_220
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_210
	jmp	$_157

$_210:	cmp	byte ptr [rbp-0x5A], 0
	jnz	$_215
	jmp	$_213

$_211:	mov	edx, 2
	lea	rcx, [rdi+0x4]
	call	$_071
$_212:	mov	edx, 2
	mov	rcx, rdi
	call	$_071
	jmp	$_392

	jmp	$_214

$_213:	cmp	eax, 8
	jz	$_211
	cmp	eax, 4
	jz	$_212
$_214:	jmp	$_391

$_215:	cmp	byte ptr [rbp-0x5A], 1
	jnz	$_219
	jmp	$_218

$_216:	mov	edx, 4
	lea	rcx, [rdi+0x8]
	call	$_071
$_217:	mov	edx, 4
	mov	rcx, rdi
	call	$_071
	jmp	$_392

	jmp	$_219

$_218:	cmp	eax, 16
	jz	$_216
	cmp	eax, 8
	jz	$_217
$_219:	cmp	eax, 16
	je	$_157
	jmp	$_391

$_220:	cmp	byte ptr [rbp-0x5D], 0
	jne	$_242
	test	byte ptr [rsi+0x13], 0x40
	jnz	$_221
	jmp	$_245

$_221:	mov	dword ptr [rbp-0x54], ebx
	mov	ebx, 271
	cmp	ecx, 4
	jnz	$_222
	mov	ebx, 274
	jmp	$_223

$_222:	cmp	ecx, 8
	jnz	$_223
	mov	ebx, 278
$_223:	mov	edx, 1
$_224:	cmp	ecx, eax
	jnc	$_225
	inc	edx
	add	ecx, dword ptr [rbp-0x38]
	jmp	$_224

$_225:	mov	dword ptr [rbp-0x58], edx
	xor	esi, esi
$_226:	cmp	esi, dword ptr [rbp-0x58]
	jge	$_241
	mov	eax, dword ptr [rbp-0x38]
	mul	esi
	cmp	dword ptr [rdi+0x3C], 0
	jne	$_237
	mov	ecx, eax
	cmp	dword ptr [rbp-0x38], 2
	jnz	$_227
	movzx	eax, word ptr [rdi+rax]
	jmp	$_229

$_227:	cmp	dword ptr [rbp-0x38], 8
	jnz	$_228
	mov	edx, dword ptr [rdi+rax+0x4]
$_228:	mov	eax, dword ptr [rdi+rax]
$_229:	test	eax, eax
	jnz	$_233
	test	edx, edx
	jnz	$_233
	mov	eax, dword ptr [rdi]
	or	eax, dword ptr [rdi+0x4]
	or	eax, dword ptr [rdi+0x8]
	or	eax, dword ptr [rdi+0xC]
	test	eax, eax
	jz	$_230
	test	byte ptr [rdi+0x40], 0x20
	jz	$_230
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_230
	mov	edx, dword ptr [rbp-0x54]
	lea	rcx, [DS0018+rip]
	call	AddLineQueueX@PLT
	jmp	$_232

$_230:	mov	ecx, dword ptr [rbp-0x54]
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_231
	mov	edx, 4
	call	get_register
	mov	ecx, eax
$_231:	mov	r8d, ecx
	mov	edx, ecx
	lea	rcx, [DS0016+rip]
	call	AddLineQueueX@PLT
$_232:	jmp	$_236

$_233:	cmp	dword ptr [rbp-0x38], 8
	jge	$_234
	mov	r8d, eax
	mov	edx, dword ptr [rbp-0x54]
	lea	rcx, [DS0019+rip]
	call	AddLineQueueX@PLT
	jmp	$_236

$_234:	test	edx, edx
	jnz	$_235
	mov	dword ptr [rbp-0x50], eax
	mov	edx, 4
	mov	ecx, dword ptr [rbp-0x54]
	call	get_register
	mov	edx, eax
	mov	r8d, dword ptr [rbp-0x50]
	lea	rcx, [DS0019+rip]
	call	AddLineQueueX@PLT
	jmp	$_236

$_235:	mov	r8, qword ptr [rdi+rcx]
	mov	edx, dword ptr [rbp-0x54]
	lea	rcx, [DS001A+rip]
	call	AddLineQueueX@PLT
$_236:	jmp	$_238

$_237:	mov	dword ptr [rsp+0x20], eax
	mov	r9, qword ptr [rbp+0x50]
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x54]
	lea	rcx, [DS001B+rip]
	call	AddLineQueueX@PLT
$_238:	test	esi, esi
	jnz	$_239
	cmp	dword ptr [rbp-0x58], 2
	jnz	$_239
	mov	rdx, qword ptr [rbp+0x38]
	movzx	eax, byte ptr [rdx+0x5B]
	jmp	$_240

$_239:	mov	rdx, qword ptr [rbp+0x60]
	mov	eax, dword ptr [rbp-0x54]
	call	$_013
$_240:	mov	dword ptr [rbp-0x54], eax
	inc	esi
	jmp	$_226

$_241:	jmp	$_392

$_242:	mov	esi, 1
$_243:	cmp	ecx, eax
	jnc	$_244
	add	esi, esi
	add	ecx, ecx
	jmp	$_243

$_244:	cmp	ecx, dword ptr [rbp-0x24]
	jg	$_245
	cmp	ecx, dword ptr [rbp-0x40]
	jle	$_247
$_245:	mov	r8, qword ptr [rbp+0x50]
	mov	edx, ebx
	lea	rcx, [DS0006+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_246
	jmp	$_388

$_246:	jmp	$_392

$_247:	cmp	dword ptr [rdi+0x3C], 0
	jne	$_256
$_248:	test	esi, esi
	jz	$_255
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_251
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	mov	r8, qword ptr [rdi+rsi*8-0x8]
	mov	edx, ebx
	lea	rcx, [DS001A+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_249
	lea	ecx, [rsi*8-0x8]
	add	ecx, dword ptr [rbp-0x2C]
	mov	r9d, ebx
	mov	r8d, ecx
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	jmp	$_250

$_249:	mov	edx, ebx
	lea	rcx, [DS0013+0xC+rip]
	call	AddLineQueueX@PLT
$_250:	jmp	$_254

$_251:	cmp	dword ptr [rbp-0x38], 4
	jnz	$_252
	mov	eax, dword ptr [rdi+rsi*4-0x4]
	jmp	$_253

$_252:	movzx	eax, word ptr [rdi+rsi*2-0x2]
$_253:	mov	edx, eax
	lea	rcx, [DS0004+0x9+rip]
	call	AddLineQueueX@PLT
$_254:	dec	esi
	jmp	$_248

$_255:	jmp	$_392

$_256:	mov	ebx, 274
	jmp	$_261

$_257:	mov	ebx, 278
	jmp	$_262

$_258:	mov	ebx, 297
	jmp	$_262

$_259:	mov	ebx, 287
	jmp	$_262

$_260:	mov	ebx, 289
	jmp	$_262

$_261:	cmp	ecx, 8
	jz	$_257
	cmp	ecx, 16
	jz	$_258
	cmp	ecx, 32
	jz	$_259
	cmp	ecx, 64
	jz	$_260
$_262:	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_263
	mov	r8d, ecx
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS000F+rip]
	call	AddLineQueueX@PLT
$_263:	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, ebx
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS001C+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	jmp	$_392

$_264:	cmp	byte ptr [rbp-0x59], 0
	je	$_315
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_265
	or	byte ptr [Options+0x7+rip], 0x10
$_265:	mov	dl, byte ptr [rbp-0x5C]
	mov	ecx, dword ptr [rbp-0x14]
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_267
	cmp	dl, 35
	jz	$_267
	cmp	dl, 39
	jz	$_267
	mov	dl, 35
	cmp	dword ptr [rbp-0xC], 16
	jz	$_266
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_267
$_266:	mov	dl, 39
$_267:	cmp	ecx, 8
	ja	$_268
	cmp	byte ptr [rbp-0x5A], 2
	jnc	$_269
	cmp	ecx, 4
	jbe	$_269
$_268:	jmp	$_391

$_269:	cmp	ecx, dword ptr [rbp-0x38]
	jge	$_270
	mov	ecx, dword ptr [rbp-0x38]
$_270:	cmp	dword ptr [rdi+0x3C], 2
	jne	$_289
	test	byte ptr [rdi+0x40], 0x01
	jne	$_289
	cmp	byte ptr [rbp-0x5D], 0
	jnz	$_272
	cmp	ebx, dword ptr [rbp-0x8]
	jnz	$_272
	cmp	dword ptr [rbp-0x20], 0
	jz	$_271
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x20]
	lea	rcx, [DS001D+rip]
	call	AddLineQueueX@PLT
$_271:	jmp	$_392

$_272:	mov	byte ptr [rbp-0x5C], dl
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_273
	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_273
	mov	r8d, ecx
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS000F+rip]
	call	AddLineQueueX@PLT
$_273:	mov	dl, byte ptr [rbp-0x5C]
	mov	ecx, 1132
	cmp	dl, 35
	jz	$_274
	cmp	dl, 33
	jnz	$_275
$_274:	mov	ecx, 1143
	jmp	$_276

$_275:	cmp	dl, 39
	jnz	$_276
	mov	ecx, 709
$_276:	cmp	dword ptr [rbp-0x8], 204
	jl	$_279
	mov	ecx, 1550
	cmp	dl, 35
	jz	$_277
	cmp	dl, 33
	jnz	$_278
$_277:	mov	ecx, 1562
	jmp	$_279

$_278:	cmp	dl, 39
	jnz	$_279
	mov	ecx, 1561
$_279:	cmp	ecx, 1562
	jz	$_280
	cmp	ecx, 1561
	jnz	$_283
$_280:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_281
	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x2C]
	mov	r8d, dword ptr [rbp-0x34]
	mov	edx, ecx
	lea	rcx, [DS0010+rip]
	call	AddLineQueueX@PLT
	jmp	$_282

$_281:	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, ebx
	mov	r8d, ebx
	mov	edx, ecx
	lea	rcx, [DS001E+rip]
	call	AddLineQueueX@PLT
$_282:	jmp	$_392

$_283:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_285
	cmp	ecx, 1143
	jnz	$_284
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_284
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_284
	mov	ecx, 1118
	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, dword ptr [rbp-0x8]
	mov	edx, ecx
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
	mov	ecx, 709
$_284:	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x2C]
	mov	r8d, dword ptr [rbp-0x34]
	mov	edx, ecx
	lea	rcx, [DS0010+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_285:	cmp	dword ptr [rbp-0x38], 8
	jnz	$_287
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_287
	cmp	ecx, 1143
	jnz	$_286
	mov	ecx, 1118
	jmp	$_287

$_286:	cmp	ecx, 709
	jnz	$_287
	mov	ecx, 1132
$_287:	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, ebx
	mov	edx, ecx
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x20], 0
	jz	$_288
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x20]
	lea	rcx, [DS001D+rip]
	call	AddLineQueueX@PLT
$_288:	jmp	$_392

$_289:	cmp	byte ptr [rbp-0x5D], 0
	je	$_294
	cmp	byte ptr [rbp-0x5B], 0
	je	$_294
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_294
	xor	eax, eax
	mov	rdx, qword ptr [rbp+0x50]
	test	byte ptr [rdi+0x40], 0x20
	jz	$_290
	inc	eax
$_290:	mov	rcx, qword ptr [rdi+0x10]
	test	rcx, rcx
	jz	$_291
	mov	rdx, qword ptr [rcx+0x10]
$_291:	cmp	dword ptr [rbp-0x38], 8
	jnz	$_292
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_292
	cmp	dword ptr [rbp-0x14], 4
	jnz	$_292
	mov	dword ptr [rbp-0x14], 8
$_292:	mov	r9d, eax
	mov	r8d, dword ptr [rbp-0x14]
	mov	rcx, rdi
	call	atofloat@PLT
	mov	r9d, dword ptr [rdi]
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS001F+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x14], 8
	jnz	$_293
	mov	r9d, dword ptr [rdi+0x4]
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS000B+0x1E+rip]
	call	AddLineQueueX@PLT
$_293:	jmp	$_392

$_294:	cmp	dl, 33
	jnz	$_298
	mov	rdx, qword ptr [rbp+0x50]
	lea	rcx, [DS0020+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_296
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_295
	mov	ebx, 9
$_295:	jmp	$_388

	jmp	$_297

$_296:	mov	rdx, qword ptr [rbp+0x58]
	or	byte ptr [rdx], 0x01
	mov	edx, ebx
	lea	rcx, [DS0021+rip]
	call	AddLineQueueX@PLT
$_297:	jmp	$_392

$_298:	cmp	dl, 35
	jne	$_310
	cmp	byte ptr [rbp-0x5D], 0
	je	$_307
	cmp	dword ptr [rbp-0x38], 4
	jg	$_303
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_301
	xor	eax, eax
	mov	rdx, qword ptr [rbp+0x50]
	test	byte ptr [rdi+0x40], 0x20
	jz	$_299
	inc	eax
$_299:	mov	rcx, qword ptr [rdi+0x10]
	test	rcx, rcx
	jz	$_300
	mov	rdx, qword ptr [rcx+0x10]
$_300:	mov	r9d, eax
	mov	r8d, 4
	mov	rcx, rdi
	call	atofloat@PLT
	mov	edx, dword ptr [rdi]
	lea	rcx, [DS0022+rip]
	call	AddLineQueueX@PLT
	jmp	$_302

$_301:	mov	rdx, qword ptr [rbp+0x50]
	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_302:	jmp	$_392

$_303:	mov	dword ptr [rbp-0x54], 17
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_305
	mov	dword ptr [rbp-0x54], 163
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_305
	mov	rdx, qword ptr [rbp+0x50]
	lea	rcx, [DS0024+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax+0x2], 0x01
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_304
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0025+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_304:	mov	edx, ebx
	lea	rcx, [DS0026+rip]
	call	AddLineQueueX@PLT
	jmp	$_388

$_305:	mov	r8, qword ptr [rbp+0x50]
	mov	edx, dword ptr [rbp-0x54]
	lea	rcx, [DS0027+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_306
	mov	ebx, dword ptr [rbp-0x54]
$_306:	jmp	$_388

$_307:	mov	ecx, 1143
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_308
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_308
	mov	ecx, 1118
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_308
	mov	ecx, 709
$_308:	mov	r9, qword ptr [rbp+0x50]
	mov	r8d, ebx
	mov	edx, ecx
	lea	rcx, [DS0028+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x20], 0
	jz	$_309
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x20]
	lea	rcx, [DS001D+rip]
	call	AddLineQueueX@PLT
$_309:	jmp	$_392

$_310:	mov	rcx, qword ptr [rbp+0x50]
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_313
	cmp	dword ptr [rbp-0x38], 8
	jnz	$_311
	mov	ebx, 163
	mov	r8, rcx
	mov	edx, ebx
	lea	rcx, [DS0027+rip]
	call	AddLineQueueX@PLT
	jmp	$_388

$_311:	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_312
	mov	edx, 4
	mov	rcx, rdi
	call	$_071
	jmp	$_392

$_312:	mov	edx, 4
	call	$_074
	jmp	$_392

$_313:	mov	r8, rcx
	mov	edx, ebx
	lea	rcx, [DS0029+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x20], 0
	jz	$_314
	mov	r8d, ebx
	mov	edx, dword ptr [rbp-0x20]
	lea	rcx, [DS001D+rip]
	call	AddLineQueueX@PLT
$_314:	jmp	$_392

$_315:	cmp	dword ptr [rdi+0x3C], 0
	jz	$_316
	cmp	dword ptr [rdi+0x3C], 1
	jne	$_335
	test	byte ptr [rdi+0x40], 0x01
	jne	$_335
	cmp	byte ptr [rdi+0x44], 192
	jne	$_335
	cmp	dword ptr [rdi+0x38], 313
	je	$_335
$_316:	cmp	ecx, 8
	jnz	$_320
	cmp	eax, 8
	jnz	$_320
	mov	rax, qword ptr [rdi]
	cmp	rax, 2147483647
	jg	$_317
	cmp	rax, -2147483648
	jge	$_320
$_317:	mov	rdx, qword ptr [rbp+0x50]
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_318
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_318
	mov	qword ptr [rsp+0x30], rdx
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rbp-0x34]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, rdx
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS002A+rip]
	call	AddLineQueueX@PLT
	jmp	$_319

$_318:	mov	r8, rdx
	mov	edx, ebx
	lea	rcx, [DS0027+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_319
	jmp	$_388

$_319:	jmp	$_392

$_320:	mov	rax, qword ptr [rdi+0x50]
	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_321
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_321
	cmp	byte ptr [rax+0x1D], 0
	jz	$_321
	jmp	$_391

$_321:	mov	rdx, qword ptr [rbp+0x50]
	cmp	byte ptr [rbp-0x5D], 0
	jnz	$_324
	cmp	word ptr [rdx], 48
	jz	$_322
	cmp	dword ptr [rdi], 0
	jnz	$_323
	cmp	dword ptr [rdi+0x4], 0
	jnz	$_323
$_322:	mov	r8d, dword ptr [rbp-0x3C]
	mov	edx, dword ptr [rbp-0x3C]
	lea	rcx, [DS0016+rip]
	call	AddLineQueueX@PLT
	jmp	$_392

$_323:	jmp	$_327

$_324:	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_327
	cmp	byte ptr [rbp-0x2D], 1
	jnc	$_325
	mov	r9d, ebx
	mov	r8, rdx
	mov	edx, ebx
	lea	rcx, [DS002B+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	jmp	$_326

$_325:	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_326:	jmp	$_392

$_327:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_332
	mov	eax, dword ptr [rbp-0x14]
	mov	ecx, 278
	cmp	eax, 1
	jnz	$_328
	mov	ecx, 269
	jmp	$_331

$_328:	cmp	eax, 2
	jnz	$_329
	mov	ecx, 271
	jmp	$_331

$_329:	cmp	eax, 4
	jnz	$_331
	cmp	dword ptr [rdi], 0
	jnz	$_330
	cmp	byte ptr [rbp-0x6F], 0
	jnz	$_331
$_330:	mov	ecx, 274
$_331:	mov	qword ptr [rsp+0x20], rdx
	mov	r9d, dword ptr [rbp-0x2C]
	mov	r8d, dword ptr [rbp-0x34]
	mov	edx, ecx
	lea	rcx, [DS002C+rip]
	call	AddLineQueueX@PLT
	jmp	$_334

$_332:	cmp	dword ptr [rdi+0x4], 0
	jnz	$_333
	mov	ebx, dword ptr [rbp-0x3C]
$_333:	mov	r8, rdx
	mov	edx, ebx
	lea	rcx, [DS0027+rip]
	call	AddLineQueueX@PLT
$_334:	jmp	$_392

$_335:	cmp	dword ptr [rbp-0x8], 0
	je	$_361
	mov	edx, dword ptr [rbp-0xC]
	cmp	edx, dword ptr [rbp-0x14]
	jge	$_336
	cmp	byte ptr [rbp-0x5C], 195
	jnz	$_336
	jmp	$_391

$_336:	cmp	edx, dword ptr [rbp-0x1C]
	jle	$_342
	mov	edx, dword ptr [rbp-0x1C]
	mov	ecx, dword ptr [rbp-0x8]
	call	get_register
	cmp	eax, dword ptr [rbp-0x18]
	jnz	$_337
	cmp	byte ptr [rbp-0x5D], 0
	jnz	$_337
	jmp	$_392

$_337:	cmp	eax, 8
	jbe	$_340
	cmp	dword ptr [rbp-0x1C], 1
	jnz	$_340
	cmp	byte ptr [rbp-0x2D], 128
	jnc	$_340
	mov	esi, 2
	cmp	byte ptr [rbp-0x2D], 3
	jc	$_338
	add	esi, esi
$_338:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_339
	jmp	$_391

$_339:	mov	edx, esi
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	ebx, eax
	mov	edx, esi
	mov	ecx, dword ptr [rbp-0x8]
	call	get_register
	mov	r8, rax
	mov	edx, ebx
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
	mov	dword ptr [rbp-0x14], esi
	mov	dword ptr [rbp-0x1C], esi
	mov	dword ptr [rbp-0x18], ebx
	mov	edx, 1
	mov	ecx, ebx
	call	get_register
	mov	dword ptr [rbp-0x8], eax
	mov	eax, 1
	mov	dword ptr [rbp-0xC], eax
	jmp	$_341

$_340:	mov	dword ptr [rbp-0x8], eax
	mov	eax, dword ptr [rbp-0x1C]
	mov	dword ptr [rbp-0xC], eax
$_341:	mov	dword ptr [rbp-0x4], eax
	mov	edx, eax
$_342:	cmp	byte ptr [rbp-0x5D], 0
	je	$_350
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_345
	cmp	byte ptr [rbp-0x6F], 0
	jz	$_344
	cmp	dword ptr [rbp-0x28], edx
	jle	$_344
	cmp	byte ptr [rbp-0x2D], 3
	jc	$_344
	mov	esi, 816
	movzx	eax, byte ptr [rdi+0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_343
	mov	esi, 815
$_343:	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, dword ptr [rbp-0x18]
	mov	edx, esi
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
	mov	eax, dword ptr [rbp-0x18]
	mov	dword ptr [rbp-0x8], eax
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
$_344:	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	jmp	$_349

$_345:	mov	ecx, dword ptr [rbp-0x8]
	cmp	ecx, 5
	jc	$_347
	cmp	ecx, 8
	ja	$_347
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	mov	ecx, edx
	mov	ecx, 816
	mov	eax, ebx
	cmp	byte ptr [rbp-0x2D], 3
	jnc	$_346
	lea	rcx, [DS002D+rip]
	call	AddLineQueueX@PLT
	mov	ecx, 779
	mov	eax, 1
	mov	edx, dword ptr [rbp-0x8]
$_346:	mov	r9d, ecx
	mov	r8d, eax
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
	mov	eax, ebx
	jmp	$_348

$_347:	mov	edx, dword ptr [rbp-0x38]
	call	get_register
$_348:	mov	edx, eax
	lea	rcx, [DS002B+0xC+rip]
	call	AddLineQueueX@PLT
$_349:	jmp	$_392

$_350:	mov	esi, 779
	cmp	dword ptr [rbp-0x28], edx
	jle	$_354
	mov	edx, dword ptr [rbp-0x28]
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	ebx, eax
	cmp	byte ptr [rbp-0x2D], 3
	jc	$_352
	mov	esi, 816
	movzx	eax, byte ptr [rdi+0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_351
	mov	esi, 815
$_351:	jmp	$_353

$_352:	jmp	$_358

$_353:	jmp	$_359

$_354:	cmp	dword ptr [rbp-0x1C], edx
	jle	$_359
	cmp	byte ptr [rbp-0x2D], 3
	jc	$_358
	mov	esi, 816
	movzx	eax, byte ptr [rdi+0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_355
	mov	esi, 815
$_355:	cmp	edx, 4
	jnz	$_357
	cmp	esi, 816
	jnz	$_356
	mov	esi, 779
	mov	edx, 4
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	ebx, eax
	jmp	$_357

$_356:	mov	esi, 1331
$_357:	jmp	$_359

$_358:	mov	eax, ebx
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	lea	ebx, [rcx+0x1]
	add	ecx, 5
	mov	edx, ecx
	lea	rcx, [DS002E+rip]
	call	AddLineQueueX@PLT
$_359:	cmp	ebx, dword ptr [rbp-0x8]
	jz	$_360
	mov	r9d, dword ptr [rbp-0x8]
	mov	r8d, ebx
	mov	edx, esi
	lea	rcx, [DS0008+rip]
	call	AddLineQueueX@PLT
$_360:	jmp	$_392

$_361:	mov	esi, eax
	bsf	eax, eax
	bsr	esi, esi
	cmp	eax, esi
	jne	$_377
	mov	eax, dword ptr [rbp-0x1C]
	cmp	dword ptr [rbp-0x4], eax
	jle	$_362
	mov	dword ptr [rbp-0x4], eax
$_362:	mov	eax, dword ptr [rbp-0x4]
	cmp	eax, ecx
	jnz	$_365
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_365
	cmp	byte ptr [rbp-0x5B], 0
	jnz	$_365
	cmp	byte ptr [rbp-0x2D], 1
	jnc	$_363
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_363
	mov	r9d, ebx
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, ebx
	lea	rcx, [DS002B+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	jmp	$_364

$_363:	mov	rdx, qword ptr [rbp+0x50]
	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_364:	jmp	$_392

$_365:	mov	esi, 779
	mov	edx, dword ptr [rbp-0x1C]
	cmp	byte ptr [rbp-0x5D], 0
	jnz	$_366
	cmp	dword ptr [rbp-0x28], edx
	jle	$_366
	mov	edx, dword ptr [rbp-0x28]
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	dword ptr [rbp-0x18], eax
	mov	eax, dword ptr [rbp-0x28]
	mov	dword ptr [rbp-0x1C], eax
	mov	eax, dword ptr [rbp-0x4]
$_366:	mov	ecx, 269
	cmp	eax, 2
	jnz	$_367
	mov	ecx, 271
	jmp	$_369

$_367:	cmp	eax, 4
	jnz	$_368
	mov	ecx, 274
	jmp	$_369

$_368:	cmp	eax, 8
	jnz	$_369
	mov	ecx, 278
$_369:	cmp	eax, dword ptr [rbp-0x1C]
	jge	$_374
	cmp	byte ptr [rbp-0x2D], 3
	jc	$_373
	mov	esi, 816
	movzx	eax, byte ptr [rdi+0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_370
	mov	esi, 815
$_370:	cmp	dword ptr [rbp-0x4], 4
	jnz	$_372
	cmp	esi, 816
	jnz	$_371
	mov	edx, 4
	mov	ecx, dword ptr [rbp-0x18]
	call	get_register
	mov	dword ptr [rbp-0x18], eax
	mov	esi, 779
	mov	ecx, 274
	jmp	$_372

$_371:	mov	esi, 1331
$_372:	jmp	$_374

$_373:	mov	eax, ebx
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	lea	eax, [rcx+0x1]
	mov	dword ptr [rbp-0x18], eax
	add	ecx, 5
	mov	edx, ecx
	lea	rcx, [DS002E+rip]
	call	AddLineQueueX@PLT
	mov	ecx, 269
$_374:	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, ecx
	mov	r8d, dword ptr [rbp-0x18]
	mov	edx, esi
	lea	rcx, [DS0011+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x5D], 0
	jz	$_376
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_375
	mov	ebx, dword ptr [rbp-0x18]
$_375:	jmp	$_388

$_376:	jmp	$_392

$_377:	mov	ecx, dword ptr [rbp-0x4]
	mov	edi, 274
	mov	esi, 1
	jmp	$_383

$_378:	inc	esi
$_379:	inc	esi
$_380:	jmp	$_384

$_381:	mov	edi, 271
	jmp	$_384

$_382:	jmp	$_391

	jmp	$_384

$_383:	cmp	ecx, 7
	jz	$_378
	cmp	ecx, 6
	jz	$_379
	cmp	ecx, 5
	jz	$_380
	cmp	ecx, 3
	jz	$_381
	jmp	$_382

$_384:	sub	ecx, esi
	mov	edx, ecx
	mov	ecx, ebx
	call	get_register
	mov	ecx, eax
	mov	edx, 779
	cmp	edi, 271
	jnz	$_385
	mov	edx, 816
	mov	ecx, ebx
$_385:	mov	dword ptr [rsp+0x28], esi
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, edi
	mov	r8d, ecx
	lea	rcx, [DS002F+rip]
	call	AddLineQueueX@PLT
	cmp	esi, 1
	jbe	$_386
	sub	esi, 2
	mov	edx, 2
	mov	ecx, ebx
	call	get_register
	mov	ecx, eax
	mov	dword ptr [rsp+0x20], esi
	mov	r9, qword ptr [rbp+0x50]
	mov	r8d, ecx
	mov	edx, ebx
	lea	rcx, [DS0030+rip]
	call	AddLineQueueX@PLT
$_386:	test	esi, esi
	jz	$_387
	mov	edx, 1
	mov	ecx, ebx
	call	get_register
	mov	ecx, eax
	mov	r9, qword ptr [rbp+0x50]
	mov	r8d, ecx
	mov	edx, ebx
	lea	rcx, [DS0031+rip]
	call	AddLineQueueX@PLT
$_387:	cmp	byte ptr [rbp-0x5D], 0
	jz	$_390
$_388:	mov	rax, qword ptr [rbp+0x58]
	or	byte ptr [rax], 0x01
	cmp	byte ptr [rbp-0x5B], 0
	jz	$_389
	mov	r9d, ebx
	mov	r8d, dword ptr [rbp-0x2C]
	mov	edx, dword ptr [rbp-0x34]
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	jmp	$_390

$_389:	mov	edx, ebx
	lea	rcx, [DS002B+0xC+rip]
	call	AddLineQueueX@PLT
$_390:	jmp	$_392

$_391:	mov	edx, dword ptr [rbp+0x30]
	inc	edx
	mov	ecx, 2114
	call	asmerr@PLT
$_392:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_393:
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rdi, rcx
	imul	ebx, edx, 32
	add	rbx, qword ptr [rbp+0x38]
	xor	eax, eax
	mov	byte ptr [rdi], al
$_394:	cmp	byte ptr [rbx], 44
	jz	$_397
	cmp	byte ptr [rbx], 0
	jz	$_397
	cmp	byte ptr [rbx+0x20], 5
	jnz	$_395
	cmp	dword ptr [rbx+0x24], 335
	jnz	$_395
	add	rbx, 32
	jmp	$_396

$_395:	mov	rsi, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rbx+0x38]
	sub	rcx, rsi
	rep movsb
$_396:	add	rbx, 32
	jmp	$_394

$_397:
	stosb
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_398:
	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, 2360
	mov	qword ptr [rbp-0x28], 0
	imul	ebx, ecx, 32
	add	rbx, rdx
	xor	ecx, ecx
$_399:	cmp	ecx, dword ptr [rbp+0x48]
	jg	$_402
	cmp	byte ptr [rbx], 0
	jnz	$_400
	mov	rax, -1
	jmp	$_671

$_400:	cmp	byte ptr [rbx], 44
	jnz	$_401
	inc	ecx
$_401:	add	rbx, 32
	inc	dword ptr [rbp+0x28]
	jmp	$_399

$_402:	mov	dword ptr [rbp-0x4], ecx
	mov	rdi, qword ptr [rbp+0x40]
	test	rdi, rdi
	jnz	$_403
	xor	eax, eax
	jmp	$_671

$_403:	mov	eax, dword ptr [rbp+0x48]
	inc	eax
	mov	dword ptr [rbp-0x8D4], eax
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_404
	mov	eax, 128
	jmp	$_405

$_404:	cmp	eax, 6
	jc	$_405
	mov	eax, 6
$_405:	mov	byte ptr [rbp-0x8CD], al
	mov	rsi, qword ptr [rbp+0x38]
	mov	dword ptr [rbp-0x8C], 17
	mov	dword ptr [rbp-0x1C], 0
	mov	eax, dword ptr [rdi+0x60]
	mov	dword ptr [rbp-0x8], eax
	cmp	byte ptr [rbx], 7
	jnz	$_406
	cmp	dword ptr [rbx+0x4], 339
	jnz	$_406
	mov	dword ptr [rbp-0x1C], 1
	cmp	byte ptr [rdi+0x1E], 194
	jz	$_406
	add	rbx, 32
	inc	dword ptr [rbp+0x28]
$_406:	mov	rdx, rbx
$_407:	cmp	byte ptr [rdx], 44
	jz	$_408
	cmp	byte ptr [rdx], 0
	jz	$_408
	add	rdx, 32
	jmp	$_407

$_408:	mov	rsi, qword ptr [rbx+0x18]
	mov	rcx, qword ptr [rdx+0x18]
	sub	rcx, rsi
	lea	rdi, [rbp-0x88C]
	rep movsb
	mov	byte ptr [rdi], 0
	mov	rdi, qword ptr [rbp+0x40]
	cmp	byte ptr [rdi+0x1E], 194
	jnz	$_409
	cmp	dword ptr [rbp-0x1C], 0
	jz	$_409
	add	rbx, 32
	inc	dword ptr [rbp+0x28]
$_409:	mov	eax, dword ptr [rbp+0x28]
	mov	dword ptr [rbp-0x14], eax
	mov	rsi, qword ptr [rbp+0x38]
	movzx	eax, byte ptr [rsi+0x20]
	cmp	byte ptr [rsi+0x1D], 7
	jz	$_410
	mov	rcx, rsi
	call	GetSymOfssize@PLT
$_410:	mov	byte ptr [rbp-0x8D5], al
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
	add	eax, 2
	mov	dword ptr [rbp-0x18], eax
	movzx	edx, byte ptr [rsi+0x1F]
	movzx	ecx, byte ptr [rbp-0x8D5]
	call	get_fasttype@PLT
	mov	qword ptr [rbp-0x8E0], rax
	cmp	qword ptr [rax], 0
	setne	al
	mov	byte ptr [rbp-0x8D6], al
	cmp	dword ptr [rbp-0x1C], 0
	je	$_440
	movzx	eax, byte ptr [r14+0x22]
	mov	dword ptr [rsp+0x20], eax
	lea	r9, [rbp-0x88]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x14]
	call	EvalOperand@PLT
	cmp	eax, -1
	jnz	$_411
	jmp	$_671

$_411:	imul	ebx, dword ptr [rbp-0x14], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rbp-0x18]
	cmp	dword ptr [rbp-0x8], eax
	jle	$_412
	cmp	dword ptr [rbp-0x18], 4
	jle	$_412
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	xor	eax, eax
	jmp	$_671

$_412:	cmp	byte ptr [rbp-0x8D6], 0
	jz	$_413
	mov	rax, qword ptr [rbp-0x8E0]
	mov	qword ptr [rsp+0x38], rax
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x30], rax
	lea	rax, [rbp-0x88C]
	mov	qword ptr [rsp+0x28], rax
	lea	rax, [rbp-0x88]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rbp-0x1C]
	mov	r8, qword ptr [rbp+0x40]
	mov	edx, dword ptr [rbp+0x48]
	mov	rcx, qword ptr [rbp+0x38]
	call	$_078
	xor	eax, eax
	jmp	$_671

$_413:	cmp	dword ptr [rbp-0x4C], 2
	jz	$_414
	test	byte ptr [rbp-0x48], 0x01
	je	$_419
$_414:	cmp	byte ptr [rdi+0x21], 0
	jnz	$_415
	mov	eax, dword ptr [rbp-0x18]
	cmp	dword ptr [rbp-0x8], eax
	jz	$_415
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_418
	cmp	byte ptr [rbp-0x44], 130
	jnz	$_418
$_415:	mov	eax, 28
	mov	rdx, qword ptr [rbp-0x38]
	test	rdx, rdx
	jz	$_416
	cmp	byte ptr [rdx+0x1D], 5
	jnz	$_416
	mov	eax, 27
	jmp	$_417

$_416:	cmp	qword ptr [rbp-0x58], 0
	jz	$_417
	mov	rdx, qword ptr [rbp-0x58]
	mov	eax, dword ptr [rdx+0x4]
$_417:	mov	edx, eax
	lea	rcx, [DS002B+0xC+rip]
	call	AddLineQueueX@PLT
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_418
	movzx	eax, byte ptr [r14+0x6]
	add	dword ptr [size_vararg+rip], eax
$_418:	mov	r9d, dword ptr [r14+0x5C]
	lea	r8, [rbp-0x88C]
	mov	edx, dword ptr [r14+0x5C]
	lea	rcx, [DS0032+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	jmp	$_438

$_419:	mov	cl, byte ptr [rdi+0x48]
	mov	eax, 2
	shl	eax, cl
	cmp	byte ptr [rdi+0x21], 0
	jnz	$_420
	cmp	dword ptr [rbp-0x8], eax
	jg	$_420
	test	byte ptr [rdi+0x4B], 0x04
	je	$_424
	cmp	byte ptr [rbp-0x44], 130
	jnz	$_424
$_420:	lea	r8, [rbp-0x88C]
	lea	rdx, [rbp-0x8CC]
	lea	rcx, [rbp-0x88]
	call	$_057
	lea	rcx, [DS0023+rip]
	lea	rdx, [rbp-0x8CC]
	test	eax, eax
	jz	$_423
	mov	dword ptr [rbp-0x8E4], eax
	mov	al, byte ptr [r14+0x4]
	cmp	byte ptr [rbp-0x8D5], al
	jnz	$_421
	cmp	byte ptr [rdi+0x48], 0
	jnz	$_422
	cmp	byte ptr [r14+0x6], 2
	jbe	$_422
$_421:	lea	rcx, [DS0033+rip]
	call	AddLineQueue@PLT
$_422:	lea	rcx, [DS0032+0xC+rip]
	mov	edx, dword ptr [rbp-0x8E4]
$_423:	call	AddLineQueueX@PLT
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_424
	movzx	eax, byte ptr [r14+0x6]
	add	dword ptr [size_vararg+rip], eax
$_424:	cmp	byte ptr [rbp-0x8CD], 1
	jnc	$_425
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0034+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	jmp	$_438

$_425:	mov	rcx, qword ptr [rbp-0x38]
	cmp	byte ptr [rbp-0x42], 254
	jnz	$_427
	test	rcx, rcx
	jz	$_427
	call	GetSymOfssize@PLT
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_426
	mov	byte ptr [rbp-0x42], al
	jmp	$_427

$_426:	mov	cl, al
	mov	eax, 2
	shl	eax, cl
	cmp	al, byte ptr [r14+0x6]
	jz	$_427
	mov	byte ptr [rbp-0x42], cl
$_427:	xor	edx, edx
	cmp	byte ptr [rbp-0x42], 0
	jnz	$_428
	cmp	byte ptr [r14+0x6], 4
	jz	$_429
$_428:	cmp	byte ptr [rdi+0x48], 1
	jnz	$_430
	cmp	byte ptr [r14+0x6], 2
	jnz	$_430
$_429:	mov	edx, 738
	jmp	$_437

$_430:	cmp	byte ptr [r14+0x6], 2
	jbe	$_432
	cmp	byte ptr [rdi+0x48], 0
	jnz	$_432
	cmp	byte ptr [rdi+0x21], 0
	jnz	$_431
	cmp	byte ptr [rbp-0x8D5], 0
	jnz	$_432
$_431:	mov	edx, 776
	jmp	$_437

$_432:	cmp	byte ptr [r14+0x6], 2
	jnz	$_433
	cmp	byte ptr [rbp-0x42], 1
	jnz	$_433
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_433
	mov	edx, 776
	jmp	$_437

$_433:	test	byte ptr [rsi+0x11], 0x02
	jz	$_434
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_437
$_434:	cmp	byte ptr [rdi+0x48], 2
	jnz	$_435
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0035+rip]
	call	AddLineQueueX@PLT
	mov	rax, qword ptr [rbp+0x50]
	or	byte ptr [rax], 0x01
	xor	edx, edx
	jmp	$_436

$_435:	mov	edx, 774
$_436:	test	byte ptr [rdi+0x4B], 0x04
	jz	$_437
	cmp	byte ptr [r14+0x6], 2
	jnz	$_437
	cmp	byte ptr [rbp-0x42], 0
	jbe	$_437
	add	dword ptr [size_vararg+rip], 2
$_437:	test	edx, edx
	jz	$_438
	lea	r8, [rbp-0x88C]
	lea	rcx, [DS0036+rip]
	call	AddLineQueueX@PLT
$_438:	test	byte ptr [rdi+0x4B], 0x04
	jz	$_439
	movzx	eax, byte ptr [r14+0x6]
	add	dword ptr [size_vararg+rip], eax
$_439:	xor	eax, eax
	jmp	$_671

$_440:	cmp	byte ptr [rbx], 2
	jne	$_448
	cmp	byte ptr [rbx+0x20], 13
	jne	$_448
	cmp	byte ptr [rbx+0x40], 2
	jne	$_448
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8+0x3], 0x0C
	jz	$_443
	mov	dword ptr [rbp-0x8E8], 2
	mov	al, byte ptr [r14+0x4]
	cmp	byte ptr [rbp-0x8D5], al
	jnz	$_441
	cmp	byte ptr [rdi+0x48], 0
	jnz	$_442
	cmp	byte ptr [r14+0x6], 2
	jbe	$_442
$_441:	lea	rcx, [DS0033+rip]
	call	AddLineQueue@PLT
$_442:	jmp	$_444

$_443:	mov	ecx, dword ptr [rbx+0x4]
	call	SizeFromRegister@PLT
	mov	dword ptr [rbp-0x8E8], eax
$_444:	mov	ecx, dword ptr [rbx+0x44]
	call	SizeFromRegister@PLT
	mov	dword ptr [rbp-0xC], eax
	cmp	dword ptr [rbp-0x8E8], 8
	jz	$_445
	cmp	byte ptr [rbp-0x8D6], 0
	jnz	$_445
	mov	edx, dword ptr [rbx+0x4]
	lea	rcx, [DS0032+0xC+rip]
	call	AddLineQueueX@PLT
$_445:	mov	eax, dword ptr [rbp-0xC]
	add	eax, dword ptr [rbp-0x8E8]
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_446
	cmp	al, byte ptr [r14+0x6]
	jz	$_446
	mov	eax, dword ptr [rbp-0x8E8]
	add	dword ptr [size_vararg+rip], eax
	jmp	$_447

$_446:	mov	eax, dword ptr [rbp-0x8E8]
	add	dword ptr [rbp-0xC], eax
$_447:	mov	rdx, qword ptr [rbx+0x50]
	lea	rcx, [rbp-0x88C]
	call	tstrcpy@PLT
	mov	dword ptr [rbp-0x4C], 2
	and	byte ptr [rbp-0x48], 0xFE
	mov	qword ptr [rbp-0x38], 0
	lea	rax, [rbx+0x40]
	mov	qword ptr [rbp-0x70], rax
	jmp	$_472

$_448:	cmp	byte ptr [rdi+0x1E], 194
	jnz	$_449
	mov	dword ptr [rbp-0x4C], 0
	mov	byte ptr [rbp-0x44], 194
	mov	qword ptr [rbp-0x38], 0
	mov	qword ptr [rbp-0x30], 0
	mov	qword ptr [rbp-0x70], 0
	jmp	$_450

$_449:	movzx	eax, byte ptr [r14+0x22]
	mov	dword ptr [rsp+0x20], eax
	lea	r9, [rbp-0x88]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x14]
	call	EvalOperand@PLT
	cmp	eax, -1
	je	$_671
	imul	ebx, dword ptr [rbp-0x14], 32
	add	rbx, qword ptr [rbp+0x30]
$_450:	cmp	dword ptr [rbp-0x4C], 2
	jnz	$_452
	test	byte ptr [rbp-0x48], 0x01
	jnz	$_452
	mov	rcx, qword ptr [rbp-0x70]
	mov	ecx, dword ptr [rcx+0x4]
	call	SizeFromRegister@PLT
	mov	dword ptr [rbp-0xC], eax
	mov	eax, dword ptr [r14+0x64]
	cmp	dword ptr [rbp-0x14], eax
	jge	$_451
	cmp	byte ptr [rbx], 44
	jz	$_451
	or	byte ptr [rbp-0x48], 0x01
$_451:	jmp	$_472

$_452:	cmp	dword ptr [rbp-0x4C], 0
	jz	$_453
	cmp	byte ptr [rbp-0x44], 192
	jne	$_458
$_453:	mov	eax, dword ptr [rbp-0x8]
	mov	rcx, qword ptr [rbp-0x38]
	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_454
	cmp	dword ptr [rbp-0x50], 313
	jnz	$_454
	test	rcx, rcx
	jz	$_454
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
$_454:	mov	dword ptr [rbp-0xC], eax
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_456
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_455
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
$_455:	mov	rcx, qword ptr [rbp-0x30]
	test	rcx, rcx
	jz	$_456
	cmp	byte ptr [rcx+0x1E], 196
	jnz	$_456
	mov	r8, qword ptr [rcx+0x28]
	movzx	edx, byte ptr [rbp-0x42]
	movzx	ecx, byte ptr [rcx+0x1E]
	call	SizeFromMemtype@PLT
	mov	dword ptr [rbp-0xC], eax
$_456:	mov	rcx, qword ptr [rbp-0x38]
	test	rcx, rcx
	jz	$_457
	cmp	byte ptr [rcx+0x1D], 5
	jnz	$_457
	test	byte ptr [rcx+0x4B], 0x04
	jz	$_457
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_457
	mov	edx, dword ptr [rbp+0x48]
	inc	edx
	mov	ecx, 8015
	call	asmerr@PLT
$_457:	jmp	$_472

$_458:	cmp	byte ptr [rbp-0x44], 196
	je	$_470
	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_460
	test	byte ptr [rbp-0x48], 0x01
	jnz	$_460
	cmp	qword ptr [rbp-0x38], 0
	jz	$_460
	cmp	dword ptr [rbp-0x50], -2
	jnz	$_460
	cmp	byte ptr [rbp-0x44], 129
	jz	$_459
	cmp	byte ptr [rbp-0x44], 130
	jnz	$_460
$_459:	jmp	$_419

$_460:	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_467
	cmp	byte ptr [rbp-0x44], 195
	jnz	$_467
	cmp	qword ptr [rbp-0x38], 0
	jz	$_467
	mov	rcx, qword ptr [rbp-0x38]
	cmp	byte ptr [rcx+0x1D], 2
	jnz	$_464
	movzx	edx, byte ptr [rbp-0x42]
	cmp	edx, 254
	jnz	$_461
	mov	dl, byte ptr [rcx+0x48]
$_461:	cmp	byte ptr [rcx+0x21], 0
	jz	$_462
	mov	ecx, 130
	jmp	$_463

$_462:	mov	ecx, 129
$_463:	xor	r8d, r8d
	movzx	ecx, cl
	call	SizeFromMemtype@PLT
	jmp	$_466

$_464:	mov	rdx, qword ptr [rbp-0x30]
	test	rdx, rdx
	jz	$_465
	mov	rcx, rdx
$_465:	mov	eax, dword ptr [rcx+0x60]
	test	byte ptr [rcx+0x10], 0x40
	jz	$_466
	mov	ecx, dword ptr [rcx+0x68]
	xor	edx, edx
	div	ecx
$_466:	jmp	$_469

$_467:	cmp	byte ptr [rbp-0x42], 254
	jnz	$_468
	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rbp-0x42], al
$_468:	mov	r8, qword ptr [rbp-0x28]
	movzx	edx, byte ptr [rbp-0x42]
	movzx	ecx, byte ptr [rbp-0x44]
	call	SizeFromMemtype@PLT
$_469:	mov	dword ptr [rbp-0xC], eax
	jmp	$_472

$_470:	mov	rcx, qword ptr [rbp-0x38]
	test	rcx, rcx
	jnz	$_471
	mov	rcx, qword ptr [rbp-0x30]
$_471:	mov	rcx, qword ptr [rcx+0x28]
	mov	eax, dword ptr [rcx+0x60]
	mov	dword ptr [rbp-0xC], eax
$_472:	movzx	eax, byte ptr [r14+0x6]
	mov	dword ptr [rbp-0x10], eax
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_473
	mov	eax, dword ptr [rbp-0xC]
	mov	dword ptr [rbp-0x8], eax
$_473:	cmp	dword ptr [rbp-0xC], 16
	jnz	$_474
	cmp	byte ptr [rbp-0x44], 47
	jnz	$_474
	cmp	dword ptr [rbp-0x10], 4
	jnz	$_474
	mov	eax, dword ptr [rbp-0x8]
	mov	dword ptr [rbp-0xC], eax
$_474:	cmp	byte ptr [rbp-0x8D6], 0
	jz	$_475
	mov	rax, qword ptr [rbp-0x8E0]
	mov	qword ptr [rsp+0x38], rax
	mov	rax, qword ptr [rbp+0x50]
	mov	qword ptr [rsp+0x30], rax
	lea	rax, [rbp-0x88C]
	mov	qword ptr [rsp+0x28], rax
	lea	rax, [rbp-0x88]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rbp-0x1C]
	mov	r8, qword ptr [rbp+0x40]
	mov	edx, dword ptr [rbp+0x48]
	mov	rcx, qword ptr [rbp+0x38]
	call	$_078
	xor	eax, eax
	jmp	$_671

$_475:	mov	eax, dword ptr [rbp-0x8]
	cmp	dword ptr [rbp-0xC], eax
	jg	$_476
	mov	eax, dword ptr [rbp-0x8]
	cmp	dword ptr [rbp-0xC], eax
	jge	$_477
	cmp	byte ptr [rdi+0x1E], 195
	jnz	$_477
$_476:	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	xor	eax, eax
	jmp	$_671

$_477:	cmp	dword ptr [rbp-0x10], 8
	jnz	$_478
	mov	dword ptr [rbp-0x8C], 163
$_478:	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_479
	cmp	dword ptr [rbp-0x50], 313
	jnz	$_480
$_479:	cmp	dword ptr [rbp-0x4C], 2
	jne	$_541
	test	byte ptr [rbp-0x48], 0x01
	je	$_541
$_480:	mov	rcx, qword ptr [rbp+0x50]
	mov	rdx, qword ptr [rbp-0x70]
	mov	rax, qword ptr [rbp-0x68]
	cmp	byte ptr [rcx], 0
	jz	$_483
	test	rdx, rdx
	jz	$_481
	cmp	dword ptr [rdx+0x4], 17
	jz	$_482
	cmp	dword ptr [rdx+0x4], 163
	jz	$_482
$_481:	test	rax, rax
	jz	$_483
	cmp	dword ptr [rax+0x4], 17
	jz	$_482
	cmp	dword ptr [rax+0x4], 163
	jnz	$_483
$_482:	mov	byte ptr [rcx], 0
	mov	ecx, 2133
	call	asmerr@PLT
$_483:	test	byte ptr [rdi+0x4B], 0x04
	jz	$_486
	test	byte ptr [rbp-0x44], 0x20
	jz	$_484
	or	byte ptr [Options+0x7+rip], 0x10
$_484:	mov	eax, dword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0xC], eax
	jle	$_485
	mov	eax, dword ptr [rbp-0xC]
$_485:	add	dword ptr [size_vararg+rip], eax
$_486:	mov	eax, dword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0xC], eax
	jle	$_496
	mov	dword ptr [rbp-0x8EC], 271
	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_487
	mov	dword ptr [rbp-0x10], 4
	mov	dword ptr [rbp-0x8EC], 274
$_487:	test	byte ptr [rbp-0x48], 0x02
	jz	$_488
	mov	r8, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbp+0x28]
	lea	rcx, [rbp-0x88C]
	call	$_393
	and	byte ptr [rbp-0x48], 0xFD
$_488:	jmp	$_495

$_489:	test	byte ptr [rbp-0xC], 0x02
	jz	$_492
	cmp	byte ptr [r14+0x4], 0
	jbe	$_491
	cmp	dword ptr [rbp-0x10], 4
	jnz	$_490
	add	dword ptr [size_vararg+rip], 2
$_490:	movzx	ecx, byte ptr [r14+0x4]
	lea	rdx, [stackreg+rip]
	mov	edx, dword ptr [rdx+rcx*4]
	lea	rcx, [DS0037+rip]
	call	AddLineQueueX@PLT
$_491:	sub	dword ptr [rbp-0xC], 2
	mov	ecx, 271
	mov	edx, dword ptr [rbp-0xC]
	jmp	$_494

$_492:	movzx	ecx, byte ptr [r14+0x4]
	lea	rdx, [ModuleInfo+rip]
	mov	ecx, dword ptr [rdx+rcx*4+0x68]
	mov	edx, dword ptr [rbp-0xC]
	mov	eax, dword ptr [rbp-0x10]
	sub	edx, eax
	sub	dword ptr [rbp-0xC], eax
	cmp	qword ptr [CurrProc+rip], 0
	jz	$_493
	cmp	ecx, 21
	jnz	$_493
	mov	edx, eax
$_493:	mov	ecx, dword ptr [rbp-0x8EC]
$_494:	mov	r9d, edx
	lea	r8, [rbp-0x88C]
	mov	edx, ecx
	lea	rcx, [DS0038+rip]
	call	AddLineQueueX@PLT
$_495:	cmp	dword ptr [rbp-0xC], 0
	jg	$_489
	jmp	$_540

$_496:	mov	eax, dword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0xC], eax
	jge	$_528
	cmp	dword ptr [rbp-0x8], 4
	jle	$_497
	cmp	dword ptr [rbp-0x10], 8
	jge	$_497
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
$_497:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	dword ptr [rbp-0xC], 4
	jge	$_498
	cmp	dword ptr [rbp-0x8], 2
	jle	$_498
	cmp	al, 64
	jnz	$_498
	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_498
	mov	r8d, dword ptr [rbp-0x8C]
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0039+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	jmp	$_527

$_498:	movzx	eax, byte ptr [rbp-0x44]
	jmp	$_526

$_499:	cmp	dword ptr [rbp-0x8], 1
	jnz	$_500
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_500
	mov	r8d, dword ptr [r14+0x5C]
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003A+rip]
	call	AddLineQueueX@PLT
	jmp	$_509

$_500:	cmp	dword ptr [rbp-0x10], 2
	jne	$_507
	cmp	byte ptr [rbp-0x44], 0
	jnz	$_505
	cmp	dword ptr [rbp-0x8], 4
	jnz	$_503
	cmp	byte ptr [rbp-0x8CD], 1
	jnc	$_502
	mov	rcx, qword ptr [rbp+0x50]
	test	byte ptr [rcx], 0x04
	jnz	$_501
	lea	rcx, [DS003B+rip]
	call	AddLineQueue@PLT
$_501:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x06
	lea	rcx, [DS0034+0x13+rip]
	call	AddLineQueue@PLT
	jmp	$_503

$_502:	lea	rcx, [DS0014+rip]
	call	AddLineQueue@PLT
$_503:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003C+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	test	byte ptr [rcx], 0x02
	jnz	$_504
	or	byte ptr [rcx], 0x02
	lea	rcx, [DS002D+rip]
	call	AddLineQueue@PLT
$_504:	jmp	$_506

$_505:	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 0
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003D+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x8], 4
	jnz	$_506
	lea	rcx, [DS003E+rip]
	call	AddLineQueue@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x08
$_506:	lea	rcx, [DS0034+0x13+rip]
	call	AddLineQueue@PLT
	jmp	$_509

$_507:	mov	ecx, 815
	cmp	byte ptr [rbp-0x44], 0
	jnz	$_508
	mov	ecx, 816
$_508:	mov	r9d, dword ptr [rbp-0x8C]
	lea	r8, [rbp-0x88C]
	mov	edx, ecx
	lea	rcx, [DS003F+rip]
	call	AddLineQueueX@PLT
$_509:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	jmp	$_527

$_510:	cmp	byte ptr [rbp-0x44], 1
	jnz	$_517
	test	byte ptr [r14+0x1], 0x08
	jnz	$_511
	cmp	dword ptr [rbp-0x8], 2
	jnz	$_517
$_511:	cmp	dword ptr [rbp-0x10], 8
	jnz	$_512
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0040+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	jmp	$_516

$_512:	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_513
	cmp	dword ptr [rbp-0x8], 2
	jz	$_514
$_513:	lea	rcx, [DS0041+rip]
	call	AddLineQueue@PLT
	jmp	$_515

$_514:	movzx	ecx, byte ptr [r14+0x4]
	lea	rdx, [stackreg+rip]
	mov	edx, dword ptr [rdx+rcx*4]
	lea	rcx, [DS0037+rip]
	call	AddLineQueueX@PLT
$_515:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_516:	jmp	$_519

$_517:	mov	edx, 815
	cmp	byte ptr [rbp-0x44], 1
	jnz	$_518
	mov	edx, 816
$_518:	mov	r9d, dword ptr [rbp-0x8C]
	lea	r8, [rbp-0x88C]
	lea	rcx, [DS003F+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
$_519:	jmp	$_527

$_520:	cmp	dword ptr [rbp-0x10], 8
	jnz	$_521
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0042+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	jmp	$_527

$_521:	cmp	dword ptr [rbp-0xC], 3
	jnz	$_524
	cmp	dword ptr [rbp-0x10], 2
	jle	$_522
	mov	r9d, dword ptr [rbp-0x8C]
	lea	r8, [rbp-0x88C]
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0043+rip]
	call	AddLineQueueX@PLT
	jmp	$_523

$_522:	mov	edx, 2
	lea	rcx, [rbp-0x88C]
	call	$_074
$_523:	jmp	$_525

$_524:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_525:	jmp	$_527

$_526:	cmp	eax, 0
	je	$_499
	cmp	eax, 64
	je	$_499
	cmp	eax, 1
	je	$_510
	cmp	eax, 65
	je	$_510
	cmp	eax, 3
	je	$_520
	cmp	eax, 67
	je	$_520
	jmp	$_521

$_527:	jmp	$_540

$_528:	cmp	dword ptr [rbp-0x8], 8
	jnz	$_532
	cmp	dword ptr [rbp-0xC], 4
	jnz	$_532
	test	byte ptr [r14+0x1], 0x08
	jz	$_529
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	jmp	$_531

$_529:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_530
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0044+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	jmp	$_531

$_530:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0045+rip]
	call	AddLineQueueX@PLT
$_531:	jmp	$_540

$_532:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_536
	mov	eax, dword ptr [rbp-0xC]
	cmp	dword ptr [rbp-0x8], eax
	jle	$_536
	cmp	dword ptr [rbp-0x8], 2
	jle	$_533
	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_533
	mov	r8d, dword ptr [rbp-0x8C]
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0039+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	jmp	$_535

$_533:	cmp	dword ptr [rbp-0x10], 2
	jnz	$_534
	cmp	dword ptr [rbp-0x8], 2
	jle	$_534
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0046+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 9
	jmp	$_535

$_534:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0045+0x8+rip]
	call	AddLineQueueX@PLT
$_535:	jmp	$_540

$_536:	cmp	dword ptr [rbp-0x10], 2
	jnz	$_539
	cmp	dword ptr [rbp-0x8], 2
	jle	$_539
	cmp	byte ptr [rbp-0x8CD], 1
	jnc	$_538
	mov	rcx, qword ptr [rbp+0x50]
	test	byte ptr [rcx], 0x04
	jnz	$_537
	lea	rcx, [DS003B+rip]
	call	AddLineQueue@PLT
$_537:	lea	rcx, [DS0046+0x1A+rip]
	call	AddLineQueue@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x07
	jmp	$_539

$_538:	lea	rcx, [DS0041+rip]
	call	AddLineQueue@PLT
$_539:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0045+0x8+rip]
	call	AddLineQueueX@PLT
$_540:	jmp	$_670

$_541:	cmp	dword ptr [rbp-0x4C], 2
	jne	$_610
	mov	rcx, qword ptr [rbp-0x70]
	mov	eax, dword ptr [rcx+0x4]
	mov	dword ptr [rbp-0x8E4], eax
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	dword ptr [rbp-0x8F0], eax
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_542
	mov	eax, dword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0x8], eax
	jge	$_542
	mov	dword ptr [rbp-0x8], eax
$_542:	test	dword ptr [rbp-0x8F0], 0x32008070
	jz	$_543
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	jmp	$_671

$_543:	mov	rcx, qword ptr [rbp+0x50]
	test	byte ptr [rcx], 0x01
	jz	$_545
	cmp	dword ptr [rbp-0x8E4], 5
	jz	$_544
	test	dword ptr [rbp-0x8F0], 0x80
	jz	$_545
$_544:	and	byte ptr [rcx], 0xFE
	mov	ecx, 2133
	call	asmerr@PLT
	jmp	$_547

$_545:	mov	eax, dword ptr [rbp-0x8E4]
	add	eax, eax
	test	byte ptr [rcx], 0x08
	jz	$_547
	cmp	dword ptr [rbp-0x8E4], 7
	jz	$_546
	cmp	byte ptr [r12+rax*8+0xC], 2
	jnz	$_547
$_546:	and	byte ptr [rcx], 0xF7
	mov	ecx, 2133
	call	asmerr@PLT
$_547:	mov	edx, 2
	mov	cl, byte ptr [rbp-0x8D5]
	shl	edx, cl
	mov	eax, dword ptr [rbp-0x8]
	cmp	dword ptr [rbp-0xC], eax
	jnz	$_548
	cmp	dword ptr [rbp-0xC], edx
	jge	$_608
$_548:	cmp	dword ptr [rbp-0x8], 4
	jle	$_553
	cmp	dword ptr [rbp-0x10], 8
	jge	$_553
	cmp	dword ptr [rbp-0x8], 8
	jnz	$_549
	test	byte ptr [r14+0x1], 0x08
	jz	$_550
$_549:	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	jmp	$_553

$_550:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_552
	cmp	dword ptr [rbp-0x8E4], 17
	jz	$_551
	mov	edx, dword ptr [rbp-0x8E4]
	lea	rcx, [DS0047+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	mov	dword ptr [rbp-0x8E4], 17
$_551:	lea	rcx, [DS0048+rip]
	call	AddLineQueueX@PLT
	jmp	$_553

$_552:	lea	rcx, [DS0014+rip]
	call	AddLineQueueX@PLT
$_553:	cmp	dword ptr [rbp-0xC], 2
	jg	$_577
	cmp	dword ptr [rbp-0x8], 4
	jz	$_554
	cmp	dword ptr [rbp-0x10], 4
	jne	$_577
$_554:	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_559
	mov	eax, dword ptr [rbp-0x8]
	cmp	dword ptr [rbp-0xC], eax
	jnz	$_559
	cmp	dword ptr [rbp-0xC], 2
	jnz	$_555
	sub	dword ptr [rbp-0x8E4], 9
	add	dword ptr [rbp-0x8E4], 17
	jmp	$_558

$_555:	cmp	dword ptr [rbp-0x8E4], 5
	jge	$_556
	sub	dword ptr [rbp-0x8E4], 1
	add	dword ptr [rbp-0x8E4], 17
	jmp	$_557

$_556:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003C+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	mov	dword ptr [rbp-0x8E4], 17
$_557:	mov	dword ptr [rbp-0xC], 2
$_558:	jmp	$_576

$_559:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jne	$_565
	cmp	dword ptr [rbp-0x10], 4
	jge	$_565
	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_560
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0049+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	mov	dword ptr [rbp-0x8E4], 17
	jmp	$_564

$_560:	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 9
	cmp	dword ptr [rbp-0xC], 1
	jnz	$_562
	cmp	dword ptr [rbp-0x8E4], 1
	jz	$_561
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003C+rip]
	call	AddLineQueueX@PLT
$_561:	lea	rcx, [DS003D+0xC+rip]
	call	AddLineQueue@PLT
	jmp	$_563

$_562:	cmp	dword ptr [rbp-0x8E4], 9
	jz	$_563
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0020+rip]
	call	AddLineQueueX@PLT
$_563:	lea	rcx, [DS003E+rip]
	call	AddLineQueue@PLT
	mov	dword ptr [rbp-0x8E4], 9
$_564:	mov	dword ptr [rbp-0xC], 2
	jmp	$_576

$_565:	cmp	byte ptr [rbp-0x8CD], 1
	jc	$_572
	cmp	dword ptr [rbp-0x10], 4
	jnz	$_570
	cmp	dword ptr [rbp-0xC], 1
	jnz	$_566
	jmp	$_569

$_566:	cmp	dword ptr [rbp-0x8], 2
	jg	$_567
	movzx	ecx, byte ptr [r14+0x4]
	lea	rdx, [stackreg+rip]
	mov	edx, dword ptr [rdx+rcx*4]
	lea	rcx, [DS0037+rip]
	call	AddLineQueueX@PLT
	jmp	$_569

$_567:	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_568
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0049+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 1
	mov	dword ptr [rbp-0x8E4], 17
	jmp	$_569

$_568:	lea	rcx, [DS0041+rip]
	call	AddLineQueue@PLT
$_569:	jmp	$_571

$_570:	lea	rcx, [DS0041+rip]
	call	AddLineQueue@PLT
$_571:	jmp	$_576

$_572:	mov	rcx, qword ptr [rbp+0x50]
	test	byte ptr [rcx], 0x04
	jnz	$_575
	cmp	dword ptr [rbp-0x8E4], 5
	jz	$_573
	test	dword ptr [rbp-0x8F0], 0x80
	jz	$_574
$_573:	mov	ecx, 2133
	call	asmerr@PLT
$_574:	lea	rcx, [DS003B+rip]
	call	AddLineQueue@PLT
$_575:	lea	rcx, [DS0046+0x1A+rip]
	call	AddLineQueue@PLT
	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], 7
$_576:	jmp	$_592

$_577:	cmp	dword ptr [rbp-0x10], 8
	jne	$_592
	mov	eax, dword ptr [rbp-0x8]
	cmp	dword ptr [rbp-0xC], eax
	jnz	$_578
	cmp	dword ptr [rbp-0x8], 8
	jl	$_579
$_578:	cmp	dword ptr [rbp-0xC], 4
	jne	$_592
	cmp	dword ptr [rbp-0x8], 8
	jne	$_592
$_579:	mov	ecx, dword ptr [rbp-0x8E4]
	call	SizeFromRegister@PLT
	mov	ecx, dword ptr [rbp-0x8E4]
	jmp	$_590

$_580:	cmp	ecx, 1
	jc	$_581
	cmp	ecx, 8
	ja	$_581
	add	ecx, 162
	jmp	$_583

$_581:	cmp	ecx, 87
	jc	$_582
	cmp	ecx, 90
	ja	$_582
	add	ecx, 80
	jmp	$_583

$_582:	cmp	ecx, 91
	jc	$_583
	cmp	ecx, 115
	jnc	$_583
	add	ecx, 80
$_583:	jmp	$_591

$_584:	cmp	ecx, 9
	jc	$_585
	cmp	ecx, 16
	ja	$_585
	add	ecx, 154
	jmp	$_586

$_585:	cmp	ecx, 115
	jc	$_586
	cmp	ecx, 139
	jnc	$_586
	add	ecx, 56
$_586:	jmp	$_591

$_587:	cmp	ecx, 17
	jc	$_588
	cmp	ecx, 24
	ja	$_588
	add	ecx, 146
	jmp	$_589

$_588:	cmp	ecx, 139
	jc	$_589
	cmp	ecx, 171
	jnc	$_589
	add	ecx, 32
$_589:	jmp	$_591

$_590:	cmp	eax, 1
	jz	$_580
	cmp	eax, 2
	jz	$_584
	cmp	eax, 4
	jz	$_587
$_591:	mov	dword ptr [rbp-0x8E4], ecx
$_592:	cmp	dword ptr [rbp-0xC], 1
	jne	$_608
	mov	eax, dword ptr [rbp-0x8E4]
	cmp	eax, 5
	jc	$_593
	cmp	eax, 8
	jbe	$_594
$_593:	cmp	dword ptr [rbp-0x8], 1
	je	$_600
$_594:	cmp	dword ptr [rbp-0x8], 1
	jz	$_596
	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_596
	mov	eax, 3
	mov	edx, 816
	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_595
	mov	edx, 815
	mov	eax, 1
$_595:	mov	rcx, qword ptr [rbp+0x50]
	mov	byte ptr [rcx], al
	lea	r9, [rbp-0x88C]
	mov	r8d, dword ptr [r14+0x5C]
	lea	rcx, [DS0028+rip]
	call	AddLineQueueX@PLT
	jmp	$_599

$_596:	cmp	eax, 1
	jz	$_597
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS003C+rip]
	call	AddLineQueueX@PLT
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	and	byte ptr [rcx], 0xFB
$_597:	cmp	dword ptr [rbp-0x8], 1
	jz	$_599
	mov	rcx, qword ptr [rbp+0x50]
	movzx	eax, byte ptr [rbp-0x44]
	and	al, 0xC0
	cmp	al, 64
	jnz	$_598
	and	byte ptr [rcx], 0xF9
	lea	rcx, [DS003D+0xC+rip]
	call	AddLineQueue@PLT
	jmp	$_599

$_598:	test	byte ptr [rcx], 0x02
	jnz	$_599
	or	byte ptr [rcx], 0x02
	lea	rcx, [DS002D+rip]
	call	AddLineQueue@PLT
$_599:	mov	eax, dword ptr [r14+0x5C]
	mov	dword ptr [rbp-0x8E4], eax
	jmp	$_608

$_600:	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_602
	cmp	dword ptr [rbp-0x8], 4
	jz	$_601
	cmp	dword ptr [rbp-0x10], 4
	jnz	$_602
$_601:	sub	eax, 1
	add	eax, 17
	jmp	$_607

$_602:	cmp	dword ptr [rbp-0x10], 8
	jnz	$_606
	cmp	byte ptr [rbp-0x8CD], 128
	jc	$_606
	cmp	eax, 1
	jc	$_603
	cmp	eax, 4
	ja	$_603
	sub	eax, 1
	add	eax, 163
	jmp	$_605

$_603:	cmp	eax, 87
	jc	$_604
	cmp	eax, 90
	ja	$_604
	sub	eax, 87
	add	eax, 167
	jmp	$_605

$_604:	sub	eax, 91
	add	eax, 171
$_605:	jmp	$_607

$_606:	cmp	dword ptr [rbp-0x10], 8
	jge	$_607
	sub	eax, 1
	add	eax, 9
$_607:	mov	dword ptr [rbp-0x8E4], eax
$_608:	mov	edx, dword ptr [rbp-0x8E4]
	lea	rcx, [DS0043+0x3A+rip]
	call	AddLineQueueX@PLT
	mov	eax, dword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0x8], eax
	jge	$_609
	mov	eax, dword ptr [rbp-0x10]
	mov	dword ptr [rbp-0x8], eax
$_609:	jmp	$_669

$_610:	cmp	dword ptr [rbp-0x8], 0
	je	$_622
	mov	eax, dword ptr [rbp-0x88]
	mov	edx, dword ptr [rbp-0x84]
	cmp	dword ptr [rbp-0x4C], 3
	jnz	$_612
	mov	ecx, 4
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_611
	cmp	dword ptr [rbp-0x10], ecx
	jl	$_611
	or	byte ptr [Options+0x7+rip], 0x10
	cmp	dword ptr [rbp-0x8], 16
	jnz	$_611
	lea	rdx, [rbp-0x88]
	lea	rcx, [rbp-0x88]
	call	__cvtq_sd@PLT
	mov	ecx, 8
	mov	dword ptr [rbp-0x8], ecx
$_611:	jmp	$_621

$_612:	test	edx, edx
	jnz	$_613
	cmp	eax, 255
	jbe	$_614
$_613:	cmp	edx, -1
	jnz	$_615
	cmp	eax, 4294967041
	jl	$_615
$_614:	mov	ecx, 1
	jmp	$_621

$_615:	test	edx, edx
	jnz	$_616
	cmp	eax, 65535
	jbe	$_617
$_616:	cmp	edx, -1
	jnz	$_618
	cmp	eax, 4294901761
	jl	$_618
$_617:	mov	ecx, 2
	jmp	$_621

$_618:	test	edx, edx
	jz	$_619
	cmp	edx, -1
	jnz	$_620
$_619:	mov	ecx, 4
	jmp	$_621

$_620:	mov	ecx, 8
$_621:	cmp	dword ptr [rbp-0x8], ecx
	jge	$_622
	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
$_622:	mov	eax, 2
	mov	cl, byte ptr [rbp-0x8D5]
	shl	eax, cl
	mov	dword ptr [rbp-0xC], eax
	cmp	dword ptr [rbp-0x8], eax
	jge	$_627
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_626
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_626
	cmp	eax, 2
	jnz	$_624
	cmp	dword ptr [rbp-0x88], 65535
	jg	$_623
	cmp	dword ptr [rbp-0x88], -65535
	jge	$_624
$_623:	mov	dword ptr [rbp-0x8], 4
	jmp	$_625

$_624:	mov	dword ptr [rbp-0x8], eax
$_625:	jmp	$_627

$_626:	mov	dword ptr [rbp-0x8], eax
$_627:	cmp	byte ptr [rbp-0x8CD], 1
	jnc	$_642
	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	jmp	$_640

$_628:	cmp	dword ptr [rbp-0x88], 0
	jnz	$_629
	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_630
$_629:	and	byte ptr [rcx], 0xF9
	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS0020+rip]
	call	AddLineQueueX@PLT
	jmp	$_632

$_630:	test	byte ptr [rcx], 0x04
	jnz	$_631
	lea	rcx, [DS003B+rip]
	call	AddLineQueue@PLT
$_631:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x06
$_632:	jmp	$_641

$_633:	cmp	dword ptr [rbp-0x88], 65535
	ja	$_634
	lea	rcx, [DS003B+rip]
	call	AddLineQueue@PLT
	jmp	$_635

$_634:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS004A+rip]
	call	AddLineQueueX@PLT
$_635:	lea	rcx, [DS0046+0x1A+rip]
	call	AddLineQueue@PLT
	cmp	dword ptr [rbp-0x88], 0
	jnz	$_636
	cmp	dword ptr [rbp-0x4C], 1
	jnz	$_637
$_636:	lea	rdx, [rbp-0x88C]
	lea	rcx, [DS004B+rip]
	call	AddLineQueueX@PLT
	jmp	$_638

$_637:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x06
$_638:	jmp	$_641

$_639:	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	jmp	$_641

$_640:	cmp	dword ptr [rbp-0x8], 2
	je	$_628
	cmp	dword ptr [rbp-0x8], 4
	je	$_633
	jmp	$_639

$_641:	lea	rcx, [DS0046+0x1A+rip]
	call	AddLineQueue@PLT
	jmp	$_669

$_642:	mov	ebx, 774
	mov	esi, 4294967294
	mov	eax, dword ptr [rbp-0x8]
	cmp	eax, dword ptr [rbp-0x10]
	je	$_667
	jmp	$_666

$_643:	mov	ebx, 776
	jmp	$_667

$_644:	cmp	byte ptr [rbp-0x8D5], 0
	jnz	$_645
	mov	ebx, 776
	jmp	$_646

$_645:	cmp	byte ptr [rbp-0x8D5], 1
	jnz	$_646
	cmp	byte ptr [r14+0x6], 2
	jnz	$_646
	mov	ebx, 738
$_646:	lea	r8, [rbp-0x88C]
	mov	edx, ebx
	lea	rcx, [DS004C+rip]
	call	AddLineQueueX@PLT
$_647:	cmp	byte ptr [rbp-0x8CD], 3
	jc	$_648
	mov	ebx, 738
	jmp	$_649

$_648:	mov	ebx, 776
	mov	esi, 309
	mov	ecx, 302
	jmp	$_664

$_649:	jmp	$_667

$_650:	cmp	byte ptr [rbp-0x8D5], 0
	jz	$_651
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_651
	cmp	dword ptr [rbp-0x4C], 3
	jz	$_652
$_651:	jmp	$_667

$_652:	mov	edx, 10
	lea	rcx, [rbp-0x88]
	call	quad_resize@PLT
	mov	r8d, dword ptr [rbp-0x80]
	mov	edx, ebx
	lea	rcx, [DS004D+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [rbp-0x8CD], 128
	jnc	$_660
	mov	ebx, 738
	jmp	$_654

$_653:	cmp	byte ptr [rbp-0x8D5], 0
	je	$_667
	test	byte ptr [Options+0x6+rip], 0x10
	jne	$_667
	cmp	byte ptr [rbp-0x8D5], 1
	jnz	$_655
	mov	ebx, 738
	mov	rax, qword ptr [rbp-0x80]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, ebx
	mov	r8, qword ptr [rbp-0x80]
	mov	edx, ebx
	lea	rcx, [DS004E+rip]
	call	AddLineQueueX@PLT
$_654:	mov	rax, qword ptr [rbp-0x88]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, ebx
	mov	r8, qword ptr [rbp-0x88]
	mov	edx, ebx
	lea	rcx, [DS004E+rip]
	call	AddLineQueueX@PLT
	jmp	$_669

$_655:	cmp	dword ptr [rbp-0x7C], 0
	jz	$_656
	cmp	dword ptr [rbp-0x7C], -1
	jnz	$_657
$_656:	mov	r8, qword ptr [rbp-0x80]
	mov	edx, ebx
	lea	rcx, [DS004F+rip]
	call	AddLineQueueX@PLT
	jmp	$_658

$_657:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	mov	r8d, ebx
	mov	rdx, qword ptr [rbp-0x80]
	lea	rcx, [DS0050+rip]
	call	AddLineQueueX@PLT
$_658:	cmp	dword ptr [rbp-0x84], 0
	jz	$_659
	cmp	dword ptr [rbp-0x84], -1
	jnz	$_660
$_659:	mov	r8, qword ptr [rbp-0x88]
	mov	edx, ebx
	lea	rcx, [DS004F+rip]
	call	AddLineQueueX@PLT
	jmp	$_661

$_660:	mov	rcx, qword ptr [rbp+0x50]
	or	byte ptr [rcx], 0x01
	mov	r8d, ebx
	mov	rdx, qword ptr [rbp-0x88]
	lea	rcx, [DS0050+rip]
	call	AddLineQueueX@PLT
$_661:	jmp	$_669

$_662:	cmp	byte ptr [rbp-0x8D5], 2
	jz	$_667
	cmp	dword ptr [rbp-0x4C], 0
	jz	$_663
	cmp	dword ptr [rbp-0x4C], 3
	jnz	$_665
$_663:	mov	ebx, 738
	mov	esi, 308
	mov	ecx, 301
$_664:	lea	r9, [rbp-0x88C]
	mov	r8d, ecx
	mov	edx, ebx
	lea	rcx, [DS0051+rip]
	call	AddLineQueueX@PLT
	jmp	$_667

$_665:	mov	edx, dword ptr [rbp-0x8D4]
	mov	ecx, 2114
	call	asmerr@PLT
	jmp	$_667

$_666:	cmp	eax, 2
	je	$_643
	cmp	eax, 6
	je	$_644
	cmp	eax, 4
	je	$_647
	cmp	eax, 10
	je	$_650
	cmp	eax, 16
	je	$_653
	cmp	eax, 8
	je	$_662
	jmp	$_665

$_667:	lea	rcx, [rbp-0x88C]
	cmp	esi, -2
	jz	$_668
	mov	r9, rcx
	mov	r8d, esi
	mov	edx, ebx
	lea	rcx, [DS0051+rip]
	call	AddLineQueueX@PLT
	jmp	$_669

$_668:	mov	r8, rcx
	mov	edx, ebx
	lea	rcx, [DS0052+rip]
	call	AddLineQueueX@PLT
$_669:	test	byte ptr [rdi+0x4B], 0x04
	jz	$_670
	mov	eax, dword ptr [rbp-0x8]
	add	dword ptr [size_vararg+rip], eax
$_670:	xor	eax, eax
$_671:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

InvokeDirective:
	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, 2872
	mov	dword ptr [rbp-0x48], 0
	mov	qword ptr [rbp-0x8C8], 0
	mov	qword ptr [rbp-0x8D8], 0
	inc	dword ptr [rbp+0x28]
	mov	eax, dword ptr [rbp+0x28]
	mov	dword ptr [rbp-0x3C], eax
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_674
$_672:	mov	r8, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbp+0x28]
	lea	rcx, [rbp-0x8C0]
	call	ExpandHllProc@PLT
	cmp	eax, -1
	je	$_793
	cmp	byte ptr [rbp-0x8C0], 0
	jz	$_674
	lea	rcx, [rbp-0x8C0]
	call	AddLineQueue@PLT
	call	RunLineQueue@PLT
	mov	rbx, qword ptr [rbp+0x30]
	cmp	dword ptr [rbx+0x4], 609
	jnz	$_673
	cmp	byte ptr [rbx+0x20], 2
	jnz	$_673
	cmp	dword ptr [r14+0x64], 2
	jnz	$_673
	xor	eax, eax
	jmp	$_793

$_673:	jmp	$_672

$_674:	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	cmp	byte ptr [rbx], 8
	jnz	$_675
	cmp	byte ptr [rbx+0x20], 44
	je	$_683
	cmp	byte ptr [rbx+0x20], 0
	je	$_683
$_675:	mov	byte ptr [rsp+0x20], 0
	lea	r9, [rbp-0xC0]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	je	$_793
	mov	rsi, qword ptr [rbp-0x60]
	test	rsi, rsi
	jz	$_677
	cmp	byte ptr [rsi+0x1D], 7
	jnz	$_677
	mov	qword ptr [rbp-0x8], rsi
	mov	qword ptr [rbp-0x10], rsi
	cmp	byte ptr [rsi+0x1E], 128
	jnz	$_676
	jmp	$_690

$_676:	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_677
	jmp	$_691

$_677:	cmp	dword ptr [rbp-0x84], 2
	jnz	$_680
	mov	rbx, qword ptr [rbp-0xA8]
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x0E
	jz	$_678
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	movzx	ecx, byte ptr [r12+rax*8+0xC]
	call	GetStdAssume@PLT
	mov	qword ptr [rbp-0x8], rax
	jmp	$_679

$_678:	mov	qword ptr [rbp-0x8], 0
$_679:	jmp	$_682

$_680:	mov	rax, qword ptr [rbp-0x68]
	test	rax, rax
	jnz	$_681
	mov	rax, qword ptr [rbp-0x70]
$_681:	mov	qword ptr [rbp-0x8], rax
$_682:	jmp	$_684

$_683:	mov	qword ptr [rbp-0xA8], 0
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, rbx
	call	SymFindID@PLT
	mov	qword ptr [rbp-0x8], rax
	inc	dword ptr [rbp+0x28]
$_684:	mov	rsi, qword ptr [rbp-0x8]
	test	rsi, rsi
	jnz	$_685
	mov	ecx, 2190
	call	asmerr@PLT
	jmp	$_793

$_685:	mov	rdx, qword ptr [rsi+0x28]
	mov	rcx, qword ptr [rsi+0x50]
	test	byte ptr [rsi+0x10], 0x02
	jz	$_686
	jmp	$_696

$_686:	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_687
	test	rcx, rcx
	jz	$_687
	test	byte ptr [rcx+0x10], 0x02
	jz	$_687
	mov	qword ptr [rbp-0x8], rcx
	jmp	$_696

$_687:	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_688
	test	rcx, rcx
	jz	$_688
	cmp	byte ptr [rcx+0x1E], 128
	jnz	$_688
	mov	qword ptr [rbp-0x10], rcx
	jmp	$_690

	jmp	$_696

$_688:	cmp	byte ptr [rsi+0x1E], 196
	jnz	$_694
	cmp	byte ptr [rdx+0x1E], 195
	jz	$_689
	cmp	byte ptr [rdx+0x1E], 128
	jnz	$_694
$_689:	mov	qword ptr [rbp-0x10], rdx
	cmp	byte ptr [rdx+0x1E], 128
	jz	$_690
	jmp	$_691

$_690:	mov	rsi, qword ptr [rbp-0x10]
	cmp	byte ptr [rsi+0x1E], 128
	jz	$_691
	mov	ecx, 2190
	call	asmerr@PLT
	jmp	$_793

$_691:	mov	rsi, qword ptr [rbp-0x10]
$_692:	mov	rax, qword ptr [rsi+0x50]
	mov	qword ptr [rbp-0x8], rax
	test	rax, rax
	jnz	$_693
	mov	ecx, 2190
	call	asmerr@PLT
	jmp	$_793

$_693:	jmp	$_696

$_694:	cmp	byte ptr [rsi+0x1E], 128
	jnz	$_695
	jmp	$_692

	jmp	$_696

$_695:	mov	ecx, 2190
	call	asmerr@PLT
	jmp	$_793

$_696:	mov	rsi, qword ptr [rbp-0x8]
	mov	qword ptr [rbp-0x10], rsi
	mov	rcx, rsi
	mov	rax, qword ptr [rcx+0x78]
	mov	qword ptr [rbp-0x50], rax
	test	byte ptr [Options+0x6+rip], 0x10
	jne	$_707
	imul	ebx, dword ptr [rbp-0x3C], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rsi+0x50]
	cmp	byte ptr [rsi+0x1D], 2
	jnz	$_698
	test	rcx, rcx
	jz	$_698
	cmp	byte ptr [rcx+0x1D], 9
	jnz	$_698
	mov	rax, qword ptr [rcx+0x68]
	test	rax, rax
	jz	$_697
	mov	qword ptr [rbp-0x8C8], rcx
	mov	qword ptr [rax], rcx
	mov	rdx, qword ptr [rcx+0x8]
	lea	rcx, [rbp-0x8C0]
	call	tstrcpy@PLT
$_697:	jmp	$_707

$_698:	cmp	byte ptr [rbx], 91
	jne	$_707
	cmp	byte ptr [rbx+0x60], 46
	jne	$_707
	cmp	qword ptr [rbp-0x68], 0
	je	$_707
	mov	rdi, qword ptr [rbp-0x68]
	test	byte ptr [rdi+0x11], 0x01
	je	$_706
	lea	rcx, [rbx+0x80]
	call	SymFindID@PLT
	mov	qword ptr [rbp-0x8D0], rax
	test	rax, rax
	je	$_702
	test	byte ptr [rax+0x13], 0x01
	je	$_702
	test	byte ptr [rdi+0x13], 0x08
	jz	$_699
	mov	rax, qword ptr [rdi+0x40]
	mov	qword ptr [rbp-0x8C8], rax
	mov	rdx, qword ptr [rax+0x8]
	lea	rcx, [rbp-0x8C0]
	call	tstrcpy@PLT
	jmp	$_700

$_699:	mov	rcx, qword ptr [rax+0x38]
	mov	rdx, qword ptr [rcx+0x8]
	lea	rcx, [rbp-0x8C0]
	call	tstrcpy@PLT
	lea	rdx, [DS0053+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rdx, qword ptr [rdi+0x8]
	mov	rcx, rax
	call	tstrcat@PLT
	mov	rcx, rax
	call	SymFind@PLT
	mov	qword ptr [rbp-0x8C8], rax
$_700:	mov	rax, qword ptr [rbp-0x8C8]
	test	rax, rax
	jz	$_701
	cmp	byte ptr [rax+0x1D], 10
	jnz	$_701
	mov	rcx, qword ptr [rax+0x30]
	call	SymFind@PLT
	mov	qword ptr [rbp-0x8C8], rax
$_701:	test	rax, rax
	jz	$_702
	cmp	byte ptr [rax+0x1D], 9
	jz	$_702
	mov	qword ptr [rbp-0x8C8], 0
$_702:	test	byte ptr [rdi+0x13], 0x04
	jz	$_706
	and	byte ptr [rdi+0x13], 0xFB
	mov	ecx, dword ptr [r14+0x64]
	dec	ecx
	imul	edx, ecx, 32
	add	rdx, qword ptr [rbp+0x30]
	jmp	$_704

$_703:	cmp	byte ptr [rdx], 44
	jz	$_705
	sub	rdx, 32
	dec	ecx
$_704:	cmp	rdx, rbx
	ja	$_703
$_705:	cmp	byte ptr [rdx], 44
	jnz	$_706
	lea	rax, [rdx+0x20]
	mov	qword ptr [rbp-0x8D8], rax
	mov	byte ptr [rdx], 0
	mov	dword ptr [r14+0x64], ecx
$_706:	or	byte ptr [rsi+0x11], 0x01
	mov	rax, qword ptr [rbp-0x8C8]
	test	rax, rax
	jz	$_707
	or	byte ptr [rsi+0x11], 0x02
	test	byte ptr [rax+0x12], 0x80
	jz	$_707
	or	byte ptr [rsi+0x12], 0x80
$_707:	mov	rdx, qword ptr [rbp-0x50]
	mov	rcx, qword ptr [rdx+0x18]
	mov	dword ptr [rbp-0x2C], 0
$_708:	test	rcx, rcx
	jz	$_709
	mov	rcx, qword ptr [rcx+0x88]
	inc	dword ptr [rbp-0x2C]
	jmp	$_708

$_709:	mov	eax, dword ptr [rbp+0x28]
	mov	dword ptr [rbp-0x44], eax
	test	byte ptr [rsi+0x12], 0x80
	jz	$_711
	inc	dword ptr [rbp+0x28]
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
$_710:	cmp	byte ptr [rbx], 0
	jz	$_711
	cmp	byte ptr [rbx], 44
	jz	$_711
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	jmp	$_710

$_711:	movzx	eax, byte ptr [rsi+0x20]
	cmp	byte ptr [rsi+0x1D], 7
	jz	$_712
	mov	rcx, rsi
	call	GetSymOfssize@PLT
$_712:	movzx	edx, byte ptr [rsi+0x1F]
	mov	ecx, eax
	call	get_fasttype@PLT
	mov	al, byte ptr [rax+0xF]
	mov	byte ptr [rbp-0x8D9], al
	test	al, 0x31
	jz	$_713
	call	$_001
	lea	rax, [rbp-0x30]
	mov	qword ptr [rsp+0x20], rax
	mov	r9, qword ptr [rbp+0x30]
	mov	r8d, dword ptr [rbp+0x28]
	mov	edx, dword ptr [rbp-0x2C]
	mov	rcx, rsi
	call	$_014
	mov	dword ptr [rbp-0x40], eax
$_713:	mov	rdx, qword ptr [rbp-0x50]
	mov	rdi, qword ptr [rdx+0x18]
	mov	eax, dword ptr [rbp+0x28]
	mov	dword ptr [rbp-0x38], eax
	test	byte ptr [rdx], 0x01
	jnz	$_715
	lea	rax, [rbp-0x48]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x20], eax
	xor	r9d, r9d
	mov	r8, qword ptr [rbp-0x10]
	mov	rdx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rbp+0x28]
	call	$_398
	cmp	eax, -1
	jz	$_714
	mov	ecx, 2136
	call	asmerr@PLT
	jmp	$_793

$_714:	jmp	$_721

$_715:	mov	eax, dword ptr [r14+0x64]
	sub	eax, dword ptr [rbp+0x28]
	shr	eax, 1
	mov	dword ptr [rbp-0x8E0], eax
	dec	dword ptr [rbp-0x2C]
	mov	dword ptr [size_vararg+rip], 0
	jmp	$_717

$_716:	mov	rdi, qword ptr [rdi+0x88]
$_717:	test	rdi, rdi
	jz	$_718
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_716
$_718:	mov	eax, dword ptr [rbp-0x2C]
	cmp	dword ptr [rbp-0x8E0], eax
	jl	$_719
	lea	rax, [rbp-0x48]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x8E0]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, rdi
	mov	r8, qword ptr [rbp-0x10]
	mov	rdx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rbp+0x28]
	call	$_398
	dec	dword ptr [rbp-0x8E0]
	jmp	$_718

$_719:	mov	rdx, qword ptr [rbp-0x50]
	mov	rdi, qword ptr [rdx+0x18]
$_720:	test	rdi, rdi
	jz	$_721
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_721
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_720

$_721:	test	byte ptr [rbp-0x8D9], 0x04
	jne	$_733
	mov	dword ptr [rbp-0x8E4], 0
$_722:	test	rdi, rdi
	je	$_729
	cmp	dword ptr [rbp-0x2C], 0
	je	$_729
	dec	dword ptr [rbp-0x2C]
	lea	rax, [rbp-0x48]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, rdi
	mov	r8, qword ptr [rbp-0x10]
	mov	rdx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rbp+0x28]
	call	$_398
	cmp	eax, -1
	jnz	$_723
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_723
	mov	edx, dword ptr [rbp-0x2C]
	mov	ecx, 2033
	call	asmerr@PLT
$_723:	movzx	eax, byte ptr [r14+0x4]
	lea	rcx, [ModuleInfo+rip]
	mov	eax, dword ptr [rcx+rax*4+0x68]
	cmp	qword ptr [CurrProc+rip], 0
	jz	$_728
	cmp	eax, 21
	jnz	$_728
	call	RunLineQueue@PLT
	mov	eax, dword ptr [rdi+0x60]
	cmp	eax, 4
	jnc	$_724
	mov	eax, 4
$_724:	cmp	eax, 4
	jbe	$_725
	mov	eax, 8
$_725:	add	dword ptr [rbp-0x8E4], eax
	mov	rcx, qword ptr [CurrProc+rip]
	mov	rdx, qword ptr [rcx+0x78]
	mov	rdx, qword ptr [rdx+0x18]
$_726:	test	rdx, rdx
	jz	$_728
	cmp	byte ptr [rdx+0x1D], 10
	jz	$_727
	add	dword ptr [rdx+0x30], eax
$_727:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_726

$_728:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_722

$_729:	cmp	dword ptr [rbp-0x8E4], 0
	jz	$_732
	mov	rcx, qword ptr [CurrProc+rip]
	mov	rax, qword ptr [rcx+0x78]
	mov	rdx, qword ptr [rax+0x18]
$_730:	test	rdx, rdx
	jz	$_732
	cmp	byte ptr [rdx+0x1D], 10
	jz	$_731
	mov	eax, dword ptr [rbp-0x8E4]
	sub	dword ptr [rdx+0x30], eax
$_731:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_730

$_732:	jmp	$_736

$_733:	mov	dword ptr [rbp-0x2C], 0
$_734:	test	rdi, rdi
	jz	$_736
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_736
	lea	rax, [rbp-0x48]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, rdi
	mov	r8, qword ptr [rbp-0x10]
	mov	rdx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rbp+0x28]
	call	$_398
	cmp	eax, -1
	jnz	$_735
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_735
	mov	edx, dword ptr [rbp-0x2C]
	mov	ecx, 2033
	call	asmerr@PLT
$_735:	mov	rdi, qword ptr [rdi+0x88]
	inc	dword ptr [rbp-0x2C]
	jmp	$_734

$_736:	mov	eax, dword ptr [rbp-0x44]
	mov	dword ptr [rbp+0x28], eax
	mov	rdx, qword ptr [rbp-0x50]
	mov	rcx, qword ptr [rbp-0x10]
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_738
	cmp	byte ptr [rcx+0x1F], 2
	jnz	$_738
	test	byte ptr [rdx], 0x01
	jz	$_738
	cmp	byte ptr [r14+0x4], 2
	jnz	$_738
	cmp	dword ptr [rbp-0x40], 0
	jz	$_737
	mov	edx, dword ptr [rbp-0x40]
	lea	rcx, [DS0054+rip]
	call	AddLineQueueX@PLT
	jmp	$_738

$_737:	lea	rcx, [DS0055+rip]
	call	AddLineQueue@PLT
$_738:	mov	rcx, qword ptr [rbp-0x10]
	mov	rdx, qword ptr [rbp-0xA8]
	test	rdx, rdx
	jz	$_739
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_739
	test	byte ptr [rbp-0x48], 0x01
	jz	$_739
	cmp	byte ptr [rdx+0x1], 0
	jnz	$_739
	test	byte ptr [rcx+0x11], 0x01
	jnz	$_739
	mov	ecx, 7002
	call	asmerr@PLT
$_739:	mov	rax, qword ptr [r14+0x1E0]
	mov	qword ptr [rbp-0x20], rax
	lea	rdx, [DS0056+rip]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcpy@PLT
	add	qword ptr [rbp-0x20], 6
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_742
	mov	rax, qword ptr [CurrProc+rip]
	test	rax, rax
	jz	$_740
	mov	rcx, qword ptr [rax+0x78]
	or	byte ptr [rcx+0x1], 0x04
$_740:	cmp	qword ptr [rsi+0x60], 0
	jz	$_742
	test	byte ptr [rsi+0x12], 0x08
	jnz	$_741
	cmp	byte ptr [rsi+0x1D], 2
	jnz	$_742
$_741:	or	byte ptr [rsi+0x12], 0x08
	test	byte ptr [rsi+0x12], 0x10
	jnz	$_742
	or	byte ptr [rsi+0x12], 0x10
	mov	rax, qword ptr [rsi+0x60]
	inc	dword ptr [rax+0x8]
$_742:	imul	ebx, dword ptr [rbp-0x3C], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp-0x68]
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_743
	cmp	byte ptr [rbx], 91
	jne	$_783
	cmp	byte ptr [rbx+0x60], 46
	jne	$_783
	test	rcx, rcx
	je	$_783
	test	byte ptr [rcx+0x11], 0x01
	je	$_783
$_743:	cmp	qword ptr [rbp-0x8C8], 0
	je	$_765
	mov	dword ptr [rbp-0x8E8], 0
	and	byte ptr [rsi+0x4B], 0xFD
	mov	rcx, qword ptr [r14+0x1E0]
	inc	rcx
	mov	qword ptr [rbp-0x20], rcx
	lea	rdx, [rbp-0x8C0]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcpy@PLT
	lea	rdx, [DS0057+rip]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrlen@PLT
	add	qword ptr [rbp-0x20], rax
	test	byte ptr [rbp-0x8D9], 0x31
	je	$_749
	mov	rdx, qword ptr [rbp-0x50]
	mov	rdi, qword ptr [rdx+0x18]
$_744:	test	rdi, rdi
	je	$_749
	mov	rax, qword ptr [rdi+0x8]
	cmp	byte ptr [rdi+0x1E], 194
	jnz	$_745
	lea	rdx, [DS0057+0x2+rip]
	mov	qword ptr [rdi+0x8], rdx
	jmp	$_748

$_745:	cmp	byte ptr [rdi+0x1D], 10
	jnz	$_746
	mov	rax, qword ptr [rdi+0x30]
	jmp	$_748

$_746:	test	byte ptr [rdi+0x11], 0x10
	jz	$_747
	movzx	ecx, byte ptr [rdi+0x58]
	lea	rdx, [rbp-0xAF8]
	call	GetResWName@PLT
	mov	rcx, rax
	call	LclDup@PLT
	jmp	$_748

$_747:	movzx	eax, byte ptr [rdi+0x48]
	lea	rdx, [stackreg+rip]
	mov	edx, dword ptr [rdx+rax*4]
	movzx	ecx, byte ptr [rdi+0x5B]
	mov	r9d, ecx
	mov	r8d, edx
	lea	rdx, [DS0058+rip]
	lea	rcx, [rbp-0xAF8]
	call	tsprintf@PLT
	lea	rcx, [rbp-0xAF8]
	call	LclDup@PLT
$_748:	movzx	ecx, byte ptr [rdi+0x59]
	mov	qword ptr [rbp+rcx*8-0xAE8], rax
	mov	rdi, qword ptr [rdi+0x88]
	inc	dword ptr [rbp-0x8E8]
	jmp	$_744

$_749:	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rdx, qword ptr [rbp-0x50]
	mov	rdi, qword ptr [rbp-0x10]
	cmp	dword ptr [rbp-0x8E8], 0
	jnz	$_753
	cmp	byte ptr [rbx], 0
	jz	$_752
	lea	rdx, [rbx+0x20]
	test	byte ptr [rdi+0x12], 0x80
	jz	$_751
	mov	rax, qword ptr [rbp-0x8D8]
	test	rax, rax
	jz	$_750
	mov	rdx, rax
	jmp	$_751

$_750:	add	rdx, 32
	mov	rax, qword ptr [rdx+0x10]
	cmp	word ptr [rax], 44
	jnz	$_751
	add	rdx, 32
$_751:	mov	rdx, qword ptr [rdx+0x18]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
$_752:	jmp	$_764

$_753:	test	byte ptr [rdx], 0x01
	jz	$_755
	mov	rdx, qword ptr [rbx+0x38]
	cmp	dword ptr [rbx+0x24], 339
	jnz	$_754
	test	byte ptr [rdi+0x11], 0x01
	jz	$_754
	mov	rdx, qword ptr [rbx+0x58]
$_754:	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
	jmp	$_764

$_755:	mov	esi, 1
	mov	rdx, qword ptr [rbp-0xAE8]
	test	byte ptr [rdi+0x12], 0x80
	jz	$_760
	mov	rax, qword ptr [rbp-0x8D8]
	test	rax, rax
	jz	$_756
	mov	rdx, qword ptr [rax+0x18]
	jmp	$_759

$_756:	mov	esi, 64
$_757:	cmp	byte ptr [rbx+rsi+0x20], 46
	jnz	$_758
	mov	rdx, qword ptr [rbx+rsi+0x10]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
	lea	rdx, [DS0059+rip]
	mov	rcx, rax
	call	tstrcat@PLT
	add	esi, 64
	jmp	$_757

$_758:	mov	rdx, qword ptr [rbx+rsi+0x10]
$_759:	xor	esi, esi
$_760:	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
$_761:	cmp	esi, dword ptr [rbp-0x8E8]
	jge	$_763
	lea	rdx, [DS005A+rip]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
	cmp	qword ptr [rbp+rsi*8-0xAE8], 0
	jz	$_762
	mov	rdx, qword ptr [rbp+rsi*8-0xAE8]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
$_762:	inc	esi
	jmp	$_761

$_763:	mov	rsi, qword ptr [rbp-0x8]
$_764:	lea	rdx, [DS0051+0xA+rip]
	mov	rcx, qword ptr [rbp-0x20]
	call	tstrcat@PLT
$_765:	cmp	qword ptr [rbp-0x8D8], 0
	je	$_773
	mov	edi, 17
	cmp	byte ptr [r14+0x4], 2
	jnz	$_766
	mov	edi, 163
	cmp	byte ptr [rsi+0x1F], 2
	jnz	$_766
	mov	edi, 173
$_766:	mov	rbx, qword ptr [rbp-0x8D8]
	cmp	byte ptr [rbx], 91
	jnz	$_767
	add	rbx, 128
$_767:	mov	rcx, rbx
	call	SymFindID@PLT
	mov	rcx, rax
	mov	rax, qword ptr [rbp-0x8C8]
	mov	qword ptr [rsp+0x28], rax
	movzx	eax, byte ptr [rsi+0x1F]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, qword ptr [rbp-0x8D0]
	mov	r8, rbx
	mov	edx, edi
	call	AssignPointer@PLT
	cmp	edi, 17
	jnz	$_772
	cmp	byte ptr [rsi+0x1F], 1
	jz	$_768
	cmp	byte ptr [rsi+0x1F], 3
	jnz	$_772
$_768:	test	rax, rax
	jz	$_771
	cmp	byte ptr [rax+0x1E], 196
	jnz	$_769
	mov	rax, qword ptr [rax+0x28]
$_769:	cmp	byte ptr [rax+0x1E], 195
	jnz	$_770
	mov	rax, qword ptr [rax+0x50]
$_770:	test	rax, rax
	jz	$_771
	test	byte ptr [rax+0x12], 0x02
	jnz	$_771
	xor	eax, eax
$_771:	test	rax, rax
	jz	$_772
	lea	rcx, [DS005B+rip]
	call	AddLineQueue@PLT
$_772:	jmp	$_783

$_773:	cmp	qword ptr [rbp-0x8C8], 0
	jne	$_783
	imul	ebx, dword ptr [rbp-0x38], 32
	add	rbx, qword ptr [rbp+0x30]
	cmp	byte ptr [r14+0x4], 2
	jnz	$_776
	cmp	byte ptr [rsi+0x1F], 2
	jnz	$_774
	lea	rcx, [DS005C+rip]
	call	AddLineQueue@PLT
	jmp	$_775

$_774:	lea	rcx, [DS005D+rip]
	call	AddLineQueue@PLT
$_775:	jmp	$_783

$_776:	cmp	byte ptr [r14+0x4], 1
	jne	$_783
	mov	dword ptr [rbp-0xAFC], 17
	cmp	byte ptr [rsi+0x1F], 9
	jz	$_777
	cmp	byte ptr [rsi+0x1F], 10
	jnz	$_778
$_777:	jmp	$_782

$_778:	cmp	byte ptr [rsi+0x1F], 7
	jnz	$_779
	mov	dword ptr [rbp-0xAFC], 18
	jmp	$_782

$_779:	cmp	dword ptr [rbx+0x24], 17
	jz	$_782
	cmp	byte ptr [rbx+0x20], 2
	jnz	$_780
	cmp	dword ptr [rbx+0x24], 17
	jbe	$_780
	cmp	dword ptr [rbx+0x24], 24
	ja	$_780
	mov	eax, dword ptr [rbx+0x24]
	mov	dword ptr [rbp-0xAFC], eax
	jmp	$_782

$_780:	cmp	byte ptr [rbx+0x20], 7
	jnz	$_781
	cmp	dword ptr [rbx+0x24], 339
	jnz	$_781
	mov	rdx, qword ptr [rbx+0x50]
	lea	rcx, [DS005E+rip]
	call	AddLineQueueX@PLT
	jmp	$_782

$_781:	mov	rdx, qword ptr [rbx+0x30]
	lea	rcx, [DS005F+rip]
	call	AddLineQueueX@PLT
$_782:	mov	edx, dword ptr [rbp-0xAFC]
	lea	rcx, [DS0060+rip]
	call	AddLineQueueX@PLT
$_783:	mov	rbx, qword ptr [rbp+0x30]
	imul	edx, dword ptr [rbp-0x38], 32
	imul	ecx, dword ptr [rbp-0x3C], 32
	cmp	qword ptr [rbp-0x8C8], 0
	jnz	$_784
	mov	rax, qword ptr [rbx+rdx+0x18]
	sub	rax, qword ptr [rbx+rcx+0x18]
	mov	dword ptr [rbp-0x34], eax
	mov	r8d, dword ptr [rbp-0x34]
	mov	rdx, qword ptr [rbx+rcx+0x18]
	mov	rcx, qword ptr [rbp-0x20]
	call	tmemcpy@PLT
	mov	edx, dword ptr [rbp-0x34]
	mov	byte ptr [rax+rdx], 0
$_784:	mov	rcx, qword ptr [r14+0x1E0]
	call	AddLineQueue@PLT
	mov	rdi, qword ptr [rbp-0x50]
	mov	rsi, qword ptr [rbp-0x8]
	cmp	byte ptr [rsi+0x1F], 1
	jz	$_785
	cmp	byte ptr [rsi+0x1F], 2
	jnz	$_790
	test	byte ptr [rbp-0x8D9], 0x31
	jnz	$_790
$_785:	cmp	dword ptr [rdi+0xC], 0
	jnz	$_786
	test	byte ptr [rdi], 0x01
	jz	$_790
	cmp	dword ptr [size_vararg+rip], 0
	jz	$_790
$_786:	movzx	eax, byte ptr [r14+0x4]
	cmp	byte ptr [r14+0x4], 0
	jnz	$_787
	cmp	qword ptr [r14+0x330], 0
	jz	$_787
	mov	ecx, 2
	call	GetOfssizeAssume@PLT
$_787:	lea	rdx, [stackreg+rip]
	mov	eax, dword ptr [rdx+rax*4]
	test	byte ptr [rdi], 0x01
	jz	$_788
	mov	ecx, dword ptr [rdi+0xC]
	add	ecx, dword ptr [size_vararg+rip]
	mov	r8d, ecx
	mov	edx, eax
	lea	rcx, [DS0061+rip]
	call	AddLineQueueX@PLT
	jmp	$_789

$_788:	mov	r8d, dword ptr [rdi+0xC]
	mov	edx, eax
	lea	rcx, [DS0061+rip]
	call	AddLineQueueX@PLT
$_789:	jmp	$_791

$_790:	test	byte ptr [rbp-0x8D9], 0x31
	jz	$_791
	mov	r8d, dword ptr [rbp-0x30]
	mov	edx, dword ptr [rbp-0x2C]
	mov	rcx, qword ptr [rbp-0x10]
	call	$_055
$_791:	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
	call	RunLineQueue@PLT
	mov	rcx, qword ptr [rbp-0x8C8]
	test	rcx, rcx
	jz	$_792
	cmp	qword ptr [rcx+0x68], 0
	jz	$_792
	mov	rdx, qword ptr [rcx+0x68]
	mov	qword ptr [rdx], rsi
$_792:	xor	eax, eax
$_793:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret


.SECTION .data
	.ALIGN	16

size_vararg:
	.int   0x00000000

simd_scratch:
	.int   0x00000000

wreg_scratch:
	.int   0x00000000

DS0000:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x72, 0x73, 0x70
	.byte  0x2C, 0x20, 0x25, 0x64, 0x00

DS0001:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x72, 0x73, 0x70
	.byte  0x2C, 0x20, 0x38, 0x00

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

DS0003:
	.byte  0x73, 0x65, 0x67, 0x20, 0x00

DS0004:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x75
	.byte  0x0A, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25
	.byte  0x75, 0x00

DS0005:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x72
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x25, 0x73, 0x5B
	.byte  0x25, 0x75, 0x5D, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x20, 0x70, 0x74, 0x72
	.byte  0x20, 0x25, 0x73, 0x5B, 0x30, 0x5D, 0x00

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

DS0007:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x75, 0x0A, 0x20, 0x25, 0x72, 0x20
	.byte  0x5B, 0x25, 0x72, 0x5D, 0x2C, 0x20, 0x25, 0x72
	.byte  0x00

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

DS0009:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x31, 0x36, 0x00

DS000A:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x71, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20
	.byte  0x30, 0x00

DS000B:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x5B, 0x30
	.byte  0x5D, 0x2C, 0x20, 0x25, 0x75, 0x0A, 0x20, 0x6D
	.byte  0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F, 0x72, 0x64
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x5B, 0x34, 0x5D, 0x2C
	.byte  0x20, 0x25, 0x75, 0x00

DS000C:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x5B, 0x38
	.byte  0x5D, 0x2C, 0x20, 0x25, 0x75, 0x0A, 0x20, 0x6D
	.byte  0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F, 0x72, 0x64
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x5B, 0x31, 0x32, 0x5D
	.byte  0x2C, 0x20, 0x25, 0x75, 0x00

DS000D:
	.byte  0x20, 0x78, 0x6F, 0x72, 0x70, 0x73, 0x20, 0x25
	.byte  0x72, 0x2C, 0x20, 0x25, 0x72, 0x00

DS000E:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x61, 0x70, 0x73, 0x20
	.byte  0x25, 0x72, 0x2C, 0x20, 0x78, 0x6D, 0x6D, 0x77
	.byte  0x6F, 0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20
	.byte  0x25, 0x73, 0x00

DS000F:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x75, 0x00

DS0010:
	.byte  0x20, 0x25, 0x72, 0x20, 0x5B, 0x25, 0x72, 0x2B
	.byte  0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x72, 0x00

DS0011:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20
	.byte  0x25, 0x72, 0x20, 0x70, 0x74, 0x72, 0x20, 0x25
	.byte  0x73, 0x00

DS0012:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x72
	.byte  0x0A, 0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x2B, 0x25, 0x75, 0x5D, 0x2C
	.byte  0x20, 0x30, 0x00

DS0013:
	.byte  0x20, 0x78, 0x6F, 0x72, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x72, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x00

DS0014:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x30, 0x00

DS0015:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x72, 0x00

DS0016:
	.byte  0x20, 0x78, 0x6F, 0x72, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x72, 0x00

DS0017:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x72
	.byte  0x00

DS0018:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x2D, 0x31, 0x00

DS0019:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x75, 0x00

DS001A:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x6C, 0x75, 0x00

DS001B:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x72, 0x20, 0x70, 0x74, 0x72, 0x20
	.byte  0x25, 0x73, 0x5B, 0x25, 0x75, 0x5D, 0x00

DS001C:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x72
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x25, 0x73, 0x00

DS001D:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x71, 0x20, 0x25, 0x72
	.byte  0x2C, 0x20, 0x25, 0x72, 0x00

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

DS001F:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20
	.byte  0x25, 0x75, 0x00

DS0020:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x25, 0x73, 0x00

DS0021:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x64, 0x20, 0x25, 0x72
	.byte  0x2C, 0x20, 0x65, 0x61, 0x78, 0x00

DS0022:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x64
	.byte  0x00

DS0023:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x73
	.byte  0x00

DS0024:
	.byte  0x20, 0x63, 0x76, 0x74, 0x73, 0x73, 0x32, 0x73
	.byte  0x64, 0x20, 0x78, 0x6D, 0x6D, 0x30, 0x2C, 0x20
	.byte  0x25, 0x73, 0x00

DS0025:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x73, 0x64, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20
	.byte  0x78, 0x6D, 0x6D, 0x30, 0x00

DS0026:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x71, 0x20, 0x25, 0x72
	.byte  0x2C, 0x20, 0x78, 0x6D, 0x6D, 0x30, 0x00

DS0027:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x73, 0x00

DS0028:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20
	.byte  0x25, 0x73, 0x00

DS0029:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x73, 0x64, 0x20, 0x25
	.byte  0x72, 0x2C, 0x20, 0x25, 0x73, 0x00

DS002A:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x64, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20
	.byte  0x6C, 0x6F, 0x77, 0x33, 0x32, 0x28, 0x25, 0x73
	.byte  0x29, 0x0A, 0x20, 0x6D, 0x6F, 0x76, 0x20, 0x64
	.byte  0x77, 0x6F, 0x72, 0x64, 0x20, 0x70, 0x74, 0x72
	.byte  0x20, 0x5B, 0x25, 0x72, 0x2B, 0x25, 0x75, 0x2B
	.byte  0x34, 0x5D, 0x2C, 0x20, 0x68, 0x69, 0x67, 0x68
	.byte  0x33, 0x32, 0x28, 0x25, 0x73, 0x29, 0x00

DS002B:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x00

DS002C:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x20
	.byte  0x70, 0x74, 0x72, 0x20, 0x5B, 0x25, 0x72, 0x2B
	.byte  0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x73, 0x00

DS002D:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x68, 0x2C
	.byte  0x20, 0x30, 0x00

DS002E:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x30, 0x00

DS002F:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20
	.byte  0x25, 0x72, 0x20, 0x70, 0x74, 0x72, 0x20, 0x25
	.byte  0x73, 0x5B, 0x25, 0x75, 0x5D, 0x00

DS0030:
	.byte  0x20, 0x73, 0x68, 0x6C, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x31, 0x36, 0x0A, 0x20, 0x6D, 0x6F, 0x76
	.byte  0x20, 0x25, 0x72, 0x2C, 0x20, 0x77, 0x6F, 0x72
	.byte  0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x25, 0x73
	.byte  0x5B, 0x25, 0x75, 0x5D, 0x00

DS0031:
	.byte  0x20, 0x73, 0x68, 0x6C, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x38, 0x0A, 0x20, 0x6D, 0x6F, 0x76, 0x20
	.byte  0x25, 0x72, 0x2C, 0x20, 0x62, 0x79, 0x74, 0x65
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x25, 0x73, 0x00

DS0032:
	.byte  0x20, 0x6C, 0x65, 0x61, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x00

DS0033:
	.byte  0x20, 0x64, 0x62, 0x20, 0x36, 0x36, 0x68, 0x00

DS0034:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x6F, 0x66, 0x66, 0x73, 0x65, 0x74, 0x20
	.byte  0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73, 0x68
	.byte  0x20, 0x61, 0x78, 0x00

DS0035:
	.byte  0x20, 0x6C, 0x65, 0x61, 0x20, 0x72, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75
	.byte  0x73, 0x68, 0x20, 0x72, 0x61, 0x78, 0x00

DS0036:
	.byte  0x20, 0x25, 0x72, 0x20, 0x6F, 0x66, 0x66, 0x73
	.byte  0x65, 0x74, 0x20, 0x25, 0x73, 0x00

DS0037:
	.byte  0x20, 0x73, 0x75, 0x62, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x32, 0x00

DS0038:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x72
	.byte  0x20, 0x70, 0x74, 0x72, 0x20, 0x25, 0x73, 0x2B
	.byte  0x25, 0x75, 0x00

DS0039:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x73, 0x78, 0x20, 0x65
	.byte  0x61, 0x78, 0x2C, 0x20, 0x25, 0x73, 0x0A, 0x20
	.byte  0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x72, 0x00

DS003A:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x6C, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x00

DS003B:
	.byte  0x20, 0x78, 0x6F, 0x72, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x61, 0x78, 0x00

DS003C:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x6C, 0x2C
	.byte  0x20, 0x25, 0x73, 0x00

DS003D:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x6C, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x63, 0x62, 0x77
	.byte  0x00

DS003E:
	.byte  0x20, 0x63, 0x77, 0x64, 0x0A, 0x20, 0x70, 0x75
	.byte  0x73, 0x68, 0x20, 0x64, 0x78, 0x00

DS003F:
	.byte  0x20, 0x25, 0x72, 0x20, 0x65, 0x61, 0x78, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x25, 0x72, 0x00

DS0040:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75, 0x73
	.byte  0x68, 0x20, 0x72, 0x61, 0x78, 0x00

DS0041:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x77, 0x20, 0x30
	.byte  0x00

DS0042:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x73, 0x0A, 0x20, 0x70, 0x75
	.byte  0x73, 0x68, 0x20, 0x72, 0x61, 0x78, 0x00

DS0043:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x6C, 0x2C
	.byte  0x20, 0x62, 0x79, 0x74, 0x65, 0x20, 0x70, 0x74
	.byte  0x72, 0x20, 0x25, 0x73, 0x5B, 0x32, 0x5D, 0x0A
	.byte  0x20, 0x73, 0x68, 0x6C, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x31, 0x36, 0x0A, 0x20, 0x6D, 0x6F
	.byte  0x76, 0x20, 0x61, 0x78, 0x2C, 0x20, 0x77, 0x6F
	.byte  0x72, 0x64, 0x20, 0x70, 0x74, 0x72, 0x20, 0x25
	.byte  0x73, 0x0A, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20
	.byte  0x25, 0x72, 0x00

DS0044:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x25, 0x73, 0x0A, 0x20, 0x63, 0x64, 0x71
	.byte  0x0A, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x65
	.byte  0x64, 0x78, 0x0A, 0x20, 0x70, 0x75, 0x73, 0x68
	.byte  0x20, 0x65, 0x61, 0x78, 0x00

DS0045:
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x30, 0x0A
	.byte  0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x25, 0x73
	.byte  0x00

DS0046:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x25, 0x73, 0x0A, 0x20, 0x63, 0x77, 0x64
	.byte  0x0A, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20, 0x64
	.byte  0x78, 0x0A, 0x20, 0x70, 0x75, 0x73, 0x68, 0x20
	.byte  0x61, 0x78, 0x00

DS0047:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x72, 0x00

DS0048:
	.byte  0x20, 0x63, 0x64, 0x71, 0x0A, 0x20, 0x70, 0x75
	.byte  0x73, 0x68, 0x20, 0x65, 0x64, 0x78, 0x00

DS0049:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x73, 0x78, 0x20, 0x65
	.byte  0x61, 0x78, 0x2C, 0x20, 0x25, 0x73, 0x00

DS004A:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x68, 0x69, 0x67, 0x68, 0x77, 0x6F, 0x72
	.byte  0x64, 0x20, 0x28, 0x25, 0x73, 0x29, 0x00

DS004B:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x61, 0x78, 0x2C
	.byte  0x20, 0x6C, 0x6F, 0x77, 0x77, 0x6F, 0x72, 0x64
	.byte  0x20, 0x28, 0x25, 0x73, 0x29, 0x00

DS004C:
	.byte  0x20, 0x25, 0x72, 0x20, 0x28, 0x25, 0x73, 0x29
	.byte  0x20, 0x73, 0x68, 0x72, 0x20, 0x33, 0x32, 0x74
	.byte  0x00

DS004D:
	.byte  0x20, 0x25, 0x72, 0x20, 0x30, 0x78, 0x25, 0x78
	.byte  0x00

DS004E:
	.byte  0x20, 0x25, 0x72, 0x20, 0x48, 0x49, 0x47, 0x48
	.byte  0x33, 0x32, 0x20, 0x28, 0x30, 0x78, 0x25, 0x6C
	.byte  0x78, 0x29, 0x0A, 0x20, 0x25, 0x72, 0x20, 0x4C
	.byte  0x4F, 0x57, 0x33, 0x32, 0x20, 0x28, 0x30, 0x78
	.byte  0x25, 0x6C, 0x78, 0x29, 0x00

DS004F:
	.byte  0x20, 0x25, 0x72, 0x20, 0x30, 0x78, 0x25, 0x6C
	.byte  0x78, 0x00

DS0050:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x72, 0x61, 0x78
	.byte  0x2C, 0x20, 0x30, 0x78, 0x25, 0x6C, 0x78, 0x0A
	.byte  0x20, 0x25, 0x72, 0x20, 0x72, 0x61, 0x78, 0x00

DS0051:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x20, 0x28
	.byte  0x25, 0x73, 0x29, 0x00

DS0052:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x73, 0x00

DS0053:
	.byte  0x5F, 0x00

DS0054:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x64, 0x00

DS0055:
	.byte  0x20, 0x78, 0x6F, 0x72, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x65, 0x61, 0x78, 0x00

DS0056:
	.byte  0x20, 0x63, 0x61, 0x6C, 0x6C, 0x20, 0x00

DS0057:
	.byte  0x28, 0x20, 0x00

DS0058:
	.byte  0x5B, 0x25, 0x72, 0x2B, 0x25, 0x75, 0x5D, 0x00

DS0059:
	.byte  0x2E, 0x00

DS005A:
	.byte  0x2C, 0x20, 0x00

DS005B:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x5B, 0x65, 0x73
	.byte  0x70, 0x5D, 0x2C, 0x20, 0x65, 0x61, 0x78, 0x0A
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x5B, 0x65, 0x61, 0x78, 0x5D, 0x00

DS005C:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x72, 0x31, 0x30
	.byte  0x2C, 0x20, 0x5B, 0x72, 0x64, 0x69, 0x5D, 0x00

DS005D:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x72, 0x61, 0x78
	.byte  0x2C, 0x20, 0x5B, 0x72, 0x63, 0x78, 0x5D, 0x00

DS005E:
	.byte  0x20, 0x6C, 0x65, 0x61, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x73, 0x00

DS005F:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x25, 0x73, 0x00

DS0060:
	.byte  0x20, 0x6D, 0x6F, 0x76, 0x20, 0x65, 0x61, 0x78
	.byte  0x2C, 0x20, 0x5B, 0x25, 0x72, 0x5D, 0x00

DS0061:
	.byte  0x20, 0x61, 0x64, 0x64, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x25, 0x75, 0x00


.att_syntax prefix
