

.intel_syntax noprefix

.global SetBitMask
.global EvalOperand
.global EmitConstError
.global ExprEvalInit

.extern StackAdj
.extern FindDotSymbol
.extern MakeExtern
.extern EvalOperator
.extern atofloat
.extern _atoow
.extern quadtof
.extern ftoquad
.extern quad_resize
.extern __sqrtq
.extern __cmpq
.extern __subq
.extern __addq
.extern __modq
.extern __divq
.extern __mulq
.extern __roro
.extern __rolo
.extern __saro
.extern __shro
.extern __shlo
.extern __divo
.extern __mulo
.extern SearchInStruct
.extern CreateTypeSymbol
.extern CurrStruct
.extern GetStdAssumeEx_
.extern CurrProc
.extern DefineFlatGroup
.extern GetSymOfssize
.extern SetSymSegOfs
.extern sym_add_table
.extern SizeFromRegister
.extern MemtypeFromSize
.extern SizeFromMemtype
.extern SymTables
.extern tsprintf
.extern asmerr
.extern Options
.extern Parse_Pass
.extern SymFindID
.extern SymFind
.extern SymLookup
.extern SymAlloc
.extern tstrcmp
.extern tstrlen


.SECTION .text
	.ALIGN	16

noasmerr:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rbp
	mov	rbp, rsp
	mov	rax, -1
	leave
	ret

$_001:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	test	byte ptr [rcx+0x40], 0x10
	jz	$_002
	xor	eax, eax
	jmp	$_005

$_002:	cmp	dword ptr [rcx+0x3C], 3
	jz	$_003
	cmp	dword ptr [rdx+0x3C], 3
	jnz	$_004
$_003:	mov	ecx, 2050
	call	qword ptr [fnasmerr+rip]
	jmp	$_005

$_004:	mov	ecx, 2026
	call	qword ptr [fnasmerr+rip]
$_005:	leave
	ret

$_006:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	mov	rsi, rdx
	mov	rdi, rcx
	mov	rax, rcx
	mov	ecx, 24
	rep movsd
	mov	rcx, rax
	leave
	pop	rdi
	pop	rsi
	ret

$_007:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	test	byte ptr [rcx+0x40], 0x10
	jnz	$_008
	mov	ecx, 2148
	call	qword ptr [fnasmerr+rip]
$_008:	mov	rax, -1
	leave
	ret

$_009:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	movzx	eax, byte ptr [rcx+0x1E]
	cmp	eax, 195
	jnz	$_010
	mov	eax, 129
	cmp	byte ptr [rcx+0x21], 0
	jz	$_010
	mov	eax, 130
$_010:	movzx	edx, byte ptr [rcx+0x48]
	mov	r8, qword ptr [rcx+0x28]
	movzx	ecx, al
	call	SizeFromMemtype@PLT
	leave
	ret

$_011:
	mov	rax, qword ptr [rcx+0x78]
	mov	rax, qword ptr [rax]
	mov	ecx, 64
$_012:	test	rax, rax
	jz	$_013
	sub	cl, byte ptr [rax+0x5A]
	mov	rax, qword ptr [rax+0x80]
	jmp	$_012

$_013:
	dec	rax
	shr	rax, cl
	mov	qword ptr [rdx], rax
	ret

SetBitMask:
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rbx, rcx
	xor	eax, eax
	mov	ecx, 64
	sub	cl, byte ptr [rbx+0x5A]
	dec	rax
	shr	rax, cl
	mov	cl, byte ptr [rbx+0x59]
	shl	rax, cl
	mov	qword ptr [rdx], rax
	leave
	pop	rbx
	ret

$_014:
	cmp	byte ptr [rcx+0x44], 192
	jnz	$_016
	mov	eax, dword ptr [rcx+0x38]
	cmp	eax, 313
	jz	$_015
	cmp	eax, 303
	jz	$_015
	cmp	eax, 315
	jz	$_015
	cmp	eax, 310
	jnz	$_016
$_015:	mov	eax, 1
	jmp	$_017

$_016:	xor	eax, eax
$_017:	ret

$_018:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	test	byte ptr [Options+0x6+rip], 0x10
	jz	$_019
	call	$_001
	mov	ecx, eax
	mov	eax, 1
	jmp	$_021

$_019:	mov	dword ptr [rdx+0x3C], 0
	mov	qword ptr [rdx+0x10], 0
	cmp	dword ptr [rbp+0x20], 16
	jz	$_020
	mov	rcx, rdx
	mov	edx, dword ptr [rbp+0x20]
	call	quad_resize@PLT
$_020:	xor	eax, eax
$_021:	leave
	ret

$_022:
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rdx
	mov	rdi, r8
	mov	eax, ecx
	jmp	$_177

	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_023
	cmp	dword ptr [rdi+0x38], 316
	jz	$_023
	mov	dword ptr [rsi+0x38], 306
	mov	byte ptr [rsi+0x44], 192
$_023:	mov	eax, dword ptr [rsi]
	and	eax, 0xFF
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_024
	cmp	dword ptr [rdi+0x38], 316
	jz	$_024
	mov	dword ptr [rsi+0x38], 299
	mov	byte ptr [rsi+0x44], 192
$_024:	mov	eax, dword ptr [rsi]
	shr	eax, 8
	and	eax, 0xFF
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_025
	cmp	dword ptr [rdi+0x38], 316
	jz	$_025
	mov	dword ptr [rsi+0x38], 309
	mov	byte ptr [rsi+0x44], 192
$_025:	mov	eax, dword ptr [rsi]
	and	eax, 0xFFFF
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_026
	cmp	dword ptr [rdi+0x38], 316
	jz	$_026
	mov	dword ptr [rsi+0x38], 302
	mov	byte ptr [rsi+0x44], 192
$_026:	mov	eax, dword ptr [rsi]
	shr	eax, 16
	and	eax, 0xFFFF
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_027
	mov	r8d, 8
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_018
	test	rax, rax
	jz	$_027
	mov	eax, ecx
	jmp	$_178

$_027:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	byte ptr [rsi+0x44], 3
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_028
	cmp	dword ptr [rdi+0x38], 316
	jz	$_028
	mov	dword ptr [rsi+0x38], 308
	mov	byte ptr [rsi+0x44], 192
$_028:	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_029
	mov	r8d, 8
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_018
	test	rax, rax
	jz	$_029
	mov	eax, ecx
	jmp	$_178

$_029:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	byte ptr [rsi+0x44], 3
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_030
	cmp	dword ptr [rdi+0x38], 316
	jz	$_030
	mov	dword ptr [rsi+0x38], 301
	mov	byte ptr [rsi+0x44], 192
$_030:	mov	eax, dword ptr [rsi+0x4]
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rbp+0x48], 313
	jnz	$_031
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_031
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	xor	eax, eax
	jmp	$_178

$_031:	mov	rbx, qword ptr [rbp+0x40]
	test	rbx, rbx
	jz	$_032
	cmp	byte ptr [rbx+0x1D], 4
	jz	$_033
$_032:	cmp	dword ptr [rdi+0x38], 316
	jnz	$_034
$_033:	mov	rdx, qword ptr [rbp+0x50]
	mov	rcx, rdi
	call	$_007
	jmp	$_178

$_034:	test	byte ptr [rdi+0x40], 0x08
	jz	$_035
	mov	dword ptr [rdi], 0
$_035:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsi+0x38], eax
	test	byte ptr [rdi+0x40], 0x01
	jz	$_036
	mov	rdx, qword ptr [rbp+0x50]
	mov	rcx, rdi
	call	$_007
	jmp	$_178

$_036:	mov	byte ptr [rsi+0x44], 192
	xor	eax, eax
	jmp	$_178

	mov	rbx, qword ptr [rdi+0x50]
	test	rbx, rbx
	jz	$_037
	cmp	byte ptr [rbx+0x1D], 5
	jz	$_037
	test	byte ptr [rdi+0x40], 0x04
	jz	$_038
$_037:	mov	ecx, 2094
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_038:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsi+0x38], eax
	cmp	qword ptr [rsi+0x58], 0
	jz	$_039
	mov	dword ptr [rsi], 0
$_039:	mov	byte ptr [rsi+0x44], 192
	xor	eax, eax
	jmp	$_178

	xor	eax, eax
	mov	dword ptr [rsi+0x3C], 0
	mov	qword ptr [rsi+0x50], rax
	mov	dword ptr [rsi], eax
	mov	byte ptr [rsi+0x44], 192
	and	byte ptr [rsi+0x40], 0xEF
	cmp	dword ptr [rdi+0x3C], -2
	jnz	$_040
	jmp	$_178

$_040:	cmp	dword ptr [rdi+0x3C], 0
	jz	$_041
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_042
$_041:	cmp	dword ptr [rbp+0x48], 314
	jnz	$_042
	test	byte ptr [rdi+0x40], 0x20
	jz	$_042
	or	byte ptr [rsi+0x1], 0x80
$_042:	mov	rbx, qword ptr [rdi+0x50]
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_047
	mov	al, byte ptr [rdi+0x44]
	test	al, 0x40
	jz	$_043
	cmp	dword ptr [rbp+0x48], 314
	jnz	$_043
	or	byte ptr [rsi+0x1], 0x80
$_043:	and	al, 0xC0
	test	rbx, rbx
	jz	$_044
	cmp	byte ptr [rbx+0x1D], 5
	jz	$_044
	cmp	eax, 128
	jnz	$_044
	or	byte ptr [rsi], 0x01
$_044:	mov	rcx, rdi
	call	$_014
	test	eax, eax
	jz	$_045
	test	rbx, rbx
	jz	$_045
	mov	al, byte ptr [rbx+0x1E]
	and	eax, 0xC0
	cmp	eax, 128
	jnz	$_045
	or	byte ptr [rsi], 0x01
$_045:	test	rbx, rbx
	jz	$_047
	cmp	byte ptr [rbx+0x1E], 196
	jz	$_046
	test	byte ptr [rdi+0x44], 0x80
	jz	$_046
	cmp	byte ptr [rdi+0x44], 192
	jnz	$_047
	test	byte ptr [rbx+0x1E], 0x80
	jnz	$_047
$_046:	or	byte ptr [rsi], 0x02
$_047:	cmp	dword ptr [rdi+0x3C], -1
	jz	$_048
	test	byte ptr [rdi+0x40], 0x01
	jz	$_048
	or	byte ptr [rsi], 0x02
$_048:	mov	rcx, rdi
	call	$_014
	mov	cl, byte ptr [rdi+0x44]
	and	ecx, 0xC0
	cmp	dword ptr [rdi+0x3C], 0
	jz	$_051
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_052
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_052
	cmp	byte ptr [rdi+0x44], 192
	jnz	$_049
	test	eax, eax
	jnz	$_050
$_049:	cmp	byte ptr [rdi+0x44], 192
	jz	$_050
	cmp	ecx, 128
	jnz	$_052
$_050:	cmp	byte ptr [rbx+0x1D], 1
	jz	$_051
	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_052
$_051:	or	byte ptr [rsi], 0x04
$_052:	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_056
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_056
	cmp	byte ptr [rdi+0x44], 192
	jnz	$_053
	cmp	dword ptr [rdi+0x38], -2
	jz	$_054
$_053:	cmp	byte ptr [rdi+0x44], 196
	jz	$_054
	test	byte ptr [rdi+0x44], 0x80
	jz	$_054
	cmp	byte ptr [rdi+0x44], 195
	jnz	$_056
$_054:	test	rbx, rbx
	jz	$_055
	cmp	byte ptr [rbx+0x1D], 1
	jz	$_055
	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_056
$_055:	or	byte ptr [rsi], 0x08
$_056:	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_057
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_057
	or	byte ptr [rsi], 0x10
	test	byte ptr [rdi+0x44], 0x40
	jz	$_057
	cmp	dword ptr [rbp+0x48], 314
	jnz	$_057
	or	byte ptr [rsi+0x1], 0x80
$_057:	cmp	dword ptr [rdi+0x3C], -1
	jz	$_059
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_059
	test	ebx, ebx
	jz	$_058
	test	byte ptr [rbx+0x10], 0x01
	jz	$_059
$_058:	or	byte ptr [rsi], 0x20
$_059:	mov	rax, qword ptr [rdi+0x20]
	test	rax, rax
	jnz	$_060
	mov	rax, qword ptr [rdi+0x18]
$_060:	test	rax, rax
	jz	$_061
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	lea	rax, [r12+rax*8]
$_061:	test	rbx, rbx
	jz	$_062
	cmp	byte ptr [rbx+0x1D], 5
	jz	$_063
$_062:	test	byte ptr [rdi+0x40], 0x01
	jz	$_064
	test	rax, rax
	jz	$_064
	test	byte ptr [rax+0x5], 0x01
	jz	$_064
$_063:	or	byte ptr [rsi], 0x40
$_064:	test	rbx, rbx
	jz	$_065
	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_065
	or	dword ptr [rsi], 0x80
$_065:	cmp	dword ptr [rbp+0x48], 314
	jnz	$_066
	test	rbx, rbx
	jz	$_066
	cmp	dword ptr [rdi+0x3C], -1
	jz	$_066
	movzx	eax, byte ptr [rbx+0x1F]
	shl	eax, 8
	or	dword ptr [rsi], eax
$_066:	xor	eax, eax
	jmp	$_178

	mov	eax, dword ptr [rbp+0x48]
	mov	rbx, qword ptr [rbp+0x40]
	mov	dword ptr [rsi+0x3C], 0
	test	rbx, rbx
	je	$_076
	jmp	$_073

$_067:	jmp	$_076

$_068:	mov	dword ptr [rsi+0x3C], 1
	mov	qword ptr [rsi+0x50], rbx
	jmp	$_076

$_069:	jmp	$_076

$_070:	mov	ecx, 2143
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

	jmp	$_076

$_071:	jmp	$_076

$_072:	mov	ecx, 2143
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

	jmp	$_076

$_073:	cmp	byte ptr [rbx+0x1D], 6
	jz	$_067
	cmp	byte ptr [rbx+0x1D], 5
	jz	$_067
	cmp	byte ptr [rbx+0x1D], 0
	jz	$_068
	cmp	byte ptr [rbx+0x1D], 2
	jz	$_074
	cmp	byte ptr [rbx+0x1D], 1
	jnz	$_075
$_074:	cmp	byte ptr [rbx+0x1E], 192
	jz	$_075
	cmp	byte ptr [rbx+0x1E], 130
	jz	$_075
	cmp	byte ptr [rbx+0x1E], 129
	jnz	$_069
$_075:	cmp	byte ptr [rbx+0x1D], 4
	jz	$_070
	cmp	byte ptr [rbx+0x1D], 3
	jz	$_070
	cmp	eax, 318
	jz	$_071
	cmp	eax, 304
	jz	$_071
	jmp	$_072

$_076:	jmp	$_105

$_077:	test	byte ptr [rdi+0x41], 0x02
	jz	$_078
	mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi], eax
	jmp	$_080

$_078:	test	byte ptr [rbx+0x12], 0x20
	jz	$_079
	mov	eax, dword ptr [rbx+0x50]
	mov	dword ptr [rsi], eax
	jmp	$_080

$_079:	mov	dword ptr [rsi], 1
$_080:	jmp	$_106

$_081:	test	byte ptr [rdi+0x41], 0x02
	jz	$_082
	mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi], eax
	jmp	$_085

$_082:	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_083
	mov	rbx, qword ptr [rdi+0x58]
	mov	eax, dword ptr [rbx+0x68]
	mov	dword ptr [rsi], eax
	jmp	$_085

$_083:	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_084
	test	byte ptr [rbx+0x4B], 0x01
	jnz	$_084
	mov	dword ptr [rsi], 1
	jmp	$_085

$_084:	mov	eax, dword ptr [rbx+0x68]
	mov	dword ptr [rsi], eax
$_085:	jmp	$_106

$_086:	jmp	$_097

$_087:	mov	al, byte ptr [rdi+0x44]
	and	eax, 0xC0
	cmp	eax, 128
	jnz	$_088
	mov	eax, dword ptr [rdi]
	or	eax, 0xFF00
	mov	dword ptr [rsi], eax
	jmp	$_089

$_088:	mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi], eax
$_089:	jmp	$_098

$_090:	mov	eax, dword ptr [rbx+0x48]
	mov	dword ptr [rsi], eax
	jmp	$_098

$_091:	mov	rcx, rbx
	call	$_009
	mov	dword ptr [rsi], eax
	jmp	$_098

$_092:	mov	rcx, rbx
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
	or	eax, 0xFF00
	mov	dword ptr [rsi], eax
	jmp	$_098

$_093:	mov	rcx, rbx
	call	GetSymOfssize@PLT
	test	rax, rax
	jz	$_094
	mov	eax, 65286
	jmp	$_095

$_094:	mov	eax, 65285
$_095:	mov	dword ptr [rsi], eax
	jmp	$_098

$_096:	mov	rcx, rbx
	call	$_009
	mov	dword ptr [rsi], eax
	jmp	$_098

$_097:	test	rbx, rbx
	jz	$_087
	test	byte ptr [rbx+0x12], 0x20
	jnz	$_090
	cmp	byte ptr [rbx+0x1D], 5
	jz	$_091
	cmp	byte ptr [rbx+0x1E], 129
	jz	$_092
	cmp	byte ptr [rbx+0x1E], 130
	jz	$_093
	jmp	$_096

$_098:	jmp	$_106

$_099:	test	rbx, rbx
	jnz	$_102
	mov	rbx, qword ptr [rdi+0x60]
	test	byte ptr [rdi+0x40], 0x08
	jz	$_100
	test	rbx, rbx
	jz	$_100
	cmp	word ptr [rbx+0x6E], 4
	jnz	$_100
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
	jmp	$_101

$_100:	mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi], eax
$_101:	jmp	$_104

$_102:	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_103
	test	byte ptr [rbx+0x4B], 0x01
	jnz	$_103
	mov	rcx, rbx
	call	$_009
	mov	dword ptr [rsi], eax
	jmp	$_104

$_103:	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
$_104:	jmp	$_106

$_105:	cmp	eax, 304
	je	$_077
	cmp	eax, 305
	je	$_081
	cmp	eax, 318
	je	$_086
	cmp	eax, 319
	jz	$_099
$_106:	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_107
	cmp	byte ptr [rdi+0x44], 192
	jz	$_108
	cmp	byte ptr [rdi+0x44], 129
	jz	$_108
	cmp	byte ptr [rdi+0x44], 130
	jz	$_108
$_107:	mov	ecx, 2028
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_108:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	eax, dword ptr [rbp+0x48]
	mov	dword ptr [rsi+0x38], eax
	xor	eax, eax
	jmp	$_178

	test	byte ptr [rdi+0x40], 0x08
	jnz	$_109
	mov	ecx, 2010
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_109:	cmp	qword ptr [CurrStruct+rip], 0
	jz	$_110
	mov	ecx, 2034
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_110:	cmp	qword ptr [r14+0x38], 0
	jnz	$_111
	mov	ecx, 2034
	call	asmerr@PLT
	jmp	$_178

$_111:	mov	rbx, qword ptr [thissym+rip]
	test	rbx, rbx
	jnz	$_112
	lea	rcx, [DS0000+rip]
	call	SymAlloc@PLT
	mov	qword ptr [thissym+rip], rax
	mov	rbx, rax
	mov	byte ptr [rbx+0x1D], 1
	or	byte ptr [rbx+0x10], 0x01
$_112:	mov	dword ptr [rsi+0x3C], 1
	mov	qword ptr [rsi+0x50], rbx
	mov	rcx, qword ptr [rdi+0x60]
	mov	qword ptr [rbx+0x28], rcx
	test	rcx, rcx
	jz	$_113
	mov	byte ptr [rbx+0x1E], 196
	jmp	$_114

$_113:	mov	cl, byte ptr [rdi+0x44]
	mov	byte ptr [rbx+0x1E], cl
$_114:	mov	rcx, rbx
	call	SetSymSegOfs@PLT
	mov	rbx, qword ptr [thissym+rip]
	mov	al, byte ptr [rbx+0x1E]
	mov	byte ptr [rsi+0x44], al
	xor	eax, eax
	jmp	$_178

	mov	rbx, qword ptr [rbp+0x40]
	mov	dword ptr [rsi+0x3C], 0
	cmp	dword ptr [rdi+0x38], -2
	jz	$_115
	cmp	byte ptr [rdi+0x44], 192
	jz	$_115
	mov	dword ptr [rdi+0x38], -2
	xor	ebx, ebx
$_115:	jmp	$_151

$_116:	cmp	qword ptr [rdi+0x50], 0
	jz	LC00AE
	mov	eax, dword ptr [rdi+0x38]
	jmp	$_117

	mov	dword ptr [rsi], 1
	jmp	LC00AE

	mov	dword ptr [rsi], 2
	jmp	LC00AE

	mov	dword ptr [rsi], 4
	jmp	LC00AE

	mov	dword ptr [rsi], 8
	jmp	LC00AE

	mov	rcx, qword ptr [rdi+0x50]
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
	mov	dword ptr [rsi], eax
	or	byte ptr [rsi+0x40], 0x08
	jmp	LC00AE

$_117:	cmp	eax, 299
	jl	LC00AE
	cmp	eax, 326
	jg	LC00AE
	lea	r11, [LC00B9+rip]
	movzx	r10, byte ptr [r11+rax-0x125]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC00AE+rip]
	sub	r11, r10
	jmp	r11

LC00AE: jmp	$_153

$_118:	mov	rbx, qword ptr [rdi+0x60]
	jmp	$_133

$_119:	test	rbx, rbx
	jz	$_120
	cmp	word ptr [rbx+0x6E], 4
	jnz	$_120
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rdi], eax
$_120:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_135

$_121:	mov	rax, qword ptr [rdi+0x18]
	mov	ecx, dword ptr [rax+0x4]
	call	SizeFromRegister@PLT
	mov	dword ptr [rsi], eax
	or	byte ptr [rsi+0x40], 0x08
	mov	rax, qword ptr [rdi+0x18]
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8], 0x0E
	jz	$_122
	cmp	byte ptr [rsi+0x44], 192
	jnz	$_122
	mov	al, byte ptr [r14+0x6]
	cmp	byte ptr [rsi], al
	jnz	$_122
	mov	rax, qword ptr [rdi+0x18]
	movzx	eax, byte ptr [rax+0x1]
	call	GetStdAssumeEx_@PLT
	mov	rbx, rax
	jmp	$_123

$_122:	xor	ebx, ebx
$_123:	test	rbx, rbx
	jz	$_124
	mov	qword ptr [rsi+0x60], rbx
	mov	al, byte ptr [rbx+0x1E]
	mov	byte ptr [rsi+0x44], al
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
	jmp	$_125

$_124:	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	cmp	byte ptr [rsi+0x44], 192
	jnz	$_125
	lea	rdx, [rsi+0x44]
	mov	ecx, dword ptr [rsi]
	call	MemtypeFromSize@PLT
$_125:	jmp	$_135

$_126:	cmp	byte ptr [rdi+0x44], 192
	jz	$_130
	test	byte ptr [rdi+0x41], 0x02
	jnz	$_127
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_128
	cmp	byte ptr [rdi+0x44], 47
	jnz	$_128
$_127:	xor	eax, eax
	jmp	$_129

$_128:	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	mov	r8, qword ptr [rdi+0x60]
	movzx	edx, byte ptr [rdi+0x46]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype@PLT
$_129:	mov	dword ptr [rsi], eax
	jmp	$_131

$_130:	mov	rbx, qword ptr [rdi+0x60]
	test	rbx, rbx
	jz	$_131
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
	mov	al, byte ptr [rbx+0x1E]
	mov	byte ptr [rsi+0x44], al
$_131:	or	byte ptr [rsi+0x40], 0x08
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_135

$_132:	mov	dword ptr [rsi], 0
	jmp	$_135

$_133:	test	byte ptr [rdi+0x40], 0x08
	jne	$_119
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_134
	test	byte ptr [rdi+0x40], 0x01
	je	$_121
$_134:	cmp	byte ptr [rdi+0x44], 192
	jne	$_126
	test	byte ptr [rdi+0x40], 0x02
	jne	$_126
	jmp	$_132

$_135:	jmp	$_153

$_136:	mov	dword ptr [rsi+0x3C], 1
	mov	qword ptr [rsi+0x50], rbx
	or	byte ptr [rsi+0x40], 0x08
	jmp	$_153

$_137:	or	byte ptr [rsi+0x40], 0x08
	mov	rbx, qword ptr [rbx+0x28]
	mov	qword ptr [rsi+0x60], rbx
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
	mov	al, byte ptr [rbx+0x1E]
	mov	byte ptr [rsi+0x44], al
	jmp	$_153

$_138:	or	byte ptr [rsi+0x40], 0x08
	cmp	byte ptr [rsi+0x44], 192
	jnz	$_139
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
$_139:	mov	rbx, qword ptr [rbp+0x40]
	jmp	$_148

$_140:	mov	rax, qword ptr [rdi+0x28]
	mov	qword ptr [rsi+0x28], rax
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	mov	eax, dword ptr [rbx+0x60]
	mov	dword ptr [rsi], eax
	jmp	$_150

$_141:	mov	rax, qword ptr [rdi+0x28]
	mov	qword ptr [rsi+0x28], rax
	mov	ecx, 129
	cmp	byte ptr [rbx+0x21], 0
	jz	$_142
	mov	ecx, 130
$_142:	xor	r8d, r8d
	movzx	edx, byte ptr [rbx+0x48]
	movzx	ecx, cl
	call	SizeFromMemtype@PLT
	mov	dword ptr [rsi], eax
	jmp	$_150

$_143:	mov	rcx, rbx
	call	GetSymOfssize@PLT
	mov	ecx, eax
	mov	eax, 2
	shl	eax, cl
	or	eax, 0xFF00
	mov	dword ptr [rsi], eax
	jmp	$_150

$_144:	mov	rcx, rbx
	call	GetSymOfssize@PLT
	test	rax, rax
	jz	$_145
	mov	eax, 65286
	jmp	$_146

$_145:	mov	eax, 65285
$_146:	mov	dword ptr [rsi], eax
	jmp	$_150

$_147:	mov	rcx, rbx
	call	GetSymOfssize@PLT
	mov	edx, eax
	mov	r8, qword ptr [rbx+0x28]
	movzx	ecx, byte ptr [rdi+0x44]
	call	SizeFromMemtype@PLT
	mov	dword ptr [rsi], eax
	jmp	$_150

$_148:	cmp	qword ptr [rdi+0x60], 0
	jz	$_149
	cmp	qword ptr [rdi+0x58], 0
	je	$_140
$_149:	cmp	byte ptr [rbx+0x1E], 195
	je	$_141
	cmp	byte ptr [rbx+0x1E], 129
	jz	$_143
	cmp	byte ptr [rbx+0x1E], 130
	jz	$_144
	jmp	$_147

$_150:	jmp	$_153

$_151:	cmp	dword ptr [rdi+0x38], -2
	jne	$_116
	test	rbx, rbx
	je	$_118
	cmp	byte ptr [rbx+0x1D], 0
	je	$_136
	cmp	byte ptr [rbx+0x1E], 196
	jnz	$_152
	test	byte ptr [rdi+0x40], 0x02
	je	$_137
$_152:	jmp	$_138

$_153:	xor	eax, eax
	jmp	$_178

	movzx	ecx, byte ptr [rdi+0x40]
	and	ecx, 0x08
	shr	ecx, 3
	test	ecx, ecx
	jnz	$_154
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_154
	mov	rbx, qword ptr [rdi+0x58]
	cmp	byte ptr [rbx+0x1D], 6
	jnz	$_154
	cmp	byte ptr [rbx+0x1E], 196
	jnz	$_154
	mov	rbx, qword ptr [rbx+0x28]
	test	rbx, rbx
	jz	$_154
	cmp	word ptr [rbx+0x6E], 4
	jnz	$_154
	inc	ecx
$_154:	jmp	$_159

$_155:	mov	rbx, qword ptr [rdi+0x60]
	cmp	word ptr [rbx+0x6E], 4
	jz	$_156
	mov	ecx, 2019
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_156:	jmp	$_160

$_157:	mov	rbx, qword ptr [rdi+0x58]
	jmp	$_160

$_158:	mov	rbx, qword ptr [rdi+0x50]
	jmp	$_160

$_159:	test	ecx, ecx
	jnz	$_155
	cmp	dword ptr [rdi+0x3C], 0
	jz	$_157
	cmp	byte ptr [rdi+0x44], 193
	jz	$_157
	jmp	$_158

$_160:	cmp	dword ptr [rbp+0x48], 311
	jz	$_161
	cmp	dword ptr [rbp+0x48], 312
	jnz	$_164
$_161:	test	ecx, ecx
	jz	$_162
	mov	rdx, rsi
	mov	rcx, rbx
	call	$_011
	jmp	$_163

$_162:	mov	rdx, rsi
	mov	rcx, rbx
	call	SetBitMask
$_163:	jmp	$_169

$_164:	test	ecx, ecx
	jz	$_167
	mov	rax, qword ptr [rbx+0x78]
	mov	rcx, qword ptr [rax]
	xor	eax, eax
$_165:	test	rcx, rcx
	jz	$_166
	add	al, byte ptr [rcx+0x5A]
	mov	rcx, qword ptr [rcx+0x80]
	jmp	$_165

$_166:	mov	dword ptr [rsi], eax
	jmp	$_169

$_167:	mov	eax, dword ptr [rbx+0x60]
	cmp	byte ptr [rbx+0x1E], 193
	jnz	$_168
	test	byte ptr [rbx+0x11], 0x40
	jz	$_168
	movzx	eax, byte ptr [rbx+0x5A]
$_168:	mov	dword ptr [rsi], eax
$_169:	mov	dword ptr [rsi+0x3C], 0
	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_170
	mov	r8d, 16
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_018
	test	rax, rax
	jz	$_170
	mov	eax, ecx
	jmp	$_178

$_170:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	byte ptr [rsi+0x44], 7
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_171
	cmp	dword ptr [rdi+0x38], 316
	jz	$_171
	mov	dword ptr [rsi+0x38], 326
	mov	byte ptr [rsi+0x44], 192
$_171:	mov	dword ptr [rsi+0x8], 0
	mov	dword ptr [rsi+0xC], 0
	xor	eax, eax
	jmp	$_178

	xor	eax, eax
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_173
	mov	r8d, 16
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_018
	test	rax, rax
	jz	$_172
	mov	eax, ecx
	jmp	$_178

$_172:	jmp	$_174

$_173:	test	byte ptr [rdi+0x40], 0x20
	jz	$_174
	cmp	rax, qword ptr [rdi+0x8]
	jnz	$_174
	dec	rax
	mov	qword ptr [rdi+0x8], rax
$_174:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	byte ptr [rsi+0x44], 7
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_175
	cmp	dword ptr [rdi+0x38], 316
	jz	$_175
	mov	dword ptr [rsi+0x38], 325
	mov	byte ptr [rsi+0x44], 192
$_175:	mov	rax, qword ptr [rsi+0x8]
	mov	qword ptr [rsi], rax
	mov	qword ptr [rsi+0x8], 0
	xor	eax, eax
	jmp	$_178

	cmp	dword ptr [rdi+0x3C], 3
	jz	$_176
	mov	ecx, 2176
	call	qword ptr [fnasmerr+rip]
	jmp	$_178

$_176:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	rcx, rsi
	call	__sqrtq@PLT
	jmp	LC0105

$_177:	cmp	eax, 24
	ja	LC0105
	lea	r11, [LC0106+rip]
	movzx	r10, word ptr [r11+rax*2]
	lea	r11, [LC0105+rip]
	sub	r11, r10
	jmp	r11

LC0105: xor	eax, eax
$_178:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_179:
	mov	rdx, rcx
	xor	eax, eax
	mov	ecx, 26
	xchg	rdi, rdx
	rep stosd
	lea	rcx, [rdi-0x68]
	mov	rdi, rdx
	mov	dword ptr [rcx+0x38], -2
	mov	dword ptr [rcx+0x3C], -2
	mov	byte ptr [rcx+0x44], 192
	mov	byte ptr [rcx+0x46], 254
	ret

$_180:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	al, byte ptr [rcx]
	jmp	$_189

$_181:	movzx	eax, byte ptr [rcx+0x1]
	jmp	$_191

$_182:	mov	eax, 1
	test	byte ptr [r14+0x2], 0x80
	jz	$_183
	mov	eax, 9
$_183:	jmp	$_191

$_184:	mov	eax, 2
	jmp	$_191

$_185:	mov	eax, 3
	jmp	$_191

$_186:	mov	eax, 8
	jmp	$_191

$_187:	mov	eax, 7
	cmp	byte ptr [rcx+0x1], 0
	jz	$_188
	mov	eax, 9
$_188:	jmp	$_191

	jmp	$_190

$_189:	cmp	al, 4
	jz	$_181
	cmp	al, 5
	jz	$_181
	cmp	al, 40
	jz	$_182
	cmp	al, 91
	jz	$_182
	cmp	al, 46
	jz	$_184
	cmp	al, 58
	jz	$_185
	cmp	al, 42
	jz	$_186
	cmp	al, 47
	jz	$_186
	cmp	al, 43
	jz	$_187
	cmp	al, 45
	jz	$_187
$_190:	mov	rdx, qword ptr [rcx+0x10]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
$_191:	leave
	ret

$_192:
	cmp	cl, 63
	jnz	$_193
	mov	eax, 64
	jmp	$_199

$_193:	test	cl, 0x80
	jnz	$_194
	and	ecx, 0x1F
	inc	ecx
	mov	eax, ecx
	jmp	$_199

$_194:	cmp	edx, 254
	jnz	$_195
	movzx	edx, byte ptr [r14+0x4]
$_195:	cmp	cl, 129
	jnz	$_196
	mov	eax, 2
	mov	ecx, edx
	shl	eax, cl
	or	eax, 0xFF00
	jmp	$_199

$_196:	cmp	cl, 130
	jnz	$_198
	mov	eax, 65285
	test	dl, dl
	jz	$_197
	mov	eax, 2
	mov	ecx, edx
	shl	eax, cl
	add	eax, 2
	or	eax, 0xFF00
$_197:	jmp	$_199

$_198:	xor	eax, eax
$_199:	ret

$_200:
	cmp	byte ptr [rcx-0x20], 44
	jnz	$_201
	cmp	byte ptr [rcx-0x40], 2
	jnz	$_201
	cmp	byte ptr [rcx-0x60], 1
	jnz	$_201
	mov	eax, dword ptr [rcx-0x3C]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8]
	test	eax, 0x10
	jz	$_201
	cmp	dword ptr [rcx-0x5C], 1442
	jnc	$_201
	cmp	dword ptr [rcx-0x5C], 1032
	jc	$_201
	xor	eax, eax
	jmp	$_202

$_201:	or	byte ptr [rcx+0x2], 0x10
	mov	eax, 1
$_202:	ret

$_203:
	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, 88
	mov	eax, dword ptr [rdx]
	mov	dword ptr [rbp-0x18], eax
	mov	rdi, rcx
	mov	rbx, r8
	imul	eax, eax, 32
	add	rbx, rax
	mov	al, byte ptr [rbx]
	jmp	$_338

$_204:	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_206
	cmp	dword ptr [rbp-0x18], 2
	jle	$_206
	cmp	byte ptr [rbx-0x20], 44
	jnz	$_206
	cmp	byte ptr [rbx-0x40], 2
	jz	$_206
	inc	dword ptr [rbp-0x18]
	inc	dword ptr [rdx]
	add	rbx, 32
	mov	al, byte ptr [rbx]
	cmp	al, 91
	jnz	$_205
	xor	eax, eax
	jmp	$_340

$_205:	jmp	$_338

$_206:	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_207:	mov	dword ptr [rdi+0x3C], 0
	mov	r9d, dword ptr [rbx+0x4]
	movsx	r8d, byte ptr [rbx+0x1]
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, rdi
	call	_atoow@PLT
	jmp	$_339

$_208:	cmp	byte ptr [rbx+0x1], 34
	jz	$_214
	cmp	byte ptr [rbx+0x1], 39
	jz	$_214
	test	byte ptr [rdi+0x40], 0x10
	jne	$_339
	mov	rcx, qword ptr [rbx+0x10]
	mov	al, byte ptr [rcx]
	cmp	byte ptr [rbx+0x1], 0
	jnz	$_210
	cmp	al, 34
	jz	$_209
	cmp	al, 39
	jnz	$_210
$_209:	mov	ecx, 2046
	call	qword ptr [fnasmerr+rip]
	jmp	$_213

$_210:	cmp	byte ptr [rbx+0x1], 123
	jnz	$_212
	mov	dword ptr [rdi+0x3C], -2
	mov	rcx, rbx
	call	$_200
	test	rax, rax
	jnz	$_211
	mov	dword ptr [rdi+0x3C], 0
	mov	qword ptr [rdi+0x10], rbx
$_211:	jmp	$_339

	jmp	$_213

$_212:	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2167
	call	qword ptr [fnasmerr+rip]
$_213:	mov	rax, -1
	jmp	$_340

$_214:	mov	dword ptr [rdi+0x3C], 0
	mov	qword ptr [rdi+0x10], rbx
	mov	rdx, qword ptr [rbx+0x10]
	inc	rdx
	mov	ecx, dword ptr [rbx+0x4]
	cmp	ecx, 16
	jbe	$_215
	mov	ecx, 16
$_215:	test	ecx, ecx
	jz	$_216
	mov	al, byte ptr [rdx]
	inc	rdx
	mov	byte ptr [rdi+rcx-0x1], al
	dec	ecx
	jmp	$_215

$_216:	jmp	$_339

$_217:	mov	dword ptr [rdi+0x3C], 2
	mov	qword ptr [rdi+0x18], rbx
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	edx, dword ptr [r12+rax*8+0x8]
	movzx	eax, dl
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_218
	mov	eax, 128
	jmp	$_219

$_218:	cmp	eax, 6
	jc	$_219
	mov	eax, 6
$_219:	mov	ecx, eax
	movzx	eax, dl
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_220
	xor	eax, eax
$_220:	mov	esi, eax
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_221
	mov	eax, 128
	jmp	$_222

$_221:	cmp	eax, 6
	jc	$_222
	mov	eax, 6
$_222:	mov	edx, eax
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_223
	xor	eax, eax
$_223:	test	esi, esi
	jz	$_224
	cmp	eax, esi
	jc	$_225
$_224:	cmp	edx, ecx
	jnc	$_227
$_225:	test	byte ptr [rbp+0x40], 0x08
	jz	$_226
	mov	dword ptr [rdi+0x3C], -1
	mov	ecx, 2085
	call	qword ptr [fnasmerr+rip]
	jmp	$_227

$_226:	mov	ecx, 2085
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_227:	cmp	dword ptr [rbp-0x18], 0
	jle	$_228
	cmp	dword ptr [rbx-0x1C], 322
	jz	$_229
$_228:	cmp	dword ptr [rbp-0x18], 1
	jle	$_230
	cmp	byte ptr [rbx-0x20], 40
	jnz	$_230
	cmp	dword ptr [rbx-0x3C], 322
	jnz	$_230
$_229:	jmp	$_236

$_230:	test	byte ptr [rbp+0x40], 0x08
	jz	$_236
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	lea	rax, [r12+rax*8]
	test	dword ptr [rax+0x4], 0x80
	jz	$_231
	or	byte ptr [rdi+0x40], 0x01
	or	byte ptr [rdi+0x40], 0x40
	jmp	$_236

$_231:	test	byte ptr [rax+0x3], 0x0C
	jz	$_234
	cmp	byte ptr [rbx+0x20], 58
	jnz	$_232
	test	byte ptr [Options+0x6+rip], 0x10
	jz	$_233
	cmp	byte ptr [rbx+0x40], 2
	jnz	$_233
$_232:	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_233:	jmp	$_236

$_234:	test	byte ptr [rdi+0x40], 0x10
	jz	$_235
	mov	dword ptr [rdi+0x3C], -1
	jmp	$_236

$_235:	mov	ecx, 2031
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_236:	jmp	$_339

$_237:	cmp	dword ptr [rbp-0x18], 0
	je	$_245
	cmp	dword ptr [rbx+0x4], 337
	jne	$_245
	cmp	byte ptr [rbx+0x20], 40
	jne	$_245
	add	dword ptr [rbp-0x18], 2
	add	rbx, 64
	mov	dword ptr [rdi+0x3C], 0
	mov	dword ptr [rdi], 0
	mov	dword ptr [rdi+0x4], 0
	mov	rcx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rbp-0x18]
	cmp	byte ptr [rbx], 41
	jnz	$_238
	mov	dword ptr [rcx], eax
	dec	dword ptr [rdi]
	dec	dword ptr [rdi+0x4]
	jmp	$_339

$_238:	cmp	byte ptr [rbx], 10
	jnz	$_239
	cmp	byte ptr [rbx+0x20], 41
	jnz	$_239
	dec	dword ptr [rdi]
	dec	dword ptr [rdi+0x4]
	inc	eax
	mov	dword ptr [rcx], eax
	jmp	$_339

$_239:	cmp	byte ptr [rbx], 8
	jne	$_245
	cmp	byte ptr [rbx+0x20], 41
	jne	$_245
	inc	eax
	mov	dword ptr [rcx], eax
	mov	rcx, rbx
	call	SymFindID@PLT
	test	rax, rax
	jz	$_240
	cmp	byte ptr [rax+0x1D], 0
	jz	$_240
	dec	dword ptr [rdi]
	dec	dword ptr [rdi+0x4]
	jmp	$_339

$_240:	cmp	byte ptr [rbx+0x40], 0
	je	$_339
	cmp	dword ptr [rbx+0x44], 682
	jne	$_339
	cmp	dword ptr [rbx-0x5C], 754
	je	$_339
	add	rbx, 96
	mov	edx, dword ptr [rbp-0x18]
	add	edx, 3
	xor	ecx, ecx
$_241:	cmp	edx, dword ptr [r14+0x64]
	jge	$_244
	cmp	byte ptr [rbx], 41
	jnz	$_242
	test	ecx, ecx
	jz	$_244
	dec	ecx
	jmp	$_243

$_242:	cmp	byte ptr [rbx], 40
	jnz	$_243
	inc	ecx
$_243:	inc	edx
	add	rbx, 32
	jmp	$_241

$_244:	dec	edx
	mov	rcx, qword ptr [rbp+0x30]
	mov	dword ptr [rcx], edx
	jmp	$_339

$_245:	mov	rsi, qword ptr [rbx+0x10]
	test	byte ptr [rdi+0x40], 0x80
	je	$_253
	mov	rcx, qword ptr [rdi+0x60]
	xor	eax, eax
	mov	dword ptr [rdi], eax
	test	rcx, rcx
	jz	$_247
	movzx	edx, byte ptr [rbx+0x3]
	mov	eax, dword ptr [rbx+0x8]
	test	byte ptr [rcx+0x1C], 0x01
	jz	$_246
	mov	eax, dword ptr [rbx+0xC]
$_246:	mov	dword ptr [rsp+0x20], 0
	mov	r9, rdi
	mov	r8d, eax
	call	SearchInStruct@PLT
$_247:	test	rax, rax
	jnz	$_252
	mov	rcx, rbx
	call	SymFindID@PLT
	test	rax, rax
	jz	$_252
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_250
	mov	rcx, qword ptr [rdi+0x60]
	cmp	rax, rcx
	jz	$_249
	test	rcx, rcx
	jz	$_248
	test	byte ptr [rcx+0x10], 0x01
	jz	$_249
$_248:	test	byte ptr [r14+0x3], 0x02
	jnz	$_249
	xor	eax, eax
$_249:	jmp	$_252

$_250:	test	byte ptr [r14+0x3], 0x02
	jz	$_251
	cmp	byte ptr [rax+0x1D], 6
	jz	$_252
	cmp	byte ptr [rax+0x1D], 2
	jz	$_252
	cmp	byte ptr [rax+0x1D], 1
	jz	$_252
$_251:	xor	eax, eax
$_252:	jmp	$_256

$_253:	mov	edx, dword ptr [rsi]
	and	edx, 0xFFFFFF
	or	dh, 0x20
	cmp	edx, 25152
	jz	$_254
	cmp	edx, 26176
	jnz	$_255
$_254:	mov	eax, dword ptr [r14+0x32C]
	lea	rsi, [rbp-0x28]
	bt	edx, 10
	adc	eax, 0
	mov	r8d, eax
	lea	rdx, [DS0001+rip]
	mov	rcx, rsi
	call	tsprintf@PLT
	mov	rcx, rsi
	call	SymFind@PLT
	jmp	$_256

$_255:	mov	rcx, rbx
	call	SymFindID@PLT
$_256:	test	rax, rax
	jz	$_257
	cmp	byte ptr [rax+0x1D], 0
	jz	$_257
	cmp	byte ptr [rax+0x1D], 10
	jz	$_257
	cmp	byte ptr [rax+0x1D], 9
	jz	$_257
	cmp	byte ptr [rax+0x1D], 7
	jne	$_276
	cmp	word ptr [rax+0x6E], 0
	jne	$_276
$_257:	test	byte ptr [rdi+0x40], 0x10
	jz	$_258
	mov	dword ptr [rdi+0x3C], -1
	jmp	$_339

$_258:	test	rax, rax
	jz	$_260
	cmp	byte ptr [rax+0x1D], 9
	jz	$_259
	cmp	byte ptr [rax+0x1D], 10
	jnz	$_260
$_259:	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 2148
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_260:	test	rax, rax
	jnz	$_262
	cmp	byte ptr [rbx-0x20], 46
	jnz	$_262
	cmp	byte ptr [rbx-0x40], 8
	jz	$_261
	cmp	byte ptr [rbx-0x40], 93
	jnz	$_262
$_261:	mov	rdx, qword ptr [rbp+0x38]
	cmp	dword ptr [rdx+0x4], 609
	jnz	$_262
	mov	rcx, rbx
	call	FindDotSymbol@PLT
	test	rax, rax
	jz	$_262
	jmp	$_277

$_262:	cmp	dword ptr [Parse_Pass+rip], 0
	jne	$_272
	test	byte ptr [rbp+0x40], 0x02
	jne	$_272
	test	rax, rax
	jne	$_271
	mov	rcx, qword ptr [rdi+0x60]
	test	rcx, rcx
	jnz	$_268
	mov	rcx, rsi
	call	SymLookup@PLT
	mov	qword ptr [rbp-0x10], rax
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_264
	test	byte ptr [rax+0x10], 0x10
	jnz	$_263
	mov	rdx, rax
	lea	rcx, [SymTables+rip]
	call	sym_add_table@PLT
	mov	rax, qword ptr [rbp-0x10]
$_263:	jmp	$_267

$_264:	test	byte ptr [rdi+0x40], 0x80
	jz	$_266
	mov	rax, qword ptr [nullmbr+rip]
	test	rax, rax
	jnz	$_265
	lea	rcx, [DS0001+0x7+rip]
	call	SymAlloc@PLT
	mov	qword ptr [nullmbr+rip], rax
$_265:	jmp	$_267

$_266:	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 2004
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_267:	jmp	$_271

$_268:	cmp	word ptr [rcx+0x6E], 0
	jz	$_269
	mov	rdx, rsi
	mov	ecx, 2006
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

	jmp	$_271

$_269:	mov	rax, qword ptr [nullmbr+rip]
	test	rax, rax
	jnz	$_270
	lea	rcx, [DS0001+0x7+rip]
	call	SymAlloc@PLT
$_270:	mov	qword ptr [rdi+0x58], rax
	mov	dword ptr [rdi+0x3C], 0
	jmp	$_339

$_271:	jmp	$_275

$_272:	mov	ecx, dword ptr [rsi]
	cmp	ch, 38
	jnz	$_273
	lea	rsi, [DS0002+rip]
	jmp	$_274

$_273:	cmp	ecx, 1330399071
	jnz	$_274
	test	rax, rax
	jz	$_274
	cmp	dword ptr [rax+0x14], 21
	jnz	$_274
	cmp	dword ptr [Options+0x8C+rip], 3
	jnz	$_274
	mov	qword ptr [rbp-0x10], rax
	lea	rdx, [DS0003+rip]
	mov	rcx, rsi
	call	tstrcmp@PLT
	test	eax, eax
	jnz	$_274
	mov	byte ptr [rsp+0x20], 1
	mov	r9, qword ptr [rbp-0x10]
	xor	r8d, r8d
	mov	edx, 129
	mov	rcx, rsi
	call	MakeExtern@PLT
	test	rax, rax
	jz	$_274
	jmp	$_277

$_274:	mov	rdx, rsi
	mov	ecx, 2006
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_275:	jmp	$_277

$_276:	cmp	byte ptr [rax+0x1D], 8
	jnz	$_277
	mov	rax, qword ptr [rax+0x30]
$_277:	or	byte ptr [rax+0x10], 0x10
	jmp	$_305

$_278:	mov	rcx, qword ptr [rax+0x78]
	cmp	word ptr [rax+0x6E], 3
	jz	$_279
	test	byte ptr [rcx+0x11], 0x01
	jz	$_279
	mov	dword ptr [rdi+0x3C], -1
	jmp	$_306

$_279:	cmp	qword ptr [rax+0x28], 0
	jz	$_280
	cmp	rax, qword ptr [rax+0x28]
	jz	$_280
	mov	rax, qword ptr [rax+0x28]
	jmp	$_279

$_280:	mov	cl, byte ptr [rax+0x1E]
	mov	dword ptr [rdi+0x3C], 0
	mov	byte ptr [rdi+0x44], cl
	or	byte ptr [rdi+0x40], 0x08
	mov	qword ptr [rdi+0x60], rax
	and	ecx, 0xC0
	cmp	word ptr [rax+0x6E], 4
	jnz	$_281
	mov	rdx, rdi
	mov	rcx, rax
	call	$_011
	jmp	$_285

$_281:	cmp	ecx, 128
	jnz	$_284
	cmp	byte ptr [rax+0x1E], 128
	jnz	$_282
	mov	ecx, dword ptr [rax+0x60]
	mov	dword ptr [rdi], ecx
	mov	cl, byte ptr [rax+0x48]
	mov	byte ptr [rdi+0x46], cl
	jmp	$_283

$_282:	movzx	edx, byte ptr [rax+0x48]
	movzx	ecx, byte ptr [rax+0x1E]
	call	$_192
	mov	dword ptr [rdi], eax
$_283:	jmp	$_285

$_284:	mov	eax, dword ptr [rax+0x60]
	mov	dword ptr [rdi], eax
$_285:	jmp	$_306

$_286:	mov	qword ptr [rdi+0x58], rax
	mov	dword ptr [rdi+0x3C], 0
	mov	ecx, dword ptr [rax+0x30]
	add	dword ptr [rdi], ecx
	adc	dword ptr [rdi+0x4], 0
$_287:	cmp	qword ptr [rax+0x28], 0
	jz	$_288
	mov	rax, qword ptr [rax+0x28]
	jmp	$_287

$_288:	mov	cl, byte ptr [rax+0x1E]
	mov	byte ptr [rdi+0x44], cl
	mov	qword ptr [rdi+0x60], 0
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_289
	cmp	word ptr [rax+0x6E], 3
	jz	$_289
	mov	qword ptr [rdi+0x60], rax
	jmp	$_290

$_289:	cmp	cl, 195
	jnz	$_290
	cmp	byte ptr [rax+0x49], 0
	jz	$_290
	cmp	byte ptr [rax+0x4A], 128
	jz	$_290
	mov	rax, qword ptr [rax+0x50]
	mov	qword ptr [rdi+0x60], rax
	mov	byte ptr [rdi+0x45], 128
$_290:	jmp	$_306

$_291:	mov	rsi, rax
	mov	dword ptr [rdi+0x3C], 1
	test	byte ptr [rsi+0x10], 0x08
	jz	$_292
	cmp	qword ptr [rsi+0x68], 0
	jz	$_292
	xor	edx, edx
	mov	rcx, rsi
	call	qword ptr [rsi+0x68]
$_292:	cmp	byte ptr [rsi+0x1D], 1
	jnz	$_296
	cmp	qword ptr [rsi+0x40], 0
	jnz	$_296
	mov	dword ptr [rdi+0x3C], 0
	mov	rax, qword ptr [rsi+0x30]
	mov	qword ptr [rdi], rax
	mov	al, byte ptr [rsi+0x1E]
	mov	byte ptr [rdi+0x44], al
	cmp	al, 47
	jnz	$_293
	test	byte ptr [Options+0x6+rip], 0x10
	jnz	$_293
	mov	dword ptr [rdi+0x3C], 3
	mov	qword ptr [rdi+0x10], 0
	mov	rax, qword ptr [rsi+0x38]
	mov	qword ptr [rdi+0x8], rax
$_293:	test	byte ptr [rsi+0x13], 0x80
	jz	$_294
	or	byte ptr [rdi+0x40], 0x20
$_294:	test	byte ptr [rsi+0x1C], 0x02
	jz	$_295
	or	byte ptr [rdi+0x41], 0x02
$_295:	jmp	$_304

$_296:	cmp	byte ptr [rsi+0x1D], 2
	jnz	$_297
	cmp	byte ptr [rsi+0x1E], 192
	jnz	$_297
	test	byte ptr [rsi+0x4B], 0x01
	jnz	$_297
	or	byte ptr [rdi+0x40], 0x04
	mov	qword ptr [rdi+0x50], rsi
	jmp	$_304

$_297:	mov	qword ptr [rdi+0x28], rbx
	mov	rcx, qword ptr [rsi+0x28]
	test	rcx, rcx
	jz	$_298
	cmp	byte ptr [rcx+0x1E], 192
	jz	$_298
	mov	al, byte ptr [rcx+0x1E]
	mov	byte ptr [rdi+0x44], al
	jmp	$_299

$_298:	mov	al, byte ptr [rsi+0x1E]
	mov	byte ptr [rdi+0x44], al
$_299:	cmp	byte ptr [rsi+0x1D], 5
	jnz	$_300
	mov	eax, dword ptr [rsi+0x30]
	add	eax, dword ptr [StackAdj+rip]
	cdq
	mov	dword ptr [rdi], eax
	mov	dword ptr [rdi+0x4], edx
	or	byte ptr [rdi+0x40], 0x01
	mov	qword ptr [rdi+0x18], rbx
	mov	rcx, qword ptr [CurrProc+rip]
	mov	rcx, qword ptr [rcx+0x78]
	mov	eax, dword ptr [rcx+0x14]
	mov	dword ptr [rbx+0x4], eax
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rbx+0x1], al
$_300:	mov	qword ptr [rdi+0x50], rsi
$_301:	cmp	qword ptr [rsi+0x28], 0
	jz	$_302
	mov	rsi, qword ptr [rsi+0x28]
	jmp	$_301

$_302:	cmp	byte ptr [rsi+0x1D], 7
	jnz	$_303
	cmp	word ptr [rsi+0x6E], 3
	jz	$_303
	mov	qword ptr [rdi+0x60], rsi
	jmp	$_304

$_303:	mov	qword ptr [rdi+0x60], 0
$_304:	jmp	$_306

$_305:	cmp	byte ptr [rax+0x1D], 7
	je	$_278
	cmp	byte ptr [rax+0x1D], 6
	je	$_286
	jmp	$_291

$_306:	jmp	$_339

$_307:	mov	dword ptr [rdi+0x3C], 0
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	al, byte ptr [r12+rax*8+0xC]
	mov	byte ptr [rdi+0x44], al
	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	eax, dword ptr [r12+rax*8+0x4]
	mov	byte ptr [rdi+0x46], al
	mov	edx, eax
	movzx	ecx, byte ptr [rdi+0x44]
	call	$_192
	mov	dword ptr [rdi], eax
	or	byte ptr [rdi+0x40], 0x08
	mov	qword ptr [rdi+0x60], 0
	jmp	$_339

$_308:	cmp	dword ptr [rbx+0x4], 340
	jnz	$_314
	test	byte ptr [rbp+0x40], 0x02
	jnz	$_312
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_309
	mov	eax, 128
	jmp	$_310

$_309:	cmp	eax, 6
	jc	$_310
	mov	eax, 6
$_310:	cmp	eax, 3
	jnc	$_311
	mov	ecx, 2085
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_311:	call	DefineFlatGroup@PLT
$_312:	mov	rax, qword ptr [r14+0x40]
	mov	qword ptr [rdi+0x50], rax
	test	eax, eax
	jnz	$_313
	mov	rax, -1
	jmp	$_340

$_313:	mov	qword ptr [rdi+0x28], rbx
	mov	dword ptr [rdi+0x3C], 1
	jmp	$_318

$_314:	cmp	dword ptr [rbx+0x4], 339
	jnz	$_317
	cmp	dword ptr [rbp-0x18], 2
	jle	$_317
	cmp	dword ptr [rbx-0x1C], 322
	jz	$_315
	cmp	dword ptr [rbx-0x3C], 322
	jnz	$_317
$_315:	cmp	byte ptr [rbx+0x20], 8
	jz	$_316
	cmp	byte ptr [rbx+0x20], 91
	jnz	$_317
$_316:	inc	dword ptr [rdx]
	mov	dword ptr [rdi+0x3C], 1
	mov	byte ptr [rdi+0x44], 195
	jmp	$_339

	jmp	$_318

$_317:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
	jmp	$_340

$_318:	jmp	$_339

$_319:	mov	dword ptr [rdi+0x3C], 3
	mov	qword ptr [rdi+0x10], rbx
	cmp	byte ptr [rbx+0x1], 114
	jne	$_326
	mov	rcx, qword ptr [rbx+0x10]
	call	tstrlen@PLT
	dec	rax
	mov	esi, eax
	mov	r9d, eax
	mov	r8d, 16
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, rdi
	call	_atoow@PLT
	mov	eax, esi
	xor	ecx, ecx
	jmp	$_320

	dec	esi
	mov	ecx, 33
	jmp	LC01C8

	dec	esi
	mov	ecx, 35
	jmp	LC01C8

	dec	esi
	mov	ecx, 39
	jmp	LC01C8

	dec	esi
	mov	ecx, 41
	jmp	LC01C8

	dec	esi
	mov	ecx, 47
	jmp	LC01C8

$_320:	cmp	eax, 4
	jl	LC01C8
	cmp	eax, 33
	jg	LC01C8
	lea	r11, [LC01D1+rip]
	movzx	r10, byte ptr [r11+rax+0x7]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC01C8+rip]
	sub	r11, r10
	jmp	r11

LC01C8: mov	rdx, qword ptr [rbx+0x10]
	cmp	eax, esi
	jz	$_321
	cmp	byte ptr [rdx], 48
	jz	$_321
	xor	ecx, ecx
$_321:	mov	byte ptr [rdi+0x44], cl
	test	ecx, ecx
	jnz	$_322
	mov	ecx, 2104
	call	asmerr@PLT
	jmp	$_325

$_322:	shr	esi, 1
$_323:	cmp	esi, 16
	jnc	$_325
	cmp	byte ptr [rdi+rsi], 0
	jz	$_324
	mov	ecx, 2104
	call	asmerr@PLT
	jmp	$_325

$_324:	inc	esi
	jmp	$_323

$_325:	jmp	$_329

$_326:	mov	eax, 47
	mov	ecx, 16
	cmp	byte ptr [rbx+0x1], 102
	jnz	$_327
	mov	eax, 35
	mov	ecx, 4
	jmp	$_328

$_327:	cmp	byte ptr [rbx+0x1], 108
	jnz	$_328
	mov	eax, 41
	mov	ecx, 10
$_328:	mov	byte ptr [rdi+0x44], al
	xor	r9d, r9d
	mov	r8d, ecx
	mov	rdx, qword ptr [rbx+0x10]
	mov	rcx, rdi
	call	atofloat@PLT
$_329:	jmp	$_339

$_330:	test	byte ptr [rdi+0x40], 0x10
	jz	$_333
	cmp	byte ptr [rbx], 0
	jz	$_331
	cmp	byte ptr [rbx], 41
	jz	$_331
	cmp	byte ptr [rbx], 93
	jnz	$_332
$_331:	xor	eax, eax
	jmp	$_340

$_332:	jmp	$_339

$_333:	mov	rcx, qword ptr [rbx+0x10]
	cmp	byte ptr [rbx], 12
	jnz	$_334
	mov	rdx, rcx
	mov	ecx, 2048
	call	qword ptr [fnasmerr+rip]
	jmp	$_337

$_334:	cmp	byte ptr [rbx], 58
	jnz	$_335
	mov	ecx, 2009
	call	qword ptr [fnasmerr+rip]
	jmp	$_337

$_335:	movzx	eax, byte ptr [rcx]
	test	byte ptr [r15+rax], 0x03
	jz	$_336
	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2016
	call	qword ptr [fnasmerr+rip]
	jmp	$_337

$_336:	mov	rdx, qword ptr [rbx+0x18]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
$_337:	jmp	$_340

	jmp	$_339

$_338:	cmp	al, 38
	je	$_204
	cmp	al, 10
	je	$_207
	cmp	al, 9
	je	$_208
	cmp	al, 2
	je	$_217
	cmp	al, 5
	je	$_237
	cmp	al, 8
	je	$_245
	cmp	al, 6
	je	$_307
	cmp	al, 7
	je	$_308
	cmp	al, 11
	je	$_319
	jmp	$_330

$_339:	mov	rcx, qword ptr [rbp+0x30]
	inc	dword ptr [rcx]
	xor	eax, eax
$_340:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_341:
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rbp
	mov	rbp, rsp
	mov	eax, dword ptr [rbp+0x20]
	cmp	dword ptr [rcx+0x3C], eax
	jnz	$_342
	mov	eax, dword ptr [rbp+0x28]
	cmp	dword ptr [rdx+0x3C], eax
	jnz	$_342
	mov	eax, 1
	jmp	$_344

$_342:	mov	eax, dword ptr [rbp+0x28]
	cmp	dword ptr [rcx+0x3C], eax
	jnz	$_343
	mov	eax, dword ptr [rbp+0x20]
	cmp	dword ptr [rdx+0x3C], eax
	jnz	$_343
	mov	eax, 1
	jmp	$_344

$_343:	xor	eax, eax
$_344:	leave
	ret

$_345:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rax, qword ptr [rdx+0x18]
	test	rax, rax
	jz	$_354
	cmp	qword ptr [rcx+0x18], 0
	jnz	$_346
	mov	qword ptr [rcx+0x18], rax
	jmp	$_353

$_346:	cmp	qword ptr [rcx+0x20], 0
	jnz	$_349
	cmp	byte ptr [rax+0x1], 4
	jnz	$_347
	mov	rax, qword ptr [rcx+0x18]
	mov	qword ptr [rcx+0x20], rax
	mov	rax, qword ptr [rdx+0x18]
	mov	qword ptr [rcx+0x18], rax
	jmp	$_348

$_347:	mov	qword ptr [rcx+0x20], rax
$_348:	jmp	$_353

$_349:	cmp	byte ptr [rax-0x20], 91
	jnz	$_352
	cmp	byte ptr [rax-0x40], 8
	jnz	$_352
	cmp	byte ptr [rax-0x60], 46
	jnz	$_352
	mov	rax, qword ptr [rcx+0x50]
	test	rax, rax
	jz	$_350
	cmp	byte ptr [rax+0x1E], 195
	jnz	$_350
	cmp	byte ptr [rax+0x49], 0
	jnz	$_351
$_350:	mov	ecx, 2030
	call	qword ptr [fnasmerr+rip]
	jmp	$_361

$_351:	jmp	$_353

$_352:	mov	ecx, 2030
	call	qword ptr [fnasmerr+rip]
	jmp	$_361

$_353:	or	byte ptr [rcx+0x40], 0x01
$_354:	mov	rax, qword ptr [rdx+0x20]
	test	rax, rax
	jz	$_360
	cmp	qword ptr [rcx+0x20], 0
	jnz	$_355
	mov	qword ptr [rcx+0x20], rax
	mov	al, byte ptr [rdx+0x45]
	mov	byte ptr [rcx+0x45], al
	jmp	$_359

$_355:	cmp	byte ptr [rax-0x20], 91
	jnz	$_358
	cmp	byte ptr [rax-0x40], 8
	jnz	$_358
	cmp	byte ptr [rax-0x60], 46
	jnz	$_358
	mov	rax, qword ptr [rcx+0x50]
	test	rax, rax
	jz	$_356
	cmp	byte ptr [rax+0x1E], 195
	jnz	$_356
	cmp	byte ptr [rax+0x49], 0
	jnz	$_357
$_356:	mov	ecx, 2030
	call	qword ptr [fnasmerr+rip]
	jmp	$_361

$_357:	jmp	$_359

$_358:	mov	ecx, 2030
	call	qword ptr [fnasmerr+rip]
	jmp	$_361

$_359:	or	byte ptr [rcx+0x40], 0x01
$_360:	xor	eax, eax
$_361:	leave
	ret

$_362:
	cmp	dword ptr [rcx+0x3C], 1
	jnz	$_363
	test	byte ptr [rcx+0x40], 0x01
	jz	$_364
$_363:	jmp	$_372

$_364:	mov	rax, qword ptr [rcx+0x50]
	test	rax, rax
	jz	$_369
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_365
	jmp	$_372

$_365:	cmp	byte ptr [rax+0x1D], 0
	jnz	$_366
	cmp	dword ptr [rcx+0x38], -2
	jz	$_368
$_366:	cmp	byte ptr [rax+0x1D], 2
	jnz	$_367
	test	byte ptr [rax+0x4B], 0x02
	jz	$_367
	test	byte ptr [rcx+0x40], 0x04
	jnz	$_368
$_367:	jmp	$_372

$_368:	mov	dword ptr [rcx], 1
	mov	dword ptr [rcx+0x4], 0
$_369:	mov	qword ptr [rcx+0x28], 0
	mov	rax, qword ptr [rcx+0x58]
	test	rax, rax
	jz	$_370
	cmp	byte ptr [rax+0x1D], 6
	jz	$_370
	jmp	$_372

$_370:	cmp	qword ptr [rcx+0x30], 0
	jz	$_371
	jmp	$_372

$_371:	mov	dword ptr [rcx+0x38], -2
	mov	dword ptr [rcx+0x3C], 0
	and	byte ptr [rcx+0x40], 0xFD
	mov	byte ptr [rcx+0x44], 192
$_372:	ret

$_373:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rax, qword ptr [rcx+0x50]
	cmp	byte ptr [rax+0x1D], 2
	jnz	$_374
	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 2018
	call	qword ptr [fnasmerr+rip]
	jmp	$_378

$_374:	mov	rbx, qword ptr [rdx+0x50]
	cmp	byte ptr [rax+0x1D], 0
	jz	$_375
	mov	rax, qword ptr [rax+0x40]
	cmp	qword ptr [rbx+0x40], rax
	jz	$_375
	cmp	byte ptr [rbx+0x1D], 0
	jnz	$_376
$_375:	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_377
$_376:	mov	ecx, 2025
	call	qword ptr [fnasmerr+rip]
	jmp	$_378

$_377:	mov	rax, qword ptr [rcx+0x50]
	mov	dword ptr [rcx+0x3C], 0
	mov	dword ptr [rdx+0x3C], 0
	mov	eax, dword ptr [rax+0x30]
	add	dword ptr [rcx], eax
	mov	eax, dword ptr [rbx+0x30]
	add	dword ptr [rdx], eax
	xor	eax, eax
$_378:	leave
	pop	rbx
	ret

$_379:
	mov	rax, qword ptr [rcx+0x58]
	test	rax, rax
	jz	$_380
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_380
	mov	eax, dword ptr [rax+0x60]
	add	dword ptr [rcx], eax
	mov	qword ptr [rcx+0x58], 0
$_380:	ret

$_381:
	cmp	dword ptr [rcx+0x3C], 2
	jnz	$_382
	test	byte ptr [rcx+0x40], 0x01
	jz	$_383
$_382:	cmp	dword ptr [rdx+0x3C], 2
	jnz	$_384
	test	byte ptr [rdx+0x40], 0x01
	jnz	$_384
$_383:	mov	rax, -1
	jmp	$_385

$_384:	xor	eax, eax
$_385:	ret

$_386:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	call	$_381
	cmp	eax, -1
	jnz	$_387
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_411

$_387:	cmp	dword ptr [rsi+0x3C], 2
	jnz	$_388
	mov	dword ptr [rsi+0x3C], 1
$_388:	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_389
	mov	dword ptr [rdi+0x3C], 1
$_389:	cmp	qword ptr [rdi+0x30], 0
	jz	$_391
	cmp	qword ptr [rsi+0x30], 0
	jz	$_390
	mov	rbx, qword ptr [rsi+0x30]
	mov	rax, qword ptr [rdi+0x30]
	mov	al, byte ptr [rax]
	cmp	al, byte ptr [rbx]
	jnz	$_390
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_411

$_390:	mov	rax, qword ptr [rdi+0x30]
	mov	qword ptr [rsi+0x30], rax
$_391:	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_393
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_393
	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	cmp	dword ptr [rsi+0x4], 0
	jl	$_392
	and	byte ptr [rsi+0x40], 0xDF
$_392:	jmp	$_410

$_393:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_394
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_394
	mov	rdx, rdi
	mov	rcx, rsi
	call	__addq@PLT
	jmp	$_410

$_394:	cmp	dword ptr [rsi+0x3C], 1
	jne	$_400
	cmp	dword ptr [rdi+0x3C], 1
	jne	$_400
	mov	rcx, rsi
	call	$_379
	mov	rcx, rdi
	call	$_379
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_345
	cmp	eax, -1
	jnz	$_395
	jmp	$_411

$_395:	cmp	qword ptr [rdi+0x50], 0
	jz	$_398
	mov	rax, qword ptr [rsi+0x50]
	test	rax, rax
	jz	$_396
	cmp	byte ptr [rax+0x1D], 0
	jz	$_396
	mov	rax, qword ptr [rdi+0x50]
	cmp	byte ptr [rax+0x1D], 0
	jz	$_396
	mov	ecx, 2101
	call	qword ptr [fnasmerr+rip]
	jmp	$_411

$_396:	mov	rax, qword ptr [rdi+0x28]
	mov	qword ptr [rsi+0x28], rax
	mov	rax, qword ptr [rdi+0x50]
	mov	qword ptr [rsi+0x50], rax
	cmp	byte ptr [rsi+0x44], 192
	jnz	$_397
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
$_397:	cmp	dword ptr [rdi+0x38], -2
	jz	$_398
	mov	eax, dword ptr [rdi+0x38]
	mov	dword ptr [rsi+0x38], eax
$_398:	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	cmp	qword ptr [rdi+0x60], 0
	jz	$_399
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
$_399:	jmp	$_410

$_400:	mov	r9d, 1
	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_341
	test	rax, rax
	je	$_409
	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_406
	mov	rax, qword ptr [rsi]
	add	qword ptr [rdi], rax
	test	byte ptr [rsi+0x40], 0x01
	jz	$_401
	or	byte ptr [rdi+0x40], 0x01
$_401:	test	byte ptr [rsi+0x40], 0x02
	jz	$_402
	or	byte ptr [rdi+0x40], 0x02
	mov	al, byte ptr [rsi+0x44]
	mov	byte ptr [rdi+0x44], al
	jmp	$_403

$_402:	cmp	byte ptr [rdi+0x44], 192
	jnz	$_403
	mov	al, byte ptr [rsi+0x44]
	mov	byte ptr [rdi+0x44], al
$_403:	cmp	qword ptr [rdi+0x58], 0
	jnz	$_404
	mov	rax, qword ptr [rsi+0x58]
	mov	qword ptr [rdi+0x58], rax
$_404:	cmp	qword ptr [rdi+0x60], 0
	jz	$_405
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
$_405:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	jmp	$_408

$_406:	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	cmp	qword ptr [rdi+0x58], 0
	jz	$_407
	mov	rax, qword ptr [rdi+0x58]
	mov	qword ptr [rsi+0x58], rax
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	jmp	$_408

$_407:	cmp	byte ptr [rsi+0x44], 192
	jnz	$_408
	test	byte ptr [rdi+0x40], 0x08
	jnz	$_408
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
$_408:	mov	rcx, rsi
	call	$_379
	jmp	$_410

$_409:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_001
	jmp	$_411

$_410:	xor	eax, eax
$_411:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_412:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_381
	cmp	eax, -1
	jnz	$_413
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_450

$_413:	mov	rax, qword ptr [rdi+0x50]
	cmp	dword ptr [rsi+0x3C], 1
	jnz	$_414
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_414
	test	rax, rax
	jz	$_414
	cmp	byte ptr [rax+0x1D], 0
	jz	$_415
$_414:	mov	rcx, rdi
	call	$_362
$_415:	jmp	$_443

$_416:	mov	rax, qword ptr [rdi]
	cmp	qword ptr [rsi], rax
	jnc	$_417
	or	byte ptr [rsi+0x40], 0x20
$_417:	mov	rax, qword ptr [rdi]
	sub	qword ptr [rsi], rax
	jmp	$_449

$_418:	mov	rdx, rdi
	mov	rcx, rsi
	call	__subq@PLT
	jmp	$_449

$_419:	mov	rax, qword ptr [rdi]
	sub	qword ptr [rsi], rax
	mov	rcx, rsi
	call	$_379
	jmp	$_449

$_420:	mov	rcx, rsi
	call	$_379
	mov	rcx, rdi
	call	$_379
	test	byte ptr [rdi+0x40], 0x01
	jz	$_421
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_450

$_421:	cmp	qword ptr [rdi+0x28], 0
	jnz	$_423
	mov	rax, qword ptr [rdi]
	sub	qword ptr [rsi], rax
	test	byte ptr [rdi+0x40], 0x01
	jz	$_422
	or	byte ptr [rsi+0x40], 0x01
$_422:	jmp	$_439

$_423:	cmp	qword ptr [rsi+0x28], 0
	jz	$_424
	cmp	qword ptr [rsi+0x50], 0
	jz	$_424
	cmp	qword ptr [rdi+0x50], 0
	jnz	$_425
$_424:	mov	ecx, 2094
	call	qword ptr [fnasmerr+rip]
	jmp	$_450

$_425:	mov	rbx, qword ptr [rsi+0x50]
	mov	eax, dword ptr [rbx+0x30]
	add	dword ptr [rsi], eax
	adc	dword ptr [rsi+0x4], 0
	mov	rax, qword ptr [rdi+0x50]
	cmp	byte ptr [r14+0x4], 2
	jnz	$_426
	test	byte ptr [rax+0x10], 0x08
	jz	$_426
	test	byte ptr [rax+0x10], 0x80
	jz	$_426
	mov	rcx, qword ptr [rax+0x8]
	movzx	ecx, word ptr [rcx]
	cmp	ecx, 36
	jnz	$_426
	or	byte ptr [rsi+0x41], 0x01
	jmp	$_449

$_426:	mov	rcx, qword ptr [rbx+0x40]
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_430
	cmp	byte ptr [rax+0x1D], 2
	jz	$_427
	cmp	byte ptr [rbx+0x1D], 2
	jnz	$_428
$_427:	cmp	rax, qword ptr [rsi+0x50]
	jz	$_428
	mov	rdx, qword ptr [rbx+0x8]
	mov	ecx, 2018
	call	qword ptr [fnasmerr+rip]
	jmp	$_450

$_428:	cmp	rcx, qword ptr [rax+0x40]
	jz	$_429
	mov	ecx, 2025
	call	qword ptr [fnasmerr+rip]
	jmp	$_450

$_429:	jmp	$_431

$_430:	cmp	rcx, qword ptr [rax+0x40]
	jz	$_431
	lea	rcx, [noasmerr@PLT+rip]
	cmp	rcx, qword ptr [fnasmerr+rip]
	jnz	$_431
	mov	rax, -1
	jmp	$_450

$_431:	mov	dword ptr [rsi+0x3C], 0
	cmp	byte ptr [rbx+0x1D], 0
	jz	$_432
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_434
$_432:	mov	dword ptr [rsi], 1
	cmp	byte ptr [rbx+0x1D], 0
	jz	$_433
	mov	qword ptr [rsi+0x50], rax
	mov	rax, qword ptr [rdi+0x28]
	mov	qword ptr [rsi+0x28], rax
$_433:	jmp	$_435

$_434:	mov	eax, dword ptr [rax+0x30]
	sub	dword ptr [rsi], eax
	sbb	dword ptr [rsi+0x4], 0
	mov	rax, qword ptr [rdi]
	sub	qword ptr [rsi], rax
	mov	qword ptr [rsi+0x28], 0
	mov	qword ptr [rsi+0x50], 0
$_435:	test	byte ptr [rsi+0x40], 0x01
	jnz	$_437
	cmp	dword ptr [rsi+0x38], 313
	jnz	$_436
	cmp	dword ptr [rdi+0x38], 313
	jnz	$_436
	mov	dword ptr [rsi+0x38], -2
$_436:	jmp	$_438

$_437:	mov	dword ptr [rsi+0x3C], 1
$_438:	and	byte ptr [rsi+0x40], 0xFD
	mov	byte ptr [rsi+0x44], 192
$_439:	jmp	$_449

$_440:	test	byte ptr [rdi+0x40], 0x01
	jz	$_441
	or	byte ptr [rsi+0x40], 0x01
$_441:	mov	dword ptr [rsi+0x3C], 1
	mov	rdx, qword ptr [rdi]
	mov	rax, -1
	mul	rdx
	mov	qword ptr [rsi], rax
	jmp	$_449

$_442:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_001
	jmp	$_450

	jmp	$_449

$_443:	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_444
	cmp	dword ptr [rdi+0x3C], 0
	je	$_416
$_444:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_445
	cmp	dword ptr [rdi+0x3C], 3
	je	$_418
$_445:	cmp	dword ptr [rsi+0x3C], 1
	jnz	$_446
	cmp	dword ptr [rdi+0x3C], 0
	je	$_419
$_446:	cmp	dword ptr [rsi+0x3C], 1
	jnz	$_447
	cmp	dword ptr [rdi+0x3C], 1
	je	$_420
$_447:	cmp	dword ptr [rsi+0x3C], 2
	jnz	$_448
	cmp	dword ptr [rdi+0x3C], 0
	jz	$_440
$_448:	jmp	$_442

$_449:	xor	eax, eax
$_450:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_451:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	test	byte ptr [rcx+0x40], 0x10
	jz	$_452
	mov	dword ptr [rcx+0x3C], -1
	xor	eax, eax
	jmp	$_453

$_452:	mov	ecx, 2166
	call	qword ptr [fnasmerr+rip]
$_453:	leave
	ret

$_454:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_381
	cmp	eax, -1
	jnz	$_455
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_492

$_455:	cmp	dword ptr [rsi+0x3C], 2
	jnz	$_456
	mov	dword ptr [rsi+0x3C], 1
$_456:	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_457
	mov	dword ptr [rdi+0x3C], 1
$_457:	mov	rax, qword ptr [rdi+0x50]
	test	rax, rax
	jz	$_459
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_459
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_459
	mov	rax, qword ptr [nullstruct+rip]
	test	rax, rax
	jnz	$_458
	xor	r8d, r8d
	lea	rdx, [DS0003+0x15+rip]
	xor	ecx, ecx
	call	CreateTypeSymbol@PLT
	mov	qword ptr [nullstruct+rip], rax
$_458:	mov	qword ptr [rdi+0x60], rax
	or	byte ptr [rdi+0x40], 0x08
	mov	qword ptr [rdi+0x50], 0
	mov	dword ptr [rdi+0x3C], 0
$_459:	cmp	dword ptr [rsi+0x3C], 1
	jne	$_467
	cmp	dword ptr [rdi+0x3C], 1
	jne	$_467
	cmp	qword ptr [rdi+0x58], 0
	jnz	$_460
	test	byte ptr [r14+0x3], 0x02
	jnz	$_460
	mov	rcx, rsi
	call	$_451
	jmp	$_492

$_460:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_345
	cmp	eax, -1
	jnz	$_461
	jmp	$_492

$_461:	mov	rax, qword ptr [rdi+0x50]
	test	rax, rax
	jz	$_463
	mov	rbx, qword ptr [rsi+0x50]
	test	rbx, rbx
	jz	$_462
	cmp	byte ptr [rbx+0x1D], 0
	jz	$_462
	cmp	byte ptr [rax+0x1D], 0
	jz	$_462
	mov	ecx, 2101
	call	qword ptr [fnasmerr+rip]
	jmp	$_492

$_462:	mov	rax, qword ptr [rdi+0x28]
	mov	qword ptr [rsi+0x28], rax
	mov	rax, qword ptr [rdi+0x50]
	mov	qword ptr [rsi+0x50], rax
$_463:	mov	rax, qword ptr [rdi+0x58]
	test	rax, rax
	jz	$_464
	mov	qword ptr [rsi+0x58], rax
$_464:	mov	eax, dword ptr [rdi]
	add	dword ptr [rsi], eax
	test	byte ptr [rsi+0x40], 0x02
	jnz	$_465
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
$_465:	mov	rax, qword ptr [rdi+0x60]
	test	rax, rax
	jz	$_466
	mov	qword ptr [rsi+0x60], rax
$_466:	jmp	$_491

$_467:	cmp	dword ptr [rsi+0x3C], 0
	jne	$_473
	cmp	dword ptr [rdi+0x3C], 1
	jne	$_473
	test	byte ptr [rsi+0x40], 0x08
	jz	$_468
	cmp	qword ptr [rsi+0x60], 0
	jz	$_468
	and	byte ptr [rdi+0x40], 0xBF
	mov	dword ptr [rsi], 0
	mov	dword ptr [rsi+0x4], 0
$_468:	test	byte ptr [r14+0x3], 0x02
	jnz	$_469
	test	byte ptr [rsi+0x40], 0x08
	jnz	$_469
	cmp	qword ptr [rsi+0x58], 0
	jnz	$_469
	mov	rcx, rsi
	call	$_451
	jmp	$_492

$_469:	mov	rax, qword ptr [rsi+0x58]
	test	rax, rax
	jz	$_470
	cmp	byte ptr [rax+0x1D], 7
	jnz	$_470
	mov	eax, dword ptr [rax+0x30]
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
$_470:	test	byte ptr [rsi+0x40], 0x01
	jz	$_471
	or	byte ptr [rdi+0x40], 0x01
$_471:	mov	rax, qword ptr [rsi]
	add	qword ptr [rdi], rax
	cmp	qword ptr [rdi+0x58], 0
	jz	$_472
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
$_472:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	jmp	$_491

$_473:	cmp	dword ptr [rsi+0x3C], 1
	jne	$_480
	cmp	dword ptr [rdi+0x3C], 0
	jne	$_480
	test	byte ptr [r14+0x3], 0x02
	jnz	$_475
	cmp	qword ptr [rdi+0x60], 0
	jz	$_474
	test	byte ptr [rdi+0x40], 0x08
	jnz	$_475
$_474:	cmp	qword ptr [rdi+0x58], 0
	jnz	$_475
	mov	rcx, rsi
	call	$_451
	jmp	$_492

$_475:	test	byte ptr [rdi+0x40], 0x08
	jz	$_476
	cmp	qword ptr [rdi+0x60], 0
	jz	$_476
	and	byte ptr [rsi+0x40], 0xBF
	mov	rbx, qword ptr [rdi+0x60]
	mov	eax, dword ptr [rbx+0x60]
	sub	dword ptr [rdi], eax
	sbb	dword ptr [rdi+0x4], 0
$_476:	mov	rbx, qword ptr [rdi+0x58]
	test	rbx, rbx
	jz	$_477
	cmp	byte ptr [rbx+0x1D], 7
	jnz	$_477
	mov	eax, dword ptr [rbx+0x30]
	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], 0
$_477:	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	test	rbx, rbx
	jz	$_479
	mov	qword ptr [rsi+0x58], rbx
	test	rax, rax
	jz	$_479
	test	byte ptr [rdi+0x40], 0x80
	jz	$_479
	test	byte ptr [rsi+0x40], 0x02
	jz	$_478
	cmp	byte ptr [rdi+0x45], 128
	jnz	$_478
	mov	qword ptr [rsi+0x60], 0
	jmp	$_479

$_478:	or	byte ptr [rsi+0x40], 0x80
$_479:	jmp	$_491

$_480:	cmp	dword ptr [rsi+0x3C], 0
	jne	$_490
	cmp	dword ptr [rdi+0x3C], 0
	jne	$_490
	cmp	qword ptr [rdi+0x58], 0
	jnz	$_481
	test	byte ptr [r14+0x3], 0x02
	jnz	$_481
	mov	rcx, rsi
	call	$_451
	jmp	$_492

$_481:	cmp	qword ptr [rsi+0x60], 0
	jz	$_488
	mov	rcx, qword ptr [rdi+0x58]
	mov	eax, dword ptr [rdi]
	mov	edx, dword ptr [rdi+0x4]
	test	rcx, rcx
	jz	$_482
	cmp	byte ptr [rcx+0x1E], 193
	jnz	$_482
	test	byte ptr [rcx+0x11], 0x40
	jz	$_482
	movzx	eax, byte ptr [rcx+0x59]
	mov	dword ptr [rsi], 0
	mov	dword ptr [rsi+0x4], 0
$_482:	cmp	qword ptr [rsi+0x58], 0
	jz	$_483
	add	dword ptr [rsi], eax
	adc	dword ptr [rsi], edx
	jmp	$_484

$_483:	mov	dword ptr [rsi], eax
	mov	dword ptr [rsi+0x4], edx
$_484:	mov	qword ptr [rsi+0x58], rcx
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	and	byte ptr [rsi+0x40], 0xF7
	test	byte ptr [rdi+0x40], 0x08
	jz	$_485
	or	byte ptr [rsi+0x40], 0x08
$_485:	mov	rax, qword ptr [rdi+0x60]
	cmp	qword ptr [rsi+0x60], rax
	jz	$_486
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_487

$_486:	mov	qword ptr [rsi+0x60], 0
$_487:	jmp	$_489

$_488:	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x58]
	mov	qword ptr [rsi+0x58], rax
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
$_489:	jmp	$_491

$_490:	mov	rcx, rsi
	call	$_451
	jmp	$_492

$_491:	xor	eax, eax
$_492:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_493:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rax, qword ptr [rdi+0x30]
	test	rax, rax
	jz	$_496
	cmp	dword ptr [rsi+0x3C], 2
	jnz	$_494
	cmp	byte ptr [rax], 2
	jz	$_495
$_494:	cmp	dword ptr [rsi+0x3C], 1
	jnz	$_496
	cmp	byte ptr [rax], 8
	jnz	$_496
$_495:	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_496:	jmp	$_500

$_497:	test	byte ptr [rdi+0x40], 0x01
	jnz	$_498
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_498:	jmp	$_501

$_499:	mov	ecx, 2050
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

	jmp	$_501

$_500:	cmp	dword ptr [rdi+0x3C], 2
	jz	$_497
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_499
$_501:	cmp	dword ptr [rsi+0x3C], 2
	jne	$_508
	cmp	qword ptr [rsi+0x20], 0
	jz	$_502
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_502:	mov	rax, qword ptr [rsi+0x18]
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	test	byte ptr [r12+rax*8+0x3], 0x0C
	jnz	$_503
	mov	ecx, 2096
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_503:	mov	rax, qword ptr [rsi+0x18]
	mov	qword ptr [rdi+0x30], rax
	test	byte ptr [rsi+0x40], 0x01
	jz	$_504
	or	byte ptr [rdi+0x40], 0x01
$_504:	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_505
	mov	dword ptr [rdi+0x3C], 1
$_505:	test	byte ptr [rsi+0x40], 0x02
	jz	$_506
	or	byte ptr [rdi+0x40], 0x02
	mov	al, byte ptr [rsi+0x44]
	mov	byte ptr [rdi+0x44], al
	mov	al, byte ptr [rsi+0x46]
	mov	byte ptr [rdi+0x46], al
$_506:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	qword ptr [rdi+0x60], 0
	jz	$_507
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
$_507:	jmp	$_516

$_508:	cmp	dword ptr [rsi+0x3C], 1
	jne	$_515
	cmp	qword ptr [rsi+0x30], 0
	jne	$_515
	cmp	dword ptr [rsi+0x38], -2
	jne	$_515
	cmp	dword ptr [rsi], 0
	jne	$_515
	cmp	qword ptr [rsi+0x50], 0
	je	$_515
	cmp	qword ptr [rsi+0x18], 0
	jnz	$_515
	cmp	qword ptr [rsi+0x20], 0
	jnz	$_515
	mov	rax, qword ptr [rsi+0x50]
	cmp	byte ptr [rax+0x1D], 4
	jz	$_509
	cmp	byte ptr [rax+0x1D], 3
	jnz	$_512
$_509:	mov	dword ptr [rdi+0x3C], 1
	mov	rax, qword ptr [rsi+0x28]
	mov	qword ptr [rdi+0x30], rax
	test	byte ptr [rsi+0x40], 0x01
	jz	$_510
	or	byte ptr [rdi+0x40], 0x01
$_510:	test	byte ptr [rsi+0x40], 0x02
	jz	$_511
	or	byte ptr [rdi+0x40], 0x02
	mov	al, byte ptr [rsi+0x44]
	mov	byte ptr [rdi+0x44], al
	mov	al, byte ptr [rsi+0x46]
	mov	byte ptr [rdi+0x46], al
$_511:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_514

$_512:	cmp	dword ptr [Parse_Pass+rip], 0
	ja	$_513
	cmp	byte ptr [rax+0x1D], 0
	jz	$_514
$_513:	mov	ecx, 2096
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_514:	jmp	$_516

$_515:	mov	ecx, 2096
	call	qword ptr [fnasmerr+rip]
	jmp	$_517

$_516:	xor	eax, eax
$_517:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_518:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rcx, rdi
	call	$_362
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_519
	mov	dword ptr [rsi+0x3C], 0
	mov	rax, qword ptr [rdi]
	mov	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rsi+0x8], rax
	jmp	$_521

$_519:	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_520
	mov	dword ptr [rsi+0x3C], 3
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	mov	rax, qword ptr [rdi]
	mov	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rsi+0x8], rax
	and	byte ptr [rsi+0xF], 0x7F
	mov	eax, dword ptr [rdi+0x40]
	mov	dword ptr [rsi+0x40], eax
	jmp	$_521

$_520:	mov	ecx, 2026
	call	qword ptr [fnasmerr+rip]
	jmp	$_522

$_521:	xor	eax, eax
$_522:	leave
	pop	rdi
	pop	rsi
	ret

$_523:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rcx, rdi
	call	$_362
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_525
	mov	eax, dword ptr [rdi+0x40]
	mov	dword ptr [rsi+0x40], eax
	xor	byte ptr [rsi+0x40], 0x20
	mov	dword ptr [rsi+0x3C], 0
	mov	rax, qword ptr [rdi]
	mov	rdx, qword ptr [rdi+0x8]
	neg	rax
	mov	qword ptr [rsi], rax
	sbb	eax, eax
	test	rdx, rdx
	jz	$_524
	bt	eax, 0
	adc	rdx, 0
	neg	rdx
	mov	qword ptr [rsi+0x8], rdx
$_524:	jmp	$_527

$_525:	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_526
	mov	dword ptr [rsi+0x3C], 3
	mov	al, byte ptr [rdi+0x44]
	mov	byte ptr [rsi+0x44], al
	mov	rax, qword ptr [rdi]
	mov	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rsi+0x8], rax
	xor	byte ptr [rsi+0xF], 0x80
	mov	eax, dword ptr [rdi+0x40]
	mov	dword ptr [rsi+0x40], eax
	xor	byte ptr [rsi+0x40], 0x20
	jmp	$_527

$_526:	mov	ecx, 2026
	call	qword ptr [fnasmerr+rip]
	jmp	$_528

$_527:	xor	eax, eax
$_528:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_529:
	push	rsi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, rcx
	test	byte ptr [rsi+0x40], 0x02
	jz	$_530
	mov	rbx, qword ptr [rsi+0x60]
	test	rbx, rbx
	jz	$_530
	cmp	byte ptr [rbx+0x1E], 195
	jnz	$_530
	cmp	byte ptr [rbx+0x49], 1
	jnz	$_530
	mov	al, byte ptr [rbx+0x4A]
	mov	byte ptr [rsi+0x44], al
	mov	rax, qword ptr [rbx+0x50]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_535

$_530:	xor	ebx, ebx
	cmp	qword ptr [rsi+0x20], 0
	jz	$_531
	mov	rax, qword ptr [rsi+0x20]
	movzx	eax, byte ptr [rax+0x1]
	call	GetStdAssumeEx_@PLT
	mov	rbx, rax
$_531:	test	rbx, rbx
	jnz	$_532
	cmp	qword ptr [rsi+0x18], 0
	jz	$_532
	mov	rax, qword ptr [rsi+0x18]
	movzx	eax, byte ptr [rax+0x1]
	call	GetStdAssumeEx_@PLT
	mov	rbx, rax
$_532:	test	rbx, rbx
	jz	$_535
	cmp	byte ptr [rbx+0x1E], 196
	jnz	$_533
	mov	rax, qword ptr [rbx+0x28]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_535

$_533:	cmp	byte ptr [rbx+0x49], 1
	jnz	$_535
	mov	rax, qword ptr [rbx+0x50]
	mov	qword ptr [rsi+0x60], rax
	cmp	qword ptr [rbx+0x50], 0
	jz	$_534
	mov	rbx, qword ptr [rbx+0x50]
	mov	al, byte ptr [rbx+0x1E]
	mov	byte ptr [rsi+0x44], al
	jmp	$_535

$_534:	mov	al, byte ptr [rbx+0x4A]
	mov	byte ptr [rsi+0x44], al
$_535:	leave
	pop	rbx
	pop	rsi
	ret

$_536:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	byte ptr [rcx+0x45], 0
	jbe	$_537
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_539

$_537:	inc	byte ptr [rcx+0x45]
	cmp	dword ptr [rdx+0x3C], 0
	jz	$_538
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_539

$_538:	mov	eax, dword ptr [rdx]
	mov	dword ptr [rcx], eax
	xor	eax, eax
$_539:	leave
	ret

$_540:
	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	rsi, qword ptr [rcx+0x60]
	mov	rdi, qword ptr [rdx+0x60]
	cmp	byte ptr [rcx+0x44], 195
	jnz	$_545
	cmp	byte ptr [rdx+0x44], 195
	jnz	$_545
	mov	rbx, rcx
	test	rsi, rsi
	jnz	$_541
	mov	rcx, qword ptr [rcx+0x28]
	call	SymFindID@PLT
	mov	rsi, rax
	mov	rdx, qword ptr [rbp+0x30]
$_541:	test	rdi, rdi
	jnz	$_542
	mov	rcx, qword ptr [rdx+0x28]
	call	SymFindID@PLT
	mov	rdi, rax
$_542:	mov	al, byte ptr [rdi+0x49]
	cmp	byte ptr [rsi+0x49], al
	jnz	$_543
	mov	al, byte ptr [rdi+0x4A]
	cmp	byte ptr [rsi+0x4A], al
	jnz	$_543
	mov	rax, qword ptr [rdi+0x50]
	cmp	qword ptr [rsi+0x50], rax
	jnz	$_543
	mov	eax, dword ptr [rbp+0x38]
	jmp	$_544

$_543:	mov	eax, dword ptr [rbp+0x38]
	not	eax
$_544:	cdq
	mov	rcx, rbx
	mov	dword ptr [rcx], eax
	mov	dword ptr [rcx+0x4], edx
	jmp	$_550

$_545:	test	rsi, rsi
	jz	$_546
	cmp	word ptr [rsi+0x6E], 3
	jnz	$_546
	cmp	byte ptr [rsi+0x49], 0
	jnz	$_546
	mov	qword ptr [rcx+0x60], 0
$_546:	test	rdi, rdi
	jz	$_547
	cmp	word ptr [rdi+0x6E], 3
	jnz	$_547
	cmp	byte ptr [rdi+0x49], 0
	jnz	$_547
	mov	qword ptr [rdx+0x60], 0
$_547:	mov	al, byte ptr [rdx+0x44]
	cmp	byte ptr [rcx+0x44], al
	jnz	$_548
	mov	rax, qword ptr [rdx+0x60]
	cmp	qword ptr [rcx+0x60], rax
	jnz	$_548
	mov	eax, dword ptr [rbp+0x38]
	jmp	$_549

$_548:	mov	eax, dword ptr [rbp+0x38]
	not	eax
$_549:	cdq
	mov	dword ptr [rcx], eax
	mov	dword ptr [rcx+0x4], edx
$_550:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_551:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 168
	mov	rsi, rcx
	mov	rdi, rdx
	mov	rbx, r8
	mov	qword ptr [rsi+0x10], 0
	cmp	dword ptr [rdi+0x8], 0
	jnz	$_552
	cmp	dword ptr [rdi+0xC], 0
	jz	$_556
$_552:	cmp	byte ptr [rdi+0x44], 47
	jz	$_556
	cmp	byte ptr [rbx], 4
	jnz	$_553
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_553
	cmp	byte ptr [r14+0x4], 2
	jz	$_556
$_553:	test	byte ptr [rdi+0x40], 0x10
	jnz	$_556
	cmp	byte ptr [rbx], 43
	jz	$_554
	cmp	byte ptr [rbx], 45
	jnz	$_555
$_554:	cmp	byte ptr [rbx+0x1], 0
	jz	$_556
$_555:	mov	ecx, 2156
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_556:	movzx	eax, byte ptr [rbx]
	jmp	$_726

$_557:	test	byte ptr [rdi+0x40], 0x40
	jz	$_558
	and	byte ptr [rdi+0x40], 0xBF
	cmp	qword ptr [rsi+0x50], 0
	jnz	$_558
	mov	rcx, rdi
	call	$_529
$_558:	cmp	dword ptr [rsi+0x3C], -2
	jnz	$_560
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	test	byte ptr [rsi+0x40], 0x08
	jz	$_559
	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_559
	and	byte ptr [rsi+0x40], 0xF7
$_559:	jmp	$_727

$_560:	test	byte ptr [rsi+0x40], 0x08
	jz	$_562
	cmp	qword ptr [rsi+0x60], 0
	jnz	$_562
	cmp	dword ptr [rdi+0x3C], 1
	jz	$_561
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_562
$_561:	mov	ecx, 2009
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_562:	mov	rax, qword ptr [rsi+0x18]
	test	rax, rax
	jz	$_563
	cmp	dword ptr [rax+0x4], 31
	jnz	$_563
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_536
	jmp	$_728

$_563:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_386
	jmp	$_728

$_564:	cmp	dword ptr [rsi+0x3C], -2
	jnz	$_565
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rsi+0x60], rax
	jmp	$_727

$_565:	test	byte ptr [rsi+0x40], 0x08
	jz	$_566
	cmp	dword ptr [rdi+0x3C], 1
	jnz	$_566
	mov	ecx, 2009
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_566:	mov	rax, qword ptr [rsi+0x18]
	cmp	qword ptr [rsi+0x18], 0
	jz	$_567
	cmp	dword ptr [rax+0x4], 31
	jnz	$_567
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_536
	jmp	$_728

$_567:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_386
	jmp	$_728

$_568:	cmp	byte ptr [rbx+0x1], 0
	jnz	$_569
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_518
	jmp	$_728

$_569:	mov	r8, rbx
	mov	rdx, rdi
	mov	rcx, rsi
	call	EvalOperator@PLT
	cmp	eax, -1
	jnz	$_570
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_386
	jmp	$_728

$_570:	jmp	$_727

$_571:	cmp	byte ptr [rbx+0x1], 0
	jnz	$_572
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_523
	jmp	$_728

$_572:	mov	r8, rbx
	mov	rdx, rdi
	mov	rcx, rsi
	call	EvalOperator@PLT
	cmp	eax, -1
	jnz	$_573
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_412
	jmp	$_728

$_573:	jmp	$_727

$_574:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_454
	jmp	$_728

$_575:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_493
	jmp	$_728

$_576:	mov	rcx, rsi
	call	$_362
	mov	rcx, rdi
	call	$_362
	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_577
	cmp	dword ptr [rdi+0x3C], 0
	jnz	$_577
	mov	rdx, qword ptr [rsi]
	mov	rax, qword ptr [rdi]
	mul	rdx
	mov	qword ptr [rsi], rax
	jmp	$_585

$_577:	xor	r9d, r9d
	mov	r8d, 2
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_341
	test	rax, rax
	jz	$_583
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_381
	cmp	eax, -1
	jnz	$_578
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_578:	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_579
	mov	rax, qword ptr [rdi+0x18]
	mov	qword ptr [rsi+0x20], rax
	jmp	$_580

$_579:	mov	rax, qword ptr [rsi+0x18]
	mov	qword ptr [rsi+0x20], rax
	mov	eax, dword ptr [rdi]
	mov	dword ptr [rsi], eax
$_580:	cmp	dword ptr [rsi], 0
	jle	$_581
	cmp	dword ptr [rsi], 127
	jle	$_582
$_581:	mov	ecx, 2083
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_582:	mov	eax, dword ptr [rsi]
	mov	byte ptr [rsi+0x45], al
	mov	dword ptr [rsi], 0
	mov	qword ptr [rsi+0x18], 0
	or	byte ptr [rsi+0x40], 0x01
	mov	dword ptr [rsi+0x3C], 1
	jmp	$_585

$_583:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_584
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_584
	mov	rcx, rsi
	call	ftoquad@PLT
	mov	rcx, rdi
	call	ftoquad@PLT
	mov	rdx, rdi
	mov	rcx, rsi
	call	__mulq@PLT
	mov	rcx, rsi
	call	quadtof@PLT
	jmp	$_585

$_584:	mov	r8, rbx
	mov	rdx, rdi
	mov	rcx, rsi
	call	EvalOperator@PLT
	cmp	eax, -1
	jnz	$_585
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_001
	jmp	$_728

$_585:	jmp	$_727

$_586:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_587
	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_587
	mov	rcx, rsi
	call	ftoquad@PLT
	mov	rcx, rdi
	call	ftoquad@PLT
	mov	rdx, rdi
	mov	rcx, rsi
	call	__divq@PLT
	mov	rcx, rsi
	call	quadtof@PLT
	jmp	$_727

$_587:	mov	r8, rbx
	mov	rdx, rdi
	mov	rcx, rsi
	call	EvalOperator@PLT
	cmp	eax, -1
	jne	$_727
	mov	rcx, rsi
	call	$_362
	mov	rcx, rdi
	call	$_362
	cmp	dword ptr [rsi+0x3C], 0
	jnz	$_588
	cmp	dword ptr [rdi+0x3C], 0
	jz	$_589
$_588:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_001
	jmp	$_728

$_589:	mov	rcx, qword ptr [rdi]
	test	rcx, rcx
	jnz	$_590
	mov	ecx, 2169
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_590:	mov	rax, qword ptr [rsi]
	test	byte ptr [rsi+0x40], 0x20
	jz	$_591
	neg	rax
$_591:	test	byte ptr [rdi+0x40], 0x20
	jz	$_592
	neg	rcx
$_592:	xor	edx, edx
	div	rcx
	test	byte ptr [rsi+0x40], 0x20
	jnz	$_593
	test	byte ptr [rdi+0x40], 0x20
	jz	$_595
$_593:	test	byte ptr [rsi+0x40], 0x20
	jz	$_594
	test	byte ptr [rdi+0x40], 0x20
	jnz	$_595
$_594:	neg	rax
$_595:	mov	qword ptr [rsi], rax
	jmp	$_727

$_596:	cmp	dword ptr [rbx+0x4], 335
	jz	$_597
	cmp	dword ptr [rbx+0x4], 336
	jne	$_614
$_597:	cmp	dword ptr [rbx+0x4], 336
	jnz	$_600
	mov	rax, rbx
$_598:	cmp	byte ptr [rax+0x20], 0
	jz	$_599
	add	rax, 32
	jmp	$_598

$_599:	or	byte ptr [rax+0x2], 0x10
$_600:	test	byte ptr [rsi+0x40], 0x08
	jnz	$_602
	mov	rax, qword ptr [rsi+0x50]
	test	rax, rax
	jz	$_601
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_601
	mov	r8d, 1
	xor	edx, edx
	mov	rcx, rax
	call	CreateTypeSymbol@PLT
	mov	rax, qword ptr [rsi+0x50]
	mov	qword ptr [rsi+0x60], rax
	mov	qword ptr [rsi+0x50], 0
	or	byte ptr [rsi+0x40], 0x08
	jmp	$_602

$_601:	mov	ecx, 2010
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_602:	or	byte ptr [rdi+0x40], 0x02
	cmp	dword ptr [rdi+0x3C], 2
	jnz	$_609
	test	byte ptr [rdi+0x40], 0x01
	jz	$_603
	test	byte ptr [rdi+0x40], 0x40
	jz	$_609
$_603:	mov	rax, qword ptr [rdi+0x18]
	mov	eax, dword ptr [rax+0x4]
	add	eax, eax
	lea	rax, [r12+rax*8]
	test	byte ptr [rax+0x3], 0x0C
	jz	$_605
	cmp	dword ptr [rsi], 2
	jz	$_604
	cmp	dword ptr [rsi], 4
	jz	$_604
	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_604:	jmp	$_608

$_605:	mov	eax, dword ptr [rax+0x4]
	and	eax, 0x7F
	jnz	$_606
	mov	eax, 4
	cmp	byte ptr [r14+0x4], 2
	jnz	$_606
	mov	eax, 8
$_606:	cmp	eax, dword ptr [rsi]
	jz	$_608
	cmp	eax, 16
	jnz	$_607
	cmp	byte ptr [rsi+0x44], 35
	jz	$_608
	cmp	byte ptr [rsi+0x44], 39
	jz	$_608
$_607:	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_608:	jmp	$_610

$_609:	cmp	dword ptr [rdi+0x3C], 3
	jnz	$_610
	test	byte ptr [rsi+0x44], 0x20
	jnz	$_610
	mov	ecx, 2050
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_610:	mov	al, byte ptr [rsi+0x44]
	mov	byte ptr [rdi+0x44], al
	mov	al, byte ptr [rsi+0x46]
	mov	byte ptr [rdi+0x46], al
	test	byte ptr [rdi+0x40], 0x08
	jz	$_611
	mov	eax, dword ptr [rsi]
	mov	dword ptr [rdi], eax
$_611:	cmp	qword ptr [rsi+0x30], 0
	jz	$_613
	cmp	qword ptr [rdi+0x30], 0
	jnz	$_612
	mov	rax, qword ptr [rsi+0x30]
	mov	qword ptr [rdi+0x30], rax
$_612:	mov	dword ptr [rdi+0x3C], 1
$_613:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	jmp	$_727

$_614:	mov	rcx, rsi
	call	$_362
	mov	rcx, rdi
	call	$_362
	mov	eax, dword ptr [rsi+0x3C]
	mov	edx, dword ptr [rdi+0x3C]
	test	eax, eax
	jz	$_615
	cmp	eax, 3
	jnz	$_617
$_615:	test	edx, edx
	jz	$_616
	cmp	edx, 3
	jnz	$_617
$_616:	jmp	$_623

$_617:	cmp	byte ptr [rbx+0x1], 10
	jnz	$_622
	test	eax, eax
	jz	$_622
	cmp	eax, 1
	jnz	$_620
	test	byte ptr [rsi+0x40], 0x01
	jnz	$_620
	cmp	qword ptr [rsi+0x50], 0
	jz	$_620
	cmp	edx, 1
	jnz	$_618
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_618
	cmp	qword ptr [rdi+0x50], 0
	jz	$_618
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_373
	cmp	eax, -1
	je	$_728
	jmp	$_619

$_618:	mov	ecx, 2094
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_619:	jmp	$_621

$_620:	mov	ecx, 2095
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_621:	jmp	$_623

$_622:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_001
	jmp	$_728

$_623:	mov	eax, dword ptr [rbx+0x4]
	jmp	$_676

$_624:	test	byte ptr [rsi+0x40], 0x08
	jz	$_625
	test	byte ptr [rdi+0x40], 0x08
	jz	$_625
	mov	r8d, 4294967295
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_540
	jmp	$_628

$_625:	xor	eax, eax
	xor	edx, edx
	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_626
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
	add	rdx, qword ptr [rsi+0x8]
	sub	rdx, qword ptr [rdi+0x8]
	mov	qword ptr [rsi+0x8], rax
$_626:	add	rdx, qword ptr [rsi]
	sub	rdx, qword ptr [rdi]
	jnz	$_627
	dec	rax
$_627:	mov	qword ptr [rsi], rax
$_628:	jmp	LC033D

$_629:	test	byte ptr [rsi+0x40], 0x08
	jz	$_630
	test	byte ptr [rdi+0x40], 0x08
	jz	$_630
	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, rsi
	call	$_540
	jmp	$_633

$_630:	xor	eax, eax
	xor	edx, edx
	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_631
	add	rdx, qword ptr [rsi+0x8]
	sub	rdx, qword ptr [rdi+0x8]
	mov	qword ptr [rsi+0x8], rax
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
$_631:	add	rdx, qword ptr [rsi]
	sub	rdx, qword ptr [rdi]
	jz	$_632
	dec	rax
$_632:	mov	qword ptr [rsi], rax
$_633:	jmp	LC033D

$_634:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_636
	mov	rdx, rdi
	mov	rcx, rsi
	call	__cmpq@PLT
	xor	ecx, ecx
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
	mov	qword ptr [rsi+0x8], rcx
	cmp	eax, -1
	jnz	$_635
	dec	rcx
$_635:	jmp	$_637

$_636:	xor	ecx, ecx
	mov	rax, qword ptr [rdi]
	cmp	qword ptr [rsi], rax
	jge	$_637
	dec	rcx
$_637:	mov	qword ptr [rsi], rcx
	jmp	LC033D

$_638:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_640
	mov	rdx, rdi
	mov	rcx, rsi
	call	__cmpq@PLT
	xor	ecx, ecx
	mov	qword ptr [rsi+0x8], rcx
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
	cmp	eax, 1
	jz	$_639
	dec	rcx
$_639:	jmp	$_641

$_640:	xor	ecx, ecx
	mov	rax, qword ptr [rdi]
	cmp	qword ptr [rsi], rax
	jg	$_641
	dec	rcx
$_641:	mov	qword ptr [rsi], rcx
	jmp	LC033D

$_642:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_644
	mov	rdx, rdi
	mov	rcx, rsi
	call	__cmpq@PLT
	xor	ecx, ecx
	mov	qword ptr [rsi+0x8], rcx
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
	cmp	eax, 1
	jnz	$_643
	dec	rcx
$_643:	jmp	$_645

$_644:	xor	ecx, ecx
	mov	rax, qword ptr [rdi]
	cmp	qword ptr [rsi], rax
	jle	$_645
	dec	rcx
$_645:	mov	qword ptr [rsi], rcx
	jmp	LC033D

$_646:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_648
	mov	rdx, rdi
	mov	rcx, rsi
	call	__cmpq@PLT
	xor	ecx, ecx
	mov	qword ptr [rsi+0x8], rcx
	mov	dword ptr [rsi+0x3C], 0
	mov	byte ptr [rsi+0x44], 192
	cmp	eax, -1
	jz	$_647
	dec	rcx
$_647:	jmp	$_649

$_648:	xor	ecx, ecx
	mov	rax, qword ptr [rdi]
	cmp	qword ptr [rsi], rax
	jl	$_649
	dec	rcx
$_649:	mov	qword ptr [rsi], rcx
	jmp	LC033D

$_650:	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_651
	mov	rdx, rdi
	mov	rcx, rsi
	call	__modq@PLT
	jmp	LC033D

$_651:	cmp	dword ptr [rdi], 0
	jnz	$_652
	cmp	dword ptr [rdi+0x4], 0
	jnz	$_652
	mov	ecx, 2169
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_652:	mov	rcx, qword ptr [rdi]
	mov	rax, qword ptr [rsi]
	test	byte ptr [rsi+0x40], 0x20
	jz	$_653
	neg	rax
$_653:	test	byte ptr [rdi+0x40], 0x20
	jz	$_654
	neg	rcx
$_654:	xor	edx, edx
	div	rcx
	test	byte ptr [rsi+0x40], 0x20
	jz	$_655
	neg	rdx
$_655:	mov	qword ptr [rsi], rdx
	jmp	LC033D

	mov	edx, dword ptr [rdi]
	cmp	edx, 0
	jge	$_656
	mov	ecx, 2092
	call	qword ptr [fnasmerr+rip]
	jmp	LC033D

$_656:	mov	ecx, 64
	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_657
	mov	ecx, 128
	jmp	$_658

$_657:	cmp	byte ptr [r14+0x4], 1
	jnz	$_658
	mov	ecx, 32
$_658:	jmp	$_665

$_659:	mov	r8d, ecx
	mov	rcx, rsi
	call	__rolo@PLT
	jmp	$_666

$_660:	mov	r8d, ecx
	mov	rcx, rsi
	call	__roro@PLT
	jmp	$_666

$_661:	mov	r8d, ecx
	mov	rcx, rsi
	call	__shro@PLT
	jmp	$_666

$_662:	mov	r8d, ecx
	mov	rcx, rsi
	call	__saro@PLT
	jmp	$_666

$_663:	mov	r8d, ecx
	mov	rcx, rsi
	call	__shlo@PLT
	test	byte ptr [r14+0x2], 0x80
	jz	$_664
	xor	eax, eax
	mov	dword ptr [rsi+0x4], eax
	mov	qword ptr [rsi+0x8], rax
$_664:	jmp	$_666

$_665:	cmp	eax, 688
	jz	$_659
	cmp	eax, 689
	jz	$_660
	cmp	eax, 693
	jz	$_661
	cmp	eax, 691
	jz	$_662
	jmp	$_663

$_666:	jmp	LC033D

	cmp	dword ptr [rsi+0x3C], 3
	jz	$_667
	mov	ecx, 2187
	call	qword ptr [fnasmerr+rip]
$_667:	mov	rax, qword ptr [rdi]
	add	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x8]
	adc	qword ptr [rsi+0x8], rax
	jmp	LC033D

	cmp	dword ptr [rsi+0x3C], 3
	jz	$_668
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_668
	mov	ecx, 2187
	call	qword ptr [fnasmerr+rip]
$_668:	mov	rax, qword ptr [rdi]
	sub	qword ptr [rsi], rax
	mov	rax, qword ptr [rdi+0x8]
	sbb	qword ptr [rsi+0x8], rax
	jmp	LC033D

$_669:	cmp	dword ptr [rsi+0x3C], 3
	jz	$_670
	mov	ecx, 2187
	call	qword ptr [fnasmerr+rip]
$_670:	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, rsi
	call	__mulo@PLT
	jmp	LC033D

$_671:	cmp	dword ptr [rsi+0x3C], 3
	jz	$_672
	mov	ecx, 2187
	call	qword ptr [fnasmerr+rip]
$_672:	lea	r8, [rbp-0x70]
	mov	rdx, rdi
	mov	rcx, rsi
	call	__divo@PLT
	jmp	LC033D

	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_673
	mov	rax, qword ptr [rdi+0x8]
	and	qword ptr [rsi+0x8], rax
$_673:	mov	rax, qword ptr [rdi]
	and	qword ptr [rsi], rax
	jmp	LC033D

	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_674
	mov	rax, qword ptr [rdi+0x8]
	or	qword ptr [rsi+0x8], rax
$_674:	mov	rax, qword ptr [rdi]
	or	qword ptr [rsi], rax
	jmp	LC033D

	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_675
	mov	rax, qword ptr [rdi+0x8]
	xor	qword ptr [rsi+0x8], rax
$_675:	mov	rax, qword ptr [rdi]
	xor	qword ptr [rsi], rax
	jmp	LC033D

$_676:	cmp	rax, 678
	jl	$_677
	cmp	rax, 693
	jg	$_677
	lea	r11, [LC037D+rip]
	movzx	r10, byte ptr [r11+rax-0x298]
	movzx	r10, word ptr [r11+r10*2]
	lea	r11, [LC033D+rip]
	sub	r11, r10
	jmp	r11

$_677:	cmp	rax, 328
	je	$_624
	cmp	rax, 329
	je	$_629
	cmp	rax, 333
	je	$_634
	cmp	rax, 332
	je	$_638
	cmp	rax, 331
	je	$_642
	cmp	rax, 330
	je	$_646
	cmp	rax, 334
	je	$_650
	cmp	rax, 752
	je	$_669
	cmp	rax, 750
	je	$_671
LC033D: jmp	$_727

$_678:	mov	eax, dword ptr [rbx+0x4]
	cmp	eax, 754
	jz	$_679
	cmp	eax, 783
	jz	$_679
	cmp	eax, 782
	jne	$_691
$_679:	mov	rcx, rdi
	call	$_362
	cmp	dword ptr [rdi+0x3C], 0
	jz	$_680
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_680
	mov	ecx, 2026
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_680:	mov	rdx, rdi
	mov	rcx, rsi
	call	$_006
	cmp	dword ptr [rbx+0x4], 754
	jnz	$_682
	not	qword ptr [rsi]
	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_681
	not	qword ptr [rsi+0x8]
$_681:	jmp	$_690

$_682:	xor	eax, eax
	xor	edx, edx
	mov	ecx, 64
	cmp	dword ptr [rsi+0x3C], 3
	jnz	$_683
	mov	ecx, 128
	jmp	$_684

$_683:	cmp	byte ptr [r14+0x4], 1
	jnz	$_684
	mov	ecx, 32
$_684:	mov	dword ptr [rsi+0x3C], 0
	cmp	dword ptr [rbx+0x4], 782
	jnz	$_686
	bsf	rax, qword ptr [rsi]
	cmp	ecx, 128
	jnz	$_685
	cmp	rdx, qword ptr [rsi]
	jnz	$_685
	bsf	rax, qword ptr [rsi+0x8]
	cmp	rdx, qword ptr [rsi+0x8]
	jz	$_685
	add	eax, 64
$_685:	jmp	$_689

$_686:	cmp	ecx, 128
	jz	$_687
	bsr	rax, qword ptr [rsi]
	jmp	$_689

$_687:	bsr	rax, qword ptr [rsi+0x8]
	cmp	rdx, qword ptr [rsi+0x8]
	jz	$_688
	add	eax, 64
	jmp	$_689

$_688:	bsr	rax, qword ptr [rsi]
$_689:	mov	qword ptr [rsi], rax
	mov	qword ptr [rsi+0x8], rdx
$_690:	jmp	$_727

$_691:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8]
	mov	rax, qword ptr [rdi+0x50]
	cmp	qword ptr [rdi+0x58], 0
	jz	$_692
	mov	rax, qword ptr [rdi+0x58]
$_692:	mov	qword ptr [rbp-0x8], rax
	mov	esi, ecx
	cmp	dword ptr [rdi+0x38], -2
	jz	$_693
	mov	rcx, qword ptr [rbx+0x10]
	call	tstrlen@PLT
	inc	eax
	add	rax, qword ptr [rbx+0x18]
	jmp	$_696

$_693:	test	rax, rax
	jz	$_694
	mov	rax, qword ptr [rax+0x8]
	jmp	$_696

$_694:	cmp	qword ptr [rdi+0x18], 0
	jz	$_695
	test	byte ptr [rdi+0x40], 0x01
	jnz	$_695
	mov	rax, qword ptr [rdi+0x18]
	mov	rax, qword ptr [rax+0x10]
	jmp	$_696

$_695:	mov	rcx, qword ptr [rbx+0x10]
	call	tstrlen@PLT
	inc	eax
	add	rax, qword ptr [rbx+0x18]
$_696:	mov	rdx, rax
	mov	ecx, esi
	mov	rsi, qword ptr [rbp+0x28]
	jmp	$_723

$_697:	mov	rax, qword ptr [rdi+0x58]
	test	rax, rax
	jz	$_701
	cmp	byte ptr [rax+0x1D], 7
	jz	$_701
	cmp	byte ptr [rax+0x1E], 193
	jnz	$_699
	test	ecx, 0x40
	jnz	$_698
	mov	rcx, rdi
	call	$_007
	jmp	$_728

$_698:	jmp	$_700

$_699:	test	ecx, 0x10
	jnz	$_700
	mov	rcx, rdi
	call	$_007
	jmp	$_728

$_700:	jmp	$_707

$_701:	test	byte ptr [rdi+0x40], 0x08
	jz	$_703
	test	ecx, 0x1
	jnz	$_702
	mov	rcx, rdi
	call	$_007
	jmp	$_728

$_702:	jmp	$_707

$_703:	test	byte ptr [rdi+0x41], 0x02
	jz	$_704
	jmp	$_707

$_704:	test	ecx, 0x20
	jnz	$_707
	test	byte ptr [rdi+0x40], 0x10
	jz	$_705
	mov	rax, -1
	jmp	$_728

$_705:	cmp	ecx, 2
	jnz	$_706
	mov	ecx, 2094
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_706:	mov	ecx, 2009
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_707:	jmp	$_724

$_708:	test	byte ptr [rdi+0x40], 0x01
	jz	$_710
	cmp	qword ptr [rdi+0x50], 0
	jnz	$_710
	test	ecx, 0x4
	jnz	$_709
	mov	rcx, rdi
	call	$_007
	jmp	$_728

$_709:	jmp	$_711

$_710:	test	ecx, 0x2
	jnz	$_711
	mov	ecx, 2026
	call	asmerr@PLT
	jmp	$_728

$_711:	jmp	$_724

$_712:	test	ecx, 0x8
	jne	$_720
	test	byte ptr [rdi+0x40], 0x10
	jne	$_719
	cmp	ecx, 2
	jnz	$_713
	mov	ecx, 2094
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_713:	cmp	ecx, 51
	jnz	$_715
	test	byte ptr [rdi+0x40], 0x01
	jz	$_714
	mov	ecx, 2098
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

	jmp	$_715

$_714:	mov	ecx, 2032
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_715:	test	ecx, 0x20
	jz	$_716
	mov	ecx, 2105
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_716:	test	byte ptr [rdi+0x40], 0x01
	jz	$_717
	mov	ecx, 2081
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

	jmp	$_718

$_717:	mov	ecx, 2009
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_718:	jmp	$_720

$_719:	mov	rax, -1
	jmp	$_728

$_720:	jmp	$_724

$_721:	test	ecx, 0x100
	jnz	$_722
	mov	ecx, 2050
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

$_722:	jmp	$_724

$_723:	cmp	dword ptr [rdi+0x3C], 0
	je	$_697
	cmp	dword ptr [rdi+0x3C], 1
	je	$_708
	cmp	dword ptr [rdi+0x3C], 2
	je	$_712
	cmp	dword ptr [rdi+0x3C], 3
	jz	$_721
$_724:	mov	eax, dword ptr [rbx+0x4]
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8+0x4]
	mov	qword ptr [rsp+0x28], rdx
	mov	eax, dword ptr [rbx+0x4]
	mov	dword ptr [rsp+0x20], eax
	mov	r9, qword ptr [rbp-0x8]
	mov	r8, rdi
	mov	rdx, rsi
	call	$_022
	jmp	$_728

$_725:	mov	rdx, qword ptr [rbx+0x10]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
	jmp	$_728

	jmp	$_727

$_726:	cmp	eax, 91
	je	$_557
	cmp	eax, 40
	je	$_564
	cmp	eax, 43
	je	$_568
	cmp	eax, 45
	je	$_571
	cmp	eax, 46
	je	$_574
	cmp	eax, 58
	je	$_575
	cmp	eax, 42
	je	$_576
	cmp	eax, 47
	je	$_586
	cmp	eax, 5
	je	$_596
	cmp	eax, 4
	je	$_678
	jmp	$_725

$_727:	xor	eax, eax
$_728:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_729:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	and	byte ptr [rcx+0x40], 0xEF
	test	byte ptr [rdx+0x40], 0x10
	jz	$_730
	or	byte ptr [rcx+0x40], 0x10
$_730:	mov	rax, qword ptr [rbp+0x20]
	jmp	$_738

$_731:	mov	rax, qword ptr [rdx+0x50]
	cmp	qword ptr [rdx+0x60], 0
	jz	$_732
	mov	rax, qword ptr [rdx+0x60]
	mov	qword ptr [rcx+0x60], rax
	or	byte ptr [rcx+0x40], 0x80
	jmp	$_734

$_732:	test	byte ptr [r14+0x3], 0x02
	jnz	$_733
	test	rax, rax
	jz	$_733
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_733
	mov	qword ptr [rcx+0x60], 0
	or	byte ptr [rcx+0x40], 0x80
	jmp	$_734

$_733:	test	rax, rax
	jz	$_734
	cmp	byte ptr [rax+0x1E], 195
	jnz	$_734
	cmp	byte ptr [rax+0x49], 0
	jz	$_734
	mov	rax, qword ptr [rax+0x50]
	mov	qword ptr [rcx+0x60], rax
	or	byte ptr [rcx+0x40], 0x80
$_734:	jmp	$_739

$_735:	cmp	dword ptr [rax+0x4], 314
	jz	$_736
	cmp	dword ptr [rax+0x4], 298
	jnz	$_737
$_736:	or	byte ptr [rcx+0x40], 0x10
$_737:	jmp	$_739

$_738:	cmp	byte ptr [rax], 46
	jz	$_731
	cmp	byte ptr [rax], 4
	jz	$_735
$_739:	leave
	ret

$_740:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	imul	eax, ecx, 32
	cmp	byte ptr [rdx+rax], 12
	ja	$_741
	mov	ecx, 2206
	call	qword ptr [fnasmerr+rip]
	jmp	$_742

$_741:	mov	rdx, qword ptr [rdx+rax+0x10]
	mov	ecx, 2008
	call	qword ptr [fnasmerr+rip]
$_742:	leave
	ret

$_743:
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 184
	mov	dword ptr [rbp-0x4], 0
	mov	rdi, rcx
	imul	ebx, dword ptr [rdx], 32
	add	rbx, qword ptr [rbp+0x38]
	imul	eax, dword ptr [rbp+0x40], 32
	add	rax, qword ptr [rbp+0x38]
	mov	qword ptr [rbp-0x80], rax
	mov	al, byte ptr [rbx]
	cmp	dword ptr [rdi+0x3C], -2
	jnz	$_744
	cmp	al, 40
	jz	$_744
	cmp	al, 91
	jz	$_744
	cmp	al, 43
	jz	$_744
	cmp	al, 45
	jz	$_744
	cmp	al, 4
	jz	$_744
	movzx	r9d, byte ptr [rbp+0x48]
	mov	r8, qword ptr [rbp+0x38]
	mov	rcx, rdi
	call	$_203
	mov	dword ptr [rbp-0x4], eax
	mov	rax, qword ptr [rbp+0x30]
	imul	ebx, dword ptr [rax], 32
	add	rbx, qword ptr [rbp+0x38]
$_744:	jmp	$_778

$_745:	mov	rsi, rbx
	cmp	dword ptr [rdi+0x3C], -2
	jz	$_752
	mov	dl, byte ptr [rsi]
	cmp	dl, 43
	jz	$_746
	cmp	dl, 45
	jnz	$_747
$_746:	mov	byte ptr [rsi+0x1], 1
	jmp	$_752

$_747:	cmp	dl, 40
	jnc	$_748
	cmp	dl, 4
	jz	$_748
	cmp	dl, 5
	jnz	$_749
$_748:	cmp	dl, 4
	jnz	$_752
$_749:	cmp	dl, 9
	jnz	$_750
	cmp	byte ptr [rsi+0x1], 123
	jnz	$_750
	mov	rcx, rsi
	call	$_200
	mov	rdx, qword ptr [rbp+0x30]
	inc	dword ptr [rdx]
	add	rbx, 32
	jmp	$_778

	jmp	$_752

$_750:	mov	dword ptr [rbp-0x4], -1
	test	byte ptr [rdi+0x40], 0x10
	jnz	$_751
	sub	rsi, qword ptr [rbp+0x38]
	mov	ecx, 32
	xor	edx, edx
	mov	eax, esi
	div	ecx
	mov	rdx, qword ptr [rbp+0x38]
	mov	ecx, eax
	call	$_740
$_751:	jmp	$_779

$_752:	mov	rdx, qword ptr [rbp+0x30]
	inc	dword ptr [rdx]
	add	rbx, 32
	lea	rcx, [rbp-0x70]
	call	$_179
	mov	r8, rsi
	mov	rdx, rdi
	lea	rcx, [rbp-0x70]
	call	$_729
	cmp	byte ptr [rsi], 40
	jz	$_753
	cmp	byte ptr [rsi], 91
	jne	$_759
$_753:	xor	ecx, ecx
	mov	dword ptr [rbp-0x74], 41
	cmp	byte ptr [rsi], 91
	jnz	$_754
	mov	dword ptr [rbp-0x74], 93
	mov	ecx, 8
	jmp	$_755

$_754:	test	byte ptr [rdi+0x40], 0x80
	jz	$_755
	mov	rax, qword ptr [rdi+0x60]
	mov	qword ptr [rbp-0x10], rax
	or	byte ptr [rbp-0x30], 0x80
$_755:	or	cl, byte ptr [rbp+0x48]
	and	ecx, 0xFFFFFFFB
	mov	byte ptr [rsp+0x20], cl
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x70]
	call	$_743
	mov	dword ptr [rbp-0x4], eax
	mov	rax, qword ptr [rbp+0x30]
	imul	ebx, dword ptr [rax], 32
	add	rbx, qword ptr [rbp+0x38]
	mov	eax, dword ptr [rbp-0x74]
	cmp	al, byte ptr [rbx]
	jz	$_757
	cmp	dword ptr [rbp-0x4], -1
	jz	$_756
	mov	ecx, 2157
	call	qword ptr [fnasmerr+rip]
	mov	rax, qword ptr [rdi+0x50]
	cmp	byte ptr [rbx], 44
	jnz	$_756
	test	rax, rax
	jz	$_756
	cmp	byte ptr [rax+0x1D], 0
	jnz	$_756
	mov	rdx, qword ptr [rax+0x8]
	mov	ecx, 2006
	call	qword ptr [fnasmerr+rip]
$_756:	mov	dword ptr [rbp-0x4], -1
	jmp	$_758

$_757:	mov	rdx, qword ptr [rbp+0x30]
	inc	dword ptr [rdx]
	add	rbx, 32
$_758:	jmp	$_762

$_759:	cmp	byte ptr [rbx], 40
	jz	$_760
	cmp	byte ptr [rbx], 91
	jz	$_760
	cmp	byte ptr [rbx], 43
	jz	$_760
	cmp	byte ptr [rbx], 45
	jz	$_760
	cmp	byte ptr [rbx], 4
	jnz	$_761
$_760:	movzx	ecx, byte ptr [rbp+0x48]
	or	ecx, 0x04
	mov	byte ptr [rsp+0x20], cl
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x70]
	call	$_743
	mov	dword ptr [rbp-0x4], eax
	jmp	$_762

$_761:	movzx	r9d, byte ptr [rbp+0x48]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x70]
	call	$_203
	mov	dword ptr [rbp-0x4], eax
$_762:	mov	rcx, qword ptr [rbp+0x30]
	imul	ebx, dword ptr [rcx], 32
	add	rbx, qword ptr [rbp+0x38]
	movzx	eax, byte ptr [rbx]
	jmp	$_771

$_763:	cmp	eax, 43
	jz	$_764
	cmp	eax, 45
	jnz	$_765
$_764:	mov	byte ptr [rbx+0x1], 1
	jmp	$_770

$_765:	cmp	eax, 40
	jnc	$_766
	cmp	eax, 4
	jz	$_766
	cmp	eax, 5
	jnz	$_767
$_766:	cmp	eax, 4
	jnz	$_770
$_767:	cmp	eax, 9
	jnz	$_768
	cmp	byte ptr [rbx+0x1], 123
	jnz	$_768
	mov	rcx, rbx
	call	$_200
	mov	rdx, qword ptr [rbp+0x30]
	inc	dword ptr [rdx]
	add	rbx, 32
	jmp	$_769

$_768:	mov	dword ptr [rbp-0x4], -1
	test	byte ptr [rdi+0x40], 0x10
	jnz	$_769
	mov	rcx, qword ptr [rbp+0x30]
	mov	rdx, qword ptr [rbp+0x38]
	mov	ecx, dword ptr [rcx]
	call	$_740
$_769:	jmp	$_772

$_770:	mov	rcx, rbx
	call	$_180
	mov	dword ptr [rbp-0x84], eax
	mov	rcx, rsi
	call	$_180
	cmp	eax, dword ptr [rbp-0x84]
	jle	$_772
	mov	cl, byte ptr [rbp+0x48]
	or	cl, 0x04
	mov	byte ptr [rsp+0x20], cl
	mov	r9d, dword ptr [rbp+0x40]
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, qword ptr [rbp+0x30]
	lea	rcx, [rbp-0x70]
	call	$_743
	mov	dword ptr [rbp-0x4], eax
	mov	rax, qword ptr [rbp+0x30]
	imul	ebx, dword ptr [rax], 32
	add	rbx, qword ptr [rbp+0x38]
	movzx	eax, byte ptr [rbx]
$_771:	cmp	dword ptr [rbp-0x4], -1
	jz	$_772
	cmp	rbx, qword ptr [rbp-0x80]
	jnc	$_772
	cmp	eax, 41
	jz	$_772
	cmp	eax, 93
	jne	$_763
$_772:	cmp	dword ptr [rbp-0x4], -1
	jnz	$_776
	test	byte ptr [rbp-0x30], 0x10
	jz	$_776
	jmp	$_774

$_773:	mov	rcx, qword ptr [rbp+0x30]
	inc	dword ptr [rcx]
	add	rbx, 32
$_774:	cmp	rbx, qword ptr [rbp-0x80]
	jnc	$_775
	cmp	byte ptr [rbx], 41
	jz	$_775
	cmp	byte ptr [rbx], 93
	jnz	$_773
$_775:	mov	dword ptr [rbp-0x34], -2
	mov	dword ptr [rbp-0x4], 0
$_776:	cmp	dword ptr [rbp-0x4], -1
	jz	$_777
	mov	r8, rsi
	lea	rdx, [rbp-0x70]
	mov	rcx, rdi
	call	$_551
	mov	dword ptr [rbp-0x4], eax
	mov	rcx, qword ptr [rbp-0x20]
	test	eax, eax
	jnz	$_777
	test	rcx, rcx
	jz	$_777
	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_777
	cmp	byte ptr [rcx+0x1D], 0
	jnz	$_777
	mov	qword ptr [rdi+0x50], rcx
$_777:	test	byte ptr [rbp+0x48], 0x04
	jnz	$_779
$_778:	cmp	dword ptr [rbp-0x4], 0
	jnz	$_779
	cmp	rbx, qword ptr [rbp-0x80]
	jnc	$_779
	cmp	byte ptr [rbx], 41
	jz	$_779
	cmp	byte ptr [rbx], 93
	jne	$_745
$_779:	mov	eax, dword ptr [rbp-0x4]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

EvalOperand:
	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	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 48
	mov	ebx, dword ptr [rcx]
	mov	esi, ebx
	imul	ebx, ebx, 32
	add	rbx, qword ptr [rbp+0x28]
	mov	rcx, qword ptr [rbp+0x38]
	call	$_179
$_780:	cmp	esi, dword ptr [rbp+0x30]
	jge	$_792
	movzx	eax, byte ptr [rbx]
	jmp	$_790

$_781:	mov	eax, dword ptr [rbx+0x4]
	jmp	$_784

$_782:	mov	byte ptr [rbx], 5
	mov	byte ptr [rbx+0x1], 8
	jmp	$_791

	mov	byte ptr [rbx], 5
	mov	byte ptr [rbx+0x1], 7
	jmp	$_791

	mov	byte ptr [rbx], 5
	mov	byte ptr [rbx+0x1], 8
	jmp	$_791

$_783:	mov	byte ptr [rbx], 4
	mov	byte ptr [rbx+0x1], 11
	jmp	$_791

	mov	byte ptr [rbx], 5
	mov	byte ptr [rbx+0x1], 12
	jmp	$_791

	mov	byte ptr [rbx], 5
	mov	byte ptr [rbx+0x1], 13
	jmp	$_791

$_784:	cmp	eax, 678
	jl	$_785
	cmp	eax, 693
	jg	$_785
	lea	r11, [LC041C+rip]
	movzx	r10, byte ptr [r11+rax-0x2A1]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC041B+rip]
	sub	r11, r10
	jmp	r11

$_785:	cmp	eax, 752
	jz	$_782
	cmp	eax, 750
	je	$_782
	cmp	eax, 782
	jz	$_783
	cmp	eax, 783
	jz	$_783
	cmp	eax, 754
	jz	$_783
LC041B: jmp	$_792

$_786:	cmp	dword ptr [rbx+0x4], 338
	jz	$_792
	jmp	$_791

$_787:	cmp	dword ptr [rbx+0x4], 605
	jnz	$_789
	mov	byte ptr [rbx], 6
	mov	dl, byte ptr [r14+0x15]
	mov	eax, 1
	xchg	edx, ecx
	shl	eax, cl
	mov	ecx, edx
	and	eax, 0x70
	mov	eax, 290
	jz	$_788
	mov	eax, 291
$_788:	mov	dword ptr [rbx+0x4], eax
	jmp	$_791

$_789:	jmp	$_792

$_790:	cmp	eax, 1
	je	$_781
	cmp	eax, 7
	jz	$_786
	cmp	eax, 3
	jz	$_787
	cmp	eax, 44
	jz	$_789
$_791:	inc	esi
	add	rbx, 32
	jmp	$_780

$_792:
	mov	rdx, qword ptr [rbp+0x20]
	cmp	esi, dword ptr [rdx]
	jnz	$_793
	xor	eax, eax
	jmp	$_795

$_793:	lea	rax, [asmerr@PLT+rip]
	test	byte ptr [rbp+0x40], 0x01
	jz	$_794
	lea	rax, [noasmerr@PLT+rip]
$_794:	mov	qword ptr [fnasmerr+rip], rax
	movzx	eax, byte ptr [rbp+0x40]
	mov	dword ptr [rsp+0x20], eax
	mov	r9d, esi
	mov	r8, qword ptr [rbp+0x28]
	mov	rcx, qword ptr [rbp+0x38]
	call	$_743
$_795:	leave
	pop	rbx
	pop	rsi
	ret

EmitConstError:
	sub	rsp, 40
	mov	ecx, 2156
	call	asmerr@PLT
	add	rsp, 40
	ret

ExprEvalInit:
	lea	rax, [asmerr@PLT+rip]
	mov	qword ptr [fnasmerr+rip], rax
	xor	eax, eax
	mov	qword ptr [thissym+rip], rax
	mov	qword ptr [nullstruct+rip], rax
	mov	qword ptr [nullmbr+rip], rax
	ret


.SECTION .data
	.ALIGN	16

thissym:
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

nullstruct:
	.quad  0x0000000000000000

nullmbr: .quad	0x0000000000000000

fnasmerr:
	.quad  thissym

	.quad  thissym+0x5A626A0000000000

DS0000:
	.byte  0x00

LC00B9:
	.byte  0x6A, 0x62, 0x5A, 0x52, 0x4A, 0x00, 0x00, 0x00
	.byte  0x02, 0x01, 0x04, 0x05, 0x05, 0x00, 0x00, 0x02
	.byte  0x01, 0x04, 0x05, 0x05, 0x04, 0x05, 0x04, 0x05
	.byte  0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05
	.byte  0x03, 0x03, 0x00

LC0106:
	.byte  0xB2, 0x0C, 0x76, 0x0C, 0x37, 0x0C, 0xFB, 0x0B
	.byte  0xBC, 0x0B, 0x62, 0x0B, 0x03, 0x0B, 0x03, 0x0B
	.byte  0x03, 0x0B, 0x03, 0x0B, 0x7A, 0x0A, 0x2C, 0x0A
	.byte  0x2C, 0x0A, 0x32, 0x08, 0x32, 0x08, 0x32, 0x08
	.byte  0x20, 0x06, 0xE0, 0x05, 0x30, 0x05, 0x30, 0x05
	.byte  0x05, 0x02, 0x05, 0x02, 0x1D, 0x01, 0xBC, 0x00
	.byte  0x46, 0x00

DS0001:
	.byte  0x4C, 0x26, 0x5F, 0x25, 0x30, 0x34, 0x75, 0x00

DS0002:
	.byte  0x40, 0x40, 0x00

DS0003:
	.byte  0x5F, 0x47, 0x4C, 0x4F, 0x42, 0x41, 0x4C, 0x5F
	.byte  0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x5F, 0x54
	.byte  0x41, 0x42, 0x4C, 0x45, 0x5F, 0x00

LC01D1:
	.byte  0x56, 0x54, 0x4D, 0x4B, 0x44, 0x42, 0x3B, 0x39
	.byte  0x32, 0x30, 0x00, 0x01, 0x00, 0x0A, 0x0A, 0x03
	.byte  0x02, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x05
	.byte  0x04, 0x0A, 0x0A, 0x07, 0x06, 0x0A, 0x0A, 0x0A
	.byte  0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x09
	.byte  0x08

LC037D:
	.byte  0x2B, 0x02, 0x80, 0x01, 0x5C, 0x01, 0xE9, 0x00
	.byte  0xD0, 0x00, 0xB7, 0x00, 0x00, 0x00, 0x01, 0x04
	.byte  0x06, 0x06, 0x03, 0x02, 0x05, 0x06, 0x06, 0x06
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00

LC041C:
	.byte  0x93, 0x87, 0x6F, 0x63, 0x00, 0x00, 0x03, 0x04
	.byte  0x04, 0x02, 0x00, 0x03, 0x04, 0x04, 0x04, 0x01
	.byte  0x01, 0x01, 0x01, 0x01, 0x01


.att_syntax prefix
