
.intel_syntax noprefix

.global get_fasttype
.global LocalDir
.global UpdateStackBase
.global UpdateProcStatus
.global ParseProc
.global CreateProc
.global DeleteProc
.global ProcDir
.global CopyPrototype
.global EndpDir
.global ExcFrameDirective
.global ProcCheckOpen
.global SetLocalOffsets
.global write_prologue
.global RetInstr
.global ProcInit
.global CurrProc
.global sym_ReservedStack
.global procidx
.global ProcStatus
.global stackreg
.global StackAdj

.extern strFUNC
.extern list_pos
.extern AlignCurrOffset
.extern RunLineQueue
.extern AddLineQueueX
.extern AddLineQueue
.extern GetOfssizeAssume
.extern _atoqw
.extern EmitConstError
.extern EvalOperand
.extern GetLabelStr
.extern GetResWName
.extern LstWrite
.extern LstSetPosition
.extern SkipSavedState
.extern UseSavedState
.extern LineStoreCurr
.extern get_curr_srcfile
.extern GetLineNumber
.extern MacroInline
.extern RunMacro
.extern GetQualifiedType
.extern Tokenize
.extern AddPublicData
.extern SimGetSegName
.extern GetSegIdx
.extern GetCurrOffset
.extern GetSymOfssize
.extern SetSymSegOfs
.extern ParseLine
.extern sym_ext2int
.extern sym_remove_table
.extern sym_add_table
.extern GetLangType
.extern SizeFromRegister
.extern SizeFromMemtype
.extern SymTables
.extern BackPatch
.extern LclDup
.extern LclAlloc
.extern tsprintf
.extern tprintf
.extern AddLinnumDataRef
.extern asmerr
.extern szDgroup
.extern Options
.extern Parse_Pass
.extern SymGetLocal
.extern SymSetLocal
.extern SymClearLocal
.extern SymCmpFunc
.extern SymFindID
.extern SymFind
.extern SymAddLocal
.extern SymLCreate
.extern SymGCreate
.extern SymCreate
.extern SymFree
.extern SymAlloc
.extern tstrcmp
.extern tstrcpy
.extern tstrlen
.extern tmemset
.extern tmemcpy
.extern fwrite


.SECTION .text
	.ALIGN	16

get_fasttype:
	imul	edx, edx, 48
	imul	ecx, ecx, 16
	lea	rax, [lang_table+rip]
	add	rax, rcx
	add	rax, rdx
	ret

$_001:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	rdi, r8
	mov	rsi, rdx
	xor	eax, eax
	mov	qword ptr [rsi+0x30], rax
	mov	al, byte ptr [rdi+0x2]
	inc	byte ptr [rdi+0x2]
	mov	byte ptr [rsi+0x59], al
	movzx	edx, byte ptr [rcx+0x1F]
	movzx	ecx, byte ptr [rsi+0x48]
	call	get_fasttype
	mov	rbx, rax
	mov	r8, qword ptr [rsi+0x28]
	movzx	edx, byte ptr [rsi+0x48]
	movzx	ecx, byte ptr [rsi+0x1E]
	call	SizeFromMemtype@PLT
	movzx	ecx, byte ptr [rsi+0x48]
	mov	edx, 2
	shl	edx, cl
	mov	dword ptr [rbp-0x24], edx
	test	eax, eax
	jnz	$_002
	cmp	byte ptr [rsi+0x1E], 194
	jnz	$_002
	mov	eax, edx
$_002:	mov	ecx, eax
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	cmp	eax, dword ptr [rbp-0x24]
	jge	$_003
	mov	eax, dword ptr [rbp-0x24]
$_003:	mov	rdx, qword ptr [rbp+0x28]
	cmp	al, byte ptr [rdx+0x5A]
	jbe	$_004
	mov	byte ptr [rdx+0x5A], al
$_004:	mov	al, byte ptr [rsi+0x1E]
	cmp	al, 196
	jnz	$_005
	mov	rax, qword ptr [rsi+0x28]
	mov	al, byte ptr [rax+0x1E]
$_005:	test	al, 0x20
	jnz	$_006
	cmp	al, 31
	jnz	$_014
$_006:	test	byte ptr [rbx+0xF], 0x10
	jz	$_007
	movzx	eax, byte ptr [rsi+0x59]
	jmp	$_008

$_007:	movzx	eax, byte ptr [rdi+0x1]
$_008:	lea	edx, [rax+0x28]
	cmp	eax, 7
	jbe	$_009
	add	edx, 148
$_009:	cmp	ecx, 64
	jnz	$_011
	lea	edx, [rax+0x40]
	cmp	eax, 7
	jbe	$_010
	add	edx, 172
$_010:	jmp	$_012

$_011:	cmp	ecx, 32
	jnz	$_012
	lea	edx, [rax+0x30]
	cmp	eax, 7
	jbe	$_012
	add	edx, 164
$_012:	mov	byte ptr [rsi+0x58], dl
	cmp	al, byte ptr [rbx+0xD]
	jc	$_013
	xor	eax, eax
	jmp	$_030

$_013:	inc	byte ptr [rdi+0x1]
	inc	byte ptr [rsi+0x5A]
	jmp	$_028

$_014:	mov	eax, dword ptr [rbp-0x24]
	add	eax, eax
	cmp	ecx, eax
	jbe	$_015
	lea	edx, [rax+rax]
	cmp	edx, ecx
	jnz	$_015
	cmp	dl, byte ptr [rbx+0xE]
	ja	$_015
	mov	dl, byte ptr [rdi]
	add	dl, 4
	cmp	dl, byte ptr [rbx+0xC]
	ja	$_015
	add	byte ptr [rdi], 2
	mov	byte ptr [rsi+0x5A], 2
	mov	eax, ecx
$_015:	test	byte ptr [rbx+0xF], 0x10
	jz	$_017
	movzx	edx, byte ptr [rsi+0x59]
	cmp	dl, byte ptr [rdi]
	jnc	$_016
	mov	dl, byte ptr [rdi]
$_016:	jmp	$_018

$_017:	movzx	edx, byte ptr [rdi]
$_018:	cmp	dl, byte ptr [rbx+0xC]
	jc	$_019
	xor	eax, eax
	jmp	$_030

$_019:	cmp	eax, ecx
	jnz	$_023
	cmp	al, byte ptr [rbx+0xE]
	ja	$_023
	mov	al, dl
	inc	al
	cmp	al, byte ptr [rbx+0xC]
	jc	$_020
	xor	eax, eax
	jmp	$_030

$_020:	mov	eax, 1
$_021:	cmp	eax, dword ptr [rbp-0x24]
	jge	$_022
	add	edx, 8
	add	eax, eax
	jmp	$_021

$_022:	add	rdx, qword ptr [rbx]
	mov	al, byte ptr [rdx]
	mov	byte ptr [rsi+0x58], al
	mov	al, byte ptr [rdx+0x1]
	mov	byte ptr [rsi+0x5B], al
	or	byte ptr [rsi+0x13], 0x40
	add	byte ptr [rdi], 2
	add	byte ptr [rsi+0x5A], 2
	jmp	$_028

$_023:	cmp	ecx, dword ptr [rbp-0x24]
	jle	$_025
	test	byte ptr [rbx+0xF], 0x10
	jnz	$_024
	xor	eax, eax
	jmp	$_030

$_024:	mov	ecx, dword ptr [rbp-0x24]
$_025:	mov	eax, 1
$_026:	cmp	eax, ecx
	jnc	$_027
	add	edx, 8
	add	eax, eax
	jmp	$_026

$_027:	add	rdx, qword ptr [rbx]
	mov	al, byte ptr [rdx]
	mov	byte ptr [rsi+0x58], al
	inc	byte ptr [rdi]
	inc	byte ptr [rsi+0x5A]
$_028:	xor	eax, eax
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_029
	jmp	$_030

$_029:	mov	ecx, dword ptr [rdi]
	mov	rdx, qword ptr [rbp+0x28]
	mov	byte ptr [rdx+0x58], cl
	mov	byte ptr [rdx+0x59], ch
	or	byte ptr [rsi+0x11], 0x10
	test	byte ptr [rbx+0xF], 0x01
	jz	$_030
	mov	byte ptr [rsi+0x1D], 10
	lea	rdx, [rbp-0x20]
	mov	al, byte ptr [rsi+0x58]
	mov	ecx, eax
	call	GetResWName@PLT
	mov	rcx, rax
	call	LclDup@PLT
	mov	qword ptr [rsi+0x30], rax
	mov	eax, 1
$_030:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

LocalDir:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 200
	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_031
	xor	eax, eax
	jmp	$_059

$_031:	test	dword ptr [ProcStatus+rip], 0x80
	jz	$_032
	cmp	qword ptr [CurrProc+rip], 0
	jnz	$_033
$_032:	mov	ecx, 2012
	call	asmerr@PLT
	jmp	$_059

$_033:	mov	rsi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rsi+0x78]
	mov	eax, dword ptr [rsi+0x14]
	add	eax, eax
	cmp	byte ptr [r12+rax*8+0xC], 4
	jnz	$_034
	or	byte ptr [rsi], 0x40
	or	byte ptr [ProcStatus+rip], 0x04
$_034:	inc	dword ptr [rbp+0x28]
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
$_035:	cmp	byte ptr [rbx], 8
	jz	$_036
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_059

$_036:	mov	rax, qword ptr [rbx+0x10]
	mov	qword ptr [rbp-0x8], rax
	mov	qword ptr [rbp-0x20], 0
	mov	byte ptr [rbp-0x17], 0
	mov	byte ptr [rbp-0x14], 192
	mov	eax, 1
	mov	cl, byte ptr [r14+0x15]
	shl	eax, cl
	mov	byte ptr [rbp-0x16], 0
	test	eax, 0x68
	jz	$_037
	mov	byte ptr [rbp-0x16], 1
$_037:	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rbp-0x15], al
	mov	rcx, qword ptr [rbp-0x8]
	call	SymLCreate@PLT
	mov	qword ptr [rbp-0x10], rax
	test	eax, eax
	jnz	$_038
	mov	rax, -1
	jmp	$_059

$_038:	mov	byte ptr [rax+0x1D], 5
	or	byte ptr [rax+0x10], 0x01
	mov	dword ptr [rax+0x68], 1
	jmp	$_041

$_039:	mov	byte ptr [rax+0x1E], 1
	mov	dword ptr [rbp-0x28], 2
	jmp	$_042

$_040:	mov	byte ptr [rax+0x1E], 3
	mov	dword ptr [rbp-0x28], 4
	jmp	$_042

$_041:	cmp	byte ptr [rbp-0x15], 0
	jz	$_039
	jmp	$_040

$_042:	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	cmp	byte ptr [rbx], 91
	jne	$_049
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	mov	ecx, dword ptr [rbp+0x28]
	mov	rdx, rbx
$_043:	cmp	ecx, dword ptr [r14+0x64]
	jge	$_044
	cmp	byte ptr [rdx], 44
	jz	$_044
	cmp	byte ptr [rdx], 58
	jz	$_044
	inc	ecx
	add	rdx, 32
	jmp	$_043

$_044:	mov	byte ptr [rsp+0x20], 0
	lea	r9, [rbp-0x90]
	mov	r8d, ecx
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	je	$_059
	cmp	dword ptr [rbp-0x54], 0
	jz	$_045
	mov	ecx, 2026
	call	asmerr@PLT
	mov	dword ptr [rbp-0x90], 1
$_045:	cmp	dword ptr [rbp-0x8C], 0
	jz	$_047
	cmp	dword ptr [rbp-0x8C], -1
	jnz	$_046
	cmp	dword ptr [rbp-0x90], 0
	jl	$_047
$_046:	call	EmitConstError@PLT
$_047:	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp-0x10]
	mov	eax, dword ptr [rbp-0x90]
	mov	dword ptr [rcx+0x68], eax
	or	byte ptr [rcx+0x10], 0x40
	cmp	byte ptr [rbx], 93
	jnz	$_048
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	jmp	$_049

$_048:	mov	ecx, 2045
	call	asmerr@PLT
$_049:	cmp	byte ptr [rbx], 58
	jnz	$_051
	inc	dword ptr [rbp+0x28]
	lea	r8, [rbp-0x28]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	GetQualifiedType@PLT
	cmp	eax, -1
	je	$_059
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp-0x10]
	mov	al, byte ptr [rbp-0x18]
	mov	byte ptr [rcx+0x1E], al
	cmp	byte ptr [rbp-0x18], 196
	jnz	$_050
	mov	rax, qword ptr [rbp-0x20]
	mov	qword ptr [rcx+0x28], rax
	jmp	$_051

$_050:	mov	rax, qword ptr [rbp-0x20]
	mov	qword ptr [rcx+0x50], rax
$_051:	mov	rcx, qword ptr [rbp-0x10]
	mov	al, byte ptr [rbp-0x17]
	mov	byte ptr [rcx+0x49], al
	mov	al, byte ptr [rbp-0x16]
	mov	byte ptr [rcx+0x21], al
	mov	al, byte ptr [rbp-0x15]
	mov	byte ptr [rcx+0x48], al
	mov	al, byte ptr [rbp-0x14]
	mov	byte ptr [rcx+0x4A], al
	mov	eax, dword ptr [rbp-0x28]
	mul	dword ptr [rcx+0x68]
	mov	dword ptr [rcx+0x60], eax
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_052
	mov	qword ptr [rsi+0x20], rcx
	jmp	$_055

$_052:	mov	rdx, qword ptr [rsi+0x20]
$_053:	cmp	qword ptr [rdx+0x88], 0
	jz	$_054
	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_053

$_054:	mov	qword ptr [rdx+0x88], rcx
$_055:	cmp	byte ptr [rbx], 0
	jz	$_058
	cmp	byte ptr [rbx], 44
	jnz	$_057
	mov	eax, dword ptr [rbp+0x28]
	inc	eax
	cmp	eax, dword ptr [r14+0x64]
	jge	$_056
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
$_056:	jmp	$_058

$_057:	lea	rdx, [DS0000+rip]
	mov	ecx, 2065
	call	asmerr@PLT
	jmp	$_059

$_058:	mov	eax, dword ptr [r14+0x64]
	cmp	dword ptr [rbp+0x28], eax
	jl	$_035
	xor	eax, eax
$_059:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

UpdateStackBase:
	test	rdx, rdx
	jz	$_060
	mov	eax, dword ptr [rdx]
	mov	dword ptr [StackAdj+rip], eax
	mov	eax, dword ptr [rdx+0x4]
	mov	dword ptr [StackAdjHigh+rip], eax
$_060:	mov	eax, dword ptr [StackAdj+rip]
	mov	dword ptr [rcx+0x30], eax
	mov	eax, dword ptr [StackAdjHigh+rip]
	mov	dword ptr [rcx+0x34], eax
	ret

UpdateProcStatus:
	xor	eax, eax
	cmp	qword ptr [CurrProc+rip], 0
	jz	$_061
	mov	eax, dword ptr [ProcStatus+rip]
$_061:	mov	dword ptr [rcx+0x30], eax
	ret

$_062:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 48
	cmp	dword ptr [Parse_Pass+rip], 0
	jne	$_071
	or	byte ptr [rcx+0x11], 0x02
	xor	esi, esi
	xor	eax, eax
	mov	rbx, qword ptr [rbp+0x28]
	mov	rcx, qword ptr [rbp+0x30]
	add	rcx, 64
	cmp	byte ptr [rcx], 7
	jnz	$_063
	cmp	dword ptr [rcx+0x4], 343
	jc	$_063
	cmp	dword ptr [rcx+0x4], 352
	ja	$_063
	add	rcx, 32
$_063:	mov	rdx, rcx
$_064:	cmp	rdx, rbx
	jnc	$_067
	cmp	byte ptr [rdx], 58
	jnz	$_065
	inc	esi
	jmp	$_066

$_065:	cmp	rdx, rcx
	jbe	$_066
	cmp	byte ptr [rdx], 44
	jnz	$_066
	inc	eax
$_066:	add	rdx, 32
	jmp	$_064

$_067:	cmp	eax, esi
	jbe	$_068
	inc	eax
	mov	esi, eax
$_068:	mov	byte ptr [rbx], 0
	mov	rax, qword ptr [rbx+0x18]
	mov	byte ptr [rax], 0
	cmp	byte ptr [rdx-0x20], 7
	jnz	$_069
	cmp	dword ptr [rdx-0x1C], 341
	jnz	$_069
	mov	edx, 1
	jmp	$_070

$_069:	xor	edx, edx
$_070:	mov	rax, qword ptr [rbp+0x30]
	mov	dword ptr [rsp+0x20], edx
	mov	r9, qword ptr [rbx+0x10]
	mov	r8, qword ptr [rcx+0x18]
	mov	edx, esi
	mov	rcx, qword ptr [rax+0x10]
	call	MacroInline@PLT
$_071:	leave
	pop	rbx
	pop	rsi
	ret

$_072:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 152
	mov	dword ptr [rbp-0x1C], 0
	mov	rsi, qword ptr [rcx+0x78]
	movzx	edi, byte ptr [rcx+0x1F]
	mov	rdi, qword ptr [rsi+0x18]
	test	byte ptr [rbp+0x48], 0x04
	jnz	$_074
$_073:	test	rdi, rdi
	jz	$_074
	cmp	qword ptr [rdi+0x88], 0
	jz	$_074
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_073

$_074:
	mov	qword ptr [rbp-0x50], rdi
	mov	rcx, qword ptr [rbp+0x28]
	movzx	eax, byte ptr [rcx+0x10]
	and	eax, 0x02
	shr	eax, 1
	mov	dword ptr [rbp-0x40], eax
	imul	ebx, dword ptr [rbp+0x30], 32
	add	rbx, qword ptr [rbp+0x38]
	mov	dword ptr [rbp-0x14], 0
$_075:	cmp	byte ptr [rbx], 0
	je	$_137
	cmp	byte ptr [rbx], 8
	jnz	$_076
	mov	rax, qword ptr [rbx+0x10]
	mov	qword ptr [rbp-0x8], rax
	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	jmp	$_080

$_076:	cmp	dword ptr [rbp+0x40], 0
	jnz	$_079
	cmp	byte ptr [rbx], 58
	jnz	$_079
	test	rdi, rdi
	jz	$_077
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rbp-0x8], rax
	jmp	$_078

$_077:	lea	rax, [DS0000+0x1+rip]
	mov	qword ptr [rbp-0x8], rax
$_078:	jmp	$_080

$_079:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_145

$_080:	mov	qword ptr [rbp-0x30], 0
	mov	byte ptr [rbp-0x27], 0
	mov	byte ptr [rbp-0x24], 192
	mov	eax, 1
	mov	cl, byte ptr [r14+0x15]
	shl	eax, cl
	test	eax, 0x68
	jz	$_081
	mov	byte ptr [rbp-0x26], 1
	jmp	$_082

$_081:	mov	byte ptr [rbp-0x26], 0
$_082:	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rbp-0x25], al
	movzx	eax, byte ptr [r14+0x6]
	mov	dword ptr [rbp-0x38], eax
	mov	dword ptr [rbp-0x3C], 0
	cmp	byte ptr [rbx], 58
	jz	$_085
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_083
	lea	rdx, [DS0001+rip]
	mov	ecx, 2065
	call	asmerr@PLT
	jmp	$_145

$_083:	mov	byte ptr [rbp-0x28], 1
	cmp	byte ptr [rbp-0x25], 0
	jz	$_084
	mov	byte ptr [rbp-0x28], 3
$_084:	jmp	$_095

$_085:	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	cmp	byte ptr [rbx], 7
	jnz	$_092
	cmp	dword ptr [rbx+0x4], 341
	jnz	$_092
	mov	rcx, qword ptr [rbp+0x28]
	movzx	eax, byte ptr [rcx+0x1F]
	jmp	$_087

$_086:	mov	ecx, 2131
	call	asmerr@PLT
	jmp	$_145

	jmp	$_088

$_087:	cmp	eax, 0
	jz	$_086
	cmp	eax, 6
	jz	$_086
	cmp	eax, 5
	jz	$_086
	cmp	eax, 4
	jz	$_086
	cmp	eax, 3
	jz	$_086
$_088:	cmp	byte ptr [rbx+0x20], 0
	jz	$_089
	cmp	byte ptr [rbx+0x20], 9
	jnz	$_090
	cmp	byte ptr [rbx+0x21], 123
	jnz	$_090
$_089:	mov	dword ptr [rbp-0x3C], 1
	jmp	$_091

$_090:	mov	ecx, 2129
	call	asmerr@PLT
$_091:	mov	byte ptr [rbp-0x28], 192
	mov	dword ptr [rbp-0x38], 0
	inc	dword ptr [rbp+0x30]
	jmp	$_095

$_092:	xor	eax, eax
	cmp	byte ptr [rbx], 8
	jnz	$_093
	mov	rcx, qword ptr [rbx+0x10]
	mov	eax, dword ptr [rcx]
	or	eax, 0x202020
$_093:	cmp	eax, 7561825
	jnz	$_094
	mov	byte ptr [rbp-0x28], 194
	inc	dword ptr [rbp+0x30]
	jmp	$_095

$_094:	lea	r8, [rbp-0x38]
	mov	rdx, qword ptr [rbp+0x38]
	lea	rcx, [rbp+0x30]
	call	GetQualifiedType@PLT
	cmp	eax, -1
	jnz	$_095
	jmp	$_145

$_095:	cmp	dword ptr [rbp+0x40], 0
	jz	$_096
	mov	rcx, qword ptr [rbp-0x8]
	call	SymFind@PLT
	test	rax, rax
	jz	$_096
	cmp	byte ptr [rax+0x1D], 0
	jz	$_096
	mov	rdx, qword ptr [rbp-0x8]
	mov	ecx, 2005
	call	asmerr@PLT
	jmp	$_145

$_096:	cmp	qword ptr [rbp-0x50], 0
	je	$_114
	mov	byte ptr [rbp-0x6B], 0
	mov	rcx, qword ptr [rbp-0x30]
$_097:	test	rcx, rcx
	jz	$_098
	cmp	qword ptr [rcx+0x28], 0
	jz	$_098
	mov	rcx, qword ptr [rcx+0x28]
	jmp	$_097

$_098:	mov	qword ptr [rbp-0x68], rcx
	mov	rdi, qword ptr [rbp-0x50]
	mov	al, byte ptr [rbp+0x48]
	and	eax, 0x27
	cmp	eax, 3
	jz	$_099
	cmp	eax, 32
	jnz	$_100
	test	byte ptr [r14+0x2D], 0x02
	jnz	$_100
$_099:	mov	qword ptr [rdi+0x50], 0
	test	byte ptr [r14+0x1], 0x08
	jnz	$_100
	mov	byte ptr [rbp-0x6B], 1
$_100:	cmp	byte ptr [rdi+0x1E], 196
	jnz	$_101
	mov	rdx, qword ptr [rdi+0x28]
	jmp	$_102

$_101:	xor	edx, edx
	cmp	byte ptr [rdi+0x1E], 195
	jnz	$_102
	mov	rdx, qword ptr [rdi+0x50]
$_102:	test	rdx, rdx
	jz	$_103
	cmp	qword ptr [rdx+0x28], 0
	jz	$_103
	mov	rdx, qword ptr [rdx+0x28]
	jmp	$_102

$_103:	mov	qword ptr [rbp-0x60], rdx
	mov	al, byte ptr [r14+0x4]
	mov	ah, al
	cmp	byte ptr [rdi+0x48], 254
	jz	$_104
	mov	al, byte ptr [rdi+0x48]
$_104:	mov	byte ptr [rbp-0x69], al
	cmp	byte ptr [rbp-0x25], 254
	jz	$_105
	mov	ah, byte ptr [rbp-0x25]
$_105:	mov	byte ptr [rbp-0x6A], ah
	mov	al, byte ptr [rdi+0x1E]
	cmp	byte ptr [rbp-0x28], al
	jnz	$_107
	cmp	byte ptr [rbp-0x28], 196
	jnz	$_106
	mov	rax, qword ptr [rbp-0x60]
	cmp	qword ptr [rbp-0x68], rax
	jnz	$_107
$_106:	cmp	byte ptr [rbp-0x28], 195
	jnz	$_108
	mov	al, byte ptr [rdi+0x21]
	cmp	byte ptr [rbp-0x26], al
	jnz	$_107
	mov	al, byte ptr [rbp-0x69]
	cmp	byte ptr [rbp-0x6A], al
	jnz	$_107
	cmp	byte ptr [rbp-0x6B], 0
	jnz	$_108
	mov	al, byte ptr [rdi+0x4A]
	cmp	byte ptr [rbp-0x24], al
	jnz	$_107
	mov	rax, qword ptr [rbp-0x60]
	cmp	qword ptr [rbp-0x68], rax
	jz	$_108
$_107:	mov	rdx, qword ptr [rbp-0x8]
	mov	ecx, 2111
	call	asmerr@PLT
$_108:	cmp	dword ptr [rbp+0x40], 0
	jz	$_109
	mov	rdx, qword ptr [rbp-0x8]
	mov	rcx, rdi
	call	SymAddLocal@PLT
$_109:	test	byte ptr [rbp+0x48], 0x04
	jnz	$_112
	mov	rcx, qword ptr [rsi+0x18]
$_110:	test	rcx, rcx
	jz	$_111
	cmp	qword ptr [rcx+0x88], rdi
	jz	$_111
	mov	rcx, qword ptr [rcx+0x88]
	jmp	$_110

$_111:	jmp	$_113

$_112:	mov	rcx, qword ptr [rdi+0x88]
$_113:	mov	qword ptr [rbp-0x50], rcx
	jmp	$_130

$_114:	cmp	dword ptr [rbp-0x40], 0
	jz	$_115
	lea	rdx, [DS0001+0x1+rip]
	mov	ecx, 2111
	call	asmerr@PLT
	jmp	$_145

	jmp	$_130

$_115:	cmp	dword ptr [rbp+0x40], 0
	jz	$_116
	mov	rcx, qword ptr [rbp-0x8]
	call	SymLCreate@PLT
	mov	rdi, rax
	jmp	$_117

$_116:	lea	rcx, [DS0001+0x1+rip]
	call	SymAlloc@PLT
	mov	rdi, rax
$_117:	test	rdi, rdi
	jnz	$_118
	mov	rax, -1
	jmp	$_145

$_118:	mov	qword ptr [rbp-0x48], rdi
	or	byte ptr [rdi+0x10], 0x01
	mov	al, byte ptr [rbp-0x28]
	mov	byte ptr [rdi+0x1E], al
	cmp	byte ptr [rbp-0x28], 196
	jnz	$_119
	mov	rax, qword ptr [rbp-0x30]
	mov	qword ptr [rdi+0x28], rax
	jmp	$_120

$_119:	mov	rax, qword ptr [rbp-0x30]
	mov	qword ptr [rdi+0x50], rax
$_120:	mov	al, byte ptr [rbp-0x26]
	mov	byte ptr [rdi+0x21], al
	mov	al, byte ptr [rbp-0x25]
	mov	byte ptr [rdi+0x48], al
	mov	al, byte ptr [rbp-0x27]
	mov	byte ptr [rdi+0x49], al
	mov	al, byte ptr [rbp-0x24]
	mov	byte ptr [rdi+0x4A], al
	cmp	dword ptr [rbp-0x3C], 0
	jz	$_121
	or	byte ptr [rdi+0x4B], 0x04
$_121:	movzx	eax, byte ptr [rbp+0x48]
	and	eax, 0x31
	test	eax, eax
	jz	$_122
	lea	r8, [rbp-0x1C]
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp+0x28]
	call	$_001
$_122:	test	eax, eax
	jnz	$_123
	mov	byte ptr [rdi+0x1D], 5
$_123:	mov	dword ptr [rdi+0x68], 1
	mov	eax, dword ptr [rbp-0x38]
	mov	dword ptr [rdi+0x60], eax
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_125
	mov	eax, 2
	mov	rcx, qword ptr [rbp+0x28]
	mov	cl, byte ptr [rcx+0x20]
	shl	eax, cl
	cmp	dword ptr [rbp+0x40], 0
	jz	$_124
	movzx	eax, byte ptr [r14+0x6]
$_124:	mov	edx, eax
	mov	eax, dword ptr [rbp-0x38]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	ecx, eax
	add	dword ptr [rsi+0xC], ecx
$_125:	test	byte ptr [rbp+0x48], 0x04
	jnz	$_126
	mov	rax, qword ptr [rsi+0x18]
	mov	qword ptr [rdi+0x88], rax
	mov	qword ptr [rsi+0x18], rdi
	jmp	$_130

$_126:	mov	qword ptr [rdi+0x88], 0
	cmp	qword ptr [rsi+0x18], 0
	jnz	$_127
	mov	qword ptr [rsi+0x18], rdi
	jmp	$_130

$_127:	mov	rdx, qword ptr [rsi+0x18]
$_128:	test	rdx, rdx
	jz	$_129
	cmp	qword ptr [rdx+0x88], 0
	jz	$_129
	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_128

$_129:	mov	qword ptr [rdx+0x88], rdi
	mov	qword ptr [rbp-0x50], 0
$_130:	imul	ebx, dword ptr [rbp+0x30], 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 0
	je	$_136
	cmp	byte ptr [rbx], 44
	je	$_135
	cmp	byte ptr [rbx], 3
	jnz	$_133
	cmp	dword ptr [rbx+0x4], 620
	jnz	$_133
	cmp	byte ptr [rbx+0x20], 9
	jnz	$_133
	cmp	byte ptr [rbx+0x21], 60
	jnz	$_133
	mov	rcx, qword ptr [rbx-0x10]
	mov	eax, dword ptr [rcx]
	or	eax, 0x202020
	cmp	byte ptr [rbx-0x20], 8
	jnz	$_131
	cmp	eax, 7561825
	jz	$_132
$_131:	mov	rdx, qword ptr [rbx-0x8]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_145

$_132:	add	dword ptr [rbp+0x30], 2
	add	rbx, 64
$_133:	mov	rcx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 9
	jnz	$_134
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_134
	cmp	dword ptr [rcx+0x24], 604
	jnz	$_134
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, rbx
	mov	rcx, qword ptr [rbp+0x28]
	call	$_062
	jmp	$_135

$_134:	cmp	byte ptr [rbx], 44
	jz	$_135
	lea	rdx, [DS0000+rip]
	mov	ecx, 2065
	call	asmerr@PLT
	jmp	$_145

$_135:	inc	dword ptr [rbp+0x30]
	add	rbx, 32
$_136:	inc	dword ptr [rbp-0x14]
	jmp	$_075

$_137:	cmp	dword ptr [rbp-0x40], 0
	jz	$_138
	cmp	qword ptr [rbp-0x50], 0
	jz	$_138
	lea	rdx, [DS0001+0x1+rip]
	mov	ecx, 2111
	call	asmerr@PLT
	jmp	$_145

$_138:	cmp	dword ptr [rbp+0x40], 0
	je	$_144
	xor	eax, eax
	mov	rcx, qword ptr [rbp+0x28]
	cmp	byte ptr [rcx+0x1E], 130
	sete	al
	inc	eax
	movzx	ecx, byte ptr [r14+0x6]
	mul	ecx
	mov	dword ptr [rbp-0x18], eax
	mov	eax, dword ptr [rsi+0x14]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8+0x4]
	and	eax, 0x7F
	add	dword ptr [rbp-0x18], eax
$_139:	cmp	dword ptr [rbp-0x14], 0
	jz	$_144
	mov	ebx, 1
	mov	rdi, qword ptr [rsi+0x18]
$_140:	cmp	ebx, dword ptr [rbp-0x14]
	jge	$_141
	mov	rdi, qword ptr [rdi+0x88]
	inc	ebx
	jmp	$_140

$_141:	cmp	byte ptr [rdi+0x1D], 10
	jz	$_143
	mov	eax, dword ptr [rbp-0x18]
	mov	dword ptr [rdi+0x30], eax
	or	byte ptr [rsi], 0x10
	movzx	ecx, byte ptr [r14+0x6]
	mov	edx, ecx
	mov	eax, dword ptr [rdi+0x60]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	ebx, eax
	movzx	ecx, byte ptr [r14+0x6]
	cmp	ebx, ecx
	jbe	$_142
	cmp	byte ptr [rdi+0x1E], 196
	jnz	$_142
	mov	ebx, ecx
$_142:	add	dword ptr [rbp-0x18], ebx
$_143:	dec	dword ptr [rbp-0x14]
	jmp	$_139

$_144:	xor	eax, eax
$_145:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ParseProc:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 120
	mov	rdi, rcx
	mov	rsi, qword ptr [rdi+0x78]
	movzx	eax, byte ptr [rdi+0x10]
	and	eax, 0x04
	shr	eax, 2
	mov	dword ptr [rbp-0x18], eax
	cmp	dword ptr [rbp+0x40], 0
	je	$_156
	test	byte ptr [r14+0x2], 0x20
	jz	$_146
	or	byte ptr [rdi+0x10], 0x20
$_146:	test	byte ptr [r14+0x2], 0x10
	jnz	$_147
	or	byte ptr [rdi+0x10], 0x04
$_147:	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_148
	mov	eax, 128
	jmp	$_149

$_148:	cmp	eax, 6
	jc	$_149
	mov	eax, 6
$_149:	mov	ebx, eax
	xor	edi, edi
	mov	eax, dword ptr [rsi+0x14]
	add	eax, eax
	cmp	byte ptr [r12+rax*8+0xC], 5
	jz	$_150
	jmp	$_155

$_150:	test	byte ptr [r14+0x1], 0x08
	jz	$_153
	cmp	byte ptr [r14+0x4], 0
	ja	$_151
	cmp	ebx, 2
	jz	$_151
	cmp	ebx, 5
	jc	$_152
$_151:	inc	edi
$_152:	jmp	$_155

$_153:	cmp	ebx, 2
	jz	$_154
	cmp	ebx, 128
	jz	$_154
	cmp	ebx, 3
	jnz	$_155
$_154:	inc	edi
$_155:	test	edi, edi
	jz	$_156
	or	byte ptr [rsi], 0x02
$_156:	mov	rdi, qword ptr [rbp+0x28]
	imul	ebx, dword ptr [rbp+0x30], 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 6
	jnz	$_161
	cmp	dword ptr [rbx+0x4], 290
	jc	$_161
	cmp	dword ptr [rbx+0x4], 295
	ja	$_161
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8+0x4]
	mov	byte ptr [rbp-0x19], al
	cmp	dword ptr [rbp+0x40], 0
	jz	$_159
	cmp	byte ptr [r14+0x4], 1
	jc	$_157
	test	al, al
	jz	$_158
$_157:	cmp	byte ptr [r14+0x4], 0
	jnz	$_159
	cmp	al, 1
	jnz	$_159
$_158:	mov	ecx, 2011
	call	asmerr@PLT
$_159:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x11], al
	mov	al, byte ptr [rbp-0x19]
	cmp	al, 254
	jnz	$_160
	mov	al, byte ptr [r14+0x4]
$_160:	mov	byte ptr [rbp-0x12], al
	inc	dword ptr [rbp+0x30]
	jmp	$_163

$_161:	mov	eax, 1
	mov	cl, byte ptr [r14+0x15]
	shl	eax, cl
	and	eax, 0x70
	mov	eax, 130
	jnz	$_162
	mov	eax, 129
$_162:	mov	byte ptr [rbp-0x11], al
	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rbp-0x12], al
$_163:	cmp	byte ptr [rdi+0x1D], 7
	jnz	$_164
	mov	al, byte ptr [rdi+0x20]
	mov	byte ptr [rbp-0x13], al
	jmp	$_165

$_164:	mov	rcx, rdi
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0x13], al
$_165:	mov	cl, byte ptr [rbp-0x11]
	mov	dl, byte ptr [rbp-0x12]
	cmp	byte ptr [rdi+0x1E], 192
	jz	$_170
	cmp	cl, byte ptr [rdi+0x1E]
	jnz	$_166
	cmp	al, dl
	jz	$_170
$_166:	cmp	byte ptr [rdi+0x1E], 129
	jz	$_167
	cmp	byte ptr [rdi+0x1E], 130
	jnz	$_168
$_167:	mov	ecx, 2112
	call	asmerr@PLT
	jmp	$_169

$_168:	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 2005
	call	asmerr@PLT
	jmp	$_239

$_169:	jmp	$_171

$_170:	mov	byte ptr [rdi+0x1E], cl
	mov	byte ptr [rdi+0x20], dl
$_171:	lea	r8, [rbp+0x48]
	mov	rdx, qword ptr [rbp+0x38]
	lea	rcx, [rbp+0x30]
	call	GetLangType@PLT
	cmp	byte ptr [rdi+0x1F], 0
	jz	$_172
	mov	al, byte ptr [rbp+0x48]
	cmp	byte ptr [rdi+0x1F], al
	jz	$_172
	mov	ecx, 2112
	call	asmerr@PLT
	jmp	$_173

$_172:	mov	al, byte ptr [rbp+0x48]
	mov	byte ptr [rdi+0x1F], al
$_173:	movzx	edx, byte ptr [rbp+0x48]
	movzx	ecx, byte ptr [rbp-0x12]
	call	get_fasttype
	mov	al, byte ptr [rax+0xF]
	mov	byte ptr [rbp-0x1A], al
	imul	ebx, dword ptr [rbp+0x30], 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 8
	jz	$_174
	cmp	byte ptr [rbx], 3
	jne	$_183
$_174:	mov	rax, qword ptr [rbx+0x10]
	mov	qword ptr [rbp-0x8], rax
	cmp	dword ptr [rbx+0x8], 194364606
	jnz	$_177
	cmp	dword ptr [rbp+0x40], 0
	jz	$_176
	and	byte ptr [rdi+0x10], 0xFB
	or	byte ptr [rdi+0x11], 0x04
	cmp	dword ptr [rbp-0x18], 0
	jz	$_175
	call	SkipSavedState@PLT
$_175:	and	byte ptr [rdi+0x10], 0xDF
$_176:	inc	dword ptr [rbp+0x30]
	jmp	$_183

$_177:	cmp	dword ptr [rbx+0x8], -2026945826
	jnz	$_179
	cmp	dword ptr [rbp+0x40], 0
	jz	$_178
	or	byte ptr [rdi+0x10], 0x04
$_178:	inc	dword ptr [rbp+0x30]
	jmp	$_183

$_179:	cmp	dword ptr [rbx+0x8], -1059869889
	jnz	$_181
	or	byte ptr [rdi+0x10], 0x20
	cmp	dword ptr [rbp+0x40], 0
	jz	$_180
	or	byte ptr [rdi+0x10], 0x04
	cmp	byte ptr [r14+0x4], 0
	jnz	$_180
	cmp	byte ptr [rdi+0x1E], 129
	jnz	$_180
	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 2145
	call	asmerr@PLT
$_180:	inc	dword ptr [rbp+0x30]
	jmp	$_183

$_181:	cmp	dword ptr [rbx+0x8], -517060422
	jnz	$_183
	or	byte ptr [rdi+0x12], 0x08
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_182
	mov	rax, qword ptr [r14+0x1B0]
	mov	qword ptr [rdi+0x60], rax
$_182:	inc	dword ptr [rbp+0x30]
$_183:	cmp	dword ptr [rbp+0x40], 0
	je	$_201
	cmp	byte ptr [rbx], 9
	jne	$_201
	cmp	byte ptr [rbx+0x1], 60
	jne	$_201
	mov	edi, dword ptr [r14+0x64]
	inc	edi
	cmp	byte ptr [r14+0x20], 2
	jnz	$_184
	jmp	$_200

$_184:	cmp	byte ptr [r14+0x20], 1
	jnz	$_185
	mov	rcx, qword ptr [rbx+0x10]
	call	LclDup@PLT
	mov	qword ptr [rsi+0x38], rax
	jmp	$_200

$_185:	mov	r9d, 1
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, edi
	mov	rcx, qword ptr [rbx+0x10]
	call	Tokenize@PLT
	mov	dword ptr [rbp-0x20], eax
$_186:	cmp	edi, dword ptr [rbp-0x20]
	jge	$_200
	imul	ebx, edi, 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 8
	jne	$_198
	cmp	dword ptr [rbx+0x8], 1858044697
	jnz	$_187
	or	byte ptr [rsi], 0x04
	jmp	$_196

$_187:	cmp	byte ptr [r14+0x4], 2
	jz	$_195
	cmp	dword ptr [rbx+0x8], -657437062
	jnz	$_188
	mov	eax, 1
	jmp	$_190

$_188:	cmp	dword ptr [rbx+0x8], 1489981138
	jnz	$_189
	mov	eax, 2
	jmp	$_190

$_189:	xor	eax, eax
$_190:	test	eax, eax
	jz	$_193
	cmp	byte ptr [r14+0x15], 7
	jnz	$_191
	mov	ecx, 8008
	call	asmerr@PLT
	jmp	$_192

$_191:	or	byte ptr [rsi], 0x08
	cmp	eax, 2
	jnz	$_192
	or	byte ptr [rsi], 0x80
$_192:	jmp	$_194

$_193:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 4005
	call	asmerr@PLT
	jmp	$_239

$_194:	jmp	$_196

$_195:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 4005
	call	asmerr@PLT
	jmp	$_239

$_196:	cmp	byte ptr [rbx+0x20], 44
	jnz	$_197
	cmp	byte ptr [rbx+0x40], 0
	jz	$_197
	inc	edi
$_197:	jmp	$_199

$_198:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_239

$_199:	inc	edi
	jmp	$_186

$_200:	inc	dword ptr [rbp+0x30]
$_201:	imul	ebx, dword ptr [rbp+0x30], 32
	add	rbx, qword ptr [rbp+0x38]
	mov	rdi, qword ptr [rbp+0x28]
	mov	cl, byte ptr [rdi+0x1F]
	cmp	byte ptr [r14+0x4], 2
	jne	$_210
	cmp	dword ptr [rbp+0x40], 0
	je	$_210
	mov	qword ptr [rsi+0x40], 0
	cmp	byte ptr [rbx], 7
	jne	$_208
	cmp	dword ptr [rbx+0x4], 342
	jne	$_208
	cmp	dword ptr [Options+0x8C+rip], 3
	jz	$_202
	cmp	dword ptr [Options+0x8C+rip], 1
	jz	$_202
	cmp	byte ptr [r14+0xB], 1
	jnz	$_203
$_202:	xor	edx, edx
	mov	ecx, 342
	call	GetResWName@PLT
	mov	rdx, rax
	mov	ecx, 2248
	call	asmerr@PLT
	jmp	$_239

$_203:	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	cmp	byte ptr [rbx], 58
	jne	$_207
	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	cmp	byte ptr [rbx], 8
	jz	$_204
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_239

$_204:	mov	rcx, rbx
	call	SymFindID@PLT
	mov	rdi, rax
	test	rax, rax
	jnz	$_205
	mov	rcx, qword ptr [rbx+0x10]
	call	SymGCreate@PLT
	mov	rdi, rax
	mov	byte ptr [rax+0x1D], 0
	or	byte ptr [rax+0x10], 0x10
	mov	rdx, rax
	lea	rcx, [SymTables+rip]
	call	sym_add_table@PLT
	jmp	$_206

$_205:	cmp	byte ptr [rax+0x1D], 0
	jz	$_206
	cmp	byte ptr [rax+0x1D], 1
	jz	$_206
	cmp	byte ptr [rax+0x1D], 2
	jz	$_206
	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 2005
	call	asmerr@PLT
	jmp	$_239

$_206:	mov	qword ptr [rsi+0x40], rdi
	inc	dword ptr [rbp+0x30]
	add	rbx, 32
$_207:	or	byte ptr [rsi], 0x20
	jmp	$_210

$_208:	cmp	byte ptr [r14+0x25], 3
	jnz	$_210
	cmp	cl, 7
	jz	$_209
	cmp	cl, 8
	jnz	$_210
$_209:	or	byte ptr [rsi], 0x20
$_210:	mov	dword ptr [rbp-0x24], 0
	cmp	byte ptr [rbx], 8
	jnz	$_214
	mov	rcx, qword ptr [rbx+0x10]
	mov	eax, dword ptr [rcx]
	or	eax, 0x20202020
	cmp	eax, 1936028533
	jnz	$_214
	cmp	byte ptr [rcx+0x4], 0
	jnz	$_214
	cmp	dword ptr [rbp+0x40], 0
	jnz	$_211
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
$_211:	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	xor	eax, eax
$_212:	cmp	byte ptr [rbx+rax], 2
	jnz	$_213
	inc	dword ptr [rbp-0x24]
	add	rax, 32
	jmp	$_212

$_213:	cmp	dword ptr [rbp-0x24], 0
	jnz	$_214
	mov	rdx, qword ptr [rbx-0x8]
	mov	ecx, 2008
	call	asmerr@PLT
$_214:	mov	eax, dword ptr [r14+0x190]
	add	dword ptr [rbp-0x24], eax
	mov	dword ptr [rbp-0x3C], 0
	test	byte ptr [rdi+0x4B], 0x10
	jz	$_218
	mov	ecx, dword ptr [r14+0x58]
	mov	eax, ecx
	add	eax, eax
	movzx	eax, byte ptr [r12+rax*8+0xC]
	jmp	$_217

$_215:	cmp	dword ptr [Options+0x8C+rip], 3
	jnz	$_216
	cmp	byte ptr [r14+0x4], 2
	jz	$_218
$_216:	mov	dword ptr [rbp-0x3C], ecx
	inc	dword ptr [rbp-0x24]
	jmp	$_218

$_217:	cmp	eax, 6
	jz	$_215
	cmp	eax, 7
	jz	$_215
	cmp	eax, 3
	jz	$_216
	cmp	eax, 12
	jz	$_216
	cmp	eax, 13
	jz	$_216
	cmp	eax, 14
	jz	$_216
	cmp	eax, 15
	jz	$_216
$_218:	cmp	dword ptr [rbp-0x24], 0
	je	$_227
	mov	ecx, dword ptr [rbp-0x24]
	inc	ecx
	imul	ecx, ecx, 2
	call	LclAlloc@PLT
	mov	rdi, rax
	mov	qword ptr [rsi+0x30], rdi
	mov	eax, dword ptr [rbp-0x24]
	stosw
$_219:	cmp	byte ptr [rbx], 2
	jnz	$_221
	mov	ecx, dword ptr [rbx+0x4]
	call	SizeFromRegister@PLT
	cmp	rax, 1
	jnz	$_220
	mov	ecx, 2032
	call	asmerr@PLT
$_220:	mov	eax, dword ptr [rbx+0x4]
	stosw
	inc	dword ptr [rbp+0x30]
	add	rbx, 32
	jmp	$_219

$_221:	xor	ecx, ecx
$_222:	cmp	ecx, dword ptr [r14+0x190]
	jnc	$_223
	lea	rdx, [r14+0x194]
	mov	eax, dword ptr [rdx+rcx*4]
	stosw
	inc	ecx
	jmp	$_222

$_223:	mov	eax, dword ptr [rbp-0x3C]
	test	eax, eax
	jz	$_227
	mov	rdx, qword ptr [rsi+0x30]
	mov	ecx, 1
$_224:	cmp	ecx, dword ptr [rbp-0x24]
	jge	$_226
	cmp	ax, word ptr [rdx+rcx*2]
	jnz	$_225
	dec	byte ptr [rdx]
	jmp	$_226

$_225:	inc	ecx
	jmp	$_224

$_226:	stosw
$_227:	cmp	byte ptr [rbx], 6
	jz	$_228
	cmp	byte ptr [rbx], 7
	jz	$_228
	cmp	byte ptr [rbx], 3
	jnz	$_229
$_228:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_239

$_229:	cmp	byte ptr [rbx], 44
	jnz	$_230
	inc	dword ptr [rbp+0x30]
	add	rbx, 32
$_230:	mov	rdi, qword ptr [rbp+0x28]
	mov	eax, dword ptr [r14+0x64]
	cmp	dword ptr [rbp+0x30], eax
	jge	$_231
	cmp	byte ptr [rbx], 9
	jnz	$_234
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_234
$_231:	cmp	qword ptr [rsi+0x18], 0
	jz	$_232
	lea	rdx, [DS0001+0x1+rip]
	mov	ecx, 2111
	call	asmerr@PLT
$_232:	cmp	byte ptr [rbx], 9
	jnz	$_233
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_233
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, rbx
	mov	rcx, rdi
	call	$_062
$_233:	jmp	$_238

$_234:	cmp	byte ptr [rdi+0x1F], 0
	jnz	$_235
	mov	ecx, 2119
	call	asmerr@PLT
	jmp	$_238

$_235:	mov	ebx, dword ptr [r14+0x64]
	dec	ebx
	imul	ebx, ebx, 32
	add	rbx, qword ptr [rbp+0x38]
	cmp	byte ptr [rbx], 9
	jnz	$_236
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_236
	sub	rbx, 32
$_236:	cmp	byte ptr [rbx], 7
	jnz	$_237
	cmp	dword ptr [rbx+0x4], 341
	jnz	$_237
	or	byte ptr [rsi], 0x01
$_237:	movzx	eax, byte ptr [rbp-0x1A]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	edx, dword ptr [rbp+0x30]
	mov	rcx, rdi
	call	$_072
	cmp	eax, -1
	jnz	$_238
$_238:	or	byte ptr [rdi+0x10], 0x01
	or	byte ptr [rdi+0x10], 0x02
	xor	eax, eax
$_239:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

CreateProc:
	mov	qword ptr [rsp+0x18], r8
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rdi, rcx
	test	rdi, rdi
	jnz	$_243
	mov	rcx, rdx
	cmp	byte ptr [rcx], 0
	jz	$_240
	call	SymCreate@PLT
	jmp	$_241

$_240:	call	SymAlloc@PLT
$_241:	mov	rdi, rax
	test	rdi, rdi
	jz	$_242
	mov	al, byte ptr [r14+0x4]
	mov	byte ptr [rdi+0x20], al
$_242:	jmp	$_246

$_243:	cmp	byte ptr [rdi+0x1D], 0
	jnz	$_244
	lea	rcx, [SymTables+rip]
	jmp	$_245

$_244:	lea	rcx, [SymTables+0x10+rip]
$_245:	mov	rdx, rdi
	call	sym_remove_table@PLT
$_246:	test	rdi, rdi
	je	$_251
	mov	eax, dword ptr [rbp+0x28]
	mov	byte ptr [rdi+0x1D], al
	mov	ecx, 80
	call	LclAlloc@PLT
	mov	qword ptr [rdi+0x78], rax
	cmp	byte ptr [rdi+0x1D], 1
	jnz	$_250
	cmp	qword ptr [SymTables+0x40+rip], 0
	jnz	$_247
	mov	qword ptr [SymTables+0x40+rip], rdi
	jmp	$_248

$_247:	mov	rcx, qword ptr [SymTables+0x48+rip]
	mov	qword ptr [rcx+0x88], rdi
$_248:	mov	qword ptr [SymTables+0x48+rip], rdi
	inc	dword ptr [procidx+rip]
	test	byte ptr [Options+0x4+rip], 0x02
	jz	$_249
	mov	ecx, 24
	call	LclAlloc@PLT
	mov	qword ptr [rdi+0x68], rax
	call	get_curr_srcfile@PLT
	mov	rdx, qword ptr [rdi+0x68]
	mov	word ptr [rdx+0xE], ax
$_249:	jmp	$_251

$_250:	cmp	byte ptr [rdi+0x1D], 2
	jnz	$_251
	or	byte ptr [rdi+0x4B], 0x02
	mov	rdx, rdi
	lea	rcx, [SymTables+0x10+rip]
	call	sym_add_table@PLT
$_251:	mov	rax, rdi
	leave
	pop	rdi
	ret

DeleteProc:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rdi, rcx
	cmp	byte ptr [rdi+0x1D], 1
	jnz	$_253
	mov	rsi, qword ptr [rdi+0x78]
	mov	rdi, qword ptr [rsi+0x28]
$_252:	test	rdi, rdi
	jz	$_253
	mov	rsi, qword ptr [rdi+0x78]
	mov	rcx, rdi
	call	SymFree@PLT
	mov	rdi, rsi
	jmp	$_252

$_253:
	leave
	pop	rdi
	pop	rsi
	ret

ProcDir:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 88
	mov	rbx, rdx
	cmp	ecx, 1
	jz	$_254
	imul	ecx, ecx, 32
	mov	rdx, qword ptr [rbx+rcx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_289

$_254:	cmp	qword ptr [r14+0x38], 0
	jnz	$_256
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_255
	mov	ecx, 2034
	call	asmerr@PLT
	jmp	$_289

$_255:	xor	eax, eax
	jmp	$_289

$_256:	mov	rax, qword ptr [rbx+0x10]
	mov	qword ptr [rbp-0x18], rax
	mov	rdi, qword ptr [CurrProc+rip]
	test	rdi, rdi
	jz	$_260
	mov	rsi, qword ptr [rdi+0x78]
	cmp	qword ptr [rsi+0x18], 0
	jnz	$_257
	test	byte ptr [rsi], 0x20
	jnz	$_257
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_257
	cmp	qword ptr [rsi+0x30], 0
	jz	$_258
$_257:	mov	rdx, qword ptr [rbp-0x18]
	mov	ecx, 2144
	call	asmerr@PLT
	jmp	$_289

$_258:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_259
	mov	rcx, rdi
	call	SymGetLocal@PLT
$_259:	mov	ecx, 16
	call	LclAlloc@PLT
	lea	rdx, [ProcStack+rip]
	mov	rcx, qword ptr [rdx]
	mov	qword ptr [rax], rcx
	mov	qword ptr [rax+0x8], rdi
	mov	qword ptr [rdx], rax
$_260:	cmp	byte ptr [r14+0x1B], 0
	jz	$_261
	movzx	ecx, byte ptr [r14+0x1B]
	call	AlignCurrOffset@PLT
$_261:	inc	dword ptr [rbp+0x28]
	mov	rcx, rbx
	call	SymFindID@PLT
	mov	qword ptr [rbp-0x8], rax
	add	rbx, 64
	cmp	dword ptr [Parse_Pass+rip], 0
	jne	$_278
	mov	dword ptr [rbp-0x1C], 0
	test	rax, rax
	jz	$_262
	test	byte ptr [rax+0x10], 0x04
	jz	$_262
	inc	dword ptr [rbp-0x1C]
$_262:	test	rax, rax
	jz	$_263
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_264
$_263:	mov	r8d, 1
	mov	rdx, qword ptr [rbp-0x18]
	mov	rcx, rax
	call	CreateProc
	mov	qword ptr [rbp-0x8], rax
	mov	dword ptr [rbp-0x20], 0
	jmp	$_269

$_264:	cmp	byte ptr [rax+0x1D], 2
	jnz	$_268
	test	byte ptr [rax+0x4B], 0x02
	jz	$_268
	mov	dword ptr [rbp-0x20], 1
	test	byte ptr [rax+0x10], 0x02
	jz	$_266
	inc	dword ptr [procidx+rip]
	test	byte ptr [Options+0x4+rip], 0x02
	jz	$_265
	mov	ecx, 24
	call	LclAlloc@PLT
	mov	rdi, rax
	mov	rcx, qword ptr [rbp-0x8]
	mov	qword ptr [rcx+0x68], rdi
	call	get_curr_srcfile@PLT
	mov	word ptr [rdi+0xE], ax
$_265:	jmp	$_267

$_266:	mov	r8d, 1
	mov	rdx, qword ptr [rbp-0x18]
	mov	rcx, qword ptr [rbp-0x8]
	call	CreateProc
	mov	qword ptr [rbp-0x8], rax
$_267:	jmp	$_269

$_268:	mov	rcx, qword ptr [rbp-0x8]
	mov	rdx, qword ptr [rcx+0x8]
	mov	ecx, 2005
	call	asmerr@PLT
	jmp	$_289

$_269:	mov	rdi, qword ptr [rbp-0x8]
	mov	rcx, rdi
	call	SetSymSegOfs@PLT
	call	SymClearLocal@PLT
	mov	rsi, qword ptr [rdi+0x78]
	movzx	ecx, byte ptr [r14+0x4]
	mov	eax, dword ptr [r14+rcx*4+0x68]
	mov	dword ptr [rsi+0x14], eax
	mov	qword ptr [CurrProc+rip], rdi
	mov	r8, qword ptr [rdi+0x8]
	lea	rdx, [DS0002+rip]
	lea	rcx, [strFUNC+rip]
	call	tsprintf@PLT
	cmp	dword ptr [r14+0x58], 0
	jz	$_270
	mov	rax, qword ptr [r14+0x50]
	mov	qword ptr [r14+0x50], 0
	test	rax, rax
	jz	$_270
	test	byte ptr [rax+0x12], 0x02
	jz	$_270
	mov	qword ptr [rdi+0x38], rax
	or	byte ptr [rdi+0x4B], 0x10
$_270:	movzx	eax, byte ptr [r14+0x9]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, 1
	mov	r8, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbp+0x28]
	mov	rcx, rdi
	call	ParseProc
	cmp	eax, -1
	jnz	$_271
	mov	qword ptr [CurrProc+rip], 0
	mov	byte ptr [strFUNC+rip], 0
	jmp	$_289

$_271:	cmp	dword ptr [rbp-0x20], 0
	jz	$_272
	test	byte ptr [Options+0x5+rip], 0x80
	jz	$_272
	or	byte ptr [rdi+0x10], 0x04
$_272:	cmp	byte ptr [rdi+0x1D], 2
	jnz	$_275
	test	byte ptr [rdi+0x10], 0x02
	jz	$_275
	mov	rcx, rdi
	call	sym_ext2int@PLT
	cmp	qword ptr [SymTables+0x40+rip], 0
	jnz	$_273
	mov	qword ptr [SymTables+0x40+rip], rdi
	jmp	$_274

$_273:	mov	rcx, qword ptr [SymTables+0x48+rip]
	mov	qword ptr [rcx+0x88], rdi
$_274:	mov	qword ptr [SymTables+0x48+rip], rdi
$_275:	mov	rcx, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rcx+0x78]
	mov	eax, dword ptr [rsi+0x14]
	add	eax, eax
	cmp	qword ptr [rsi+0x18], 0
	jz	$_276
	cmp	byte ptr [r12+rax*8+0xC], 4
	jnz	$_276
	or	byte ptr [rsi], 0x40
$_276:	test	byte ptr [rdi+0x10], 0x04
	jz	$_277
	cmp	dword ptr [rbp-0x1C], 0
	jnz	$_277
	mov	rcx, rdi
	call	AddPublicData@PLT
$_277:	mov	rcx, qword ptr [r14+0x38]
	mov	rdx, qword ptr [rcx+0x78]
	mov	rax, qword ptr [rdx+0x20]
	mov	qword ptr [rdi+0x80], rax
	mov	qword ptr [rdx+0x20], rdi
	jmp	$_281

$_278:	mov	rdi, qword ptr [rbp-0x8]
	test	rdi, rdi
	jnz	$_279
	xor	eax, eax
	jmp	$_289

$_279:	inc	dword ptr [procidx+rip]
	or	byte ptr [rdi+0x10], 0x01
	mov	rcx, rdi
	call	SymSetLocal@PLT
	call	GetCurrOffset@PLT
	mov	ecx, eax
	cmp	ecx, dword ptr [rdi+0x30]
	jz	$_280
	or	byte ptr [r14+0x370], 0x01
	mov	dword ptr [rdi+0x30], ecx
$_280:	mov	qword ptr [CurrProc+rip], rdi
	mov	r8, qword ptr [rdi+0x8]
	lea	rdx, [DS0002+rip]
	lea	rcx, [strFUNC+rip]
	call	tsprintf@PLT
	mov	rsi, qword ptr [rdi+0x78]
	mov	rcx, qword ptr [rsi+0x40]
	test	byte ptr [rsi], 0x20
	jz	$_281
	test	rcx, rcx
	jz	$_281
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_281
	mov	rdx, qword ptr [rcx+0x8]
	mov	ecx, 2006
	call	asmerr@PLT
$_281:	mov	rcx, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rcx+0x78]
	mov	ecx, 128
	test	byte ptr [rsi], 0x40
	jz	$_282
	or	ecx, 0x04
$_282:	mov	dword ptr [ProcStatus+rip], ecx
	mov	dword ptr [StackAdj+rip], 0
	mov	dword ptr [StackAdjHigh+rip], 0
	test	byte ptr [rsi], 0x20
	jz	$_283
	mov	dword ptr [endprolog_found+rip], 0
	mov	r8d, 4
	xor	edx, edx
	lea	rcx, [unw_info+rip]
	call	tmemset@PLT
	cmp	qword ptr [rsi+0x40], 0
	jz	$_283
	mov	eax, 3
	and	byte ptr [unw_info+rip], 0x03
	shl	al, 2
	or	byte ptr [unw_info+rip], al
$_283:	mov	rcx, qword ptr [rbp-0x8]
	mov	eax, dword ptr [Parse_Pass+rip]
	mov	byte ptr [rcx+0x4A], al
	test	byte ptr [r14], 0x08
	jz	$_284
	xor	r8d, r8d
	xor	edx, edx
	mov	ecx, 7
	call	LstWrite@PLT
$_284:	test	byte ptr [Options+0x4+rip], 0x02
	jz	$_287
	call	get_curr_srcfile@PLT
	mov	edi, eax
	cmp	byte ptr [Options+0xAA+rip], 4
	jnz	$_285
	call	GetLineNumber@PLT
	mov	edx, eax
	mov	ecx, edi
	call	AddLinnumDataRef@PLT
	jmp	$_287

$_285:	xor	eax, eax
	cmp	dword ptr [Options+0x8C+rip], 2
	jz	$_286
	call	GetLineNumber@PLT
$_286:	mov	edx, eax
	mov	ecx, edi
	call	AddLinnumDataRef@PLT
$_287:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_288
	mov	rcx, qword ptr [rbp-0x8]
	call	BackPatch@PLT
$_288:	mov	eax, 0
$_289:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

CopyPrototype:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rdi, rcx
	mov	rsi, qword ptr [rdi+0x78]
	mov	rcx, qword ptr [rbp+0x28]
	test	byte ptr [rcx+0x10], 0x02
	jnz	$_290
	mov	rax, -1
	jmp	$_298

$_290:	mov	r8d, 80
	mov	rdx, qword ptr [rcx+0x78]
	mov	rcx, rsi
	call	tmemcpy@PLT
	mov	rcx, qword ptr [rbp+0x28]
	mov	al, byte ptr [rcx+0x1E]
	mov	byte ptr [rdi+0x1E], al
	mov	al, byte ptr [rcx+0x1F]
	mov	byte ptr [rdi+0x1F], al
	and	byte ptr [rdi+0x10], 0xFB
	test	byte ptr [rcx+0x10], 0x04
	jz	$_291
	or	byte ptr [rdi+0x10], 0x04
$_291:	mov	al, byte ptr [rcx+0x20]
	mov	byte ptr [rdi+0x20], al
	or	byte ptr [rdi+0x10], 0x02
	mov	qword ptr [rsi+0x18], 0
	mov	rdx, qword ptr [rcx+0x78]
	mov	rdi, qword ptr [rdx+0x18]
$_292:	test	rdi, rdi
	jz	$_297
	mov	ecx, 144
	call	LclAlloc@PLT
	mov	r8d, 144
	mov	rdx, rdi
	mov	rcx, rax
	call	tmemcpy@PLT
	mov	qword ptr [rax+0x88], 0
	cmp	qword ptr [rsi+0x18], 0
	jnz	$_293
	mov	qword ptr [rsi+0x18], rax
	jmp	$_296

$_293:	mov	rcx, qword ptr [rsi+0x18]
$_294:	cmp	qword ptr [rcx+0x88], 0
	jz	$_295
	mov	rcx, qword ptr [rcx+0x88]
	jmp	$_294

$_295:	mov	qword ptr [rcx+0x88], rax
$_296:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_292

$_297:	xor	eax, eax
$_298:	leave
	pop	rdi
	pop	rsi
	ret

$_299:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 264
	lea	rax, [DS0003+rip]
	mov	qword ptr [rbp-0x10], rax
	mov	dword ptr [rbp-0x20], 0
	mov	rdi, rcx
	cmp	dword ptr [endprolog_found+rip], 0
	jnz	$_300
	mov	ecx, 2220
	call	asmerr@PLT
$_300:	cmp	byte ptr [unw_segs_defined+rip], 0
	jz	$_301
	mov	r8d, 613
	mov	rdx, qword ptr [rbp-0x10]
	lea	rcx, [DS0004+rip]
	call	AddLineQueueX@PLT
	jmp	$_302

$_301:	mov	dword ptr [rsp+0x30], 290
	mov	dword ptr [rsp+0x28], 608
	mov	dword ptr [rsp+0x20], 340
	mov	r9d, 611
	mov	r8d, 613
	mov	rdx, qword ptr [rbp-0x10]
	lea	rcx, [DS0005+rip]
	call	AddLineQueueX@PLT
$_302:	mov	dword ptr [rbp-0x20], 0
	mov	rcx, qword ptr [rbp-0x10]
	call	SymFind@PLT
	mov	qword ptr [rbp-0x8], rax
	test	rax, rax
	jz	$_303
	mov	eax, dword ptr [rax+0x60]
	mov	dword ptr [rbp-0x20], eax
$_303:	movzx	eax, byte ptr [unw_info+rip]
	shr	eax, 2
	mov	ecx, eax
	mov	al, byte ptr [unw_info+0x3+rip]
	and	eax, 0x0F
	mov	edx, eax
	movzx	eax, byte ptr [unw_info+0x3+rip]
	shr	eax, 4
	mov	qword ptr [rsp+0x30], rax
	mov	dword ptr [rsp+0x28], edx
	movzx	eax, byte ptr [unw_info+0x2+rip]
	mov	dword ptr [rsp+0x20], eax
	movzx	r9d, byte ptr [unw_info+0x1+rip]
	mov	r8d, ecx
	mov	edx, 1
	lea	rcx, [DS0006+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [unw_info+0x2+rip], 0
	je	$_307
	lea	rax, [DS0007+rip]
	mov	qword ptr [rbp-0xB8], rax
	mov	byte ptr [rbp-0xAC], 0
	movzx	esi, byte ptr [unw_info+0x2+rip]
	lea	rdi, [rbp-0xAC]
$_304:	test	esi, esi
	jz	$_307
	mov	rcx, rdi
	call	tstrlen@PLT
	lea	rbx, [rdi+rax]
	lea	rcx, [unw_code+rip]
	mov	rdx, rsi
	movzx	r9d, word ptr [rcx+rdx*2-0x2]
	mov	r8, qword ptr [rbp-0xB8]
	lea	rdx, [DS0008+rip]
	mov	rcx, rbx
	call	tsprintf@PLT
	lea	rax, [DS0000+rip]
	mov	qword ptr [rbp-0xB8], rax
	mov	rcx, rdi
	call	tstrlen@PLT
	cmp	esi, 1
	jz	$_305
	cmp	rax, 72
	jbe	$_306
$_305:	mov	rcx, rdi
	call	AddLineQueue@PLT
	mov	byte ptr [rdi], 0
	lea	rax, [DS0007+rip]
	mov	qword ptr [rbp-0xB8], rax
$_306:	dec	esi
	jmp	$_304

$_307:
	lea	rcx, [DS0009+rip]
	call	AddLineQueue@PLT
	mov	rdi, qword ptr [rbp+0x28]
	mov	rsi, qword ptr [rdi+0x78]
	cmp	qword ptr [rsi+0x40], 0
	jz	$_308
	mov	rcx, qword ptr [rsi+0x40]
	mov	r9d, 611
	mov	r8, qword ptr [rcx+0x8]
	mov	edx, 303
	lea	rcx, [DS000A+rip]
	call	AddLineQueueX@PLT
$_308:	mov	r8d, 614
	mov	rdx, qword ptr [rbp-0x10]
	lea	rcx, [DS0004+rip]
	call	AddLineQueueX@PLT
	xor	ecx, ecx
	call	SimGetSegName@PLT
	mov	rcx, qword ptr [rdi+0x40]
	mov	rdx, qword ptr [rcx+0x8]
	mov	rcx, rax
	call	tstrcmp@PLT
	test	eax, eax
	jnz	$_309
	lea	rax, [DS000B+rip]
	mov	qword ptr [rbp-0x10], rax
	mov	al, byte ptr [unw_segs_defined+rip]
	and	eax, 0x01
	mov	dword ptr [rbp-0x18], eax
	mov	byte ptr [unw_segs_defined+rip], 3
	jmp	$_310

$_309:	lea	rax, [rbp-0x2C]
	mov	qword ptr [rbp-0x10], rax
	mov	rcx, qword ptr [rdi+0x40]
	call	GetSegIdx@PLT
	mov	r8, rax
	lea	rdx, [DS000C+rip]
	mov	rcx, qword ptr [rbp-0x10]
	call	tsprintf@PLT
	mov	dword ptr [rbp-0x18], 0
	or	byte ptr [unw_segs_defined+rip], 0x02
$_310:	cmp	dword ptr [rbp-0x18], 0
	jz	$_311
	mov	r8d, 613
	mov	rdx, qword ptr [rbp-0x10]
	lea	rcx, [DS0004+rip]
	call	AddLineQueueX@PLT
	jmp	$_312

$_311:	mov	dword ptr [rsp+0x20], 340
	mov	r9d, 611
	mov	r8d, 613
	mov	rdx, qword ptr [rbp-0x10]
	lea	rcx, [DS000D+rip]
	call	AddLineQueueX@PLT
$_312:	mov	dword ptr [rsp+0x48], 614
	mov	rax, qword ptr [rbp-0x10]
	mov	qword ptr [rsp+0x40], rax
	mov	eax, dword ptr [rbp-0x20]
	mov	dword ptr [rsp+0x38], eax
	mov	dword ptr [rsp+0x30], 303
	mov	eax, dword ptr [rdi+0x60]
	mov	dword ptr [rsp+0x28], eax
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, 303
	mov	r8, qword ptr [rdi+0x8]
	mov	edx, 303
	lea	rcx, [DS000E+rip]
	call	AddLineQueueX@PLT
	movzx	esi, byte ptr [r14]
	and	esi, 0x04
	shr	esi, 2
	or	byte ptr [r14], 0x04
	call	RunLineQueue@PLT
	test	esi, esi
	jnz	$_313
	and	byte ptr [r14], 0xFB
$_313:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_314:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rdi, rcx
	mov	rax, qword ptr [rdi+0x40]
	cmp	qword ptr [r14+0x38], rax
	jnz	$_315
	call	GetCurrOffset@PLT
	mov	ecx, eax
	sub	ecx, dword ptr [rdi+0x30]
	mov	dword ptr [rdi+0x60], ecx
	jmp	$_316

$_315:	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 1010
	call	asmerr@PLT
	mov	rdx, qword ptr [r14+0x38]
	mov	rcx, qword ptr [rdx+0x40]
	mov	ecx, dword ptr [rcx+0x30]
	sub	ecx, dword ptr [rdi+0x30]
	mov	dword ptr [rdi+0x60], ecx
$_316:	mov	rsi, qword ptr [rdi+0x78]
	cmp	byte ptr [Options+0xAC+rip], 2
	jbe	$_322
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_322
	mov	rdi, qword ptr [rsi+0x18]
$_317:	test	rdi, rdi
	jz	$_319
	test	byte ptr [rdi+0x10], 0x10
	jnz	$_318
	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 6004
	call	asmerr@PLT
$_318:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_317

$_319:	mov	rdi, qword ptr [rsi+0x20]
$_320:	test	rdi, rdi
	jz	$_322
	test	byte ptr [rdi+0x10], 0x10
	jnz	$_321
	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 6004
	call	asmerr@PLT
$_321:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_320

$_322:
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_327
	cmp	byte ptr [r14+0x7], 2
	jz	$_323
	cmp	byte ptr [r14+0x7], 5
	jz	$_323
	cmp	byte ptr [r14+0x7], 3
	jnz	$_327
$_323:	test	byte ptr [r14+0x2D], 0x02
	jz	$_327
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	ecx, dword ptr [rcx+0x30]
	mov	dword ptr [rsi+0x8], ecx
	test	byte ptr [rsi], 0x40
	jz	$_327
	mov	rdi, qword ptr [rsi+0x20]
$_324:	test	rdi, rdi
	jz	$_325
	add	dword ptr [rdi+0x30], ecx
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_324

$_325:	mov	rdi, qword ptr [rsi+0x18]
$_326:	test	rdi, rdi
	jz	$_327
	add	dword ptr [rdi+0x30], ecx
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_326

$_327:
	test	byte ptr [rsi], 0x20
	jz	$_328
	call	LstSetPosition@PLT
	mov	rcx, qword ptr [rbp+0x20]
	call	$_299
$_328:	test	byte ptr [r14], 0x08
	jz	$_329
	xor	r8d, r8d
	xor	edx, edx
	mov	ecx, 7
	call	LstWrite@PLT
$_329:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_331
	test	dword ptr [ProcStatus+rip], 0x80
	jz	$_330
	mov	rcx, qword ptr [CurrProc+rip]
	mov	rcx, qword ptr [rcx+0x78]
	call	SetLocalOffsets
$_330:	mov	rcx, qword ptr [CurrProc+rip]
	call	SymGetLocal@PLT
$_331:	lea	rdx, [ProcStack+rip]
	mov	rax, qword ptr [rdx]
	test	rax, rax
	jz	$_332
	mov	rcx, rax
	mov	rax, qword ptr [rcx]
	mov	qword ptr [rdx], rax
	mov	rax, qword ptr [rcx+0x8]
$_332:	mov	qword ptr [CurrProc+rip], rax
	test	rax, rax
	jz	$_333
	mov	r8, qword ptr [rax+0x8]
	lea	rdx, [DS0002+rip]
	lea	rcx, [strFUNC+rip]
	call	tsprintf@PLT
	mov	rcx, qword ptr [CurrProc+rip]
	call	SymSetLocal@PLT
	jmp	$_334

$_333:	mov	byte ptr [strFUNC+rip], al
$_334:	mov	dword ptr [ProcStatus+rip], 0
	leave
	pop	rdi
	pop	rsi
	ret

EndpDir:
	mov	qword ptr [rsp+0x8], rcx
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 168
	mov	rbx, rdx
	cmp	dword ptr [rbp+0x18], 1
	jnz	$_335
	cmp	byte ptr [rbx+0x40], 0
	jz	$_336
$_335:	imul	ecx, dword ptr [rbp+0x18], 32
	mov	rdx, qword ptr [rbx+rcx+0x18]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_345

$_336:	mov	rcx, qword ptr [CurrProc+rip]
	cmp	qword ptr [r14+0x2F8], 0
	jz	$_337
	or	byte ptr [r14+0x370], 0x02
	or	byte ptr [rcx+0x13], 0x20
	lea	rcx, [DS000F+rip]
	call	AddLineQueue@PLT
	call	RunLineQueue@PLT
	mov	rcx, qword ptr [CurrProc+rip]
$_337:	test	rcx, rcx
	jz	$_343
	mov	edx, dword ptr [rcx+0x14]
	cmp	edx, 4
	jz	$_338
	cmp	edx, 5
	jnz	$_341
$_338:	mov	rdx, qword ptr [rcx+0x8]
	mov	eax, dword ptr [rdx]
	cmp	eax, 1852399981
	jz	$_339
	cmp	eax, 1767992695
	jnz	$_340
	cmp	byte ptr [rdx+0x4], 110
	jnz	$_340
$_339:	or	byte ptr [Options+0x7+rip], 0x20
	mov	rax, qword ptr [rcx+0x78]
	mov	rax, qword ptr [rax+0x18]
	test	rax, rax
	jz	$_340
	or	byte ptr [Options+0x7+rip], 0x40
$_340:	mov	edx, dword ptr [rcx+0x14]
$_341:	inc	edx
	mov	r8d, edx
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, qword ptr [rcx+0x8]
	call	qword ptr [SymCmpFunc+rip]
	test	eax, eax
	jnz	$_342
	mov	rcx, qword ptr [CurrProc+rip]
	call	$_314
	mov	ecx, 1
	jmp	$_343

$_342:	xor	ecx, ecx
$_343:	test	ecx, ecx
	jnz	$_344
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 1010
	call	asmerr@PLT
	jmp	$_345

$_344:	xor	eax, eax
$_345:	leave
	pop	rbx
	ret

ExcFrameDirective:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 184
	mov	al, byte ptr [unw_info+0x2+rip]
	mov	byte ptr [rbp-0x71], al
	mov	rdi, qword ptr [CurrProc+rip]
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	cmp	dword ptr [Options+0x8C+rip], 3
	jz	$_346
	cmp	dword ptr [Options+0x8C+rip], 1
	jz	$_346
	cmp	byte ptr [r14+0xB], 1
	jnz	$_347
$_346:	xor	edx, edx
	mov	ecx, dword ptr [rbx+0x4]
	call	GetResWName@PLT
	mov	rdx, rax
	mov	ecx, 2248
	call	asmerr@PLT
	jmp	$_393

$_347:	test	rdi, rdi
	jz	$_348
	cmp	dword ptr [endprolog_found+rip], 1
	jnz	$_349
$_348:	mov	ecx, 4020
	call	asmerr@PLT
	jmp	$_393

$_349:	mov	rsi, qword ptr [rdi+0x78]
	test	byte ptr [rsi], 0x20
	jnz	$_350
	mov	ecx, 2221
	call	asmerr@PLT
	jmp	$_393

$_350:	movzx	ecx, byte ptr [unw_info+0x2+rip]
	lea	rax, [unw_code+rip]
	lea	rax, [rax+rcx*2]
	mov	qword ptr [rbp-0x80], rax
	call	GetCurrOffset@PLT
	mov	ecx, eax
	sub	ecx, dword ptr [rdi+0x30]
	mov	byte ptr [rbp-0x73], cl
	mov	eax, dword ptr [rbx+0x4]
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	mov	dword ptr [rbp-0x6C], eax
	jmp	$_389

$_351:	mov	byte ptr [rsp+0x20], 0
	lea	r9, [rbp-0x68]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	je	$_393
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp-0x18]
	cmp	dword ptr [rbp-0x2C], 1
	jnz	$_352
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_352
	jmp	$_353

$_352:	cmp	dword ptr [rbp-0x2C], 0
	jz	$_353
	mov	ecx, 2026
	call	asmerr@PLT
	jmp	$_393

$_353:	cmp	dword ptr [rbp-0x64], 0
	jz	$_354
	call	EmitConstError@PLT
	jmp	$_393

$_354:	cmp	dword ptr [rbp-0x68], 0
	jnz	$_355
	mov	ecx, 2090
	call	asmerr@PLT
	jmp	$_393

$_355:	test	byte ptr [rbp-0x68], 0x07
	jz	$_356
	mov	ecx, 2219
	call	asmerr@PLT
	jmp	$_393

$_356:	cmp	dword ptr [rbp-0x68], 128
	jbe	$_359
	cmp	dword ptr [rbp-0x68], 524288
	jc	$_357
	mov	edx, dword ptr [rbp-0x68]
	shr	edx, 16
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	movzx	edx, word ptr [rbp-0x68]
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	add	byte ptr [unw_info+0x2+rip], 2
	mov	edx, 1
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	jmp	$_358

$_357:	mov	edx, dword ptr [rbp-0x68]
	shr	edx, 3
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	inc	byte ptr [unw_info+0x2+rip]
	xor	edx, edx
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
$_358:	mov	edx, 1
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	jmp	$_360

$_359:	mov	edx, 2
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	mov	edx, dword ptr [rbp-0x68]
	sub	edx, 8
	shr	edx, 3
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
$_360:	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	inc	byte ptr [unw_info+0x2+rip]
	jmp	$_390

$_361:	call	GetCurrOffset@PLT
	mov	ecx, eax
	sub	ecx, dword ptr [rdi+0x30]
	mov	dword ptr [rbp-0x68], ecx
	cmp	ecx, 255
	jbe	$_362
	mov	ecx, 2247
	call	asmerr@PLT
	jmp	$_393

$_362:	mov	eax, dword ptr [rbp-0x68]
	mov	byte ptr [unw_info+0x1+rip], al
	mov	dword ptr [endprolog_found+rip], 1
	jmp	$_390

$_363:	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	mov	edx, 10
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	xor	edx, edx
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	cmp	byte ptr [rbx], 8
	jnz	$_364
	mov	rcx, qword ptr [rbx+0x10]
	mov	eax, dword ptr [rcx]
	or	eax, 0x20202020
	cmp	eax, 1701080931
	jnz	$_364
	cmp	byte ptr [rcx+0x4], 0
	jnz	$_364
	mov	edx, 1
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
$_364:	inc	byte ptr [unw_info+0x2+rip]
	jmp	$_390

$_365:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8]
	and	ecx, 0x08
	cmp	byte ptr [rbx], 2
	jnz	$_366
	test	ecx, ecx
	jnz	$_367
$_366:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_367:	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	xor	edx, edx
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	movzx	edx, byte ptr [r12+rax*8+0xC]
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	inc	byte ptr [unw_info+0x2+rip]
	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	jmp	$_390

$_368:	cmp	byte ptr [rbx], 2
	jz	$_369
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_369:	cmp	dword ptr [rbp-0x6C], 592
	jnz	$_371
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jnz	$_370
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_370:	jmp	$_372

$_371:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x08
	jnz	$_372
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_372:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbp-0x72], al
	cmp	dword ptr [rbp-0x6C], 591
	jnz	$_373
	mov	dword ptr [rbp-0x70], 8
	jmp	$_374

$_373:	mov	dword ptr [rbp-0x70], 16
$_374:	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	cmp	byte ptr [rbx], 44
	jz	$_375
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_375:	inc	dword ptr [rbp+0x28]
	mov	byte ptr [rsp+0x20], 0
	lea	r9, [rbp-0x68]
	mov	r8d, dword ptr [r14+0x64]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp+0x28]
	call	EvalOperand@PLT
	cmp	eax, -1
	je	$_393
	imul	ebx, dword ptr [rbp+0x28], 32
	add	rbx, qword ptr [rbp+0x30]
	mov	rcx, qword ptr [rbp-0x18]
	cmp	dword ptr [rbp-0x2C], 1
	jnz	$_376
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_376
	jmp	$_377

$_376:	cmp	dword ptr [rbp-0x2C], 0
	jz	$_377
	mov	ecx, 2026
	call	asmerr@PLT
	jmp	$_393

$_377:	mov	eax, dword ptr [rbp-0x70]
	dec	eax
	test	dword ptr [rbp-0x68], eax
	jz	$_378
	mov	ecx, 2219
	call	asmerr@PLT
	jmp	$_393

$_378:	mov	eax, dword ptr [rbp-0x6C]
	jmp	$_387

$_379:	movzx	edx, byte ptr [rbp-0x72]
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	imul	ecx, dword ptr [rbp-0x70], 65536
	cmp	dword ptr [rbp-0x68], ecx
	jle	$_380
	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 19
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 3
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	edx, 5
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	add	byte ptr [unw_info+0x2+rip], 3
	jmp	$_381

$_380:	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 3
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	edx, 4
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	add	byte ptr [unw_info+0x2+rip], 2
$_381:	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	movzx	edx, byte ptr [rbp-0x72]
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	jmp	$_388

$_382:	imul	ecx, dword ptr [rbp-0x70], 65536
	cmp	dword ptr [rbp-0x68], ecx
	jle	$_383
	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 20
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 4
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	edx, 9
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	add	byte ptr [unw_info+0x2+rip], 3
	jmp	$_384

$_383:	mov	ecx, dword ptr [rbp-0x68]
	shr	ecx, 4
	movzx	edx, cx
	mov	rax, qword ptr [rbp-0x80]
	mov	word ptr [rax], dx
	add	qword ptr [rbp-0x80], 2
	mov	edx, 8
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	add	byte ptr [unw_info+0x2+rip], 2
$_384:	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	movzx	edx, byte ptr [rbp-0x72]
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	jmp	$_388

$_385:	cmp	dword ptr [rbp-0x68], 240
	jbe	$_386
	call	EmitConstError@PLT
	jmp	$_393

$_386:	movzx	eax, byte ptr [rbp-0x72]
	and	byte ptr [unw_info+0x3+rip], 0xF0
	or	byte ptr [unw_info+0x3+rip], al
	mov	edx, dword ptr [rbp-0x68]
	shr	edx, 4
	movzx	eax, dl
	and	byte ptr [unw_info+0x3+rip], 0x0F
	shl	al, 4
	or	byte ptr [unw_info+0x3+rip], al
	movzx	edx, byte ptr [rbp-0x73]
	mov	rax, qword ptr [rbp-0x80]
	mov	byte ptr [rax], dl
	mov	edx, 3
	mov	rax, qword ptr [rbp-0x80]
	and	byte ptr [rax+0x1], 0xF0
	or	byte ptr [rax+0x1], dl
	movzx	edx, byte ptr [rbp-0x72]
	mov	rax, qword ptr [rbp-0x80]
	shl	dl, 4
	and	byte ptr [rax+0x1], 0x0F
	or	byte ptr [rax+0x1], dl
	inc	byte ptr [unw_info+0x2+rip]
	jmp	$_388

$_387:	cmp	eax, 591
	je	$_379
	cmp	eax, 592
	je	$_382
	cmp	eax, 593
	je	$_385
$_388:	jmp	$_390

$_389:	cmp	eax, 587
	je	$_351
	cmp	eax, 588
	je	$_361
	cmp	eax, 589
	je	$_363
	cmp	eax, 590
	je	$_365
	cmp	eax, 591
	je	$_368
	cmp	eax, 592
	je	$_368
	cmp	eax, 593
	je	$_368
$_390:	cmp	byte ptr [rbx], 0
	jz	$_391
	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	asmerr@PLT
	jmp	$_393

$_391:	mov	al, byte ptr [unw_info+0x2+rip]
	cmp	byte ptr [rbp-0x71], al
	jbe	$_392
	mov	ecx, 2247
	call	asmerr@PLT
	jmp	$_393

$_392:	xor	eax, eax
$_393:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ProcCheckOpen:
	push	rdi
	sub	rsp, 32
	mov	rdi, qword ptr [CurrProc+rip]
	jmp	$_395

$_394:	mov	rdx, qword ptr [rdi+0x8]
	mov	ecx, 1010
	call	asmerr@PLT
	mov	rcx, rdi
	call	$_314
	mov	rdi, qword ptr [CurrProc+rip]
$_395:	test	rdi, rdi
	jnz	$_394
	add	rsp, 32
	pop	rdi
	ret

$_396:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2296
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_397
	cmp	dword ptr [UseSavedState+rip], 0
	jz	$_397
	xor	eax, eax
	jmp	$_413

$_397:	mov	rdi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rdi+0x78]
	movzx	ebx, byte ptr [rdi+0x1F]
	mov	qword ptr [rbp-0x8], rsi
	cmp	ebx, 7
	jnz	$_398
	cmp	byte ptr [r14+0x7], 2
	jnz	$_398
	mov	ebx, 0
$_398:	cmp	ebx, 1
	jz	$_399
	cmp	ebx, 2
	jz	$_399
	cmp	ebx, 7
	jnz	$_400
$_399:	or	ebx, 0x10
$_400:	cmp	byte ptr [rdi+0x1E], 130
	jnz	$_401
	or	ebx, 0x20
$_401:	test	byte ptr [rdi+0x10], 0x04
	jnz	$_402
	or	ebx, 0x40
$_402:	test	byte ptr [rdi+0x10], 0x20
	jz	$_403
	or	ebx, 0x80
$_403:	mov	dword ptr [rbp-0x8B4], ebx
	mov	rcx, qword ptr [r14+0x180]
	call	SymFind@PLT
	mov	qword ptr [rbp-0x28], rax
	test	eax, eax
	jz	$_404
	cmp	byte ptr [rax+0x1D], 9
	jnz	$_404
	test	byte ptr [rax+0x48], 0x02
	jnz	$_405
$_404:	mov	ecx, 2120
	call	asmerr@PLT
	jmp	$_413

$_405:	test	byte ptr [Options+0x5+rip], 0x20
	jz	$_406
	lea	rcx, [DS0010+rip]
	call	tprintf@PLT
$_406:	lea	rdi, [rbp-0xB0]
	mov	rsi, qword ptr [rsi+0x30]
	test	rsi, rsi
	jz	$_409
	movzx	ebx, word ptr [rsi]
	add	rsi, 2
$_407:	test	ebx, ebx
	jz	$_409
	movzx	ecx, word ptr [rsi]
	mov	rdx, rdi
	call	GetResWName@PLT
	mov	rcx, rdi
	call	tstrlen@PLT
	add	rdi, rax
	cmp	ebx, 1
	jbe	$_408
	mov	byte ptr [rdi], 44
	inc	rdi
$_408:	dec	ebx
	add	rsi, 2
	jmp	$_407

$_409:	mov	byte ptr [rdi], 0
	mov	rsi, qword ptr [rbp-0x8]
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rcx, qword ptr [rsi+0x38]
	test	rcx, rcx
	jnz	$_410
	lea	rcx, [DS0010+0x15+rip]
$_410:	mov	qword ptr [rsp+0x38], rcx
	lea	rax, [rbp-0xB0]
	mov	qword ptr [rsp+0x30], rax
	mov	eax, dword ptr [rsi+0x4]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rsi+0xC]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x8B4]
	mov	r8, qword ptr [rdi+0x8]
	lea	rdx, [DS0011+rip]
	lea	rcx, [rbp-0x8B0]
	call	tsprintf@PLT
	mov	ebx, dword ptr [r14+0x64]
	inc	ebx
	mov	r9d, 1
	mov	r8, qword ptr [rbp+0x28]
	mov	edx, ebx
	lea	rcx, [rbp-0x8B0]
	call	Tokenize@PLT
	mov	dword ptr [r14+0x64], eax
	lea	rax, [rbp-0x1C]
	mov	qword ptr [rsp+0x28], rax
	mov	dword ptr [rsp+0x20], 0
	lea	r9, [rbp-0x8B0]
	mov	r8, qword ptr [rbp+0x28]
	mov	edx, ebx
	mov	rcx, qword ptr [rbp-0x28]
	call	RunMacro@PLT
	dec	ebx
	mov	dword ptr [r14+0x64], ebx
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_412
	lea	rcx, [rbp-0x8B0]
	call	_atoqw@PLT
	mov	ebx, eax
	sub	ebx, dword ptr [rsi+0x4]
	mov	rdi, qword ptr [rsi+0x20]
$_411:	test	rdi, rdi
	jz	$_412
	sub	dword ptr [rdi+0x30], ebx
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_411

$_412:	xor	eax, eax
$_413:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_414:
	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, 40
	mov	rcx, qword ptr [CurrProc+rip]
	mov	al, byte ptr [rcx+0x1F]
	mov	byte ptr [rbp-0x1], al
	xor	esi, esi
	mov	rdi, qword ptr [rbp+0x38]
	mov	al, byte ptr [rdi+0x1E]
	cmp	al, 196
	jnz	$_415
	mov	rdx, qword ptr [rdi+0x28]
	mov	al, byte ptr [rdx+0x1E]
$_415:	mov	ecx, dword ptr [rbp+0x28]
	lea	edx, [rcx+0x28]
	xor	ebx, ebx
	test	al, 0x20
	jnz	$_416
	cmp	al, 31
	jz	$_416
	cmp	byte ptr [rbp-0x1], 8
	jnz	$_423
	cmp	al, 15
	jz	$_416
	cmp	al, 79
	jnz	$_423
$_416:	cmp	al, 35
	jz	$_417
	cmp	al, 33
	jnz	$_418
$_417:	mov	esi, 1129
	jmp	$_422

$_418:	cmp	al, 39
	jnz	$_419
	mov	esi, 1130
	jmp	$_422

$_419:	cmp	dword ptr [rdi+0x60], 16
	ja	$_420
	mov	esi, 1132
	jmp	$_422

$_420:	cmp	dword ptr [rdi+0x60], 32
	jnz	$_421
	mov	esi, 1554
	lea	edx, [rcx+0x30]
	jmp	$_422

$_421:	cmp	dword ptr [rdi+0x60], 64
	jnz	$_422
	mov	esi, 1554
	lea	edx, [rcx+0x40]
$_422:	jmp	$_425

$_423:	cmp	ecx, 4
	jnc	$_425
	lea	rdi, [fast_regs+0x18+rip]
	movzx	edx, byte ptr [rdi+rcx]
	mov	esi, 779
	cmp	al, 15
	jz	$_424
	cmp	al, 79
	jnz	$_425
$_424:	cmp	byte ptr [rbp-0x1], 8
	jz	$_425
	movzx	ebx, byte ptr [rdi+rcx+0x1]
	inc	dword ptr [rbp+0x28]
$_425:	test	esi, esi
	jz	$_426
	imul	ecx, dword ptr [rbp+0x30]
	lea	edi, [rcx+0x8]
	mov	r9d, edx
	mov	r8d, edi
	mov	edx, esi
	lea	rcx, [DS0012+rip]
	call	AddLineQueueX@PLT
	test	ebx, ebx
	jz	$_426
	add	edi, 8
	mov	r9d, ebx
	mov	r8d, edi
	mov	edx, esi
	lea	rcx, [DS0012+rip]
	call	AddLineQueueX@PLT
$_426:	mov	eax, dword ptr [rbp+0x28]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_427:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, rdx
	mov	rdi, r8
	mov	rcx, qword ptr [CurrProc+rip]
	mov	cl, byte ptr [rcx+0x1F]
	cmp	cl, 8
	jnz	$_428
	mov	dword ptr [rsi], 16
	jmp	$_429

$_428:	mov	dword ptr [rsi], 8
$_429:	mov	rdx, qword ptr [rbp+0x28]
	test	rdi, rdi
	jz	$_430
	test	byte ptr [rdi+0x4B], 0x04
	jz	$_430
	mov	dword ptr [rdx], 1
	mov	eax, 4
	jmp	$_439

$_430:	mov	dword ptr [rdx], 0
	xor	ebx, ebx
$_431:	test	rdi, rdi
	jz	$_438
	mov	eax, dword ptr [rsi]
	cmp	dword ptr [rdi+0x60], eax
	jbe	$_437
	movzx	ecx, byte ptr [rdi+0x1E]
	jmp	$_435

$_432:	mov	eax, 16
	jmp	$_436

$_433:	mov	eax, 32
	jmp	$_436

$_434:	mov	eax, 64
	jmp	$_436

$_435:	cmp	ecx, 41
	jz	$_432
	cmp	ecx, 15
	jz	$_432
	cmp	ecx, 79
	jz	$_432
	cmp	ecx, 47
	jz	$_432
	cmp	ecx, 31
	jz	$_433
	cmp	ecx, 63
	jz	$_434
$_436:	mov	dword ptr [rsi], eax
$_437:	inc	ebx
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_431

$_438:	mov	eax, ebx
$_439:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_440:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	dword ptr [rbp-0x14], 4
	mov	rsi, rcx
	mov	rdi, qword ptr [CurrProc+rip]
	cmp	byte ptr [rdi+0x1F], 8
	jnz	$_441
	mov	dword ptr [rbp-0x14], 6
$_441:	mov	r8, qword ptr [rsi+0x18]
	lea	rdx, [rbp-0x4]
	lea	rcx, [rbp-0x8]
	call	$_427
	mov	dword ptr [rbp-0xC], eax
	cmp	dword ptr [rbp-0x8], 0
	jz	$_444
	xor	eax, eax
	mov	rdi, qword ptr [rsi+0x18]
$_442:	test	rdi, rdi
	jz	$_443
	cmp	eax, ebx
	jnc	$_443
	mov	rdi, qword ptr [rdi+0x88]
	inc	eax
	jmp	$_442

$_443:	mov	dword ptr [rbp-0x8], eax
$_444:	mov	dword ptr [rbp-0x10], 0
	xor	ebx, ebx
$_445:	cmp	ebx, dword ptr [rbp-0xC]
	jge	$_459
	mov	eax, dword ptr [rbp-0x8]
	mov	ecx, dword ptr [rbp-0xC]
	test	eax, eax
	jz	$_448
	lea	ecx, [rax-0x1]
	cmp	ebx, ecx
	jc	$_446
	xor	ecx, ecx
	jmp	$_447

$_446:	sub	ecx, ebx
$_447:	jmp	$_449

$_448:	sub	ecx, ebx
	dec	ecx
$_449:	mov	rdi, qword ptr [rsi+0x18]
$_450:	test	ecx, ecx
	jz	$_451
	mov	rdi, qword ptr [rdi+0x88]
	dec	ecx
	jmp	$_450

$_451:	mov	eax, dword ptr [rbp-0x14]
	cmp	dword ptr [rbp-0x10], eax
	jge	$_457
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_455
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_452
	cmp	dword ptr [rbp-0x4], 16
	jl	$_452
	mov	eax, dword ptr [rbp-0x4]
	mul	ebx
	add	eax, 16
	mov	dword ptr [rdi+0x30], eax
$_452:	test	byte ptr [rdi+0x10], 0x10
	jnz	$_453
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_454
$_453:	mov	r8, rdi
	mov	edx, dword ptr [rbp-0x4]
	mov	ecx, dword ptr [rbp-0x10]
	call	$_414
	mov	dword ptr [rbp-0x10], eax
$_454:	jmp	$_456

$_455:	cmp	ebx, 4
	jnc	$_456
	mov	eax, dword ptr [rbp-0x4]
	mul	ebx
	add	eax, 8
	lea	rcx, [fast_regs+0x18+rip]
	movzx	ecx, byte ptr [rcx+rbx]
	mov	r9d, ecx
	mov	r8d, eax
	mov	edx, 779
	lea	rcx, [DS0012+0x1+rip]
	call	AddLineQueueX@PLT
$_456:	jmp	$_458

$_457:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_458
	test	byte ptr [rdi+0x4B], 0x04
	jnz	$_458
	cmp	dword ptr [rbp-0x4], 16
	jl	$_458
	mov	eax, dword ptr [rbp-0x4]
	mul	ebx
	add	eax, 16
	mov	dword ptr [rdi+0x30], eax
$_458:	inc	ebx
	inc	dword ptr [rbp-0x10]
	jmp	$_445

$_459:
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_460:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	dword ptr [rbp-0x4], 0
	mov	rsi, rcx
	test	rsi, rsi
	jz	$_464
	lodsw
	movzx	ebx, ax
$_461:	test	ebx, ebx
	jz	$_464
	movzx	edi, word ptr [rsi]
	mov	eax, edi
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_462
	inc	dword ptr [rbp-0x4]
	jmp	$_463

$_462:	mov	rcx, qword ptr [rbp+0x38]
	movzx	eax, byte ptr [r14+0x4]
	shl	eax, 2
	add	dword ptr [rcx], eax
	mov	r8d, edi
	mov	edx, 774
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp+0x30], 0
	jz	$_463
	mov	eax, edi
	add	eax, eax
	mov	cl, byte ptr [r12+rax*8+0xC]
	mov	eax, 1
	shl	eax, cl
	test	ax, 0xF0E8
	jz	$_463
	mov	r8d, edi
	mov	edx, 590
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_463:	dec	ebx
	add	rsi, 2
	jmp	$_461

$_464:
	mov	eax, dword ptr [rbp-0x4]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_465:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 248
	mov	dword ptr [rbp-0x24], 0
	mov	dword ptr [rbp-0x30], 0
	mov	dword ptr [rbp-0x34], 0
	mov	dword ptr [rbp-0x3C], 0
	mov	dword ptr [rbp-0x40], 4096
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rdi+0x78]
	mov	qword ptr [rbp-0x8], rsi
	test	byte ptr [rsi+0x2], 0x40
	jz	$_468
	test	byte ptr [rsi+0x1], 0x10
	jz	$_468
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_468
	test	byte ptr [rsi+0x1], 0x01
	jnz	$_468
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_468
	or	byte ptr [rsi+0x2], 0x01
	test	byte ptr [rsi+0x1], 0x02
	jnz	$_468
	test	byte ptr [rsi+0x1], 0x08
	jnz	$_468
	cmp	qword ptr [rsi+0x30], 0
	jnz	$_468
	test	byte ptr [rsi+0x2], 0x10
	jz	$_467
	test	byte ptr [rsi+0x1], 0x80
	jz	$_466
	test	byte ptr [rsi+0x1], 0x04
	jnz	$_466
	mov	dword ptr [rsi+0x4], 0
	and	byte ptr [rsi+0x2], 0xFD
	and	byte ptr [rsi+0x2], 0xFB
$_466:	jmp	$_468

$_467:	cmp	dword ptr [rsi+0x4], 0
	jnz	$_468
	and	byte ptr [rsi+0x2], 0xFB
$_468:	test	byte ptr [rsi], 0x20
	je	$_491
	test	byte ptr [r14+0x25], 0x01
	je	$_490
	test	byte ptr [rsi+0x1], 0x10
	jz	$_469
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	eax, dword ptr [rcx+0x30]
	mov	dword ptr [rbp-0x30], eax
$_469:	test	byte ptr [rsi+0x1], 0x40
	jz	$_470
	mov	rcx, rsi
	call	$_440
$_470:	test	byte ptr [rsi+0x2], 0x20
	je	$_477
	mov	rsi, qword ptr [rsi+0x30]
	test	rsi, rsi
	je	$_477
	mov	dword ptr [rbp-0x2C], 0
	lea	r8, [rbp-0x2C]
	mov	edx, 1
	mov	rcx, rsi
	call	$_460
	mov	dword ptr [rbp-0x24], eax
	mov	rsi, qword ptr [rbp-0x8]
	mov	rdi, qword ptr [rsi+0x18]
$_471:	test	rdi, rdi
	jz	$_472
	cmp	qword ptr [rdi+0x88], 0
	jz	$_472
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_471

$_472:	test	rdi, rdi
	jz	$_477
	movzx	ecx, byte ptr [r14+0x4]
	mov	ecx, dword ptr [r14+rcx*4+0x68]
	cmp	dword ptr [rdi+0x30], 8
	jnz	$_473
	cmp	ecx, 22
	jz	$_474
$_473:	cmp	dword ptr [rdi+0x30], 16
	jnz	$_477
	cmp	ecx, 168
	jnz	$_477
$_474:	mov	rdi, qword ptr [rsi+0x18]
$_475:	test	rdi, rdi
	jz	$_477
	cmp	byte ptr [rdi+0x1D], 10
	jz	$_476
	mov	eax, dword ptr [rbp-0x2C]
	add	dword ptr [rdi+0x30], eax
$_476:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_475

$_477:	mov	rsi, qword ptr [rbp-0x8]
	test	byte ptr [rsi], 0x40
	jnz	$_478
	cmp	dword ptr [rsi+0xC], 0
	jnz	$_479
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_479
$_478:	jmp	$_480

$_479:	test	byte ptr [rsi+0x2], 0x04
	jz	$_480
	mov	ecx, dword ptr [rsi+0x14]
	mov	dword ptr [rsp+0x48], ecx
	mov	dword ptr [rsp+0x40], 593
	mov	dword ptr [rsp+0x38], 167
	mov	dword ptr [rsp+0x30], ecx
	mov	dword ptr [rsp+0x28], 779
	mov	dword ptr [rsp+0x20], ecx
	mov	r9d, 590
	mov	r8d, ecx
	mov	edx, 774
	lea	rcx, [DS0013+rip]
	call	AddLineQueueX@PLT
$_480:	test	byte ptr [rsi+0x2], 0x20
	jnz	$_481
	mov	rsi, qword ptr [rsi+0x30]
	test	rsi, rsi
	jz	$_481
	mov	dword ptr [rbp-0x2C], 0
	lea	r8, [rbp-0x2C]
	mov	edx, 1
	mov	rcx, rsi
	call	$_460
	mov	dword ptr [rbp-0x24], eax
$_481:	mov	rsi, qword ptr [rbp-0x8]
	mov	ebx, dword ptr [rsi+0x4]
	add	ebx, dword ptr [rbp-0x30]
	test	ebx, ebx
	je	$_489
	test	byte ptr [Options+0x7+rip], 0x01
	jz	$_482
	cmp	ebx, dword ptr [rbp-0x40]
	jbe	$_482
	mov	dword ptr [rsp+0x48], 163
	mov	dword ptr [rsp+0x40], 167
	mov	dword ptr [rsp+0x38], 683
	mov	dword ptr [rsp+0x30], 628
	mov	dword ptr [rsp+0x28], 605
	mov	dword ptr [rsp+0x20], 602
	mov	r9d, ebx
	mov	r8d, 163
	mov	edx, 779
	lea	rcx, [DS0014+rip]
	call	AddLineQueueX@PLT
	jmp	$_483

$_482:	mov	r9d, ebx
	mov	r8d, 167
	mov	edx, 683
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_483:	mov	r8d, ebx
	mov	edx, 587
	lea	rcx, [DS0016+rip]
	call	AddLineQueueX@PLT
	cmp	dword ptr [rbp-0x24], 0
	je	$_489
	imul	ecx, dword ptr [rbp-0x24], 16
	mov	eax, dword ptr [rsi+0x4]
	sub	eax, ecx
	and	eax, 0xFFFFFFF0
	mov	dword ptr [rbp-0x44], eax
	mov	rsi, qword ptr [rsi+0x30]
	lodsw
	movzx	ebx, ax
$_484:	test	ebx, ebx
	je	$_489
	movzx	edi, word ptr [rsi]
	mov	eax, edi
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	je	$_488
	cmp	dword ptr [rbp-0x30], 0
	jz	$_486
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	dword ptr [rsp+0x28], edi
	mov	rax, qword ptr [rcx+0x8]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, 167
	mov	edx, 1133
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	mov	eax, edi
	add	eax, eax
	mov	cl, byte ptr [r12+rax*8+0xC]
	mov	eax, 1
	shl	eax, cl
	test	ax, 0xFFC0
	jz	$_485
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	rax, qword ptr [rcx+0x8]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, edi
	mov	edx, 592
	lea	rcx, [DS0018+rip]
	call	AddLineQueueX@PLT
$_485:	jmp	$_487

$_486:	mov	dword ptr [rsp+0x20], edi
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, 167
	mov	edx, 1133
	lea	rcx, [DS0019+rip]
	call	AddLineQueueX@PLT
	mov	eax, edi
	add	eax, eax
	mov	cl, byte ptr [r12+rax*8+0xC]
	mov	eax, 1
	shl	eax, cl
	test	ax, 0xFFC0
	jz	$_487
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, edi
	mov	edx, 592
	lea	rcx, [DS001A+rip]
	call	AddLineQueueX@PLT
$_487:	add	dword ptr [rbp-0x44], 16
$_488:	dec	ebx
	add	rsi, 2
	jmp	$_484

$_489:	mov	edx, 588
	lea	rcx, [DS0019+0xC+rip]
	call	AddLineQueueX@PLT
	jmp	$_539

$_490:	xor	eax, eax
	jmp	$_581

$_491:	mov	rsi, qword ptr [rbp-0x8]
	test	byte ptr [rsi+0x1], 0x10
	je	$_497
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	eax, dword ptr [rcx+0x30]
	mov	dword ptr [rbp-0x30], eax
	cmp	byte ptr [rdi+0x1F], 2
	jne	$_497
	test	byte ptr [rsi], 0x01
	jz	$_492
	add	eax, 208
	mov	dword ptr [rbp-0x30], eax
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_492
	mov	dword ptr [rcx+0x30], eax
$_492:	movzx	eax, byte ptr [rdi+0x58]
	add	al, byte ptr [rdi+0x59]
	test	eax, eax
	jz	$_497
	mov	ebx, 8
	xor	eax, eax
	mov	rdx, qword ptr [rsi+0x18]
$_493:	test	rdx, rdx
	jz	$_496
	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_494
	test	byte ptr [rdx+0x10], 0x10
	jz	$_495
$_494:	test	byte ptr [rdx+0x11], 0x10
	jz	$_495
	inc	eax
	cmp	ebx, dword ptr [rdx+0x60]
	jnc	$_495
	mov	ebx, dword ptr [rdx+0x60]
$_495:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_493

$_496:	test	eax, eax
	jz	$_497
	add	ebx, 7
	and	ebx, 0xFFFFFFF8
	mov	byte ptr [rdi+0x5A], bl
	mul	bl
	mov	edx, 16
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rbp-0x34], eax
	add	dword ptr [rbp-0x30], eax
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_497
	add	dword ptr [rcx+0x30], eax
$_497:	test	byte ptr [rsi], 0x01
	jnz	$_498
	test	byte ptr [rsi], 0x08
	jnz	$_498
	test	byte ptr [rsi], 0x04
	jnz	$_498
	test	byte ptr [rsi], 0x10
	jnz	$_498
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_498
	cmp	dword ptr [rsi+0x4], 0
	jnz	$_498
	cmp	qword ptr [rsi+0x30], 0
	jnz	$_498
	test	byte ptr [rsi+0x2], 0x02
	jnz	$_498
	cmp	dword ptr [rbp-0x30], 0
	jnz	$_498
	xor	eax, eax
	jmp	$_581

$_498:	mov	rax, qword ptr [rsi+0x30]
	mov	qword ptr [rbp-0x10], rax
	test	byte ptr [rsi+0x2], 0x08
	jz	$_503
	test	byte ptr [rsi+0x1], 0x40
	jz	$_499
	mov	rcx, rsi
	call	$_440
	jmp	$_503

$_499:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_503
	cmp	byte ptr [r14+0x7], 5
	jnz	$_503
	xor	eax, eax
	mov	ecx, 16
	mov	rdx, qword ptr [rsi+0x18]
$_500:	test	rdx, rdx
	jz	$_501
	cmp	qword ptr [rdx+0x88], 0
	jz	$_501
	mov	rdx, qword ptr [rdx+0x88]
	inc	eax
	add	ecx, 16
	jmp	$_500

$_501:	mov	rdx, qword ptr [rsi+0x18]
$_502:	test	rdx, rdx
	jz	$_503
	test	eax, eax
	jz	$_503
	mov	dword ptr [rdx+0x30], ecx
	mov	rdx, qword ptr [rdx+0x88]
	dec	eax
	sub	ecx, 16
	jmp	$_502

$_503:	cmp	qword ptr [rbp-0x10], 0
	je	$_510
	test	byte ptr [rsi+0x2], 0x20
	je	$_510
	mov	dword ptr [rbp-0x2C], 0
	lea	r8, [rbp-0x2C]
	xor	edx, edx
	mov	rcx, qword ptr [rbp-0x10]
	call	$_460
	mov	dword ptr [rbp-0x24], eax
	mov	qword ptr [rbp-0x10], 0
	mov	eax, dword ptr [rbp-0x2C]
	add	dword ptr [rbp-0x3C], eax
	mov	rdi, qword ptr [rsi+0x18]
$_504:	test	rdi, rdi
	jz	$_505
	cmp	qword ptr [rdi+0x88], 0
	jz	$_505
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_504

$_505:	test	rdi, rdi
	jz	$_510
	movzx	ecx, byte ptr [r14+0x4]
	mov	ecx, dword ptr [r14+rcx*4+0x68]
	cmp	dword ptr [rdi+0x30], 8
	jnz	$_506
	cmp	ecx, 22
	jz	$_507
$_506:	cmp	dword ptr [rdi+0x30], 16
	jnz	$_510
	cmp	ecx, 168
	jnz	$_510
$_507:	mov	rdi, qword ptr [rsi+0x18]
$_508:	test	rdi, rdi
	jz	$_510
	cmp	byte ptr [rdi+0x1D], 10
	jz	$_509
	mov	eax, dword ptr [rbp-0x2C]
	add	dword ptr [rdi+0x30], eax
$_509:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_508

$_510:	movzx	eax, byte ptr [r14+0x4]
	lea	rdx, [stackreg+rip]
	mov	eax, dword ptr [rdx+rax*4]
	mov	dword ptr [rbp-0x38], eax
	test	byte ptr [rsi+0x2], 0x02
	jnz	$_511
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_511
	test	byte ptr [rsi], 0x01
	jnz	$_511
	test	byte ptr [rsi], 0x10
	jnz	$_511
	test	byte ptr [rsi], 0x04
	jz	$_513
$_511:	cmp	qword ptr [r14+0x330], 0
	jz	$_512
	mov	ecx, 2
	call	GetOfssizeAssume@PLT
	lea	rdx, [stackreg+rip]
	mov	eax, dword ptr [rdx+rax*4]
	mov	dword ptr [rbp-0x38], eax
$_512:	test	byte ptr [rsi], 0x40
	jnz	$_513
	test	byte ptr [rsi+0x2], 0x04
	jz	$_513
	mov	edx, dword ptr [rsi+0x14]
	mov	eax, dword ptr [rbp-0x38]
	mov	dword ptr [rsp+0x28], eax
	mov	dword ptr [rsp+0x20], edx
	mov	r9d, 779
	mov	r8d, edx
	mov	edx, 774
	lea	rcx, [DS001B+rip]
	call	AddLineQueueX@PLT
$_513:	cmp	dword ptr [rbp-0x30], 0
	jnz	$_514
	test	byte ptr [rsi+0x2], 0x01
	je	$_518
$_514:	cmp	qword ptr [rbp-0x10], 0
	jz	$_515
	lea	r8, [rbp-0x2C]
	xor	edx, edx
	mov	rcx, qword ptr [rbp-0x10]
	call	$_460
	mov	dword ptr [rbp-0x24], eax
	mov	qword ptr [rbp-0x10], 0
$_515:	mov	ecx, dword ptr [rsi+0x4]
	add	ecx, dword ptr [rbp-0x30]
	test	byte ptr [Options+0x7+rip], 0x01
	jz	$_516
	cmp	ecx, dword ptr [rbp-0x40]
	jbe	$_516
	mov	dword ptr [rsp+0x48], 163
	mov	dword ptr [rsp+0x40], 167
	mov	dword ptr [rsp+0x38], 683
	mov	dword ptr [rsp+0x30], 628
	mov	dword ptr [rsp+0x28], 605
	mov	dword ptr [rsp+0x20], 602
	mov	r9d, ecx
	mov	r8d, 163
	mov	edx, 779
	lea	rcx, [DS0014+rip]
	call	AddLineQueueX@PLT
	jmp	$_517

$_516:	test	ecx, ecx
	jz	$_517
	mov	r9d, ecx
	mov	r8d, dword ptr [rbp-0x38]
	mov	edx, 683
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_517:	jmp	$_523

$_518:	cmp	dword ptr [rsi+0x4], 0
	je	$_523
	test	byte ptr [Options+0x7+rip], 0x01
	jz	$_520
	mov	eax, dword ptr [rbp-0x40]
	cmp	dword ptr [rsi+0x4], eax
	jbe	$_520
	mov	dword ptr [rsp+0x30], 628
	mov	eax, dword ptr [rsi+0x4]
	mov	dword ptr [rsp+0x28], eax
	mov	dword ptr [rsp+0x20], 17
	mov	r9d, 779
	mov	r8d, 605
	mov	edx, 602
	lea	rcx, [DS001C+rip]
	call	AddLineQueueX@PLT
	cmp	byte ptr [r14+0x4], 2
	jnz	$_519
	mov	r9d, 163
	mov	r8d, dword ptr [rbp-0x38]
	mov	edx, 683
	lea	rcx, [DS001B+0x6+rip]
	call	AddLineQueueX@PLT
$_519:	jmp	$_523

$_520:	xor	ecx, ecx
	sub	ecx, dword ptr [rsi+0x4]
	test	byte ptr [r14+0x1], 0x08
	jnz	$_521
	cmp	dword ptr [rsi+0x4], 128
	jnz	$_522
$_521:	mov	r9d, ecx
	mov	r8d, dword ptr [rbp-0x38]
	mov	edx, 678
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
	jmp	$_523

$_522:	mov	r9d, dword ptr [rsi+0x4]
	mov	r8d, dword ptr [rbp-0x38]
	mov	edx, 683
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_523:	test	byte ptr [rsi], 0x08
	je	$_533
	xor	ebx, ebx
	test	byte ptr [rsi], 0x80
	jz	$_530
	mov	al, byte ptr [r14+0x15]
	cmp	al, 1
	jz	$_524
	cmp	al, 2
	jz	$_524
	cmp	al, 4
	jnz	$_525
$_524:	mov	ebx, 2
	jmp	$_529

$_525:	mov	rdx, qword ptr [rsi+0x30]
	test	rdx, rdx
	jz	$_528
	movzx	ecx, word ptr [rdx]
	add	rdx, 2
$_526:	test	ecx, ecx
	jz	$_528
	movzx	eax, word ptr [rdx]
	cmp	eax, 15
	jnz	$_527
	inc	ebx
	jmp	$_528

$_527:	dec	ecx
	add	rdx, 2
	jmp	$_526

$_528:	test	ebx, ebx
	jnz	$_529
	and	byte ptr [rsi], 0xF7
$_529:	jmp	$_531

$_530:	mov	ebx, 3
$_531:	test	ebx, ebx
	jz	$_533
	mov	r8d, 28
	mov	edx, 774
	lea	rcx, [DS0005+0x24+rip]
	call	AddLineQueueX@PLT
	cmp	ebx, 2
	jnz	$_532
	mov	r8d, 25
	mov	edx, 775
	lea	rcx, [DS0005+0x24+rip]
	call	AddLineQueueX@PLT
	jmp	$_533

$_532:	cmp	ebx, 3
	jnz	$_533
	lea	r9, [szDgroup+rip]
	mov	r8d, 9
	mov	edx, 779
	lea	rcx, [DS001D+rip]
	call	AddLineQueueX@PLT
	mov	r9d, dword ptr [r14+0x5C]
	mov	r8d, 28
	mov	edx, 779
	lea	rcx, [DS001E+rip]
	call	AddLineQueueX@PLT
$_533:	cmp	qword ptr [rbp-0x10], 0
	jz	$_534
	test	byte ptr [rsi+0x2], 0x20
	jnz	$_534
	lea	r8, [rbp-0x2C]
	xor	edx, edx
	mov	rcx, qword ptr [rbp-0x10]
	call	$_460
	mov	dword ptr [rbp-0x24], eax
$_534:	cmp	dword ptr [rbp-0x24], 0
	je	$_539
	test	byte ptr [rsi+0x1], 0x10
	je	$_539
	imul	ecx, dword ptr [rbp-0x24], 16
	mov	eax, dword ptr [rsi+0x4]
	sub	eax, ecx
	and	eax, 0xFFFFFFF0
	mov	dword ptr [rbp-0x44], eax
	mov	rsi, qword ptr [rsi+0x30]
	lodsw
	movzx	ebx, ax
$_535:	test	ebx, ebx
	jz	$_539
	movzx	edi, word ptr [rsi]
	mov	eax, edi
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_538
	movzx	ecx, byte ptr [r14+0x4]
	lea	rax, [stackreg+rip]
	mov	ecx, dword ptr [rax+rcx*4]
	cmp	dword ptr [rbp-0x30], 0
	jz	$_536
	mov	rdx, qword ptr [sym_ReservedStack+rip]
	mov	dword ptr [rsp+0x28], edi
	mov	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, ecx
	mov	edx, 1133
	lea	rcx, [DS0017+rip]
	call	AddLineQueueX@PLT
	jmp	$_537

$_536:	mov	dword ptr [rsp+0x20], edi
	mov	r9d, dword ptr [rbp-0x44]
	mov	r8d, ecx
	mov	edx, 1133
	lea	rcx, [DS0019+rip]
	call	AddLineQueueX@PLT
$_537:	add	dword ptr [rbp-0x44], 16
$_538:	dec	ebx
	add	rsi, 2
	jmp	$_535

$_539:	mov	rdi, qword ptr [CurrProc+rip]
	test	byte ptr [rsi+0x2], 0x10
	je	$_567
	test	byte ptr [rsi+0x1], 0x10
	je	$_567
	cmp	dword ptr [rbp-0x30], 0
	je	$_552
	cmp	dword ptr [rbp-0x34], 0
	je	$_552
	cmp	qword ptr [rsi+0x30], 0
	jz	$_540
	test	byte ptr [rsi+0x2], 0x20
	jnz	$_540
	lea	rdx, [DS001F+rip]
	mov	ecx, 2008
	call	asmerr@PLT
$_540:	mov	eax, dword ptr [rbp-0x34]
	mov	ecx, dword ptr [rbp-0x30]
	mov	ebx, ecx
	sub	ecx, eax
	sub	ebx, ecx
	add	ebx, dword ptr [rsi+0x4]
	movzx	eax, byte ptr [rdi+0x5A]
	mov	dword ptr [rbp-0x28], eax
	cmp	dword ptr [rsi+0x14], 167
	jnz	$_541
	mov	ebx, ecx
	add	ebx, dword ptr [rsi+0x4]
	jmp	$_542

$_541:	neg	ebx
$_542:	mov	rdi, qword ptr [rsi+0x18]
	test	rdi, rdi
	jz	$_543
	test	byte ptr [rsi], 0x01
	jz	$_543
	mov	rdi, qword ptr [rdi+0x88]
$_543:	test	rdi, rdi
	je	$_552
	test	byte ptr [rdi+0x11], 0x10
	jz	$_551
	cmp	dword ptr [Parse_Pass+rip], 0
	jz	$_544
	test	byte ptr [rdi+0x10], 0x10
	jz	$_551
$_544:	mov	edx, 779
	mov	al, byte ptr [rdi+0x1E]
	cmp	al, 196
	jnz	$_545
	mov	rcx, qword ptr [rdi+0x28]
	mov	al, byte ptr [rcx+0x1E]
$_545:	test	al, 0x20
	jz	$_549
	mov	edx, 1132
	cmp	al, 35
	jz	$_546
	cmp	dword ptr [rdi+0x60], 4
	jnz	$_547
$_546:	mov	edx, 1143
	jmp	$_549

$_547:	cmp	al, 39
	jz	$_548
	cmp	dword ptr [rdi+0x60], 8
	jnz	$_549
$_548:	mov	edx, 709
$_549:	test	byte ptr [rdi+0x10], 0x10
	jz	$_550
	mov	byte ptr [rdi+0x1D], 5
	mov	dword ptr [rdi+0x30], ebx
$_550:	movzx	ecx, byte ptr [rdi+0x58]
	mov	dword ptr [rsp+0x20], ecx
	mov	r9d, ebx
	mov	r8d, dword ptr [rsi+0x14]
	lea	rcx, [DS0020+rip]
	call	AddLineQueueX@PLT
	add	ebx, dword ptr [rbp-0x28]
$_551:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_543

$_552:	test	byte ptr [rsi], 0x01
	je	$_567
	cmp	qword ptr [rsi+0x30], 0
	jz	$_553
	test	byte ptr [rsi+0x2], 0x20
	jnz	$_553
	lea	rdx, [DS001F+rip]
	mov	ecx, 2008
	call	asmerr@PLT
$_553:	mov	eax, dword ptr [rbp-0x34]
	add	eax, 208
	mov	ecx, dword ptr [rbp-0x30]
	mov	ebx, ecx
	sub	ecx, eax
	sub	ebx, ecx
	add	ebx, dword ptr [rsi+0x4]
	cmp	dword ptr [rsi+0x14], 167
	jnz	$_554
	mov	ebx, ecx
	add	ebx, dword ptr [rsi+0x4]
	jmp	$_555

$_554:	neg	ebx
$_555:	mov	dword ptr [rbp-0x2C], ebx
	mov	rdi, qword ptr [rsi+0x18]
	test	rdi, rdi
	jz	$_556
	mov	dword ptr [rdi+0x30], ebx
	mov	rdi, qword ptr [rdi+0x88]
$_556:	xor	ebx, ebx
	mov	dword ptr [rbp-0x28], 0
$_557:	test	rdi, rdi
	jz	$_560
	test	byte ptr [rdi+0x1E], 0x20
	jz	$_558
	inc	dword ptr [rbp-0x28]
	jmp	$_559

$_558:	inc	ebx
$_559:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_557

$_560:	mov	edi, dword ptr [rsi+0x14]
	imul	ecx, dword ptr [rbp-0x28], 16
	mov	dword ptr [rsp+0x60], ecx
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x58], eax
	mov	dword ptr [rsp+0x50], edi
	mov	dword ptr [rsp+0x48], 335
	mov	dword ptr [rsp+0x40], 274
	mov	dword ptr [rsp+0x38], 779
	lea	rax, [rbx*8]
	mov	qword ptr [rsp+0x30], rax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x28], eax
	mov	dword ptr [rsp+0x20], edi
	mov	r9d, 335
	mov	r8d, 274
	mov	edx, 779
	lea	rcx, [DS0021+rip]
	call	AddLineQueueX@PLT
$_561:	cmp	ebx, 6
	jnc	$_562
	lea	rcx, [sysv_regs+0x18+rip]
	movzx	ecx, byte ptr [rcx+rbx]
	lea	edx, [rbx*8+0x20]
	mov	dword ptr [rsp+0x28], ecx
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, edx
	mov	r8d, edi
	mov	edx, 779
	lea	rcx, [DS0022+rip]
	call	AddLineQueueX@PLT
	inc	ebx
	jmp	$_561

$_562:	mov	r8d, 1
	mov	edx, 409
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
	mov	ebx, dword ptr [rbp-0x28]
	imul	edi, ebx, 16
	add	edi, 80
$_563:	cmp	ebx, 8
	jnc	$_564
	lea	rax, [rbx+0x28]
	mov	qword ptr [rsp+0x28], rax
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, edi
	mov	r8d, dword ptr [rsi+0x14]
	mov	edx, 1132
	lea	rcx, [DS0022+rip]
	call	AddLineQueueX@PLT
	inc	ebx
	add	edi, 16
	jmp	$_563

$_564:	mov	edx, 416
	lea	rcx, [DS0022+0x11+rip]
	call	AddLineQueueX@PLT
	mov	edi, dword ptr [rsi+0x14]
	test	byte ptr [Options+0x7+rip], 0x01
	jz	$_565
	mov	dword ptr [rsp+0x58], 163
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x50], eax
	mov	dword ptr [rsp+0x48], edi
	mov	dword ptr [rsp+0x40], 779
	mov	dword ptr [rsp+0x38], 29
	mov	dword ptr [rsp+0x30], 616
	mov	dword ptr [rsp+0x28], 29
	mov	dword ptr [rsp+0x20], 163
	mov	r9d, 779
	mov	r8d, 29
	mov	edx, 616
	lea	rcx, [DS0023+rip]
	call	AddLineQueueX@PLT
$_565:	mov	ecx, dword ptr [rbp-0x3C]
	cmp	edi, 167
	jnz	$_566
	add	ecx, dword ptr [rbp-0x2C]
$_566:	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0xA0], eax
	mov	dword ptr [rsp+0x98], edi
	mov	dword ptr [rsp+0x90], 163
	mov	dword ptr [rsp+0x88], 808
	mov	dword ptr [rsp+0x80], 163
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x78], eax
	mov	dword ptr [rsp+0x70], edi
	mov	dword ptr [rsp+0x68], 779
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x60], eax
	mov	dword ptr [rsp+0x58], edi
	mov	dword ptr [rsp+0x50], 163
	mov	dword ptr [rsp+0x48], 808
	mov	dword ptr [rsp+0x40], 163
	mov	eax, dword ptr [rbp-0x2C]
	mov	dword ptr [rsp+0x38], eax
	mov	dword ptr [rsp+0x30], edi
	mov	dword ptr [rsp+0x28], 779
	mov	dword ptr [rsp+0x20], ecx
	mov	r9d, edi
	mov	r8d, 163
	mov	edx, 808
	lea	rcx, [DS0024+rip]
	call	AddLineQueueX@PLT
$_567:	test	byte ptr [r14], 0x08
	jz	$_571
	cmp	dword ptr [UseSavedState+rip], 0
	jz	$_571
	cmp	dword ptr [Parse_Pass+rip], 1
	jnz	$_568
	test	byte ptr [Options+0x6+rip], 0x02
	jnz	$_569
$_568:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_570
$_569:	mov	eax, dword ptr [list_pos+rip]
	mov	dword ptr [rsi+0x48], eax
	jmp	$_571

$_570:	mov	eax, dword ptr [rsi+0x48]
	mov	dword ptr [list_pos+rip], eax
$_571:	test	byte ptr [Options+0x2+rip], 0x20
	jz	$_573
	test	byte ptr [rsi], 0x20
	jz	$_573
	test	byte ptr [rsi+0x1], 0x10
	jz	$_573
	test	byte ptr [rsi+0x1], 0x40
	jz	$_573
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_573
	mov	rdi, qword ptr [rsi+0x18]
$_572:	test	rdi, rdi
	jz	$_573
	or	byte ptr [rdi+0x10], 0x10
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_572

$_573:	mov	rdi, qword ptr [CurrProc+rip]
	test	byte ptr [rdi+0x4B], 0x10
	jz	$_574
	mov	r8d, dword ptr [r14+0x58]
	mov	edx, 517
	lea	rcx, [DS0025+rip]
	call	AddLineQueueX@PLT
$_574:	movzx	ebx, byte ptr [Options+0x4+rip]
	and	ebx, 0x02
	shr	ebx, 1
	and	byte ptr [Options+0x4+rip], 0xFD
	call	RunLineQueue@PLT
	test	ebx, ebx
	jz	$_575
	or	byte ptr [Options+0x4+rip], 0x02
$_575:	test	byte ptr [r14], 0x08
	je	$_580
	cmp	dword ptr [UseSavedState+rip], 0
	je	$_580
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_580
	mov	rcx, qword ptr [LineStoreCurr+rip]
	mov	ebx, dword ptr [rcx+0x1C]
	mov	eax, dword ptr [list_pos+rip]
	mov	dword ptr [rcx+0x1C], eax
	cmp	ebx, dword ptr [list_pos+rip]
	jbe	$_580
	test	byte ptr [Options+0x6+rip], 0x02
	jnz	$_580
	mov	rcx, qword ptr [rcx]
	test	rcx, rcx
	jz	$_576
	cmp	dword ptr [rcx+0x1C], ebx
	jbe	$_576
	mov	ebx, dword ptr [rcx+0x1C]
$_576:	sub	ebx, dword ptr [list_pos+rip]
	test	ebx, ebx
	jz	$_577
	dec	ebx
$_577:	jmp	$_579

$_578:	mov	rcx, qword ptr [r14+0x1F8]
	mov	edx, 8
	mov	esi, 1
	lea	rdi, [DS0026+rip]
	call	fwrite@PLT
	sub	ebx, 8
$_579:	cmp	ebx, 8
	jnc	$_578
	test	ebx, ebx
	jz	$_580
	mov	rcx, qword ptr [r14+0x1F8]
	mov	edx, ebx
	mov	esi, 1
	lea	rdi, [DS0026+rip]
	call	fwrite@PLT
$_580:	xor	eax, eax
$_581:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

SetLocalOffsets:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 56
	mov	dword ptr [rbp-0x4], 0
	mov	dword ptr [rbp-0x8], 0
	mov	dword ptr [rbp-0xC], 0
	mov	dword ptr [rbp-0x10], 0
	movzx	eax, byte ptr [r14+0x6]
	mov	dword ptr [rbp-0x14], eax
	movzx	eax, byte ptr [r14+0x6]
	mov	dword ptr [rbp-0x18], eax
	mov	rsi, rcx
	mov	rdi, qword ptr [CurrProc+rip]
	cmp	byte ptr [r14+0x7], 5
	jnz	$_582
	mov	dword ptr [rbp-0x18], 16
$_582:	test	byte ptr [rsi+0x1], 0x80
	jz	$_583
	test	byte ptr [rsi+0x1], 0x20
	jz	$_583
	mov	dword ptr [rbp-0x14], 16
$_583:	test	byte ptr [rsi], 0x40
	jnz	$_584
	test	byte ptr [rsi+0x1], 0x80
	je	$_592
$_584:	cmp	qword ptr [rsi+0x30], 0
	jz	$_588
	mov	rdi, qword ptr [rsi+0x30]
	movzx	ebx, word ptr [rdi]
	add	rdi, 2
$_585:	test	ebx, ebx
	jz	$_588
	movzx	edx, word ptr [rdi]
	mov	eax, edx
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_586
	inc	dword ptr [rbp-0x4]
	jmp	$_587

$_586:	inc	dword ptr [rbp-0x8]
$_587:	dec	ebx
	add	rdi, 2
	jmp	$_585

$_588:	test	byte ptr [rsi], 0x40
	jnz	$_590
	cmp	byte ptr [rdi+0x1F], 9
	jnz	$_589
	cmp	dword ptr [rsi+0xC], 32
	ja	$_589
	cmp	qword ptr [rsi+0x20], 0
	jz	$_590
$_589:	cmp	dword ptr [rsi+0xC], 0
	jnz	$_591
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_591
$_590:	movzx	eax, byte ptr [r14+0x6]
	mov	dword ptr [rbp-0xC], eax
$_591:	test	byte ptr [rsi+0x1], 0x80
	jz	$_592
	mov	eax, dword ptr [rbp-0x8]
	mul	dword ptr [rbp-0x18]
	add	eax, dword ptr [rbp-0xC]
	mov	dword ptr [rsi+0x4], eax
	cmp	dword ptr [rbp-0x4], 0
	jz	$_592
	imul	eax, dword ptr [rbp-0x4], 16
	add	eax, dword ptr [rsi+0x4]
	mov	edx, 16
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rsi+0x4], eax
$_592:	cmp	dword ptr [rbp-0x4], 0
	jz	$_593
	or	byte ptr [rsi+0x1], 0x08
$_593:	movzx	ecx, byte ptr [r14+0x4]
	mov	ebx, dword ptr [r14+rcx*4+0x68]
	imul	ecx, dword ptr [rbp-0x4], 16
	mov	eax, dword ptr [rbp-0x18]
	mul	dword ptr [rbp-0x8]
	add	eax, ecx
	test	eax, eax
	jz	$_597
	test	byte ptr [rsi+0x2], 0x20
	jz	$_597
	cmp	dword ptr [rbp-0x14], 16
	jnz	$_594
	cmp	ebx, 167
	jnz	$_594
	mov	edx, 16
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
$_594:	cmp	ebx, 22
	jz	$_595
	cmp	ebx, 168
	jnz	$_596
$_595:	mov	dword ptr [rbp-0x10], eax
	jmp	$_597

$_596:	cmp	ebx, 21
	jnz	$_597
	neg	eax
	mov	dword ptr [rbp-0x10], eax
$_597:	mov	rdi, qword ptr [rsi+0x20]
$_598:	test	rdi, rdi
	jz	$_602
	xor	eax, eax
	cmp	dword ptr [rdi+0x60], 0
	jz	$_599
	mov	eax, dword ptr [rdi+0x60]
	cdq
	div	dword ptr [rdi+0x68]
$_599:	mov	ecx, eax
	mov	eax, dword ptr [rdi+0x60]
	add	dword ptr [rsi+0x4], eax
	cmp	ecx, dword ptr [rbp-0x14]
	jle	$_600
	mov	edx, dword ptr [rbp-0x14]
	mov	eax, dword ptr [rsi+0x4]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rsi+0x4], eax
	jmp	$_601

$_600:	test	ecx, ecx
	jz	$_601
	mov	edx, ecx
	mov	eax, dword ptr [rsi+0x4]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rsi+0x4], eax
$_601:	mov	eax, dword ptr [rsi+0x4]
	neg	eax
	add	eax, dword ptr [rbp-0x10]
	mov	dword ptr [rdi+0x30], eax
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_598

$_602:
	mov	edx, dword ptr [rbp-0x18]
	mov	eax, dword ptr [rsi+0x4]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rsi+0x4], eax
	test	byte ptr [rsi+0x1], 0x80
	jz	$_603
	mov	edx, 16
	mov	eax, dword ptr [rsi+0x4]
	dec	edx
	add	eax, edx
	not	edx
	and	eax, edx
	mov	dword ptr [rsi+0x4], eax
$_603:	test	byte ptr [rsi], 0x40
	jz	$_610
	movzx	edi, byte ptr [r14+0x6]
	test	byte ptr [rsi+0x1], 0x80
	jz	$_604
	mov	ecx, dword ptr [rsi+0x4]
	mov	ebx, ecx
	sub	ebx, edi
	sub	ebx, dword ptr [rbp-0xC]
	jmp	$_605

$_604:	mov	eax, dword ptr [rbp-0x8]
	mul	edi
	mov	ecx, dword ptr [rsi+0x4]
	add	ecx, eax
	mov	ebx, ecx
	sub	ebx, edi
$_605:	mov	rdi, qword ptr [rsi+0x20]
$_606:	test	rdi, rdi
	jz	$_607
	add	dword ptr [rdi+0x30], ecx
	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_606

$_607:	mov	rdi, qword ptr [rsi+0x18]
$_608:	test	rdi, rdi
	jz	$_610
	cmp	byte ptr [rdi+0x1D], 10
	jz	$_609
	add	dword ptr [rdi+0x30], ebx
$_609:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_608

$_610:
	test	byte ptr [rsi+0x1], 0x80
	jz	$_611
	mov	eax, dword ptr [rbp-0x8]
	mul	dword ptr [rbp-0x18]
	add	eax, dword ptr [rbp-0xC]
	sub	dword ptr [rsi+0x4], eax
$_611:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

write_prologue:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rdi+0x78]
	cmp	dword ptr [Parse_Pass+rip], 0
	jne	$_620
	and	dword ptr [rsi], 0xFF
	or	byte ptr [rsi+0x2], 0x04
	cmp	byte ptr [r14+0x7], 2
	jz	$_612
	cmp	byte ptr [r14+0x7], 5
	jz	$_612
	cmp	byte ptr [r14+0x7], 3
	jnz	$_615
$_612:	test	byte ptr [r14+0x2D], 0x01
	jz	$_613
	or	byte ptr [rsi+0x1], 0x40
$_613:	test	byte ptr [r14+0x2D], 0x02
	jz	$_615
	or	byte ptr [rsi+0x1], 0x10
	test	byte ptr [r14+0x2D], 0x04
	jnz	$_614
	cmp	byte ptr [r14+0x7], 5
	jnz	$_615
$_614:	or	byte ptr [rsi+0x1], 0x20
$_615:	movzx	edx, byte ptr [rdi+0x1F]
	movzx	ecx, byte ptr [rdi+0x20]
	call	get_fasttype
	mov	al, byte ptr [rax+0xF]
	test	al, 0x40
	jz	$_616
	test	byte ptr [r14+0x1], 0x10
	jz	$_616
	or	byte ptr [rsi+0x2], 0x20
$_616:	test	al, 0x20
	jz	$_617
	or	byte ptr [rsi+0x2], 0x10
$_617:	test	al, 0x20
	jz	$_618
	cmp	qword ptr [rsi+0x18], 0
	jz	$_618
	test	byte ptr [rsi+0x1], 0x10
	jz	$_618
	or	byte ptr [rsi+0x2], 0x02
$_618:	test	al, 0x10
	jz	$_619
	or	byte ptr [rsi+0x2], 0x08
$_619:	test	al, 0x31
	jz	$_620
	or	byte ptr [rsi+0x2], 0x40
$_620:	and	dword ptr [ProcStatus+rip], 0xFFFFFF7F
	test	byte ptr [r14+0x1], 0x04
	jz	$_622
	cmp	byte ptr [r14+0x20], 2
	jz	$_622
	cmp	byte ptr [r14+0x9], 2
	jnz	$_622
	cmp	byte ptr [r14+0x4], 2
	jnz	$_621
	lea	rcx, [DS0027+rip]
	call	AddLineQueue@PLT
	jmp	$_622

$_621:	cmp	byte ptr [r14+0x4], 1
	jnz	$_622
	lea	rcx, [DS0028+rip]
	call	AddLineQueue@PLT
$_622:	test	byte ptr [rsi+0x1], 0x10
	jz	$_631
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	movzx	edx, byte ptr [rdi+0x1F]
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_630
	mov	dword ptr [rcx+0x30], 32
	cmp	dl, 8
	jnz	$_623
	mov	dword ptr [rcx+0x30], 96
	jmp	$_629

$_623:	cmp	dl, 2
	jnz	$_629
	mov	dword ptr [rcx+0x30], 0
	xor	ecx, ecx
	mov	rdx, qword ptr [rsi+0x18]
$_624:	test	rdx, rdx
	jz	$_626
	test	byte ptr [rdx+0x11], 0x10
	jz	$_625
	add	ecx, 8
$_625:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_624

$_626:	mov	rdx, qword ptr [rsi+0x18]
$_627:	test	rdx, rdx
	jz	$_629
	test	byte ptr [rdx+0x11], 0x10
	jnz	$_628
	sub	dword ptr [rdx+0x30], ecx
$_628:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_627

$_629:	jmp	$_631

$_630:	mov	eax, dword ptr [rsi+0x8]
	mov	dword ptr [rcx+0x30], eax
$_631:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_634
	test	byte ptr [rsi], 0x20
	jnz	$_632
	test	byte ptr [rsi+0x1], 0x10
	jz	$_633
$_632:	or	byte ptr [rsi+0x1], 0x80
$_633:	mov	rcx, rsi
	call	SetLocalOffsets
$_634:	or	byte ptr [ProcStatus+rip], 0x01
	cmp	byte ptr [r14+0x20], 0
	jnz	$_635
	call	$_465
	jmp	$_637

$_635:	cmp	byte ptr [r14+0x20], 2
	jnz	$_636
	jmp	$_637

$_636:	mov	rcx, qword ptr [rbp+0x28]
	call	$_396
$_637:	and	dword ptr [ProcStatus+rip], 0xFFFFFFFE
	call	GetCurrOffset@PLT
	mov	ecx, eax
	sub	ecx, dword ptr [rdi+0x30]
	mov	dword ptr [rsi+0x10], ecx
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_638:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rsi, rcx
	test	rsi, rsi
	jz	$_641
	movzx	edi, word ptr [rsi]
	lea	rsi, [rsi+rdi*2]
$_639:	test	edi, edi
	jz	$_641
	movzx	ecx, word ptr [rsi]
	mov	eax, ecx
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jnz	$_640
	mov	r8d, ecx
	mov	edx, 775
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_640:	dec	edi
	sub	rsi, 2
	jmp	$_639

$_641:
	leave
	pop	rdi
	pop	rsi
	ret

$_642:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	dword ptr [rbp-0x18], edi
	cmp	qword ptr [rsi+0x30], 0
	je	$_650
	mov	rdi, qword ptr [rsi+0x30]
	movzx	ebx, word ptr [rdi]
	add	rdi, 2
	xor	ecx, ecx
$_643:	test	ebx, ebx
	jz	$_645
	movzx	eax, word ptr [rdi]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_644
	inc	ecx
$_644:	dec	ebx
	add	rdi, 2
	jmp	$_643

$_645:	test	ecx, ecx
	je	$_650
	imul	ecx, ecx, 16
	mov	ebx, dword ptr [rsi+0x4]
	sub	ebx, ecx
	and	ebx, 0xFFFFFFF0
	mov	rdi, qword ptr [rsi+0x30]
	movzx	esi, word ptr [rdi]
	add	rdi, 2
$_646:	test	esi, esi
	jz	$_650
	movzx	ecx, word ptr [rdi]
	mov	eax, ecx
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x10
	jz	$_649
	test	byte ptr [r14+0x2D], 0x02
	jz	$_647
	mov	rdx, qword ptr [sym_ReservedStack+rip]
	mov	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rsp+0x28], rax
	mov	dword ptr [rsp+0x20], ebx
	mov	r9d, dword ptr [rbp-0x18]
	mov	r8d, ecx
	mov	edx, 1133
	lea	rcx, [DS0029+rip]
	call	AddLineQueueX@PLT
	jmp	$_648

$_647:	mov	dword ptr [rsp+0x20], ebx
	mov	r9d, dword ptr [rbp-0x18]
	mov	r8d, ecx
	mov	edx, 1133
	lea	rcx, [DS002A+rip]
	call	AddLineQueueX@PLT
$_648:	add	ebx, 16
$_649:	dec	esi
	add	rdi, 2
	jmp	$_646

$_650:
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_651:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	dword ptr [rbp-0xC], 0
	mov	dword ptr [rbp-0x10], 0
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rdi+0x78]
	mov	qword ptr [rbp-0x8], rsi
	test	byte ptr [rsi+0x2], 0x40
	je	$_660
	test	byte ptr [rsi+0x1], 0x10
	je	$_660
	test	byte ptr [rsi], 0x01
	jz	$_652
	or	byte ptr [rsi+0x1], 0x02
	jmp	$_655

$_652:	mov	rdx, qword ptr [rsi+0x18]
$_653:	test	rdx, rdx
	jz	$_655
	test	byte ptr [rdx+0x10], 0x10
	jz	$_654
	or	byte ptr [rsi+0x1], 0x02
	jmp	$_655

$_654:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_653

$_655:	test	byte ptr [rsi+0x1], 0x01
	jnz	$_660
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_660
	mov	rdx, qword ptr [sym_ReservedStack+rip]
	test	rdx, rdx
	jz	$_656
	mov	dword ptr [rdx+0x30], 0
$_656:	test	byte ptr [rsi+0x1], 0x08
	jnz	$_659
	cmp	dword ptr [rsi+0x4], 8
	jnz	$_659
	test	byte ptr [rsi+0x1], 0x04
	jnz	$_659
	mov	dword ptr [rsi+0x4], 0
	cmp	dword ptr [r14+0x70], 167
	jnz	$_659
	mov	rdx, qword ptr [rsi+0x18]
$_657:	test	rdx, rdx
	jz	$_659
	cmp	byte ptr [rdx+0x1D], 10
	jz	$_658
	sub	dword ptr [rdx+0x30], 8
$_658:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_657

$_659:	test	byte ptr [rsi+0x1], 0x02
	jnz	$_660
	test	byte ptr [rsi+0x1], 0x08
	jnz	$_660
	cmp	dword ptr [rsi+0x4], 0
	jnz	$_660
	cmp	qword ptr [rsi+0x30], 0
	jnz	$_660
	test	byte ptr [rsi+0x1], 0x04
	jnz	$_660
	and	byte ptr [rsi+0x2], 0xFB
$_660:	cmp	qword ptr [rsi+0x20], 0
	jnz	$_661
	test	byte ptr [rsi+0x2], 0x02
	jnz	$_661
	test	byte ptr [rsi], 0x04
	jnz	$_661
	test	byte ptr [rsi], 0x01
	jnz	$_661
	test	byte ptr [rsi], 0x10
	jz	$_662
$_661:	inc	dword ptr [rbp-0xC]
$_662:	movzx	eax, byte ptr [r14+0x4]
	cmp	qword ptr [r14+0x330], 0
	jz	$_663
	mov	ecx, 2
	call	GetOfssizeAssume@PLT
$_663:	lea	rdx, [stackreg+rip]
	mov	eax, dword ptr [rdx+rax*4]
	mov	dword ptr [rbp-0x14], eax
	test	byte ptr [rsi], 0x20
	je	$_680
	test	byte ptr [r14+0x25], 0x01
	je	$_679
	mov	edi, dword ptr [rbp-0x14]
	call	$_642
	cmp	dword ptr [rbp-0xC], 0
	je	$_671
	test	byte ptr [rsi], 0x02
	je	$_671
	test	byte ptr [rsi+0x2], 0x20
	jnz	$_665
	test	byte ptr [rsi+0x2], 0x02
	jnz	$_664
	cmp	qword ptr [rsi+0x30], 0
	jnz	$_671
$_664:	cmp	dword ptr [rsi+0x14], 168
	jnz	$_671
$_665:	test	byte ptr [rsi+0x2], 0x20
	jnz	$_666
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
$_666:	test	byte ptr [rsi+0x2], 0x02
	jnz	$_668
	cmp	dword ptr [rbp-0x10], 0
	jnz	$_668
	test	byte ptr [rsi], 0x10
	jnz	$_668
	test	byte ptr [rsi], 0x01
	jnz	$_668
	test	byte ptr [rsi], 0x04
	jnz	$_668
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_668
	test	byte ptr [rsi+0x2], 0x20
	jz	$_667
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
$_667:	jmp	$_698

$_668:	test	byte ptr [rsi+0x2], 0x04
	jz	$_669
	mov	edx, 809
	lea	rcx, [DS0023+0x3B+rip]
	call	AddLineQueueX@PLT
$_669:	test	byte ptr [rsi+0x2], 0x20
	jz	$_670
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
$_670:	jmp	$_679

$_671:	mov	ebx, dword ptr [rbp-0x14]
	cmp	byte ptr [r14+0x7], 2
	jz	$_672
	cmp	byte ptr [r14+0x7], 5
	jnz	$_674
$_672:	test	byte ptr [r14+0x2D], 0x02
	jz	$_674
	mov	rdx, qword ptr [sym_ReservedStack+rip]
	mov	edx, dword ptr [rdx+0x30]
	add	edx, dword ptr [rsi+0x4]
	jz	$_673
	mov	r9d, edx
	mov	r8d, ebx
	mov	edx, 678
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_673:	jmp	$_675

$_674:	cmp	dword ptr [rsi+0x4], 0
	jz	$_675
	mov	r9d, dword ptr [rsi+0x4]
	mov	r8d, ebx
	mov	edx, 678
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_675:	test	byte ptr [rsi+0x2], 0x20
	jnz	$_676
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
$_676:	mov	ecx, dword ptr [rsi+0x14]
	mov	eax, ecx
	add	eax, eax
	cmp	byte ptr [r12+rax*8+0xC], 4
	jz	$_678
	cmp	dword ptr [rsi+0xC], 0
	jnz	$_677
	cmp	qword ptr [rsi+0x20], 0
	jz	$_678
$_677:	mov	r8d, ecx
	mov	edx, 775
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_678:	test	byte ptr [rsi+0x2], 0x20
	jz	$_679
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
$_679:	jmp	$_698

$_680:	test	byte ptr [rsi+0x1], 0x10
	je	$_685
	mov	edi, dword ptr [rbp-0x14]
	call	$_642
	mov	rcx, qword ptr [sym_ReservedStack+rip]
	mov	eax, dword ptr [rcx+0x30]
	mov	dword ptr [rbp-0x10], eax
	test	byte ptr [rsi+0x2], 0x20
	jz	$_681
	cmp	dword ptr [rbp-0xC], 0
	jz	$_681
	test	byte ptr [rsi], 0x02
	jz	$_681
	jmp	$_685

$_681:	test	byte ptr [rsi+0x2], 0x20
	jnz	$_683
	cmp	dword ptr [rbp-0xC], 0
	jz	$_683
	test	byte ptr [rsi], 0x02
	jz	$_683
	test	byte ptr [rsi+0x2], 0x02
	jnz	$_682
	cmp	qword ptr [rsi+0x30], 0
	jnz	$_683
$_682:	cmp	dword ptr [rsi+0x14], 168
	jnz	$_683
	jmp	$_685

$_683:	cmp	dword ptr [rbp-0x10], 0
	jnz	$_684
	cmp	dword ptr [rsi+0x4], 0
	jz	$_685
$_684:	mov	rdx, qword ptr [sym_ReservedStack+rip]
	mov	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rsp+0x20], rax
	mov	r9d, dword ptr [rsi+0x4]
	mov	r8d, dword ptr [rbp-0x14]
	mov	edx, 678
	lea	rcx, [DS002B+rip]
	call	AddLineQueueX@PLT
$_685:	test	byte ptr [rsi+0x2], 0x20
	jnz	$_688
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
	test	byte ptr [rsi], 0x08
	jz	$_688
	mov	ecx, 1
	test	byte ptr [rsi], 0x80
	jz	$_687
	mov	al, byte ptr [r14+0x15]
	cmp	al, 1
	jz	$_686
	cmp	al, 2
	jz	$_686
	cmp	al, 4
	jnz	$_687
$_686:	xor	ecx, ecx
$_687:	test	ecx, ecx
	jz	$_688
	mov	r8d, 28
	mov	edx, 775
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_688:	test	byte ptr [rsi+0x2], 0x02
	jnz	$_690
	cmp	dword ptr [rbp-0x10], 0
	jnz	$_690
	test	byte ptr [rsi], 0x10
	jnz	$_690
	test	byte ptr [rsi], 0x01
	jnz	$_690
	test	byte ptr [rsi], 0x04
	jnz	$_690
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_690
	test	byte ptr [rsi+0x2], 0x20
	jz	$_689
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
	test	byte ptr [rsi], 0x08
	jz	$_689
	lea	rcx, [DS002C+rip]
	call	AddLineQueue@PLT
$_689:	jmp	$_698

$_690:	cmp	dword ptr [rbp-0xC], 0
	jnz	$_691
	jmp	$_697

$_691:	test	byte ptr [rsi], 0x02
	jz	$_693
	test	byte ptr [rsi+0x2], 0x04
	jz	$_692
	lea	rcx, [DS002D+rip]
	call	AddLineQueue@PLT
$_692:	jmp	$_697

$_693:	test	byte ptr [rsi], 0x40
	jz	$_695
	test	byte ptr [rsi+0x1], 0x10
	jnz	$_694
	cmp	dword ptr [rsi+0x4], 0
	jz	$_694
	mov	r9d, dword ptr [rsi+0x4]
	mov	r8d, dword ptr [rbp-0x14]
	mov	edx, 678
	lea	rcx, [DS0015+rip]
	call	AddLineQueueX@PLT
$_694:	jmp	$_697

$_695:	test	byte ptr [rsi+0x2], 0x04
	jz	$_697
	cmp	dword ptr [rsi+0x4], 0
	jz	$_696
	mov	r9d, dword ptr [rsi+0x14]
	mov	r8d, dword ptr [rbp-0x14]
	mov	edx, 779
	lea	rcx, [DS001E+0x1+rip]
	call	AddLineQueueX@PLT
$_696:	mov	r8d, dword ptr [rsi+0x14]
	mov	edx, 775
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_697:	test	byte ptr [rsi+0x2], 0x20
	jz	$_698
	mov	rcx, qword ptr [rsi+0x30]
	call	$_638
	test	byte ptr [rsi], 0x08
	jz	$_698
	mov	r8d, 28
	mov	edx, 775
	lea	rcx, [DS0005+0x25+rip]
	call	AddLineQueueX@PLT
$_698:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_699:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 2296
	mov	rdi, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rdi+0x78]
	mov	qword ptr [rbp-0x28], rsi
	mov	rcx, qword ptr [r14+0x188]
	call	SymFind@PLT
	mov	qword ptr [rbp-0x38], rax
	test	eax, eax
	jz	$_700
	cmp	byte ptr [rax+0x1D], 9
	jnz	$_700
	test	byte ptr [rax+0x48], 0x02
	jz	$_701
$_700:	mov	rdx, qword ptr [r14+0x188]
	mov	ecx, 2121
	call	asmerr@PLT
	jmp	$_714

$_701:	movzx	ebx, byte ptr [rdi+0x1F]
	mov	edx, ebx
	cmp	ebx, 7
	jnz	$_702
	cmp	byte ptr [r14+0x7], 2
	jnz	$_702
	mov	edx, 0
$_702:	cmp	ebx, 1
	jz	$_703
	cmp	ebx, 2
	jz	$_703
	cmp	ebx, 7
	jnz	$_704
$_703:	or	edx, 0x10
$_704:	cmp	byte ptr [rdi+0x1E], 130
	jnz	$_705
	or	edx, 0x20
$_705:	test	byte ptr [rdi+0x10], 0x04
	jnz	$_706
	or	edx, 0x40
$_706:	test	byte ptr [rdi+0x10], 0x20
	jz	$_707
	or	edx, 0x80
$_707:	cmp	dword ptr [rbp+0x28], 0
	jz	$_708
	or	edx, 0x100
$_708:	mov	dword ptr [rbp-0x2C], edx
	mov	rdi, qword ptr [rsi+0x30]
	lea	rsi, [rbp-0xB8]
	test	rdi, rdi
	jz	$_711
	movzx	ebx, word ptr [rdi]
	lea	rdi, [rdi+rbx*2]
$_709:	test	ebx, ebx
	jz	$_711
	movzx	ecx, word ptr [rdi]
	mov	rdx, rsi
	call	GetResWName@PLT
	mov	rcx, rsi
	call	tstrlen@PLT
	add	rsi, rax
	cmp	ebx, 1
	jz	$_710
	mov	byte ptr [rsi], 44
	inc	rsi
$_710:	sub	rdi, 2
	dec	ebx
	jmp	$_709

$_711:	mov	byte ptr [rsi], 0
	mov	rsi, qword ptr [rbp-0x28]
	mov	rdi, qword ptr [CurrProc+rip]
	lea	rcx, [DS002D+0x5+rip]
	cmp	qword ptr [rsi+0x38], 0
	jz	$_712
	mov	rcx, qword ptr [rsi+0x38]
$_712:	mov	qword ptr [rsp+0x38], rcx
	lea	rax, [rbp-0xB8]
	mov	qword ptr [rsp+0x30], rax
	mov	eax, dword ptr [rsi+0x4]
	mov	dword ptr [rsp+0x28], eax
	mov	eax, dword ptr [rsi+0xC]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, dword ptr [rbp-0x2C]
	mov	r8, qword ptr [rdi+0x8]
	lea	rdx, [DS002E+rip]
	lea	rcx, [rbp-0x8B8]
	call	tsprintf@PLT
	mov	ecx, dword ptr [r14+0x64]
	inc	ecx
	mov	dword ptr [rbp-0xC], ecx
	mov	r9d, 1
	mov	r8, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbp-0xC]
	lea	rcx, [rbp-0x8B8]
	call	Tokenize@PLT
	test	byte ptr [Options+0x5+rip], 0x20
	jz	$_713
	lea	rcx, [DS002F+rip]
	call	tprintf@PLT
$_713:	lea	rax, [rbp-0x1C]
	mov	qword ptr [rsp+0x28], rax
	mov	dword ptr [rsp+0x20], 0
	xor	r9d, r9d
	mov	r8, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbp-0xC]
	mov	rcx, qword ptr [rbp-0x38]
	call	RunMacro@PLT
	mov	eax, dword ptr [rbp-0xC]
	dec	eax
	mov	dword ptr [r14+0x64], eax
	xor	eax, eax
$_714:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

RetInstr:
	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, 2104
	mov	dword ptr [rbp-0x814], 0
	imul	ebx, ecx, 32
	add	rbx, rdx
	mov	eax, dword ptr [rbx+0x4]
	cmp	eax, 801
	jz	$_715
	cmp	eax, 802
	jz	$_715
	cmp	eax, 1329
	jnz	$_716
$_715:	mov	dword ptr [rbp-0x814], 1
	jmp	$_717

$_716:	cmp	eax, 823
	jnz	$_717
	cmp	qword ptr [r14+0x2F8], 0
	jz	$_717
	mov	rcx, qword ptr [r14+0x2F8]
	mov	ecx, dword ptr [rcx+0x14]
	lea	rdx, [rbp-0x810]
	call	GetLabelStr@PLT
	lea	r8, [DS0001+rip]
	mov	rdx, rax
	lea	rcx, [DS0030+rip]
	call	AddLineQueueX@PLT
	mov	qword ptr [r14+0x2F8], 0
$_717:	cmp	byte ptr [r14+0x21], 1
	jnz	$_720
	cmp	dword ptr [UseSavedState+rip], 0
	jz	$_719
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_718
	mov	rcx, qword ptr [rbp+0x30]
	call	ParseLine@PLT
	jmp	$_740

$_718:	mov	rcx, qword ptr [LineStoreCurr+rip]
	mov	byte ptr [rcx+0x20], 59
$_719:	mov	rdx, qword ptr [rbp+0x30]
	mov	ecx, dword ptr [rbp-0x814]
	call	$_699
	jmp	$_740

$_720:	test	byte ptr [r14], 0x08
	jz	$_721
	call	GetCurrOffset@PLT
	xor	r8d, r8d
	mov	edx, eax
	mov	ecx, 4
	call	LstWrite@PLT
$_721:	mov	rdx, qword ptr [rbx+0x10]
	lea	rcx, [rbp-0x810]
	call	tstrcpy@PLT
	mov	rdi, rax
	mov	rcx, rax
	call	tstrlen@PLT
	add	rdi, rax
	call	$_651
	mov	rcx, qword ptr [CurrProc+rip]
	mov	rsi, qword ptr [rcx+0x78]
	cmp	dword ptr [rbp-0x814], 0
	jnz	$_724
	cmp	byte ptr [rcx+0x1E], 130
	jnz	$_722
	mov	al, 102
	jmp	$_723

$_722:	mov	al, 110
$_723:	stosb
$_724:	inc	dword ptr [rbp+0x28]
	add	rbx, 32
	mov	edx, dword ptr [rbp+0x38]
	cmp	dword ptr [rsi+0xC], 0
	jnz	$_725
	cmp	edx, dword ptr [rbp+0x28]
	jz	$_726
$_725:	mov	al, 32
	stosb
$_726:	mov	byte ptr [rdi], 0
	cmp	dword ptr [rbp-0x814], 0
	jne	$_738
	cmp	edx, dword ptr [rbp+0x28]
	jne	$_738
	cmp	byte ptr [r14+0x21], 2
	je	$_737
	movzx	eax, byte ptr [rcx+0x1F]
	jmp	$_736

$_727:	test	byte ptr [rsi], 0x01
	jne	$_737
$_728:	cmp	dword ptr [rsi+0xC], 0
	jz	$_729
	mov	r8d, dword ptr [rsi+0xC]
	lea	rdx, [DS0021+0x2C+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
$_729:	jmp	$_737

$_730:	cmp	byte ptr [r14+0x4], 0
	jne	$_737
	test	byte ptr [rsi], 0x01
	jne	$_737
$_731:	mov	ebx, eax
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
	mov	dword ptr [rbp-0x818], eax
	mov	edx, ebx
	call	get_fasttype
	test	byte ptr [rax+0xF], 0x02
	jz	$_735
	xor	ecx, ecx
	mov	rdx, qword ptr [rsi+0x18]
$_732:	test	rdx, rdx
	jz	$_734
	cmp	byte ptr [rdx+0x1D], 10
	jz	$_733
	add	ecx, dword ptr [rdx+0x60]
	mov	eax, dword ptr [rbp-0x818]
	dec	eax
	add	ecx, eax
	not	eax
	and	ecx, eax
$_733:	mov	rdx, qword ptr [rdx+0x88]
	jmp	$_732

$_734:	test	ecx, ecx
	jz	$_735
	mov	r8d, ecx
	lea	rdx, [DS0021+0x2C+rip]
	mov	rcx, rdi
	call	tsprintf@PLT
$_735:	jmp	$_737

$_736:	cmp	eax, 3
	je	$_727
	cmp	eax, 6
	je	$_728
	cmp	eax, 5
	je	$_728
	cmp	eax, 4
	je	$_728
	cmp	eax, 9
	je	$_730
	cmp	eax, 7
	je	$_731
	cmp	eax, 8
	je	$_731
$_737:	jmp	$_739

$_738:	mov	rdx, qword ptr [rbx+0x18]
	mov	rcx, rdi
	call	tstrcpy@PLT
$_739:	lea	rcx, [rbp-0x810]
	call	AddLineQueue@PLT
	call	RunLineQueue@PLT
	xor	eax, eax
$_740:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

ProcInit:
	xor	eax, eax
	mov	qword ptr [ProcStack+rip], rax
	mov	qword ptr [CurrProc+rip], rax
	mov	byte ptr [strFUNC+rip], al
	mov	dword ptr [procidx+rip], 1
	mov	dword ptr [ProcStatus+rip], eax
	mov	byte ptr [r14+0x20], 0
	mov	byte ptr [r14+0x21], 0
	test	byte ptr [Options+0x6+rip], 0x10
	jz	$_741
	mov	al, 2
$_741:	mov	byte ptr [r14+0x22], al
	mov	dword ptr [r14+0x68], 14
	mov	dword ptr [r14+0x6C], 22
	mov	dword ptr [r14+0x70], 168
	mov	byte ptr [unw_segs_defined+rip], 0
	ret


.SECTION .data
	.ALIGN	16

CurrProc:
	.quad  0x0000000000000000

ProcStack:
	.quad  0x0000000000000000

sym_ReservedStack:
	.quad  0x0000000000000000

procidx: .int	0x00000000

ProcStatus:
	.int   0x00000000

endprolog_found:
	.int   0x00000000

stackreg:
	.byte  0x0D, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00
	.byte  0xA7, 0x00, 0x00, 0x00

StackAdj: .int	 0x00000000

StackAdjHigh:
	.int   0x00000000

fast_regs:
	.byte  0x02, 0x03, 0x5B, 0x5C, 0x00, 0x00, 0x00, 0x00
	.byte  0x0A, 0x0B, 0x73, 0x74, 0x00, 0x00, 0x00, 0x00
	.byte  0x12, 0x13, 0x8B, 0x8C, 0x00, 0x00, 0x00, 0x00
	.byte  0xA4, 0xA5, 0xAB, 0xAC, 0x00, 0x00, 0x00, 0x00

sysv_regs:
	.byte  0x5A, 0x59, 0x03, 0x02, 0x5B, 0x5C, 0x00, 0x00
	.byte  0x10, 0x0F, 0x0B, 0x0A, 0x73, 0x74, 0x00, 0x00
	.byte  0x18, 0x17, 0x13, 0x12, 0x8B, 0x8C, 0x00, 0x00
	.byte  0xAA, 0xA9, 0xA5, 0xA4, 0xAB, 0xAC, 0x00, 0x00

watc_regs:
	.byte  0x01, 0x03, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00
	.byte  0x09, 0x0B, 0x0C, 0x0A, 0x00, 0x00, 0x00, 0x00
	.byte  0x11, 0x13, 0x14, 0x12, 0x00, 0x00, 0x00, 0x00
	.byte  0xA3, 0xA5, 0xA6, 0xA4, 0x00, 0x00, 0x00, 0x00

user_regs:
	.byte  0x01, 0x03, 0x02, 0x5B, 0x5C, 0x5D, 0x5E, 0x00
	.byte  0x09, 0x0B, 0x0A, 0x73, 0x74, 0x75, 0x76, 0x00
	.byte  0x11, 0x13, 0x12, 0x8B, 0x8C, 0x8D, 0x8E, 0x00
	.byte  0xA3, 0xA5, 0xA4, 0xAB, 0xAC, 0xAD, 0xAE, 0x00

lang_table:
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40
	.quad  sysv_regs
	.quad  0x6810080600FF03C6
	.quad  0x0000000000000000
	.quad  0x0202000000000000
	.quad  0x0000000000000000
	.quad  0x4200000000000000
	.quad  0x0000000000000000
	.quad  0x4200000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  0x0000000000000000
	.quad  0x0600000000000000
	.quad  watc_regs
	.quad  0x0F0400030000000D
	.quad  fast_regs
	.quad  0x0B04000200000006
	.quad  fast_regs
	.quad  0x58080404000F0306
	.quad  watc_regs
	.quad  0x0B0400030000000D
	.quad  fast_regs
	.quad  0x0B040802003F0006
	.quad  fast_regs
	.quad  0x58080604003F0306
	.quad  watc_regs
	.quad  0x030800040000000F
	.quad  watc_regs
	.quad  0x091000040000000F
	.quad  watc_regs
	.quad  0x09100404000F000F
	.quad  user_regs
	.quad  0x0904000300000007
	.quad  user_regs
	.quad  0x09081003FFFF0007
	.quad  user_regs
	.quad  0x09101007FFFF0F07

DS0000:
	.byte  0x2C, 0x00

DS0001:
	.byte  0x3A, 0x00

DS0002:
	.byte  0x22, 0x25, 0x73, 0x22, 0x00

DS0003:
	.byte  0x2E, 0x78, 0x64, 0x61, 0x74, 0x61, 0x00

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

DS0005:
	.byte  0x25, 0x73, 0x20, 0x25, 0x72, 0x20, 0x25, 0x72
	.byte  0x28, 0x38, 0x29, 0x20, 0x25, 0x72, 0x20, 0x72
	.byte  0x65, 0x61, 0x64, 0x20, 0x27, 0x44, 0x41, 0x54
	.byte  0x41, 0x27, 0x0A, 0x24, 0x78, 0x64, 0x61, 0x74
	.byte  0x61, 0x73, 0x79, 0x6D, 0x20, 0x25, 0x72, 0x20
	.byte  0x25, 0x72, 0x00

DS0006:
	.byte  0x64, 0x62, 0x20, 0x25, 0x75, 0x74, 0x20, 0x2B
	.byte  0x20, 0x28, 0x30, 0x25, 0x78, 0x68, 0x20, 0x73
	.byte  0x68, 0x6C, 0x20, 0x33, 0x29, 0x2C, 0x20, 0x25
	.byte  0x75, 0x74, 0x2C, 0x20, 0x25, 0x75, 0x74, 0x2C
	.byte  0x20, 0x30, 0x25, 0x78, 0x68, 0x20, 0x2B, 0x20
	.byte  0x28, 0x30, 0x25, 0x78, 0x68, 0x20, 0x73, 0x68
	.byte  0x6C, 0x20, 0x34, 0x29, 0x00

DS0007:
	.byte  0x64, 0x77, 0x00

DS0008:
	.byte  0x25, 0x73, 0x20, 0x30, 0x25, 0x78, 0x68, 0x00

DS0009:
	.byte  0x41, 0x4C, 0x49, 0x47, 0x4E, 0x20, 0x34, 0x00

DS000A:
	.byte  0x64, 0x64, 0x20, 0x25, 0x72, 0x20, 0x25, 0x73
	.byte  0x0A, 0x25, 0x72, 0x20, 0x38, 0x00

DS000B:
	.byte  0x2E, 0x70, 0x64, 0x61, 0x74, 0x61, 0x00

DS000C:
	.byte  0x2E, 0x70, 0x64, 0x61, 0x74, 0x61, 0x24, 0x25
	.byte  0x30, 0x34, 0x75, 0x00

DS000D:
	.byte  0x25, 0x73, 0x20, 0x25, 0x72, 0x20, 0x25, 0x72
	.byte  0x28, 0x34, 0x29, 0x20, 0x25, 0x72, 0x20, 0x72
	.byte  0x65, 0x61, 0x64, 0x20, 0x27, 0x44, 0x41, 0x54
	.byte  0x41, 0x27, 0x00

DS000E:
	.byte  0x64, 0x64, 0x20, 0x25, 0x72, 0x20, 0x25, 0x73
	.byte  0x2C, 0x20, 0x25, 0x72, 0x20, 0x25, 0x73, 0x2B
	.byte  0x30, 0x25, 0x78, 0x68, 0x2C, 0x20, 0x25, 0x72
	.byte  0x20, 0x24, 0x78, 0x64, 0x61, 0x74, 0x61, 0x73
	.byte  0x79, 0x6D, 0x2B, 0x30, 0x25, 0x78, 0x68, 0x0A
	.byte  0x25, 0x73, 0x20, 0x25, 0x72, 0x00

DS000F:
	.byte  0x20, 0x72, 0x65, 0x74, 0x00

DS0010:
	.byte  0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x70
	.byte  0x72, 0x6F, 0x6C, 0x6F, 0x67, 0x75, 0x65, 0x3A
	.byte  0x6E, 0x6F, 0x6E, 0x65, 0x0A, 0x00

DS0011:
	.byte  0x20, 0x28, 0x25, 0x73, 0x2C, 0x20, 0x30, 0x25
	.byte  0x58, 0x48, 0x2C, 0x20, 0x30, 0x25, 0x58, 0x48
	.byte  0x2C, 0x20, 0x30, 0x25, 0x58, 0x48, 0x2C, 0x20
	.byte  0x3C, 0x3C, 0x25, 0x73, 0x3E, 0x3E, 0x2C, 0x20
	.byte  0x3C, 0x25, 0x73, 0x3E, 0x29, 0x00

DS0012:
	.byte  0x20, 0x25, 0x72, 0x20, 0x5B, 0x72, 0x73, 0x70
	.byte  0x2B, 0x25, 0x75, 0x5D, 0x2C, 0x20, 0x25, 0x72
	.byte  0x00

DS0013:
	.byte  0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x0A, 0x20
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x0A, 0x20, 0x25
	.byte  0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25, 0x72
	.byte  0x0A, 0x20, 0x25, 0x72, 0x20, 0x25, 0x72, 0x2C
	.byte  0x20, 0x30, 0x00

DS0014:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25
	.byte  0x64, 0x0A, 0x25, 0x72, 0x20, 0x5F, 0x63, 0x68
	.byte  0x6B, 0x73, 0x74, 0x6B, 0x3A, 0x25, 0x72, 0x0A
	.byte  0x25, 0x72, 0x20, 0x5F, 0x63, 0x68, 0x6B, 0x73
	.byte  0x74, 0x6B, 0x0A, 0x25, 0x72, 0x20, 0x25, 0x72
	.byte  0x2C, 0x20, 0x25, 0x72, 0x00

DS0015:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25
	.byte  0x64, 0x00

DS0016:
	.byte  0x25, 0x72, 0x20, 0x25, 0x64, 0x00

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

DS0018:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25
	.byte  0x75, 0x2B, 0x25, 0x73, 0x00

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

DS001A:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25
	.byte  0x75, 0x00

DS001B:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x0A, 0x25, 0x72
	.byte  0x20, 0x25, 0x72, 0x2C, 0x20, 0x25, 0x72, 0x00

DS001C:
	.byte  0x25, 0x72, 0x20, 0x5F, 0x63, 0x68, 0x6B, 0x73
	.byte  0x74, 0x6B, 0x3A, 0x25, 0x72, 0x0A, 0x25, 0x72
	.byte  0x20, 0x25, 0x72, 0x2C, 0x20, 0x25, 0x64, 0x0A
	.byte  0x25, 0x72, 0x20, 0x5F, 0x63, 0x68, 0x6B, 0x73
	.byte  0x74, 0x6B, 0x00

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

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

DS001F:
	.byte  0x55, 0x73, 0x65, 0x72, 0x20, 0x72, 0x65, 0x67
	.byte  0x69, 0x73, 0x74, 0x65, 0x72, 0x73, 0x20, 0x69
	.byte  0x6E, 0x73, 0x69, 0x64, 0x65, 0x20, 0x66, 0x72
	.byte  0x61, 0x6D, 0x65, 0x3A, 0x20, 0x75, 0x73, 0x65
	.byte  0x20, 0x2D, 0x43, 0x73, 0x20, 0x6F, 0x72, 0x20
	.byte  0x4F, 0x50, 0x54, 0x49, 0x4F, 0x4E, 0x20, 0x43
	.byte  0x53, 0x54, 0x41, 0x43, 0x4B, 0x3A, 0x4F, 0x4E
	.byte  0x00

DS0020:
	.byte  0x25, 0x72, 0x20, 0x5B, 0x25, 0x72, 0x5D, 0x5B
	.byte  0x25, 0x64, 0x5D, 0x2C, 0x25, 0x72, 0x00

DS0021:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x20, 0x25, 0x72
	.byte  0x20, 0x5B, 0x25, 0x72, 0x5D, 0x5B, 0x25, 0x64
	.byte  0x5D, 0x2C, 0x25, 0x64, 0x0A, 0x25, 0x72, 0x20
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x20, 0x5B, 0x25
	.byte  0x72, 0x2B, 0x34, 0x5D, 0x5B, 0x25, 0x64, 0x5D
	.byte  0x2C, 0x34, 0x38, 0x2B, 0x25, 0x64, 0x00

DS0022:
	.byte  0x25, 0x72, 0x20, 0x5B, 0x25, 0x72, 0x2B, 0x30
	.byte  0x78, 0x25, 0x58, 0x5D, 0x5B, 0x25, 0x64, 0x5D
	.byte  0x2C, 0x25, 0x72, 0x00

DS0023:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x3A, 0x6E, 0x6F
	.byte  0x74, 0x68, 0x69, 0x6E, 0x67, 0x0A, 0x25, 0x72
	.byte  0x20, 0x25, 0x72, 0x2C, 0x25, 0x72, 0x3A, 0x5B
	.byte  0x30, 0x78, 0x32, 0x38, 0x5D, 0x0A, 0x25, 0x72
	.byte  0x20, 0x25, 0x72, 0x3A, 0x65, 0x72, 0x72, 0x6F
	.byte  0x72, 0x0A, 0x25, 0x72, 0x20, 0x5B, 0x25, 0x72
	.byte  0x2B, 0x30, 0x78, 0x31, 0x38, 0x5D, 0x5B, 0x25
	.byte  0x64, 0x5D, 0x2C, 0x25, 0x72, 0x00

DS0024:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x5B, 0x25
	.byte  0x72, 0x2B, 0x30, 0x78, 0x31, 0x30, 0x5D, 0x5B
	.byte  0x25, 0x64, 0x5D, 0x0A, 0x25, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x30, 0x78, 0x30, 0x38, 0x5D
	.byte  0x5B, 0x25, 0x64, 0x5D, 0x2C, 0x25, 0x72, 0x0A
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x5B, 0x25
	.byte  0x72, 0x2B, 0x30, 0x78, 0x32, 0x30, 0x5D, 0x5B
	.byte  0x25, 0x64, 0x5D, 0x0A, 0x25, 0x72, 0x20, 0x5B
	.byte  0x25, 0x72, 0x2B, 0x30, 0x78, 0x31, 0x30, 0x5D
	.byte  0x5B, 0x25, 0x64, 0x5D, 0x2C, 0x25, 0x72, 0x0A
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x5B, 0x25
	.byte  0x72, 0x5D, 0x5B, 0x25, 0x64, 0x5D, 0x00

DS0025:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x74, 0x68
	.byte  0x69, 0x73, 0x00

DS0026:
	.byte  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
	.byte  0x00

DS0027:
	.byte  0x65, 0x6E, 0x64, 0x62, 0x72, 0x36, 0x34, 0x00

DS0028:
	.byte  0x65, 0x6E, 0x64, 0x62, 0x72, 0x33, 0x32, 0x00

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

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

DS002B:
	.byte  0x25, 0x72, 0x20, 0x25, 0x72, 0x2C, 0x20, 0x25
	.byte  0x64, 0x20, 0x2B, 0x20, 0x25, 0x73, 0x00

DS002C:
	.byte  0x70, 0x6F, 0x70, 0x20, 0x64, 0x73, 0x00

DS002D:
	.byte  0x6C, 0x65, 0x61, 0x76, 0x65, 0x00

DS002E:
	.byte  0x25, 0x73, 0x2C, 0x20, 0x30, 0x25, 0x58, 0x48
	.byte  0x2C, 0x20, 0x30, 0x25, 0x58, 0x48, 0x2C, 0x20
	.byte  0x30, 0x25, 0x58, 0x48, 0x2C, 0x20, 0x3C, 0x3C
	.byte  0x25, 0x73, 0x3E, 0x3E, 0x2C, 0x20, 0x3C, 0x25
	.byte  0x73, 0x3E, 0x00

DS002F:
	.byte  0x6F, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x65
	.byte  0x70, 0x69, 0x6C, 0x6F, 0x67, 0x75, 0x65, 0x3A
	.byte  0x6E, 0x6F, 0x6E, 0x65, 0x0A, 0x00

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


.SECTION .bss
	.ALIGN	16

unw_code:
	.zero	516 * 1

unw_info:
	.zero	4 * 1

unw_segs_defined:
	.zero	1


.att_syntax prefix
