

.intel_syntax noprefix

.global sym_add_table
.global sym_remove_table
.global sym_ext2int
.global GetLangType
.global SizeFromRegister
.global SizeFromMemtype
.global MemtypeFromSize
.global OperandSize
.global set_frame
.global set_frame2
.global segm_override
.global idata_fixup
.global ParseLine
.global ProcessFile
.global SegOverride
.global SymTables

.extern NewDirective
.extern ProcType
.extern CRecordField
.extern imm2xmm
.extern mem2mem
.extern EnumDirective
.extern CurrEnum
.extern data_dir
.extern process_branch
.extern ExpandHllProcEx
.extern HandleIndirection
.extern ExpandLine
.extern RunLineQueue
.extern AddLineQueueX
.extern ProcessOperator
.extern GetOperator
.extern GetResWName
.extern RemoveResWord
.extern vex_flags
.extern opnd_clstab3
.extern opnd_clstab
.extern ResWordTable
.extern quad_resize
.extern EmitConstError
.extern EvalOperand
.extern PublicDirective
.extern AddPublicData
.extern omf_OutSelect
.extern StoreLine
.extern UseSavedState
.extern StoreState
.extern GetTextLine
.extern LstWrite
.extern LstWriteSrcLine
.extern Tokenize
.extern write_prologue
.extern RetInstr
.extern CurrProc
.extern ProcStatus
.extern GetOverrideAssume
.extern GetAssume
.extern StdAssumeTable
.extern SegAssumeTable
.extern GetGroup
.extern GetCurrOffset
.extern GetSymOfssize
.extern CreateLabel
.extern CurrStruct
.extern codegen
.extern PreprocessLine
.extern WritePreprocessedLine
.extern optable_idx
.extern SetFixupFrame
.extern CreateFixup
.extern Frame_Datum
.extern Frame_Type
.extern MemFree
.extern MemAlloc
.extern asmerr
.extern Options
.extern ModuleInfo
.extern Parse_Pass
.extern directive_tab
.extern SymFind
.extern tstrcat
.extern tstrcpy


.SECTION .text
	.ALIGN	16

sym_add_table:
	xor	eax, eax
	cmp	qword ptr [rcx], rax
	jnz	$_0001
	mov	qword ptr [rcx], rdx
	mov	qword ptr [rcx+0x8], rdx
	mov	qword ptr [rdx+0x80], rax
	mov	qword ptr [rdx+0x88], rax
	jmp	$_0002

$_0001: mov	rax, qword ptr [rcx+0x8]
	mov	qword ptr [rdx+0x88], rax
	mov	qword ptr [rax+0x80], rdx
	mov	qword ptr [rcx+0x8], rdx
	mov	qword ptr [rdx+0x80], 0
$_0002: ret

sym_remove_table:
	push	rbx
	push	rbp
	mov	rbp, rsp
	cmp	qword ptr [rdx+0x88], 0
	jz	$_0003
	mov	rax, qword ptr [rdx+0x80]
	mov	rbx, qword ptr [rdx+0x88]
	mov	qword ptr [rbx+0x80], rax
$_0003: cmp	qword ptr [rdx+0x80], 0
	jz	$_0004
	mov	rax, qword ptr [rdx+0x88]
	mov	rbx, qword ptr [rdx+0x80]
	mov	qword ptr [rbx+0x88], rax
$_0004: cmp	qword ptr [rcx], rdx
	jnz	$_0005
	mov	rax, qword ptr [rdx+0x80]
	mov	qword ptr [rcx], rax
$_0005: cmp	qword ptr [rcx+0x8], rdx
	jnz	$_0006
	mov	rax, qword ptr [rdx+0x88]
	mov	qword ptr [rcx+0x8], rax
$_0006: mov	qword ptr [rdx+0x80], 0
	mov	qword ptr [rdx+0x88], 0
	leave
	pop	rbx
	ret

sym_ext2int:
	mov	qword ptr [rsp+0x8], rcx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	test	byte ptr [rcx+0x10], 0x02
	jnz	$_0007
	test	byte ptr [rcx+0x10], 0x04
	jnz	$_0007
	or	byte ptr [rcx+0x10], 0x04
	call	AddPublicData@PLT
$_0007: mov	rdx, qword ptr [rbp+0x10]
	lea	rcx, [SymTables+0x10+rip]
	call	sym_remove_table
	mov	rcx, qword ptr [rbp+0x10]
	test	byte ptr [rcx+0x10], 0x02
	jnz	$_0008
	mov	dword ptr [rcx+0x48], 0
$_0008: mov	byte ptr [rcx+0x1D], 1
	leave
	ret

GetLangType:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	imul	eax, dword ptr [rcx], 32
	add	rdx, rax
	mov	rax, qword ptr [rdx+0x10]
	mov	eax, dword ptr [rax]
	or	al, 0x20
	cmp	byte ptr [rdx], 8
	jnz	$_0010
	cmp	ax, 99
	jnz	$_0010
	cmp	dword ptr [rdx-0x1C], 605
	jnz	$_0009
	cmp	byte ptr [rdx+0x20], 58
	jz	$_0010
$_0009: mov	byte ptr [rdx], 7
	mov	dword ptr [rdx+0x4], 343
	mov	byte ptr [rdx+0x1], 1
$_0010: cmp	byte ptr [rdx], 7
	jnz	$_0011
	cmp	dword ptr [rdx+0x4], 343
	jc	$_0011
	cmp	dword ptr [rdx+0x4], 352
	ja	$_0011
	inc	dword ptr [rcx]
	mov	al, byte ptr [rdx+0x1]
	mov	rcx, qword ptr [rbp+0x20]
	mov	byte ptr [rcx], al
	xor	eax, eax
	jmp	$_0012

$_0011: mov	rax, -1
$_0012: leave
	ret

SizeFromRegister:
	mov	eax, ecx
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8+0x4]
	and	eax, 0x7F
	jnz	$_0013
	mov	eax, ecx
	add	eax, eax
	test	byte ptr [r12+rax*8+0x3], 0x0C
	movzx	eax, byte ptr [r14+0x6]
	jnz	$_0013
	mov	eax, 4
	cmp	byte ptr [r14+0x4], 2
	jnz	$_0013
	mov	eax, 8
$_0013: ret

SizeFromMemtype:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	movzx	eax, cl
	cmp	al, 63
	jnz	$_0014
	mov	eax, 64
	jmp	$_0026

$_0014: and	ecx, 0x80
	jnz	$_0015
	and	eax, 0x1F
	inc	eax
	jmp	$_0026

$_0015: mov	ecx, edx
	cmp	ecx, 254
	jnz	$_0016
	movzx	ecx, byte ptr [r14+0x4]
$_0016: mov	edx, 2
	shl	edx, cl
	jmp	$_0025

$_0017: mov	eax, edx
	jmp	$_0026

$_0018: lea	eax, [rdx+0x2]
	jmp	$_0026

$_0019: mov	eax, edx
	mov	rcx, qword ptr [rbp+0x20]
	test	rcx, rcx
	jz	$_0020
	cmp	byte ptr [rcx+0x21], 0
	jz	$_0020
	add	eax, 2
$_0020: jmp	$_0026

$_0021: mov	eax, edx
	movzx	ecx, byte ptr [r14+0x15]
	mov	edx, 1
	shl	edx, cl
	and	edx, 0x68
	jz	$_0022
	add	eax, 2
$_0022: jmp	$_0026

$_0023: mov	rcx, qword ptr [rbp+0x20]
	test	rcx, rcx
	jz	$_0024
	mov	eax, dword ptr [rcx+0x60]
	jmp	$_0026

$_0024: xor	eax, eax
	jmp	$_0026

$_0025: cmp	eax, 129
	jz	$_0017
	cmp	eax, 130
	jz	$_0018
	cmp	eax, 128
	jz	$_0019
	cmp	eax, 195
	jz	$_0021
	cmp	eax, 196
	jz	$_0023
	jmp	$_0024

$_0026:
	leave
	ret

MemtypeFromSize:
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	eax, 269
	add	eax, eax
	lea	rax, [r12+rax*8]
$_0027: cmp	byte ptr [rax+0xD], 6
	jnz	$_0030
	mov	bl, byte ptr [rax+0xC]
	and	ebx, 0x80
	jnz	$_0029
	mov	bl, byte ptr [rax+0xC]
	cmp	bl, 63
	jz	$_0028
	and	ebx, 0x1F
$_0028: inc	ebx
	cmp	ebx, ecx
	jnz	$_0029
	mov	al, byte ptr [rax+0xC]
	mov	byte ptr [rdx], al
	xor	eax, eax
	jmp	$_0031

$_0029: add	rax, 16
	jmp	$_0027

$_0030: mov	rax, -1
$_0031: leave
	pop	rbx
	ret

OperandSize:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	jmp	$_0045

$_0032: xor	eax, eax
	jmp	$_0047

$_0033: mov	cl, byte ptr [rdx+0x8]
	xor	r8d, r8d
	movzx	edx, byte ptr [rdx+0x9]
	movzx	ecx, cl
	call	SizeFromMemtype
	jmp	$_0047

$_0034: mov	eax, 1
	jmp	$_0047

$_0035: mov	eax, 2
	jmp	$_0047

$_0036: mov	eax, 4
	jmp	$_0047

$_0037: mov	eax, 8
	jmp	$_0047

$_0038: mov	eax, 6
	jmp	$_0047

$_0039: mov	eax, 10
	jmp	$_0047

$_0040: mov	eax, 16
	jmp	$_0047

$_0041: mov	eax, 32
	jmp	$_0047

$_0042: mov	eax, 64
	jmp	$_0047

$_0043: mov	eax, 4
	cmp	byte ptr [rdx+0x9], 2
	jnz	$_0044
	mov	eax, 8
$_0044: jmp	$_0047

	jmp	$_0046

$_0045: test	ecx, ecx
	je	$_0032
	cmp	ecx, 4202240
	je	$_0033
	test	ecx, 0x10101
	jne	$_0034
	test	ecx, 0xC020202
	jne	$_0035
	test	ecx, 0x40404
	jne	$_0036
	test	ecx, 0x188808
	jne	$_0037
	test	ecx, 0x40200000
	jne	$_0038
	test	ecx, 0x30400000
	jne	$_0039
	test	ecx, 0x1010
	jne	$_0040
	test	ecx, 0x2020
	jne	$_0041
	test	ecx, 0x4040
	jne	$_0042
	test	ecx, 0x2000000
	jne	$_0043
$_0046: xor	eax, eax
$_0047: leave
	ret

$_0048:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	ecx, 12
	jnz	$_0051
	cmp	edx, 15
	jnz	$_0049
	xor	eax, eax
	jmp	$_0056

$_0049: cmp	edx, 16
	jnz	$_0050
	mov	eax, 1
	jmp	$_0056

$_0050: jmp	$_0055

$_0051: cmp	ecx, 14
	jnz	$_0054
	cmp	edx, 15
	jnz	$_0052
	mov	eax, 2
	jmp	$_0056

$_0052: cmp	edx, 16
	jnz	$_0053
	mov	eax, 3
	jmp	$_0056

$_0053: jmp	$_0055

$_0054: mov	ecx, 2030
	call	asmerr@PLT
	jmp	$_0056

$_0055: mov	ecx, 2029
	call	asmerr@PLT
$_0056: leave
	ret

$_0057:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	sub	rsp, 48
	test	rdx, rdx
	jz	$_0058
	cmp	byte ptr [rdx+0x1D], 0
	jnz	$_0058
	jmp	$_0064

$_0058: lea	r9, [rbp-0x10]
	mov	r8d, dword ptr [rbp+0x20]
	mov	rcx, qword ptr [SegOverride+rip]
	call	GetAssume@PLT
	mov	dword ptr [rbp-0x4], eax
	xor	edx, edx
	mov	rcx, qword ptr [rbp-0x10]
	call	SetFixupFrame@PLT
	mov	rdx, qword ptr [rbp+0x18]
	cmp	dword ptr [rbp-0x4], -2
	jnz	$_0063
	test	rdx, rdx
	jz	$_0061
	cmp	qword ptr [rdx+0x40], 0
	jz	$_0059
	mov	rdx, qword ptr [rdx+0x8]
	mov	ecx, 2074
	call	asmerr@PLT
	jmp	$_0060

$_0059: mov	rax, qword ptr [rbp+0x10]
	mov	ecx, dword ptr [rbp+0x20]
	mov	dword ptr [rax+0x1C], ecx
$_0060: jmp	$_0062

$_0061: mov	rdx, qword ptr [SegOverride+rip]
	mov	rdx, qword ptr [rdx+0x8]
	mov	ecx, 2074
	call	asmerr@PLT
$_0062: jmp	$_0064

$_0063: cmp	dword ptr [rbp+0x20], -2
	jz	$_0064
	mov	rax, qword ptr [rbp+0x10]
	mov	ecx, dword ptr [rbp-0x4]
	mov	dword ptr [rax+0x1C], ecx
$_0064: leave
	ret

$_0065:
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	rbx, rcx
	mov	ecx, edx
	mov	rax, qword ptr [rbx+0x68]
	movzx	eax, byte ptr [rax+0x2]
	and	eax, 0x07
	cmp	eax, 2
	je	$_0080
	cmp	eax, 3
	je	$_0080
	cmp	dword ptr [rbx+0x14], 808
	jnz	$_0067
	mov	dword ptr [rbx+0x1C], -2
	mov	rcx, qword ptr [SegOverride+rip]
	test	rcx, rcx
	jnz	$_0066
	mov	rcx, qword ptr [rbp+0x28]
$_0066: xor	edx, edx
	call	SetFixupFrame@PLT
	jmp	$_0080

$_0067: jmp	$_0070

$_0068: mov	dword ptr [rbp-0x4], 2
	jmp	$_0071

$_0069: mov	dword ptr [rbp-0x4], 3
	jmp	$_0071

$_0070: cmp	ecx, 14
	jz	$_0068
	cmp	ecx, 22
	jz	$_0068
	cmp	ecx, 21
	jz	$_0068
	jmp	$_0069

$_0071: cmp	dword ptr [rbx+0x1C], -2
	je	$_0077
	mov	ecx, dword ptr [rbx+0x1C]
	call	GetOverrideAssume@PLT
	cmp	qword ptr [rbp+0x28], 0
	jz	$_0073
	test	rax, rax
	jnz	$_0072
	mov	rax, qword ptr [rbp+0x28]
$_0072: xor	edx, edx
	mov	rcx, rax
	call	SetFixupFrame@PLT
	jmp	$_0076

$_0073: cmp	dword ptr [rbp+0x30], 0
	jz	$_0076
	test	rax, rax
	jz	$_0074
	mov	rcx, rax
	call	GetSymOfssize@PLT
	movzx	edx, al
	movzx	eax, byte ptr [rbx+0x9]
	test	al, al
	setne	al
	test	dl, dl
	setne	dl
	xor	al, dl
	shl	al, 6
	and	byte ptr [rbx+0x1], 0xBF
	or	byte ptr [rbx+0x1], al
	jmp	$_0076

$_0074: test	byte ptr [r14+0x2], 0x80
	jz	$_0075
	movzx	edx, byte ptr [ModuleInfo+0x4+rip]
	movzx	eax, byte ptr [rbx+0x9]
	test	al, al
	setne	al
	test	dl, dl
	setne	dl
	xor	al, dl
	shl	al, 6
	and	byte ptr [rbx+0x1], 0xBF
	or	byte ptr [rbx+0x1], al
	jmp	$_0076

$_0075: movzx	edx, byte ptr [ModuleInfo+0x5+rip]
	movzx	eax, byte ptr [rbx+0x9]
	test	al, al
	setne	al
	test	dl, dl
	setne	dl
	xor	al, dl
	shl	al, 6
	and	byte ptr [rbx+0x1], 0xBF
	or	byte ptr [rbx+0x1], al
$_0076: jmp	$_0079

$_0077: cmp	qword ptr [rbp+0x28], 0
	jnz	$_0078
	cmp	qword ptr [SegOverride+rip], 0
	jz	$_0079
$_0078: mov	r8d, dword ptr [rbp-0x4]
	mov	rdx, qword ptr [rbp+0x28]
	mov	rcx, rbx
	call	$_0057
$_0079: mov	eax, dword ptr [rbp-0x4]
	cmp	dword ptr [rbx+0x1C], eax
	jnz	$_0080
	mov	dword ptr [rbx+0x1C], -2
$_0080: leave
	pop	rbx
	ret

set_frame:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rax, qword ptr [SegOverride+rip]
	test	rax, rax
	jz	$_0081
	mov	rcx, rax
$_0081: xor	edx, edx
	call	SetFixupFrame@PLT
	leave
	ret

set_frame2:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rax, qword ptr [SegOverride+rip]
	test	rax, rax
	jz	$_0082
	mov	rcx, rax
$_0082: mov	edx, 1
	call	SetFixupFrame@PLT
	leave
	ret

$_0083:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	byte ptr [rbp-0x6], 0
	mov	byte ptr [rbp-0x9], 0
	mov	byte ptr [rbp-0xA], 0
	mov	byte ptr [rbp-0xB], 0
	mov	byte ptr [rbp-0xC], 0
	mov	rsi, rcx
	mov	edi, r9d
	mov	ecx, dword ptr [rbp+0x48]
	imul	ebx, edx, 24
	cmp	ecx, 195
	jnz	$_0084
	or	byte ptr [rsi], 0x80
$_0084: mov	al, 64
	cmp	qword ptr [rsi+rbx+0x28], 0
	jz	$_0085
	mov	al, 128
	jmp	$_0089

$_0085: cmp	dword ptr [rsi+rbx+0x30], 0
	jz	$_0086
	cmp	ecx, 195
	jnz	$_0087
$_0086: mov	al, 0
	jmp	$_0089

$_0087: cmp	dword ptr [rsi+rbx+0x30], 127
	jg	$_0088
	cmp	dword ptr [rsi+rbx+0x30], -128
	jge	$_0089
$_0088: mov	al, 128
$_0089: mov	byte ptr [rbp-0x5], al
	cmp	edi, -2
	jne	$_0099
	cmp	ecx, -2
	jne	$_0099
	or	byte ptr [rsi], 0x02
	mov	byte ptr [rbp-0x5], 0
	mov	r9d, 1
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, 28
	mov	rcx, rsi
	call	$_0065
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_0090
	test	byte ptr [rsi+0x1], 0x40
	jz	$_0091
$_0090: cmp	byte ptr [rsi+0x9], 1
	jnz	$_0096
	test	byte ptr [rsi+0x1], 0x40
	jz	$_0096
$_0091: cmp	dword ptr [rsi+rbx+0x30], 65535
	jg	$_0092
	cmp	dword ptr [rsi+rbx+0x30], -65535
	jge	$_0094
$_0092: mov	byte ptr [rbp-0x6], 5
	xor	byte ptr [rsi+0x1], 0x40
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0093
	mov	ecx, 7009
	call	asmerr@PLT
$_0093: jmp	$_0095

$_0094: mov	byte ptr [rbp-0x6], 6
$_0095: jmp	$_0098

$_0096: mov	byte ptr [rbp-0x6], 5
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0098
	mov	rax, qword ptr [rsi+rbx+0x28]
	test	rax, rax
	jnz	$_0097
	mov	byte ptr [rbp-0x6], 4
	mov	byte ptr [rsi+0xB], 37
	jmp	$_0098

$_0097: cmp	byte ptr [rax+0x18], 6
	jnz	$_0098
	mov	byte ptr [rax+0x18], 3
$_0098: jmp	$_0134

$_0099: cmp	edi, -2
	jne	$_0113
	cmp	ecx, -2
	je	$_0113
	jmp	$_0111

$_0100: mov	byte ptr [rbp-0x6], 4
	jmp	$_0112

$_0101: mov	byte ptr [rbp-0x6], 5
	jmp	$_0112

$_0102: mov	byte ptr [rbp-0x6], 6
	cmp	byte ptr [rbp-0x5], 0
	jnz	$_0103
	cmp	ecx, 195
	jz	$_0103
	mov	byte ptr [rbp-0x5], 64
$_0103: jmp	$_0112

$_0104: mov	byte ptr [rbp-0x6], 7
	jmp	$_0112

$_0105: mov	byte ptr [rbp-0x7], 5
	cmp	ecx, 195
	jz	$_0106
	mov	eax, ecx
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x7], al
$_0106: cmp	byte ptr [rbp-0x7], 15
	jbe	$_0108
	mov	eax, ecx
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x0F
	jz	$_0107
	or	byte ptr [rsi+0x1], 0x10
$_0107: mov	byte ptr [rbp-0xC], 16
	and	byte ptr [rbp-0x7], 0x0F
$_0108: mov	al, byte ptr [rbp-0x7]
	shr	al, 3
	mov	byte ptr [rbp-0x9], al
	and	byte ptr [rbp-0x7], 0x07
	mov	al, byte ptr [rbp-0x7]
	mov	byte ptr [rbp-0x6], al
	cmp	byte ptr [rbp-0x7], 4
	jnz	$_0109
	mov	byte ptr [rsi+0xB], 36
	jmp	$_0110

$_0109: cmp	byte ptr [rbp-0x7], 5
	jnz	$_0110
	cmp	byte ptr [rbp-0x5], 0
	jnz	$_0110
	cmp	ecx, 195
	jz	$_0110
	mov	byte ptr [rbp-0x5], 64
$_0110: mov	al, byte ptr [rbp-0x9]
	mov	byte ptr [rbp-0xB], al
	jmp	$_0112

$_0111: cmp	ecx, 15
	je	$_0100
	cmp	ecx, 16
	je	$_0101
	cmp	ecx, 14
	je	$_0102
	cmp	ecx, 12
	je	$_0104
	jmp	$_0105

$_0112: xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, ecx
	mov	rcx, rsi
	call	$_0065
	jmp	$_0134

$_0113: cmp	edi, -2
	je	$_0119
	cmp	ecx, -2
	jne	$_0119
	mov	eax, edi
	add	eax, eax
	mov	ebx, dword ptr [r12+rax*8]
	mov	eax, edi
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x8], al
	cmp	al, 15
	jbe	$_0115
	test	ebx, 0xF
	jz	$_0114
	or	byte ptr [rsi+0x1], 0x10
$_0114: mov	byte ptr [rbp-0xC], 32
	and	al, 0x0F
$_0115: shr	al, 3
	shl	al, 1
	mov	byte ptr [rbp-0xB], al
	and	byte ptr [rbp-0x8], 0x07
	mov	byte ptr [rbp-0x5], 0
	mov	byte ptr [rbp-0x6], 4
	mov	al, byte ptr [rbp-0x8]
	shl	al, 3
	or	al, byte ptr [rbp+0x38]
	or	al, 0x05
	mov	byte ptr [rsi+0xB], al
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, 28
	mov	rcx, rsi
	call	$_0065
	mov	rax, qword ptr [rsi+0x68]
	test	byte ptr [rax+0x4], 0x20
	jz	$_0118
	mov	eax, edi
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	test	ebx, 0x60
	jz	$_0117
	or	al, 0x40
	test	ebx, 0x40
	jz	$_0116
	or	byte ptr [rsi+0xF], 0x08
	jmp	$_0117

$_0116: or	byte ptr [rsi+0xF], 0x04
$_0117: mov	byte ptr [rsi+0xC], al
$_0118: jmp	$_0134

$_0119: mov	ebx, ecx
	mov	eax, ebx
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8]
	mov	eax, edi
	add	eax, eax
	mov	edx, dword ptr [r12+rax*8]
	mov	byte ptr [rbp-0x7], 5
	cmp	ebx, 195
	jz	$_0121
	mov	eax, ebx
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x7], al
	cmp	al, 15
	jbe	$_0121
	test	ecx, 0xF
	jz	$_0120
	or	byte ptr [rsi+0x1], 0x10
$_0120: mov	byte ptr [rbp-0xC], 16
	and	byte ptr [rbp-0x7], 0x0F
$_0121: mov	eax, edi
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x8], al
	cmp	al, 15
	jbe	$_0123
	test	edx, 0xF
	jz	$_0122
	or	byte ptr [rsi+0x1], 0x10
$_0122: or	byte ptr [rbp-0xC], 0x20
	and	byte ptr [rbp-0x8], 0x0F
$_0123: mov	al, byte ptr [rbp-0x7]
	shr	al, 3
	mov	byte ptr [rbp-0x9], al
	mov	al, byte ptr [rbp-0x8]
	shr	al, 3
	mov	byte ptr [rbp-0xA], al
	and	byte ptr [rbp-0x7], 0x07
	mov	eax, ebx
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8+0x4]
	mov	eax, edi
	add	eax, eax
	and	ecx, dword ptr [r12+rax*8+0x4]
	and	ecx, 0x7F
	test	ecx, ecx
	jnz	$_0127
	mov	rcx, qword ptr [rsi+0x68]
	test	edx, 0x70
	jz	$_0126
	test	byte ptr [rcx+0x4], 0x20
	jz	$_0126
	mov	eax, edi
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rsi+0xC], al
	test	edx, 0x60
	jz	$_0125
	or	byte ptr [rsi+0xC], 0x40
	test	edx, 0x40
	jz	$_0124
	or	byte ptr [rsi+0xF], 0x08
	jmp	$_0125

$_0124: or	byte ptr [rsi+0xF], 0x04
$_0125: jmp	$_0127

$_0126: mov	ecx, 2082
	call	asmerr@PLT
	jmp	$_0138

$_0127: and	byte ptr [rbp-0x8], 0x07
	jmp	$_0133

$_0128: mov	edx, ebx
	mov	ecx, edi
	call	$_0048
	cmp	eax, -1
	je	$_0138
	mov	byte ptr [rbp-0x6], al
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, edi
	mov	rcx, rsi
	call	$_0065
	jmp	$_0134

$_0129: mov	edx, edi
	mov	ecx, ebx
	call	$_0048
	cmp	eax, -1
	je	$_0138
	mov	byte ptr [rbp-0x6], al
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0065
	jmp	$_0134

$_0130: mov	ecx, 2032
	call	asmerr@PLT
	jmp	$_0138

$_0131: cmp	byte ptr [rbp-0x7], 5
	jnz	$_0132
	cmp	ebx, 195
	jz	$_0132
	cmp	byte ptr [rbp-0x5], 0
	jnz	$_0132
	mov	byte ptr [rbp-0x5], 64
$_0132: or	byte ptr [rbp-0x6], 0x04
	mov	al, byte ptr [rbp-0x8]
	shl	al, 3
	or	al, byte ptr [rbp+0x38]
	or	al, byte ptr [rbp-0x7]
	mov	byte ptr [rsi+0xB], al
	mov	al, byte ptr [rbp-0xA]
	shl	al, 1
	add	al, byte ptr [rbp-0x9]
	mov	byte ptr [rbp-0xB], al
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x50]
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0065
	jmp	$_0134

$_0133: cmp	edi, 12
	je	$_0128
	cmp	edi, 14
	je	$_0128
	cmp	edi, 15
	je	$_0129
	cmp	edi, 16
	je	$_0129
	cmp	edi, 167
	je	$_0130
	cmp	edi, 195
	je	$_0130
	cmp	edi, 21
	je	$_0130
	jmp	$_0131

$_0134: cmp	dword ptr [rbp+0x48], 195
	jnz	$_0135
	and	byte ptr [rbp-0x5], 0x07
$_0135: cmp	dword ptr [rbp+0x30], 1
	jnz	$_0136
	mov	al, byte ptr [rbp-0x6]
	shl	al, 3
	mov	cl, byte ptr [rsi+0xA]
	and	cl, 0x07
	or	al, byte ptr [rbp-0x5]
	or	al, cl
	mov	byte ptr [rsi+0xA], al
	mov	al, byte ptr [rbp-0xB]
	mov	cl, al
	mov	dl, al
	shr	al, 2
	and	cl, 0x02
	and	dl, 0x01
	shl	dl, 2
	or	al, cl
	or	al, dl
	or	byte ptr [rsi+0x2], al
	mov	al, byte ptr [rbp-0xC]
	mov	cl, al
	mov	dl, al
	and	al, 0x40
	and	dl, 0x10
	and	cl, 0x20
	shr	al, 2
	shl	dl, 2
	or	al, cl
	or	al, dl
	or	byte ptr [rsi+0x3], al
	jmp	$_0137

$_0136: cmp	dword ptr [rbp+0x30], 0
	jnz	$_0137
	mov	al, byte ptr [rbp-0x5]
	or	al, byte ptr [rbp-0x6]
	mov	byte ptr [rsi+0xA], al
	mov	al, byte ptr [rbp-0xB]
	or	byte ptr [rsi+0x2], al
	mov	al, byte ptr [rbp-0xC]
	or	byte ptr [rsi+0x3], al
$_0137: xor	eax, eax
$_0138: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

segm_override:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, qword ptr [rbp+0x30]
	mov	rdi, qword ptr [rcx+0x30]
	test	rdi, rdi
	je	$_0145
	cmp	byte ptr [rdi], 2
	jnz	$_0142
	mov	eax, dword ptr [rdi+0x4]
	add	eax, eax
	movzx	ebx, byte ptr [r12+rax*8+0xC]
	imul	eax, ebx, 16
	lea	rcx, [SegAssumeTable+rip]
	cmp	byte ptr [rcx+rax+0x8], 0
	jz	$_0139
	mov	ecx, 2108
	call	asmerr@PLT
	jmp	$_0146

$_0139: test	rsi, rsi
	jz	$_0140
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0140
	cmp	ebx, 4
	jnc	$_0140
	mov	ecx, 2202
	call	asmerr@PLT
	jmp	$_0146

$_0140: mov	ecx, ebx
	call	GetOverrideAssume@PLT
	test	rsi, rsi
	jz	$_0141
	mov	ecx, dword ptr [rsi+0x1C]
	mov	dword ptr [LastRegOverride+rip], ecx
	mov	dword ptr [rsi+0x1C], ebx
$_0141: jmp	$_0143

$_0142: mov	rcx, qword ptr [rdi+0x10]
	call	SymFind@PLT
$_0143: test	rax, rax
	jz	$_0145
	cmp	byte ptr [rax+0x1D], 4
	jz	$_0144
	cmp	byte ptr [rax+0x1D], 3
	jnz	$_0145
$_0144: mov	qword ptr [SegOverride+rip], rax
$_0145: xor	eax, eax
$_0146: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0147:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	dword ptr [rbp-0xC], 0
	mov	rsi, rcx
	mov	rdi, r8
	imul	ebx, dword ptr [rbp+0x30], 24
	cmp	dword ptr [rsi+0x14], 628
	jc	$_0148
	cmp	dword ptr [rsi+0x14], 677
	ja	$_0148
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp+0x28]
	call	process_branch@PLT
	jmp	$_0199

$_0148: movzx	edx, byte ptr [rdi+0x44]
	test	edx, 0x20
	je	$_0155
	and	edx, 0x1F
	inc	edx
	mov	eax, 4
	mov	ecx, dword ptr [rsi+0x14]
	jmp	$_0153

$_0149: mov	eax, 8
	mov	dword ptr [rbp-0xC], 8
	jmp	$_0154

$_0150: cmp	edx, 1
	jnz	$_0152
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0151
	test	byte ptr [rsi+0x20], 0x08
	jz	$_0151
	mov	eax, 8
	jmp	$_0152

$_0151: test	byte ptr [rsi+0x20], 0x02
	jz	$_0152
	mov	eax, 2
$_0152: jmp	$_0154

$_0153: cmp	ecx, 1034
	jz	$_0149
	cmp	ecx, 1058
	jz	$_0149
	cmp	ecx, 1050
	jz	$_0149
	cmp	ecx, 1038
	jz	$_0149
	cmp	ecx, 709
	jz	$_0149
	cmp	ecx, 1130
	jz	$_0149
	cmp	ecx, 1101
	jz	$_0149
	cmp	ecx, 1227
	jz	$_0149
	cmp	ecx, 779
	jz	$_0150
$_0154: cmp	eax, edx
	jz	$_0155
	cmp	edx, 16
	jnz	$_0155
	mov	edx, eax
	mov	rcx, rdi
	call	quad_resize@PLT
$_0155: mov	eax, dword ptr [rdi]
	mov	dword ptr [rbp-0x8], eax
	mov	dword ptr [rsi+rbx+0x30], eax
	cmp	dword ptr [rdi+0x8], 0
	jnz	$_0156
	cmp	dword ptr [rdi+0xC], 0
	jz	$_0157
$_0156: call	EmitConstError@PLT
	jmp	$_0199

$_0157: mov	edx, dword ptr [rdi+0x4]
	xor	ecx, ecx
	add	eax, -2147483648
	adc	edx, 0
	test	edx, edx
	seta	cl
	cmp	dword ptr [rbp-0xC], 0
	jnz	$_0158
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0159
	cmp	dword ptr [rsi+0x14], 779
	jnz	$_0159
	cmp	dword ptr [rbp+0x30], 1
	jnz	$_0159
	test	byte ptr [rsi+0x20], 0x08
	jz	$_0159
	test	ecx, ecx
	jnz	$_0158
	test	byte ptr [rdi+0x40], 0x02
	jz	$_0159
	cmp	byte ptr [rdi+0x44], 7
	jz	$_0158
	cmp	byte ptr [rdi+0x44], 71
	jnz	$_0159
$_0158: mov	dword ptr [rsi+rbx+0x20], 524288
	mov	eax, dword ptr [rdi+0x4]
	mov	dword ptr [rsi+rbx+0x34], eax
	xor	eax, eax
	jmp	$_0199

$_0159: cmp	dword ptr [rdi+0x4], 0
	jle	$_0162
	cmp	byte ptr [rsi+0x9], 1
	jc	$_0161
	cmp	dword ptr [rbp+0x30], 1
	jnz	$_0161
	cmp	dword ptr [rsi+0x20], 2048
	jnz	$_0161
	cmp	dword ptr [rsi+0x14], 1101
	jz	$_0160
	cmp	byte ptr [rsi+0x8], 193
	jnz	$_0161
	cmp	dword ptr [rsi+0x14], 779
	jz	$_0160
	cmp	dword ptr [rsi+0x14], 682
	jnz	$_0161
$_0160: mov	dword ptr [rsi+rbx+0x20], 524288
	mov	eax, dword ptr [rdi+0x4]
	mov	dword ptr [rsi+rbx+0x34], eax
	xor	eax, eax
	jmp	$_0199

$_0161: call	EmitConstError@PLT
	jmp	$_0199

$_0162: test	byte ptr [rdi+0x40], 0x02
	je	$_0170
	or	byte ptr [rsi], 0x08
	mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rdi+0x46]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype
	jmp	$_0168

$_0163: mov	dword ptr [rbp-0x4], 65536
	jmp	$_0169

$_0164: mov	dword ptr [rbp-0x4], 131072
	jmp	$_0169

$_0165: mov	dword ptr [rbp-0x4], 262144
	jmp	$_0169

$_0166: cmp	byte ptr [rsi+0x9], 2
	jnz	$_0167
	cmp	byte ptr [rdi+0x44], 39
	jnz	$_0167
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_0167
	cmp	dword ptr [rdi+0x4], 0
	jnz	$_0167
	mov	dword ptr [rbp-0x4], 524288
	mov	dword ptr [rsi+rbx+0x34], 0
	jmp	$_0169

$_0167: mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0199

	jmp	$_0169

$_0168: cmp	rax, 1
	jz	$_0163
	cmp	rax, 2
	jz	$_0164
	cmp	rax, 4
	jz	$_0165
	cmp	rax, 8
	jz	$_0166
	jmp	$_0167

$_0169: jmp	$_0173

$_0170: movsx	eax, byte ptr [rbp-0x8]
	cmp	eax, dword ptr [rbp-0x8]
	jnz	$_0171
	mov	dword ptr [rbp-0x4], 65536
	jmp	$_0173

$_0171: cmp	dword ptr [rbp-0x8], 65535
	jg	$_0172
	cmp	dword ptr [rbp-0x8], -65535
	jl	$_0172
	mov	dword ptr [rbp-0x4], 131072
	jmp	$_0173

$_0172: mov	dword ptr [rbp-0x4], 262144
$_0173: mov	eax, dword ptr [rsi+0x14]
	jmp	$_0196

$_0174: cmp	dword ptr [rdi+0x4], 0
	jne	$_0197
	test	byte ptr [r14+0x1], 0x08
	jne	$_0197
	mov	edx, dword ptr [rsi+0x20]
	test	byte ptr [rdi+0x40], 0x02
	jne	$_0187
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0187
	cmp	edx, 512
	jz	$_0175
	cmp	edx, 1024
	jz	$_0175
	cmp	edx, 2048
	jne	$_0187
$_0175: sub	rdi, 104
	mov	byte ptr [rsi+0x2], 0
	cmp	dword ptr [rbp-0x4], 65536
	jnz	$_0176
	mov	byte ptr [rdi+0x44], 0
	jmp	$_0186

$_0176: mov	eax, dword ptr [rdi+0x68]
	xor	ecx, ecx
	jmp	$_0180

$_0177: inc	ecx
	shr	eax, 8
$_0178: inc	ecx
	shr	eax, 8
$_0179: inc	ecx
	shr	eax, 8
	jmp	$_0184

$_0180: cmp	edx, 512
	jz	$_0181
	test	eax, 0xFFFFFF
	jz	$_0177
$_0181: cmp	edx, 512
	jz	$_0182
	test	eax, 0xFF00FFFF
	jz	$_0178
$_0182: cmp	edx, 512
	jz	$_0183
	test	eax, 0xFFFF00FF
	jz	$_0179
$_0183: cmp	edx, 512
	jnz	$_0184
	test	eax, 0xFF
	jz	$_0179
$_0184: test	ecx, ecx
	jz	$_0185
	mov	dword ptr [rbp-0x4], 65536
	mov	byte ptr [rdi+0x44], 0
	add	dword ptr [rdi], ecx
	adc	dword ptr [rdi+0x4], 0
	mov	dword ptr [rsi+rbx+0x30], eax
	mov	dword ptr [rdi+0x68], eax
	jmp	$_0186

$_0185: cmp	edx, 2048
	jnz	$_0186
	mov	dword ptr [rbp-0x4], 262144
	mov	byte ptr [rdi+0x44], 3
$_0186: xor	r9d, r9d
	mov	r8, rdi
	xor	edx, edx
	mov	rcx, rsi
	call	$_0331
$_0187: jmp	$_0197

$_0188: test	byte ptr [rdi+0x40], 0x02
	jnz	$_0189
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0189
	cmp	dword ptr [rbp-0x4], 131072
	jnz	$_0189
	mov	dword ptr [rbp-0x4], 262144
$_0189: cmp	dword ptr [rbp-0x4], 131072
	jnz	$_0190
	movzx	eax, byte ptr [rsi+0x9]
	test	eax, eax
	setne	al
	shl	al, 5
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], al
	jmp	$_0191

$_0190: cmp	dword ptr [rbp-0x4], 262144
	jnz	$_0191
	movzx	eax, byte ptr [rsi+0x9]
	test	eax, eax
	sete	al
	shl	al, 5
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], al
$_0191: jmp	$_0197

$_0192: cmp	dword ptr [rbp-0x4], 262144
	jz	$_0193
	mov	dword ptr [rbp-0x4], 131072
	movsx	eax, byte ptr [rbp-0x8]
	movsx	ecx, word ptr [rbp-0x8]
	cmp	eax, ecx
	jnz	$_0193
	mov	dword ptr [rbp-0x4], 65536
$_0193: jmp	$_0197

$_0194: cmp	dword ptr [rbp-0x4], 131072
	jnz	$_0195
	mov	dword ptr [rbp-0x4], 262144
$_0195: jmp	$_0197

$_0196: cmp	eax, 679
	je	$_0174
	cmp	eax, 834
	je	$_0174
	cmp	eax, 774
	je	$_0188
	cmp	eax, 776
	jz	$_0192
	cmp	eax, 738
	jz	$_0194
$_0197: cmp	dword ptr [rbp+0x30], 1
	jnz	$_0198
	test	byte ptr [rsi+0x8], 0x80
	jnz	$_0198
	test	byte ptr [rsi+0x8], 0x1F
	jz	$_0198
	or	byte ptr [rsi], 0x01
$_0198: mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rsi+rbx+0x20], eax
	xor	eax, eax
$_0199: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

idata_fixup:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	dword ptr [rbp-0x8], 0
	mov	rsi, rcx
	mov	rdi, r8
	imul	ebx, dword ptr [rbp+0x30], 24
	cmp	dword ptr [rsi+0x14], 628
	jc	$_0200
	cmp	dword ptr [rsi+0x14], 677
	ja	$_0200
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp+0x30]
	mov	rcx, rsi
	call	process_branch@PLT
	jmp	$_0287

$_0200: mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi+rbx+0x30], eax
	mov	rcx, qword ptr [rdi+0x50]
	cmp	byte ptr [rdi+0x46], 254
	jz	$_0201
	mov	al, byte ptr [rdi+0x46]
	mov	byte ptr [rbp-0xD], al
	jmp	$_0207

$_0201: test	rcx, rcx
	jnz	$_0203
	xor	edx, edx
	mov	rcx, rdi
	call	segm_override
	cmp	qword ptr [SegOverride+rip], 0
	jz	$_0202
	mov	rcx, qword ptr [SegOverride+rip]
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0xD], al
$_0202: jmp	$_0207

$_0203: cmp	byte ptr [rcx+0x1D], 3
	jz	$_0204
	cmp	byte ptr [rcx+0x1D], 4
	jz	$_0204
	cmp	dword ptr [rdi+0x38], 316
	jnz	$_0205
$_0204: mov	byte ptr [rbp-0xD], 0
	jmp	$_0207

$_0205: test	byte ptr [rdi+0x40], 0x04
	jz	$_0206
	mov	byte ptr [rbp-0xD], 0
	jmp	$_0207

$_0206: call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0xD], al
$_0207: cmp	dword ptr [rdi+0x38], 317
	jnz	$_0208
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0287

$_0208: test	byte ptr [rdi+0x40], 0x02
	jz	$_0209
	test	byte ptr [rdi+0x40], 0x04
	jnz	$_0209
	or	byte ptr [rsi], 0x08
	cmp	byte ptr [rsi+0x8], 192
	jnz	$_0209
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x8], al
$_0209: cmp	byte ptr [rsi+0x8], 192
	jne	$_0230
	cmp	dword ptr [rbp+0x30], 0
	jbe	$_0230
	cmp	byte ptr [rdi+0x46], 254
	jne	$_0230
	mov	rdx, rsi
	mov	ecx, dword ptr [rsi+0x20]
	call	OperandSize
	mov	ecx, dword ptr [rdi+0x38]
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_0216
	cmp	dword ptr [rdi+0x38], -2
	je	$_0216
	jmp	$_0215

$_0210: test	eax, eax
	jz	$_0211
	cmp	eax, 2
	jnc	$_0211
	mov	r8d, 2
	mov	edx, eax
	mov	ecx, 2022
	call	asmerr@PLT
	jmp	$_0287

$_0211: jmp	$_0216

$_0212: test	eax, eax
	jz	$_0214
	cmp	eax, 2
	jc	$_0213
	cmp	byte ptr [rbp-0xD], 0
	jz	$_0214
	cmp	eax, 4
	jnc	$_0214
$_0213: movzx	ecx, byte ptr [rbp-0xD]
	mov	edx, 2
	shl	edx, cl
	mov	r8d, edx
	mov	edx, eax
	mov	ecx, 2022
	call	asmerr@PLT
	jmp	$_0287

$_0214: jmp	$_0216

$_0215: cmp	ecx, 316
	jz	$_0210
	cmp	ecx, 313
	jz	$_0212
	cmp	ecx, 310
	jz	$_0212
	cmp	ecx, 303
	jz	$_0212
	cmp	ecx, 315
	jz	$_0212
$_0216: jmp	$_0229

$_0217: test	byte ptr [rdi+0x40], 0x04
	jnz	$_0218
	cmp	ecx, 306
	jz	$_0218
	cmp	ecx, 299
	jz	$_0218
	cmp	ecx, 307
	jz	$_0218
	cmp	ecx, 300
	jnz	$_0219
$_0218: mov	byte ptr [rsi+0x8], 0
$_0219: jmp	$_0230

$_0220: test	byte ptr [rdi+0x40], 0x04
	jnz	$_0221
	cmp	byte ptr [rsi+0x9], 0
	jz	$_0221
	cmp	ecx, 309
	jz	$_0221
	cmp	ecx, 302
	jnz	$_0222
$_0221: mov	byte ptr [rsi+0x8], 1
$_0222: jmp	$_0230

$_0223: mov	byte ptr [rsi+0x8], 3
	jmp	$_0230

$_0224: cmp	byte ptr [rbp-0xD], 2
	jnz	$_0228
	cmp	ecx, 326
	jz	$_0225
	cmp	ecx, 325
	jz	$_0225
	cmp	dword ptr [rsi+0x14], 779
	jnz	$_0226
	test	byte ptr [rsi+0x20], 0x08
	jz	$_0226
$_0225: mov	byte ptr [rsi+0x8], 7
	jmp	$_0228

$_0226: cmp	ecx, 308
	jz	$_0227
	cmp	ecx, 301
	jnz	$_0228
$_0227: mov	byte ptr [rsi+0x8], 3
$_0228: jmp	$_0230

$_0229: cmp	eax, 1
	je	$_0217
	cmp	eax, 2
	jz	$_0220
	cmp	eax, 4
	jz	$_0223
	cmp	eax, 8
	jz	$_0224
$_0230: cmp	byte ptr [rsi+0x8], 192
	jne	$_0253
	test	byte ptr [rdi+0x40], 0x04
	jz	$_0235
	cmp	byte ptr [rdi+0x44], 192
	jz	$_0231
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x8], al
	jmp	$_0234

$_0231: cmp	dword ptr [rsi+0x14], 776
	jnz	$_0232
	mov	byte ptr [rsi+0x8], 1
	jmp	$_0234

$_0232: mov	ecx, 1
	cmp	byte ptr [rsi+0x9], 0
	setne	al
	test	byte ptr [rsi+0x1], 0x20
	setne	ah
	xor	al, ah
	test	al, al
	jz	$_0233
	mov	ecx, 3
$_0233: mov	byte ptr [rsi+0x8], cl
$_0234: jmp	$_0253

$_0235: mov	eax, dword ptr [rsi+0x14]
	jmp	$_0247

$_0236: cmp	byte ptr [rdi+0x44], 192
	jnz	$_0241
	mov	eax, dword ptr [rdi+0x38]
	jmp	$_0240

$_0237: mov	byte ptr [rdi+0x44], 0
	jmp	$_0241

$_0238: mov	byte ptr [rdi+0x44], 1
	jmp	$_0241

$_0239: mov	byte ptr [rdi+0x44], 3
	jmp	$_0241

$_0240: cmp	eax, -2
	jz	$_0237
	cmp	eax, 306
	jz	$_0237
	cmp	eax, 299
	jz	$_0237
	cmp	eax, 307
	jz	$_0237
	cmp	eax, 300
	jz	$_0237
	cmp	eax, 309
	jz	$_0238
	cmp	eax, 302
	jz	$_0238
	cmp	eax, 308
	jz	$_0239
	cmp	eax, 303
	jz	$_0239
	cmp	eax, 315
	jz	$_0239
$_0241: cmp	byte ptr [rdi+0x44], 130
	jnz	$_0242
	test	byte ptr [rdi+0x40], 0x02
	jnz	$_0242
	mov	byte ptr [rdi+0x44], 129
$_0242: cmp	dword ptr [rsi+0x14], 776
	jnz	$_0245
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_0243
	cmp	byte ptr [rbp-0xD], 0
	jbe	$_0243
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_0243
	mov	ecx, 7009
	call	asmerr@PLT
$_0243: mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rbp-0xD]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype
	cmp	eax, 2
	jnc	$_0244
	mov	byte ptr [rdi+0x44], 1
$_0244: jmp	$_0246

$_0245: cmp	dword ptr [rsi+0x14], 738
	jnz	$_0246
	mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rbp-0xD]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype
	cmp	eax, 4
	jnc	$_0246
	mov	byte ptr [rdi+0x44], 3
$_0246: jmp	$_0248

$_0247: cmp	eax, 776
	je	$_0236
	cmp	eax, 738
	je	$_0236
	cmp	eax, 774
	je	$_0236
$_0248: mov	rcx, qword ptr [rdi+0x50]
	cmp	byte ptr [rdi+0x44], 192
	jz	$_0249
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x8], al
	jmp	$_0253

$_0249: cmp	byte ptr [rcx+0x1D], 0
	jnz	$_0250
	mov	byte ptr [rsi+0x8], 0
	mov	dword ptr [rbp-0x8], 6
	jmp	$_0253

$_0250: mov	eax, 1
	cmp	byte ptr [rbp-0xD], 2
	jnz	$_0251
	mov	eax, 7
	jmp	$_0252

$_0251: cmp	byte ptr [rbp-0xD], 1
	jnz	$_0252
	mov	eax, 3
$_0252: mov	byte ptr [rsi+0x8], al
$_0253: xor	r8d, r8d
	movzx	edx, byte ptr [rbp-0xD]
	movzx	ecx, byte ptr [rsi+0x8]
	call	SizeFromMemtype
	mov	dword ptr [rbp-0xC], eax
	jmp	$_0265

$_0254: mov	dword ptr [rsi+rbx+0x20], 65536
	and	byte ptr [rsi+0x1], 0xBF
	jmp	$_0266

$_0255: mov	dword ptr [rsi+rbx+0x20], 131072
	movzx	eax, byte ptr [rsi+0x9]
	test	eax, eax
	setne	al
	shl	al, 5
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], al
	jmp	$_0266

$_0256: mov	dword ptr [rsi+rbx+0x20], 262144
	movzx	eax, byte ptr [rsi+0x9]
	test	eax, eax
	sete	al
	shl	al, 5
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], al
	jmp	$_0266

$_0257: mov	al, byte ptr [rdi+0x44]
	and	eax, 0x1F
	xor	ecx, ecx
	mov	edx, dword ptr [rdi+0x4]
	cmp	edx, ecx
	jnz	$_0258
	cmp	dword ptr [rdi], 2147483647
$_0258: setg	cl
	cmp	edx, -1
	jnz	$_0259
	cmp	dword ptr [rdi], -2147483648
$_0259: setl	ch
	test	ecx, ecx
	jnz	$_0260
	test	byte ptr [rdi+0x40], 0x02
	jz	$_0261
	cmp	eax, 7
	jnz	$_0261
$_0260: mov	dword ptr [rsi+rbx+0x20], 524288
	mov	eax, dword ptr [rdi+0x4]
	mov	dword ptr [rsi+rbx+0x34], eax
	jmp	$_0264

$_0261: cmp	byte ptr [rbp-0xD], 2
	jnz	$_0263
	cmp	dword ptr [rdi+0x38], 313
	jz	$_0262
	cmp	dword ptr [rsi+0x14], 779
	jnz	$_0263
	test	byte ptr [rsi+0x20], 0x08
	jz	$_0263
$_0262: mov	dword ptr [rsi+rbx+0x20], 524288
	mov	eax, dword ptr [rdi+0x4]
	mov	dword ptr [rsi+rbx+0x34], eax
	jmp	$_0264

$_0263: mov	dword ptr [rsi+rbx+0x20], 262144
$_0264: movzx	eax, byte ptr [rsi+0x9]
	test	eax, eax
	sete	al
	shl	al, 5
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], al
	jmp	$_0266

$_0265: cmp	eax, 1
	je	$_0254
	cmp	eax, 2
	je	$_0255
	cmp	eax, 4
	je	$_0256
	cmp	eax, 8
	je	$_0257
$_0266: cmp	dword ptr [rdi+0x38], 316
	jnz	$_0267
	mov	dword ptr [rbp-0x4], 8
	jmp	$_0279

$_0267: cmp	byte ptr [rsi+0x8], 0
	jnz	$_0271
	cmp	dword ptr [rdi+0x38], 299
	jz	$_0268
	cmp	dword ptr [rdi+0x38], 300
	jnz	$_0269
$_0268: mov	dword ptr [rbp-0x4], 11
	jmp	$_0270

$_0269: mov	dword ptr [rbp-0x4], 4
$_0270: jmp	$_0279

$_0271: cmp	byte ptr [rsi+0x9], 0
	setne	al
	test	byte ptr [rsi+0x1], 0x20
	setne	ah
	xor	al, ah
	test	al, al
	jz	$_0278
	cmp	dword ptr [rsi+rbx+0x20], 524288
	jnz	$_0273
	cmp	dword ptr [rdi+0x38], -2
	jz	$_0272
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_0273
$_0272: mov	dword ptr [rbp-0x4], 7
	jmp	$_0277

$_0273: cmp	dword ptr [rbp-0xC], 4
	jl	$_0276
	cmp	dword ptr [rdi+0x38], 309
	jz	$_0276
	test	byte ptr [rdi+0x40], 0x02
	jz	$_0274
	cmp	byte ptr [rbp-0xD], 0
	jnz	$_0274
	cmp	byte ptr [rdi+0x44], 130
	jnz	$_0274
	mov	dword ptr [rbp-0x4], 9
	jmp	$_0275

$_0274: mov	dword ptr [rbp-0x4], 6
$_0275: jmp	$_0277

$_0276: mov	dword ptr [rbp-0x4], 5
$_0277: jmp	$_0279

$_0278: mov	dword ptr [rbp-0x4], 5
$_0279: cmp	dword ptr [rbp+0x30], 1
	jnz	$_0280
	cmp	dword ptr [rbp-0xC], 1
	jz	$_0280
	or	byte ptr [rsi], 0x01
$_0280: xor	edx, edx
	mov	rcx, rdi
	call	segm_override
	cmp	byte ptr [r14+0x17], 2
	jnz	$_0282
	cmp	dword ptr [rdi+0x38], 313
	jz	$_0281
	cmp	dword ptr [rdi+0x38], 316
	jnz	$_0282
$_0281: mov	rcx, qword ptr [rdi+0x50]
	call	set_frame2
	jmp	$_0283

$_0282: mov	rcx, qword ptr [rdi+0x50]
	call	set_frame
$_0283: mov	r8d, dword ptr [rbp-0x8]
	mov	edx, dword ptr [rbp-0x4]
	mov	rcx, qword ptr [rdi+0x50]
	call	CreateFixup@PLT
	mov	qword ptr [rsi+rbx+0x28], rax
	cmp	dword ptr [rdi+0x38], 310
	jnz	$_0284
	or	byte ptr [rax+0x1B], 0x01
$_0284: cmp	dword ptr [rdi+0x38], 303
	jnz	$_0285
	cmp	dword ptr [rbp-0x4], 6
	jnz	$_0285
	mov	byte ptr [rax+0x18], 12
$_0285: cmp	dword ptr [rdi+0x38], 315
	jnz	$_0286
	cmp	dword ptr [rbp-0x4], 6
	jnz	$_0286
	mov	byte ptr [rax+0x18], 13
$_0286: xor	eax, eax
$_0287: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0288:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	xor	ebx, ebx
	mov	rdx, qword ptr [rdi+0x50]
	cmp	qword ptr [rdi+0x58], 0
	jz	$_0289
	mov	rdx, qword ptr [rdi+0x58]
$_0289: test	byte ptr [rdi+0x40], 0x02
	jz	$_0292
	cmp	qword ptr [rdi+0x60], 0
	jz	$_0292
	mov	rcx, qword ptr [rdi+0x60]
	mov	ebx, dword ptr [rcx+0x60]
	cmp	byte ptr [rcx+0x21], 0
	jz	$_0290
	or	byte ptr [rsi], 0x04
	jmp	$_0291

$_0290: and	byte ptr [rsi], 0xFB
$_0291: jmp	$_0304

$_0292: test	rdx, rdx
	je	$_0302
	cmp	qword ptr [rdx+0x28], 0
	jz	$_0296
	mov	rcx, qword ptr [rdx+0x28]
	mov	ebx, dword ptr [rcx+0x60]
	cmp	byte ptr [rcx+0x21], 0
	jz	$_0293
	or	byte ptr [rsi], 0x04
	jmp	$_0294

$_0293: and	byte ptr [rsi], 0xFB
$_0294: mov	al, byte ptr [rcx+0x48]
	cmp	ebx, 4
	jnz	$_0295
	cmp	al, byte ptr [rsi+0x9]
	jz	$_0295
	mov	byte ptr [rdi+0x46], al
$_0295: jmp	$_0301

$_0296: cmp	byte ptr [rdx+0x1E], 195
	jnz	$_0299
	mov	ecx, 129
	cmp	byte ptr [rdx+0x21], 0
	jz	$_0297
	mov	ecx, 130
$_0297: mov	qword ptr [rbp-0x8], rdx
	xor	r8d, r8d
	movzx	edx, byte ptr [rdx+0x48]
	movzx	ecx, cl
	call	SizeFromMemtype
	mov	ebx, eax
	and	byte ptr [rsi], 0xFB
	mov	rdx, qword ptr [rbp-0x8]
	cmp	byte ptr [rdx+0x21], 0
	jz	$_0298
	or	byte ptr [rsi], 0x04
$_0298: jmp	$_0301

$_0299: test	byte ptr [rdx+0x10], 0x40
	jz	$_0300
	mov	ecx, dword ptr [rdx+0x68]
	mov	eax, dword ptr [rdx+0x60]
	xor	edx, edx
	div	ecx
	mov	ebx, eax
	jmp	$_0301

$_0300: mov	ebx, dword ptr [rdx+0x60]
$_0301: jmp	$_0304

$_0302: mov	cl, byte ptr [r14+0x15]
	mov	eax, 1
	shl	eax, cl
	test	cl, 0x68
	jz	$_0303
	mov	ebx, 2
$_0303: mov	cl, byte ptr [r14+0x5]
	mov	eax, 2
	shl	eax, cl
	add	ebx, eax
$_0304: test	ebx, ebx
	jz	$_0305
	lea	rdx, [rdi+0x44]
	mov	ecx, ebx
	call	MemtypeFromSize
$_0305: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0306:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, rcx
	cmp	dword ptr [rsi+0x14], 808
	jnz	$_0307
	jmp	$_0330

$_0307: movzx	eax, byte ptr [rbp+0x30]
	cmp	al, 192
	je	$_0330
	cmp	al, 196
	je	$_0330
	cmp	al, 129
	je	$_0330
	cmp	al, 130
	je	$_0330
	mov	byte ptr [rsi+0x8], al
	mov	rbx, qword ptr [rsi+0x68]
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0320
	cmp	al, 1
	jz	$_0308
	cmp	al, 65
	jnz	$_0309
$_0308: or	byte ptr [rsi+0x1], 0x20
	jmp	$_0319

$_0309: mov	ah, al
	and	al, 0xC0
	and	ah, 0x1F
	cmp	al, 128
	jnc	$_0319
	cmp	ah, 7
	jne	$_0319
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0318

$_0310: jmp	$_0319

$_0311: movzx	eax, byte ptr [rbx]
	lea	rcx, [opnd_clstab+rip]
	cmp	dword ptr [rcx+rax*8], 6323968
	je	$_0319
	test	byte ptr [rbx+0x3], 0x20
	jne	$_0319
	movzx	eax, byte ptr [rbx+0x3]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_0312
	xor	eax, eax
$_0312: test	eax, eax
	jz	$_0316
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0314

$_0313: or	byte ptr [rsi+0x2], 0x08
	jmp	$_0315

$_0314: cmp	eax, 1116
	jz	$_0313
	cmp	eax, 1117
	jz	$_0313
	cmp	eax, 1337
	jz	$_0313
	cmp	eax, 1338
	jz	$_0313
	cmp	eax, 1129
	jz	$_0313
	cmp	eax, 1526
	jz	$_0313
	cmp	eax, 1527
	jz	$_0313
	cmp	eax, 1601
	jz	$_0313
	cmp	eax, 1602
	jz	$_0313
	cmp	eax, 1547
	jz	$_0313
$_0315: jmp	$_0317

$_0316: or	byte ptr [rsi+0x2], 0x08
$_0317: jmp	$_0319

$_0318: cmp	eax, 774
	je	$_0310
	cmp	eax, 775
	je	$_0310
	cmp	eax, 791
	je	$_0310
	cmp	eax, 1428
	je	$_0310
	cmp	eax, 1429
	je	$_0310
	cmp	eax, 1430
	je	$_0310
	cmp	eax, 1431
	je	$_0310
	jmp	$_0311

$_0319: jmp	$_0330

$_0320: mov	ah, al
	and	al, 0xC0
	and	ah, 0x1F
	cmp	al, 128
	jnc	$_0325
	cmp	ah, 3
	jnz	$_0325
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0323

$_0321: jmp	$_0324

$_0322: or	byte ptr [rsi+0x1], 0x20
	jmp	$_0324

$_0323: cmp	eax, 728
	jz	$_0321
	cmp	eax, 729
	jz	$_0321
	cmp	eax, 810
	jz	$_0321
	cmp	eax, 811
	jz	$_0321
	cmp	eax, 812
	jz	$_0321
	cmp	eax, 628
	jz	$_0321
	cmp	eax, 629
	jz	$_0321
	jmp	$_0322

$_0324: jmp	$_0330

$_0325: mov	al, byte ptr [rbp+0x30]
	mov	ah, al
	and	al, 0xC0
	and	ah, 0x1F
	cmp	al, 128
	jnc	$_0330
	cmp	ah, 7
	jnz	$_0330
	movzx	eax, byte ptr [rbx]
	lea	rcx, [opnd_clstab+rip]
	cmp	dword ptr [rcx+rax*8], 6323968
	jnz	$_0326
	jmp	$_0330

$_0326: movzx	eax, byte ptr [rbx+0x3]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_0327
	xor	eax, eax
$_0327: test	byte ptr [rbx+0x3], 0x20
	jnz	$_0328
	test	rax, rax
	jz	$_0329
$_0328: jmp	$_0330

$_0329: cmp	dword ptr [rsi+0x14], 791
	jz	$_0330
	or	byte ptr [rsi+0x2], 0x08
$_0330: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0331:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 88
	mov	byte ptr [rbp-0x16], 0
	mov	rsi, rcx
	mov	rdi, r8
	imul	ebx, dword ptr [rbp+0x30], 24
	mov	rax, qword ptr [rdi]
	mov	qword ptr [rsi+rbx+0x30], rax
	mov	dword ptr [rsi+rbx+0x20], 4202240
	mov	rax, qword ptr [rdi+0x50]
	mov	qword ptr [rbp-0x8], rax
	mov	rdx, rsi
	mov	rcx, rdi
	call	segm_override
	mov	al, byte ptr [rdi+0x44]
	mov	ah, al
	and	ah, 0xC0
	cmp	al, 195
	jnz	$_0332
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_0288
	jmp	$_0334

$_0332: cmp	ah, 128
	jnz	$_0334
	cmp	byte ptr [rdi+0x46], 254
	jnz	$_0333
	cmp	qword ptr [rbp-0x8], 0
	jz	$_0333
	mov	rcx, qword ptr [rbp-0x8]
	call	GetSymOfssize@PLT
	mov	byte ptr [rdi+0x46], al
$_0333: mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rdi+0x46]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype
	mov	ecx, eax
	lea	rdx, [rdi+0x44]
	call	MemtypeFromSize
$_0334: movzx	edx, byte ptr [rdi+0x44]
	mov	rcx, rsi
	call	$_0306
	mov	rcx, qword ptr [rdi+0x58]
	test	rcx, rcx
	jz	$_0336
	cmp	byte ptr [rcx+0x1E], 196
	jnz	$_0335
	cmp	byte ptr [rdi+0x44], 192
	jnz	$_0335
	lea	rdx, [rbp-0x15]
	mov	ecx, dword ptr [rcx+0x60]
	call	MemtypeFromSize
	test	eax, eax
	jnz	$_0335
	movzx	edx, byte ptr [rbp-0x15]
	mov	rcx, rsi
	call	$_0306
$_0335: mov	rcx, qword ptr [rdi+0x58]
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_0336
	or	byte ptr [rsi], 0x40
$_0336: jmp	$_0348

$_0337: cmp	byte ptr [rsi+0x8], 192
	jnz	$_0341
	test	byte ptr [r14+0x2], 0x80
	jnz	$_0338
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_0338
	cmp	qword ptr [rdi+0x50], 0
	jnz	$_0338
	mov	ecx, 2023
	call	asmerr@PLT
	jmp	$_0440

$_0338: mov	eax, 1
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0339
	mov	eax, 7
	jmp	$_0340

$_0339: cmp	byte ptr [rsi+0x9], 1
	jnz	$_0340
	mov	eax, 3
$_0340: mov	byte ptr [rdi+0x44], al
	movzx	edx, al
	mov	rcx, rsi
	call	$_0306
$_0341: xor	r8d, r8d
	movzx	edx, byte ptr [rsi+0x9]
	movzx	ecx, byte ptr [rsi+0x8]
	call	SizeFromMemtype
	cmp	eax, 1
	jz	$_0342
	cmp	eax, 6
	jbe	$_0343
$_0342: cmp	byte ptr [rsi+0x9], 2
	jz	$_0343
	mov	ecx, 2024
	call	asmerr@PLT
	jmp	$_0440

$_0343: cmp	byte ptr [rdi+0x44], 130
	jz	$_0346
	cmp	byte ptr [rsi+0x8], 5
	jz	$_0346
	cmp	byte ptr [rsi+0x8], 9
	jnz	$_0344
	cmp	byte ptr [rsi+0x9], 2
	jz	$_0346
$_0344: cmp	byte ptr [rsi+0x8], 3
	jnz	$_0347
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_0345
	cmp	byte ptr [rdi+0x46], 1
	jnz	$_0346
$_0345: cmp	byte ptr [rsi+0x9], 1
	jnz	$_0347
	cmp	byte ptr [rdi+0x46], 0
	jnz	$_0347
$_0346: or	byte ptr [rsi], 0x04
$_0347: jmp	$_0349

$_0348: cmp	dword ptr [rsi+0x14], 629
	je	$_0337
	cmp	dword ptr [rsi+0x14], 628
	je	$_0337
$_0349: mov	al, byte ptr [rsi+0x8]
	and	eax, 0x80
	jne	$_0362
	mov	al, byte ptr [rsi+0x8]
	and	eax, 0x3F
	cmp	eax, 63
	jnz	$_0350
	mov	dword ptr [rsi+rbx+0x20], 16384
	jmp	$_0361

$_0350: mov	al, byte ptr [rsi+0x8]
	and	eax, 0x1F
	mov	ecx, dword ptr [rsi+rbx+0x20]
	jmp	$_0359

$_0351: mov	ecx, 256
	jmp	$_0360

$_0352: mov	ecx, 512
	jmp	$_0360

$_0353: mov	ecx, 1024
	jmp	$_0360

$_0354: mov	ecx, 2097152
	jmp	$_0360

$_0355: mov	ecx, 2048
	jmp	$_0360

$_0356: mov	ecx, 4194304
	jmp	$_0360

$_0357: mov	ecx, 4096
	jmp	$_0360

$_0358: mov	ecx, 8192
	jmp	$_0360

$_0359: cmp	eax, 0
	jz	$_0351
	cmp	eax, 1
	jz	$_0352
	cmp	eax, 3
	jz	$_0353
	cmp	eax, 5
	jz	$_0354
	cmp	eax, 7
	jz	$_0355
	cmp	eax, 9
	jz	$_0356
	cmp	eax, 15
	jz	$_0357
	cmp	eax, 31
	jz	$_0358
$_0360: mov	dword ptr [rsi+rbx+0x20], ecx
$_0361: jmp	$_0378

$_0362: cmp	byte ptr [rsi+0x8], 193
	jnz	$_0370
	mov	rdx, qword ptr [rdi+0x58]
	test	rdx, rdx
	jz	$_0369
	test	byte ptr [rdx+0x11], 0x40
	jz	$_0369
	mov	eax, dword ptr [rdx+0x60]
	mov	ecx, dword ptr [rsi+rbx+0x20]
	jmp	$_0367

$_0363: mov	ecx, 256
	jmp	$_0368

$_0364: mov	ecx, 512
	jmp	$_0368

$_0365: mov	ecx, 1024
	jmp	$_0368

$_0366: mov	ecx, 2048
	jmp	$_0368

$_0367: cmp	eax, 1
	jz	$_0363
	cmp	eax, 2
	jz	$_0364
	cmp	eax, 4
	jz	$_0365
	cmp	eax, 8
	jz	$_0366
$_0368: mov	dword ptr [rsi+rbx+0x20], ecx
$_0369: jmp	$_0378

$_0370: cmp	byte ptr [rsi+0x8], 192
	jnz	$_0378
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0377

$_0371: cmp	qword ptr [rdi+0x50], 0
	jnz	$_0372
	mov	ecx, 2023
	call	asmerr@PLT
	jmp	$_0440

$_0372: jmp	$_0378

$_0373: cmp	byte ptr [rdi+0x44], 196
	jnz	$_0374
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0440

$_0374: jmp	$_0378

$_0375: mov	edx, 1
	mov	rcx, rsi
	call	$_0306
	jmp	$_0378

$_0376: mov	edx, 3
	mov	rcx, rsi
	call	$_0306
	jmp	$_0378

$_0377: cmp	eax, 772
	jz	$_0371
	cmp	eax, 773
	jz	$_0371
	cmp	eax, 774
	jz	$_0373
	cmp	eax, 775
	jz	$_0373
	cmp	eax, 776
	jz	$_0375
	cmp	eax, 738
	jz	$_0376
$_0378: mov	rax, qword ptr [rdi+0x18]
	mov	ecx, 4294967294
	test	rax, rax
	jz	$_0379
	mov	ecx, dword ptr [rax+0x4]
$_0379: mov	dword ptr [rbp-0x10], ecx
	mov	rax, qword ptr [rdi+0x20]
	mov	edx, 4294967294
	test	rax, rax
	jz	$_0380
	mov	edx, dword ptr [rax+0x4]
$_0380: mov	dword ptr [rbp-0xC], edx
	cmp	ecx, -2
	jz	$_0386
	mov	eax, ecx
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	cl, byte ptr [rsi+0x9]
	test	eax, 0x4
	jz	$_0381
	cmp	cl, 1
	jz	$_0383
$_0381: test	eax, 0x8
	jz	$_0382
	cmp	cl, 2
	jz	$_0383
$_0382: test	eax, 0x2
	jz	$_0384
	test	cl, cl
	jnz	$_0384
$_0383: and	byte ptr [rsi+0x1], 0xBF
	jmp	$_0386

$_0384: test	eax, 0x4
	jz	$_0385
	cmp	cl, 2
	jnz	$_0385
	cmp	dword ptr [rsi+0x14], 808
	jnz	$_0385
	test	byte ptr [rsi+0x20], 0x04
	jz	$_0385
	and	byte ptr [rsi+0x1], 0xBF
	jmp	$_0386

$_0385: or	byte ptr [rsi+0x1], 0x40
	test	eax, 0x2
	jz	$_0386
	cmp	cl, 2
	jnz	$_0386
	mov	ecx, 2085
	call	asmerr@PLT
	jmp	$_0440

$_0386: cmp	dword ptr [rbp-0xC], -2
	je	$_0411
	mov	eax, dword ptr [rbp-0xC]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	cl, byte ptr [rsi+0x9]
	test	eax, 0x4
	jz	$_0387
	cmp	cl, 1
	jz	$_0389
$_0387: test	eax, 0x8
	jz	$_0388
	cmp	cl, 2
	jz	$_0389
$_0388: test	eax, 0x2
	jz	$_0390
	test	cl, cl
	jnz	$_0390
$_0389: and	byte ptr [rsi+0x1], 0xBF
	jmp	$_0392

$_0390: test	eax, 0x4
	jz	$_0391
	cmp	cl, 2
	jnz	$_0391
	cmp	dword ptr [rsi+0x14], 808
	jnz	$_0391
	test	byte ptr [rsi+0x20], 0x04
	jz	$_0391
	and	byte ptr [rsi+0x1], 0xBF
	jmp	$_0392

$_0391: or	byte ptr [rsi+0x1], 0x40
	test	eax, 0x2
	jz	$_0392
	cmp	cl, 2
	jnz	$_0392
	mov	ecx, 2032
	call	asmerr@PLT
	jmp	$_0440

$_0392: mov	rcx, qword ptr [rsi+0x68]
	mov	eax, dword ptr [rbp-0xC]
	add	eax, eax
	cmp	byte ptr [r12+rax*8+0xC], 4
	jnz	$_0395
	test	byte ptr [rcx+0x4], 0x20
	jnz	$_0395
	cmp	byte ptr [rdi+0x45], 0
	jz	$_0393
	xor	edx, edx
	mov	ecx, dword ptr [rbp-0xC]
	call	GetResWName@PLT
	mov	rdx, rax
	mov	ecx, 2031
	call	asmerr@PLT
	jmp	$_0394

$_0393: mov	ecx, 2029
	call	asmerr@PLT
$_0394: jmp	$_0440

$_0395: mov	cl, byte ptr [rsi+0x9]
	test	cl, cl
	jnz	$_0396
	test	byte ptr [rsi+0x1], 0x40
	jnz	$_0397
$_0396: cmp	cl, 2
	jz	$_0397
	cmp	cl, 1
	jne	$_0410
	test	byte ptr [rsi+0x1], 0x40
	jne	$_0410
$_0397: movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_0398
	mov	eax, 128
	jmp	$_0399

$_0398: cmp	eax, 6
	jc	$_0399
	mov	eax, 6
$_0399: cmp	eax, 3
	jc	$_0408
	movzx	eax, byte ptr [rdi+0x45]
	jmp	$_0406

$_0400: jmp	$_0407

$_0401: jmp	$_0407

$_0402: mov	byte ptr [rbp-0x16], 64
	jmp	$_0407

$_0403: mov	byte ptr [rbp-0x16], 128
	jmp	$_0407

$_0404: mov	byte ptr [rbp-0x16], 192
	jmp	$_0407

$_0405: mov	ecx, 2083
	call	asmerr@PLT
	jmp	$_0440

	jmp	$_0407

$_0406: cmp	eax, 0
	jz	$_0400
	cmp	eax, 1
	jz	$_0401
	cmp	eax, 2
	jz	$_0402
	cmp	eax, 4
	jz	$_0403
	cmp	eax, 8
	jz	$_0404
	jmp	$_0405

$_0407: jmp	$_0409

$_0408: mov	ecx, 2085
	call	asmerr@PLT
	jmp	$_0440

$_0409: jmp	$_0411

$_0410: cmp	byte ptr [rdi+0x45], 0
	jz	$_0411
	mov	ecx, 2032
	call	asmerr@PLT
	jmp	$_0440

$_0411: cmp	dword ptr [rbp+0x40], 0
	je	$_0429
	mov	byte ptr [rbp-0x17], 0
	mov	dword ptr [rbp-0x1C], 0
	test	byte ptr [rdi+0x40], 0x04
	jz	$_0412
	cmp	byte ptr [rsi+0x9], 0
	setne	al
	test	byte ptr [rsi+0x1], 0x40
	setne	ah
	xor	al, ah
	add	byte ptr [rbp-0x17], al
	jmp	$_0415

$_0412: cmp	qword ptr [rbp-0x8], 0
	jz	$_0413
	mov	rcx, qword ptr [rbp-0x8]
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0x17], al
	jmp	$_0415

$_0413: cmp	qword ptr [SegOverride+rip], 0
	jz	$_0414
	mov	rcx, qword ptr [SegOverride+rip]
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0x17], al
	jmp	$_0415

$_0414: mov	al, byte ptr [rsi+0x9]
	mov	byte ptr [rbp-0x17], al
$_0415: cmp	dword ptr [rbp-0x10], -2
	jne	$_0423
	cmp	dword ptr [rbp-0xC], -2
	jne	$_0423
	test	byte ptr [rdi+0x40], 0x04
	jnz	$_0416
	cmp	qword ptr [rbp-0x8], 0
	jz	$_0416
	lea	r9, [rbp-0x28]
	mov	r8d, 3
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, qword ptr [SegOverride+rip]
	call	GetAssume@PLT
	cmp	eax, -2
	jz	$_0416
	cmp	qword ptr [rbp-0x28], 0
	jz	$_0416
	mov	rcx, qword ptr [rbp-0x28]
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0x17], al
$_0416: movzx	edx, byte ptr [rbp-0x17]
	movzx	eax, byte ptr [rsi+0x9]
	test	al, al
	setne	al
	test	dl, dl
	setne	dl
	xor	al, dl
	shl	al, 6
	and	byte ptr [rsi+0x1], 0xBF
	or	byte ptr [rsi+0x1], al
	cmp	byte ptr [rbp-0x17], 2
	jz	$_0417
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0420
$_0417: cmp	qword ptr [rdi+0x30], 0
	jz	$_0418
	mov	rax, qword ptr [r14+0x40]
	cmp	qword ptr [SegOverride+rip], rax
	jz	$_0418
	mov	dword ptr [rbp-0x1C], 6
	jmp	$_0419

$_0418: mov	dword ptr [rbp-0x1C], 3
$_0419: jmp	$_0422

$_0420: cmp	byte ptr [rbp-0x17], 0
	jz	$_0421
	mov	dword ptr [rbp-0x1C], 6
	jmp	$_0422

$_0421: mov	dword ptr [rbp-0x1C], 5
$_0422: jmp	$_0426

$_0423: cmp	byte ptr [rbp-0x17], 2
	jnz	$_0424
	mov	dword ptr [rbp-0x1C], 6
	jmp	$_0426

$_0424: cmp	byte ptr [rsi+0x9], 0
	setne	al
	test	byte ptr [rsi+0x1], 0x40
	setne	ah
	xor	al, ah
	test	al, al
	jz	$_0425
	mov	dword ptr [rbp-0x1C], 6
	jmp	$_0426

$_0425: mov	dword ptr [rbp-0x1C], 5
	cmp	byte ptr [rbp-0x17], 0
	jz	$_0426
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_0426
	mov	rax, qword ptr [rbp-0x8]
	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 8002
	call	asmerr@PLT
$_0426: cmp	dword ptr [rbp-0x1C], 6
	jnz	$_0428
	cmp	dword ptr [rdi+0x38], 303
	jnz	$_0427
	mov	dword ptr [rbp-0x1C], 12
	jmp	$_0428

$_0427: cmp	dword ptr [rdi+0x38], 315
	jnz	$_0428
	mov	dword ptr [rbp-0x1C], 13
$_0428: cmp	dword ptr [rsi+0x14], 841
	jz	$_0429
	cmp	dword ptr [rsi+0x14], 842
	jz	$_0429
	xor	r8d, r8d
	mov	edx, dword ptr [rbp-0x1C]
	mov	rcx, qword ptr [rbp-0x8]
	call	CreateFixup@PLT
	mov	qword ptr [rsi+rbx+0x28], rax
	cmp	dword ptr [rbp-0x10], 195
	jnz	$_0429
	cmp	dword ptr [rbp-0xC], -2
	jnz	$_0429
	or	byte ptr [rax+0x1B], 0x04
$_0429: cmp	dword ptr [rdi+0x4], 0
	jz	$_0432
	cmp	dword ptr [rdi+0x4], -1
	jnz	$_0430
	cmp	dword ptr [rdi], 0
	jl	$_0432
$_0430: cmp	byte ptr [rsi+0x9], 2
	jnz	$_0431
	test	byte ptr [rdi+0x40], 0x01
	jz	$_0432
$_0431: call	EmitConstError@PLT
	jmp	$_0440

$_0432: mov	rax, qword ptr [rbp-0x8]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x10]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0xC]
	movzx	r8d, byte ptr [rbp-0x16]
	mov	edx, dword ptr [rbp+0x30]
	mov	rcx, rsi
	call	$_0083
	cmp	eax, -1
	jnz	$_0433
	jmp	$_0440

$_0433: cmp	dword ptr [rbp+0x40], 0
	jne	$_0438
	cmp	dword ptr [rsi+0x14], 808
	je	$_0438
	xor	edi, edi
	cmp	dword ptr [rbp-0x10], -2
	jz	$_0435
	mov	eax, dword ptr [rbp-0x10]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x02
	jz	$_0435
	lea	rcx, [SegAssumeTable+rip]
	mov	eax, dword ptr [rsi+0x1C]
	cmp	eax, -2
	jnz	$_0434
	mov	eax, 3
	cmp	dword ptr [rbp-0x10], 14
	jnz	$_0434
	mov	eax, 2
$_0434: imul	eax, eax, 16
	movzx	edi, byte ptr [rcx+rax+0x9]
$_0435: test	edi, edi
	jnz	$_0437
	cmp	dword ptr [rbp-0xC], -2
	jz	$_0437
	mov	eax, dword ptr [rbp-0xC]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x02
	jz	$_0437
	lea	rcx, [SegAssumeTable+rip]
	mov	eax, dword ptr [rsi+0x1C]
	cmp	eax, -2
	jnz	$_0436
	mov	eax, 3
	cmp	dword ptr [rbp-0xC], 14
	jnz	$_0436
	mov	eax, 2
$_0436: imul	eax, eax, 16
	movzx	edi, byte ptr [rcx+rax+0x9]
$_0437: test	edi, edi
	jz	$_0438
	mov	ecx, 2155
	call	asmerr@PLT
$_0438: mov	rcx, qword ptr [rsi+rbx+0x28]
	test	rcx, rcx
	jz	$_0439
	mov	al, byte ptr [Frame_Type+rip]
	mov	byte ptr [rcx+0x20], al
	mov	ax, word ptr [Frame_Datum+rip]
	mov	word ptr [rcx+0x22], ax
$_0439: xor	eax, eax
$_0440: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0441:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, r8
	mov	ebx, edx
	mov	rcx, qword ptr [rdi+0x50]
	test	byte ptr [rdi+0x40], 0x01
	jz	$_0444
	mov	rcx, qword ptr [rdi+0x50]
	test	rcx, rcx
	jz	$_0442
	cmp	byte ptr [rcx+0x1D], 5
	jnz	$_0443
$_0442: xor	r9d, r9d
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
	jmp	$_0477

$_0443: jmp	$_0476

$_0444: cmp	dword ptr [rdi+0x38], -2
	jz	$_0449
	mov	rcx, qword ptr [rdi+0x30]
	cmp	qword ptr [rdi+0x50], 0
	jnz	$_0446
	test	rcx, rcx
	jz	$_0445
	cmp	byte ptr [rcx], 2
	jnz	$_0446
$_0445: mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0147
	jmp	$_0477

	jmp	$_0448

$_0446: cmp	dword ptr [rsi+0x14], 808
	jnz	$_0447
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_0447
	mov	r9d, 1
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
	jmp	$_0477

$_0447: mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0448: jmp	$_0476

$_0449: cmp	qword ptr [rdi+0x50], 0
	jnz	$_0455
	cmp	qword ptr [rdi+0x30], 0
	jz	$_0453
	mov	rcx, qword ptr [rdi+0x30]
	cmp	byte ptr [rcx], 2
	jz	$_0450
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0451
$_0450: xor	r9d, r9d
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
	jmp	$_0477

	jmp	$_0452

$_0451: mov	r9d, 1
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
	jmp	$_0477

$_0452: jmp	$_0454

$_0453: mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0147
	jmp	$_0477

$_0454: jmp	$_0476

$_0455: cmp	byte ptr [rcx+0x1D], 0
	jne	$_0468
	test	byte ptr [rdi+0x40], 0x02
	jne	$_0468
	cmp	dword ptr [rsi+0x14], 628
	jc	$_0456
	cmp	dword ptr [rsi+0x14], 677
	ja	$_0456
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	process_branch@PLT
	jmp	$_0477

$_0456: jmp	$_0466

$_0457: movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_0458
	mov	eax, 128
	jmp	$_0459

$_0458: cmp	eax, 6
	jc	$_0459
	mov	eax, 6
$_0459: cmp	eax, 0
	jbe	$_0460
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0460: jmp	$_0467

$_0461: cmp	ebx, 1
	jnz	$_0464
	test	byte ptr [rsi+0x23], 0x0C
	jnz	$_0464
	mov	rcx, qword ptr [rsi+0x68]
	lea	rdx, [opnd_clstab+rip]
$_0462: movzx	eax, byte ptr [rcx]
	test	byte ptr [rdx+rax*8+0x6], 0x07
	jz	$_0463
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0463: add	rcx, 8
	test	byte ptr [rcx+0x2], 0x08
	jz	$_0462
$_0464: cmp	ebx, 2
	jnz	$_0465
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0465: jmp	$_0467

$_0466: cmp	dword ptr [rsi+0x14], 774
	je	$_0457
	cmp	dword ptr [rsi+0x14], 776
	je	$_0457
	cmp	dword ptr [rsi+0x14], 738
	je	$_0457
	jmp	$_0461

$_0467: jmp	$_0476

$_0468: cmp	byte ptr [rcx+0x1D], 3
	jz	$_0469
	cmp	byte ptr [rcx+0x1D], 4
	jnz	$_0470
$_0469: mov	dword ptr [rdi+0x38], 316
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

	jmp	$_0476

$_0470: test	byte ptr [rdi+0x40], 0x04
	jz	$_0471
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0471: cmp	byte ptr [rdi+0x44], 129
	jz	$_0472
	cmp	byte ptr [rdi+0x44], 130
	jnz	$_0476
$_0472: xor	eax, eax
	mov	rcx, qword ptr [rdi+0x28]
	test	rcx, rcx
	jz	$_0473
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_0473
	cmp	byte ptr [rcx-0x20], 38
	jnz	$_0473
	inc	eax
$_0473: test	eax, eax
	jnz	$_0474
	cmp	dword ptr [rsi+0x14], 808
	jz	$_0474
	cmp	qword ptr [rdi+0x58], 0
	jz	$_0475
$_0474: mov	r9d, 1
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
	jmp	$_0477

$_0475: mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	idata_fixup
	jmp	$_0477

$_0476: mov	r9d, 1
	mov	r8, rdi
	mov	edx, ebx
	mov	rcx, rsi
	call	$_0331
$_0477: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0478:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, r8
	test	byte ptr [rbx+0x44], 0x20
	jz	$_0479
	mov	qword ptr [rbx+0x10], 0
$_0479: mov	rax, qword ptr [rbx+0x10]
	test	rax, rax
	jz	$_0480
	cmp	dword ptr [rax+0x4], 0
	jnz	$_0480
	mov	ecx, 2047
	call	asmerr@PLT
	jmp	$_0482

$_0480: mov	rax, qword ptr [rcx+0x68]
	mov	al, byte ptr [rax+0x6]
	and	eax, 0xF7
	cmp	eax, 194
	jnz	$_0481
	test	edx, edx
	jnz	$_0481
	cmp	dword ptr [rbx], 0
	jnz	$_0481
	xor	eax, eax
	jmp	$_0482

$_0481: mov	r8, rbx
	call	$_0147
$_0482: leave
	pop	rbx
	ret

$_0483:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	rsi, rcx
	mov	rdi, r8
	mov	ecx, edx
	imul	ebx, ecx, 24
	imul	eax, ecx, 104
	mov	rax, qword ptr [rdi+rax+0x18]
	mov	eax, dword ptr [rax+0x4]
	mov	dword ptr [rbp-0x4], eax
	add	eax, eax
	movzx	eax, byte ptr [r12+rax*8+0xC]
	mov	dword ptr [rbp-0x8], eax
	mov	eax, dword ptr [rbp-0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	dword ptr [rbp-0xC], eax
	mov	dword ptr [rsi+rbx+0x20], eax
	mov	edx, dword ptr [rbp-0x8]
	jmp	$_0491

$_0484: cmp	dword ptr [rsi+0x14], 1834
	jc	$_0485
	cmp	dword ptr [rsi+0x14], 1884
	jbe	$_0486
$_0485: or	byte ptr [rsi+0x1], 0x08
$_0486: jmp	$_0492

$_0487: test	eax, 0x80000000
	jz	$_0492
$_0488: test	eax, 0xF
	jz	$_0489
	or	byte ptr [rsi+0x1], 0x10
	jmp	$_0492

$_0489: or	byte ptr [rsi+0x1], 0x08
	test	eax, 0x40
	jz	$_0490
	or	byte ptr [rsi+0x5], 0x10
$_0490: jmp	$_0492

$_0491: test	eax, 0x100000
	jnz	$_0484
	test	eax, 0x20
	jnz	$_0487
	test	eax, 0x80000000
	jnz	$_0488
	test	eax, 0x40
	jnz	$_0489
$_0492: test	eax, 0x1
	jz	$_0498
	cmp	eax, 8388609
	jz	$_0493
	and	byte ptr [rsi], 0xFE
$_0493: cmp	byte ptr [rsi+0x9], 2
	jnz	$_0495
	cmp	edx, 4
	jc	$_0495
	cmp	edx, 7
	ja	$_0495
	mov	eax, dword ptr [rbp-0x4]
	add	eax, eax
	cmp	dword ptr [r12+rax*8+0x8], 0
	jnz	$_0494
	or	byte ptr [rsi], 0x10
	jmp	$_0495

$_0494: or	byte ptr [rsi], 0x20
$_0495: imul	eax, edx, 16
	mov	ecx, 1
	cmp	dword ptr [rbp-0x4], 5
	jl	$_0496
	cmp	dword ptr [rbp-0x4], 8
	jg	$_0496
	mov	ecx, 16
$_0496: lea	rdx, [StdAssumeTable+rip]
	test	byte ptr [rdx+rax+0x8], cl
	jz	$_0497
	mov	ecx, 2108
	call	asmerr@PLT
	jmp	$_0528

$_0497: jmp	$_0521

$_0498: test	eax, 0xF
	jz	$_0503
	or	byte ptr [rsi], 0x01
	imul	ecx, edx, 16
	and	al, 0x0F
	lea	rdx, [StdAssumeTable+rip]
	test	byte ptr [rdx+rcx+0x8], al
	jz	$_0499
	mov	ecx, 2108
	call	asmerr@PLT
	jmp	$_0528

$_0499: test	byte ptr [rbp-0xC], 0x02
	jz	$_0501
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0500
	or	byte ptr [rsi+0x1], 0x20
$_0500: jmp	$_0502

$_0501: cmp	byte ptr [rsi+0x9], 0
	jnz	$_0502
	or	byte ptr [rsi+0x1], 0x20
$_0502: jmp	$_0521

$_0503: test	eax, 0xC000000
	jz	$_0508
	cmp	edx, 1
	jnz	$_0504
	cmp	dword ptr [rsi+0x14], 775
	jnz	$_0504
	lea	rdx, [DS0000+rip]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0528

$_0504: cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_0507
	cmp	dword ptr [rsi+0x14], 738
	jnz	$_0505
	cmp	byte ptr [rsi+0x9], 0
	jz	$_0506
$_0505: cmp	dword ptr [rsi+0x14], 776
	jnz	$_0507
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0507
$_0506: mov	ecx, 8014
	call	asmerr@PLT
$_0507: jmp	$_0521

$_0508: test	eax, 0x10000000
	jz	$_0511
	imul	eax, dword ptr [rbp+0x30], 104
	mov	eax, dword ptr [rdi+rax]
	mov	dword ptr [rbp-0x8], eax
	cmp	eax, 7
	jbe	$_0509
	mov	ecx, 2032
	call	asmerr@PLT
	jmp	$_0528

$_0509: or	byte ptr [rsi+0xA], al
	test	eax, eax
	jz	$_0510
	mov	dword ptr [rsi+rbx+0x20], 536870912
$_0510: xor	eax, eax
	jmp	$_0528

	jmp	$_0521

$_0511: test	eax, 0x2000000
	je	$_0521
	cmp	dword ptr [rsi+0x14], 779
	jz	$_0513
	cmp	dword ptr [rsi+0x14], 774
	jnz	$_0512
	mov	ecx, 2151
	call	asmerr@PLT
	jmp	$_0528

$_0512: mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0528

$_0513: cmp	edx, 32
	jc	$_0519
	or	byte ptr [rsi+0xC], 0x04
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_0514
	mov	eax, 128
	jmp	$_0515

$_0514: cmp	eax, 6
	jc	$_0515
	mov	eax, 6
$_0515: cmp	eax, 6
	jc	$_0518
	mov	eax, 3
	cmp	edx, 37
	jbe	$_0516
	mov	eax, 6
$_0516: mov	ecx, 5
	cmp	edx, 37
	jbe	$_0517
	mov	ecx, 7
$_0517: mov	r8d, ecx
	mov	edx, eax
	mov	ecx, 3004
	call	asmerr@PLT
	jmp	$_0528

$_0518: jmp	$_0520

$_0519: cmp	edx, 16
	jc	$_0520
	or	byte ptr [rsi+0xC], 0x01
$_0520: and	dword ptr [rbp-0x8], 0x0F
$_0521: mov	eax, dword ptr [rbp-0x4]
	add	eax, eax
	mov	edx, dword ptr [r12+rax*8+0x8]
	mov	eax, dword ptr [rbp-0x8]
	mov	cl, byte ptr [rsi+0x2]
	mov	ch, byte ptr [rsi+0xA]
	and	edx, 0x9F
	test	edx, 0x80
	jz	$_0522
	or	cl, 0x40
	test	byte ptr [rbp-0xC], 0x08
	jz	$_0522
	or	cl, 0x08
$_0522: mov	edx, eax
	and	eax, 0x08
	mov	dh, byte ptr [rsi+0x3]
	cmp	dword ptr [rbp+0x30], 0
	jnz	$_0524
	shr	al, 3
	cmp	dl, 15
	jbe	$_0523
	or	dh, 0x10
$_0523: or	cl, al
	and	dl, 0x07
	or	dl, 0xC0
	or	ch, dl
	jmp	$_0527

$_0524: cmp	dword ptr [rsi+0x14], 840
	jnz	$_0525
	test	dword ptr [rsi+0x20], 0x80
	jz	$_0525
	test	byte ptr [rsi+0x20], 0x01
	jnz	$_0525
	shr	al, 3
	or	cl, al
	and	dl, 0x07
	and	ch, 0xC0
	or	ch, dl
	jmp	$_0527

$_0525: shr	al, 1
	cmp	dl, 15
	jbe	$_0526
	or	dh, 0x40
$_0526: or	cl, al
	and	dl, 0x07
	and	ch, 0xC7
	shl	dl, 3
	or	ch, dl
$_0527: mov	byte ptr [rsi+0x2], cl
	mov	byte ptr [rsi+0x3], dh
	mov	byte ptr [rsi+0xA], ch
	xor	eax, eax
$_0528: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0529:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	imul	edx, edx, 16
	lea	rax, [SegAssumeTable+rip]
	mov	rbx, qword ptr [rdx+rax]
	cmp	qword ptr [rcx+0x40], 0
	jz	$_0530
	test	rbx, rbx
	jz	$_0530
	cmp	qword ptr [rcx+0x40], rbx
	jz	$_0530
	call	GetGroup@PLT
	cmp	rax, rbx
	jz	$_0530
	xor	eax, eax
	jmp	$_0531

$_0530: mov	eax, 1
$_0531: leave
	pop	rbx
	ret

$_0532:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	dword ptr [rbp-0x4], 0
	mov	rsi, rcx
	mov	rdi, rdx
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0561

$_0533: test	dword ptr [rsi+0x20], 0x8010
	jz	$_0534
	and	byte ptr [rsi+0x2], 0xF7
	jmp	$_0577

$_0534: cmp	dword ptr [rsi+0x38], 0
	jz	$_0535
	cmp	qword ptr [rdi+0x98], 0
	jnz	$_0535
	cmp	qword ptr [rdi+0xB8], 0
	jz	$_0535
	xor	edx, edx
	mov	rcx, qword ptr [rdi+0xB8]
	call	$_0529
	test	eax, eax
	jnz	$_0535
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0563

$_0535: cmp	dword ptr [rsi+0x1C], -2
	jz	$_0540
	cmp	qword ptr [rdi+0x98], 0
	jz	$_0539
	cmp	dword ptr [rsi+0x1C], 0
	jnz	$_0538
	cmp	dword ptr [LastRegOverride+rip], 3
	jnz	$_0536
	mov	dword ptr [rsi+0x1C], -2
	jmp	$_0537

$_0536: mov	eax, dword ptr [LastRegOverride+rip]
	mov	dword ptr [rsi+0x1C], eax
$_0537: jmp	$_0539

$_0538: mov	ecx, 2070
	call	asmerr@PLT
$_0539: jmp	$_0541

$_0540: cmp	dword ptr [rsi+0x20], 0
	jz	$_0541
	cmp	qword ptr [rdi+0x30], 0
	jnz	$_0541
	cmp	qword ptr [rdi+0x50], 0
	jz	$_0541
	mov	r8d, 3
	mov	rdx, qword ptr [rdi+0x50]
	mov	rcx, rsi
	call	$_0057
$_0541: cmp	dword ptr [rsi+0x1C], 3
	jnz	$_0542
	mov	dword ptr [rsi+0x1C], -2
$_0542: jmp	$_0563

$_0543: test	dword ptr [rsi+0x20], 0x8010
	jnz	$_0544
	test	dword ptr [rsi+0x38], 0x8010
	jz	$_0545
$_0544: and	byte ptr [rsi+0x2], 0xF7
	jmp	$_0577

$_0545: cmp	dword ptr [rsi+0x20], 0
	jz	$_0546
	cmp	qword ptr [rdi+0x30], 0
	jnz	$_0546
	cmp	qword ptr [rdi+0x50], 0
	jz	$_0546
	xor	edx, edx
	mov	rcx, qword ptr [rdi+0x50]
	call	$_0529
	test	eax, eax
	jnz	$_0546
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0563

$_0546: cmp	dword ptr [rsi+0x1C], -2
	jz	$_0550
	mov	rcx, qword ptr [rdi+0x30]
	test	rcx, rcx
	jz	$_0547
	cmp	byte ptr [rcx], 2
	jnz	$_0547
	cmp	dword ptr [rcx+0x4], 25
	jz	$_0547
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0549

$_0547: cmp	qword ptr [rdi+0x98], 0
	jnz	$_0549
	cmp	dword ptr [rsi+0x1C], 0
	jnz	$_0548
	mov	dword ptr [rsi+0x1C], -2
	jmp	$_0549

$_0548: mov	ecx, 2070
	call	asmerr@PLT
$_0549: jmp	$_0551

$_0550: cmp	dword ptr [rsi+0x38], 0
	jz	$_0551
	cmp	qword ptr [rdi+0x98], 0
	jnz	$_0551
	cmp	qword ptr [rdi+0xB8], 0
	jz	$_0551
	mov	r8d, 3
	mov	rdx, qword ptr [rdi+0xB8]
	mov	rcx, rsi
	call	$_0057
$_0551: cmp	dword ptr [rsi+0x1C], 3
	jnz	$_0552
	mov	dword ptr [rsi+0x1C], -2
$_0552: jmp	$_0563

	cmp	dword ptr [rsi+0x38], 0
	jz	$_0553
	cmp	qword ptr [rdi+0x98], 0
	jnz	$_0553
	cmp	qword ptr [rdi+0xB8], 0
	jz	$_0553
	mov	r8d, 3
	mov	rdx, qword ptr [rdi+0xB8]
	mov	rcx, rsi
	call	$_0057
$_0553: cmp	dword ptr [rsi+0x1C], 3
	jnz	$_0554
	mov	dword ptr [rsi+0x1C], -2
$_0554: mov	dword ptr [rbp-0x4], 1
	jmp	$_0563

$_0555: cmp	dword ptr [rsi+0x20], 0
	jz	$_0556
	cmp	qword ptr [rdi+0x30], 0
	jnz	$_0556
	cmp	qword ptr [rdi+0x50], 0
	jz	$_0556
	mov	r8d, 3
	mov	rdx, qword ptr [rdi+0x50]
	mov	rcx, rsi
	call	$_0057
$_0556: cmp	dword ptr [rsi+0x1C], 3
	jnz	$_0557
	mov	dword ptr [rsi+0x1C], -2
$_0557: jmp	$_0563

LC0312: cmp	dword ptr [rsi+0x20], 0
	jz	$_0558
	cmp	qword ptr [rdi+0x30], 0
	jnz	$_0558
	cmp	qword ptr [rdi+0x50], 0
	jz	$_0558
	xor	edx, edx
	mov	rcx, qword ptr [rdi+0x50]
	call	$_0529
	test	eax, eax
	jnz	$_0558
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0563

$_0558: cmp	dword ptr [rsi+0x1C], -2
	jz	$_0560
	cmp	dword ptr [rsi+0x1C], 0
	jnz	$_0559
	mov	dword ptr [rsi+0x1C], -2
	jmp	$_0560

$_0559: mov	ecx, 2070
	call	asmerr@PLT
$_0560: jmp	$_0563

$_0561: cmp	eax, 694
	jl	$_0562
	cmp	eax, 713
	jg	$_0562
	lea	r11, [LC0318+rip]
	movzx	r10, byte ptr [r11+rax-0x2A8]
	movzx	r10, word ptr [r11+r10*2]
	lea	r11, [LC0312+rip]
	sub	r11, r10
	jmp	r11

$_0562: cmp	eax, 1449
	je	$_0533
	cmp	eax, 1332
	je	$_0534
	cmp	eax, 1561
	je	$_0543
	cmp	eax, 1334
	je	$_0545
	cmp	eax, 1333
	je	$_0555
	jmp	LC0312

$_0563: mov	ecx, dword ptr [rbp-0x4]
	shl	ecx, 2
	mov	rax, qword ptr [rsi+0x68]
	movzx	eax, byte ptr [rax]
	lea	rdx, [opnd_clstab+rip]
	add	rdx, rcx
	mov	eax, dword ptr [rdx+rax*8]
	test	eax, eax
	jnz	$_0564
	and	byte ptr [rsi], 0xFE
	and	byte ptr [rsi+0x1], 0xDF
$_0564: mov	ebx, dword ptr [rbp-0x4]
	imul	ebx, ebx, 24
	test	eax, eax
	je	$_0577
	cmp	dword ptr [rsi+rbx+0x20], 0
	je	$_0577
	mov	rdx, rsi
	mov	ecx, dword ptr [rsi+rbx+0x20]
	call	OperandSize
	test	eax, eax
	jnz	$_0568
	mov	rdx, qword ptr [rsi+rbx+0x28]
	xor	eax, eax
	test	rdx, rdx
	jz	$_0565
	mov	rcx, qword ptr [rdx+0x30]
	cmp	byte ptr [rcx+0x1D], 0
	jz	$_0565
	inc	eax
$_0565: test	rdx, rdx
	jz	$_0566
	test	eax, eax
	jz	$_0567
$_0566: mov	ecx, 2023
	call	asmerr@PLT
$_0567: mov	eax, 1
$_0568: jmp	$_0576

$_0569: and	byte ptr [rsi], 0xFE
	and	byte ptr [rsi+0x1], 0xDF
	jmp	$_0577

$_0570: or	byte ptr [rsi], 0x01
	and	byte ptr [rsi+0x1], 0xDF
	cmp	byte ptr [rsi+0x9], 0
	jz	$_0571
	or	byte ptr [rsi+0x1], 0x20
$_0571: jmp	$_0577

$_0572: or	byte ptr [rsi], 0x01
	and	byte ptr [rsi+0x1], 0xDF
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_0573
	or	byte ptr [rsi+0x1], 0x20
$_0573: jmp	$_0577

$_0574: cmp	byte ptr [rsi+0x9], 2
	jnz	$_0575
	or	byte ptr [rsi], 0x01
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x2], 0x08
$_0575: jmp	$_0577

$_0576: cmp	eax, 1
	jz	$_0569
	cmp	eax, 2
	jz	$_0570
	cmp	eax, 4
	jz	$_0572
	cmp	eax, 8
	jz	$_0574
$_0577: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0578:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	rsi, rcx
	mov	rdi, rdx
	mov	ecx, dword ptr [rsi+0x20]
	mov	edx, dword ptr [rsi+0x38]
	mov	dword ptr [rbp-0xC], 0
	mov	dword ptr [rbp-0x4], ecx
	mov	dword ptr [rbp-0x8], edx
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_0693

$_0579: test	edx, 0x8
	jz	$_0581
	cmp	dword ptr [rdi+0xA4], 2
	jnz	$_0581
	and	byte ptr [rsi+0x2], 0xF7
	cmp	eax, 1883
	jz	$_0580
	mov	ecx, 2070
	call	asmerr@PLT
$_0580: jmp	$_0695

$_0581: jmp	LC03B3

$_0582: test	edx, 0x4
	jz	$_0583
	cmp	dword ptr [rdi+0xA4], 2
	jnz	$_0583
	test	byte ptr [Options+0x6+rip], 0x10
	jz	$_0583
	mov	ecx, 2070
	call	asmerr@PLT
$_0583: jmp	LC03B3

$_0584: cmp	ecx, 65536
	jz	$_0585
	cmp	edx, 132
	jz	$_0585
	jmp	LC03B3

$_0585: jmp	$_0695

	cmp	dword ptr [rbp-0x8], 16777218
	jnz	$_0591
	jmp	$_0590

$_0586: jmp	$_0591

$_0587: and	byte ptr [rsi], 0xFE
$_0588: cmp	byte ptr [rsi+0x9], 0
	jz	$_0589
	and	byte ptr [rsi+0x1], 0xDF
$_0589: jmp	$_0591

$_0590: cmp	ecx, 130
	jz	$_0586
	cmp	ecx, 129
	jz	$_0587
	cmp	ecx, 132
	jz	$_0588
$_0591: jmp	$_0695

	cmp	ecx, 16777218
	jnz	$_0597
	jmp	$_0596

$_0592: jmp	$_0597

$_0593: and	byte ptr [rsi], 0xFE
$_0594: cmp	byte ptr [rsi+0x9], 0
	jz	$_0595
	and	byte ptr [rsi+0x1], 0xDF
$_0595: jmp	$_0597

$_0596: cmp	edx, 130
	jz	$_0592
	cmp	edx, 129
	jz	$_0593
	cmp	edx, 132
	jz	$_0594
$_0597: jmp	$_0695

	jmp	$_0695

$_0598: mov	rcx, qword ptr [rdi+0x50]
	cmp	dword ptr [rsi+0x20], 4202240
	jnz	$_0600
	test	byte ptr [rsi], 0x40
	jnz	$_0600
	test	rcx, rcx
	jz	$_0599
	cmp	byte ptr [rcx+0x1D], 0
	jz	$_0600
$_0599: mov	ecx, 2023
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
	jmp	$_0695

$_0600: mov	rcx, qword ptr [rdi+0xB8]
	cmp	dword ptr [rdi+0xA4], 1
	jnz	$_0601
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0601
	test	byte ptr [rdi+0xA8], 0x01
	jnz	$_0601
	test	rcx, rcx
	jz	$_0601
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_0601
	mov	dword ptr [rsi+0x38], 65536
	mov	dword ptr [rsi+0x48], 1
$_0601: mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	cmp	rax, 1
	jbe	$_0602
	or	byte ptr [rsi], 0x01
$_0602: cmp	dword ptr [rbp-0x8], 8388609
	jnz	$_0603
	and	byte ptr [rsi+0xA], 0xC7
$_0603: jmp	$_0695

$_0604: mov	rdx, rsi
	call	OperandSize
	add	eax, 2
	mov	dword ptr [rbp-0x10], eax
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	cmp	dword ptr [rbp-0x14], 0
	jz	$_0605
	mov	eax, dword ptr [rbp-0x14]
	cmp	dword ptr [rbp-0x10], eax
	jz	$_0605
	mov	ecx, 2024
	call	asmerr@PLT
	jmp	$_0696

$_0605: jmp	$_0695

	jmp	$_0695

	and	byte ptr [rsi], 0xFE
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	mov	dword ptr [rbp-0x10], eax
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	cmp	dword ptr [rbp-0x14], 0
	jnz	$_0607
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_0607
	cmp	dword ptr [rbp-0x10], 2
	jnz	$_0606
	lea	rdx, [DS0001+rip]
	mov	ecx, 8012
	call	asmerr@PLT
	jmp	$_0607

$_0606: mov	ecx, 2023
	call	asmerr@PLT
$_0607: jmp	$_0617

$_0608: cmp	dword ptr [rbp-0x14], 2
	jge	$_0609
	jmp	$_0611

$_0609: cmp	dword ptr [rbp-0x14], 2
	jnz	$_0610
	or	byte ptr [rsi], 0x01
	jmp	$_0611

$_0610: mov	ecx, 2024
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
$_0611: and	byte ptr [rsi+0x1], 0xDF
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_0612
	or	byte ptr [rsi+0x1], 0x20
$_0612: jmp	$_0618

$_0613: cmp	dword ptr [rbp-0x14], 2
	jl	$_0614
	mov	ecx, 2024
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
$_0614: and	byte ptr [rsi+0x1], 0xDF
	cmp	byte ptr [rsi+0x9], 0
	jz	$_0615
	or	byte ptr [rsi+0x1], 0x20
$_0615: jmp	$_0618

$_0616: mov	ecx, 2024
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
	jmp	$_0618

$_0617: cmp	dword ptr [rbp-0x10], 8
	jz	$_0608
	cmp	dword ptr [rbp-0x10], 4
	jz	$_0608
	cmp	dword ptr [rbp-0x10], 2
	jz	$_0613
	jmp	$_0616

$_0618: jmp	$_0695

$_0619: jmp	$_0695

$_0620: and	byte ptr [rsi+0x1], 0xDF
	jmp	LC03B3

	and	edx, 0x401F00
	cmp	byte ptr [r14+0x4], 2
	jnz	$_0621
	test	edx, edx
	jnz	$_0622
$_0621: jmp	LC03B3

$_0622: mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	cmp	eax, 2
	jz	$_0623
	test	eax, eax
	jz	$_0623
	mov	ecx, 2024
	call	asmerr@PLT
	jmp	$_0696

$_0623: mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	mov	dword ptr [rbp-0x10], eax
	cmp	eax, 2
	jz	$_0624
	and	byte ptr [rsi+0x1], 0xDF
$_0624: jmp	$_0695

	cmp	dword ptr [rsi+0x50], 0
	jz	$_0627
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	mov	dword ptr [rbp-0x10], eax
	mov	rdx, rsi
	mov	ecx, dword ptr [rsi+0x50]
	call	OperandSize
	cmp	dword ptr [rbp-0x10], 2
	jnz	$_0625
	cmp	eax, 2
	jbe	$_0625
	mov	r8d, eax
	mov	edx, dword ptr [rbp-0x10]
	mov	ecx, 2022
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
	jmp	$_0695

$_0625: test	byte ptr [rsi+0x52], 0x06
	jz	$_0627
	mov	eax, 262144
	cmp	dword ptr [rbp-0x10], 2
	jnz	$_0626
	mov	eax, 131072
$_0626: mov	dword ptr [rsi+0x50], eax
$_0627: jmp	LC03B3

$_0628: jmp	$_0695

$_0629: test	byte ptr [rsi+0x5], 0x01
	jne	$_0695
	cmp	edx, 4202240
	jnz	$_0630
	test	byte ptr [rdi+0xA8], 0x01
	jz	$_0630
	mov	ecx, 2023
	call	asmerr@PLT
	jmp	$_0696

$_0630: jmp	$_0695

$_0631: test	ecx, 0x20
	je	$_0695
$_0632: cmp	edx, 4202240
	jnz	$_0633
	or	byte ptr [rsi+0x39], 0x20
$_0633: jmp	$_0695

$_0634: mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	and	byte ptr [rsi+0x1], 0xDF
	cmp	eax, 2
	jnc	$_0635
	jmp	$_0638

$_0635: cmp	eax, 2
	jnz	$_0637
	cmp	byte ptr [rsi+0x9], 0
	jz	$_0636
	or	byte ptr [rsi+0x1], 0x20
$_0636: jmp	$_0638

$_0637: cmp	byte ptr [rsi+0x9], 0
	jnz	$_0638
	or	byte ptr [rsi+0x1], 0x20
$_0638: jmp	$_0695

$_0639: jmp	$_0695

	test	byte ptr [rbp-0x1], 0x0C
	jz	$_0642
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	cmp	eax, 2
	jz	$_0640
	cmp	eax, 4
	jz	$_0640
	cmp	eax, 8
	jnz	$_0641
	cmp	byte ptr [r14+0x4], 2
	jnz	$_0641
$_0640: xor	eax, eax
	jmp	$_0696

$_0641: jmp	LC03B3

$_0642: test	byte ptr [rbp-0x5], 0x0C
	jz	$_0645
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	mov	dword ptr [rbp-0x10], eax
	cmp	eax, 2
	jz	$_0643
	cmp	eax, 4
	jz	$_0643
	cmp	eax, 8
	jnz	$_0644
	cmp	byte ptr [r14+0x4], 2
	jnz	$_0644
$_0643: xor	eax, eax
	jmp	$_0696

$_0644: jmp	LC03B3

$_0645: test	dword ptr [rbp-0x4], 0x401F00
	jz	$_0649
	test	dword ptr [rbp-0x8], 0x80
	jz	$_0649
	test	byte ptr [rsi], 0x02
	jnz	$_0646
	and	dword ptr [rsi+0x38], 0xFFFFFF7F
	jmp	$_0648

$_0646: cmp	byte ptr [rsi+0x9], 2
	jnz	$_0648
	movabs	rax, 0x80000000
	mov	rdx, -2147483648
	cmp	qword ptr [rsi+0x30], rax
	jc	$_0647
	cmp	qword ptr [rsi+0x30], rdx
	jc	$_0648
$_0647: and	dword ptr [rsi+0x38], 0xFFFFFF7F
$_0648: jmp	LC03B3

$_0649: test	dword ptr [rbp-0x4], 0x80
	jz	LC03B3
	test	dword ptr [rbp-0x8], 0x401F00
	jz	LC03B3
	test	byte ptr [rsi], 0x02
	jnz	$_0650
	and	dword ptr [rsi+0x20], 0xFFFFFF7F
	jmp	LC03B3

$_0650: cmp	byte ptr [rsi+0x9], 2
	jnz	LC03B3
	mov	eax, 2147483648
	mov	rdx, -2147483648
	cmp	qword ptr [rsi+0x48], rax
	jc	$_0651
	cmp	qword ptr [rsi+0x48], rdx
	jc	LC03B3
$_0651: and	dword ptr [rsi+0x20], 0xFFFFFF7F
LC03B3: mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x4]
	call	OperandSize
	mov	dword ptr [rbp-0x10], eax
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp-0x8]
	call	OperandSize
	mov	dword ptr [rbp-0x14], eax
	cmp	dword ptr [rbp-0x10], eax
	jle	$_0652
	cmp	dword ptr [rbp-0x8], 65536
	jl	$_0652
	cmp	dword ptr [rbp-0x8], 262144
	jg	$_0652
	mov	eax, dword ptr [rbp-0x10]
	mov	dword ptr [rbp-0x14], eax
$_0652: cmp	dword ptr [rbp-0x10], 1
	jnz	$_0653
	cmp	dword ptr [rbp-0x8], 131072
	jnz	$_0653
	cmp	dword ptr [rsi+0x48], 255
	jg	$_0653
	cmp	dword ptr [rsi+0x48], -255
	jl	$_0653
	mov	eax, dword ptr [rbp-0xC]
	jmp	$_0696

$_0653: mov	eax, dword ptr [rbp-0x14]
	cmp	dword ptr [rbp-0x10], eax
	je	$_0692
	mov	eax, dword ptr [rbp-0x4]
	or	eax, dword ptr [rbp-0x8]
	test	eax, 0x108070
	jnz	$_0654
	cmp	dword ptr [rsi+0x14], 1442
	jc	$_0655
$_0654: jmp	$_0664

$_0655: cmp	dword ptr [rbp-0x10], 0
	je	$_0664
	cmp	dword ptr [rbp-0x14], 0
	je	$_0664
	mov	eax, 1
	cmp	byte ptr [rsi+0x9], 0
	jbe	$_0659
	test	dword ptr [rbp-0x4], 0x607F00
	jz	$_0659
	test	dword ptr [rbp-0x8], 0x607F00
	jz	$_0659
	mov	ecx, dword ptr [rsi+0x14]
	jmp	$_0657

$_0656: xor	eax, eax
	jmp	$_0658

$_0657: cmp	ecx, 779
	jz	$_0656
	cmp	ecx, 685
	jz	$_0656
	cmp	ecx, 834
	jz	$_0656
	cmp	ecx, 680
	jz	$_0656
	cmp	ecx, 678
	jz	$_0656
	cmp	ecx, 681
	jz	$_0656
	cmp	ecx, 683
	jz	$_0656
	cmp	ecx, 682
	jz	$_0656
	cmp	ecx, 679
	jz	$_0656
	cmp	ecx, 684
	jz	$_0656
$_0658: jmp	$_0663

$_0659: test	byte ptr [rbp-0x3], 0x0F
	jnz	$_0660
	test	byte ptr [rbp-0x7], 0x0F
	jz	$_0663
$_0660: xor	ecx, ecx
	test	byte ptr [rbp-0x3], 0x0F
	jz	$_0661
	test	byte ptr [rbp-0x8], 0x0F
	jz	$_0661
	mov	rcx, qword ptr [rdi+0x58]
	jmp	$_0662

$_0661: test	byte ptr [rbp-0x7], 0x0F
	jz	$_0662
	test	byte ptr [rbp-0x4], 0x0F
	jz	$_0662
	mov	rcx, qword ptr [rdi+0xC0]
$_0662: test	rcx, rcx
	jz	$_0663
	test	byte ptr [rcx+0x11], 0x40
	jz	$_0663
	xor	eax, eax
$_0663: test	eax, eax
	jz	$_0664
	mov	r8d, dword ptr [rbp-0x14]
	mov	edx, dword ptr [rbp-0x10]
	mov	ecx, 2022
	call	asmerr@PLT
	mov	dword ptr [rbp-0xC], eax
$_0664: cmp	dword ptr [rbp-0x10], 0
	jne	$_0692
	mov	eax, dword ptr [rbp-0x4]
	or	eax, dword ptr [rbp-0x8]
	test	dword ptr [rbp-0x4], 0x607F00
	je	$_0677
	test	byte ptr [rbp-0x6], 0x07
	je	$_0677
	mov	eax, dword ptr [rsi+0x48]
	cmp	dword ptr [rbp-0x14], 1
	jz	$_0666
	cmp	dword ptr [rbp-0x4], 4202240
	jnz	$_0668
	test	byte ptr [rdi+0xA8], 0x02
	jnz	$_0668
	cmp	eax, 0
	jge	$_0665
	cmp	eax, -128
	jl	$_0668
$_0665: cmp	eax, 255
	jg	$_0668
$_0666: mov	byte ptr [rsi+0x8], 0
	mov	dword ptr [rsi+0x38], 65536
	lea	rcx, [DS0001+rip]
	cmp	dword ptr [rbp-0x4], 4202240
	jnz	$_0667
	test	byte ptr [rdi+0xA8], 0x02
	jnz	$_0667
	mov	dword ptr [rsi+0x20], 256
$_0667: jmp	$_0673

$_0668: cmp	dword ptr [rbp-0x14], 2
	jnz	$_0670
	cmp	eax, 0
	jge	$_0669
	cmp	eax, 4294934528
	jl	$_0670
$_0669: cmp	eax, 65535
	jg	$_0670
	mov	byte ptr [rsi+0x8], 1
	or	byte ptr [rsi], 0x01
	mov	dword ptr [rsi+0x38], 131072
	lea	rcx, [DS0002+rip]
	jmp	$_0673

$_0670: or	byte ptr [rsi], 0x01
	cmp	byte ptr [r14+0x4], 0
	jnz	$_0671
	cmp	dword ptr [rbp-0x14], 2
	jle	$_0671
	cmp	dword ptr [rsi+0x48], 65535
	jg	$_0671
	cmp	dword ptr [rsi+0x48], -65535
	jl	$_0671
	mov	dword ptr [rbp-0x14], 2
$_0671: cmp	dword ptr [rbp-0x14], 2
	jg	$_0672
	cmp	eax, 4294934528
	jle	$_0672
	cmp	byte ptr [r14+0x4], 0
	jnz	$_0672
	mov	byte ptr [rsi+0x8], 1
	mov	dword ptr [rsi+0x38], 131072
	jmp	$_0673

$_0672: mov	byte ptr [rsi+0x8], 3
	mov	dword ptr [rsi+0x38], 262144
	lea	rcx, [DS0003+rip]
$_0673: test	byte ptr [rdi+0xA8], 0x02
	jnz	$_0676
	mov	rax, qword ptr [rsi+0x28]
	test	rax, rax
	jnz	$_0674
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0674
	test	byte ptr [rsi], 0x40
	jz	$_0675
$_0674: test	rax, rax
	jz	$_0676
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_0676
$_0675: mov	rdx, rcx
	mov	ecx, 8012
	call	asmerr@PLT
$_0676: jmp	$_0692

$_0677: test	dword ptr [rbp-0x4], 0x607F00
	jz	$_0678
	test	dword ptr [rbp-0x8], 0xC00000F
	jz	$_0678
	jmp	$_0692

$_0678: test	dword ptr [rbp-0x4], 0x8010
	jz	$_0682
	test	byte ptr [rbp-0x6], 0x07
	jz	$_0682
	mov	eax, dword ptr [rsi+0x48]
	cmp	eax, 65535
	jbe	$_0679
	mov	dword ptr [rsi+0x38], 262144
	jmp	$_0681

$_0679: cmp	eax, 255
	jbe	$_0680
	mov	dword ptr [rsi+0x38], 131072
	jmp	$_0681

$_0680: mov	dword ptr [rsi+0x38], 65536
$_0681: jmp	$_0692

$_0682: test	eax, 0x8010
	jz	$_0683
	jmp	$_0692

$_0683: jmp	$_0691

$_0684: mov	byte ptr [rsi+0x8], 0
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0685
	test	byte ptr [rbp-0x6], 0x07
	jz	$_0685
	lea	rdx, [DS0001+rip]
	mov	ecx, 8012
	call	asmerr@PLT
$_0685: jmp	$_0692

$_0686: mov	byte ptr [rsi+0x8], 1
	or	byte ptr [rsi], 0x01
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0687
	test	byte ptr [rbp-0x6], 0x07
	jz	$_0687
	lea	rdx, [DS0003+0x1+rip]
	mov	ecx, 8012
	call	asmerr@PLT
$_0687: cmp	byte ptr [rsi+0x9], 0
	jz	$_0688
	or	byte ptr [rsi+0x1], 0x20
$_0688: jmp	$_0692

$_0689: mov	byte ptr [rsi+0x8], 3
	or	byte ptr [rsi], 0x01
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0690
	test	byte ptr [rbp-0x6], 0x07
	jz	$_0690
	lea	rdx, [DS0003+rip]
	mov	ecx, 8012
	call	asmerr@PLT
$_0690: jmp	$_0692

$_0691: cmp	dword ptr [rbp-0x14], 1
	je	$_0684
	cmp	dword ptr [rbp-0x14], 2
	jz	$_0686
	cmp	dword ptr [rbp-0x14], 4
	jz	$_0689
$_0692: jmp	$_0695

$_0693: cmp	eax, 779
	jl	$_0694
	cmp	eax, 818
	jg	$_0694
	lea	r11, [LC03F6+rip]
	movzx	r10, byte ptr [r11+rax-0x2F7]
	movzx	r10, word ptr [r11+r10*2]
	lea	r11, [LC03B3+rip]
	sub	r11, r10
	jmp	r11

$_0694: cmp	eax, 1881
	je	$_0579
	cmp	eax, 1882
	je	$_0579
	cmp	eax, 1883
	je	$_0579
	cmp	eax, 1884
	je	$_0582
	cmp	eax, 1322
	je	$_0584
	cmp	eax, 686
	je	$_0598
	cmp	eax, 687
	je	$_0598
	cmp	eax, 688
	je	$_0598
	cmp	eax, 689
	je	$_0598
	cmp	eax, 690
	je	$_0598
	cmp	eax, 691
	je	$_0598
	cmp	eax, 692
	je	$_0598
	cmp	eax, 693
	je	$_0598
	cmp	eax, 728
	je	$_0604
	cmp	eax, 729
	je	$_0604
	cmp	eax, 1331
	je	$_0619
	cmp	eax, 741
	je	$_0620
	cmp	eax, 1113
	je	$_0628
	cmp	eax, 1114
	je	$_0628
	cmp	eax, 1119
	je	$_0628
	cmp	eax, 1120
	je	$_0628
	cmp	eax, 1443
	je	$_0628
	cmp	eax, 1444
	je	$_0628
	cmp	eax, 1451
	je	$_0628
	cmp	eax, 1466
	je	$_0628
	cmp	eax, 1523
	je	$_0628
	cmp	eax, 1524
	je	$_0628
	cmp	eax, 1529
	je	$_0628
	cmp	eax, 1530
	je	$_0628
	cmp	eax, 1434
	je	$_0628
	cmp	eax, 1435
	je	$_0628
	cmp	eax, 1517
	je	$_0629
	cmp	eax, 1518
	je	$_0629
	cmp	eax, 1519
	je	$_0629
	cmp	eax, 1688
	je	$_0631
	cmp	eax, 1459
	je	$_0632
	cmp	eax, 1400
	je	$_0634
	cmp	eax, 1129
	je	$_0639
	jmp	LC03B3

$_0695: mov	eax, dword ptr [rbp-0xC]
$_0696: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_0697:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	call	SymFind@PLT
	test	rax, rax
	jz	$_0698
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_0698
	jmp	$_0699

$_0698: xor	eax, eax
$_0699: leave
	ret

$_0700:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	eax, dword ptr [rcx]
	jmp	$_0719

$_0701: inc	rcx
	mov	eax, dword ptr [rcx]
	jmp	$_0719

$_0702: cmp	ah, 49
	jc	$_0720
	cmp	ah, 55
	ja	$_0720
	test	eax, 0xFF0000
	jne	$_0720
	sub	ah, 48
	or	byte ptr [rdx+0x4], ah
	mov	eax, 1
	jmp	$_0721

$_0703: cmp	ah, 116
	jne	$_0720
	movzx	eax, byte ptr [rcx+0x4]
	movzx	ecx, byte ptr [rcx+0x3]
	sub	cl, 48
	test	eax, eax
	jz	$_0704
	sub	al, 48
	imul	ecx, ecx, 10
	add	ecx, eax
$_0704: xor	ah, ah
	mov	al, 2
$_0705: cmp	al, cl
	jnc	$_0706
	add	al, al
	inc	ah
	jmp	$_0705

$_0706: cmp	al, cl
	jz	$_0707
	mov	edx, ecx
	mov	ecx, 2063
	call	asmerr@PLT
	jmp	$_0720

$_0707: shl	ah, 5
	or	byte ptr [rdx+0x5], ah
	or	byte ptr [rdx+0x4], 0x10
	or	byte ptr [rdx+0x5], 0x01
	mov	eax, 1
	jmp	$_0721

$_0708: test	ah, ah
	jnz	$_0709
	or	byte ptr [rdx+0x4], 0x80
	or	byte ptr [rdx+0x5], 0x08
	mov	eax, 1
	jmp	$_0721

$_0709: jmp	$_0720

$_0710: cmp	byte ptr [rcx+0x2], 45
	jne	$_0720
	cmp	byte ptr [rcx+0x3], 115
	jne	$_0720
	mov	cl, ah
	xor	eax, eax
	jmp	$_0716

$_0711: or	al, 0x20
$_0712: or	al, 0x50
	jmp	$_0717

$_0713: or	al, 0x20
$_0714: or	al, 0x10
	jmp	$_0717

$_0715: jmp	$_0721

	jmp	$_0717

$_0716: cmp	cl, 122
	jz	$_0711
	cmp	cl, 117
	jz	$_0712
	cmp	cl, 100
	jz	$_0713
	cmp	cl, 110
	jz	$_0714
	jmp	$_0715

$_0717: and	byte ptr [rdx+0x4], 0x8F
	or	byte ptr [rdx+0x4], al
	or	byte ptr [rdx+0x5], 0x02
	jmp	$_0721

$_0718: cmp	eax, 6644083
	jnz	$_0720
	or	byte ptr [rdx+0x4], 0x10
	or	byte ptr [rdx+0x5], 0x04
	mov	eax, 1
	jmp	$_0721

	jmp	$_0720

$_0719: cmp	al, 9
	je	$_0701
	cmp	al, 32
	je	$_0701
	cmp	al, 107
	je	$_0702
	cmp	al, 49
	je	$_0703
	cmp	al, 122
	je	$_0708
	cmp	al, 114
	je	$_0710
	cmp	al, 115
	jz	$_0718
$_0720: xor	eax, eax
$_0721: leave
	ret

$_0722:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	mov	rsi, rcx
	xor	eax, eax
	test	byte ptr [rcx+0x40], 0x08
	jz	$_0724
	mov	rcx, qword ptr [rcx+0x60]
	test	rcx, rcx
	jz	$_0723
	mov	rcx, qword ptr [rcx+0x78]
	test	rcx, rcx
	jz	$_0723
	mov	rcx, qword ptr [rcx]
$_0723: jmp	$_0725

$_0724: mov	rcx, qword ptr [rcx+0x58]
$_0725: test	rcx, rcx
	jz	$_0731
	mov	rdx, qword ptr [rcx+0x28]
	test	rdx, rdx
	jz	$_0731
	cmp	byte ptr [rdx+0x1D], 7
	jnz	$_0731
	mov	rdx, qword ptr [rdx+0x78]
	mov	rdx, qword ptr [rdx]
	test	byte ptr [rdx+0x11], 0x40
	jz	$_0731
	mov	dword ptr [rsi], 0
	mov	dword ptr [rsi+0x4], 0
	mov	rdi, rdx
$_0726: test	rdi, rdi
	jz	$_0730
	movzx	ecx, byte ptr [rdi+0x59]
	cmp	ecx, 64
	jnc	$_0729
	mov	eax, dword ptr [rdi+0x38]
	mov	edx, dword ptr [rdi+0x3C]
	cmp	cl, 32
	jnc	$_0727
	shld	edx, eax, cl
	shl	eax, cl
	jmp	$_0728

$_0727: and	ecx, 0x1F
	mov	edx, eax
	xor	eax, eax
	shl	edx, cl
$_0728: or	dword ptr [rsi], eax
	or	dword ptr [rsi+0x4], edx
$_0729: mov	rdi, qword ptr [rdi+0x80]
	jmp	$_0726

$_0730: mov	eax, 1
$_0731: leave
	pop	rdi
	pop	rsi
	ret

ParseLine:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 632
	mov	rbx, rcx
	cmp	qword ptr [CurrEnum+rip], 0
	jz	$_0732
	cmp	byte ptr [rbx], 8
	jnz	$_0732
	mov	rdx, rbx
	xor	ecx, ecx
	call	EnumDirective@PLT
	jmp	$_0987

$_0732: mov	dword ptr [rbp-0x4], 0
	cmp	byte ptr [rbx], 8
	jne	$_0741
	cmp	dword ptr [r14+0x64], 2
	jle	$_0741
	cmp	byte ptr [rbx+0x20], 58
	jz	$_0733
	cmp	byte ptr [rbx+0x20], 13
	jne	$_0741
$_0733: test	byte ptr [Options+0x5+rip], 0x20
	jz	$_0736
	mov	r9, qword ptr [rbx+0x58]
	mov	r8, qword ptr [rbx+0x30]
	mov	rdx, qword ptr [rbx+0x10]
	lea	rcx, [DS0004+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0734
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0734: cmp	qword ptr [r14+0x1F8], 0
	jz	$_0735
	xor	r8d, r8d
	xor	edx, edx
	mov	ecx, 7
	call	LstWrite@PLT
$_0735: call	RunLineQueue@PLT
	xor	eax, eax
	jmp	$_0987

$_0736: mov	ecx, dword ptr [r14+0x234]
	call	MemAlloc@PLT
	mov	rdi, rax
	mov	rdx, qword ptr [rbx+0x58]
	mov	rcx, rdi
	call	tstrcpy@PLT
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, qword ptr [r14+0x1D8]
	call	tstrcpy@PLT
	mov	rdx, qword ptr [rbx+0x30]
	mov	rcx, qword ptr [r14+0x1D8]
	call	tstrcat@PLT
	xor	r9d, r9d
	mov	r8, rbx
	xor	edx, edx
	mov	rcx, qword ptr [r14+0x1D8]
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
	mov	rcx, rbx
	call	ParseLine
	cmp	eax, -1
	jnz	$_0737
	mov	rcx, rdi
	call	MemFree@PLT
	mov	rax, -1
	jmp	$_0987

$_0737: test	byte ptr [r14], 0x08
	jz	$_0738
	and	byte ptr [r14+0x16], 0xFE
$_0738: mov	rdx, rdi
	mov	rcx, qword ptr [r14+0x1D8]
	call	tstrcpy@PLT
	mov	rcx, rdi
	call	MemFree@PLT
	xor	r9d, r9d
	mov	r8, rbx
	xor	edx, edx
	mov	rcx, qword ptr [r14+0x1D8]
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
	mov	rdx, rbx
	mov	rcx, qword ptr [r14+0x1D8]
	call	ExpandLine@PLT
	cmp	eax, -2
	jz	$_0739
	cmp	eax, -1
	jnz	$_0740
$_0739: jmp	$_0987

$_0740: jmp	$_0749

$_0741: cmp	byte ptr [rbx], 8
	jne	$_0749
	cmp	byte ptr [rbx+0x20], 58
	jz	$_0742
	cmp	byte ptr [rbx+0x20], 13
	jne	$_0749
$_0742: mov	dword ptr [rbp-0x4], 2
	test	dword ptr [ProcStatus+rip], 0x80
	jz	$_0743
	mov	rcx, rbx
	call	write_prologue@PLT
$_0743: xor	eax, eax
	test	byte ptr [r14+0x3], 0x01
	jz	$_0744
	cmp	qword ptr [CurrProc+rip], 0
	jz	$_0744
	cmp	byte ptr [rbx+0x20], 13
	jz	$_0744
	inc	eax
$_0744: mov	dword ptr [rsp+0x20], eax
	xor	r9d, r9d
	mov	r8d, 129
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, rbx
	call	CreateLabel@PLT
	test	rax, rax
	jnz	$_0745
	mov	rax, -1
	jmp	$_0987

$_0745: cmp	byte ptr [rbx+0x20], 13
	jnz	$_0746
	test	byte ptr [r14+0x3], 0x01
	jz	$_0746
	cmp	qword ptr [CurrProc+rip], 0
	jnz	$_0746
	mov	byte ptr [rbx+0x20], 0
	mov	dword ptr [r14+0x64], 1
	mov	rdx, qword ptr [rbp+0x28]
	mov	ecx, 4294967295
	call	PublicDirective@PLT
$_0746: lea	rsi, [rbx+0x40]
	cmp	byte ptr [rsi], 0
	jnz	$_0749
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0747
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0747: cmp	qword ptr [r14+0x1F8], 0
	jz	$_0748
	xor	r8d, r8d
	xor	edx, edx
	mov	ecx, 7
	call	LstWrite@PLT
$_0748: xor	eax, eax
	jmp	$_0987

$_0749: imul	esi, dword ptr [rbp-0x4], 32
	add	rsi, rbx
	mov	dword ptr [rbp-0x8], 0
	mov	byte ptr [rbp-0x97], 0
	cmp	qword ptr [r14+0x2F0], 0
	jz	$_0751
	cmp	byte ptr [rbx], 6
	jnz	$_0750
	cmp	byte ptr [rbx+0x20], 3
	jnz	$_0750
	cmp	dword ptr [rbx+0x24], 605
	jnz	$_0750
	inc	dword ptr [rbp-0x8]
$_0750: jmp	$_0752

$_0751: cmp	byte ptr [rbx], 3
	jnz	$_0752
	cmp	dword ptr [rbx+0x4], 500
	jnz	$_0752
	mov	byte ptr [rbx], 8
	mov	rax, qword ptr [rbx+0x30]
	mov	qword ptr [rbx+0x10], rax
	mov	eax, dword ptr [rbx+0x28]
	mov	dword ptr [rbx+0x8], eax
	mov	eax, dword ptr [rbx+0x2C]
	mov	dword ptr [rbx+0xC], eax
	mov	al, byte ptr [rbx+0x23]
	mov	byte ptr [rbx+0x3], al
	mov	byte ptr [rbx+0x20], 3
	mov	dword ptr [rbx+0x24], 604
	mov	byte ptr [rbx+0x21], 32
$_0752: cmp	dword ptr [rbp-0x8], 0
	jnz	$_0753
	cmp	byte ptr [rsi], 1
	je	$_0811
$_0753: mov	byte ptr [Frame_Type+rip], 6
	mov	qword ptr [SegOverride+rip], 0
	cmp	dword ptr [rbp-0x4], 0
	jnz	$_0759
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_0754
	cmp	byte ptr [rbx], 8
	jnz	$_0759
$_0754: cmp	byte ptr [rbx+0x20], 3
	jnz	$_0755
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
	jmp	$_0759

$_0755: mov	rcx, qword ptr [rbx+0x10]
	call	$_0697
	mov	qword ptr [rbp-0x20], rax
	test	rax, rax
	jnz	$_0756
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
	jmp	$_0759

$_0756: cmp	qword ptr [CurrStruct+rip], 0
	jz	$_0759
	xor	eax, eax
	cmp	byte ptr [rbx+0x20], 6
	jnz	$_0757
	inc	eax
	jmp	$_0758

$_0757: cmp	byte ptr [rbx+0x20], 8
	jnz	$_0758
	mov	rcx, qword ptr [rbx+0x30]
	call	$_0697
$_0758: test	rax, rax
	jz	$_0759
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
$_0759: movzx	eax, byte ptr [rsi]
	jmp	$_0788

$_0760: cmp	byte ptr [rsi+0x1], 8
	jnz	$_0761
	xor	r8d, r8d
	mov	rdx, qword ptr [rbp+0x28]
	mov	ecx, dword ptr [rbp-0x4]
	call	data_dir@PLT
	jmp	$_0987

$_0761: mov	eax, dword ptr [rsi+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	dword ptr [rbp-0x14], eax
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_0762
	cmp	qword ptr [CurrStruct+rip], 0
	jz	$_0767
	test	byte ptr [rbp-0x14], 0x10
	jz	$_0767
$_0762: cmp	dword ptr [rsi+0x4], 605
	jz	$_0763
	mov	ecx, 2037
	call	asmerr@PLT
	jmp	$_0987

$_0763: cmp	dword ptr [StoreState+rip], 0
	jz	$_0764
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0764
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0764: mov	rdx, qword ptr [rbp+0x28]
	mov	ecx, dword ptr [rbp-0x4]
	call	ProcType@PLT
	mov	edi, eax
	test	byte ptr [r14], 0x08
	jz	$_0766
	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_0765
	cmp	dword ptr [r14+0x60], 0
	jnz	$_0765
	cmp	dword ptr [UseSavedState+rip], 0
	jnz	$_0766
$_0765: call	LstWriteSrcLine@PLT
$_0766: mov	eax, edi
	jmp	$_0987

$_0767: test	byte ptr [rbp-0x14], 0x08
	jz	$_0769
	cmp	dword ptr [rbp-0x4], 0
	jz	$_0768
	cmp	byte ptr [rbx], 8
	jz	$_0768
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0768: jmp	$_0770

$_0769: cmp	dword ptr [rbp-0x4], 0
	jz	$_0770
	cmp	byte ptr [rsi-0x20], 58
	jz	$_0770
	cmp	byte ptr [rsi-0x20], 13
	jz	$_0770
	mov	rdx, qword ptr [rsi-0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0770: test	dword ptr [ProcStatus+rip], 0x80
	jz	$_0771
	test	byte ptr [rbp-0x14], 0x40
	jz	$_0771
	mov	rcx, qword ptr [rbp+0x28]
	call	write_prologue@PLT
$_0771: cmp	dword ptr [StoreState+rip], 0
	jnz	$_0772
	test	dword ptr [rbp-0x14], 0x80
	jz	$_0773
$_0772: cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0773
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0773: movzx	eax, byte ptr [rsi+0x1]
	cmp	eax, 8
	jbe	$_0774
	lea	rcx, [directive_tab+rip]
	mov	rax, qword ptr [rcx+rax*8]
	mov	rdx, rbx
	mov	ecx, dword ptr [rbp-0x4]
	call	rax
	mov	edi, eax
	jmp	$_0779

$_0774: mov	edi, 4294967295
	mov	eax, dword ptr [rsi+0x4]
	jmp	$_0778

$_0775: mov	ecx, 1008
	call	asmerr@PLT
	jmp	$_0779

$_0776: mov	ecx, 2170
	call	asmerr@PLT
	jmp	$_0779

$_0777: mov	rdx, qword ptr [rsi+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0779

$_0778: cmp	eax, 572
	jz	$_0775
	cmp	eax, 503
	jz	$_0776
	cmp	eax, 571
	jz	$_0776
	cmp	eax, 573
	jz	$_0776
	jmp	$_0777

$_0779: test	byte ptr [r14], 0x08
	jz	$_0781
	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_0780
	cmp	dword ptr [r14+0x60], 0
	jnz	$_0780
	cmp	dword ptr [UseSavedState+rip], 0
	jnz	$_0781
$_0780: call	LstWriteSrcLine@PLT
$_0781: mov	eax, edi
	jmp	$_0987

$_0782: cmp	dword ptr [rsi+0x4], 335
	jnz	$_0789
$_0783: xor	r8d, r8d
	mov	rdx, rbx
	mov	ecx, dword ptr [rbp-0x4]
	call	data_dir@PLT
	jmp	$_0987

$_0784: mov	rcx, qword ptr [rsi+0x10]
	call	$_0697
	test	rax, rax
	jz	$_0785
	test	byte ptr [rsi+0x2], 0x08
	jnz	$_0789
	mov	r8, rax
	mov	rdx, rbx
	mov	ecx, dword ptr [rbp-0x4]
	call	data_dir@PLT
	jmp	$_0987

$_0785: jmp	$_0789

$_0786: cmp	byte ptr [rsi], 58
	jnz	$_0787
	lea	rdx, [DS0005+rip]
	mov	ecx, 2065
	call	asmerr@PLT
	jmp	$_0987

$_0787: jmp	$_0789

$_0788: cmp	eax, 3
	je	$_0760
	cmp	eax, 5
	jz	$_0782
	cmp	eax, 6
	jz	$_0783
	cmp	eax, 8
	jz	$_0784
	jmp	$_0786

$_0789: cmp	dword ptr [rbp-0x4], 0
	jz	$_0790
	cmp	byte ptr [rsi-0x20], 8
	jnz	$_0790
	dec	dword ptr [rbp-0x4]
	sub	rsi, 32
$_0790: cmp	dword ptr [rbp-0x4], 0
	jnz	$_0791
	cmp	byte ptr [rbx+0x1], 123
	je	$_0803
$_0791: cmp	qword ptr [CurrEnum+rip], 0
	jz	$_0792
	cmp	byte ptr [rbx], 9
	jnz	$_0792
	mov	rdx, rbx
	xor	ecx, ecx
	call	EnumDirective@PLT
	jmp	$_0987

$_0792: cmp	dword ptr [rbp-0x4], 0
	jne	$_0801
	cmp	dword ptr [r14+0x64], 1
	jle	$_0801
	cmp	byte ptr [rbx], 8
	jnz	$_0796
	mov	rcx, qword ptr [rbx+0x10]
	mov	eax, dword ptr [rcx]
	or	eax, 0x20202020
	mov	cl, byte ptr [rcx+0x4]
	cmp	eax, 2019915365
	jnz	$_0793
	test	cl, cl
	jnz	$_0793
	or	byte ptr [rbp-0x97], 0x08
	jmp	$_0802

	jmp	$_0796

$_0793: cmp	eax, 544761206
	jnz	$_0794
	or	byte ptr [rbp-0x97], 0x01
	jmp	$_0802

	jmp	$_0796

$_0794: cmp	eax, 846751094
	jnz	$_0795
	test	cl, cl
	jnz	$_0795
	or	byte ptr [rbp-0x97], 0x02
	jmp	$_0802

	jmp	$_0796

$_0795: cmp	eax, 863528310
	jnz	$_0796
	test	cl, cl
	jnz	$_0796
	or	byte ptr [rbp-0x97], 0x04
	jmp	$_0802

$_0796: lea	rcx, [rbx+0x20]
	call	GetOperator@PLT
	test	rax, rax
	jz	$_0797
	mov	rcx, qword ptr [rbp+0x28]
	call	ProcessOperator@PLT
	jmp	$_0987

$_0797: cmp	byte ptr [rbx], 5
	jnz	$_0798
	cmp	dword ptr [rbx+0x4], 337
	jz	$_0799
$_0798: cmp	byte ptr [rbx], 4
	jnz	$_0801
	cmp	dword ptr [rbx+0x4], 327
	jnz	$_0801
$_0799: mov	ecx, dword ptr [rbx+0x4]
	call	RemoveResWord@PLT
	mov	byte ptr [rbx], 8
	mov	rcx, rbx
	call	PreprocessLine@PLT
	test	rax, rax
	jz	$_0800
	mov	rcx, rbx
	call	ParseLine
$_0800: jmp	$_0987

$_0801: mov	rdx, qword ptr [rsi+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0802: inc	dword ptr [rbp-0x4]
	add	rsi, 32
	jmp	$_0811

$_0803: cmp	dword ptr [rbp-0x4], 0
	jnz	$_0811
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_0811
	mov	rcx, qword ptr [rbx+0x10]
	mov	eax, dword ptr [rcx]
	cmp	dword ptr [rbx+0x4], 4
	jnz	$_0810
	or	eax, 0x20202020
	jmp	$_0808

$_0804: or	byte ptr [rbp-0x97], 0x08
	jmp	$_0802

$_0805: or	byte ptr [rbp-0x97], 0x02
	jmp	$_0802

$_0806: or	byte ptr [rbp-0x97], 0x04
	jmp	$_0802

$_0807: or	byte ptr [rbp-0x97], 0x80
	jmp	$_0802

	jmp	$_0809

$_0808: cmp	eax, 2019915365
	jz	$_0804
	cmp	eax, 846751094
	jz	$_0805
	cmp	eax, 863528310
	jz	$_0806
	cmp	eax, 1885435763
	jz	$_0807
$_0809: jmp	$_0811

$_0810: cmp	dword ptr [rbx+0x4], 3
	jnz	$_0811
	cmp	eax, 7890294
	jnz	$_0811
	or	byte ptr [rbp-0x97], 0x01
	jmp	$_0802

$_0811: cmp	qword ptr [CurrStruct+rip], 0
	jz	$_0812
	mov	ecx, 2037
	call	asmerr@PLT
	jmp	$_0987

$_0812: test	dword ptr [ProcStatus+rip], 0x80
	jz	$_0813
	mov	rcx, rbx
	call	write_prologue@PLT
$_0813: cmp	qword ptr [r14+0x1F8], 0
	jz	$_0814
	call	GetCurrOffset@PLT
	mov	dword ptr [rbp-0x24], eax
$_0814: mov	dl, byte ptr [rbp-0x97]
	xor	eax, eax
	mov	ecx, 28
	lea	rdi, [rbp-0x98]
	rep stosd
	mov	dword ptr [rbp-0x80], -2
	mov	dword ptr [rbp-0x7C], -2
	mov	byte ptr [rbp-0x90], 192
	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rbp-0x8F], al
	mov	byte ptr [rbp-0x97], dl
	mov	eax, dword ptr [rsi+0x4]
	mov	ecx, dword ptr [rsi+0x24]
	cmp	eax, 755
	jnz	$_0816
	cmp	ecx, 1323
	jz	$_0815
	cmp	ecx, 1324
	jnz	$_0816
$_0815: xchg	ecx, eax
$_0816: cmp	eax, 1323
	jz	$_0817
	cmp	eax, 1324
	jne	$_0825
$_0817: cmp	eax, 1323
	jnz	$_0818
	mov	byte ptr [rbp-0x88], 242
	jmp	$_0819

$_0818: mov	byte ptr [rbp-0x88], 243
$_0819: mov	edx, eax
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
	mov	eax, ecx
	cmp	eax, 755
	jnz	$_0822
	cmp	dword ptr [rsi+0x24], 779
	jz	$_0820
	cmp	dword ptr [rsi+0x24], 840
	jnz	$_0822
$_0820: cmp	edx, 1323
	jnz	$_0821
	cmp	dword ptr [rsi+0x24], 779
	jnz	$_0821
	mov	ecx, 2068
	call	asmerr@PLT
$_0821: inc	dword ptr [rbp-0x4]
	add	rsi, 32
	mov	eax, dword ptr [rsi+0x4]
	jmp	$_0825

$_0822: cmp	edx, 1323
	jnz	$_0824
	cmp	eax, 779
	jz	$_0823
	cmp	dword ptr [rsi+0x24], 779
	jnz	$_0824
$_0823: mov	ecx, 2068
	call	asmerr@PLT
	jmp	$_0825

$_0824: cmp	eax, 840
	jz	$_0825
	cmp	eax, 779
	jz	$_0825
	mov	eax, 755
	cmp	ecx, 755
	jz	$_0825
	sub	rsi, 32
	dec	dword ptr [rbp-0x4]
$_0825: cmp	eax, 755
	jc	$_0826
	cmp	eax, 760
	ja	$_0826
	mov	dword ptr [rbp-0x80], eax
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
	cmp	byte ptr [rsi], 1
	jz	$_0826
	mov	ecx, 2068
	call	asmerr@PLT
	jmp	$_0987

$_0826: cmp	qword ptr [CurrProc+rip], 0
	je	$_0832
	mov	eax, dword ptr [rsi+0x4]
	jmp	$_0831

$_0827: test	byte ptr [ProcStatus+rip], 0x02
	jnz	$_0829
	cmp	byte ptr [r14+0x21], 2
	jz	$_0829
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0828
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0828: or	byte ptr [ProcStatus+rip], 0x02
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x28]
	mov	ecx, dword ptr [rbp-0x4]
	call	RetInstr@PLT
	and	dword ptr [ProcStatus+rip], 0xFFFFFFFD
	jmp	$_0987

$_0829: cmp	eax, 823
	jnz	$_0830
	mov	rax, qword ptr [CurrProc+rip]
	cmp	byte ptr [rax+0x1E], 130
	jnz	$_0830
	mov	dword ptr [rsi+0x4], 825
$_0830: jmp	$_0832

$_0831: cmp	eax, 823
	jz	$_0827
	cmp	eax, 801
	jz	$_0827
	cmp	eax, 802
	jz	$_0827
	cmp	eax, 1329
	je	$_0827
$_0832: test	byte ptr [rbx+0x2], 0x40
	je	$_0841
	lea	rsi, [rbx+0x20]
	mov	dword ptr [rbp-0x8], 1
$_0833: cmp	byte ptr [rsi], 0
	je	$_0841
	test	byte ptr [rsi+0x2], 0x08
	je	$_0840
	mov	byte ptr [rbp-0x239], 0
	mov	ecx, dword ptr [r14+0x234]
	cmp	ecx, 2048
	jbe	$_0834
	mov	byte ptr [rbp-0x239], 1
	call	MemAlloc@PLT
	jmp	$_0835

$_0834: mov	eax, ecx
	add	eax, 15
	and	eax, 0xFFFFFFF0
	sub	rsp, rax
	lea	rax, [rsp+0x30]
$_0835: mov	rdi, rax
	mov	r8, rbx
	mov	edx, dword ptr [rbp-0x8]
	mov	rcx, rdi
	call	ExpandHllProcEx@PLT
	mov	dword ptr [rbp-0x10], eax
	cmp	byte ptr [rbp-0x239], 0
	jz	$_0836
	mov	rcx, rdi
	call	MemFree@PLT
$_0836: cmp	dword ptr [rbp-0x10], -1
	jnz	$_0837
	mov	rax, -1
	jmp	$_0987

$_0837: cmp	dword ptr [rbp-0x10], 1
	jnz	$_0839
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0838
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0838: xor	eax, eax
	jmp	$_0987

$_0839: jmp	$_0841

$_0840: inc	dword ptr [rbp-0x8]
	add	rsi, 32
	jmp	$_0833

$_0841: cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0842
	mov	rcx, qword ptr [r14+0x1D8]
	call	StoreLine@PLT
$_0842: imul	esi, dword ptr [rbp-0x4], 32
	add	rsi, rbx
	mov	eax, dword ptr [rsi+0x4]
	mov	dword ptr [rbp-0x84], eax
	lea	rcx, [ResWordTable+rip]
	mov	cl, byte ptr [rcx+rax*8+0x3]
	mov	byte ptr [rbp-0x91], cl
	lea	r11, [optable_idx+rip]
	movzx	eax, word ptr [r11+rax*2-0x4E8]
	lea	rax, [r12+rax*8+0x2740]
	mov	qword ptr [rbp-0x30], rax
	inc	dword ptr [rbp-0x4]
	add	rsi, 32
	mov	rax, qword ptr [r14+0x38]
	test	rax, rax
	jnz	$_0843
	mov	ecx, 2034
	call	asmerr@PLT
	jmp	$_0987

$_0843: mov	rax, qword ptr [rax+0x78]
	cmp	dword ptr [rax+0x48], 0
	jnz	$_0844
	mov	dword ptr [rax+0x48], 1
$_0844: cmp	byte ptr [r14+0x1F], 0
	jz	$_0845
	xor	ecx, ecx
	call	omf_OutSelect@PLT
$_0845: mov	dword ptr [rbp-0x8], 0
$_0846: cmp	dword ptr [rbp-0x8], 4
	jge	$_0881
	cmp	byte ptr [rsi], 0
	je	$_0881
	cmp	dword ptr [rbp-0x8], 0
	jz	$_0847
	cmp	byte ptr [rsi], 44
	jne	$_0881
	inc	dword ptr [rbp-0x4]
$_0847: imul	edi, dword ptr [rbp-0x8], 104
	lea	rcx, [rbp+rdi-0x238]
	mov	byte ptr [rsp+0x20], 0
	mov	r9, rcx
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x28]
	lea	rcx, [rbp-0x4]
	call	EvalOperand@PLT
	cmp	eax, -1
	jnz	$_0848
	jmp	$_0987

$_0848: imul	esi, dword ptr [rbp-0x4], 32
	add	rsi, qword ptr [rbp+0x28]
	test	byte ptr [rsi-0x1E], 0x10
	je	$_0856
	lea	rbx, [rsi-0x20]
	cmp	byte ptr [rbx], 9
	jne	$_0855
	mov	rax, qword ptr [rbx+0x10]
	cmp	byte ptr [rax], 0
	jnz	$_0850
	cmp	byte ptr [rbx+0x20], 0
	jnz	$_0850
	cmp	dword ptr [rbp+rdi-0x1FC], 0
	jnz	$_0850
	lea	rcx, [rbp+rdi-0x238]
	call	$_0722
	test	eax, eax
	jnz	$_0849
	mov	rdx, qword ptr [rbx-0x8]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0849: jmp	$_0853

$_0850: or	byte ptr [rbp-0x97], 0x08
$_0851: lea	rdx, [rbp-0x98]
	mov	rcx, qword ptr [rbx+0x10]
	call	$_0700
	test	eax, eax
	jnz	$_0852
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0852: sub	rbx, 32
	test	byte ptr [rbx+0x2], 0x10
	jnz	$_0851
$_0853: cmp	dword ptr [rbp+rdi-0x1FC], -2
	jnz	$_0854
	dec	dword ptr [rbp-0x8]
	jmp	$_0880

$_0854: jmp	$_0856

$_0855: or	byte ptr [rbp-0x97], 0x08
	or	byte ptr [rbp-0x94], 0x10
	or	byte ptr [rbp-0x93], 0x01
$_0856: mov	eax, dword ptr [rbp+rdi-0x1FC]
	jmp	$_0879

$_0857: cmp	dword ptr [rbp-0x8], 1
	jz	$_0858
	cmp	dword ptr [rbp-0x84], 774
	jz	$_0858
	cmp	dword ptr [rbp-0x84], 738
	jne	$_0870
$_0858: test	byte ptr [Options+0x6+rip], 0x10
	jne	$_0869
	cmp	byte ptr [rbp+rdi-0x1F4], 192
	je	$_0869
	movzx	eax, byte ptr [r14+0x6]
	cmp	dword ptr [rbp-0x8], 0
	jz	$_0861
	cmp	dword ptr [rbp+rdi-0x264], 2
	jnz	$_0859
	test	byte ptr [rbp+rdi-0x260], 0x01
	jnz	$_0859
	mov	rax, qword ptr [rbp+rdi-0x288]
	mov	ecx, dword ptr [rax+0x4]
	call	SizeFromRegister
	jmp	$_0861

$_0859: cmp	dword ptr [rbp+rdi-0x264], 1
	jz	$_0860
	cmp	dword ptr [rbp+rdi-0x264], 2
	jnz	$_0861
$_0860: mov	r8, qword ptr [rbp+rdi-0x240]
	movzx	edx, byte ptr [rbp+rdi-0x25A]
	movzx	ecx, byte ptr [rbp+rdi-0x25C]
	call	SizeFromMemtype
$_0861: xor	ecx, ecx
	jmp	$_0866

$_0862: mov	ecx, 33
	jmp	$_0867

$_0863: mov	ecx, 35
	jmp	$_0867

$_0864: mov	ecx, 39
	jmp	$_0867

$_0865: mov	ecx, 47
	jmp	$_0867

$_0866: cmp	eax, 2
	jz	$_0862
	cmp	eax, 4
	jz	$_0863
	cmp	eax, 8
	jz	$_0864
	cmp	eax, 16
	jz	$_0865
$_0867: test	ecx, ecx
	jz	$_0869
	lea	rdx, [rbp+rdi-0x238]
	mov	dword ptr [rbp+rdi-0x1FC], 0
	cmp	cl, byte ptr [rbp+rdi-0x1F4]
	jz	$_0868
	cmp	eax, 16
	jz	$_0868
	mov	byte ptr [rbp+rdi-0x1F4], cl
	mov	rcx, rdx
	mov	edx, eax
	call	quad_resize@PLT
$_0868: jmp	$_0880

$_0869: mov	ecx, 2050
	call	asmerr@PLT
	jmp	$_0987

$_0870: cmp	dword ptr [rbp-0x4], 1
	jle	$_0877
	cmp	byte ptr [rsi], 3
	jne	$_0877
	cmp	dword ptr [rsi+0x4], 504
	jne	$_0877
	mov	byte ptr [rbp-0x239], 0
	mov	ecx, dword ptr [r14+0x234]
	cmp	ecx, 2048
	jbe	$_0871
	mov	byte ptr [rbp-0x239], 1
	call	MemAlloc@PLT
	jmp	$_0872

$_0871: mov	eax, ecx
	add	eax, 15
	and	eax, 0xFFFFFFF0
	sub	rsp, rax
	lea	rax, [rsp+0x30]
$_0872: mov	rbx, rax
	mov	rax, qword ptr [rbp+0x28]
	mov	rax, qword ptr [rax+0x18]
	mov	rcx, qword ptr [rsi+0x18]
	sub	rcx, rax
	mov	rsi, rax
	mov	rdi, rbx
	rep movsb
	cmp	byte ptr [r14+0x4], 2
	jnz	$_0873
	mov	eax, 7889266
	jmp	$_0874

$_0873: mov	eax, 7889253
$_0874: stosd
	mov	rdx, qword ptr [rbp+0x28]
	mov	ecx, dword ptr [rbp-0x4]
	call	NewDirective@PLT
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_0875
	mov	rdx, rbx
	mov	rcx, qword ptr [r14+0x1D8]
	call	tstrcpy@PLT
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x28]
	xor	edx, edx
	mov	rcx, rax
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
	mov	rcx, rbx
	call	MemFree@PLT
	mov	rcx, qword ptr [rbp+0x28]
	call	ParseLine
	jmp	$_0987

$_0875: cmp	byte ptr [rbp-0x239], 0
	jz	$_0876
	mov	rcx, rbx
	call	MemFree@PLT
$_0876: xor	eax, eax
	jmp	$_0987

$_0877: mov	eax, dword ptr [r14+0x64]
	cmp	dword ptr [rbp-0x4], eax
	jnz	$_0878
	sub	rsi, 32
$_0878: mov	rdx, qword ptr [rsi+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

	jmp	$_0880

$_0879: cmp	eax, 3
	je	$_0857
	cmp	eax, -2
	je	$_0870
	cmp	eax, -1
	jz	$_0878
$_0880: inc	dword ptr [rbp-0x8]
	jmp	$_0846

$_0881: cmp	byte ptr [rsi], 0
	jz	$_0882
	mov	rdx, qword ptr [rsi+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0882: mov	dword ptr [rbp-0xC], 0
	xor	ebx, ebx
$_0883: cmp	ebx, dword ptr [rbp-0x8]
	jge	$_0924
	cmp	ebx, 3
	jnc	$_0924
	mov	byte ptr [Frame_Type+rip], 6
	mov	qword ptr [SegOverride+rip], 0
	imul	edx, ebx, 104
	mov	eax, dword ptr [rbp-0x84]
	mov	ecx, dword ptr [rbp-0x78]
	cmp	eax, 1442
	jc	$_0910
	cmp	ebx, 1
	jne	$_0910
	test	ecx, 0x507F7C
	je	$_0910
	lea	rdi, [vex_flags+rip]
	movzx	edi, byte ptr [rdi+rax-0x5A2]
	cmp	eax, 1726
	jc	$_0884
	cmp	eax, 1734
	jbe	$_0885
$_0884: test	ecx, 0xC
	jz	$_0885
	jmp	$_0910

$_0885: test	edi, 0x2
	jz	$_0887
	cmp	eax, 2400
	jnz	$_0886
	cmp	dword ptr [rbp-0x8], 3
	jz	$_0887
$_0886: jmp	$_0910

$_0887: test	edi, 0x8
	jz	$_0889
	cmp	dword ptr [rbp-0x12C], 0
	jnz	$_0889
	cmp	dword ptr [rbp-0x8], 2
	jle	$_0889
	test	byte ptr [rbp-0x91], 0x20
	jz	$_0888
	mov	rcx, qword ptr [rbp-0x220]
	mov	al, byte ptr [rcx+0x1]
	and	byte ptr [rbp-0x96], 0xFE
	and	byte ptr [rbp-0x95], 0xEF
	inc	al
	mov	byte ptr [rbp-0x8B], al
	and	byte ptr [rbp-0x8E], 0xC0
$_0888: jmp	$_0910

$_0889: test	edi, 0x20
	jz	$_0890
	test	ecx, 0x70
	jz	$_0890
	test	byte ptr [rbp+rdx-0x1F8], 0x01
	jz	$_0890
	mov	byte ptr [rbp-0x8E], 0
	jmp	$_0910

$_0890: test	edi, 0x10
	jz	$_0893
	test	ecx, 0x401F00
	jnz	$_0892
	cmp	eax, 1561
	jz	$_0891
	cmp	eax, 1562
	jnz	$_0893
$_0891: cmp	dword ptr [rbp-0x194], 2
	jnz	$_0892
	test	byte ptr [rbp-0x190], 0x01
	jz	$_0893
$_0892: jmp	$_0910

$_0893: cmp	dword ptr [rbp-0x194], 2
	jz	$_0894
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0987

$_0894: mov	rax, qword ptr [rbp+rdx-0x220]
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	test	dword ptr [r12+rax*8], 0x10007C
	jnz	$_0895
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0987

$_0895: cmp	dword ptr [rbp-0x8], 2
	jg	$_0897
	test	byte ptr [rbp-0x91], 0x10
	jz	$_0896
	inc	dword ptr [rbp-0x8]
$_0896: jmp	$_0909

$_0897: test	edi, 0x4
	je	$_0900
	cmp	dword ptr [rbp-0x12C], 0
	jnz	$_0900
	cmp	qword ptr [rbp-0x220], 0
	jz	$_0899
	mov	rcx, qword ptr [rbp+rdx-0x220]
	mov	eax, dword ptr [rcx+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	rcx, qword ptr [rbp-0x220]
	mov	cl, byte ptr [rcx+0x1]
	inc	cl
	mov	byte ptr [rbp-0x8A], cl
	lea	rdi, [rbp-0x238]
	lea	rax, [rbp+rdx-0x238]
	xchg	rsi, rax
	mov	ecx, 312
	rep movsb
	mov	rsi, rax
	mov	byte ptr [rbp-0x8E], 0
	mov	r9d, dword ptr [rbp-0xC]
	lea	r8, [rbp-0x238]
	xor	edx, edx
	lea	rcx, [rbp-0x98]
	call	$_0483
	cmp	eax, -1
	jnz	$_0898
	jmp	$_0987

$_0898: inc	dword ptr [rbp-0xC]
$_0899: jmp	$_0909

$_0900: mov	rcx, qword ptr [rbp+rdx-0x220]
	mov	eax, dword ptr [rcx+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	ecx, dword ptr [rbp-0x78]
	cmp	ecx, 4202240
	jnz	$_0901
	jmp	$_0904

$_0901: test	eax, 0x1010
	jz	$_0902
	test	ecx, 0x2020
	jnz	$_0903
$_0902: test	eax, 0x2020
	jz	$_0904
	test	ecx, 0x1010
	jz	$_0904
	test	edi, 0x20
	jnz	$_0904
$_0903: mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_0987

$_0904: mov	edi, eax
	mov	rcx, qword ptr [rbp+rdx-0x220]
	mov	al, byte ptr [rcx+0x1]
	inc	al
	mov	byte ptr [rbp-0x8A], al
	test	edi, 0x40
	jz	$_0905
	or	byte ptr [rbp-0x89], 0x02
	or	byte ptr [rbp-0x93], 0x10
	jmp	$_0906

$_0905: test	edi, 0x20
	jz	$_0906
	or	byte ptr [rbp-0x89], 0x01
$_0906: cmp	byte ptr [rbp-0x8A], 16
	ja	$_0907
	test	edi, 0x40
	jz	$_0908
$_0907: or	byte ptr [rbp-0x97], 0x08
$_0908: inc	dword ptr [rbp-0xC]
	lea	rdi, [rbp+rdx-0x238]
	lea	rax, [rbp+rdx-0x1D0]
	xchg	rsi, rax
	mov	ecx, 208
	rep movsb
	mov	rsi, rax
$_0909: dec	dword ptr [rbp-0x8]
$_0910: imul	edx, ebx, 104
	mov	eax, dword ptr [rbp+rdx-0x1FC]
	jmp	$_0922

$_0911: lea	r8, [rbp+rdx-0x238]
	mov	edx, ebx
	lea	rcx, [rbp-0x98]
	call	$_0441
	cmp	eax, -1
	jnz	$_0912
	jmp	$_0987

$_0912: jmp	$_0923

$_0913: lea	r8, [rbp+rdx-0x238]
	mov	edx, ebx
	lea	rcx, [rbp-0x98]
	call	$_0478
	cmp	eax, -1
	jnz	$_0914
	jmp	$_0987

$_0914: jmp	$_0923

$_0915: test	byte ptr [rbp+rdx-0x1F8], 0x01
	jz	$_0917
	lea	r8, [rbp+rdx-0x238]
	mov	edx, ebx
	lea	rcx, [rbp-0x98]
	call	$_0441
	cmp	eax, -1
	jnz	$_0916
	jmp	$_0987

$_0916: jmp	$_0921

$_0917: cmp	ebx, 2
	jnz	$_0920
	mov	rcx, qword ptr [rbp+rdx-0x220]
	mov	eax, dword ptr [rcx+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	mov	dword ptr [rbp-0x48], eax
	movzx	eax, byte ptr [rcx+0x1]
	mov	dword ptr [rbp-0x38], eax
	mov	rcx, qword ptr [rbp-0x30]
	test	byte ptr [rcx+0x4], 0x20
	jnz	$_0918
	test	byte ptr [rcx+0x4], 0x10
	jz	$_0919
$_0918: mov	cl, byte ptr [rbp-0x8C]
	and	cl, 0xF0
	or	al, cl
	mov	byte ptr [rbp-0x8C], al
$_0919: jmp	$_0921

$_0920: mov	r9d, dword ptr [rbp-0xC]
	lea	r8, [rbp-0x238]
	mov	edx, ebx
	lea	rcx, [rbp-0x98]
	call	$_0483
	cmp	eax, -1
	jnz	$_0921
	jmp	$_0987

$_0921: jmp	$_0923

$_0922: cmp	eax, 1
	je	$_0911
	cmp	eax, 0
	je	$_0913
	cmp	eax, 2
	je	$_0915
$_0923: inc	ebx
	inc	dword ptr [rbp-0xC]
	jmp	$_0883

$_0924: cmp	ebx, 2
	jne	$_0932
	cmp	dword ptr [rbp-0x1FC], 2
	jnz	$_0925
	cmp	dword ptr [rbp-0x194], 1
	jz	$_0926
$_0925: cmp	dword ptr [rbp-0x1FC], 1
	jne	$_0932
	cmp	dword ptr [rbp-0x194], 1
	je	$_0932
$_0926: mov	ecx, 1
	lea	rdi, [rbp-0x238]
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_0927
	add	rdi, 104
	dec	ecx
$_0927: mov	rbx, qword ptr [rdi+0x18]
	mov	rax, qword ptr [rdi+0x50]
	mov	rdx, qword ptr [rdi+0x58]
	test	rbx, rbx
	jz	$_0931
	test	rax, rax
	jz	$_0931
	test	rdx, rdx
	jz	$_0931
	test	byte ptr [rdi+0x40], 0x80
	jz	$_0931
	mov	rdx, qword ptr [rax+0x50]
	test	rdx, rdx
	jz	$_0931
	cmp	byte ptr [rax+0x1E], 195
	jnz	$_0931
	cmp	byte ptr [rax+0x49], 0
	jz	$_0931
	cmp	byte ptr [rdx+0x1D], 7
	jnz	$_0931
	cmp	byte ptr [rbx], 8
	jnz	$_0931
	cmp	byte ptr [rbx+0x20], 46
	jz	$_0928
	cmp	byte ptr [rbx+0x20], 91
	jnz	$_0931
$_0928: mov	dl, byte ptr [rbx-0x20]
	mov	dh, byte ptr [rbx-0x40]
	test	ecx, ecx
	jnz	$_0929
	cmp	byte ptr [rbx-0x60], 1
	jnz	$_0929
	cmp	dh, 2
	jnz	$_0929
	cmp	dl, 44
	jz	$_0930
$_0929: test	ecx, ecx
	jz	$_0931
	cmp	dh, 1
	jz	$_0930
	cmp	dl, 1
	jnz	$_0931
$_0930: mov	r8d, ecx
	mov	rdx, rbx
	mov	rcx, rax
	call	HandleIndirection@PLT
	jmp	$_0987

$_0931: mov	ebx, 2
$_0932: cmp	ebx, dword ptr [rbp-0x8]
	jz	$_0935
$_0933: cmp	byte ptr [rsi], 44
	jz	$_0934
	dec	dword ptr [rbp-0x4]
	sub	rsi, 32
	jmp	$_0933

$_0934: mov	rdx, qword ptr [rsi+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0935: test	byte ptr [rbp-0x98], 0x04
	jz	$_0937
	cmp	dword ptr [rbp-0x84], 628
	jz	$_0936
	cmp	dword ptr [rbp-0x84], 629
	jnz	$_0937
$_0936: add	qword ptr [rbp-0x30], 8
	mov	rdx, qword ptr [rbp-0x30]
	test	byte ptr [rdx+0x2], 0x08
	jz	$_0936
$_0937: mov	rdx, qword ptr [rbp-0x30]
	movzx	eax, byte ptr [rdx+0x2]
	and	eax, 0x07
	cmp	eax, 2
	jz	$_0938
	cmp	eax, 3
	jnz	$_0940
$_0938: test	byte ptr [r14+0x1], 0x08
	jnz	$_0939
	cmp	dword ptr [rbp-0x84], 709
	jnz	$_0939
	cmp	dword ptr [rbp-0x78], 16
	jnz	$_0939
	test	dword ptr [rbp-0x60], 0x400F0000
	jz	$_0939
	mov	r8d, 8
	lea	rdx, [rbp-0x1D0]
	mov	rcx, qword ptr [rbp+0x28]
	call	imm2xmm@PLT
	jmp	$_0987

$_0939: lea	rdx, [rbp-0x238]
	lea	rcx, [rbp-0x98]
	call	$_0532
	jmp	$_0986

$_0940: cmp	ebx, 1
	jbe	$_0951
	cmp	ebx, 2
	jbe	$_0946
	mov	rdx, qword ptr [rbp-0x30]
$_0941: movzx	eax, byte ptr [rdx]
	lea	rcx, [opnd_clstab3+rip]
	cmp	byte ptr [rcx+rax], 0
	jnz	$_0945
	add	rdx, 8
	test	byte ptr [rdx+0x2], 0x08
	jz	$_0944
$_0942: cmp	byte ptr [rsi], 44
	jz	$_0943
	sub	rsi, 32
	jmp	$_0942

$_0943: mov	rdx, qword ptr [rsi+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_0987

$_0944: jmp	$_0941

$_0945: mov	qword ptr [rbp-0x30], rdx
$_0946: cmp	dword ptr [rbp-0x84], 795
	jnz	$_0950
	mov	rax, qword ptr [rbp-0x58]
	test	rax, rax
	jz	$_0947
	mov	rax, qword ptr [rax+0x30]
$_0947: cmp	dword ptr [rbp-0x48], 0
	jnz	$_0949
	test	byte ptr [rbp-0x5E], 0x07
	jz	$_0949
	test	byte ptr [rbp-0x96], 0x01
	jz	$_0948
	or	byte ptr [rbp-0x96], 0x04
$_0948: mov	al, byte ptr [rbp-0x8E]
	mov	dl, al
	and	al, 0xC7
	and	dl, 0x07
	shl	dl, 3
	or	al, dl
	mov	byte ptr [rbp-0x8E], al
	jmp	$_0950

$_0949: cmp	dword ptr [rbp-0x48], 0
	jz	$_0950
	test	byte ptr [rbp-0x5E], 0x07
	jz	$_0950
	test	rax, rax
	jz	$_0950
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_0950
	mov	dword ptr [rbp-0x60], 4202240
$_0950: lea	rdx, [rbp-0x238]
	lea	rcx, [rbp-0x98]
	call	$_0578
	cmp	eax, -1
	jnz	$_0951
	jmp	$_0987

$_0951: cmp	byte ptr [rbp-0x8F], 2
	jne	LC055D
	test	byte ptr [rbp-0x98], 0x10
	jz	$_0952
	cmp	byte ptr [rbp-0x96], 0
	jz	$_0952
	mov	ecx, 2218
	call	asmerr@PLT
$_0952: mov	eax, dword ptr [rbp-0x84]
	cmp	eax, 1442
	jnc	$_0953
	cmp	eax, 1032
	jc	$_0953
	cmp	dword ptr [rbp-0x8], 1
	jle	$_0953
	cmp	dword ptr [rbp-0x194], 0
	jnz	$_0953
	mov	rdx, qword ptr [rbp-0x1C0]
	test	rdx, rdx
	jz	$_0953
	cmp	byte ptr [rdx], 9
	jnz	$_0953
	cmp	byte ptr [rdx+0x1], 123
	jnz	$_0953
	mov	eax, 1132
$_0953: mov	ecx, 4
	jmp	$_0962

$_0954: and	byte ptr [rbp-0x96], 0x07
	jmp	LC055D

$_0955: and	byte ptr [rbp-0x96], 0x07
	jmp	LC055D

$_0956: add	ecx, 8
$_0957: add	ecx, 4
$_0958: test	byte ptr [r14+0x1], 0x08
	jne	LC055D
	cmp	dword ptr [rbp-0x78], 16
	jne	LC055D
	test	dword ptr [rbp-0x60], 0x400F0000
	je	LC055D
	mov	r8d, ecx
	lea	rdx, [rbp-0x1D0]
	mov	rcx, qword ptr [rbp+0x28]
	call	imm2xmm@PLT
	jmp	$_0987

$_0959: test	byte ptr [rbp-0x75], 0x02
	jnz	$_0960
	test	byte ptr [rbp-0x5D], 0x02
	jz	$_0961
$_0960: and	byte ptr [rbp-0x96], 0x07
$_0961: jmp	LC055D

$_0962: cmp	eax, 1034
	jl	$_0963
	cmp	eax, 1059
	jg	$_0963
	lea	r11, [LC0579+rip]
	movzx	r10, byte ptr [r11+rax-0x404]
	movzx	r10, word ptr [r11+r10*2]
	lea	r11, [LC055D+rip]
	sub	r11, r10
	jmp	r11

$_0963: cmp	eax, 774
	je	$_0954
	cmp	eax, 775
	je	$_0954
	cmp	eax, 628
	je	$_0955
	cmp	eax, 629
	je	$_0955
	cmp	eax, 1432
	je	$_0955
	cmp	eax, 1433
	je	$_0955
	cmp	eax, 1132
	je	$_0956
	cmp	eax, 1130
	je	$_0957
	cmp	eax, 709
	je	$_0957
	cmp	eax, 1101
	je	$_0957
	cmp	eax, 1227
	je	$_0957
	cmp	eax, 1102
	je	$_0958
	cmp	eax, 1228
	je	$_0958
	cmp	eax, 1129
	je	$_0958
	cmp	eax, 1143
	je	$_0958
	cmp	eax, 779
	je	$_0959
LC055D: mov	eax, dword ptr [rbp-0x84]
	mov	ecx, dword ptr [rbp-0x78]
	mov	edx, dword ptr [rbp-0x60]
	test	ecx, 0x607F00
	jnz	$_0964
	test	edx, 0x607F00
	je	$_0975
$_0964: mov	rbx, qword ptr [rbp-0x178]
	test	ecx, 0x607F00
	jz	$_0965
	mov	rbx, qword ptr [rbp-0x1E0]
$_0965: test	rbx, rbx
	je	$_0975
	cmp	byte ptr [rbx+0x1D], 6
	jne	$_0975
	cmp	byte ptr [rbx+0x1E], 193
	jne	$_0975
	test	byte ptr [r14+0x1], 0x08
	jnz	$_0972
	test	byte ptr [rbx+0x11], 0x40
	jz	$_0972
	jmp	$_0971

$_0966: test	edx, 0xF0000
	jz	$_0967
	xor	ebx, ebx
$_0967: jmp	$_0972

$_0968: test	ecx, 0xF
	jz	$_0969
	xor	ebx, ebx
	jmp	$_0970

$_0969: test	edx, 0xF000F
	jz	$_0970
	xor	ebx, ebx
$_0970: jmp	$_0972

$_0971: cmp	eax, 679
	jz	$_0966
	cmp	eax, 682
	jz	$_0966
	cmp	eax, 684
	jz	$_0966
	cmp	eax, 834
	jz	$_0966
	cmp	eax, 685
	jz	$_0966
	cmp	eax, 779
	jz	$_0968
	cmp	eax, 816
	jz	$_0968
$_0972: test	rbx, rbx
	jnz	$_0973
	mov	ecx, eax
	lea	r8, [rbp-0x1D0]
	lea	rdx, [rbp-0x238]
	call	CRecordField@PLT
	jmp	$_0987

	jmp	$_0975

$_0973: test	ecx, 0xF00
	jz	$_0974
	test	edx, 0xF00
	jnz	$_0975
$_0974: mov	ecx, 2166
	call	asmerr@PLT
	jmp	$_0987

$_0975: test	byte ptr [r14+0x1], 0x08
	jne	$_0986
	test	ecx, 0x607F00
	jz	$_0978
	test	edx, 0x607F00
	jz	$_0978
	jmp	$_0977

$_0976: lea	r9, [rbp-0x238]
	mov	r8, qword ptr [rbp+0x28]
	call	mem2mem@PLT
	jmp	$_0987

	jmp	$_0978

$_0977: cmp	eax, 779
	jz	$_0976
	cmp	eax, 685
	jz	$_0976
	cmp	eax, 834
	jz	$_0976
	cmp	eax, 680
	jz	$_0976
	cmp	eax, 678
	jz	$_0976
	cmp	eax, 681
	jz	$_0976
	cmp	eax, 683
	jz	$_0976
	cmp	eax, 682
	jz	$_0976
	cmp	eax, 679
	jz	$_0976
	cmp	eax, 684
	jz	$_0976
	cmp	eax, 1102
	jz	$_0976
	cmp	eax, 1101
	jz	$_0976
$_0978: xor	ebx, ebx
	cmp	eax, 1102
	jnz	$_0979
	cmp	ecx, 1024
	jnz	$_0979
	test	edx, 0x400F0000
	jz	$_0979
	inc	ebx
	mov	ecx, 4
	jmp	LC05BB

$_0979: cmp	eax, 1101
	jnz	$_0980
	cmp	ecx, 2048
	jnz	$_0980
	test	edx, 0x400F0000
	jz	$_0980
	inc	ebx
	mov	ecx, 8
	jmp	LC05BB

$_0980: cmp	ecx, 16
	jne	LC05BB
	test	edx, 0x400F0000
	je	LC05BB
	mov	ecx, 4
	jmp	$_0984

$_0981: add	ecx, 8
$_0982: add	ecx, 4
$_0983: inc	ebx
	jmp	LC05BB

$_0984: cmp	eax, 1034
	jl	$_0985
	cmp	eax, 1059
	jg	$_0985
	lea	r11, [LC05BC+rip]
	movzx	r10, byte ptr [r11+rax-0x407]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC05BB+rip]
	sub	r11, r10
	jmp	r11

$_0985: cmp	eax, 1132
	jz	$_0981
	cmp	eax, 1130
	jz	$_0982
	cmp	eax, 709
	jz	$_0982
	cmp	eax, 1101
	jz	$_0982
	cmp	eax, 1227
	jz	$_0982
	cmp	eax, 1102
	jz	$_0983
	cmp	eax, 1228
	jz	$_0983
	cmp	eax, 1129
	jz	$_0983
	cmp	eax, 1143
	jz	$_0983
LC05BB: test	ebx, ebx
	jz	$_0986
	mov	r8d, ecx
	lea	rdx, [rbp-0x1D0]
	mov	rcx, qword ptr [rbp+0x28]
	call	imm2xmm@PLT
	jmp	$_0987

$_0986: mov	edx, dword ptr [rbp-0x24]
	lea	rcx, [rbp-0x98]
	call	codegen@PLT
$_0987: leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ProcessFile:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rcx, qword ptr [r14+0x1D8]
	call	GetTextLine@PLT
	test	byte ptr [r14+0x3], 0x40
	jnz	$_0990
	test	rax, rax
	jz	$_0990
	mov	rcx, qword ptr [r14+0x1D8]
	mov	eax, dword ptr [rcx]
	and	eax, 0xFFFFFF
	cmp	eax, 12565487
	jnz	$_0988
	lea	rax, [rcx+0x3]
	mov	rdx, rax
	call	tstrcpy@PLT
$_0988: mov	rcx, qword ptr [r14+0x1D0]
	call	PreprocessLine@PLT
	test	rax, rax
	jz	$_0989
	mov	rcx, qword ptr [r14+0x1D0]
	call	ParseLine
	test	byte ptr [Options+0x5+rip], 0x20
	jz	$_0989
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_0989
	mov	rcx, qword ptr [r14+0x1D8]
	call	WritePreprocessedLine@PLT
$_0989: mov	rcx, qword ptr [r14+0x1D8]
	call	GetTextLine@PLT
	test	byte ptr [r14+0x3], 0x40
	jnz	$_0990
	test	rax, rax
	jnz	$_0988
$_0990: leave
	ret


.SECTION .data
	.ALIGN	16

SegOverride:
	.quad  0x0000000000000000

LastRegOverride:
	.int   0x00000000

DS0000:
	.byte  0x50, 0x4F, 0x50, 0x20, 0x43, 0x53, 0x00, 0x00

LC0318:
	.byte  0x1D, 0x02, 0x0B, 0x02, 0x59, 0x01, 0x3E, 0x01
	.byte  0x80, 0x00, 0x38, 0x00, 0x00, 0x00, 0x01, 0x01
	.byte  0x01, 0x00, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05
	.byte  0x05, 0x05, 0x03, 0x03, 0x03, 0x02, 0x04, 0x04
	.byte  0x04, 0x04

DS0001:
	.byte  0x42, 0x59, 0x54, 0x45, 0x00

DS0002:
	.byte  0x57, 0x4F, 0x52, 0x44, 0x00

DS0003:
	.byte  0x44, 0x57, 0x4F, 0x52, 0x44, 0x00

LC03F6:
	.byte  0x69, 0x04, 0x30, 0x04, 0xF8, 0x03, 0x63, 0x03
	.byte  0x25, 0x03, 0x20, 0x03, 0x44, 0x02, 0xEC, 0x01
	.byte  0xFD, 0x00, 0x00, 0x00, 0x08, 0x09, 0x09, 0x09
	.byte  0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09
	.byte  0x09, 0x09, 0x04, 0x09, 0x07, 0x00, 0x09, 0x09
	.byte  0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06
	.byte  0x06, 0x02, 0x09, 0x03, 0x03, 0x03, 0x09, 0x09
	.byte  0x05, 0x05, 0x09, 0x01

DS0004:
	.byte  0x20, 0x25, 0x73, 0x25, 0x73, 0x0A, 0x20, 0x25
	.byte  0x73, 0x00

DS0005:
	.byte  0x3A, 0x00

LC0579:
	.byte  0x35, 0x01, 0x32, 0x01, 0x00, 0x00, 0x00, 0x01
	.byte  0x02, 0x02, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01
	.byte  0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x00, 0x01
	.byte  0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x01

LC05BC:
	.byte  0x76, 0x73, 0x00, 0x00, 0x01, 0x02, 0x02, 0x00
	.byte  0x01, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x02
	.byte  0x01, 0x02, 0x02, 0x00, 0x01, 0x02, 0x02, 0x02
	.byte  0x02, 0x02, 0x02, 0x00, 0x01


.SECTION .bss
	.ALIGN	16

SymTables:
	.zero	96 * 1


.att_syntax prefix
