

.intel_syntax noprefix

.global codegen
.global szNull

.extern CurrProc
.extern get_curr_srcfile
.extern GetLineNumber
.extern LstWrite
.extern vex_flags
.extern opnd_clstab3
.extern opnd_clstab
.extern GetCurrOffset
.extern OperandSize
.extern optable_idx
.extern AddFloatingPointEmulationFixup
.extern AddLinnumDataRef
.extern OutputBytes
.extern OutputByte
.extern asmerr
.extern write_to_file
.extern Options
.extern Parse_Pass


.SECTION .text
	.ALIGN	16

$_001:	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 64
	mov	byte ptr [rbp-0x11], 0
	mov	rdi, qword ptr [rsi+0x68]
	test	byte ptr [Options+0x4+rip], 0x02
	jz	$_002
	call	GetLineNumber@PLT
	mov	ebx, eax
	call	get_curr_srcfile@PLT
	mov	edx, ebx
	mov	ecx, eax
	call	AddLinnumDataRef@PLT
$_002:	movzx	eax, byte ptr [rdi+0x3]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_003
	mov	eax, 128
	jmp	$_004

$_003:	cmp	eax, 6
	jc	$_004
	mov	eax, 6
$_004:	mov	bl, al
	movzx	eax, byte ptr [rdi+0x3]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_005
	xor	eax, eax
$_005:	mov	bh, al
	test	byte ptr [rdi+0x3], 0x20
	jnz	$_006
	cmp	bh, 16
	jz	$_006
	cmp	bh, 18
	jc	$_007
$_006:	mov	eax, dword ptr [rsi+0x14]
	cmp	eax, 1400
	jz	$_007
	cmp	eax, 1407
	jz	$_007
	and	byte ptr [rsi+0x1], 0xDF
$_007:	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_008
	mov	eax, 128
	jmp	$_009

$_008:	cmp	eax, 6
	jc	$_009
	mov	eax, 6
$_009:	mov	cl, al
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x1F
	cmp	eax, 6
	ja	$_010
	xor	eax, eax
$_010:	mov	ch, al
	cmp	bl, cl
	ja	$_012
	test	byte ptr [rdi+0x3], 0x20
	jz	$_011
	test	byte ptr [r14+0x14], 0x20
	jz	$_012
$_011:	cmp	bh, ch
	jbe	$_016
$_012:	mov	eax, dword ptr [rsi+0x14]
	lea	r11, [optable_idx+rip]
	movzx	eax, word ptr [r11+rax*2-0x4E8]
	lea	rax, [r12+rax*8+0x2740]
	movzx	eax, byte ptr [rax+0x3]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_013
	mov	eax, 128
	jmp	$_014

$_013:	cmp	eax, 6
	jc	$_014
	mov	eax, 6
$_014:	mov	ecx, 2085
	cmp	bl, 3
	jnz	$_015
	cmp	al, 3
	ja	$_015
	mov	ecx, 2087
$_015:	call	asmerr@PLT
$_016:	movzx	eax, byte ptr [rdi+0x2]
	and	eax, 0x07
	cmp	byte ptr [r14+0x24], 1
	jnz	$_017
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_017
	test	byte ptr [rdi+0x3], 0x20
	jz	$_017
	cmp	eax, 5
	jz	$_017
	mov	byte ptr [rbp-0x11], 1
	mov	rcx, rsi
	call	AddFloatingPointEmulationFixup@PLT
	jmp	$_018

$_017:	cmp	eax, 6
	jnz	$_018
	or	byte ptr [rsi+0x2], 0x08
$_018:	cmp	byte ptr [rsi+0x10], 0
	jz	$_019
	movzx	ecx, byte ptr [rsi+0x10]
	call	OutputByte@PLT
$_019:	cmp	dword ptr [rsi+0x18], -2
	jz	$_024
	mov	eax, dword ptr [rsi+0x18]
	lea	r11, [optable_idx+rip]
	movzx	eax, word ptr [r11+rax*2-0x4E8]
	lea	rax, [r12+rax*8+0x2740]
	mov	rdx, rax
	movzx	eax, byte ptr [rdx+0x2]
	and	eax, 0x07
	movzx	ecx, byte ptr [rdi+0x2]
	and	ecx, 0x07
	test	byte ptr [r14+0x2], 0x80
	jz	$_020
	cmp	eax, 2
	jnz	$_020
	cmp	ecx, 3
	jnz	$_020
	mov	eax, ecx
$_020:	mov	byte ptr [rbp-0x12], al
	cmp	ecx, eax
	jz	$_023
	cmp	byte ptr [rsi+0x10], 243
	jnz	$_021
	cmp	dword ptr [rsi+0x14], 779
	jz	$_022
$_021:	mov	ecx, 2068
	call	asmerr@PLT
$_022:	jmp	$_024

$_023:	movzx	ecx, byte ptr [rdx+0x6]
	call	OutputByte@PLT
$_024:	test	byte ptr [rdi+0x3], 0x20
	jz	$_031
	movzx	ecx, byte ptr [rdi+0x2]
	and	ecx, 0x07
	cmp	dword ptr [rsi+0x14], 1007
	jnz	$_026
	cmp	byte ptr [rbp-0x11], 0
	jz	$_025
	mov	ecx, 144
	call	OutputByte@PLT
$_025:	jmp	$_031

$_026:	cmp	byte ptr [rbp-0x11], 0
	jnz	$_027
	cmp	ecx, 4
	jnz	$_028
$_027:	mov	ecx, 155
	call	OutputByte@PLT
	jmp	$_031

$_028:	cmp	ecx, 5
	jz	$_031
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_029
	mov	eax, 128
	jmp	$_030

$_029:	cmp	eax, 6
	jc	$_030
	mov	eax, 6
$_030:	cmp	eax, 2
	jnc	$_031
	mov	ecx, 155
	call	OutputByte@PLT
$_031:	mov	al, byte ptr [rdi+0x1]
	jmp	$_042

$_032:	cmp	byte ptr [rsi+0x9], 1
	jc	$_033
	or	byte ptr [rsi+0x1], 0x20
$_033:	jmp	$_043

$_034:	cmp	byte ptr [rsi+0x9], 0
	jnz	$_035
	or	byte ptr [rsi+0x1], 0x20
$_035:	jmp	$_043

$_036:	cmp	byte ptr [rsi+0x9], 1
	jnz	$_037
	or	byte ptr [rsi+0x1], 0x40
$_037:	jmp	$_043

$_038:	cmp	byte ptr [rsi+0x9], 1
	jz	$_039
	or	byte ptr [rsi+0x1], 0x40
$_039:	jmp	$_043

$_040:	and	byte ptr [rsi+0x1], 0xDF
	jmp	$_043

$_041:	or	byte ptr [rsi+0x2], 0x08
	jmp	$_043

$_042:	cmp	al, 1
	jz	$_032
	cmp	al, 2
	jz	$_034
	cmp	al, 3
	jz	$_036
	cmp	al, 4
	jz	$_038
	cmp	al, 29
	jz	$_040
	cmp	al, 6
	jz	$_041
	cmp	al, 30
	jz	$_041
$_043:	test	byte ptr [rsi+0x7], 0x18
	jne	$_052
	jmp	$_051

$_044:	or	byte ptr [rsi+0x1], 0x20
	jmp	$_052

$_045:	mov	ecx, 242
	call	OutputByte@PLT
	jmp	$_052

$_046:	cmp	dword ptr [rsi+0x14], 1440
	jnz	$_050
	cmp	byte ptr [r14+0x4], 2
	jnz	$_049
	mov	byte ptr [rsi+0x2], 0
	test	byte ptr [rsi+0x20], 0x04
	jz	$_047
	or	byte ptr [rsi+0x1], 0x40
	jmp	$_048

$_047:	test	byte ptr [rsi+0x20], 0x02
	jz	$_048
	mov	ecx, 2024
	call	asmerr@PLT
$_048:	jmp	$_050

$_049:	test	byte ptr [rsi+0x1], 0x20
	jz	$_050
	and	byte ptr [rsi+0x1], 0xDF
	or	byte ptr [rsi+0x1], 0x40
$_050:	mov	ecx, 243
	call	OutputByte@PLT
	jmp	$_052

$_051:	cmp	al, 19
	jz	$_044
	cmp	al, 35
	jz	$_044
	cmp	al, 37
	jz	$_044
	cmp	al, 23
	jz	$_045
	cmp	al, 40
	jz	$_045
	cmp	al, 26
	jz	$_046
	cmp	al, 5
	jz	$_050
	cmp	al, 41
	jz	$_050
	cmp	al, 43
	jz	$_050
$_052:	test	byte ptr [rsi+0x1], 0x40
	jz	$_053
	test	byte ptr [rsi], 0x80
	jnz	$_053
	test	byte ptr [rdi+0x4], 0x20
	jnz	$_053
	mov	ecx, 103
	call	OutputByte@PLT
$_053:	test	byte ptr [rsi+0x1], 0x20
	jz	$_057
	movzx	eax, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_054
	mov	eax, 128
	jmp	$_055

$_054:	cmp	eax, 6
	jc	$_055
	mov	eax, 6
$_055:	cmp	eax, 3
	jnc	$_056
	mov	ecx, 2087
	call	asmerr@PLT
$_056:	mov	ecx, 102
	call	OutputByte@PLT
$_057:	cmp	dword ptr [rsi+0x1C], -2
	jz	$_058
	mov	eax, dword ptr [rsi+0x1C]
	lea	rcx, [sr_prefix+rip]
	mov	ecx, dword ptr [rcx+rax]
	call	OutputByte@PLT
$_058:	test	byte ptr [rdi+0x2], 0x80
	jz	$_059
	mov	al, byte ptr [rsi+0xA]
	mov	byte ptr [rbp-0x12], al
	mov	ah, al
	mov	dl, al
	and	ah, 0xC0
	shr	dl, 3
	and	dl, 0x07
	shl	al, 3
	and	al, 0x38
	or	al, dl
	or	al, ah
	mov	byte ptr [rsi+0xA], al
	mov	al, byte ptr [rsi+0x3]
	mov	cl, al
	mov	dl, al
	and	cl, 0x20
	and	dl, 0x40
	and	al, 0x10
	shr	dl, 2
	shl	al, 2
	or	al, dl
	or	al, cl
	mov	byte ptr [rsi+0x3], al
	mov	al, byte ptr [rsi+0x2]
	mov	cl, al
	mov	dl, al
	and	cl, 0xFA
	and	dl, 0x04
	shr	dl, 2
	and	al, 0x01
	shl	al, 2
	or	al, dl
	or	al, cl
	mov	byte ptr [rsi+0x2], al
$_059:	test	byte ptr [rsi+0x7], 0x18
	je	$_167
	mov	byte ptr [rbp-0x13], 0
	test	byte ptr [rsi+0x1], 0x80
	jz	$_061
	mov	al, byte ptr [rsi+0xA]
	and	al, 0xC0
	cmp	al, 192
	jnz	$_060
	test	byte ptr [rdi+0x2], 0x80
	jz	$_060
	test	byte ptr [rdi+0xA], 0x80
	jnz	$_060
	add	rdi, 8
	mov	qword ptr [rsi+0x68], rdi
	mov	al, byte ptr [rbp-0x12]
	mov	byte ptr [rsi+0xA], al
	inc	byte ptr [rbp-0x13]
	jmp	$_061

$_060:	lea	rdx, [DS0000+rip]
	mov	ecx, 2008
	call	asmerr@PLT
$_061:	test	byte ptr [rsi+0x1], 0x08
	jz	$_062
	mov	ecx, 98
	call	OutputByte@PLT
	jmp	$_063

$_062:	test	byte ptr [rsi+0x7], 0x40
	jz	$_063
	cmp	byte ptr [rbp-0x13], 0
	jnz	$_063
	mov	al, byte ptr [rsi+0x2]
	mov	ah, byte ptr [rsi+0xA]
	and	eax, 0xC00B
	cmp	eax, 49153
	jnz	$_063
	add	rdi, 8
	mov	qword ptr [rsi+0x68], rdi
	mov	al, byte ptr [rbp-0x12]
	mov	byte ptr [rsi+0xA], al
	inc	byte ptr [rbp-0x13]
$_063:	movzx	ebx, byte ptr [rsi+0x6]
	and	bl, 0x80
	shl	ebx, 8
	mov	al, byte ptr [rdi+0x1]
	jmp	$_064

	or	bl, 0x01
	jmp	LC0068

	or	bl, 0x80
	or	bl, 0x02
	jmp	LC0068

	or	bl, 0x03
	jmp	LC0068

	or	bl, 0x05
	jmp	LC0068

	or	bl, 0x06
	jmp	LC0068

$_064:	cmp	al, 7
	jl	LC0068
	cmp	al, 43
	jg	LC0068
	movsx	r10, al
	lea	r11, [LC0079+rip]
	movzx	r10, byte ptr [r11+r10]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC0068+rip]
	sub	r11, r10
	jmp	r11

LC0068: jmp	$_065

	or	bh, 0x01
	jmp	LC0081

	or	bh, 0x02
	jmp	LC0081

	or	bh, 0x03
	jmp	LC0081

	or	bh, 0x04
	jmp	LC0081

	or	bh, 0x05
	jmp	LC0081

$_065:	cmp	al, 17
	jl	LC0081
	cmp	al, 43
	jg	LC0081
	movsx	r10, al
	lea	r11, [LC0090+rip]
	movzx	r10, byte ptr [r11+r10-0xB]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC0081+rip]
	sub	r11, r10
	jmp	r11

LC0081: cmp	byte ptr [rsi+0xE], 0
	jz	$_066
	mov	dl, byte ptr [rsi+0xE]
	mov	al, 16
	sub	al, dl
	shl	al, 3
	mov	dl, al
	and	dl, 0x80
	shr	dl, 5
	or	al, dl
	shl	dl, 3
	or	bh, al
	or	byte ptr [rsi+0x3], dl
	jmp	$_072

$_066:	cmp	byte ptr [rsi+0xD], 0
	jz	$_071
	or	bh, 0x78
	mov	al, byte ptr [rsi+0xD]
	dec	al
	mov	cl, al
	mov	dl, al
	and	al, 0x07
	and	cl, 0x08
	and	dl, 0x10
	mov	ah, byte ptr [rsi+0xA]
	and	ah, 0xC7
	jmp	$_069

$_067:	or	byte ptr [rsi+0xA], 0x04
	or	al, cl
	shl	al, 3
	xor	bh, al
	xor	cl, cl
	shl	dl, 1
	jmp	$_070

$_068:	or	al, cl
	shl	al, 3
	xor	bh, al
	xor	cl, cl
	shl	dl, 1
	jmp	$_070

$_069:	cmp	ah, 4
	jz	$_067
	cmp	ah, 68
	jz	$_067
	cmp	ah, 132
	jz	$_067
	jmp	$_068

$_070:	or	byte ptr [rsi+0x2], cl
	or	byte ptr [rsi+0x3], dl
	jmp	$_072

$_071:	or	bh, 0x68
	test	byte ptr [rdi+0x4], 0x20
	jnz	$_072
	or	bh, 0x10
$_072:	mov	al, byte ptr [rsi+0x2]
	cmp	byte ptr [rbp-0x13], 0
	jz	$_075
	test	byte ptr [rsi+0x1], 0x08
	jnz	$_073
	mov	bl, 197
	jmp	$_074

$_073:	mov	al, byte ptr [rsi+0x2]
	not	al
	and	al, 0x07
	shl	al, 5
	or	bl, al
$_074:	and	bh, 0x7F
	jmp	$_080

$_075:	cmp	byte ptr [rdi+0x1], 31
	jnc	$_076
	test	al, 0x0B
	jz	$_078
$_076:	test	byte ptr [rsi+0x1], 0x08
	jnz	$_077
	mov	ecx, 196
	call	OutputByte@PLT
$_077:	mov	al, byte ptr [rsi+0x2]
	mov	ah, al
	not	al
	and	al, 0x07
	shl	al, 5
	and	ah, 0x08
	shl	ah, 4
	or	bx, ax
	jmp	$_080

$_078:	mov	al, byte ptr [rsi+0x2]
	not	al
	and	al, 0x07
	shl	al, 5
	or	bl, al
	test	byte ptr [rsi+0x2], 0x04
	jnz	$_079
	or	bh, 0x80
$_079:	test	byte ptr [rsi+0x1], 0x08
	jnz	$_080
	mov	bl, 197
$_080:	test	byte ptr [rsi+0x1], 0x08
	je	$_153
	or	bh, 0x04
	and	bh, 0x7F
	test	byte ptr [rsi+0x3], 0x40
	jnz	$_081
	or	bl, 0x10
$_081:	mov	al, 4
	test	byte ptr [rsi+0x7], 0x80
	jnz	$_082
	test	byte ptr [rdi+0x4], 0x80
	jz	$_083
$_082:	or	bh, 0x80
	add	al, al
$_083:	mov	byte ptr [rbp-0xF], al
	test	byte ptr [rsi+0x3], 0x20
	jnz	$_084
	or	byte ptr [rsi+0x4], 0x08
$_084:	mov	al, byte ptr [rsi+0xA]
	and	al, 0xC0
	cmp	al, 192
	jnz	$_094
	test	byte ptr [rsi+0x3], 0x10
	jz	$_085
	and	bl, 0xBF
$_085:	test	byte ptr [rsi+0x5], 0x02
	jnz	$_093
	mov	eax, dword ptr [rsi+0x20]
	test	eax, 0x100000
	jnz	$_086
	test	byte ptr [rsi+0x38], 0x70
	jz	$_087
$_086:	or	eax, dword ptr [rsi+0x38]
$_087:	test	byte ptr [rsi+0xF], 0x02
	jz	$_088
	or	eax, 0x40
	jmp	$_089

$_088:	test	byte ptr [rsi+0xF], 0x01
	jz	$_089
	or	eax, 0x20
$_089:	jmp	$_092

$_090:	or	byte ptr [rsi+0x4], 0x40
	jmp	$_093

$_091:	or	byte ptr [rsi+0x4], 0x20
	jmp	$_093

$_092:	test	eax, 0x40
	jnz	$_090
	test	eax, 0x20
	jnz	$_091
$_093:	jmp	$_140

$_094:	test	byte ptr [rsi+0x3], 0x10
	jz	$_095
	or	bl, 0x08
$_095:	xor	eax, eax
	xor	edx, edx
	xor	ecx, ecx
	test	dword ptr [rsi+0x38], 0x607F00
	jz	$_096
	mov	edx, 24
	mov	ecx, 4
$_096:	mov	dword ptr [rbp-0x4], edx
	movzx	eax, byte ptr [rdi]
	lea	rdx, [opnd_clstab+rip]
	lea	rdx, [rdx+rax*8]
	mov	eax, dword ptr [rdx+rcx]
	test	byte ptr [rsi+0x6], 0x20
	jz	$_097
	test	ecx, ecx
	jz	$_097
	or	eax, dword ptr [rdx]
$_097:	mov	edx, dword ptr [rbp-0x4]
	or	eax, dword ptr [rsi+rdx+0x20]
	test	byte ptr [rsi+0x6], 0x01
	jz	$_099
	test	edx, edx
	jz	$_098
	or	eax, dword ptr [rsi+0x20]
	jmp	$_099

$_098:	or	eax, dword ptr [rsi+0x38]
$_099:	test	byte ptr [rsi+0xF], 0x02
	jz	$_100
	or	eax, 0x40
	jmp	$_101

$_100:	test	byte ptr [rsi+0xF], 0x01
	jz	$_101
	or	eax, 0x20
$_101:	mov	dword ptr [rbp-0x8], eax
	xor	eax, eax
	test	byte ptr [rsi+0x5], 0x01
	jz	$_102
	mov	cl, byte ptr [rsi+0x5]
	shr	cl, 5
	test	cl, cl
	jz	$_102
	mov	al, 2
	shl	al, cl
$_102:	mov	byte ptr [rbp-0x10], al
	xor	eax, eax
	mov	cl, byte ptr [rsi+0x8]
	cmp	cl, 63
	jnz	$_103
	mov	al, 64
	jmp	$_104

$_103:	test	cl, 0x80
	jnz	$_104
	and	cl, 0x1F
	inc	cl
	mov	al, cl
$_104:	mov	byte ptr [rbp-0xD], al
	cmp	al, 64
	jnz	$_105
	or	byte ptr [rbp-0x7], 0x40
	jmp	$_106

$_105:	cmp	al, 32
	jnz	$_106
	or	byte ptr [rbp-0x7], 0x20
$_106:	mov	al, 16
	test	dword ptr [rbp-0x8], 0x4040
	jz	$_107
	mov	al, 64
	jmp	$_108

$_107:	test	dword ptr [rbp-0x8], 0x2020
	jz	$_108
	mov	al, 32
$_108:	mov	byte ptr [rbp-0xE], al
	cmp	byte ptr [rbp-0xD], 0
	jnz	$_112
	test	byte ptr [rsi+0x5], 0x01
	jnz	$_109
	mov	byte ptr [rbp-0xD], al
	jmp	$_111

$_109:	mov	al, byte ptr [rbp-0xF]
	mov	byte ptr [rbp-0xD], al
	cmp	byte ptr [rbp-0x10], 0
	jz	$_111
	mul	byte ptr [rbp-0x10]
	mov	byte ptr [rbp-0xE], al
	cmp	al, 64
	ja	$_110
	cmp	al, 16
	jnc	$_111
$_110:	lea	rdx, [DS0001+rip]
	mov	ecx, 2008
	call	asmerr@PLT
$_111:	jmp	$_114

$_112:	cmp	byte ptr [rbp-0x10], 0
	jz	$_114
	mov	al, byte ptr [rbp-0xD]
	mul	byte ptr [rbp-0x10]
	mov	byte ptr [rbp-0xE], al
	cmp	al, 64
	ja	$_113
	cmp	al, 16
	jnc	$_114
$_113:	lea	rdx, [DS0001+rip]
	mov	ecx, 2008
	call	asmerr@PLT
$_114:	xor	eax, eax
	movzx	ecx, byte ptr [rdi+0x4]
	and	ecx, 0x0F
	jmp	$_133

	test	byte ptr [rsi+0x4], 0x10
	jz	$_115
	cmp	byte ptr [rbp-0xE], 32
	jnz	$_115
	cmp	byte ptr [rbp-0x10], 0
	jnz	$_115
	mov	byte ptr [rbp-0xE], 64
$_115:	test	byte ptr [rsi+0x4], 0x10
	jz	$_117
	movzx	eax, byte ptr [rbp-0xF]
	cmp	byte ptr [rbp-0xD], 2
	jnz	$_116
	mov	eax, 2
$_116:	jmp	$_134

$_117:	movzx	eax, byte ptr [rbp-0xE]
	jmp	$_134

	test	byte ptr [rsi+0x4], 0x10
	jz	$_119
	mov	eax, 4
	cmp	byte ptr [rbp-0xD], 2
	jnz	$_118
	mov	eax, 2
$_118:	jmp	$_120

$_119:	movzx	eax, byte ptr [rbp-0xE]
	shr	eax, 1
$_120:	jmp	$_134

	mov	cl, byte ptr [rbp-0xD]
	mov	edx, dword ptr [rsi+0x14]
	jmp	$_123

$_121:	mov	cl, 1
	jmp	$_124

$_122:	mov	cl, 2
	jmp	$_124

$_123:	cmp	edx, 2430
	jz	$_121
	cmp	edx, 2429
	jz	$_121
	cmp	edx, 2440
	jz	$_122
	cmp	edx, 2439
	jz	$_122
$_124:	mov	al, byte ptr [rbp-0xF]
	cmp	cl, 1
	jz	$_125
	cmp	cl, 2
	jnz	$_126
$_125:	mov	al, cl
$_126:	jmp	$_134

	movzx	eax, byte ptr [rbp-0xF]
	movzx	ecx, byte ptr [rbp-0xD]
	cmp	ecx, 4
	jz	$_127
	cmp	ecx, 8
	jnz	$_128
$_127:	mov	eax, ecx
$_128:	jmp	$_134

	mov	eax, 8
	cmp	byte ptr [rbp-0xF], 8
	jnz	$_129
	add	eax, eax
$_129:	jmp	$_134

	mov	eax, 16
	cmp	byte ptr [rbp-0xF], 8
	jnz	$_130
	add	eax, eax
$_130:	jmp	$_134

	movzx	eax, byte ptr [rbp-0xD]
	jmp	$_134

	movzx	eax, byte ptr [rbp-0xE]
	shr	eax, 3
	jmp	$_134

	movzx	eax, byte ptr [rbp-0xE]
	shr	eax, 2
	cmp	byte ptr [rbp-0xD], 2
	jnz	$_131
	mov	eax, 2
$_131:	jmp	$_134

	movzx	eax, byte ptr [rbp-0xE]
	shr	eax, 1
	jmp	$_134

	mov	eax, 16
	jmp	$_134

	movzx	eax, byte ptr [rbp-0xE]
	cmp	eax, 16
	jnz	$_132
	mov	eax, 8
$_132:	jmp	$_134

LC0100: xor	eax, eax
	jmp	$_134

$_133:	cmp	ecx, 1
	jl	LC0100
	cmp	ecx, 15
	jg	LC0100
	lea	r11, [LC0101+rip]
	movzx	r10, word ptr [r11+rcx*2-0x2]
	lea	r11, [LC0100+rip]
	sub	r11, r10
	jmp	r11

$_134:	test	byte ptr [rsi+0x5], 0x02
	jnz	$_138
	cmp	byte ptr [rbp-0xE], 64
	jz	$_135
	test	byte ptr [rsi+0xF], 0x08
	jz	$_136
$_135:	or	byte ptr [rsi+0x4], 0x40
	jmp	$_138

$_136:	cmp	byte ptr [rbp-0xE], 32
	jz	$_137
	test	byte ptr [rsi+0xF], 0x04
	jz	$_138
$_137:	or	byte ptr [rsi+0x4], 0x20
$_138:	mov	edx, dword ptr [rbp-0x4]
	test	eax, eax
	jz	$_139
	cmp	dword ptr [rsi+rdx+0x30], 0
	jz	$_139
	or	byte ptr [rsi+0xA], 0x80
	and	byte ptr [rsi+0xA], 0xBF
	mov	ecx, dword ptr [rsi+rdx+0x30]
	dec	eax
	and	ecx, eax
	jnz	$_139
	lea	ecx, [rax+0x1]
	mov	eax, dword ptr [rsi+rdx+0x30]
	cdq
	idiv	ecx
	mov	edx, dword ptr [rbp-0x4]
	cmp	eax, -128
	jl	$_139
	cmp	eax, 127
	jg	$_139
	mov	dword ptr [rsi+rdx+0x30], eax
	and	byte ptr [rsi+0xA], 0x7F
	or	byte ptr [rsi+0xA], 0x40
$_139:	test	byte ptr [rdi+0x4], 0x20
	jz	$_140
	mov	cl, byte ptr [rsi+0xC]
	or	ebx, 0x7840
	or	byte ptr [rsi+0x4], 0x08
	mov	al, cl
	and	al, 0x08
	and	cl, 0x10
	shl	al, 3
	shr	cl, 1
	xor	bl, al
	xor	byte ptr [rsi+0x4], cl
	mov	byte ptr [rsi+0xC], 0
$_140:	mov	ecx, ebx
	call	OutputByte@PLT
	shr	ebx, 8
	test	byte ptr [rdi+0x4], 0x40
	jz	$_141
	test	byte ptr [rsi+0x7], 0x80
	jnz	$_141
	and	bl, 0x7F
$_141:	mov	ecx, ebx
	call	OutputByte@PLT
	mov	bl, byte ptr [rsi+0x4]
	test	byte ptr [rdi+0x5], 0x80
	jz	$_142
	test	byte ptr [rsi+0x5], 0x02
	jnz	$_142
	and	bl, 0x9F
	jmp	$_143

$_142:	test	byte ptr [rsi+0x5], 0x04
	jz	$_143
	test	bl, 0x40
	jz	$_143
	and	bl, 0xBF
$_143:	mov	ecx, ebx
	call	OutputByte@PLT
	test	byte ptr [rsi+0x4], 0x07
	jz	$_144
	test	byte ptr [rdi+0x5], 0x01
	jnz	$_144
	mov	ecx, 2152
	call	asmerr@PLT
$_144:	test	byte ptr [rsi+0x4], 0x80
	jz	$_145
	test	byte ptr [rdi+0x5], 0x10
	jnz	$_145
	mov	ecx, 2152
	call	asmerr@PLT
$_145:	test	byte ptr [rsi+0x5], 0x01
	jz	$_146
	test	byte ptr [rdi+0x5], 0x02
	jnz	$_146
	mov	ecx, 2152
	call	asmerr@PLT
$_146:	test	byte ptr [rsi+0x5], 0x04
	jz	$_149
	test	byte ptr [rdi+0x5], 0x20
	jnz	$_147
	test	byte ptr [rdi+0x5], 0x04
	jz	$_148
$_147:	test	byte ptr [rdi+0x5], 0x20
	jz	$_149
	test	byte ptr [rsi+0x5], 0x10
	jnz	$_149
$_148:	mov	ecx, 2024
	call	asmerr@PLT
$_149:	test	byte ptr [rsi+0x5], 0x02
	jz	$_152
	test	byte ptr [rdi+0x5], 0x40
	jnz	$_150
	test	byte ptr [rdi+0x5], 0x08
	jz	$_151
$_150:	test	byte ptr [rdi+0x5], 0x40
	jz	$_152
	test	byte ptr [rsi+0x5], 0x10
	jnz	$_152
$_151:	mov	ecx, 2024
	call	asmerr@PLT
$_152:	jmp	$_166

$_153:	mov	eax, dword ptr [rsi+0x20]
	test	eax, 0x20
	jnz	$_154
	test	dword ptr [rsi+0x38], 0x2020
	jnz	$_154
	test	eax, eax
	jnz	$_155
	test	byte ptr [rsi+0x6], 0x01
	jz	$_155
$_154:	or	bh, 0x04
$_155:	test	byte ptr [rsi+0x4], 0x10
	jz	$_156
	mov	ecx, 2152
	call	asmerr@PLT
$_156:	mov	ecx, ebx
	call	OutputByte@PLT
	shr	ebx, 8
	test	byte ptr [rdi+0x4], 0x10
	jnz	$_157
	test	byte ptr [rdi+0x4], 0x20
	je	$_165
$_157:	mov	ecx, dword ptr [rsi+0x14]
	test	byte ptr [rdi+0x4], 0x20
	jz	$_158
	mov	ecx, 1728
$_158:	jmp	$_164

$_159:	mov	al, byte ptr [rbp-0x12]
	not	al
	shl	al, 3
	and	al, 0x38
	and	bl, 0xC7
	or	bl, al
	test	byte ptr [rsi+0x2], 0x04
	jz	$_160
	and	bl, 0xBF
$_160:	cmp	ecx, 1736
	jnz	$_161
	and	byte ptr [rsi+0xA], 0xF7
	jmp	$_162

$_161:	and	byte ptr [rsi+0xA], 0xCF
$_162:	jmp	$_165

$_163:	mov	al, byte ptr [rsi+0xC]
	shl	al, 3
	not	al
	and	al, 0x38
	and	bl, 0xC7
	or	bl, al
	mov	al, byte ptr [rsi+0xC]
	shr	al, 4
	or	bl, al
	mov	byte ptr [rsi+0xC], 0
	jmp	$_165

$_164:	cmp	ecx, 1735
	jz	$_159
	cmp	ecx, 1737
	jz	$_159
	cmp	ecx, 1736
	jz	$_159
	cmp	ecx, 1728
	jz	$_163
	cmp	ecx, 1729
	jz	$_163
	cmp	ecx, 1730
	jz	$_163
	cmp	ecx, 1731
	jz	$_163
	cmp	ecx, 1732
	jz	$_163
$_165:	mov	ecx, ebx
	call	OutputByte@PLT
$_166:	jmp	$_179

$_167:	test	byte ptr [rsi+0x1], 0x10
	jz	$_168
	mov	ecx, 213
	call	OutputByte@PLT
	mov	cl, byte ptr [rsi+0x2]
	and	cl, 0x0F
	or	cl, byte ptr [rsi+0x3]
	mov	byte ptr [rsi+0x2], 0
	call	OutputByte@PLT
$_168:	cmp	byte ptr [rsi+0x2], 0
	jz	$_174
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_173

$_169:	jmp	$_174

$_170:	and	byte ptr [rsi+0x2], 0x04
	jz	$_174
$_171:	cmp	byte ptr [rsi+0x9], 2
	jz	$_172
	mov	ecx, 2024
	call	asmerr@PLT
$_172:	mov	cl, byte ptr [rsi+0x2]
	or	cl, 0x40
	call	OutputByte@PLT
	jmp	$_174

$_173:	cmp	eax, 1413
	jz	$_169
	cmp	eax, 1343
	jz	$_169
	cmp	eax, 1351
	jz	$_169
	cmp	eax, 1352
	jz	$_169
	cmp	eax, 1353
	jz	$_169
	cmp	eax, 1434
	jz	$_170
	cmp	eax, 1435
	jz	$_170
	jmp	$_171

$_174:	cmp	byte ptr [rdi+0x1], 16
	jc	$_179
	mov	ecx, 15
	call	OutputByte@PLT
	mov	al, byte ptr [rdi+0x1]
	jmp	$_178

$_175:	mov	ecx, 15
	call	OutputByte@PLT
	jmp	$_179

$_176:	mov	ecx, 56
	call	OutputByte@PLT
	jmp	$_179

$_177:	mov	ecx, 58
	call	OutputByte@PLT
	jmp	$_179

$_178:	cmp	al, 18
	jz	$_175
	cmp	al, 31
	jz	$_176
	cmp	al, 40
	jz	$_176
	cmp	al, 41
	jz	$_176
	cmp	al, 35
	jz	$_176
	cmp	al, 33
	jz	$_177
	cmp	al, 43
	jz	$_177
	cmp	al, 37
	jz	$_177
$_179:	xor	ecx, ecx
	test	byte ptr [rsi], 0x01
	jz	$_180
	inc	ecx
$_180:	movzx	eax, byte ptr [rdi+0x2]
	and	eax, 0x70
	shr	eax, 4
	jmp	$_196

$_181:	mov	al, byte ptr [rsi+0xA]
	and	al, 0x3F
	or	al, byte ptr [rdi+0x6]
	mov	ecx, eax
	call	OutputByte@PLT
	jmp	$_197

$_182:	mov	al, byte ptr [rdi+0x6]
	or	al, cl
	mov	ecx, eax
	call	OutputByte@PLT
	jmp	$_197

$_183:	xor	ecx, ecx
$_184:	cmp	byte ptr [rdi+0x1], 18
	jz	$_185
	mov	al, byte ptr [rdi+0x6]
	or	al, cl
	or	al, byte ptr [rsi+0xC]
	mov	ecx, eax
	call	OutputByte@PLT
$_185:	mov	bl, byte ptr [rdi+0x7]
	or	bl, byte ptr [rsi+0xA]
	test	byte ptr [rsi], 0x80
	jz	$_186
	and	bl, 0x7F
$_186:	mov	eax, dword ptr [rsi+0x14]
	jmp	$_189

$_187:	mov	bl, 248
	or	bl, byte ptr [rsi+0xA]
	jmp	$_190

$_188:	mov	ecx, 246
	call	OutputByte@PLT
	jmp	$_190

$_189:	cmp	eax, 1413
	jz	$_187
	cmp	eax, 1414
	jz	$_188
$_190:	mov	ecx, ebx
	call	OutputByte@PLT
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_191
	test	byte ptr [rsi+0x1], 0x40
	jz	$_197
$_191:	cmp	byte ptr [rsi+0x9], 1
	jnz	$_192
	test	byte ptr [rsi+0x1], 0x40
	jnz	$_197
$_192:	and	bl, 0xC7
	jmp	$_194

$_193:	movzx	ecx, byte ptr [rsi+0xB]
	call	OutputByte@PLT
	jmp	$_195

$_194:	cmp	bl, 4
	jz	$_193
	cmp	bl, 68
	jz	$_193
	cmp	bl, 132
	jz	$_193
$_195:	jmp	$_197

$_196:	cmp	eax, 3
	je	$_181
	cmp	eax, 1
	je	$_182
	cmp	eax, 2
	je	$_183
	jmp	$_184

$_197:
	leave
	pop	rbx
	pop	rdi
	ret

$_198:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	xor	ebx, ebx
	mov	rdi, qword ptr [rsi+0x68]
	mov	eax, dword ptr [rsi+0x14]
	jmp	$_202

$_199:	cmp	dword ptr [rsi+0x48], 0
	je	$_236
	cmp	dword ptr [rbp+0x28], 2
	je	$_236
	jmp	$_203

$_200:	cmp	dword ptr [rsi+0x48], 0
	je	$_236
	cmp	dword ptr [rbp+0x28], 0
	je	$_236
	cmp	dword ptr [rbp+0x28], 2
	je	$_236
	jmp	$_203

$_201:	jmp	$_236

	jmp	$_203

$_202:	cmp	eax, 1726
	jz	$_199
	cmp	eax, 1727
	jz	$_199
	cmp	eax, 1733
	jz	$_199
	cmp	eax, 1734
	jz	$_199
	cmp	eax, 1728
	jz	$_200
	cmp	eax, 1729
	jz	$_200
	cmp	eax, 1730
	jz	$_200
	cmp	eax, 1731
	jz	$_200
	cmp	eax, 1732
	jz	$_200
	cmp	eax, 841
	jz	$_201
	cmp	eax, 842
	jz	$_201
$_203:	movzx	eax, byte ptr [rdi+0x2]
	and	eax, 0x07
	cmp	eax, 2
	je	$_236
	cmp	eax, 3
	je	$_236
	mov	eax, dword ptr [rbp+0x20]
	jmp	$_231

$_204:	mov	ebx, 1
	jmp	$_232

$_205:	mov	ebx, 2
	jmp	$_232

$_206:	mov	ebx, 4
	jmp	$_232

$_207:	mov	ebx, 6
	jmp	$_232

$_208:	mov	ebx, 8
	jmp	$_232

$_209:	mov	al, byte ptr [rsi+0xA]
	and	eax, 0xC0
	jmp	$_229

$_210:	mov	ebx, 1
	jmp	$_230

$_211:	cmp	byte ptr [rsi+0x9], 0
	jnz	$_212
	test	byte ptr [rsi+0x1], 0x40
	jz	$_213
$_212:	cmp	byte ptr [rsi+0x9], 1
	jnz	$_215
	test	byte ptr [rsi+0x1], 0x40
	jz	$_215
$_213:	mov	al, byte ptr [rsi+0xA]
	and	al, 0x07
	cmp	al, 6
	jnz	$_214
	mov	ebx, 2
$_214:	jmp	$_224

$_215:	mov	al, byte ptr [rdi+0x6]
	and	al, 0xFC
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_216
	cmp	al, 160
	jnz	$_216
	cmp	byte ptr [rdi+0x1], 0
	jnz	$_216
	mov	ebx, 8
	jmp	$_224

$_216:	mov	al, byte ptr [rsi+0xA]
	and	eax, 0x07
	jmp	$_223

$_217:	mov	al, byte ptr [rsi+0xB]
	and	al, 0x07
	cmp	al, 5
	jnz	$_224
$_218:	mov	ebx, 4
	imul	ecx, dword ptr [rbp+0x28], 24
	mov	eax, dword ptr [rsi+rcx+0x30]
	mov	edx, dword ptr [rsi+rcx+0x34]
	xor	ecx, ecx
	test	edx, edx
	jnz	$_219
	cmp	eax, 2147483648
	jc	$_221
$_219:	inc	ecx
	cmp	edx, -1
	jc	$_221
	cmp	edx, -1
	jnz	$_220
	cmp	eax, 2147483648
	jc	$_221
$_220:	xor	ecx, ecx
$_221:	cmp	byte ptr [rsi+0x9], 2
	jnz	$_222
	test	ecx, ecx
	jz	$_222
	mov	ecx, 2070
	call	asmerr@PLT
$_222:	jmp	$_224

$_223:	cmp	eax, 4
	jz	$_217
	cmp	eax, 5
	jz	$_218
$_224:	jmp	$_230

$_225:	mov	ebx, 4
	cmp	byte ptr [rsi+0x9], 0
	jnz	$_226
	test	byte ptr [rsi+0x1], 0x40
	jz	$_227
$_226:	cmp	byte ptr [rsi+0x9], 1
	jnz	$_228
	test	byte ptr [rsi+0x1], 0x40
	jz	$_228
$_227:	mov	ebx, 2
$_228:	jmp	$_230

$_229:	cmp	eax, 64
	je	$_210
	cmp	eax, 0
	je	$_211
	cmp	eax, 128
	jz	$_225
$_230:	jmp	$_232

$_231:	test	eax, 0x10000
	jne	$_204
	test	eax, 0x20000
	jne	$_205
	test	eax, 0x40000
	jne	$_206
	test	eax, 0x40000000
	jne	$_207
	test	eax, 0x80000
	jne	$_208
	test	eax, 0x607F00
	jne	$_209
$_232:	mov	edi, ebx
	imul	ebx, dword ptr [rbp+0x28], 24
	test	edi, edi
	je	$_236
	cmp	qword ptr [rsi+rbx+0x28], 0
	jz	$_235
	cmp	dword ptr [Parse_Pass+rip], 0
	jbe	$_234
	mov	eax, 1
	mov	rdx, qword ptr [rsi+rbx+0x28]
	mov	cl, byte ptr [rdx+0x18]
	shl	eax, cl
	mov	rcx, qword ptr [r14+0x1B8]
	movzx	ecx, word ptr [rcx+0x8]
	test	ecx, eax
	jz	$_234
	mov	rcx, qword ptr [r14+0x1B8]
	lea	rax, [rcx+0xA]
	lea	rcx, [szNull+rip]
	cmp	qword ptr [rdx+0x30], 0
	jz	$_233
	mov	rcx, qword ptr [rdx+0x30]
	mov	rcx, qword ptr [rcx+0x8]
$_233:	mov	r8, rcx
	mov	rdx, rax
	mov	ecx, 3001
	call	asmerr@PLT
$_234:	cmp	dword ptr [write_to_file+rip], 0
	jz	$_235
	call	GetCurrOffset@PLT
	mov	rdx, qword ptr [rsi+rbx+0x28]
	mov	dword ptr [rdx+0x14], eax
	mov	r8, rdx
	mov	edx, edi
	lea	rcx, [rsi+rbx+0x30]
	call	OutputBytes@PLT
	jmp	$_236

$_235:	xor	r8d, r8d
	mov	edx, edi
	lea	rcx, [rsi+rbx+0x30]
	call	OutputBytes@PLT
$_236:	leave
	pop	rbx
	pop	rdi
	ret

$_237:
	mov	rdx, qword ptr [rsi+0x68]
	movzx	eax, byte ptr [rdx]
	lea	rcx, [opnd_clstab3+rip]
	movzx	eax, byte ptr [rcx+rax]
	test	eax, eax
	jz	$_238
	cmp	eax, 5
	jnz	$_240
$_238:	cmp	dword ptr [rsi+0x50], 0
	jz	$_239
	mov	rax, -1
	jmp	$_255

$_239:	xor	eax, eax
	jmp	$_255

$_240:	jmp	$_253

$_241:	cmp	dword ptr [rsi+0x50], 8388609
	jnz	$_242
	xor	eax, eax
	jmp	$_255

$_242:	jmp	$_254

$_243:	test	byte ptr [rsi+0x52], 0x07
	jz	$_246
	cmp	dword ptr [rsi+0x60], -128
	jl	$_246
	cmp	dword ptr [rsi+0x14], 795
	jnz	$_244
	cmp	dword ptr [rsi+0x60], 128
	jl	$_245
$_244:	cmp	dword ptr [rsi+0x14], 795
	jz	$_246
	cmp	dword ptr [rsi+0x60], 256
	jge	$_246
$_245:	mov	dword ptr [rsi+0x50], 65536
	xor	eax, eax
	jmp	$_255

$_246:	jmp	$_254

$_247:	test	byte ptr [rsi+0x52], 0x07
	je	$_254
	xor	eax, eax
	jmp	$_255

$_248:	cmp	dword ptr [rsi+0x14], 1442
	jc	$_251
	test	dword ptr [rsi+0x50], 0x100070
	jz	$_249
	xor	eax, eax
	jmp	$_255

$_249:	mov	eax, dword ptr [rsi+0x14]
	jmp	$_250

	xor	eax, eax
	jmp	$_255

	jmp	LC01B7

$_250:	cmp	eax, 1726
	jl	LC01B7
	cmp	eax, 1738
	jg	LC01B7
	lea	r11, [LC01B8+rip]
	movzx	r10, byte ptr [r11+rax-0x6BC]
	movzx	r10, byte ptr [r11+r10]
	lea	r11, [LC01B7+rip]
	sub	r11, r10
	jmp	r11

LC01B7: jmp	$_252

$_251:	cmp	dword ptr [rsi+0x50], 16
	jnz	$_252
	cmp	dword ptr [rsi+0x60], 0
	jnz	$_252
	xor	eax, eax
	jmp	$_255

$_252:	jmp	$_254

$_253:	cmp	eax, 1
	je	$_241
	cmp	eax, 2
	je	$_243
	cmp	eax, 4
	je	$_247
	cmp	eax, 3
	je	$_248
$_254:	mov	rax, -1
$_255:	ret

$_256:
	sub	rsp, 40
	mov	rdx, qword ptr [rsi+0x68]
	movzx	eax, byte ptr [rdx]
	lea	rcx, [opnd_clstab3+rip]
	movzx	eax, byte ptr [rcx+rax]
	jmp	$_272

$_257:	mov	edx, 2
	mov	ecx, 65536
	call	$_198
	jmp	$_273

$_258:	mov	edx, 2
	mov	ecx, dword ptr [rsi+0x50]
	call	$_198
	jmp	$_273

$_259:	mov	eax, dword ptr [rsi+0x14]
	xor	edx, edx
	jmp	$_268

$_260:	jmp	$_269

$_261:	inc	edx
	jmp	$_269

$_262:	mov	edx, 16
	jmp	$_269

$_263:	mov	edx, 17
	jmp	$_269

$_264:	cmp	eax, 2127
	jnc	$_265
	sub	eax, 1063
	mov	ecx, 8
	div	ecx
	jmp	$_267

$_265:	cmp	eax, 2259
	jnc	$_266
	sub	eax, 2127
	mov	ecx, 32
	div	ecx
	jmp	$_267

$_266:	sub	eax, 2259
	mov	ecx, 6
	div	ecx
	cmp	edx, 3
	jc	$_267
	inc	edx
$_267:	jmp	$_269

$_268:	cmp	eax, 1290
	jz	$_260
	cmp	eax, 2123
	jz	$_260
	cmp	eax, 1291
	jz	$_261
	cmp	eax, 2124
	jz	$_261
	cmp	eax, 1292
	jz	$_262
	cmp	eax, 2125
	jz	$_262
	cmp	eax, 1293
	jz	$_263
	cmp	eax, 2126
	jz	$_263
	jmp	$_264

$_269:	mov	dword ptr [rsi+0x60], edx
	mov	qword ptr [rsi+0x58], 0
	mov	edx, 2
	mov	ecx, 65536
	call	$_198
	jmp	$_273

$_270:	cmp	dword ptr [rsi+0x14], 1442
	jc	$_271
	mov	eax, dword ptr [rsi+0x60]
	shl	eax, 4
	mov	dword ptr [rsi+0x60], eax
	mov	edx, 2
	mov	ecx, 65536
	call	$_198
$_271:	jmp	$_273

$_272:	cmp	eax, 2
	je	$_257
	cmp	eax, 4
	je	$_258
	cmp	eax, 5
	je	$_259
	cmp	eax, 3
	jz	$_270
$_273:	add	rsp, 40
	ret

$_274:
	mov	qword ptr [rsp+0x8], rcx
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 48
	mov	rdi, qword ptr [rsi+0x68]
	movzx	eax, byte ptr [rdi]
	lea	rcx, [opnd_clstab+rip]
	mov	eax, dword ptr [rcx+rax*8]
	mov	dword ptr [rbp-0x4], eax
	mov	ebx, dword ptr [rsi+0x38]
	cmp	dword ptr [rsi+0x14], 1442
	jc	$_283
	test	byte ptr [rsi+0x6], 0x01
	je	$_283
	mov	eax, dword ptr [rsi+0x20]
	test	eax, 0x106060
	jz	$_281
	test	ebx, 0x40
	jz	$_275
	or	ebx, 0x20
	jmp	$_276

$_275:	test	ebx, 0x4000
	jz	$_276
	or	ebx, 0x2000
$_276:	test	ebx, 0x20
	jz	$_277
	or	ebx, 0x10
	jmp	$_280

$_277:	test	ebx, 0x2000
	jz	$_278
	or	ebx, 0x1000
	jmp	$_280

$_278:	test	ebx, 0x1000
	jz	$_279
	or	ebx, 0x800
	jmp	$_280

$_279:	test	ebx, 0x10
	jz	$_280
	test	byte ptr [rsi+0x6], 0x20
	jnz	$_280
	cmp	eax, 1048576
	jz	$_280
	mov	ecx, 2085
	call	asmerr@PLT
	jmp	$_337

$_280:	jmp	$_282

$_281:	cmp	eax, 4202240
	jnz	$_282
	test	ebx, 0x60
	jz	$_282
	or	ebx, 0x10
$_282:	jmp	$_286

$_283:	cmp	dword ptr [rbp+0x20], 16
	jnz	$_286
	cmp	ebx, 2048
	jnz	$_286
	mov	rax, qword ptr [CurrProc+rip]
	test	rax, rax
	jz	$_285
	cmp	byte ptr [rax+0x1F], 8
	jnz	$_284
	or	ebx, 0x1000
$_284:	jmp	$_286

$_285:	cmp	byte ptr [r14+0x9], 8
	jnz	$_286
	or	ebx, 0x1000
$_286:	movzx	eax, byte ptr [rdi]
	lea	rcx, [opnd_clstab+rip]
	mov	eax, dword ptr [rcx+rax*8+0x4]
	test	byte ptr [rsi+0x6], 0x01
	jz	$_288
	cmp	eax, 16
	jnz	$_288
	cmp	ebx, 64
	jz	$_287
	cmp	ebx, 32
	jnz	$_288
$_287:	or	eax, ebx
$_288:	test	byte ptr [rsi+0x1], 0x08
	jz	$_290
	test	byte ptr [rdi+0x5], 0x02
	jz	$_290
	test	eax, 0xE00
	jnz	$_289
	test	ebx, 0xE00
	jz	$_290
$_289:	or	eax, ebx
$_290:	jmp	$_331

$_291:	test	eax, ebx
	je	$_305
	test	byte ptr [rbp+0x20], 0x01
	jz	$_293
	and	byte ptr [rsi+0x1], 0xDF
	mov	ebx, 65536
	mov	rax, qword ptr [rsi+0x40]
	test	rax, rax
	jz	$_292
	cmp	byte ptr [rax+0x18], 11
	jz	$_292
	mov	byte ptr [rax+0x18], 4
$_292:	jmp	$_304

$_293:	test	byte ptr [rbp+0x20], 0x02
	jz	$_294
	mov	ebx, 131072
	jmp	$_304

$_294:	test	byte ptr [rbp+0x20], 0x0C
	jz	$_296
	or	byte ptr [rsi+0x1], 0x20
	cmp	byte ptr [rsi+0x9], 0
	jz	$_295
	and	byte ptr [rsi+0x1], 0xDF
$_295:	mov	ebx, 262144
	jmp	$_304

$_296:	test	dword ptr [rbp+0x20], 0x401F00
	jz	$_304
	mov	rdx, rsi
	mov	ecx, dword ptr [rbp+0x20]
	call	OperandSize@PLT
	jmp	$_303

$_297:	mov	ebx, 65536
	and	byte ptr [rsi+0x1], 0xDF
	jmp	$_304

$_298:	mov	ebx, 131072
	and	byte ptr [rsi+0x1], 0xDF
	cmp	byte ptr [rsi+0x9], 0
	jz	$_299
	or	byte ptr [rsi+0x1], 0x20
$_299:	jmp	$_304

$_300:	mov	ebx, 262144
	or	byte ptr [rsi+0x1], 0x20
	cmp	byte ptr [rsi+0x9], 0
	jz	$_301
	and	byte ptr [rsi+0x1], 0xDF
$_301:	jmp	$_304

$_302:	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_304

$_303:	cmp	rax, 1
	jz	$_297
	cmp	rax, 2
	jz	$_298
	cmp	rax, 8
	jz	$_300
	cmp	rax, 4
	jz	$_300
	jmp	$_302

$_304:	call	$_001
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x20]
	call	$_198
	mov	edx, 1
	mov	ecx, ebx
	call	$_198
	xor	eax, eax
	jmp	$_337

$_305:	jmp	$_332

$_306:	test	eax, ebx
	jz	$_310
	test	byte ptr [rsi], 0x08
	jz	$_307
	cmp	ebx, 65536
	jne	$_332
$_307:	cmp	dword ptr [rsi+0x48], 255
	jg	$_310
	cmp	dword ptr [rsi+0x48], -128
	jl	$_310
	mov	rax, qword ptr [rsi+0x40]
	test	rax, rax
	jz	$_309
	cmp	byte ptr [rax+0x18], 5
	jz	$_308
	cmp	byte ptr [rax+0x18], 6
	jnz	$_309
$_308:	mov	byte ptr [rax+0x18], 4
$_309:	call	$_001
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x20]
	call	$_198
	mov	edx, 1
	mov	ecx, 65536
	call	$_198
	xor	eax, eax
	jmp	$_337

$_310:	jmp	$_332

$_311:	mov	edx, eax
	mov	eax, dword ptr [rsi+0x14]
	cmp	byte ptr [r14+0x26], 0
	jz	$_312
	cmp	eax, 682
	je	$_332
	cmp	eax, 679
	je	$_332
	cmp	eax, 684
	je	$_332
$_312:	mov	rax, qword ptr [rsi+0x40]
	test	rax, rax
	jz	$_313
	mov	rcx, qword ptr [rax+0x30]
	test	rcx, rcx
	jz	$_313
	cmp	byte ptr [rcx+0x1D], 0
	jne	$_332
$_313:	test	byte ptr [rsi], 0x08
	jnz	$_315
	movsx	eax, byte ptr [rsi+0x48]
	movsx	ecx, word ptr [rsi+0x48]
	test	dword ptr [rbp+0x20], 0x202
	jz	$_314
	cmp	eax, ecx
	jnz	$_314
	or	edx, 0x20000
	jmp	$_315

$_314:	test	dword ptr [rbp+0x20], 0xC0C
	jz	$_315
	cmp	eax, dword ptr [rsi+0x48]
	jnz	$_315
	or	edx, 0x40000
$_315:	test	edx, ebx
	jz	$_316
	call	$_001
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x20]
	call	$_198
	mov	edx, 1
	mov	ecx, 65536
	call	$_198
	xor	eax, eax
	jmp	$_337

$_316:	jmp	$_332

$_317:	test	eax, ebx
	jz	$_318
	cmp	dword ptr [rsi+0x48], 1
	jnz	$_318
	call	$_001
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x20]
	call	$_198
	xor	eax, eax
	jmp	$_337

$_318:	jmp	$_332

$_319:	jmp	$_323

$_320:	test	ebx, 0xC
	jnz	$_321
	or	ebx, 0x0C
$_321:	jmp	$_324

$_322:	call	$_001
	mov	edx, 2
	mov	ecx, 8847360
	call	$_198
	xor	eax, eax
	jmp	$_337

	jmp	$_324

$_323:	cmp	dword ptr [rsi+0x14], 1726
	jz	$_320
	cmp	dword ptr [rsi+0x14], 1727
	jz	$_320
	cmp	dword ptr [rsi+0x14], 1733
	jz	$_320
	cmp	dword ptr [rsi+0x14], 1734
	jz	$_320
	cmp	dword ptr [rsi+0x14], 1738
	jz	$_322
$_324:	test	eax, ebx
	jz	$_330
	call	$_237
	cmp	eax, -1
	je	$_332
	call	$_001
	test	dword ptr [rbp+0x20], 0x406F7F00
	jz	$_325
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x20]
	call	$_198
$_325:	test	ebx, 0x406F7F00
	jz	$_326
	mov	edx, 1
	mov	ecx, ebx
	call	$_198
$_326:	movzx	eax, byte ptr [rdi]
	lea	rcx, [opnd_clstab3+rip]
	cmp	byte ptr [rcx+rax], 0
	jz	$_327
	test	byte ptr [rdi+0x4], 0x20
	jnz	$_327
	call	$_256
$_327:	cmp	byte ptr [rdi+0x1], 18
	jnz	$_329
	movzx	eax, byte ptr [rdi+0x6]
	test	byte ptr [rsi], 0x01
	jz	$_328
	or	eax, 0x01
$_328:	mov	ecx, eax
	call	OutputByte@PLT
$_329:	xor	eax, eax
	jmp	$_337

$_330:	jmp	$_332

$_331:	cmp	eax, 458752
	je	$_291
	cmp	eax, 8847360
	je	$_306
	cmp	eax, 65536
	je	$_311
	cmp	eax, 2162688
	je	$_317
	cmp	eax, 12
	je	$_319
	jmp	$_324

$_332:	add	rdi, 8
	jmp	$_334

$_333:	add	rdi, 8
$_334:	test	byte ptr [rsi+0x1], 0x08
	jz	$_335
	cmp	word ptr [rdi+0x4], 0
	jnz	$_335
	test	byte ptr [rdi+0x2], 0x08
	jz	$_333
$_335:	mov	qword ptr [rsi+0x68], rdi
	movzx	eax, byte ptr [rdi]
	lea	rcx, [opnd_clstab+rip]
	mov	eax, dword ptr [rcx+rax*8]
	cmp	eax, dword ptr [rbp-0x4]
	jnz	$_336
	test	byte ptr [rdi+0x2], 0x08
	je	$_286
$_336:	sub	qword ptr [rsi+0x68], 8
	mov	rax, -1
$_337:	leave
	pop	rbx
	pop	rdi
	ret

$_338:
	mov	qword ptr [rsp+0x8], rcx
	push	rdi
	push	rbp
	mov	rbp, rsp
	imul	eax, dword ptr [rbp+0x18], 24
	mov	rdi, qword ptr [rsi+rax+0x28]
	test	rdi, rdi
	jz	$_339
	cmp	byte ptr [rdi+0x18], 3
	jnz	$_339
	call	GetCurrOffset@PLT
	sub	eax, dword ptr [rdi+0x14]
	mov	byte ptr [rdi+0x1A], al
$_339:	leave
	pop	rdi
	ret

$_340:
	mov	qword ptr [rsp+0x8], rcx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	cmp	dword ptr [rsi+0x38], 0
	jne	$_346
	mov	rcx, qword ptr [rsi+0x68]
	movzx	eax, byte ptr [rcx]
	lea	rdx, [opnd_clstab+rip]
	cmp	dword ptr [rdx+rax*8+0x4], 0
	jz	$_341
	mov	rax, -1
	jmp	$_349

$_341:	cmp	dword ptr [rbp+0x10], 4202240
	jnz	$_344
	movzx	eax, byte ptr [rcx+0x8]
	test	dword ptr [rdx+rax*8], 0x401F00
	jz	$_344
	test	byte ptr [rcx+0xA], 0x08
	jnz	$_344
	xor	ecx, ecx
	xor	edx, edx
	mov	rax, qword ptr [rsi+0x28]
	test	rax, rax
	jz	$_342
	mov	rdx, qword ptr [rax+0x30]
	test	rdx, rdx
	jz	$_342
	mov	cl, byte ptr [rdx+0x1D]
$_342:	test	byte ptr [rsi], 0x40
	jnz	$_344
	test	eax, eax
	jz	$_343
	test	rdx, rdx
	jz	$_343
	test	ecx, ecx
	jz	$_344
$_343:	mov	ecx, 2023
	call	asmerr@PLT
$_344:	call	$_001
	xor	edx, edx
	mov	ecx, dword ptr [rbp+0x10]
	call	$_198
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_345
	xor	ecx, ecx
	call	$_338
$_345:	xor	eax, eax
	jmp	$_349

$_346:	mov	ecx, dword ptr [rbp+0x10]
	call	$_274
	test	eax, eax
	jnz	$_348
	cmp	byte ptr [rsi+0x9], 2
	jnz	$_347
	xor	ecx, ecx
	call	$_338
	mov	ecx, 1
	call	$_338
$_347:	xor	eax, eax
	jmp	$_349

$_348:	mov	rax, -1
$_349:	leave
	ret

codegen:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	rdi, qword ptr [rsi+0x68]
	test	byte ptr [rdi+0x3], 0x40
	jz	$_350
	test	byte ptr [r14+0x14], 0x40
	jnz	$_350
	mov	ecx, 2085
	call	asmerr@PLT
	jmp	$_378

$_350:	test	byte ptr [rsi+0x1], 0x1F
	jnz	$_354
	test	byte ptr [rsi+0x7], 0x10
	jz	$_353
	test	byte ptr [rsi+0x7], 0x08
	jz	$_351
	test	byte ptr [r14+0x2B], 0x0B
	jnz	$_352
$_351:	or	byte ptr [rsi+0x1], 0x08
$_352:	jmp	$_354

$_353:	test	byte ptr [rsi+0x7], 0x08
	jz	$_354
	cmp	byte ptr [r14+0x2B], 4
	jnz	$_354
	or	byte ptr [rsi+0x1], 0x08
$_354:	test	byte ptr [rsi+0x1], 0x08
	jz	$_357
	jmp	$_356

$_355:	add	rdi, 8
	mov	qword ptr [rsi+0x68], rdi
$_356:	cmp	word ptr [rdi+0x4], 0
	jnz	$_357
	test	byte ptr [rdi+0xA], 0x08
	jz	$_355
$_357:	mov	ebx, dword ptr [rsi+0x20]
	test	ebx, 0x70000
	jz	$_359
	cmp	ebx, 65536
	jnz	$_358
	mov	ebx, 458752
	jmp	$_359

$_358:	cmp	ebx, 131072
	jnz	$_359
	mov	ebx, 393216
$_359:	test	byte ptr [rsi+0x7], 0x18
	jz	$_364
	lea	rdx, [vex_flags+rip]
	mov	ecx, dword ptr [rsi+0x14]
	mov	al, byte ptr [rcx+rdx-0x5A2]
	mov	byte ptr [rsi+0x6], al
	test	al, 0x01
	jz	$_364
	test	ebx, 0x6060
	jz	$_364
	test	byte ptr [rsi+0x38], 0x10
	jz	$_360
	test	al, 0x20
	jnz	$_360
	mov	ecx, 2070
	call	asmerr@PLT
	jmp	$_378

$_360:	test	ebx, 0x40
	jz	$_361
	or	ebx, 0x20
	jmp	$_362

$_361:	test	ebx, 0x4000
	jz	$_362
	or	ebx, 0x2000
$_362:	test	ebx, 0x20
	jz	$_363
	or	ebx, 0x10
	jmp	$_364

$_363:	or	ebx, 0x1000
$_364:	movzx	eax, byte ptr [rdi]
	lea	rcx, [opnd_clstab+rip]
	mov	ecx, dword ptr [rcx+rax*8]
	test	ecx, ecx
	jnz	$_366
	test	ebx, ebx
	jnz	$_366
	call	$_001
	cmp	qword ptr [r14+0x1F8], 0
	jz	$_365
	xor	r8d, r8d
	mov	edx, dword ptr [rbp+0x30]
	mov	ecx, 1
	call	LstWrite@PLT
$_365:	xor	eax, eax
	jmp	$_378

$_366:	test	ecx, ebx
	je	$_377
	mov	eax, 4294967295
	jmp	$_374

$_367:	call	$_340
	jmp	$_375

$_368:	cmp	dword ptr [rsi+0x30], 255
	jg	$_369
	cmp	dword ptr [rsi+0x30], -128
	jl	$_369
	mov	ecx, 65536
	call	$_340
$_369:	jmp	$_375

$_370:	cmp	dword ptr [rsi+0x30], 3
	jnz	$_371
	xor	ecx, ecx
	call	$_340
$_371:	jmp	$_375

$_372:	test	byte ptr [rsi+0x1], 0x08
	jz	$_373
	cmp	word ptr [rdi+0x4], 0
	jz	$_375
$_373:	mov	ecx, dword ptr [rsi+0x20]
	call	$_340
	jmp	$_375

$_374:	cmp	ecx, 262144
	jz	$_367
	cmp	ecx, 131072
	jz	$_367
	cmp	ecx, 8847360
	jz	$_368
	cmp	ecx, 4259840
	jz	$_370
	jmp	$_372

$_375:	test	eax, eax
	jnz	$_377
	cmp	qword ptr [r14+0x1F8], 0
	jz	$_376
	xor	r8d, r8d
	mov	edx, dword ptr [rbp+0x30]
	mov	ecx, 1
	call	LstWrite@PLT
$_376:	xor	eax, eax
	jmp	$_378

$_377:	add	rdi, 8
	mov	qword ptr [rsi+0x68], rdi
	test	byte ptr [rdi+0x2], 0x08
	je	$_364
	mov	ecx, 2070
	call	asmerr@PLT
$_378:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret


.SECTION .data
	.ALIGN	16

szNull:
	.byte  0x3C, 0x4E, 0x55, 0x4C, 0x4C, 0x3E, 0x00

sr_prefix:
	.byte  0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65

DS0000:
	.byte  0x7B, 0x73, 0x77, 0x61, 0x70, 0x7D, 0x20, 0x6E
	.byte  0x6F, 0x74, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6F
	.byte  0x72, 0x74, 0x65, 0x64, 0x00

LC0079:
	.byte  0x46, 0x41, 0x3E, 0x39, 0x34, 0x2F, 0x00, 0x04
	.byte  0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
	.byte  0x00, 0x06, 0x06, 0x00, 0x04, 0x05, 0x06, 0x00
	.byte  0x04, 0x05, 0x00, 0x04, 0x05, 0x06, 0x06, 0x01
	.byte  0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00
	.byte  0x02, 0x02, 0x03, 0x03

LC0090:
	.byte  0x44, 0x3F, 0x3A, 0x35, 0x30, 0x00, 0x03, 0x05
	.byte  0x00, 0x00, 0x00, 0x04, 0x02, 0x02, 0x02, 0x01
	.byte  0x01, 0x01, 0x05, 0x05, 0x05, 0x03, 0x05, 0x05
	.byte  0x00, 0x04, 0x00, 0x00, 0x05, 0x02, 0x01, 0x02
	.byte  0x01

DS0001:
	.byte  0x6D, 0x69, 0x73, 0x6D, 0x61, 0x74, 0x63, 0x68
	.byte  0x20, 0x69, 0x6E, 0x20, 0x74, 0x68, 0x65, 0x20
	.byte  0x6E, 0x75, 0x6D, 0x62, 0x65, 0x72, 0x20, 0x6F
	.byte  0x66, 0x20, 0x62, 0x72, 0x6F, 0x61, 0x64, 0x63
	.byte  0x61, 0x73, 0x74, 0x69, 0x6E, 0x67, 0x20, 0x65
	.byte  0x6C, 0x65, 0x6D, 0x65, 0x6E, 0x74, 0x73, 0x00
	.byte  0x00

LC0101:
	.byte  0x03, 0x01, 0xE0, 0x00, 0xE9, 0x00, 0xBD, 0x00
	.byte  0x79, 0x00, 0x60, 0x00, 0x51, 0x00, 0x42, 0x00
	.byte  0x1F, 0x00, 0x33, 0x00, 0x3C, 0x00, 0x17, 0x00
	.byte  0x10, 0x00, 0x17, 0x00, 0x19, 0x01

LC01B8:
	.byte  0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00


.att_syntax prefix
