
.intel_syntax noprefix

.global cv_write_debug_tables

.extern CV8Label
.extern GetSymOfssize
.extern SizeFromMemtype
.extern SymTables
.extern store_fixup
.extern CreateFixup
.extern LclAlloc
.extern tsprintf
.extern Options
.extern SymEnum
.extern tstrcmp
.extern tstrcat
.extern tstrcpy
.extern tstrlen
.extern tmemicmp
.extern _pgmptr
.extern getcwd


.SECTION .text
	.ALIGN	16

$_001:	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rsi, rcx
	movzx	edi, dl
	mov	cl, byte ptr [rsi+0x1E]
	test	cl, 0x80
	jne	$_029
	mov	r8, qword ptr [rsi+0x28]
	mov	edx, edi
	movzx	ecx, cl
	call	SizeFromMemtype@PLT
	mov	cl, byte ptr [rsi+0x1E]
	test	cl, 0x20
	jz	$_009
	jmp	$_007

$_002:	mov	eax, 70
	jmp	$_064

$_003:	mov	eax, 64
	jmp	$_064

$_004:	mov	eax, 65
	jmp	$_064

$_005:	mov	eax, 66
	jmp	$_064

$_006:	mov	eax, 119
	jmp	$_064

	jmp	$_008

$_007:	cmp	eax, 2
	jz	$_002
	cmp	eax, 4
	jz	$_003
	cmp	eax, 8
	jz	$_004
	cmp	eax, 10
	jz	$_005
	cmp	eax, 16
	jz	$_006
$_008:	jmp	$_028

$_009:	test	cl, 0x40
	jz	$_017
	jmp	$_015

$_010:	mov	eax, 16
	jmp	$_064

$_011:	mov	eax, 114
	jmp	$_064

$_012:	mov	eax, 116
	jmp	$_064

$_013:	mov	eax, 118
	jmp	$_064

$_014:	mov	eax, 119
	jmp	$_064

	jmp	$_016

$_015:	cmp	eax, 1
	jz	$_010
	cmp	eax, 2
	jz	$_011
	cmp	eax, 4
	jz	$_012
	cmp	eax, 8
	jz	$_013
	cmp	eax, 16
	jz	$_014
$_016:	jmp	$_026

$_017:	jmp	$_025

$_018:	mov	eax, 32
	jmp	$_064

$_019:	mov	eax, 117
	jmp	$_064

$_020:	mov	eax, 68
	jmp	$_064

$_021:	mov	eax, 119
	jmp	$_064

$_022:	mov	eax, 119
	jmp	$_064

$_023:	cmp	byte ptr [Options+0xAA+rip], 4
	jnz	$_024
	mov	eax, 122
	jmp	$_064

$_024:	mov	eax, 33
	jmp	$_064

	jmp	$_026

$_025:	cmp	eax, 1
	jz	$_018
	cmp	eax, 4
	jz	$_019
	cmp	eax, 6
	jz	$_020
	cmp	eax, 8
	jz	$_021
	cmp	eax, 16
	jz	$_022
	cmp	eax, 2
	jz	$_023
$_026:	cmp	byte ptr [rsi+0x48], 1
	jnz	$_027
	mov	eax, 117
	jmp	$_064

$_027:	mov	eax, 119
	jmp	$_064

$_028:	jmp	$_063

$_029:	jmp	$_062

$_030:	mov	al, byte ptr [rsi+0x48]
	jmp	$_052

$_031:	cmp	byte ptr [rsi+0x21], 0
	jz	$_032
	mov	eax, 515
	jmp	$_064

$_032:	mov	eax, 259
	jmp	$_064

$_033:	cmp	byte ptr [rsi+0x21], 0
	jz	$_034
	mov	eax, 1283
	jmp	$_064

$_034:	mov	eax, 1027
	jmp	$_064

$_035:	mov	al, byte ptr [rsi+0x4A]
	jmp	$_050

$_036:	mov	eax, 1568
	jmp	$_064

$_037:	mov	eax, 1552
	jmp	$_064

$_038:	mov	eax, 1658
	jmp	$_064

$_039:	mov	eax, 1553
	jmp	$_064

$_040:	mov	eax, 1651
	jmp	$_064

$_041:	mov	eax, 1653
	jmp	$_064

$_042:	mov	eax, 1652
	jmp	$_064

$_043:	mov	eax, 1600
	jmp	$_064

$_044:	mov	eax, 1655
	jmp	$_064

$_045:	mov	eax, 1654
	jmp	$_064

$_046:	mov	eax, 1601
	jmp	$_064

$_047:	mov	eax, 1655
	jmp	$_064

$_048:	mov	eax, 1655
	jmp	$_064

$_049:	mov	eax, 1539
	jmp	$_064

	jmp	$_051

$_050:	cmp	al, 0
	je	$_036
	cmp	al, 64
	je	$_037
	cmp	al, 1
	je	$_038
	cmp	al, 65
	je	$_039
	cmp	al, 33
	je	$_040
	cmp	al, 3
	je	$_041
	cmp	al, 67
	je	$_042
	cmp	al, 35
	je	$_043
	cmp	al, 7
	je	$_044
	cmp	al, 71
	jz	$_045
	cmp	al, 39
	jz	$_046
	cmp	al, 15
	jz	$_047
	cmp	al, 47
	jz	$_048
	cmp	al, 128
	jz	$_049
$_051:	mov	eax, 528
	jmp	$_064

	jmp	$_053

$_052:	cmp	al, 0
	je	$_031
	cmp	al, 1
	je	$_033
	cmp	al, 2
	je	$_035
$_053:	jmp	$_063

$_054:	cmp	word ptr [rsi+0x6C], 0
	jz	$_055
	movzx	eax, word ptr [rsi+0x6C]
	jmp	$_064

$_055:	jmp	$_063

$_056:	mov	eax, 259
	jmp	$_064

$_057:	mov	eax, 515
	jmp	$_064

$_058:	mov	rsi, qword ptr [rsi+0x28]
$_059:	cmp	qword ptr [rsi+0x28], 0
	jz	$_060
	mov	rsi, qword ptr [rsi+0x28]
	jmp	$_059

$_060:	cmp	word ptr [rsi+0x6C], 0
	jz	$_061
	movzx	eax, word ptr [rsi+0x6C]
	jmp	$_064

$_061:	mov	edx, edi
	movzx	edx, dl
	mov	rcx, rsi
	call	$_001
	jmp	$_064

	jmp	$_063

$_062:	cmp	cl, 195
	je	$_030
	cmp	cl, 193
	jz	$_054
	cmp	cl, 129
	jz	$_056
	cmp	cl, 130
	jz	$_057
	cmp	cl, 196
	jz	$_058
$_063:	xor	eax, eax
$_064:	leave
	pop	rdi
	pop	rsi
	ret

$_065:
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	xchg	rsi, rdx
	mov	rax, rdi
	mov	rdi, rcx
	mov	ecx, dword ptr [rbp+0x20]
	cmp	byte ptr [Options+0xAA+rip], 1
	jnz	$_066
	mov	byte ptr [rdi], cl
	inc	rdi
	rep movsb
	jmp	$_067

$_066:	rep movsb
	mov	byte ptr [rdi], 0
	inc	rdi
$_067:	xchg	rdi, rax
	mov	rsi, rdx
	leave
	ret

$_068:
	cmp	byte ptr [Options+0xAA+rip], 1
	jne	$_078
	cmp	byte ptr [rcx+0x1D], 7
	jnz	$_069
	mov	eax, 6
	jmp	$_086

$_069:	test	byte ptr [rcx+0x10], 0x02
	jz	$_071
	cmp	byte ptr [Options+0xAB+rip], 1
	jc	$_071
	test	dl, dl
	jnz	$_070
	mov	eax, 29
	jmp	$_086

$_070:	mov	eax, 37
	jmp	$_086

$_071:	cmp	byte ptr [rcx+0x1E], 129
	jz	$_072
	cmp	byte ptr [rcx+0x1E], 130
	jnz	$_074
$_072:	test	dl, dl
	jnz	$_073
	mov	eax, 9
	jmp	$_086

$_073:	mov	eax, 11
	jmp	$_086

$_074:	test	byte ptr [rcx+0x11], 0x80
	jz	$_077
	mov	eax, 8
	cmp	dword ptr [rcx+0x34], 0
	jnz	$_075
	cmp	dword ptr [rcx+0x30], 32768
	jc	$_076
$_075:	add	eax, 2
$_076:	jmp	$_086

$_077:	mov	eax, 12
	jmp	$_086

$_078:	cmp	byte ptr [rcx+0x1D], 7
	jnz	$_079
	mov	eax, 8
	jmp	$_086

$_079:	test	byte ptr [rcx+0x10], 0x02
	jz	$_080
	cmp	byte ptr [Options+0xAB+rip], 1
	jc	$_080
	mov	eax, 39
	jmp	$_086

$_080:	cmp	byte ptr [rcx+0x1E], 129
	jz	$_081
	cmp	byte ptr [rcx+0x1E], 130
	jnz	$_082
$_081:	mov	eax, 11
	jmp	$_086

$_082:	test	byte ptr [rcx+0x11], 0x80
	jz	$_085
	mov	eax, 10
	cmp	dword ptr [rcx+0x34], 0
	jnz	$_083
	cmp	dword ptr [rcx+0x30], 32768
	jc	$_084
$_083:	add	eax, 2
$_084:	jmp	$_086

$_085:	mov	eax, 14
$_086:	ret

$_087:
	cmp	byte ptr [rcx+0x1D], 7
	jnz	$_088
	cmp	word ptr [rcx+0x6C], 0
	jnz	$_088
	cmp	dword ptr [rcx+0x60], 0
	jz	$_088
	cmp	dword ptr [rcx+0x14], 0
	jz	$_088
	cmp	word ptr [rcx+0x6E], 1
	jz	$_089
	cmp	word ptr [rcx+0x6E], 2
	jz	$_089
$_088:	xor	eax, eax
	jmp	$_098

$_089:	test	byte ptr [rcx+0x13], 0x01
	jz	$_090
	mov	eax, 1
	jmp	$_098

$_090:	mov	rcx, qword ptr [rcx+0x78]
	mov	rcx, qword ptr [rcx]
$_091:	test	rcx, rcx
	je	$_097
	mov	rdx, qword ptr [rcx+0x28]
	test	rdx, rdx
	jz	$_096
	cmp	byte ptr [rdx+0x1D], 7
	jnz	$_096
	cmp	word ptr [rdx+0x6C], 0
	jnz	$_096
	xor	eax, eax
	cmp	word ptr [rdx+0x6E], 1
	jz	$_092
	cmp	word ptr [rdx+0x6E], 2
	jnz	$_093
$_092:	mov	rax, rdx
	jmp	$_095

$_093:	cmp	word ptr [rdx+0x6E], 3
	jnz	$_095
	cmp	byte ptr [rdx+0x1E], 195
	jnz	$_095
	cmp	byte ptr [rdx+0x4A], 192
	jnz	$_095
	mov	rdx, qword ptr [rdx+0x50]
	test	rdx, rdx
	jz	$_095
	cmp	byte ptr [rdx+0x1D], 7
	jnz	$_095
	cmp	word ptr [rdx+0x6E], 1
	jz	$_094
	cmp	word ptr [rdx+0x6E], 2
	jnz	$_095
$_094:	mov	rax, rdx
$_095:	test	rax, rax
	jz	$_096
	cmp	dword ptr [rax+0x14], 0
	jz	$_096
	cmp	dword ptr [rax+0x60], 0
	jz	$_096
	cmp	word ptr [rax+0x6C], 0
	jnz	$_096
	mov	eax, 2
	jmp	$_098

$_096:	mov	rcx, qword ptr [rcx+0x80]
	jmp	$_091

$_097:	mov	eax, 1
$_098:	ret

dbgcv_flushpt:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rcx, qword ptr [rbx+0x28]
	mov	rax, qword ptr [rcx+0x78]
	mov	r9, qword ptr [rbx+0x30]
	mov	r8d, edx
	mov	rdx, qword ptr [rbx+0x10]
	call	qword ptr [rax+0x20]
	mov	qword ptr [rbx+0x10], rax
	leave
	pop	rbx
	ret

dbgcv_flushps:
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rcx, qword ptr [rbx+0x20]
	mov	rax, qword ptr [rcx+0x78]
	mov	r9, qword ptr [rbx+0x30]
	mov	r8d, edx
	mov	rdx, qword ptr [rbx+0x8]
	call	qword ptr [rax+0x20]
	mov	qword ptr [rbx+0x8], rax
	leave
	pop	rbx
	ret

dbgcv_padbytes:
	mov	rcx, qword ptr [rcx+0x28]
	mov	rcx, qword ptr [rcx+0x78]
	mov	rcx, qword ptr [rcx+0x10]
$_099:	mov	rax, rdx
	sub	rax, rcx
	test	eax, 0x3
	jz	$_100
	not	eax
	and	eax, 0x03
	add	eax, 241
	mov	byte ptr [rdx], al
	inc	rdx
	jmp	$_099

$_100:
	ret

dbgcv_alignps:
	mov	rdx, qword ptr [rcx+0x18]
	mov	eax, dword ptr [rdx+0x4]
	and	eax, 0x03
	jz	$_103
	mov	edx, 4
	sub	edx, eax
	jmp	$_102

$_101:	mov	rax, qword ptr [rcx+0x8]
	mov	byte ptr [rax], 0
	inc	qword ptr [rcx+0x8]
	dec	edx
$_102:	test	edx, edx
	jnz	$_101
$_103:	mov	rax, qword ptr [rcx+0x8]
	ret

dbgcv_write_bitfield:
	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	rbx, rcx
	mov	esi, 12
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_104
	mov	esi, 8
$_104:	mov	edx, esi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	xor	edx, edx
	mov	rcx, qword ptr [rbp+0x30]
	call	$_001
	mov	edx, eax
	mov	rcx, qword ptr [rbp+0x38]
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rcx+0x6C], ax
	mov	al, byte ptr [rcx+0x5A]
	mov	cl, byte ptr [rcx+0x59]
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_105
	mov	byte ptr [rdi+0x4], al
	mov	byte ptr [rdi+0x5], cl
	mov	word ptr [rdi+0x6], dx
	mov	eax, 33947654
	jmp	$_106

$_105:	mov	dword ptr [rdi+0x4], edx
	mov	byte ptr [rdi+0x8], al
	mov	byte ptr [rdi+0x9], cl
	mov	eax, 61938
	mov	word ptr [rdi+0xA], ax
	mov	eax, 302317578
$_106:	mov	dword ptr [rdi], eax
	inc	dword ptr [rbx+0x3C]
	add	qword ptr [rbx+0x10], rsi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_write_array_type:
	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, 40
	mov	rbx, rcx
	mov	rdi, rdx
	cmp	dword ptr [rbp+0x38], 0
	jnz	$_107
	movzx	edx, byte ptr [rbp+0x40]
	mov	rcx, rdi
	call	$_001
	mov	dword ptr [rbp+0x38], eax
$_107:	xor	esi, esi
	cmp	dword ptr [rdi+0x60], 32768
	jc	$_108
	add	esi, 4
$_108:	mov	eax, 12
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_109
	mov	eax, 8
$_109:	lea	edi, [rsi+rax+0x6]
	and	edi, 0xFFFFFFFC
	mov	edx, edi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	ecx, edi
	mov	rdi, rax
	add	qword ptr [rbx+0x10], rcx
	sub	ecx, 2
	mov	word ptr [rdi], cx
	mov	eax, dword ptr [rbp+0x38]
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_110
	mov	word ptr [rdi+0x4], ax
	mov	word ptr [rdi+0x6], 18
	lea	rdx, [rdi+0x8]
	mov	eax, 3
	jmp	$_111

$_110:	mov	dword ptr [rdi+0x4], eax
	movzx	edx, byte ptr [rbp+0x40]
	mov	rcx, qword ptr [rbp+0x30]
	call	$_001
	mov	dword ptr [rdi+0x8], eax
	lea	rdx, [rdi+0xC]
	mov	eax, 5379
$_111:	mov	word ptr [rdi+0x2], ax
	mov	rcx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rcx+0x60]
	test	esi, esi
	jz	$_112
	mov	word ptr [rdx], -32764
	mov	dword ptr [rdx+0x2], eax
	add	rdx, 6
	jmp	$_113

$_112:	mov	word ptr [rdx], ax
	add	rdx, 2
$_113:	mov	byte ptr [rdx], 0
	inc	rdx
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x10]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_write_ptr_type:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rsi, rdx
	cmp	byte ptr [rsi+0x4A], 192
	jnz	$_114
	cmp	qword ptr [rsi+0x50], 0
	jz	$_115
$_114:	cmp	byte ptr [rsi+0x4A], 128
	jnz	$_116
$_115:	movzx	edx, byte ptr [rsi+0x48]
	mov	rcx, rsi
	call	$_001
	jmp	$_132

$_116:	mov	edi, 20
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_117
	mov	edi, 12
$_117:	mov	edx, edi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	xchg	rdi, rax
	add	qword ptr [rbx+0x10], rax
	sub	eax, 2
	mov	word ptr [rdi], ax
	cmp	byte ptr [rsi+0x48], 0
	jnz	$_119
	mov	eax, 0
	cmp	byte ptr [rsi+0x21], 0
	jz	$_118
	mov	eax, 1
$_118:	jmp	$_122

$_119:	cmp	byte ptr [rsi+0x48], 1
	jnz	$_121
	mov	eax, 10
	cmp	byte ptr [rsi+0x21], 0
	jz	$_120
	mov	eax, 11
$_120:	jmp	$_122

$_121:	mov	eax, 10
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_122
	mov	eax, 12
$_122:	xor	ecx, ecx
	mov	edx, 4098
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_123
	mov	edx, 2
	mov	word ptr [rdi+0x4], ax
	mov	word ptr [rdi+0x8], cx
	mov	word ptr [rdi+0xA], cx
	jmp	$_124

$_123:	mov	dword ptr [rdi+0x8], eax
	mov	dword ptr [rdi+0xC], ecx
	mov	dword ptr [rdi+0x10], ecx
$_124:	mov	word ptr [rdi+0x2], dx
	cmp	byte ptr [rsi+0x49], 1
	jbe	$_125
	movzx	edx, byte ptr [rsi+0x48]
	mov	rcx, rsi
	call	$_001
	jmp	$_129

$_125:	cmp	qword ptr [rsi+0x50], 0
	jz	$_128
	mov	rcx, qword ptr [rsi+0x50]
	cmp	word ptr [rcx+0x6C], 0
	jz	$_126
	movzx	eax, word ptr [rcx+0x6C]
	jmp	$_127

$_126:	movzx	edx, byte ptr [rsi+0x48]
	mov	rcx, rsi
	call	$_001
$_127:	jmp	$_129

$_128:	mov	al, byte ptr [rsi+0x1E]
	mov	byte ptr [rbp-0x1], al
	mov	al, byte ptr [rsi+0x4A]
	mov	byte ptr [rsi+0x1E], al
	movzx	edx, byte ptr [rsi+0x48]
	mov	rcx, rsi
	call	$_001
	mov	cl, byte ptr [rbp-0x1]
	mov	byte ptr [rsi+0x1E], cl
$_129:	cmp	byte ptr [rbx+0x50], 1
	jnz	$_130
	mov	word ptr [rdi+0x6], ax
	jmp	$_131

$_130:	mov	dword ptr [rdi+0x4], eax
$_131:	mov	eax, dword ptr [rbx+0x3C]
	inc	dword ptr [rbx+0x3C]
$_132:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_cntproc:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rdi, r8
	mov	rsi, r9
	inc	dword ptr [rsi]
	mov	eax, 8
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_133
	mov	eax, 6
$_133:	mov	rcx, qword ptr [rbp+0x30]
	xor	edx, edx
	cmp	word ptr [rcx+0x6E], 4
	jz	$_134
	add	edx, dword ptr [rdi+0x30]
	add	edx, dword ptr [rsi+0x8]
$_134:	cmp	edx, 32768
	jc	$_135
	add	eax, 4
$_135:	mov	ecx, dword ptr [rdi+0x14]
	lea	rax, [rcx+rax+0x6]
	and	eax, 0xFFFFFFFC
	add	dword ptr [rsi+0x4], eax
	mov	rcx, qword ptr [rdi+0x28]
	cmp	byte ptr [rdi+0x1E], 196
	jnz	$_136
	cmp	word ptr [rcx+0x6C], 0
	jnz	$_136
	inc	dword ptr [rbx+0x38]
	mov	rdx, qword ptr [rdi+0x28]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
	dec	dword ptr [rbx+0x38]
	jmp	$_137

$_136:	cmp	byte ptr [rdi+0x1E], 193
	jnz	$_137
	cmp	word ptr [rdi+0x6C], 0
	jnz	$_137
	mov	r8, rdi
	mov	rdx, qword ptr [rbp+0x30]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x28]
$_137:	test	byte ptr [rdi+0x10], 0x40
	jz	$_138
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0x70], ax
	inc	dword ptr [rbx+0x3C]
	xor	r9d, r9d
	xor	r8d, r8d
	mov	rdx, rdi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x30]
$_138:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_memberproc:
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rbx, rcx
	mov	rsi, r9
	mov	rdi, r8
	mov	rcx, rdx
	xor	eax, eax
	xor	edx, edx
	cmp	word ptr [rcx+0x6E], 4
	jz	$_139
	add	edx, dword ptr [rdi+0x30]
	add	edx, dword ptr [rsi+0x8]
$_139:	mov	dword ptr [rbp-0x4], edx
	cmp	edx, 32768
	jc	$_140
	add	eax, 4
$_140:	mov	dword ptr [rbp-0x8], eax
	mov	edx, 8
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_141
	mov	edx, 6
$_141:	add	eax, edx
	mov	ecx, dword ptr [rdi+0x14]
	lea	esi, [rax+rcx+0x6]
	and	esi, 0xFFFFFFFC
	mov	edx, esi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	add	qword ptr [rbx+0x10], rsi
	mov	eax, 5389
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_142
	mov	eax, 1030
$_142:	mov	word ptr [rdi], ax
	mov	rsi, qword ptr [rbp+0x38]
	test	byte ptr [rsi+0x10], 0x40
	jz	$_143
	movzx	eax, word ptr [rsi+0x70]
	mov	word ptr [rsi+0x70], 0
	jmp	$_144

$_143:	xor	edx, edx
	mov	rcx, rsi
	call	$_001
$_144:	cmp	byte ptr [rbx+0x50], 1
	jnz	$_145
	mov	word ptr [rdi+0x2], ax
	mov	word ptr [rdi+0x4], 3
	lea	rcx, [rdi+0x6]
	jmp	$_146

$_145:	mov	dword ptr [rdi+0x4], eax
	mov	word ptr [rdi+0x2], 3
	lea	rcx, [rdi+0x8]
$_146:	mov	eax, dword ptr [rbp-0x4]
	cmp	dword ptr [rbp-0x8], 0
	jnz	$_147
	mov	word ptr [rcx], ax
	add	rcx, 2
	jmp	$_148

$_147:
	mov	word ptr [rcx], -32764
	mov	dword ptr [rcx+0x2], eax
	add	rcx, 6
$_148:	mov	r8d, dword ptr [rsi+0x14]
	mov	rdx, qword ptr [rsi+0x8]
	call	$_065
	mov	rdx, rax
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x10]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_enum_fields:
	mov	qword ptr [rsp+0x8], rcx
	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, 56
	mov	rsi, rdx
	mov	rcx, qword ptr [rsi+0x78]
	mov	rdi, qword ptr [rcx]
	xor	ebx, ebx
$_149:	test	rdi, rdi
	je	$_156
	mov	rcx, qword ptr [rdi+0x28]
	mov	eax, dword ptr [rdi+0x14]
	test	rcx, rcx
	jz	$_152
	test	eax, eax
	jnz	$_152
	cmp	byte ptr [Options+0xAA+rip], 4
	jnz	$_152
	mov	eax, 6
	lea	rdx, [DS0000+rip]
	cmp	word ptr [rcx+0x6E], 2
	jnz	$_150
	lea	rdx, [DS0001+rip]
	dec	eax
	jmp	$_151

$_150:	cmp	word ptr [rcx+0x6E], 4
	jnz	$_151
	lea	rdx, [DS0002+rip]
$_151:	mov	qword ptr [rdi+0x8], rdx
	mov	dword ptr [rdi+0x14], eax
$_152:	test	eax, eax
	jz	$_153
	mov	r9, qword ptr [rbp+0x40]
	mov	r8, rdi
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	qword ptr [rbp+0x38]
	jmp	$_155

$_153:	test	rcx, rcx
	jz	$_154
	mov	rdx, qword ptr [rbp+0x40]
	mov	eax, dword ptr [rdi+0x30]
	add	dword ptr [rdx+0x8], eax
	mov	r9, rdx
	mov	r8, qword ptr [rbp+0x38]
	mov	rdx, rcx
	mov	rcx, qword ptr [rbp+0x28]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x68]
	mov	rcx, qword ptr [rbp+0x40]
	mov	eax, dword ptr [rdi+0x30]
	sub	dword ptr [rcx+0x8], eax
	jmp	$_155

$_154:	cmp	word ptr [rsi+0x6E], 2
	jnz	$_155
	mov	rax, qword ptr [rdi+0x8]
	mov	qword ptr [rbp-0x8], rax
	mov	r8d, ebx
	lea	rdx, [DS0003+rip]
	lea	rcx, [rbp-0x10]
	call	tsprintf@PLT
	mov	dword ptr [rdi+0x14], eax
	inc	ebx
	lea	rax, [rbp-0x10]
	mov	qword ptr [rdi+0x8], rax
	mov	r9, qword ptr [rbp+0x40]
	mov	r8, rdi
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	qword ptr [rbp+0x38]
	mov	rax, qword ptr [rbp-0x8]
	mov	qword ptr [rdi+0x8], rax
	mov	dword ptr [rdi+0x14], 0
$_155:	mov	rdi, qword ptr [rdi+0x80]
	jmp	$_149

$_156:
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_write_type_procedure:
	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	rbx, rcx
	mov	esi, 16
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_157
	mov	esi, 12
$_157:	mov	edx, esi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	add	qword ptr [rbx+0x10], rsi
	sub	esi, 2
	mov	word ptr [rdi], si
	inc	dword ptr [rbx+0x3C]
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_158
	mov	word ptr [rdi+0x2], 8
	mov	word ptr [rdi+0x4], 3
	mov	byte ptr [rdi+0x6], 0
	mov	byte ptr [rdi+0x7], 0
	mov	eax, dword ptr [rbp+0x38]
	mov	word ptr [rdi+0x8], ax
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0xA], ax
	mov	esi, 6
	mov	eax, 2
	jmp	$_159

$_158:
	mov	word ptr [rdi+0x2], 4104
	mov	dword ptr [rdi+0x4], 3
	mov	byte ptr [rdi+0x8], 0
	mov	byte ptr [rdi+0x9], 0
	mov	eax, dword ptr [rbp+0x38]
	mov	word ptr [rdi+0xA], ax
	mov	eax, dword ptr [rbx+0x3C]
	mov	dword ptr [rdi+0xC], eax
	mov	esi, 8
	mov	eax, 4
$_159:	mul	dword ptr [rbp+0x38]
	add	esi, eax
	mov	edx, esi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	add	qword ptr [rbx+0x10], rsi
	sub	esi, 2
	mov	word ptr [rdi], si
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_160
	mov	word ptr [rdi+0x2], 513
	mov	eax, dword ptr [rbp+0x38]
	mov	word ptr [rdi+0x4], ax
	add	rdi, 6
	jmp	$_161

$_160:
	mov	word ptr [rdi+0x2], 4609
	mov	eax, dword ptr [rbp+0x38]
	mov	dword ptr [rdi+0x4], eax
	add	rdi, 8
$_161:	mov	rsi, qword ptr [rbp+0x30]
	mov	rsi, qword ptr [rsi+0x78]
	mov	rsi, qword ptr [rsi+0x18]
$_162:	test	rsi, rsi
	jz	$_166
	movzx	eax, word ptr [rsi+0x70]
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_163
	stosw
	jmp	$_165

$_163:	cmp	byte ptr [r14+0x5], 2
	jnz	$_164
	dec	dword ptr [rbp+0x38]
	mov	ecx, dword ptr [rbp+0x38]
	mov	dword ptr [rdi+rcx*4], eax
	jmp	$_165

$_164:	stosd
$_165:	mov	rsi, qword ptr [rsi+0x88]
	jmp	$_162

$_166:
	inc	dword ptr [rbx+0x3C]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_write_type:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 72
	mov	rbx, rcx
	mov	rsi, rdx
	cmp	word ptr [rsi+0x6E], 3
	jne	$_173
	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_168
	mov	rcx, qword ptr [rsi+0x50]
	cmp	byte ptr [rsi+0x4A], 128
	jz	$_167
	test	rcx, rcx
	jz	$_167
	cmp	word ptr [rcx+0x6C], 0
	jnz	$_167
	cmp	dword ptr [rbx+0x38], 0
	jnz	$_167
	mov	rdx, qword ptr [rsi+0x50]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_167:	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x38]
	mov	word ptr [rsi+0x6C], ax
	jmp	$_210

$_168:	cmp	byte ptr [rsi+0x1E], 196
	jnz	$_172
	cmp	qword ptr [rsi+0x28], 0
	jz	$_172
	mov	rdi, rsi
	jmp	$_170

$_169:	mov	rdi, qword ptr [rdi+0x28]
$_170:	cmp	qword ptr [rdi+0x28], 0
	jnz	$_169
	cmp	word ptr [rdi+0x6C], 0
	jnz	$_171
	mov	rdx, rdi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_171:	mov	ax, word ptr [rdi+0x6C]
	mov	word ptr [rsi+0x6C], ax
$_172:	jmp	$_210

	jmp	$_174

$_173:	cmp	word ptr [rsi+0x6E], 0
	jnz	$_174
	jmp	$_210

$_174:	xor	eax, eax
	mov	word ptr [rbp-0x18], ax
	cmp	dword ptr [rsi+0x60], 32768
	jc	$_175
	mov	eax, 4
$_175:	mov	dword ptr [rbp-0x10], eax
	cmp	dword ptr [rbx+0x38], 0
	jz	$_176
	mov	word ptr [rbp-0x18], 8
$_176:	mov	rax, qword ptr [rsi+0x8]
	mov	ecx, dword ptr [rsi+0x14]
	test	ecx, ecx
	jne	$_186
	lea	rax, [DS0004+rip]
	mov	ecx, 9
	cmp	byte ptr [rbx+0x50], 4
	jne	$_185
	mov	ecx, 6
	lea	rax, [DS0000+rip]
	cmp	word ptr [rsi+0x6E], 2
	jnz	$_177
	lea	rax, [DS0001+rip]
	dec	ecx
	jmp	$_178

$_177:	cmp	word ptr [rsi+0x6E], 4
	jnz	$_178
	lea	rax, [DS0002+rip]
$_178:	mov	edx, dword ptr [rsi+0x60]
	jmp	$_184

$_179:	lea	rax, [DS0005+rip]
	mov	ecx, 4
	jmp	$_185

$_180:	lea	rax, [DS0006+rip]
	mov	ecx, 4
	jmp	$_185

$_181:	lea	rax, [DS0007+rip]
	mov	ecx, 5
	jmp	$_185

$_182:	lea	rax, [DS0008+rip]
	mov	ecx, 5
	jmp	$_185

$_183:	lea	rax, [DS0009+rip]
	mov	ecx, 5
	jmp	$_185

$_184:	cmp	edx, 1
	jz	$_179
	cmp	edx, 2
	jz	$_180
	cmp	edx, 4
	jz	$_181
	cmp	edx, 8
	jz	$_182
	cmp	edx, 16
	jz	$_183
$_185:	jmp	$_187

$_186:	cmp	word ptr [rsi+0x6C], 0
	jnz	$_187
	test	byte ptr [rsi+0x12], 0x40
	jz	$_187
	or	word ptr [rbp-0x18], 0x80
$_187:	mov	qword ptr [rbp-0x8], rax
	mov	dword ptr [rbp-0xC], ecx
	movzx	eax, word ptr [rsi+0x6E]
	jmp	$_195

$_188:	mov	eax, 12
	mov	word ptr [rbp-0x16], 5382
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_189
	mov	eax, 10
	mov	word ptr [rbp-0x16], 6
	jmp	$_190

$_189:	cmp	byte ptr [rbx+0x50], 2
	jnz	$_190
	mov	eax, 10
	mov	word ptr [rbp-0x16], 4102
$_190:	add	eax, dword ptr [rbp-0x10]
	add	eax, dword ptr [rbp-0xC]
	add	eax, 6
	and	eax, 0xFFFFFFFC
	mov	dword ptr [rbp-0x14], eax
	jmp	$_196

$_191:	or	byte ptr [rbp-0x18], 0x01
$_192:	mov	eax, 20
	mov	word ptr [rbp-0x16], 5381
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_193
	mov	eax, 14
	mov	word ptr [rbp-0x16], 5
	jmp	$_194

$_193:	cmp	byte ptr [rbx+0x50], 2
	jnz	$_194
	mov	eax, 14
	mov	word ptr [rbp-0x16], 4101
$_194:	add	eax, dword ptr [rbp-0x10]
	add	eax, dword ptr [rbp-0xC]
	add	eax, 6
	and	eax, 0xFFFFFFFC
	mov	dword ptr [rbp-0x14], eax
	jmp	$_196

$_195:	cmp	eax, 2
	je	$_188
	cmp	eax, 4
	jz	$_191
	cmp	eax, 1
	jz	$_192
$_196:	mov	dword ptr [rbp-0x28], 0
	mov	dword ptr [rbp-0x24], 0
	mov	dword ptr [rbp-0x20], 0
	test	word ptr [rbp-0x18], 0x80
	jnz	$_197
	mov	rcx, qword ptr [rbx]
	lea	r9, [rbp-0x28]
	mov	r8, qword ptr [rcx+0x58]
	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x68]
$_197:	mov	edx, 4
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	add	qword ptr [rbx+0x10], 4
	mov	eax, 2
	add	eax, dword ptr [rbp-0x24]
	mov	word ptr [rdi], ax
	mov	eax, 4611
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_198
	mov	eax, 516
$_198:	mov	word ptr [rdi+0x2], ax
	mov	dword ptr [rbp-0x20], 0
	test	word ptr [rbp-0x18], 0x80
	jnz	$_199
	mov	rcx, qword ptr [rbx]
	lea	r9, [rbp-0x28]
	mov	r8, qword ptr [rcx+0x60]
	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x68]
$_199:	mov	edx, dword ptr [rbp-0x14]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	mov	rdi, rax
	mov	eax, dword ptr [rbp-0x14]
	sub	eax, 2
	mov	word ptr [rdi], ax
	mov	ax, word ptr [rbp-0x16]
	mov	word ptr [rdi+0x2], ax
	mov	eax, dword ptr [rbp-0x28]
	mov	word ptr [rdi+0x4], ax
	movzx	eax, word ptr [rsi+0x6E]
	jmp	$_206

$_200:	cmp	byte ptr [rbx+0x50], 1
	jnz	$_201
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0x6], ax
	mov	ax, word ptr [rbp-0x18]
	mov	word ptr [rdi+0x8], ax
	lea	rcx, [rdi+0xA]
	jmp	$_202

$_201:	mov	eax, dword ptr [rbx+0x3C]
	mov	dword ptr [rdi+0x8], eax
	mov	ax, word ptr [rbp-0x18]
	mov	word ptr [rdi+0x6], ax
	lea	rcx, [rdi+0xC]
$_202:	inc	dword ptr [rbx+0x3C]
	jmp	$_207

$_203:	cmp	byte ptr [rbx+0x50], 1
	jnz	$_204
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0x6], ax
	mov	ax, word ptr [rbp-0x18]
	mov	word ptr [rdi+0x8], ax
	mov	word ptr [rdi+0xA], 0
	mov	word ptr [rdi+0xC], 0
	lea	rcx, [rdi+0xE]
	jmp	$_205

$_204:	mov	eax, dword ptr [rbx+0x3C]
	mov	dword ptr [rdi+0x8], eax
	mov	ax, word ptr [rbp-0x18]
	mov	word ptr [rdi+0x6], ax
	mov	dword ptr [rdi+0xC], 0
	mov	dword ptr [rdi+0x10], 0
	lea	rcx, [rdi+0x14]
$_205:	inc	dword ptr [rbx+0x3C]
	jmp	$_207

$_206:	cmp	eax, 2
	je	$_200
	cmp	eax, 4
	jz	$_203
	cmp	eax, 1
	jz	$_203
$_207:	mov	rdx, qword ptr [rbp+0x30]
	mov	eax, dword ptr [rdx+0x60]
	cmp	dword ptr [rbp-0x10], 0
	jnz	$_208
	mov	word ptr [rcx], ax
	add	rcx, 2
	jmp	$_209

$_208:
	mov	word ptr [rcx], -32764
	mov	dword ptr [rcx+0x2], eax
	add	rcx, 6
$_209:	mov	r8d, dword ptr [rbp-0xC]
	mov	rdx, qword ptr [rbp-0x8]
	call	$_065
	mov	rdx, rax
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x10]
	mov	eax, dword ptr [rbp-0x14]
	add	qword ptr [rbx+0x10], rax
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rsi+0x6C], ax
	inc	dword ptr [rbx+0x3C]
$_210:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_211:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, rcx
	xor	edi, edi
	xor	ebx, ebx
$_212:	cmp	ebx, 2
	jnc	$_217
	movzx	edx, word ptr [rsi+rbx*2+0x58]
	test	edx, edx
	jz	$_216
	mov	eax, edx
	add	eax, eax
	mov	ecx, dword ptr [r12+rax*8]
	mov	eax, edx
	add	eax, eax
	movzx	eax, byte ptr [r12+rax*8+0xC]
	inc	eax
	test	ecx, 0x2
	jz	$_213
	add	eax, 8
	jmp	$_215

$_213:	test	ecx, 0x4
	jz	$_214
	add	eax, 16
	jmp	$_215

$_214:	test	ecx, 0xC000000
	jz	$_215
	add	eax, 24
$_215:	lea	rcx, [rbx*8]
	shl	eax, cl
	or	edi, eax
$_216:	inc	ebx
	jmp	$_212

$_217:
	mov	eax, edi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_218:
	cmp	ecx, 163
	jc	$_219
	cmp	ecx, 170
	ja	$_219
	lea	rax, [reg64+rip]
	movzx	eax, byte ptr [rax+rcx-0xA3]
	add	eax, 328
	jmp	$_221

$_219:	cmp	ecx, 171
	jc	$_220
	cmp	ecx, 178
	ja	$_220
	lea	eax, [rcx+0xA5]
	jmp	$_221

$_220:	lea	eax, [rcx+0xDD]
$_221:	ret

dbgcv_write_symbol:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 136
	mov	rsi, rdx
	mov	rbx, rcx
	mov	rcx, rsi
	call	GetSymOfssize@PLT
	mov	byte ptr [rbp-0xD], al
	movzx	edx, al
	mov	rcx, rsi
	call	$_068
	mov	dword ptr [rbp-0x4], eax
	test	byte ptr [rsi+0x11], 0x80
	je	$_237
	mov	edi, 32769
	mov	eax, dword ptr [rsi+0x30]
	mov	edx, dword ptr [rsi+0x34]
	test	edx, edx
	jnz	$_222
	cmp	eax, 32768
	jc	$_227
$_222:	test	edx, edx
	jns	$_223
	neg	eax
	neg	edx
	sbb	edx, 0
$_223:	test	edx, edx
	jnz	$_226
	cmp	eax, 255
	ja	$_224
	mov	edi, 32768
	dec	dword ptr [rbp-0x4]
	jmp	$_225

$_224:	cmp	eax, 65535
	jbe	$_225
	mov	edi, 32771
	add	dword ptr [rbp-0x4], 2
$_225:	jmp	$_227

$_226:	add	dword ptr [rbp-0x4], 6
	mov	edi, 32777
$_227:	mov	eax, dword ptr [rbp-0x4]
	mov	ecx, dword ptr [rsi+0x14]
	lea	edx, [rax+rcx+0x1]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rcx, rax
	xchg	rcx, rdi
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_228
	mov	word ptr [rdi+0x2], 3
	mov	word ptr [rdi+0x4], 17
	lea	rdx, [rdi+0x8]
	jmp	$_229

$_228:
	mov	word ptr [rdi+0x2], 4359
	mov	dword ptr [rdi+0x4], 17
	lea	rdx, [rdi+0xA]
$_229:	mov	eax, dword ptr [rsi+0x30]
	cmp	dword ptr [rsi+0x34], 0
	jnz	$_230
	cmp	eax, 32768
	jc	$_235
$_230:	cmp	ecx, 32768
	jnz	$_231
	mov	byte ptr [rdx], al
	mov	eax, ecx
	mov	ecx, 16
	jmp	$_234

$_231:	cmp	ecx, 32769
	jnz	$_232
	mov	word ptr [rdx], ax
	mov	eax, ecx
	mov	ecx, 17
	jmp	$_234

$_232:	cmp	ecx, 32771
	jnz	$_233
	mov	dword ptr [rdx], eax
	mov	eax, ecx
	mov	ecx, 18
	jmp	$_234

$_233:	cmp	ecx, 32777
	jnz	$_234
	mov	dword ptr [rdx], eax
	mov	eax, dword ptr [rsi+0x34]
	mov	dword ptr [rdx+0x4], eax
	mov	eax, ecx
	mov	ecx, 19
$_234:	mov	word ptr [rdi+0x4], cx
$_235:	mov	word ptr [rdx-0x2], ax
	mov	eax, dword ptr [rbp-0x4]
	mov	ecx, dword ptr [rsi+0x14]
	lea	edx, [rax+rcx-0x1]
	mov	word ptr [rdi], dx
	add	qword ptr [rbx+0x8], rax
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_236
	add	edx, 2
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], edx
$_236:	mov	r8d, dword ptr [rsi+0x14]
	mov	rdx, qword ptr [rsi+0x8]
	mov	rcx, qword ptr [rbx+0x8]
	call	$_065
	mov	qword ptr [rbx+0x8], rax
	jmp	$_325

$_237:	mov	ecx, dword ptr [rsi+0x14]
	lea	eax, [rcx+rax+0x1]
	mov	edx, eax
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdi, rax
	cmp	byte ptr [rsi+0x1D], 7
	jne	$_244
	mov	eax, 9
	mov	edx, 4360
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_238
	mov	eax, 7
	mov	edx, 4
$_238:	mov	word ptr [rdi+0x2], dx
	sub	eax, 2
	mov	ecx, dword ptr [rsi+0x14]
	add	eax, ecx
	mov	word ptr [rdi], ax
	cmp	word ptr [rsi+0x6C], 0
	jz	$_239
	movzx	eax, word ptr [rsi+0x6C]
	jmp	$_240

$_239:	movzx	edx, byte ptr [rbp-0xD]
	mov	rcx, rsi
	call	$_001
$_240:	cmp	byte ptr [rbx+0x50], 1
	jnz	$_241
	mov	word ptr [rdi+0x4], ax
	jmp	$_242

$_241:	mov	dword ptr [rdi+0x4], eax
$_242:	test	eax, eax
	jz	$_243
	mov	eax, dword ptr [rbp-0x4]
	add	qword ptr [rbx+0x8], rax
	mov	r8d, dword ptr [rsi+0x14]
	mov	rdx, qword ptr [rsi+0x8]
	mov	rcx, qword ptr [rbx+0x8]
	call	$_065
	mov	qword ptr [rbx+0x8], rax
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_243
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	inc	eax
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], eax
$_243:	jmp	$_325

$_244:	test	byte ptr [rsi+0x10], 0x02
	je	$_273
	cmp	byte ptr [Options+0xAB+rip], 1
	jc	$_273
	mov	rdx, qword ptr [rsi+0x78]
	mov	qword ptr [rbp-0x20], rdx
	mov	rax, qword ptr [rdx+0x18]
	mov	qword ptr [rbp-0x50], rax
	mov	rax, qword ptr [rdx+0x20]
	mov	qword ptr [rbp-0x48], rax
	mov	dword ptr [rbp-0x2C], 0
$_245:	cmp	dword ptr [rbp-0x2C], 2
	jge	$_259
	cmp	byte ptr [r14+0x5], 2
	jnz	$_247
	cmp	dword ptr [rbp-0x2C], 0
	jnz	$_247
	mov	dword ptr [rbp-0x30], 0
	mov	rcx, qword ptr [rbp-0x50]
$_246:	test	rcx, rcx
	jz	$_247
	mov	rsi, rcx
	mov	rcx, qword ptr [rcx+0x88]
	inc	dword ptr [rbp-0x30]
	jmp	$_246

$_247:	mov	ecx, dword ptr [rbp-0x2C]
	mov	dword ptr [rbp+rcx*4-0x3C], 0
	mov	rdi, qword ptr [rbp+rcx*8-0x50]
$_248:	test	rdi, rdi
	je	$_258
	mov	ecx, dword ptr [rbp-0x2C]
	cmp	byte ptr [r14+0x5], 2
	jnz	$_249
	test	ecx, ecx
	jz	$_250
$_249:	mov	rsi, rdi
$_250:	inc	dword ptr [rbp+rcx*4-0x3C]
	cmp	byte ptr [rsi+0x1E], 192
	jnz	$_251
	test	byte ptr [rsi+0x4B], 0x04
	jz	$_251
	mov	word ptr [rbp-0x60], 259
	jmp	$_254

$_251:	cmp	byte ptr [rsi+0x1E], 195
	jnz	$_252
	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x38]
	jmp	$_253

$_252:	movzx	edx, byte ptr [rbp-0xD]
	mov	rcx, rsi
	call	$_001
$_253:	mov	word ptr [rbp-0x60], ax
$_254:	test	byte ptr [rsi+0x10], 0x40
	jz	$_255
	movzx	r9d, byte ptr [rbp-0xD]
	movzx	r8d, word ptr [rbp-0x60]
	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x30]
	mov	eax, dword ptr [rbx+0x3C]
	inc	dword ptr [rbx+0x3C]
	mov	word ptr [rbp-0x60], ax
$_255:	mov	ax, word ptr [rbp-0x60]
	mov	word ptr [rsi+0x70], ax
	cmp	byte ptr [r14+0x5], 2
	jnz	$_257
	cmp	dword ptr [rbp-0x2C], 0
	jnz	$_257
	mov	ecx, 1
	dec	dword ptr [rbp-0x30]
	mov	rsi, qword ptr [rbp-0x50]
$_256:	cmp	dword ptr [rbp-0x30], ecx
	jle	$_257
	inc	ecx
	mov	rsi, qword ptr [rsi+0x88]
	jmp	$_256

$_257:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_248

$_258:	inc	dword ptr [rbp-0x2C]
	jmp	$_245

$_259:	mov	rdi, qword ptr [rbx+0x8]
	mov	rsi, qword ptr [rbp+0x30]
	cmp	byte ptr [rbp-0xD], 0
	jne	$_262
	mov	eax, dword ptr [rsi+0x14]
	add	eax, 28
	mov	word ptr [rdi], ax
	mov	eax, 260
	test	byte ptr [rsi+0x10], 0x04
	jz	$_260
	mov	eax, 261
$_260:	mov	word ptr [rdi+0x2], ax
	mov	dword ptr [rdi+0x4], 0
	mov	dword ptr [rdi+0x8], 0
	mov	dword ptr [rdi+0xC], 0
	mov	eax, dword ptr [rsi+0x60]
	mov	word ptr [rdi+0x10], ax
	mov	rcx, qword ptr [rsi+0x78]
	mov	eax, dword ptr [rcx+0x10]
	mov	word ptr [rdi+0x12], ax
	mov	eax, dword ptr [rsi+0x60]
	mov	word ptr [rdi+0x14], ax
	mov	word ptr [rdi+0x16], 0
	mov	word ptr [rdi+0x18], 0
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0x1A], ax
	xor	eax, eax
	cmp	byte ptr [rsi+0x1E], 130
	jnz	$_261
	mov	eax, 4
$_261:	mov	byte ptr [rdi+0x1C], al
	mov	dword ptr [rbp-0xC], 9
	mov	dword ptr [rbp-0x8], 22
	jmp	$_272

$_262:	mov	dword ptr [rbp-0x5C], 40
	mov	eax, 4367
	test	byte ptr [rsi+0x10], 0x04
	jz	$_263
	mov	eax, 4368
$_263:	mov	word ptr [rbp-0x5E], ax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_265
	mov	dword ptr [rbp-0x5C], 38
	mov	eax, 516
	test	byte ptr [rsi+0x10], 0x04
	jz	$_264
	mov	eax, 517
$_264:	mov	word ptr [rbp-0x5E], ax
$_265:	mov	eax, dword ptr [rbp-0x5C]
	sub	eax, 2
	mov	ecx, dword ptr [rsi+0x14]
	add	eax, ecx
	mov	word ptr [rdi], ax
	mov	ax, word ptr [rbp-0x5E]
	mov	word ptr [rdi+0x2], ax
	mov	dword ptr [rdi+0x4], 0
	mov	dword ptr [rdi+0x8], 0
	mov	dword ptr [rdi+0xC], 0
	mov	eax, dword ptr [rsi+0x60]
	mov	dword ptr [rdi+0x10], eax
	mov	rcx, qword ptr [rsi+0x78]
	mov	eax, dword ptr [rcx+0x10]
	mov	dword ptr [rdi+0x14], eax
	mov	eax, dword ptr [rsi+0x60]
	mov	dword ptr [rdi+0x18], eax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_268
	mov	dword ptr [rdi+0x1C], 0
	mov	word ptr [rdi+0x20], 0
	mov	eax, dword ptr [rbx+0x3C]
	mov	word ptr [rdi+0x22], ax
	mov	byte ptr [rdi+0x24], 0
	cmp	byte ptr [rsi+0x1E], 130
	jnz	$_266
	mov	byte ptr [rdi+0x24], 4
$_266:	mov	rcx, qword ptr [rbp-0x20]
	test	byte ptr [rcx], 0x40
	jz	$_267
	mov	byte ptr [rdi+0x24], 1
$_267:	mov	dword ptr [rbp-0x8], 28
	jmp	$_271

$_268:	mov	dword ptr [rdi+0x20], 0
	mov	word ptr [rdi+0x24], 0
	mov	eax, dword ptr [rbx+0x3C]
	mov	dword ptr [rdi+0x1C], eax
	mov	byte ptr [rdi+0x26], 0
	cmp	byte ptr [rsi+0x1E], 130
	jnz	$_269
	mov	byte ptr [rdi+0x26], 4
$_269:	mov	rcx, qword ptr [rbp-0x20]
	test	byte ptr [rcx], 0x40
	jz	$_270
	mov	byte ptr [rdi+0x26], 1
$_270:	mov	dword ptr [rbp-0x8], 32
$_271:	mov	dword ptr [rbp-0xC], 10
$_272:	mov	r8d, dword ptr [rbp-0x3C]
	mov	rdx, qword ptr [rbp+0x30]
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x48]
	jmp	$_293

$_273:	cmp	byte ptr [rsi+0x1E], 129
	jz	$_274
	cmp	byte ptr [rsi+0x1E], 130
	jne	$_281
$_274:	mov	eax, dword ptr [rsi+0x14]
	cmp	byte ptr [rbp-0xD], 0
	jnz	$_276
	add	eax, 8
	mov	word ptr [rdi], ax
	mov	word ptr [rdi+0x2], 265
	xor	eax, eax
	mov	word ptr [rdi+0x4], ax
	mov	word ptr [rdi+0x6], ax
	cmp	byte ptr [rsi+0x1E], 130
	jnz	$_275
	mov	eax, 4
$_275:	mov	byte ptr [rdi+0x8], al
	mov	dword ptr [rbp-0xC], 9
	mov	dword ptr [rbp-0x8], 4
	jmp	$_280

$_276:	add	eax, 10
	mov	word ptr [rdi], ax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_277
	mov	word ptr [rdi+0x2], 521
	jmp	$_278

$_277:
	mov	word ptr [rdi+0x2], 4357
$_278:	xor	eax, eax
	mov	dword ptr [rdi+0x4], eax
	mov	word ptr [rdi+0x8], ax
	cmp	byte ptr [rsi+0x1E], 130
	jnz	$_279
	mov	eax, 4
$_279:	mov	byte ptr [rdi+0xA], al
	mov	dword ptr [rbp-0xC], 10
	mov	dword ptr [rbp-0x8], 4
$_280:	jmp	$_293

$_281:	test	byte ptr [rsi+0x10], 0x40
	jz	$_282
	movzx	r9d, byte ptr [rbp-0xD]
	xor	r8d, r8d
	mov	rdx, rsi
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x30]
	mov	eax, dword ptr [rbx+0x3C]
	inc	dword ptr [rbx+0x3C]
	jmp	$_283

$_282:	movzx	edx, byte ptr [rbp-0xD]
	mov	rcx, rsi
	call	$_001
$_283:	mov	word ptr [rbp-0x60], ax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_284
	mov	dword ptr [rbp-0x5C], 13
	mov	dword ptr [rdi+0x4], 0
	mov	word ptr [rdi+0x8], 0
	mov	word ptr [rdi+0xA], ax
	mov	dword ptr [rbp-0x8], 4
	jmp	$_285

$_284:	mov	dword ptr [rbp-0x5C], 15
	mov	dword ptr [rdi+0x8], 0
	mov	word ptr [rdi+0xC], 0
	mov	dword ptr [rdi+0x4], eax
	mov	dword ptr [rbp-0x8], 8
$_285:	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x5C]
	sub	eax, 2
	mov	word ptr [rdi], ax
	cmp	byte ptr [rbp-0xD], 0
	jnz	$_287
	mov	eax, 257
	test	byte ptr [rsi+0x10], 0x04
	jz	$_286
	mov	eax, 258
$_286:	mov	word ptr [rbp-0x5E], ax
	mov	dword ptr [rbp-0xC], 9
	jmp	$_292

$_287:	mov	rcx, qword ptr [rsi+0x40]
	mov	eax, 1
	test	byte ptr [r14+0x23], 0x01
	jz	$_288
	cmp	qword ptr [rcx+0x50], 0
	jz	$_288
	mov	rcx, qword ptr [rcx+0x50]
	lea	rdx, [DS000A+rip]
	mov	rcx, qword ptr [rcx+0x8]
	call	tstrcmp@PLT
	test	rax, rax
	jnz	$_288
	mov	ecx, 525
	test	byte ptr [rsi+0x10], 0x04
	jz	$_288
	mov	ecx, 526
$_288:	test	eax, eax
	jz	$_291
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_290
	mov	ecx, 513
	test	byte ptr [rsi+0x10], 0x04
	jz	$_289
	mov	ecx, 514
$_289:	jmp	$_291

$_290:	mov	ecx, 4364
	test	byte ptr [rsi+0x10], 0x04
	jz	$_291
	mov	ecx, 4365
$_291:	mov	word ptr [rbp-0x5E], cx
	mov	dword ptr [rbp-0xC], 10
$_292:	mov	ax, word ptr [rbp-0x5E]
	mov	word ptr [rdi+0x2], ax
$_293:	mov	eax, dword ptr [rbp-0x8]
	add	qword ptr [rbx+0x8], rax
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_294
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], eax
$_294:	mov	rax, qword ptr [rbx+0x20]
	mov	rdi, qword ptr [rax+0x78]
	mov	rax, qword ptr [rbx+0x8]
	sub	rax, qword ptr [rdi+0x10]
	add	eax, dword ptr [rdi+0x8]
	mov	dword ptr [rdi+0xC], eax
	cmp	dword ptr [Options+0x8C+rip], 2
	jnz	$_296
	xor	r8d, r8d
	mov	edx, 13
	mov	rcx, rsi
	call	CreateFixup@PLT
	mov	rcx, rax
	mov	eax, dword ptr [rdi+0xC]
	mov	dword ptr [rcx+0x14], eax
	mov	r8, qword ptr [rbx+0x8]
	mov	rdx, qword ptr [rbx+0x20]
	call	store_fixup@PLT
	xor	r8d, r8d
	mov	edx, 8
	mov	rcx, rsi
	call	CreateFixup@PLT
	mov	rcx, rax
	mov	eax, 2
	cmp	dword ptr [rbp-0xC], 10
	jnz	$_295
	mov	eax, 4
$_295:	add	eax, dword ptr [rdi+0xC]
	mov	dword ptr [rcx+0x14], eax
	mov	r8, qword ptr [rbx+0x8]
	mov	rdx, qword ptr [rbx+0x20]
	call	store_fixup@PLT
	jmp	$_297

$_296:	xor	r8d, r8d
	mov	edx, dword ptr [rbp-0xC]
	mov	rcx, rsi
	call	CreateFixup@PLT
	mov	rcx, rax
	mov	eax, dword ptr [rdi+0xC]
	mov	dword ptr [rcx+0x14], eax
	mov	r8, qword ptr [rbx+0x8]
	mov	rdx, qword ptr [rbx+0x20]
	call	store_fixup@PLT
$_297:	mov	eax, dword ptr [rbp-0x4]
	sub	eax, dword ptr [rbp-0x8]
	add	qword ptr [rbx+0x8], rax
	mov	r8d, dword ptr [rsi+0x14]
	mov	rdx, qword ptr [rsi+0x8]
	mov	rcx, qword ptr [rbx+0x8]
	call	$_065
	mov	qword ptr [rbx+0x8], rax
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_298
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	sub	eax, dword ptr [rbp-0x8]
	inc	eax
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], eax
$_298:	test	byte ptr [rsi+0x10], 0x02
	je	$_325
	cmp	byte ptr [Options+0xAB+rip], 1
	jc	$_325
	mov	dword ptr [rbp-0x2C], 0
$_299:	cmp	dword ptr [rbp-0x2C], 2
	jge	$_324
	cmp	byte ptr [r14+0x5], 2
	jnz	$_301
	cmp	dword ptr [rbp-0x2C], 0
	jnz	$_301
	mov	dword ptr [rbp-0x30], 0
	mov	rcx, qword ptr [rbp-0x50]
$_300:	test	rcx, rcx
	jz	$_301
	inc	dword ptr [rbp-0x30]
	mov	rsi, rcx
	mov	rcx, qword ptr [rcx+0x88]
	jmp	$_300

$_301:	mov	ecx, dword ptr [rbp-0x2C]
	mov	rdi, qword ptr [rbp+rcx*8-0x50]
$_302:	test	rdi, rdi
	je	$_323
	cmp	byte ptr [r14+0x5], 2
	jnz	$_303
	cmp	dword ptr [rbp-0x2C], 0
	jz	$_304
$_303:	mov	rsi, rdi
$_304:	cmp	byte ptr [rsi+0x1D], 10
	jne	$_308
	mov	dword ptr [rbp-0x4], 10
	mov	word ptr [rbp-0x5E], 4358
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_305
	mov	dword ptr [rbp-0x4], 8
	mov	word ptr [rbp-0x5E], 2
$_305:	mov	edx, dword ptr [rsi+0x14]
	add	edx, dword ptr [rbp-0x4]
	inc	edx
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdx, rax
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	lea	eax, [rax-0x1]
	mov	word ptr [rdx], ax
	mov	ax, word ptr [rbp-0x5E]
	mov	word ptr [rdx+0x2], ax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_306
	mov	ax, word ptr [rsi+0x70]
	mov	word ptr [rdx+0x4], ax
	mov	rcx, rsi
	call	$_211
	mov	rdx, qword ptr [rbx+0x8]
	mov	word ptr [rdx+0x6], ax
	jmp	$_307

$_306:	movzx	eax, word ptr [rsi+0x70]
	mov	dword ptr [rdx+0x4], eax
	mov	rcx, rsi
	call	$_211
	mov	rdx, qword ptr [rbx+0x8]
	mov	word ptr [rdx+0x8], ax
$_307:	jmp	$_319

$_308:	cmp	byte ptr [rbp-0xD], 0
	jnz	$_309
	mov	dword ptr [rbp-0x4], 8
	mov	edx, dword ptr [rsi+0x14]
	add	edx, dword ptr [rbp-0x4]
	inc	edx
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdx, rax
	mov	eax, 7
	add	eax, dword ptr [rsi+0x14]
	mov	word ptr [rdx], ax
	mov	word ptr [rdx+0x2], 256
	mov	eax, dword ptr [rsi+0x30]
	mov	word ptr [rdx+0x4], ax
	mov	ax, word ptr [rsi+0x70]
	mov	word ptr [rdx+0x6], ax
	jmp	$_319

$_309:	mov	rcx, qword ptr [rbp-0x20]
	mov	ecx, dword ptr [rcx+0x14]
	mov	eax, ecx
	add	eax, eax
	cmp	byte ptr [rbp-0xD], 2
	jz	$_310
	cmp	byte ptr [r12+rax*8+0xC], 5
	je	$_316
$_310:	mov	dword ptr [rbp-0x4], 14
	mov	word ptr [rbp-0x5E], 4369
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_311
	mov	dword ptr [rbp-0x4], 12
	mov	word ptr [rbp-0x5E], 524
$_311:	mov	edx, dword ptr [rsi+0x14]
	add	edx, dword ptr [rbp-0x4]
	inc	edx
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdx, rax
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	lea	eax, [rax-0x1]
	mov	word ptr [rdx], ax
	mov	ax, word ptr [rbp-0x5E]
	mov	word ptr [rdx+0x2], ax
	mov	rcx, qword ptr [rbp-0x20]
	mov	ecx, dword ptr [rcx+0x14]
	mov	eax, ecx
	add	eax, eax
	cmp	dword ptr [r12+rax*8+0x8], 128
	jnz	$_312
	call	$_218
	mov	dword ptr [rbp-0x5C], eax
	jmp	$_313

$_312:	mov	eax, ecx
	add	eax, eax
	movzx	eax, byte ptr [r12+rax*8+0xC]
	mov	dword ptr [rbp-0x5C], eax
	add	dword ptr [rbp-0x5C], 17
$_313:	mov	rdx, qword ptr [rbx+0x8]
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_314
	mov	eax, dword ptr [rsi+0x30]
	mov	dword ptr [rdx+0x4], eax
	mov	ax, word ptr [rsi+0x70]
	mov	word ptr [rdx+0xA], ax
	mov	eax, dword ptr [rbp-0x5C]
	mov	word ptr [rdx+0x8], ax
	jmp	$_315

$_314:	mov	eax, dword ptr [rsi+0x30]
	mov	dword ptr [rdx+0x4], eax
	movzx	eax, word ptr [rsi+0x70]
	mov	dword ptr [rdx+0x8], eax
	mov	eax, dword ptr [rbp-0x5C]
	mov	word ptr [rdx+0xC], ax
$_315:	jmp	$_319

$_316:	mov	dword ptr [rbp-0x4], 12
	mov	word ptr [rbp-0x5E], 4363
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_317
	mov	dword ptr [rbp-0x4], 10
	mov	word ptr [rbp-0x5E], 512
$_317:	mov	edx, dword ptr [rsi+0x14]
	add	edx, dword ptr [rbp-0x4]
	inc	edx
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdx, rax
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	lea	eax, [rax-0x1]
	mov	word ptr [rdx], ax
	mov	ax, word ptr [rbp-0x5E]
	mov	word ptr [rdx+0x2], ax
	cmp	byte ptr [rbx+0x50], 1
	jnz	$_318
	mov	eax, dword ptr [rsi+0x30]
	mov	dword ptr [rdx+0x4], eax
	mov	ax, word ptr [rsi+0x70]
	mov	word ptr [rdx+0x8], ax
	jmp	$_319

$_318:	mov	eax, dword ptr [rsi+0x30]
	mov	dword ptr [rdx+0x4], eax
	movzx	eax, word ptr [rsi+0x70]
	mov	dword ptr [rdx+0x8], eax
$_319:
	mov	word ptr [rsi+0x70], 0
	mov	eax, dword ptr [rbp-0x4]
	add	qword ptr [rbx+0x8], rax
	mov	r8d, dword ptr [rsi+0x14]
	mov	rdx, qword ptr [rsi+0x8]
	mov	rcx, qword ptr [rbx+0x8]
	call	$_065
	mov	qword ptr [rbx+0x8], rax
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_320
	mov	eax, dword ptr [rsi+0x14]
	add	eax, dword ptr [rbp-0x4]
	inc	eax
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], eax
$_320:	cmp	byte ptr [r14+0x5], 2
	jnz	$_322
	cmp	dword ptr [rbp-0x2C], 0
	jnz	$_322
	mov	ecx, 1
	dec	dword ptr [rbp-0x30]
	mov	rsi, qword ptr [rbp-0x50]
$_321:	cmp	dword ptr [rbp-0x30], ecx
	jle	$_322
	inc	ecx
	mov	rsi, qword ptr [rsi+0x88]
	jmp	$_321

$_322:	mov	rdi, qword ptr [rdi+0x88]
	jmp	$_302

$_323:	inc	dword ptr [rbp-0x2C]
	jmp	$_299

$_324:	mov	edx, 4
	mov	rcx, rbx
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	word ptr [rax], 2
	mov	word ptr [rax+0x2], 6
	add	qword ptr [rbx+0x8], 4
	cmp	byte ptr [rbx+0x50], 4
	jnz	$_325
	mov	rcx, qword ptr [rbx+0x18]
	add	dword ptr [rcx+0x4], 4
$_325:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

dbgcv_flush_section:
	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	rbx, rcx
	mov	rdi, qword ptr [rbx+0x20]
	mov	rsi, qword ptr [rbx+0x8]
	mov	rcx, qword ptr [rdi+0x78]
	mov	rax, qword ptr [rcx+0x10]
	mov	qword ptr [rbx+0x8], rax
	sub	rsi, rax
	mov	eax, dword ptr [rbp+0x38]
	lea	rcx, [rsi+rax+0x18]
	call	LclAlloc@PLT
	mov	rdi, rax
	mov	qword ptr [rdi], 0
	lea	rax, [rsi+0x8]
	add	eax, dword ptr [rbp+0x38]
	mov	dword ptr [rdi+0x8], eax
	lea	rcx, [rdi+rsi+0x10]
	mov	qword ptr [rbx+0x18], rcx
	mov	eax, dword ptr [rbp+0x30]
	mov	dword ptr [rcx], eax
	mov	eax, dword ptr [rbp+0x38]
	mov	dword ptr [rcx+0x4], eax
	test	esi, esi
	jz	$_326
	mov	ecx, esi
	lea	rdx, [rdi+0x10]
	mov	rax, qword ptr [rbx+0x8]
	xchg	rsi, rax
	xchg	rdx, rdi
	rep movsb
	mov	rdi, rdx
	mov	rsi, rax
$_326:	mov	rdx, qword ptr [rbx+0x30]
	lea	rcx, [rdx+0x48]
	mov	rdx, qword ptr [rcx]
	cmp	rdx, qword ptr [rbx+0x20]
	jz	$_327
	sub	rcx, 24
$_327:	cmp	qword ptr [rcx+0x8], 0
	jnz	$_328
	mov	qword ptr [rcx+0x8], rdi
	mov	qword ptr [rcx+0x10], rdi
	jmp	$_329

$_328:	mov	rdx, qword ptr [rcx+0x10]
	mov	qword ptr [rdx], rdi
	mov	qword ptr [rcx+0x10], rdi
$_329:	mov	rdx, qword ptr [rbx+0x20]
	mov	rcx, qword ptr [rdx+0x78]
	mov	eax, dword ptr [rcx+0x8]
	lea	rax, [rsi+rax+0x8]
	add	eax, dword ptr [rbp+0x38]
	mov	dword ptr [rcx+0xC], eax
	mov	dword ptr [rcx+0x8], eax
	mov	rax, qword ptr [rbx+0x18]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

cv_write_debug_tables:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 216
	lea	rax, [vtable+rip]
	mov	qword ptr [rbp-0x68], rax
	mov	rsi, rcx
	mov	qword ptr [rbp-0x48], rsi
	mov	rcx, qword ptr [rsi+0x78]
	mov	rsi, qword ptr [rcx+0x10]
	mov	rdi, qword ptr [rbp+0x30]
	mov	qword ptr [rbp-0x40], rdi
	mov	rcx, qword ptr [rdi+0x78]
	mov	rdi, qword ptr [rcx+0x10]
	mov	dword ptr [rbp-0x2C], 4096
	mov	dword ptr [rbp-0x30], 0
	mov	rax, qword ptr [rbp+0x38]
	mov	qword ptr [rbp-0x38], rax
	movzx	eax, byte ptr [Options+0xAA+rip]
	mov	byte ptr [rbp-0x18], al
	stosd
	mov	qword ptr [rbp-0x58], rdi
	mov	dword ptr [rsi], eax
	add	rsi, 4
	mov	qword ptr [rbp-0x60], rsi
	cmp	eax, 4
	jne	$_366
	imul	ecx, dword ptr [r14+0x230], 12
	call	LclAlloc@PLT
	mov	qword ptr [rbp-0x28], rax
	mov	rdi, rax
	xor	eax, eax
	mov	rsi, qword ptr [r14+0x228]
	mov	ebx, dword ptr [r14+0x230]
$_330:	test	ebx, ebx
	jz	$_331
	movsq
	stosd
	dec	ebx
	jmp	$_330

$_331:	mov	ecx, 1040
	call	LclAlloc@PLT
	mov	rdi, rax
	mov	esi, 1040
	call	getcwd@PLT
	mov	rcx, rdi
	call	tstrlen@PLT
	mov	dword ptr [rbp-0x70], eax
	add	rax, rdi
	mov	qword ptr [rbp-0x10], rax
	mov	qword ptr [rbp-0x20], rdi
	xor	r8d, r8d
	mov	edx, 243
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x20]
	mov	rbx, rax
	inc	dword ptr [rbx+0x4]
	mov	rdi, qword ptr [rbp-0x60]
	mov	byte ptr [rdi], 0
	inc	qword ptr [rbp-0x60]
	mov	rdi, qword ptr [rbp-0x28]
	mov	dword ptr [rbp-0x4], 0
$_332:	mov	eax, dword ptr [r14+0x230]
	cmp	dword ptr [rbp-0x4], eax
	jge	$_334
	mov	eax, dword ptr [rbx+0x4]
	mov	dword ptr [rdi+0x8], eax
	mov	rsi, qword ptr [rdi]
	mov	eax, dword ptr [rsi]
	cmp	al, 92
	jz	$_333
	cmp	al, 46
	jz	$_333
	cmp	ah, 58
	jz	$_333
	lea	rdx, [DS000B+rip]
	mov	rcx, qword ptr [rbp-0x10]
	call	tstrcpy@PLT
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp-0x10]
	call	tstrcat@PLT
	mov	rsi, qword ptr [rbp-0x20]
$_333:	mov	rcx, rsi
	call	tstrlen@PLT
	inc	rax
	mov	dword ptr [rbp-0x8], eax
	mov	edx, eax
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	xchg	rdi, rax
	mov	ecx, dword ptr [rbp-0x8]
	add	qword ptr [rbp-0x60], rcx
	add	dword ptr [rbx+0x4], ecx
	rep movsb
	mov	rdi, rax
	inc	dword ptr [rbp-0x4]
	add	rdi, 12
	jmp	$_332

$_334:	mov	rcx, qword ptr [rbp-0x10]
	mov	byte ptr [rcx], 0
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x18]
	mov	eax, dword ptr [rbx+0x4]
	add	eax, 3
	and	eax, 0xFFFFFFFC
	add	eax, 8
	mov	dword ptr [rbp-0x6C], eax
	xor	r8d, r8d
	mov	edx, 244
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x20]
	mov	rbx, rax
	mov	rsi, qword ptr [rbp-0x28]
	mov	dword ptr [rbp-0x4], 0
$_335:	mov	eax, dword ptr [r14+0x230]
	cmp	dword ptr [rbp-0x4], eax
	jge	$_336
	mov	edx, 8
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdi, rax
	mov	eax, dword ptr [rsi+0x8]
	stosd
	mov	eax, dword ptr [rbx+0x4]
	mov	dword ptr [rsi+0x8], eax
	xor	eax, eax
	stosd
	add	dword ptr [rbx+0x4], 8
	mov	qword ptr [rbp-0x60], rdi
	inc	dword ptr [rbp-0x4]
	add	rsi, 12
	jmp	$_335

$_336:	mov	eax, dword ptr [rbx+0x4]
	add	eax, 3
	and	eax, 0xFFFFFFFC
	add	eax, 20
	add	dword ptr [rbp-0x6C], eax
	mov	rcx, qword ptr [CV8Label+rip]
	xor	eax, eax
	test	rcx, rcx
	jz	$_337
	mov	rcx, qword ptr [rcx+0x40]
	mov	rcx, qword ptr [rcx+0x78]
	mov	eax, dword ptr [rcx+0x18]
$_337:	test	eax, eax
	jz	$_338
	mov	dword ptr [rbp-0x74], 0
	xor	r8d, r8d
	mov	edx, 13
	mov	rcx, qword ptr [CV8Label+rip]
	call	CreateFixup@PLT
	mov	rcx, rax
	mov	eax, dword ptr [rbp-0x6C]
	mov	dword ptr [rcx+0x14], eax
	lea	r8, [rbp-0x74]
	mov	rdx, qword ptr [rbp-0x48]
	call	store_fixup@PLT
	xor	r8d, r8d
	mov	edx, 8
	mov	rcx, qword ptr [CV8Label+rip]
	call	CreateFixup@PLT
	mov	rcx, rax
	mov	eax, dword ptr [rbp-0x6C]
	add	eax, 4
	mov	dword ptr [rcx+0x14], eax
	lea	r8, [rbp-0x74]
	mov	rdx, qword ptr [rbp-0x48]
	call	store_fixup@PLT
$_338:	mov	qword ptr [rbp-0x50], 0
	mov	rsi, qword ptr [SymTables+0x20+rip]
$_339:	test	rsi, rsi
	je	$_352
	mov	rbx, qword ptr [rsi+0x78]
	cmp	qword ptr [rbx+0x38], 0
	je	$_351
	cmp	qword ptr [rbp-0x50], 0
	jz	$_340
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x18]
$_340:	mov	r8d, 24
	mov	edx, 242
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x20]
	mov	rdi, rax
	add	rdi, 8
	mov	qword ptr [rbp-0x80], rdi
	mov	dword ptr [rdi], 0
	mov	word ptr [rdi+0x4], 0
	mov	word ptr [rdi+0x6], 0
	mov	eax, dword ptr [rsi+0x60]
	mov	dword ptr [rdi+0x8], eax
	add	rdi, 12
	mov	qword ptr [rbp-0x88], rdi
	mov	dword ptr [rdi], 0
	mov	dword ptr [rdi+0x4], 0
	mov	dword ptr [rdi+0x8], 0
	mov	rbx, qword ptr [rbx+0x38]
	mov	rbx, qword ptr [rbx]
	jmp	$_350

$_341:	mov	eax, dword ptr [rbx+0x10]
	cmp	dword ptr [rbx+0x8], 0
	jnz	$_342
	mov	eax, dword ptr [rbx+0xC]
	shr	eax, 20
$_342:	mov	dword ptr [rbp-0xA4], eax
	mov	rcx, qword ptr [rbp-0x88]
	mov	dword ptr [rcx+0x8], 12
	mov	rdx, qword ptr [rbp-0x28]
	imul	eax, eax, 12
	mov	eax, dword ptr [rdx+rax+0x8]
	mov	dword ptr [rcx], eax
	mov	qword ptr [rbp-0xA0], 0
$_343:	test	rbx, rbx
	je	$_350
	cmp	dword ptr [rbx+0x8], 0
	jnz	$_344
	mov	eax, dword ptr [rbx+0xC]
	shr	eax, 20
	mov	ecx, dword ptr [rbx+0xC]
	mov	rdx, qword ptr [rbx+0x10]
	mov	edx, dword ptr [rdx+0x30]
	jmp	$_345

$_344:	mov	eax, dword ptr [rbx+0x10]
	mov	ecx, dword ptr [rbx+0x8]
	mov	edx, dword ptr [rbx+0xC]
$_345:	cmp	dword ptr [rbp-0xA4], eax
	jz	$_346
	mov	edx, 12
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	qword ptr [rbp-0x88], rax
	xor	edx, edx
	mov	ecx, 12
	add	qword ptr [rbp-0x60], rcx
	mov	dword ptr [rax], edx
	mov	dword ptr [rax+0x4], edx
	mov	dword ptr [rax+0x8], edx
	mov	rax, qword ptr [rbp-0x80]
	add	dword ptr [rax-0x4], ecx
	jmp	$_350

$_346:	mov	dword ptr [rbp-0xA8], eax
	mov	dword ptr [rbp-0xAC], ecx
	mov	dword ptr [rbp-0xB0], edx
	mov	rcx, qword ptr [rbp-0xA0]
	test	rcx, rcx
	jz	$_348
	mov	eax, dword ptr [rcx+0x4]
	and	eax, 0xFFFFFF
	cmp	edx, dword ptr [rcx]
	jc	$_347
	cmp	edx, dword ptr [rcx]
	jnz	$_348
	cmp	eax, dword ptr [rbp-0xAC]
	jnz	$_348
$_347:	jmp	$_349

$_348:	mov	edx, 8
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	qword ptr [rbp-0x98], rax
	add	qword ptr [rbp-0x60], 8
	mov	rcx, qword ptr [rbp-0x50]
	add	dword ptr [rcx+0x4], 8
	mov	rcx, qword ptr [rbp-0x88]
	inc	dword ptr [rcx+0x4]
	add	dword ptr [rcx+0x8], 8
	mov	rcx, qword ptr [rbp-0x98]
	mov	eax, dword ptr [rbp-0xB0]
	mov	dword ptr [rcx], eax
	mov	eax, dword ptr [rbp-0xAC]
	mov	dword ptr [rcx+0x4], eax
	or	byte ptr [rcx+0x7], 0x80
	mov	qword ptr [rbp-0xA0], rcx
$_349:	mov	rbx, qword ptr [rbx]
	jmp	$_343

$_350:	test	rbx, rbx
	jne	$_341
$_351:	mov	rsi, qword ptr [rsi+0x80]
	jmp	$_339

$_352:	cmp	qword ptr [rbp-0x50], 0
	jz	$_353
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x18]
$_353:	xor	r8d, r8d
	mov	edx, 241
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x20]
	mov	rsi, qword ptr [rbp-0x60]
	mov	qword ptr [rbp-0xB8], rsi
	mov	rdi, qword ptr [r14+0x210]
	mov	eax, dword ptr [rdi]
	cmp	al, 92
	jz	$_354
	cmp	al, 46
	jz	$_354
	cmp	ah, 58
	jz	$_354
	lea	rdx, [DS000B+rip]
	mov	rcx, qword ptr [rbp-0x10]
	call	tstrcpy@PLT
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp-0x10]
	call	tstrcat@PLT
	mov	rdi, qword ptr [rbp-0x20]
$_354:	mov	rcx, rdi
	call	tstrlen@PLT
	mov	dword ptr [rbp-0x8], eax
	add	eax, 7
	mov	word ptr [rsi], ax
	mov	word ptr [rsi+0x2], 4353
	mov	dword ptr [rsi+0x4], 0
	add	qword ptr [rbp-0x60], 8
	mov	r8d, dword ptr [rbp-0x8]
	mov	rdx, rdi
	mov	rcx, qword ptr [rbp-0x60]
	call	$_065
	mov	qword ptr [rbp-0x60], rax
	mov	rcx, qword ptr [rbp-0x10]
	mov	byte ptr [rcx], 0
	mov	rdi, qword ptr [rbp-0x60]
	mov	word ptr [rdi+0x2], 4412
	lea	rdx, [DS000C+rip]
	lea	rcx, [rdi+0x1A]
	call	tstrcpy@PLT
	mov	word ptr [rdi], 46
	add	qword ptr [rbp-0x60], 48
	mov	rdx, qword ptr [rbp-0x60]
	mov	byte ptr [rdx-0x1], 0
	mov	dword ptr [rdi+0x4], 3
	mov	al, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_355
	mov	eax, 208
	jmp	$_357

$_355:	cmp	eax, 6
	jc	$_356
	mov	eax, 6
	jmp	$_357

$_356:	test	eax, eax
	jnz	$_357
	inc	eax
$_357:	mov	word ptr [rdi+0x8], ax
	mov	word ptr [rdi+0xA], 0
	mov	word ptr [rdi+0xC], 0
	mov	word ptr [rdi+0xE], 0
	mov	word ptr [rdi+0x10], 0
	mov	word ptr [rdi+0x12], 2
	mov	word ptr [rdi+0x14], 39
	mov	word ptr [rdi+0x16], 0
	mov	word ptr [rdi+0x18], 0
	mov	rdi, qword ptr [rbp-0x60]
	mov	byte ptr [rdi+0x4], 0
	mov	word ptr [rdi+0x2], 4413
	lea	rdi, [rdi+0x5]
	mov	rsi, qword ptr [rbp-0x20]
	mov	ebx, dword ptr [rbp-0x70]
	mov	eax, 6584163
	stosd
	lea	ecx, [rbx+0x1]
	rep movsb
	mov	eax, 6649957
	stosd
	mov	rsi, qword ptr [_pgmptr+rip]
	mov	rcx, rsi
	call	tstrlen@PLT
	inc	rax
	mov	ecx, eax
	rep movsb
	mov	eax, 6517363
	stosd
	mov	rdx, qword ptr [rbp-0x28]
	mov	rsi, qword ptr [rdx]
	mov	r8d, ebx
	mov	rdx, qword ptr [rbp-0x20]
	mov	rcx, rsi
	call	tmemicmp@PLT
	test	eax, eax
	jnz	$_358
	lea	rsi, [rsi+rbx+0x1]
$_358:	mov	rcx, rsi
	call	tstrlen@PLT
	inc	rax
	mov	ecx, eax
	rep movsb
	xor	eax, eax
	stosb
	mov	rax, rdi
	mov	rdx, qword ptr [rbp-0x60]
	sub	rax, rdx
	sub	rax, 2
	mov	word ptr [rdx], ax
	mov	qword ptr [rbp-0x60], rdi
	mov	rbx, qword ptr [rbp-0x50]
	sub	rdi, qword ptr [rbp-0xB8]
	add	dword ptr [rbx+0x4], edi
	xor	esi, esi
	jmp	$_360

$_359:	mov	rsi, rax
	mov	rcx, rax
	call	$_087
	cmp	eax, 1
	jnz	$_360
	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_360:	lea	rdx, [rbp-0x4]
	mov	rcx, rsi
	call	SymEnum@PLT
	test	rax, rax
	jnz	$_359
	xor	esi, esi
	jmp	$_365

$_361:	mov	rsi, rax
	mov	rcx, rax
	call	$_087
	cmp	eax, 1
	jnz	$_362
	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
	jmp	$_365

$_362:	cmp	eax, 2
	jnz	$_365
	mov	rdi, rdx
	mov	rcx, rdx
	call	$_087
	cmp	eax, 1
	jnz	$_363
	mov	rdx, rdi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
	mov	rcx, rsi
	call	$_087
$_363:	cmp	eax, 1
	jz	$_364
	or	byte ptr [rsi+0x12], 0x40
$_364:	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_365:	lea	rdx, [rbp-0x4]
	mov	rcx, rsi
	call	SymEnum@PLT
	test	rax, rax
	jnz	$_361
	jmp	$_379

$_366:	mov	rsi, qword ptr [r14+0x210]
	mov	rcx, rsi
	call	tstrlen@PLT
	mov	rbx, rax
$_367:	test	ebx, ebx
	jz	$_370
	mov	al, byte ptr [rsi+rbx-0x1]
	cmp	al, 47
	jz	$_368
	cmp	al, 92
	jnz	$_369
$_368:	jmp	$_370

$_369:	dec	ebx
	jmp	$_367

$_370:	add	rsi, rbx
	mov	rcx, rsi
	call	tstrlen@PLT
	mov	ecx, eax
	mov	rdi, qword ptr [rbp-0x60]
	add	eax, 7
	mov	word ptr [rdi], ax
	mov	word ptr [rdi+0x2], 9
	mov	dword ptr [rdi+0x4], 1
	add	rdi, 8
	mov	r8d, ecx
	mov	rdx, rsi
	mov	rcx, rdi
	call	$_065
	mov	rdi, rax
	lea	rcx, [DS000C+rip]
	call	tstrlen@PLT
	mov	ebx, eax
	add	eax, 7
	mov	word ptr [rdi], ax
	mov	word ptr [rdi+0x2], 1
	mov	al, byte ptr [r14+0x14]
	and	eax, 0x9F
	test	eax, 0x80
	jz	$_371
	mov	eax, 208
	jmp	$_373

$_371:	cmp	eax, 6
	jc	$_372
	mov	eax, 6
	jmp	$_373

$_372:	test	eax, eax
	jnz	$_373
	inc	eax
$_373:	mov	byte ptr [rdi+0x4], al
	mov	byte ptr [rdi+0x5], 3
	mov	word ptr [rdi+0x6], 0
	mov	cl, byte ptr [r14+0x15]
	test	cl, cl
	jz	$_378
	mov	edx, 1
	shl	edx, cl
	cmp	cl, 6
	jnz	$_374
	or	byte ptr [rdi+0x6], 0x00
	jmp	$_376

$_374:	mov	eax, 0
	test	edx, 0x68
	jz	$_375
	mov	eax, 1
$_375:	shl	eax, 5
	or	word ptr [rdi+0x6], ax
$_376:	mov	eax, 0
	test	edx, 0x70
	jz	$_377
	mov	eax, 1
$_377:	shl	eax, 8
	or	word ptr [rdi+0x6], ax
$_378:	add	rdi, 8
	mov	r8d, ebx
	lea	rdx, [DS000C+rip]
	mov	rcx, rdi
	call	$_065
	mov	qword ptr [rbp-0x60], rax
$_379:	xor	esi, esi
	jmp	$_381

$_380:	mov	rsi, rax
	cmp	byte ptr [rsi+0x1D], 7
	jnz	$_381
	cmp	word ptr [rsi+0x6E], 3
	jz	$_381
	cmp	word ptr [rsi+0x6C], 0
	jnz	$_381
	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_381:	lea	rdx, [rbp-0x4]
	mov	rcx, rsi
	call	SymEnum@PLT
	test	rax, rax
	jnz	$_380
	cmp	byte ptr [rbp-0x18], 4
	jnz	$_384
	xor	esi, esi
	jmp	$_383

$_382:	mov	rsi, rax
	cmp	byte ptr [rsi+0x1D], 7
	jnz	$_383
	cmp	word ptr [rsi+0x6E], 3
	jz	$_383
	cmp	word ptr [rsi+0x6C], 0
	jz	$_383
	test	byte ptr [rsi+0x12], 0x40
	jz	$_383
	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x40]
$_383:	lea	rdx, [rbp-0x4]
	mov	rcx, rsi
	call	SymEnum@PLT
	test	rax, rax
	jnz	$_382
$_384:	xor	esi, esi
	jmp	$_393

$_385:	mov	rsi, rax
	jmp	$_392

$_386:	cmp	byte ptr [Options+0xAB+rip], 2
	jc	$_394
$_387:	movzx	edx, byte ptr [rsi+0x10]
	and	edx, 0x08
	shr	edx, 3
	movzx	ecx, byte ptr [rsi+0x11]
	and	ecx, 0x80
	shr	ecx, 7
	movzx	eax, byte ptr [rsi+0x10]
	and	eax, 0x80
	shr	eax, 7
	cmp	byte ptr [Options+0xAB+rip], 3
	jnc	$_388
	mov	eax, ecx
$_388:	cmp	byte ptr [rbp-0x18], 4
	jnz	$_389
	cmp	rsi, qword ptr [CV8Label+rip]
	jz	$_390
$_389:	test	eax, eax
	jnz	$_390
	test	edx, edx
	jz	$_391
$_390:	jmp	$_393

$_391:	mov	rdx, rsi
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x50]
	jmp	$_393

$_392:	cmp	byte ptr [rsi+0x1D], 7
	jz	$_386
	cmp	byte ptr [rsi+0x1D], 1
	jz	$_387
$_393:	lea	rdx, [rbp-0x4]
	mov	rcx, rsi
	call	SymEnum@PLT
	test	rax, rax
	jne	$_385
$_394:	mov	edx, 4096
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax]
	cmp	byte ptr [rbp-0x18], 4
	jnz	$_395
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x18]
$_395:	mov	edx, 4096
	lea	rcx, [rbp-0x68]
	mov	rax, qword ptr [rcx]
	call	qword ptr [rax+0x8]
	mov	rdi, qword ptr [rbp+0x30]
	mov	rdx, qword ptr [rdi+0x78]
	mov	eax, dword ptr [rdx+0xC]
	mov	dword ptr [rdi+0x60], eax
	mov	dword ptr [rdx+0x8], 0
	mov	rdi, qword ptr [rbp+0x28]
	mov	rdx, qword ptr [rdi+0x78]
	mov	eax, dword ptr [rdx+0xC]
	mov	dword ptr [rdi+0x60], eax
	mov	dword ptr [rdx+0x8], 0
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret


.SECTION .data
	.ALIGN	16

reg64:
	.byte  0x00, 0x02, 0x03, 0x01, 0x07, 0x06, 0x04, 0x05

DS0000:
	.byte  0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x00

DS0001:
	.byte  0x75, 0x6E, 0x69, 0x6F, 0x6E, 0x00

DS0002:
	.byte  0x72, 0x65, 0x63, 0x6F, 0x72, 0x64, 0x00

DS0003:
	.byte  0x40, 0x40, 0x25, 0x75, 0x00

DS0004:
	.byte  0x5F, 0x5F, 0x75, 0x6E, 0x6E, 0x61, 0x6D, 0x65
	.byte  0x64, 0x00

DS0005:
	.byte  0x62, 0x79, 0x74, 0x65, 0x00

DS0006:
	.byte  0x77, 0x6F, 0x72, 0x64, 0x00

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

DS0008:
	.byte  0x71, 0x77, 0x6F, 0x72, 0x64, 0x00

DS0009:
	.byte  0x6F, 0x77, 0x6F, 0x72, 0x64, 0x00

DS000A:
	.byte  0x54, 0x4C, 0x53, 0x00

vtable:
	.quad  dbgcv_flushpt
	.quad  dbgcv_flushps
	.quad  dbgcv_padbytes
	.quad  dbgcv_alignps
	.quad  dbgcv_flush_section
	.quad  dbgcv_write_bitfield
	.quad  dbgcv_write_array_type
	.quad  dbgcv_write_ptr_type
	.quad  dbgcv_write_type
	.quad  dbgcv_write_type_procedure
	.quad  dbgcv_write_symbol
	.quad  dbgcv_cntproc
	.quad  dbgcv_memberproc
	.quad  dbgcv_enum_fields

DS000B:
	.byte  0x5C, 0x00

DS000C:
	.byte  0x41, 0x73, 0x6D, 0x63, 0x20, 0x4D, 0x61, 0x63
	.byte  0x72, 0x6F, 0x20, 0x41, 0x73, 0x73, 0x65, 0x6D
	.byte  0x62, 0x6C, 0x65, 0x72, 0x00


.att_syntax prefix
