
.intel_syntax noprefix

.global __mulo
.global __divo
.global __shlo
.global __shro
.global __rolo
.global __roro
.global __saro
.global __cvtq_ss
.global __cvtq_sd
.global __cvtq_ld
.global __cmpq
.global __addq
.global __subq
.global __mulq
.global __divq
.global __sqrtq
.global _lk_fltscale
.global _fltscale
.global _atoow
.global _atoqw
.global atofloat
.global ftoquad
.global quadtof
.global quad_resize
.global __modq
.global _flttostr

.extern asmerr
.extern Parse_Pass
.extern tmemset


.SECTION .text
	.ALIGN	16

__mulo:
	mov	rax, qword ptr [rcx]
	mov	r10, qword ptr [rcx+0x8]
	mov	r9, qword ptr [rdx+0x8]
	test	r10, r10
	jnz	$_002
	test	r9, r9
	jnz	$_002
	test	r8, r8
	jz	$_001
	mov	qword ptr [r8], r9
	mov	qword ptr [r8+0x8], r9
$_001:	mul	qword ptr [rdx]
	jmp	$_004

$_002:	push	rcx
	mov	r11, qword ptr [rdx]
	mul	r11
	push	rax
	xchg	r11, rdx
	mov	rax, r10
	mul	rdx
	add	r11, rax
	xchg	rdx, rcx
	mov	rax, qword ptr [rdx]
	mul	r9
	add	r11, rax
	adc	rcx, rdx
	mov	edx, 0
	adc	edx, 0
	test	r8, r8
	jz	$_003
	xchg	r9, rdx
	mov	rax, r10
	mul	rdx
	add	rax, rcx
	adc	rdx, r9
	mov	qword ptr [r8], rax
	mov	qword ptr [r8+0x8], rdx
$_003:	pop	rax
	mov	rdx, r11
	pop	rcx
$_004:	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], rdx
	mov	rax, rcx
	ret

__divo:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x18], r8
	push	rbp
	mov	rbp, rsp
	mov	r9, qword ptr [rcx]
	mov	rcx, qword ptr [rcx+0x8]
	mov	r10, qword ptr [rdx]
	mov	r11, qword ptr [rdx+0x8]
	xor	eax, eax
	xor	edx, edx
	test	r10, r10
	jnz	$_005
	test	r11, r11
	jnz	$_005
	xor	r9d, r9d
	xor	ecx, ecx
	jmp	$_013

$_005:	cmp	r11, rcx
	jnz	$_006
	cmp	r10, r9
$_006:	ja	$_013
	jnz	$_007
	xor	r9d, r9d
	xor	ecx, ecx
	inc	eax
	jmp	$_013

$_007:	mov	r8d, 4294967295
$_008:	inc	r8d
	shl	r10, 1
	rcl	r11, 1
	jc	$_009
	cmp	r11, rcx
	ja	$_009
	jc	$_008
	cmp	r10, r9
	jc	$_008
	jz	$_008
$_009:	rcr	r11, 1
	rcr	r10, 1
	sub	r9, r10
	sbb	rcx, r11
	cmc
	jc	$_012
$_010:	add	rax, rax
	adc	rdx, rdx
	dec	r8d
	jns	$_011
	add	r9, r10
	adc	rcx, r11
	jmp	$_013

$_011:	shr	r11, 1
	rcr	r10, 1
	add	r9, r10
	adc	rcx, r11
	jnc	$_010
$_012:	adc	rax, rax
	adc	rdx, rdx
	dec	r8d
	jns	$_009
$_013:	mov	r10, qword ptr [rbp+0x20]
	test	r10, r10
	jz	$_014
	mov	qword ptr [r10], r9
	mov	qword ptr [r10+0x8], rcx
$_014:	mov	r10, rax
	mov	rax, qword ptr [rbp+0x10]
	mov	qword ptr [rax], r10
	mov	qword ptr [rax+0x8], rdx
	leave
	ret

__shlo:
	mov	r10, rcx
	mov	ecx, edx
	mov	rax, qword ptr [r10]
	mov	rdx, qword ptr [r10+0x8]
	cmp	ecx, 128
	jnc	$_015
	cmp	ecx, 64
	jc	$_016
	cmp	r8d, 128
	jnc	$_016
$_015:	xor	eax, eax
	xor	edx, edx
	jmp	$_020

$_016:	cmp	r8d, 128
	jnz	$_019
	jmp	$_018

$_017:	mov	rdx, rax
	xor	eax, eax
	sub	ecx, 64
$_018:	cmp	ecx, 64
	jnc	$_017
	shld	rdx, rax, cl
	shl	rax, cl
	jmp	$_020

$_019:	shl	rax, cl
$_020:	mov	qword ptr [r10], rax
	mov	qword ptr [r10+0x8], rdx
	mov	rax, r10
	ret

__shro:
	mov	r10, rcx
	mov	ecx, edx
	mov	rax, qword ptr [r10]
	mov	rdx, qword ptr [r10+0x8]
	cmp	ecx, 128
	jnc	$_021
	cmp	ecx, 64
	jc	$_022
	cmp	r8d, 128
	jnc	$_022
$_021:	xor	edx, edx
	xor	eax, eax
	jmp	$_027

$_022:	cmp	r8d, 128
	jnz	$_025
	jmp	$_024

$_023:	mov	rax, rdx
	xor	edx, edx
	sub	ecx, 64
$_024:	cmp	ecx, 64
	ja	$_023
	shrd	rax, rdx, cl
	shr	rdx, cl
	jmp	$_027

$_025:	cmp	eax, -1
	jnz	$_026
	cmp	r8d, 32
	jnz	$_026
	and	eax, eax
$_026:	shr	rax, cl
$_027:	mov	qword ptr [r10], rax
	mov	qword ptr [r10+0x8], rdx
	mov	rax, r10
	ret

__rolo:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	edi, r8d
	jmp	$_029

$_028:	mov	ecx, edi
	shr	ecx, 3
	movzx	ebx, byte ptr [rsi+rcx-0x1]
	mov	r8d, edi
	mov	edx, 1
	mov	rcx, rsi
	call	__shlo
	shr	ebx, 7
	or	byte ptr [rsi], bl
	dec	dword ptr [rbp+0x30]
$_029:	cmp	dword ptr [rbp+0x30], 0
	jnz	$_028
	mov	rax, rsi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

__roro:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, rcx
	mov	edi, r8d
	jmp	$_031

$_030:	mov	bl, byte ptr [rsi]
	mov	r8d, edi
	mov	edx, 1
	mov	rcx, rsi
	call	__shro
	shl	ebx, 7
	mov	ecx, edi
	shr	ecx, 3
	or	byte ptr [rsi+rcx-0x1], bl
	dec	dword ptr [rbp+0x30]
$_031:	cmp	dword ptr [rbp+0x30], 0
	jnz	$_030
	mov	rax, rsi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

__saro:
	mov	r10, rcx
	mov	ecx, edx
	mov	rax, qword ptr [r10]
	mov	rdx, qword ptr [r10+0x8]
	cmp	ecx, 64
	jc	$_032
	cmp	r8d, 64
	ja	$_032
	xor	eax, eax
	xor	edx, edx
	jmp	$_038

$_032:	cmp	ecx, 128
	jc	$_033
	cmp	r8d, 128
	jnz	$_033
	sar	rdx, 63
	mov	rax, rdx
	jmp	$_038

$_033:	cmp	r8d, 128
	jnz	$_035
	cmp	ecx, 64
	jc	$_034
	mov	rax, rdx
	sar	rdx, 63
	sub	ecx, 64
$_034:	shrd	rax, rdx, cl
	sar	rdx, cl
	jmp	$_038

$_035:	cmp	eax, -1
	jnz	$_036
	cmp	r8d, 32
	jnz	$_036
	mov	eax, eax
$_036:	cmp	r8d, 32
	jnz	$_037
	sar	eax, cl
	jmp	$_038

$_037:	sar	rax, cl
$_038:	mov	qword ptr [r10], rax
	mov	qword ptr [r10+0x8], rdx
	mov	rax, r10
	ret

$_039:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rsi, rdx
	mov	rdi, rcx
	mov	eax, dword ptr [rsi+0xA]
	mov	cx, word ptr [rsi+0xE]
	shr	eax, 1
	test	ecx, 0x7FFF
	jz	$_040
	or	eax, 0x80000000
$_040:	mov	edx, eax
	shl	edx, 12
	mov	edx, 4292870144
	jnc	$_042
	jnz	$_041
	cmp	dword ptr [rsi+0x6], 0
	jnz	$_041
	shl	edx, 1
$_041:	add	eax, 2097152
	jnc	$_042
	mov	eax, 2147483648
	inc	cx
$_042:	mov	ebx, ecx
	and	cx, 0x7FFF
	je	$_048
	cmp	cx, 32767
	jnz	$_044
	test	eax, 0x7FFFFFFF
	jz	$_043
	mov	eax, 4294967295
	jmp	$_049

$_043:	mov	eax, 4160749568
	shl	bx, 1
	rcr	eax, 1
	jmp	$_049

$_044:
	add	cx, -16368
	jns	$_045
	mov	dword ptr [qerrno+rip], 34
	mov	eax, 65536
	jmp	$_049

$_045:	cmp	cx, 31
	jnc	$_046
	cmp	cx, 30
	jnz	$_047
	cmp	eax, edx
	jbe	$_047
$_046:	mov	dword ptr [qerrno+rip], 34
	mov	eax, 4160618496
	shl	bx, 1
	rcr	eax, 1
	jmp	$_049

$_047:	and	eax, edx
	shl	eax, 1
	shrd	eax, ecx, 5
	shl	bx, 1
	rcr	eax, 1
	test	cx, cx
	jnz	$_049
	cmp	eax, 1
	jge	$_049
	mov	ebx, eax
	mov	dword ptr [qerrno+rip], 34
	mov	eax, ebx
	jmp	$_049

$_048:	and	eax, edx
$_049:	shr	eax, 16
	mov	ecx, eax
	mov	rax, rdi
	mov	word ptr [rax], cx
	cmp	rax, rsi
	jnz	$_050
	xor	ecx, ecx
	mov	word ptr [rax+0x2], cx
	mov	dword ptr [rax+0x4], ecx
	mov	dword ptr [rax+0x8], ecx
	mov	dword ptr [rax+0xC], ecx
$_050:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

__cvtq_ss:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rbx, rdx
	mov	edx, 4294967040
	mov	eax, dword ptr [rbx+0xA]
	mov	cx, word ptr [rbx+0xE]
	and	ecx, 0x7FFF
	neg	ecx
	rcr	eax, 1
	mov	ecx, eax
	shl	ecx, 25
	mov	cx, word ptr [rbx+0xE]
	jnc	$_052
	jnz	$_051
	cmp	dword ptr [rbx+0x6], 0
	jnz	$_051
	shl	edx, 1
$_051:	add	eax, 256
	jnc	$_052
	mov	eax, 2147483648
	inc	cx
$_052:	and	eax, edx
	mov	ebx, ecx
	and	cx, 0x7FFF
	jz	$_056
	cmp	cx, 32767
	jnz	$_053
	shl	eax, 1
	shr	eax, 8
	or	eax, 0xFF000000
	shl	bx, 1
	rcr	eax, 1
	jmp	$_056

$_053:
	add	cx, -16256
	jns	$_054
	mov	dword ptr [qerrno+rip], 34
	xor	eax, eax
	jmp	$_056

$_054:
	cmp	cx, 255
	jl	$_055
	mov	dword ptr [qerrno+rip], 34
	mov	eax, 4278190080
	shl	bx, 1
	rcr	eax, 1
	jmp	$_056

$_055:	shl	eax, 1
	shrd	eax, ecx, 8
	shl	bx, 1
	rcr	eax, 1
	test	cx, cx
	jnz	$_056
	cmp	eax, 8388608
	jge	$_056
	mov	ebx, eax
	mov	dword ptr [qerrno+rip], 34
	mov	eax, ebx
$_056:	mov	ecx, eax
	mov	rax, qword ptr [rbp+0x18]
	mov	dword ptr [rax], ecx
	cmp	rax, qword ptr [rbp+0x20]
	jnz	$_057
	xor	ecx, ecx
	mov	dword ptr [rax+0x4], ecx
	mov	dword ptr [rax+0x8], ecx
	mov	dword ptr [rax+0xC], ecx
$_057:	leave
	pop	rbx
	ret

__cvtq_sd:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rax, rdx
	movzx	ecx, word ptr [rax+0xE]
	mov	edx, dword ptr [rax+0xA]
	mov	ebx, ecx
	and	ebx, 0x7FFF
	mov	edi, ebx
	neg	ebx
	mov	eax, dword ptr [rax+0x6]
	rcr	edx, 1
	rcr	eax, 1
	mov	esi, 4294965248
	mov	ebx, eax
	shl	ebx, 22
	jnc	$_059
	jnz	$_058
	shl	ebx, 1
$_058:	add	eax, 2048
	adc	edx, 0
	jnc	$_059
	mov	edx, 2147483648
	inc	cx
$_059:	and	eax, esi
	mov	ebx, ecx
	and	cx, 0x7FFF
	add	cx, -15360
	cmp	cx, 2047
	jnc	$_062
	test	cx, cx
	jnz	$_060
	shrd	eax, edx, 12
	shl	edx, 1
	shr	edx, 12
	jmp	$_061

$_060:	shrd	eax, edx, 11
	shl	edx, 1
	shrd	edx, ecx, 11
$_061:	shl	bx, 1
	rcr	edx, 1
	jmp	$_067

$_062:
	cmp	cx, -15360
	jc	$_066
	cmp	cx, -52
	jl	$_064
	sub	cx, 12
	neg	cx
	cmp	cl, 32
	jc	$_063
	sub	cl, 32
	mov	esi, eax
	mov	eax, edx
	xor	edx, edx
$_063:	shrd	esi, eax, cl
	shrd	eax, edx, cl
	shr	edx, cl
	add	esi, esi
	adc	eax, 0
	adc	edx, 0
	jmp	$_065

$_064:	xor	eax, eax
	xor	edx, edx
	shl	ebx, 17
	rcr	edx, 1
$_065:	jmp	$_067

$_066:	shrd	eax, edx, 11
	shl	edx, 1
	shr	edx, 11
	shl	bx, 1
	rcr	edx, 1
	or	edx, 0x7FF00000
$_067:	xor	ebx, ebx
	cmp	edi, 15308
	jnc	$_070
	mov	rcx, qword ptr [rbp+0x30]
	test	edi, edi
	jnz	$_068
	cmp	edi, dword ptr [rcx+0x6]
	jnz	$_068
	cmp	edi, dword ptr [rcx+0xA]
	jz	$_069
$_068:	xor	eax, eax
	xor	edx, edx
	mov	ebx, 34
$_069:	jmp	$_073

$_070:	cmp	edi, 15309
	jc	$_072
	mov	edi, edx
	and	edi, 0x7FF00000
	mov	ebx, 34
	jz	$_071
	cmp	edi, 2146435072
	jz	$_071
	xor	ebx, ebx
$_071:	jmp	$_073

$_072:	cmp	edi, 15308
	jc	$_073
	mov	edi, edx
	or	edi, eax
	mov	ebx, 34
	jz	$_073
	mov	edi, edx
	and	edi, 0x7FF00000
	jz	$_073
	xor	ebx, ebx
$_073:	mov	rdi, qword ptr [rbp+0x28]
	mov	dword ptr [rdi], eax
	mov	dword ptr [rdi+0x4], edx
	test	ebx, ebx
	jz	$_074
	mov	dword ptr [qerrno+rip], ebx
$_074:	cmp	rdi, qword ptr [rbp+0x30]
	jnz	$_075
	xor	eax, eax
	mov	dword ptr [rdi+0x8], eax
	mov	dword ptr [rdi+0xC], eax
$_075:	mov	rax, rdi
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

__cvtq_ld:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rax, rcx
	mov	rdi, rdx
	xor	ecx, ecx
	mov	ebx, dword ptr [rdi+0x6]
	mov	edx, dword ptr [rdi+0xA]
	mov	cx, word ptr [rdi+0xE]
	mov	esi, ecx
	and	esi, 0x7FFF
	neg	esi
	rcr	edx, 1
	rcr	ebx, 1
	jnc	$_077
	cmp	ebx, -1
	jnz	$_076
	cmp	edx, -1
	jnz	$_076
	xor	ebx, ebx
	mov	edx, 2147483648
	inc	cx
	jmp	$_077

$_076:	add	ebx, 1
	adc	edx, 0
$_077:	mov	dword ptr [rax], ebx
	mov	dword ptr [rax+0x4], edx
	cmp	rax, rdi
	jnz	$_078
	mov	dword ptr [rax+0x8], ecx
	mov	dword ptr [rax+0xC], 0
	jmp	$_079

$_078:	mov	word ptr [rax+0x8], cx
$_079:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_080:
	mov	rax, rcx
	movsx	edx, word ptr [rdx]
	mov	ecx, edx
	shl	edx, 21
	sar	ecx, 10
	and	cx, 0x1F
	test	cl, cl
	jz	$_084
	cmp	cl, 31
	jz	$_081
	add	cx, 16368
	jmp	$_083

$_081:
	or	cx, 0x7FE0
	test	edx, 0x7FFFFFFF
	jz	$_082
	mov	dword ptr [qerrno+rip], 33
	mov	ecx, 65535
	mov	edx, 1073741824
	jmp	$_083

$_082:	xor	edx, edx
$_083:	jmp	$_086

$_084:	test	edx, edx
	jz	$_086
	or	cx, 0x3FF1
$_085:	test	edx, edx
	js	$_086
	shl	edx, 1
	dec	cx
	jmp	$_085

$_086:
	shl	ecx, 1
	rcr	cx, 1
	mov	word ptr [rax+0xE], cx
	shl	edx, 1
	mov	dword ptr [rax+0xA], edx
	xor	edx, edx
	mov	qword ptr [rax], rdx
	mov	dword ptr [rax+0x8], edx
	ret

$_087:
	mov	rax, rcx
	mov	edx, dword ptr [rdx]
	mov	ecx, edx
	shl	edx, 8
	sar	ecx, 23
	xor	ch, ch
	test	cl, cl
	jz	$_090
	cmp	cl, 255
	jz	$_088
	add	cx, 16256
	jmp	$_089

$_088:	or	ch, 0xFF
	test	edx, 0x7FFFFFFF
	jnz	$_089
	or	edx, 0x40000000
	mov	dword ptr [qerrno+rip], 33
$_089:	jmp	$_092

$_090:	test	edx, edx
	jz	$_092
	or	cx, 0x3F81
$_091:	test	edx, edx
	js	$_092
	shl	edx, 1
	dec	cx
	jmp	$_091

$_092:
	add	ecx, ecx
	rcr	cx, 1
	mov	word ptr [rax+0xE], cx
	shl	edx, 1
	mov	dword ptr [rax+0xA], edx
	xor	edx, edx
	mov	dword ptr [rax], edx
	mov	dword ptr [rax+0x4], edx
	mov	word ptr [rax+0x8], dx
	ret

$_093:
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	rbx, rcx
	mov	eax, dword ptr [rdx]
	mov	edx, dword ptr [rdx+0x4]
	mov	ecx, edx
	shld	edx, eax, 11
	shl	eax, 11
	sar	ecx, 20
	and	cx, 0x7FF
	jz	$_097
	cmp	cx, 2047
	jz	$_094
	add	cx, 15360
	jmp	$_096

$_094:	or	ch, 0x7F
	test	edx, 0x7FFFFFFF
	jnz	$_095
	test	eax, eax
	jz	$_096
$_095:	or	edx, 0x40000000
$_096:	or	edx, 0x80000000
	jmp	$_100

$_097:	test	edx, edx
	jnz	$_098
	test	eax, eax
	jz	$_100
$_098:	or	ecx, 0x3C01
	test	edx, edx
	jnz	$_099
	xchg	edx, eax
	sub	cx, 32
$_099:	test	edx, edx
	js	$_100
	shl	eax, 1
	rcl	edx, 1
	dec	rcx
	jnz	$_099
$_100:	add	ecx, ecx
	rcr	cx, 1
	shl	eax, 1
	rcl	edx, 1
	xchg	rbx, rax
	mov	dword ptr [rax+0x6], ebx
	mov	dword ptr [rax+0xA], edx
	mov	word ptr [rax+0xE], cx
	xor	ebx, ebx
	mov	dword ptr [rax], ebx
	mov	word ptr [rax+0x4], bx
	leave
	pop	rbx
	ret

$_101:
	mov	rax, qword ptr [rdx]
	movzx	edx, word ptr [rdx+0x8]
	add	dx, dx
	rcr	dx, 1
	shl	rax, 1
	shld	rdx, rax, 48
	shl	rax, 48
	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], rdx
	mov	rax, rcx
	ret

__cmpq:
	mov	rax, qword ptr [rdx]
	cmp	qword ptr [rcx], rax
	jnz	$_102
	mov	rax, qword ptr [rdx+0x8]
	cmp	qword ptr [rcx+0x8], rax
	jnz	$_102
	xor	eax, eax
	jmp	$_108

$_102:	cmp	byte ptr [rcx+0xF], 0
	jl	$_103
	cmp	byte ptr [rdx+0xF], 0
	jge	$_103
	mov	eax, 1
	jmp	$_108

$_103:	cmp	byte ptr [rcx+0xF], 0
	jge	$_104
	cmp	byte ptr [rdx+0xF], 0
	jl	$_104
	mov	rax, -1
	jmp	$_108

$_104:	cmp	byte ptr [rcx+0xF], 0
	jge	$_106
	mov	rax, qword ptr [rcx+0x8]
	cmp	qword ptr [rdx+0x8], rax
	jnz	$_105
	mov	rax, qword ptr [rcx]
	cmp	qword ptr [rdx], rax
$_105:	jmp	$_107

$_106:	mov	rax, qword ptr [rdx+0x8]
	cmp	qword ptr [rcx+0x8], rax
	jnz	$_107
	mov	rax, qword ptr [rdx]
	cmp	qword ptr [rcx], rax
$_107:	sbb	eax, eax
	sbb	eax, -1
$_108:	ret

$_109:
	mov	rax, qword ptr [rdx]
	mov	r8, qword ptr [rdx+0x8]
	shld	r9, r8, 16
	shld	r8, rax, 16
	shl	rax, 16
	mov	word ptr [rcx+0x10], r9w
	and	r9d, 0x7FFF
	neg	r9d
	rcr	r8, 1
	rcr	rax, 1
	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], r8
	mov	rax, rcx
	ret

$_110:
	mov	rax, qword ptr [rcx]
	test	eax, 0x4000
	jz	$_112
	mov	rdx, qword ptr [rcx+0x8]
	add	rax, 16384
	adc	rdx, 0
	jnc	$_111
	rcr	rdx, 1
	rcr	rax, 1
	inc	word ptr [rcx+0x10]
	cmp	word ptr [rcx+0x10], 32767
	jnz	$_111
	mov	word ptr [rcx+0x10], 32767
	xor	eax, eax
	xor	edx, edx
$_111:	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], rdx
$_112:	mov	rax, rcx
	ret

$_113:
	mov	qword ptr [rsp+0x8], rcx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	rcx, rdx
	call	$_110
	mov	rax, qword ptr [rcx]
	mov	rdx, qword ptr [rcx+0x8]
	mov	cx, word ptr [rcx+0x10]
	shl	rax, 1
	rcl	rdx, 1
	shrd	rax, rdx, 16
	shrd	rdx, rcx, 16
	mov	rcx, qword ptr [rbp+0x10]
	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], rdx
	mov	rax, rcx
	leave
	ret

$_114:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	r11, rcx
	mov	rbx, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	mov	si, word ptr [rdx+0x10]
	shl	esi, 16
	mov	rax, qword ptr [rcx]
	mov	rdx, qword ptr [rcx+0x8]
	mov	si, word ptr [rcx+0x10]
	add	si, 1
	jc	$_137
	jo	$_137
	add	esi, 65535
	jc	$_140
	jo	$_140
	sub	esi, 65536
	xor	esi, r8d
	mov	rcx, rax
	or	rcx, rdx
	je	$_131
$_115:	mov	rcx, rbx
	or	rcx, rdi
	je	$_133
$_116:	mov	ecx, esi
	rol	esi, 16
	sar	esi, 16
	sar	ecx, 16
	and	esi, 0x80007FFF
	and	ecx, 0x80007FFF
	mov	r9d, ecx
	rol	esi, 16
	rol	ecx, 16
	add	cx, si
	rol	esi, 16
	rol	ecx, 16
	sub	cx, si
	jz	$_118
	jnc	$_117
	mov	r9d, esi
	neg	cx
	xchg	rbx, rax
	xchg	rdi, rdx
$_117:
	cmp	cx, 128
	jbe	$_118
	mov	esi, r9d
	shl	esi, 1
	rcr	si, 1
	mov	rax, rbx
	mov	rdx, rdi
	jmp	$_130

$_118:	mov	esi, r9d
	mov	ch, 0
	test	ecx, ecx
	jns	$_119
	mov	ch, 255
	neg	rdi
	neg	rbx
	sbb	rdi, 0
	xor	esi, 0x80000000
$_119:	mov	r8d, 0
	test	cl, cl
	jz	$_123
	cmp	cl, 64
	jc	$_122
	test	rax, rax
	jz	$_120
	inc	r8d
$_120:	cmp	cl, 128
	jnz	$_121
	shr	rdx, 32
	or	r8d, edx
	xor	edx, edx
$_121:	mov	rax, rdx
	xor	edx, edx
$_122:	xor	r9d, r9d
	shrd	r9d, eax, cl
	or	r8d, r9d
	shrd	rax, rdx, cl
	shr	rdx, cl
$_123:	add	rax, rbx
	adc	rdx, rdi
	adc	ch, 0
	jns	$_125
	cmp	cl, 128
	jnz	$_124
	test	r8d, 0x7FFFFFFF
	jz	$_124
	add	rax, 1
	adc	rdx, 0
$_124:	neg	rdx
	neg	rax
	sbb	rdx, 0
	xor	ch, ch
	xor	esi, 0x80000000
$_125:	mov	r9d, ecx
	and	r9d, 0xFF00
	or	r9, rax
	or	r9, rdx
	jnz	$_126
	xor	esi, esi
$_126:	test	si, si
	jz	$_130
	test	ch, ch
	mov	ecx, r8d
	jnz	$_128
	rol	ecx, 1
	rol	ecx, 1
$_127:	dec	si
	jz	$_129
	adc	rax, rax
	adc	rdx, rdx
	jnc	$_127
$_128:	inc	si
	cmp	si, 32767
	je	$_135
	stc
	rcr	rdx, 1
	rcr	rax, 1
	add	ecx, ecx
	jnc	$_129
	adc	rax, 0
	adc	rdx, 0
	jnc	$_129
	rcr	rdx, 1
	rcr	rax, 1
	inc	si
	cmp	si, 32767
	jz	$_135
$_129:	add	esi, esi
	rcr	si, 1
$_130:	mov	qword ptr [r11], rax
	mov	qword ptr [r11+0x8], rdx
	mov	word ptr [r11+0x10], si
	mov	rax, r11
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_131:	shl	si, 1
	jnz	$_132
	shr	esi, 16
	mov	rax, rbx
	mov	rdx, rdi
	shl	esi, 1
	mov	rcx, rax
	or	rcx, rdx
	jz	$_130
	shr	esi, 1
	jmp	$_130

$_132:	rcr	si, 1
	jmp	$_115

$_133:	test	esi, 0x7FFF0000
	jz	$_130
	jmp	$_116

$_134:	mov	esi, 65535
	movabs	rdx, 0x4000000000000000
	xor	eax, eax
	jmp	$_130

$_135:	mov	esi, 32767
	xor	eax, eax
	xor	edx, edx
	jmp	$_130

$_136:	mov	rax, rbx
	mov	rdx, rdi
	shr	esi, 16
	jmp	$_130

$_137:	dec	si
	add	esi, 65536
	jc	$_138
	jo	$_138
	jns	$_130
	mov	rcx, rax
	or	rcx, rdx
	jne	$_130
	xor	esi, 0x8000
	jmp	$_130

$_138:	sub	esi, 65536
	mov	rcx, rax
	or	rcx, rdx
	or	rcx, rbx
	or	rcx, rdi
	jnz	$_139
	or	esi, 0xFFFFFFFF
	jmp	$_134

$_139:	cmp	rdx, rdi
	jc	$_136
	ja	$_130
	cmp	rax, rbx
	jbe	$_136
	jmp	$_130

$_140:
	sub	esi, 65536
	mov	rcx, rbx
	or	rcx, rdi
	jnz	$_136
	mov	ecx, esi
	shl	ecx, 16
	xor	esi, ecx
	and	esi, 0x80000000
	jmp	$_136

$_141:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	xor	r8d, r8d
	call	$_114
	leave
	ret

$_142:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	r8d, 2147483648
	call	$_114
	leave
	ret

$_143:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	r12
	push	r13
	push	rbp
	mov	rbp, rsp
	mov	rbx, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	mov	si, word ptr [rdx+0x10]
	shl	esi, 16
	mov	rax, qword ptr [rcx]
	mov	rdx, qword ptr [rcx+0x8]
	mov	si, word ptr [rcx+0x10]
	add	si, 1
	jc	$_166
	jo	$_166
	add	esi, 65535
	jc	$_168
	jo	$_168
	sub	esi, 65536
	mov	rcx, rbx
	or	rcx, rdi
	je	$_159
$_144:	mov	rcx, rax
	or	rcx, rdx
	je	$_157
$_145:	mov	ecx, esi
	rol	ecx, 16
	sar	ecx, 16
	sar	esi, 16
	and	ecx, 0x80007FFF
	and	esi, 0x80007FFF
	rol	ecx, 16
	rol	esi, 16
	add	cx, si
	rol	ecx, 16
	rol	esi, 16
	test	cx, cx
	je	$_155
$_146:	test	si, si
	je	$_156
$_147:	sub	cx, si
	add	cx, 16383
	js	$_148
	cmp	cx, 32767
	ja	$_162
$_148:	cmp	cx, -65
	jl	$_161
	mov	r13, rcx
	mov	r12, rbp
	shrd	rax, rdx, 14
	shr	rdx, 14
	shrd	rbx, rdi, 14
	shr	rdi, 14
	mov	ecx, 115
	mov	rbp, rdi
	mov	r10, rax
	mov	r11, rdx
	xor	eax, eax
	xor	edx, edx
	xor	r8d, r8d
	xor	r9d, r9d
	xor	edi, edi
	xor	esi, esi
	add	rbx, rbx
	adc	rbp, rbp
$_149:	shr	rbp, 1
	rcr	rbx, 1
	rcr	r9, 1
	rcr	r8, 1
	sub	rdi, r8
	sbb	rsi, r9
	sbb	r10, rbx
	sbb	r11, rbp
	cmc
	jc	$_151
$_150:	add	rax, rax
	adc	rdx, rdx
	dec	ecx
	jz	$_152
	shr	rbp, 1
	rcr	rbx, 1
	rcr	r9, 1
	rcr	r8, 1
	add	rdi, r8
	adc	rsi, r9
	adc	r10, rbx
	adc	r11, rbp
	jnc	$_150
$_151:	adc	rax, rax
	adc	rdx, rdx
	dec	ecx
	jnz	$_149
$_152:	mov	rsi, r13
	mov	rbp, r12
	dec	si
	bt	rax, 0
	adc	rax, 0
	adc	rdx, 0
	bt	rdx, 50
	jnc	$_153
	rcr	rdx, 1
	rcr	rax, 1
	add	esi, 1
$_153:	shld	rdx, rax, 14
	shl	rax, 14
	test	si, si
	jle	$_164
	add	esi, esi
	rcr	si, 1
$_154:	mov	rcx, qword ptr [rbp+0x38]
	mov	qword ptr [rcx], rax
	mov	qword ptr [rcx+0x8], rdx
	mov	word ptr [rcx+0x10], si
	mov	rax, rcx
	leave
	pop	r13
	pop	r12
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_155:	dec	cx
	add	rax, rax
	adc	rdx, rdx
	jnc	$_155
	jmp	$_146

$_156:	dec	si
	add	rbx, rbx
	adc	rdi, rdi
	jnc	$_156
	jmp	$_147

$_157:	add	si, si
	jz	$_158
	rcr	si, 1
	jmp	$_145

$_158:	rcr	si, 1
	test	esi, 0x80008000
	jz	$_164
	mov	esi, 32768
	jmp	$_154

$_159:	test	esi, 0x7FFF0000
	jne	$_144
	mov	rcx, rax
	or	rcx, rdx
	jnz	$_162
	mov	ecx, esi
	add	cx, cx
	jnz	$_162
$_160:	mov	esi, 65535
	movabs	rdx, 0x4000000000000000
	xor	eax, eax
	jmp	$_154

$_161:
	and	cx, 0x7FFF
	cmp	cx, 16383
	jnc	$_164
$_162:	mov	esi, 32767
$_163:	xor	eax, eax
	xor	edx, edx
	jmp	$_154

$_164:	xor	esi, esi
	jmp	$_163

$_165:	mov	rax, rbx
	mov	rdx, rdi
	shr	esi, 16
	jmp	$_154

$_166:	dec	si
	add	esi, 65536
	jc	$_167
	jo	$_167
	jns	$_154
	mov	rcx, rax
	or	rcx, rdx
	jne	$_154
	xor	esi, 0x8000
	jmp	$_154

$_167:	sub	esi, 65536
	mov	rcx, rax
	or	rcx, rdx
	or	rcx, rbx
	or	rcx, rdi
	jz	$_160
	cmp	rdx, rdi
	jc	$_165
	ja	$_154
	cmp	rax, rbx
	jbe	$_165
	jmp	$_154

$_168:
	sub	esi, 65536
	mov	rcx, rbx
	or	rcx, rdi
	jnz	$_165
	mov	ecx, esi
	shl	ecx, 16
	xor	esi, ecx
	and	esi, 0x80000000
	jmp	$_165

$_169:
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	mov	r10, rcx
	mov	rbx, qword ptr [rdx]
	mov	rdi, qword ptr [rdx+0x8]
	mov	si, word ptr [rdx+0x10]
	shl	esi, 16
	mov	rax, qword ptr [rcx]
	mov	rdx, qword ptr [rcx+0x8]
	mov	si, word ptr [rcx+0x10]
	add	si, 1
	jc	$_183
	jo	$_183
	add	esi, 65535
	jc	$_186
	jo	$_186
	sub	esi, 65536
	mov	rcx, rax
	or	rcx, rdx
	je	$_175
$_170:	mov	rcx, rbx
	or	rcx, rdi
	je	$_177
$_171:	mov	ecx, esi
	rol	ecx, 16
	sar	ecx, 16
	sar	esi, 16
	and	ecx, 0x80007FFF
	and	esi, 0x80007FFF
	add	esi, ecx
	sub	si, 16382
	jc	$_172
	cmp	si, 32767
	ja	$_179
$_172:	cmp	si, -65
	jl	$_181
	mov	rcx, rbx
	mov	r11, rdi
	mov	r8, rax
	mov	r9, rdi
	mov	rdi, rdx
	mul	rcx
	mov	rbx, rdx
	mov	rax, rdi
	mul	r11
	mov	r11, rdx
	xchg	rcx, rax
	mov	rdx, rdi
	mul	rdx
	add	rbx, rax
	adc	rcx, rdx
	adc	r11, 0
	mov	rax, r8
	mov	rdx, r9
	mul	rdx
	add	rbx, rax
	adc	rcx, rdx
	adc	r11, 0
	mov	rax, rcx
	mov	rdx, r11
	test	rdx, rdx
	js	$_173
	add	rbx, rbx
	adc	rax, rax
	adc	rdx, rdx
	dec	si
$_173:	add	rbx, rbx
	adc	rax, 0
	adc	rdx, 0
	test	si, si
	jle	$_181
	add	esi, esi
	rcr	si, 1
$_174:	mov	qword ptr [r10], rax
	mov	qword ptr [r10+0x8], rdx
	mov	word ptr [r10+0x10], si
	mov	rax, r10
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_175:	add	si, si
	jz	$_176
	rcr	si, 1
	jmp	$_170

$_176:	rcr	si, 1
	test	esi, 0x80008000
	jz	$_181
	mov	esi, 32768
	jmp	$_174

$_177:	test	esi, 0x7FFF0000
	jne	$_171
	test	esi, 0x80008000
	jz	$_181
	mov	esi, 2147483648
	jmp	$_182

$_178:	mov	esi, 65535
	mov	edx, 1
	rol	rdx, 1
	xor	eax, eax
	jmp	$_174

$_179:	mov	esi, 32767
$_180:	xor	eax, eax
	xor	edx, edx
	jmp	$_174

$_181:	xor	esi, esi
	jmp	$_180

$_182:	mov	rax, rbx
	mov	rdx, rdi
	shr	esi, 16
	jmp	$_174

$_183:	dec	si
	add	esi, 65536
	jc	$_184
	jo	$_184
	jns	$_174
	test	rax, rax
	jne	$_174
	test	rdx, rdx
	jne	$_174
	xor	esi, 0x8000
	jmp	$_174

$_184:	sub	esi, 65536
	mov	rcx, rax
	or	rcx, rdx
	or	rcx, rbx
	or	rcx, rdi
	jnz	$_185
	or	esi, 0xFFFFFFFF
	jmp	$_178

$_185:	cmp	rdx, rdi
	jc	$_182
	ja	$_174
	cmp	rax, rbx
	jbe	$_182
	jmp	$_174

$_186:
	sub	esi, 65536
	test	rbx, rbx
	jnz	$_182
	test	rdi, rdi
	jnz	$_182
	mov	ecx, esi
	shl	ecx, 16
	xor	esi, ecx
	and	esi, 0x80000000
	jmp	$_182

__addq:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 112
	mov	rdx, qword ptr [rbp+0x10]
	lea	rcx, [rbp-0x28]
	call	$_109
	mov	rdx, qword ptr [rbp+0x18]
	lea	rcx, [rbp-0x50]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_141
	lea	rdx, [rbp-0x28]
	mov	rcx, qword ptr [rbp+0x10]
	call	$_113
	leave
	ret

__subq:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 112
	mov	rdx, qword ptr [rbp+0x10]
	lea	rcx, [rbp-0x28]
	call	$_109
	mov	rdx, qword ptr [rbp+0x18]
	lea	rcx, [rbp-0x50]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_142
	lea	rdx, [rbp-0x28]
	mov	rcx, qword ptr [rbp+0x10]
	call	$_113
	leave
	ret

__mulq:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 112
	mov	rdx, qword ptr [rbp+0x10]
	lea	rcx, [rbp-0x28]
	call	$_109
	mov	rdx, qword ptr [rbp+0x18]
	lea	rcx, [rbp-0x50]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_169
	lea	rdx, [rbp-0x28]
	mov	rcx, qword ptr [rbp+0x10]
	call	$_113
	leave
	ret

__divq:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 112
	mov	rdx, qword ptr [rbp+0x10]
	lea	rcx, [rbp-0x28]
	call	$_109
	mov	rdx, qword ptr [rbp+0x18]
	lea	rcx, [rbp-0x50]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_143
	lea	rdx, [rbp-0x28]
	mov	rcx, qword ptr [rbp+0x10]
	call	$_113
	leave
	ret

__sqrtq:
	mov	qword ptr [rsp+0x8], rcx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 80
	mov	rax, qword ptr [rcx]
	or	eax, dword ptr [rcx+0x8]
	or	ax, word ptr [rcx+0xC]
	mov	dx, word ptr [rcx+0xE]
	and	edx, 0x7FFF
	cmp	edx, 32767
	jnz	$_187
	test	eax, eax
	je	$_190
$_187:	test	edx, edx
	jnz	$_188
	test	eax, eax
	je	$_190
$_188:	test	byte ptr [rcx+0xF], 0x80
	jz	$_189
	mov	rdx, rcx
	call	__subq
	mov	rdx, rax
	mov	rcx, rax
	call	__divq
	jmp	$_190

$_189:	mov	rax, qword ptr [rcx]
	mov	qword ptr [rbp-0x10], rax
	mov	rax, qword ptr [rcx+0x8]
	mov	qword ptr [rbp-0x8], rax
	mov	rdx, rcx
	call	__cvtq_ld
	mov	rcx, qword ptr [rbp+0x10]
	fld	tbyte ptr [rcx]
	fsqrt
	fstp	tbyte ptr [rcx]
	mov	rdx, rcx
	call	$_101
	mov	rdx, qword ptr [rbp+0x10]
	mov	rax, qword ptr [rdx]
	mov	qword ptr [rbp-0x20], rax
	mov	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rbp-0x18], rax
	lea	rcx, [rbp-0x10]
	call	__divq
	mov	rdx, rax
	lea	rcx, [rbp-0x20]
	call	__subq
	mov	qword ptr [rbp-0x10], 0
	mov	dword ptr [rbp-0x8], 0
	mov	dword ptr [rbp-0x4], 1073610752
	lea	rdx, [rbp-0x10]
	lea	rcx, [rbp-0x20]
	call	__mulq
	lea	rdx, [rbp-0x20]
	mov	rcx, qword ptr [rbp+0x10]
	call	__subq
$_190:	leave
	ret

$_191:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	mov	rdi, rcx
	mov	rsi, rdx
	mov	ecx, r8d
	xor	eax, eax
	mov	qword ptr [rdi], rax
	mov	qword ptr [rdi+0x8], rax
	mov	word ptr [rdi+0x10], ax
	mov	dword ptr [rdi+0x1C], eax
	or	ecx, 0x08
$_192:	lodsb
	test	al, al
	je	$_209
	cmp	al, 32
	jz	$_192
	cmp	al, 9
	jc	$_193
	cmp	al, 13
	jbe	$_192
$_193:	dec	rsi
	and	ecx, 0xFFFFFFF7
	cmp	al, 43
	jnz	$_194
	inc	rsi
	or	ecx, 0x01
$_194:	cmp	al, 45
	jnz	$_195
	inc	rsi
	or	ecx, 0x03
$_195:	lodsb
	test	al, al
	je	$_209
	or	al, 0x20
	cmp	al, 110
	jnz	$_204
	mov	ax, word ptr [rsi]
	or	ax, 0x2020
	cmp	ax, 28257
	jnz	$_202
	add	rsi, 2
	or	ecx, 0x20
	mov	word ptr [rdi+0x10], -1
	movzx	eax, byte ptr [rsi]
	cmp	al, 40
	jnz	$_201
	lea	rdx, [rsi+0x1]
	mov	al, byte ptr [rdx]
	jmp	$_197

$_196:	inc	rdx
	mov	al, byte ptr [rdx]
	jmp	$_197

$_197:	cmp	al, 95
	jz	$_196
	cmp	al, 48
	jc	$_198
	cmp	al, 57
	jbe	$_196
$_198:	cmp	al, 97
	jc	$_199
	cmp	al, 122
	jbe	$_196
$_199:	cmp	al, 65
	jc	$_200
	cmp	al, 90
	jbe	$_196
$_200:	cmp	al, 41
	jnz	$_201
	lea	rsi, [rdx+0x1]
$_201:	jmp	$_203

$_202:	dec	rsi
	or	ecx, 0x80
$_203:	jmp	$_209

$_204:	cmp	al, 105
	jnz	$_207
	mov	ax, word ptr [rsi]
	or	ax, 0x2020
	cmp	ax, 26222
	jnz	$_205
	add	rsi, 2
	or	ecx, 0x40
	jmp	$_206

$_205:	dec	rsi
	or	ecx, 0x80
$_206:	jmp	$_209

$_207:	cmp	al, 48
	jnz	$_208
	mov	al, byte ptr [rsi]
	or	al, 0x20
	cmp	al, 120
	jnz	$_208
	or	ecx, 0x10
	add	rsi, 2
$_208:	dec	rsi
$_209:	mov	dword ptr [rdi+0x18], ecx
	mov	qword ptr [rdi+0x20], rsi
	mov	eax, ecx
	leave
	pop	rdi
	pop	rsi
	ret

$_210:
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	dword ptr [rbp-0x4], 0
	mov	dword ptr [rbp-0x8], 0
	mov	rbx, rcx
	mov	rdi, rdx
	mov	rsi, qword ptr [rbx+0x20]
	mov	ecx, dword ptr [rbx+0x18]
	xor	eax, eax
	xor	edx, edx
$_211:	lodsb
	test	al, al
	jz	$_219
	cmp	al, 46
	jnz	$_212
	test	ecx, 0x800
	jnz	$_219
	or	ecx, 0x800
	jmp	$_218

$_212:	test	ecx, 0x10
	jz	$_214
	or	al, 0x20
	cmp	al, 48
	jc	$_219
	cmp	al, 102
	ja	$_219
	cmp	al, 57
	jbe	$_213
	cmp	al, 97
	jc	$_219
$_213:	jmp	$_215

$_214:	cmp	al, 48
	jc	$_219
	cmp	al, 57
	ja	$_219
$_215:	test	ecx, 0x800
	jz	$_216
	inc	dword ptr [rbp-0x8]
$_216:	or	ecx, 0x400
	or	edx, eax
	cmp	edx, 48
	jz	$_211
	cmp	dword ptr [rbp-0x4], 49
	jge	$_217
	stosb
$_217:	inc	dword ptr [rbp-0x4]
$_218:	jmp	$_211

$_219:
	mov	byte ptr [rdi], 0
	xor	edx, edx
	test	ecx, 0x400
	je	$_234
	xor	edi, edi
	test	ecx, 0x10
	jz	$_220
	cmp	al, 112
	jz	$_221
	cmp	al, 80
	jz	$_221
$_220:	cmp	al, 101
	jz	$_221
	cmp	al, 69
	jnz	$_229
$_221:	mov	al, byte ptr [rsi]
	lea	rdx, [rsi-0x1]
	cmp	al, 43
	jnz	$_222
	inc	rsi
$_222:	cmp	al, 45
	jnz	$_223
	inc	rsi
	or	ecx, 0x04
$_223:	and	ecx, 0xFFFFFBFF
$_224:	movzx	eax, byte ptr [rsi]
	cmp	al, 48
	jc	$_226
	cmp	al, 57
	ja	$_226
	cmp	edi, 100000000
	jnc	$_225
	imul	edi, edi, 10
	lea	edi, [rdi+rax-0x30]
$_225:	or	ecx, 0x400
	inc	rsi
	jmp	$_224

$_226:	test	ecx, 0x4
	jz	$_227
	neg	edi
$_227:	test	ecx, 0x400
	jnz	$_228
	mov	rsi, rdx
$_228:	jmp	$_230

$_229:	dec	rsi
$_230:	mov	edx, edi
	mov	eax, dword ptr [rbp-0x8]
	mov	edi, 38
	test	ecx, 0x10
	jz	$_231
	mov	edi, 32
	mov	word ptr [rbx+0x10], dx
	xor	edx, edx
$_231:	sub	edx, eax
	cmp	dword ptr [rbp-0x4], edi
	jle	$_232
	add	edx, dword ptr [rbp-0x4]
	mov	dword ptr [rbp-0x4], edi
	sub	edx, edi
$_232:	cmp	dword ptr [rbp-0x4], 0
	jle	$_233
	mov	edi, dword ptr [rbp-0x4]
	add	rdi, qword ptr [rbp+0x30]
	cmp	byte ptr [rdi-0x1], 48
	jnz	$_233
	inc	edx
	dec	dword ptr [rbp-0x4]
	jmp	$_232

$_233:	jmp	$_235

$_234:	mov	rsi, qword ptr [rbx+0x20]
$_235:	mov	dword ptr [rbx+0x18], ecx
	mov	qword ptr [rbx+0x20], rsi
	mov	dword ptr [rbx+0x1C], edx
	mov	eax, dword ptr [rbp-0x4]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

_lk_fltscale:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 40
	mov	rsi, r8
	mov	edi, edx
	mov	ebx, 13
	test	byte ptr [rcx+0x18], 0x10
	jz	$_236
	inc	ebx
$_236:	cmp	edi, 0
	jge	$_237
	imul	eax, ebx, 24
	add	rsi, rax
	neg	edi
$_237:	test	edi, edi
	jz	$_241
$_238:	test	edi, edi
	jz	$_240
	test	ebx, ebx
	jz	$_240
	test	edi, 0x1
	jz	$_239
	mov	rdx, rsi
	mov	rcx, qword ptr [rbp+0x28]
	call	$_169
$_239:	dec	ebx
	shr	edi, 1
	add	rsi, 24
	jmp	$_238

$_240:	test	edi, edi
	jz	$_241
	xor	eax, eax
	mov	rbx, qword ptr [rbp+0x28]
	mov	qword ptr [rbx], rax
	mov	qword ptr [rbx+0x8], rax
	mov	word ptr [rbx+0x10], 32767
$_241:	mov	rax, qword ptr [rbp+0x28]
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

_fltscale:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	lea	r8, [_fltpowtable+rip]
	mov	edx, dword ptr [rcx+0x1C]
	call	_lk_fltscale
	leave
	ret

$_242:
	mov	qword ptr [rsp+0x8], rcx
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 296
	xor	r8d, r8d
	mov	rdx, qword ptr [rbp+0x28]
	lea	rcx, [flt+rip]
	call	$_191
	test	eax, 0xE8
	jne	$_268
	lea	rdx, [rbp-0x100]
	lea	rcx, [flt+rip]
	call	$_210
	mov	dword ptr [rbp-0x104], eax
	test	eax, eax
	jnz	$_243
	or	byte ptr [flt+0x18+rip], 0x08
	jmp	$_268

$_243:	mov	byte ptr [rbp+rax-0x100], 0
	lea	rdx, [rbp-0x100]
	xor	eax, eax
	mov	al, byte ptr [rdx]
	mov	dword ptr [rbp-0x108], eax
	cmp	al, 43
	jz	$_244
	cmp	al, 45
	jnz	$_245
$_244:	inc	rdx
$_245:	mov	ebx, 16
	test	byte ptr [flt+0x18+rip], 0x10
	jnz	$_246
	mov	ebx, 10
$_246:	lea	rsi, [flt+rip]
$_247:	mov	al, byte ptr [rdx]
	test	al, al
	jz	$_249
	and	eax, 0xFFFFFFCF
	bt	eax, 6
	sbb	ecx, ecx
	and	ecx, 0x37
	sub	eax, ecx
	mov	ecx, 8
$_248:	movzx	edi, word ptr [rsi]
	imul	edi, ebx
	add	eax, edi
	mov	word ptr [rsi], ax
	add	rsi, 2
	shr	eax, 16
	dec	rcx
	jnz	$_248
	sub	rsi, 16
	inc	rdx
	jmp	$_247

$_249:	xor	ecx, ecx
	mov	rax, qword ptr [flt+rip]
	mov	rdx, qword ptr [flt+0x8+rip]
	test	rax, rax
	jnz	$_250
	test	rdx, rdx
	jz	$_255
$_250:	test	rdx, rdx
	jz	$_251
	bsr	rcx, rdx
	add	ecx, 64
	jmp	$_252

$_251:	bsr	rcx, rax
$_252:	mov	ch, cl
	mov	cl, 127
	sub	cl, ch
	cmp	cl, 64
	jc	$_253
	sub	cl, 64
	mov	rdx, rax
	xor	eax, eax
$_253:	shld	rdx, rax, cl
	shl	rax, cl
	mov	qword ptr [flt+rip], rax
	mov	qword ptr [flt+0x8+rip], rdx
	shr	ecx, 8
	add	ecx, 16383
	test	byte ptr [flt+0x18+rip], 0x10
	jz	$_254
	imul	eax, dword ptr [flt+0x1C+rip], 4
	add	ecx, eax
$_254:	jmp	$_256

$_255:	or	byte ptr [flt+0x18+rip], 0x08
$_256:	mov	edx, dword ptr [flt+0x18+rip]
	cmp	dword ptr [rbp-0x108], 45
	jz	$_257
	test	edx, 0x2
	jz	$_258
$_257:
	or	cx, 0x8000
$_258:	mov	ebx, ecx
	and	ebx, 0x7FFF
	jmp	$_261

$_259:	or	ecx, 0x7FFF
	xor	eax, eax
	mov	qword ptr [flt+rip], rax
	mov	qword ptr [flt+0x8+rip], rax
	test	edx, 0xA0
	jz	$_260
	or	ecx, 0x8000
	or	byte ptr [flt+0xF+rip], 0x80
$_260:	jmp	$_262

$_261:	test	edx, 0x3E0
	jnz	$_259
	cmp	ebx, 32767
	jnc	$_259
$_262:	movsx	edi, word ptr [flt+0x10+rip]
	mov	word ptr [flt+0x10+rip], cx
	and	ecx, 0x7FFF
	cmp	ecx, 32767
	jc	$_263
	mov	dword ptr [qerrno+rip], 34
	jmp	$_266

$_263:	test	byte ptr [flt+0x18+rip], 0x10
	jz	$_265
	test	edi, edi
	jz	$_264
	lea	r8, [_base2table+rip]
	mov	edx, edi
	lea	rcx, [flt+rip]
	call	_lk_fltscale
$_264:	jmp	$_266

$_265:	cmp	dword ptr [flt+0x1C+rip], 0
	jz	$_266
	lea	rcx, [flt+rip]
	call	_fltscale
$_266:	mov	eax, dword ptr [flt+0x1C+rip]
	add	eax, dword ptr [rbp-0x104]
	dec	eax
	cmp	eax, 4932
	jle	$_267
	or	byte ptr [flt+0x19+rip], 0x02
$_267:	cmp	eax, 4294962364
	jge	$_268
	or	byte ptr [flt+0x19+rip], 0x01
$_268:	lea	rdx, [flt+rip]
	lea	rcx, [flt+rip]
	call	$_113
	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

_atoow:
	mov	r10, rcx
	mov	r11, rdx
	xor	edx, edx
	mov	qword ptr [rcx], rdx
	mov	qword ptr [rcx+0x8], rdx
	xor	ecx, ecx
	movzx	eax, word ptr [r11]
	or	eax, 0x2000
	cmp	eax, 30768
	jnz	$_269
	add	r11, 2
	sub	r9d, 2
$_269:	cmp	r8d, 16
	jnz	$_271
$_270:	movzx	eax, byte ptr [r11]
	inc	r11
	and	eax, 0xFFFFFFCF
	bt	eax, 6
	sbb	r8d, r8d
	and	r8d, 0x37
	sub	eax, r8d
	shld	rdx, rcx, 4
	shl	rcx, 4
	add	rcx, rax
	dec	r9d
	jnz	$_270
	jmp	$_275

$_271:	cmp	r8d, 10
	jnz	$_273
	mov	cl, byte ptr [r11]
	inc	r11
	sub	cl, 48
$_272:	dec	r9d
	jz	$_275
	mov	r8, rdx
	mov	rax, rcx
	shld	rdx, rcx, 3
	shl	rcx, 3
	add	rcx, rax
	adc	rdx, r8
	add	rcx, rax
	adc	rdx, r8
	movzx	eax, byte ptr [r11]
	inc	r11
	sub	al, 48
	add	rcx, rax
	adc	rdx, 0
	jmp	$_272

$_273:	movzx	eax, byte ptr [r11]
	and	eax, 0xFFFFFFCF
	bt	eax, 6
	sbb	ecx, ecx
	and	ecx, 0x37
	sub	eax, ecx
	mov	ecx, 8
$_274:	movzx	edx, word ptr [r10]
	imul	edx, r8d
	add	eax, edx
	mov	word ptr [r10], ax
	add	r10, 2
	shr	eax, 16
	dec	ecx
	jnz	$_274
	sub	r10, 16
	inc	r11
	dec	r9d
	jnz	$_273
	mov	rcx, qword ptr [r10]
	mov	rdx, qword ptr [r10+0x8]
$_275:	mov	rax, r10
	mov	qword ptr [rax], rcx
	mov	qword ptr [rax+0x8], rdx
	ret

_atoqw:
	push	rbx
	push	rbp
	mov	rbp, rsp
	xor	edx, edx
	xor	eax, eax
$_276:	mov	dl, byte ptr [rcx]
	inc	rcx
	cmp	dl, 32
	jz	$_276
	mov	bl, dl
	cmp	dl, 43
	jz	$_277
	cmp	dl, 45
	jnz	$_278
$_277:	mov	dl, byte ptr [rcx]
	inc	rcx
$_278:	sub	dl, 48
	jc	$_279
	cmp	dl, 9
	ja	$_279
	imul	eax, eax, 10
	add	eax, edx
	mov	dl, byte ptr [rcx]
	inc	rcx
	jmp	$_278

$_279:
	cmp	bl, 45
	jnz	$_280
	neg	eax
$_280:	leave
	pop	rbx
	ret

atofloat:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	dword ptr [qerrno+rip], 0
	mov	rcx, qword ptr [rbp+0x18]
	call	$_242
	mov	rdx, rax
	mov	rcx, qword ptr [rbp+0x10]
	mov	rax, qword ptr [rdx]
	mov	qword ptr [rcx], rax
	mov	rax, qword ptr [rdx+0x8]
	mov	qword ptr [rcx+0x8], rax
	cmp	dword ptr [qerrno+rip], 0
	jz	$_281
	mov	rdx, qword ptr [rbp+0x18]
	mov	ecx, 2104
	call	asmerr@PLT
$_281:	cmp	dword ptr [rbp+0x28], 0
	jz	$_282
	mov	rcx, qword ptr [rbp+0x10]
	or	byte ptr [rcx+0xF], 0x80
$_282:	mov	eax, dword ptr [rbp+0x20]
	jmp	$_293

$_283:	mov	rdx, qword ptr [rbp+0x10]
	mov	rcx, qword ptr [rbp+0x10]
	call	$_039
	cmp	dword ptr [qerrno+rip], 0
	jz	$_284
	mov	ecx, 2071
	call	asmerr@PLT
$_284:	jmp	$_294

$_285:	mov	rdx, qword ptr [rbp+0x10]
	mov	rcx, qword ptr [rbp+0x10]
	call	__cvtq_ss
	cmp	dword ptr [qerrno+rip], 0
	jz	$_286
	mov	ecx, 2071
	call	asmerr@PLT
$_286:	jmp	$_294

$_287:	mov	rdx, qword ptr [rbp+0x10]
	mov	rcx, qword ptr [rbp+0x10]
	call	__cvtq_sd
	cmp	dword ptr [qerrno+rip], 0
	jz	$_288
	mov	ecx, 2071
	call	asmerr@PLT
$_288:	jmp	$_294

$_289:	mov	rdx, qword ptr [rbp+0x10]
	mov	rcx, qword ptr [rbp+0x10]
	call	__cvtq_ld
$_290:	jmp	$_294

$_291:	cmp	dword ptr [Parse_Pass+rip], 0
	jnz	$_292
	mov	ecx, 7004
	call	asmerr@PLT
$_292:	mov	r8d, dword ptr [rbp+0x20]
	xor	edx, edx
	mov	rcx, qword ptr [rbp+0x10]
	call	tmemset@PLT
	jmp	$_294

$_293:	cmp	al, 2
	je	$_283
	cmp	al, 4
	je	$_285
	cmp	al, 8
	jz	$_287
	cmp	al, 10
	jz	$_289
	cmp	al, 16
	jz	$_290
	jmp	$_291

$_294:
	leave
	ret

ftoquad:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	xor	eax, eax
	mov	dword ptr [qerrno+rip], eax
	mov	al, byte ptr [rcx+0x44]
	jmp	$_299

$_295:	mov	rdx, rcx
	call	$_080
	jmp	$_300

$_296:	mov	rdx, rcx
	call	$_087
	jmp	$_300

$_297:	mov	rdx, rcx
	call	$_093
	jmp	$_300

$_298:	mov	rdx, rcx
	call	$_101
	jmp	$_300

$_299:	cmp	eax, 33
	jz	$_295
	cmp	eax, 35
	jz	$_296
	cmp	eax, 39
	jz	$_297
	cmp	eax, 41
	jz	$_298
$_300:	cmp	dword ptr [qerrno+rip], 0
	jz	$_301
	mov	ecx, 2071
	call	asmerr@PLT
$_301:	leave
	ret

quadtof:
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	al, byte ptr [rcx+0x44]
	jmp	$_306

$_302:	mov	rdx, rcx
	call	$_039
	jmp	$_307

$_303:	mov	rdx, rcx
	call	__cvtq_ss
	jmp	$_307

$_304:	mov	rdx, rcx
	call	__cvtq_sd
	jmp	$_307

$_305:	mov	rdx, rcx
	call	__cvtq_ld
	jmp	$_307

$_306:	cmp	al, 33
	jz	$_302
	cmp	al, 35
	jz	$_303
	cmp	al, 39
	jz	$_304
	cmp	al, 41
	jz	$_305
$_307:	leave
	ret

quad_resize:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	push	rsi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 32
	mov	dword ptr [qerrno+rip], 0
	mov	rbx, qword ptr [rbp+0x20]
	movzx	esi, word ptr [rbx+0xE]
	and	esi, 0x7FFF
	mov	eax, dword ptr [rbp+0x28]
	jmp	$_318

$_308:	mov	rdx, rbx
	mov	rcx, rbx
	call	__cvtq_ld
	jmp	$_319

$_309:	test	byte ptr [rbx+0xF], 0x80
	jz	$_310
	or	byte ptr [rbx+0x40], 0x20
	and	byte ptr [rbx+0xF], 0x7F
$_310:	mov	rdx, rbx
	mov	rcx, rbx
	call	__cvtq_sd
	test	byte ptr [rbx+0x40], 0x20
	jz	$_311
	or	byte ptr [rbx+0x7], 0x80
$_311:	mov	byte ptr [rbx+0x44], 39
	jmp	$_319

$_312:	test	byte ptr [rbx+0xF], 0x80
	jz	$_313
	or	byte ptr [rbx+0x40], 0x20
	and	byte ptr [rbx+0xF], 0x7F
$_313:	mov	rdx, rbx
	mov	rcx, rbx
	call	__cvtq_ss
	test	byte ptr [rbx+0x40], 0x20
	jz	$_314
	or	byte ptr [rbx+0x3], 0x80
$_314:	mov	byte ptr [rbx+0x44], 35
	jmp	$_319

$_315:	test	byte ptr [rbx+0xF], 0x80
	jz	$_316
	or	byte ptr [rbx+0x40], 0x20
	and	byte ptr [rbx+0xF], 0x7F
$_316:	mov	rdx, rbx
	mov	rcx, rbx
	call	$_039
	test	byte ptr [rbx+0x40], 0x20
	jz	$_317
	or	byte ptr [rbx+0x1], 0x80
$_317:	mov	byte ptr [rbx+0x44], 33
	jmp	$_319

$_318:	cmp	eax, 10
	je	$_308
	cmp	eax, 8
	je	$_309
	cmp	eax, 4
	jz	$_312
	cmp	eax, 2
	jz	$_315
$_319:	cmp	dword ptr [qerrno+rip], 0
	jz	$_320
	cmp	esi, 32767
	jz	$_320
	mov	ecx, 2071
	call	asmerr@PLT
$_320:	leave
	pop	rbx
	pop	rsi
	ret

$_321:
	mov	dx, word ptr [rcx+0x10]
	mov	eax, edx
	and	eax, 0x7FFF
	cmp	eax, 16383
	jge	$_323
	xor	eax, eax
	test	dx, 0x8000
	jz	$_322
	dec	rax
$_322:	jmp	$_326

$_323:	cmp	eax, 16445
	jle	$_325
	mov	dword ptr [qerrno+rip], 34
	movabs	rax, 0x7FFFFFFFFFFFFFFF
	test	edx, 0x8000
	jz	$_324
	movabs	rax, 0x8000000000000000
$_324:	jmp	$_326

$_325:	mov	r10, qword ptr [rcx+0x8]
	mov	ecx, eax
	xor	eax, eax
	sub	ecx, 16383
	shl	r10, 1
	adc	eax, eax
	shld	rax, r10, cl
	test	edx, 0x8000
	jz	$_326
	neg	rax
$_326:	ret

$_327:
	mov	rax, rdx
	mov	rdx, rcx
	mov	r8d, 16383
	test	rax, rax
	jns	$_328
	neg	rax
	or	r8d, 0x8000
$_328:	xor	r9d, r9d
	test	rax, rax
	jz	$_329
	bsr	r9, rax
	mov	ecx, 63
	sub	ecx, r9d
	shl	rax, cl
	add	r9d, r8d
$_329:	xor	ecx, ecx
	mov	qword ptr [rdx], rcx
	mov	qword ptr [rdx+0x8], rax
	mov	word ptr [rdx+0x10], r9w
	mov	rax, rdx
	ret

__modq:
	push	rsi
	push	rdi
	push	rbp
	mov	rbp, rsp
	sub	rsp, 112
	mov	rsi, rcx
	mov	rdi, rdx
	xor	eax, eax
	mov	rcx, qword ptr [rdi+0x10]
	test	rcx, rcx
	jz	$_330
	cmp	byte ptr [rcx+0x1], 114
	jnz	$_330
	inc	eax
	jmp	$_331

$_330:	cmp	dword ptr [rdi+0x3C], 3
	jz	$_331
	inc	eax
$_331:	test	eax, eax
	jz	$_332
	lea	r8, [rbp-0x28]
	mov	rdx, rdi
	mov	rcx, rsi
	call	__divo
	mov	rax, qword ptr [rbp-0x28]
	mov	qword ptr [rsi], rax
	mov	rax, qword ptr [rbp-0x20]
	mov	qword ptr [rsi+0x8], rax
	jmp	$_333

$_332:	mov	rdx, rsi
	lea	rcx, [rbp-0x28]
	call	$_109
	mov	rdx, rdi
	lea	rcx, [rbp-0x50]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_143
	lea	rcx, [rbp-0x28]
	call	$_321
	mov	rdx, rax
	lea	rcx, [rbp-0x28]
	call	$_327
	lea	rdx, [rbp-0x28]
	lea	rcx, [rbp-0x50]
	call	$_169
	mov	rdx, rsi
	lea	rcx, [rbp-0x28]
	call	$_109
	lea	rdx, [rbp-0x50]
	lea	rcx, [rbp-0x28]
	call	$_142
	lea	rdx, [rbp-0x28]
	mov	rcx, rsi
	call	$_113
$_333:	leave
	pop	rdi
	pop	rsi
	ret

_flttostr:
	mov	qword ptr [rsp+0x8], rcx
	mov	qword ptr [rsp+0x10], rdx
	mov	qword ptr [rsp+0x18], r8
	mov	qword ptr [rsp+0x20], r9
	push	rsi
	push	rdi
	push	rbx
	push	rbp
	mov	rbp, rsp
	sub	rsp, 664
	mov	rbx, rdx
	mov	rcx, r8
	mov	eax, dword ptr [rbx+0x2C]
	add	rax, rcx
	dec	rax
	mov	qword ptr [rbp-0x270], rax
	mov	eax, 20
	test	byte ptr [rbp+0x42], 0x10
	jz	$_334
	mov	eax, 23
	jmp	$_335

$_334:	test	byte ptr [rbp+0x42], 0x20
	jz	$_335
	mov	eax, 33
$_335:	mov	dword ptr [rbp-0x18], eax
	xor	eax, eax
	mov	dword ptr [rbx+0x1C], eax
	mov	dword ptr [rbx+0x20], eax
	mov	dword ptr [rbx+0x24], eax
	mov	dword ptr [rbx+0x28], eax
	mov	dword ptr [rbx+0x18], eax
	mov	rdx, qword ptr [rbp+0x28]
	lea	rcx, [rbp-0x40]
	call	$_109
	mov	ax, word ptr [rbp-0x30]
	bt	eax, 15
	sbb	ecx, ecx
	mov	dword ptr [rbx+0x14], ecx
	and	eax, 0x7FFF
	mov	word ptr [rbp-0x30], ax
	movzx	ecx, ax
	xor	eax, eax
	mov	dword ptr [rbp-0x28], eax
	cmp	ecx, 32767
	jnz	$_339
	or	rax, qword ptr [rbp-0x40]
	or	rax, qword ptr [rbp-0x38]
	jnz	$_336
	mov	eax, 6712937
	or	byte ptr [rbx+0x8], 0x40
	jmp	$_337

$_336:	mov	eax, 7233902
	or	byte ptr [rbx+0x8], 0x20
$_337:	test	byte ptr [rbp+0x42], 0x01
	jz	$_338
	and	eax, 0xFFDFDFDF
$_338:	mov	rcx, qword ptr [rbp+0x38]
	mov	dword ptr [rcx], eax
	mov	dword ptr [rbx+0x1C], 3
	mov	eax, 64
	jmp	$_430

$_339:	test	ecx, ecx
	jnz	$_340
	mov	dword ptr [rbx+0x14], eax
	mov	dword ptr [rbp-0x10], eax
	mov	dword ptr [rbp-0x28], 8
	jmp	$_346

$_340:	mov	esi, ecx
	sub	ecx, 16382
	mov	eax, 30103
	imul	ecx
	mov	ecx, 100000
	idiv	ecx
	sub	eax, 8
	mov	dword ptr [rbp-0x10], eax
	test	eax, eax
	je	$_346
	jns	$_341
	neg	eax
	add	eax, 7
	and	eax, 0xFFFFFFF8
	neg	eax
	mov	dword ptr [rbp-0x10], eax
	neg	eax
	mov	dword ptr [rbp-0x24], eax
	lea	rcx, [rbp-0x40]
	call	_fltscale
	jmp	$_346

$_341:	mov	eax, dword ptr [rbp-0x38]
	mov	edx, dword ptr [rbp-0x34]
	cmp	esi, 16436
	jc	$_342
	cmp	esi, 16436
	jnz	$_343
	cmp	edx, -1910781505
	jc	$_342
	cmp	edx, -1910781505
	jnz	$_343
	cmp	eax, 67108864
	jnc	$_343
$_342:	mov	dword ptr [rbp-0x10], 0
	jmp	$_346

$_343:	cmp	esi, 16489
	jc	$_344
	cmp	esi, 16489
	jnz	$_345
	cmp	edx, -1647989336
	jc	$_344
	cmp	edx, -1647989336
	jnz	$_345
	cmp	eax, 728806813
	jnc	$_345
$_344:	mov	dword ptr [rbp-0x10], 16
$_345:	mov	eax, dword ptr [rbp-0x10]
	and	eax, 0xFFFFFFF8
	mov	dword ptr [rbp-0x10], eax
	neg	eax
	mov	dword ptr [rbp-0x24], eax
	lea	rcx, [rbp-0x40]
	call	_fltscale
$_346:	mov	eax, dword ptr [rbx]
	test	byte ptr [rbx+0x9], 0x20
	jz	$_348
	add	eax, dword ptr [rbp-0x10]
	add	eax, 18
	cmp	dword ptr [rbx+0x4], 0
	jle	$_347
	add	eax, dword ptr [rbx+0x4]
$_347:	jmp	$_349

$_348:	add	eax, 24
$_349:	cmp	eax, 495
	jbe	$_350
	mov	eax, 495
$_350:	mov	dword ptr [rbp-0x8], eax
	mov	ecx, dword ptr [rbp-0x18]
	add	ecx, 8
	mov	dword ptr [rbp-0x14], ecx
	xor	eax, eax
	mov	qword ptr [rbp-0x278], rax
	lea	rdi, [rbp-0x268]
	mov	word ptr [rdi], 48
	inc	rdi
	mov	dword ptr [rbp-0x4], 0
	jmp	$_357

$_351:	sub	dword ptr [rbp-0x8], 16
	cmp	qword ptr [rbp-0x278], 0
	jnz	$_352
	lea	rcx, [rbp-0x40]
	call	$_321
	mov	qword ptr [rbp-0x278], rax
	cmp	dword ptr [rbp-0x8], 0
	jle	$_352
	mov	rdx, qword ptr [rbp-0x278]
	lea	rcx, [rbp-0x68]
	call	$_327
	lea	rdx, [rbp-0x68]
	lea	rcx, [rbp-0x40]
	call	$_142
	lea	rdx, [_fltpowtable+0x60+rip]
	lea	rcx, [rbp-0x40]
	call	$_169
$_352:	mov	ecx, 16
	mov	rax, qword ptr [rbp-0x278]
	mov	qword ptr [rbp-0x278], 0
	test	rax, rax
	jz	$_355
	mov	r8d, 10
$_353:	test	ecx, ecx
	jz	$_354
	xor	edx, edx
	div	r8
	add	dl, 48
	mov	byte ptr [rdi+rcx-0x1], dl
	dec	ecx
	jmp	$_353

$_354:	add	rdi, 16
	jmp	$_356

$_355:	mov	al, 48
	rep stosb
$_356:	add	dword ptr [rbp-0x4], 16
$_357:	cmp	dword ptr [rbp-0x8], 0
	jg	$_351
	mov	eax, dword ptr [rbp-0x4]
	mov	edx, 510
	lea	rsi, [rbp-0x267]
	mov	ecx, dword ptr [rbp-0x10]
	add	ecx, 15
$_358:	test	edx, edx
	jz	$_359
	cmp	byte ptr [rsi], 48
	jnz	$_359
	dec	eax
	dec	ecx
	dec	edx
	inc	rsi
	jmp	$_358

$_359:	mov	dword ptr [rbp-0x8], eax
	mov	rbx, qword ptr [rbp+0x30]
	mov	edx, dword ptr [rbx]
	test	byte ptr [rbx+0x9], 0x20
	jz	$_360
	add	ecx, dword ptr [rbx+0x4]
	lea	edx, [rdx+rcx+0x1]
	jmp	$_363

$_360:	test	byte ptr [rbx+0x9], 0x10
	jz	$_363
	cmp	dword ptr [rbx+0x4], 0
	jle	$_361
	inc	edx
	jmp	$_362

$_361:	add	edx, dword ptr [rbx+0x4]
$_362:	inc	ecx
	sub	ecx, dword ptr [rbx+0x4]
$_363:	cmp	edx, 0
	jl	$_374
	cmp	edx, eax
	jle	$_364
	mov	edx, eax
$_364:	mov	eax, dword ptr [rbp-0x18]
	cmp	edx, eax
	jle	$_365
	mov	edx, eax
$_365:	mov	dword ptr [rbp-0x14], eax
	mov	eax, 48
	cmp	dword ptr [rbp-0x8], edx
	jle	$_366
	cmp	byte ptr [rsi+rdx], 53
	jge	$_367
$_366:	cmp	edx, dword ptr [rbp-0x18]
	jnz	$_368
	cmp	byte ptr [rsi+rdx-0x1], 57
	jnz	$_368
$_367:	mov	al, 57
$_368:	mov	edi, dword ptr [rbx+0x4]
	add	edi, dword ptr [rbx]
	cmp	al, 57
	jnz	$_372
	cmp	edx, edi
	jnz	$_372
	cmp	byte ptr [rsi+rdx], 57
	jz	$_372
	cmp	byte ptr [rsi+rdx-0x1], 57
	jnz	$_372
	jmp	$_370

$_369:	dec	edi
	cmp	byte ptr [rsi+rdi], 57
	jnz	$_371
$_370:	test	edi, edi
	jnz	$_369
$_371:	cmp	byte ptr [rsi+rdi], 57
	jnz	$_372
	mov	al, 48
$_372:	lea	rdi, [rsi+rdx-0x1]
	xchg	edx, ecx
	inc	ecx
	std
	repe scasb
	cld
	xchg	edx, ecx
	inc	rdi
	cmp	al, 57
	jnz	$_373
	inc	byte ptr [rdi]
$_373:	sub	rdi, rsi
	jns	$_374
	dec	rsi
	inc	edx
	inc	ecx
$_374:	cmp	edx, 0
	jle	$_375
	cmp	dword ptr [rbp-0x28], 8
	jnz	$_376
$_375:	mov	edx, 1
	xor	ecx, ecx
	mov	byte ptr [rbp-0x268], 48
	mov	dword ptr [rbx+0x14], ecx
	lea	rsi, [rbp-0x268]
$_376:	mov	dword ptr [rbp-0x4], 0
	mov	eax, dword ptr [rbx+0x8]
	test	eax, 0x2000
	jnz	$_378
	test	eax, 0x4000
	je	$_395
	cmp	ecx, -1
	jl	$_377
	cmp	ecx, dword ptr [rbx]
	jl	$_378
$_377:	test	eax, 0x8000
	je	$_395
$_378:	mov	rdi, qword ptr [rbp+0x38]
	inc	ecx
	test	eax, 0x4000
	jz	$_380
	cmp	edx, dword ptr [rbx]
	jge	$_379
	test	eax, 0x800
	jnz	$_379
	mov	dword ptr [rbx], edx
$_379:	sub	dword ptr [rbx], ecx
	cmp	dword ptr [rbx], 0
	jge	$_380
	mov	dword ptr [rbx], 0
$_380:	cmp	ecx, 0
	jg	$_385
	test	eax, 0x8000
	jnz	$_382
	mov	byte ptr [rdi], 48
	inc	dword ptr [rbp-0x4]
	cmp	dword ptr [rbx], 0
	jg	$_381
	test	eax, 0x800
	jz	$_382
$_381:	mov	byte ptr [rdi+0x1], 46
	inc	dword ptr [rbp-0x4]
$_382:	mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rbx+0x1C], eax
	mov	eax, ecx
	neg	eax
	cmp	dword ptr [rbx], eax
	jge	$_383
	mov	ecx, dword ptr [rbx]
	neg	ecx
$_383:	mov	eax, ecx
	neg	eax
	mov	dword ptr [rbx+0x18], eax
	mov	dword ptr [rbx+0x20], eax
	add	dword ptr [rbx], ecx
	cmp	dword ptr [rbx], edx
	jge	$_384
	mov	edx, dword ptr [rbx]
$_384:	mov	dword ptr [rbx+0x24], edx
	sub	edx, dword ptr [rbx]
	neg	edx
	mov	dword ptr [rbx+0x28], edx
	mov	ecx, dword ptr [rbx+0x1C]
	add	rdi, rcx
	mov	ecx, dword ptr [rbx+0x20]
	mov	eax, dword ptr [rbx+0x24]
	add	eax, dword ptr [rbx+0x28]
	add	eax, ecx
	lea	rax, [rdi+rax]
	cmp	rax, qword ptr [rbp-0x270]
	ja	$_431
	add	dword ptr [rbp-0x4], ecx
	mov	al, 48
	rep stosb
	mov	ecx, dword ptr [rbx+0x24]
	add	dword ptr [rbp-0x4], ecx
	rep movsb
	mov	ecx, dword ptr [rbx+0x28]
	add	dword ptr [rbp-0x4], ecx
	rep stosb
	jmp	$_394

$_385:	cmp	edx, ecx
	jge	$_388
	add	dword ptr [rbp-0x4], edx
	mov	dword ptr [rbx+0x1C], edx
	mov	eax, ecx
	sub	eax, edx
	mov	dword ptr [rbx+0x20], eax
	mov	dword ptr [rbx+0x18], ecx
	mov	ecx, edx
	rep movsb
	lea	rcx, [rdi+rax+0x2]
	cmp	rcx, qword ptr [rbp-0x270]
	ja	$_431
	mov	ecx, eax
	mov	eax, 48
	add	dword ptr [rbp-0x4], ecx
	rep stosb
	mov	ecx, dword ptr [rbx]
	test	byte ptr [rbx+0x9], 0x80
	jnz	$_387
	cmp	ecx, 0
	jg	$_386
	test	byte ptr [rbx+0x9], 0x08
	jz	$_387
$_386:	mov	byte ptr [rdi], 46
	inc	rdi
	inc	dword ptr [rbp-0x4]
	mov	dword ptr [rbx+0x24], 1
$_387:	lea	rdx, [rdi+rcx]
	cmp	rdx, qword ptr [rbp-0x270]
	ja	$_431
	mov	dword ptr [rbx+0x28], ecx
	add	dword ptr [rbp-0x4], ecx
	rep stosb
	jmp	$_394

$_388:	mov	dword ptr [rbx+0x18], ecx
	add	dword ptr [rbp-0x4], ecx
	sub	edx, ecx
	rep movsb
	mov	rdi, qword ptr [rbp+0x38]
	mov	ecx, dword ptr [rbx+0x18]
	test	byte ptr [rbx+0x9], 0x80
	jnz	$_391
	cmp	dword ptr [rbx], 0
	jg	$_389
	test	byte ptr [rbx+0x9], 0x08
	jz	$_390
$_389:	mov	eax, dword ptr [rbp-0x4]
	mov	byte ptr [rdi+rax], 46
	inc	dword ptr [rbp-0x4]
$_390:	jmp	$_392

$_391:	cmp	byte ptr [rdi], 48
	jnz	$_392
	mov	dword ptr [rbx+0x18], 0
$_392:	cmp	dword ptr [rbx], edx
	jge	$_393
	mov	edx, dword ptr [rbx]
$_393:	mov	eax, dword ptr [rbp-0x4]
	add	rdi, rax
	mov	ecx, edx
	rep movsb
	add	dword ptr [rbp-0x4], edx
	mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rbx+0x1C], eax
	mov	eax, edx
	mov	ecx, dword ptr [rbx]
	add	edx, ecx
	mov	dword ptr [rbx+0x20], edx
	sub	ecx, eax
	add	dword ptr [rbp-0x4], ecx
	lea	rdx, [rdi+rcx]
	cmp	rdx, qword ptr [rbp-0x270]
	ja	$_431
	mov	eax, 48
	rep stosb
$_394:	mov	edi, dword ptr [rbp-0x4]
	add	rdi, qword ptr [rbp+0x38]
	mov	byte ptr [rdi], 0
	jmp	$_430

$_395:	mov	eax, dword ptr [rbx]
	cmp	dword ptr [rbx+0x4], 0
	jg	$_396
	add	eax, dword ptr [rbx+0x4]
	jmp	$_397

$_396:	sub	eax, dword ptr [rbx+0x4]
	inc	eax
$_397:	mov	dword ptr [rbp-0x4], 0
	test	byte ptr [rbx+0x9], 0x40
	jz	$_400
	cmp	edx, eax
	jnc	$_398
	test	byte ptr [rbx+0x9], 0x08
	jnz	$_398
	mov	eax, edx
$_398:	dec	eax
	cmp	eax, 0
	jge	$_399
	xor	eax, eax
$_399:	cmp	ecx, -5
	jle	$_400
	cmp	ecx, 0
	jge	$_400
	neg	ecx
	add	eax, ecx
	add	edx, ecx
	sub	rsi, rcx
	xor	ecx, ecx
$_400:	mov	dword ptr [rbx], eax
	mov	dword ptr [rbp-0x10], ecx
	mov	dword ptr [rbp-0xC], edx
	mov	rdi, qword ptr [rbp+0x38]
	cmp	dword ptr [rbx+0x4], 0
	jg	$_402
	mov	byte ptr [rdi], 48
	inc	dword ptr [rbp-0x4]
	cmp	ecx, dword ptr [rbp-0x14]
	jl	$_401
	inc	dword ptr [rbp-0x10]
$_401:	jmp	$_404

$_402:	mov	eax, dword ptr [rbx+0x4]
	cmp	eax, edx
	jbe	$_403
	mov	eax, edx
$_403:	mov	edx, eax
	mov	ecx, dword ptr [rbp-0x4]
	add	rdi, rcx
	mov	ecx, eax
	mov	rax, rsi
	rep movsb
	mov	rsi, rax
	add	dword ptr [rbp-0x4], edx
	add	rsi, rdx
	sub	dword ptr [rbp-0xC], edx
	cmp	edx, dword ptr [rbx+0x4]
	jge	$_404
	mov	ecx, dword ptr [rbx+0x4]
	sub	ecx, edx
	add	dword ptr [rbp-0x4], ecx
	mov	edi, dword ptr [rbp-0x4]
	add	rdi, qword ptr [rbp+0x38]
	mov	al, 48
	rep stosb
$_404:	mov	edx, dword ptr [rbp-0x4]
	mov	rdi, qword ptr [rbp+0x38]
	mov	dword ptr [rbx+0x18], edx
	mov	eax, dword ptr [rbx]
	test	byte ptr [rbx+0x9], 0x80
	jnz	$_406
	cmp	eax, 0
	jg	$_405
	test	byte ptr [rbx+0x9], 0x08
	jz	$_406
$_405:	mov	byte ptr [rdi+rdx], 46
	inc	dword ptr [rbp-0x4]
$_406:	mov	ecx, dword ptr [rbx+0x4]
	cmp	ecx, 0
	jge	$_407
	neg	ecx
	add	rdi, rdx
	add	dword ptr [rbp-0x4], ecx
	mov	al, 48
	rep stosb
$_407:	mov	ecx, dword ptr [rbp-0xC]
	mov	eax, dword ptr [rbx]
	cmp	eax, 0
	jle	$_410
	cmp	eax, ecx
	jge	$_408
	mov	ecx, eax
	mov	dword ptr [rbp-0xC], eax
$_408:	test	ecx, ecx
	jz	$_409
	mov	edi, dword ptr [rbp-0x4]
	add	rdi, qword ptr [rbp+0x38]
	add	dword ptr [rbp-0x4], ecx
	rep movsb
$_409:	mov	eax, dword ptr [rbp-0x4]
	mov	dword ptr [rbx+0x1C], eax
	mov	ecx, dword ptr [rbx]
	sub	ecx, dword ptr [rbp-0xC]
	mov	dword ptr [rbx+0x20], ecx
	mov	edi, dword ptr [rbp-0x4]
	add	rdi, qword ptr [rbp+0x38]
	add	dword ptr [rbp-0x4], ecx
	mov	eax, 48
	rep stosb
$_410:	mov	edi, dword ptr [rbp-0x10]
	mov	rsi, qword ptr [rbp+0x38]
	mov	ecx, dword ptr [rbp-0x4]
	test	byte ptr [rbx+0x9], 0x40
	jz	$_411
	test	edi, edi
	jnz	$_411
	mov	edx, ecx
	jmp	$_429

$_411:	mov	eax, dword ptr [rbx+0xC]
	test	al, al
	jz	$_412
	mov	byte ptr [rsi+rcx], al
	inc	dword ptr [rbp-0x4]
	inc	ecx
$_412:	cmp	edi, 0
	jl	$_413
	mov	byte ptr [rsi+rcx], 43
	jmp	$_414

$_413:	mov	byte ptr [rsi+rcx], 45
	neg	edi
$_414:	inc	dword ptr [rbp-0x4]
	mov	eax, edi
	mov	ecx, dword ptr [rbx+0x10]
	jmp	$_421

$_415:	mov	ecx, 3
	cmp	eax, 1000
	jl	$_416
	mov	ecx, 4
$_416:	jmp	$_422

$_417:	cmp	eax, 10
	jl	$_418
	mov	ecx, 2
$_418:	cmp	eax, 100
	jl	$_419
	mov	ecx, 3
$_419:	cmp	eax, 1000
	jl	$_420
	mov	ecx, 4
$_420:	jmp	$_422

$_421:	cmp	ecx, 0
	jz	$_415
	cmp	ecx, 1
	jz	$_417
	cmp	ecx, 2
	jz	$_418
	cmp	ecx, 3
	jz	$_419
$_422:	mov	dword ptr [rbx+0x10], ecx
	cmp	ecx, 4
	jc	$_424
	xor	edx, edx
	cmp	eax, 1000
	jc	$_423
	mov	ecx, 1000
	div	ecx
	mov	edx, eax
	imul	eax, eax, 1000
	sub	edi, eax
	mov	ecx, dword ptr [rbx+0x10]
$_423:	lea	eax, [rdx+0x30]
	mov	edx, dword ptr [rbp-0x4]
	mov	byte ptr [rsi+rdx], al
	inc	dword ptr [rbp-0x4]
$_424:	cmp	ecx, 3
	jc	$_426
	xor	edx, edx
	cmp	edi, 100
	jl	$_425
	mov	eax, edi
	mov	ecx, 100
	div	ecx
	mov	edx, eax
	imul	eax, eax, 100
	sub	edi, eax
	mov	ecx, dword ptr [rbx+0x10]
$_425:	lea	eax, [rdx+0x30]
	mov	edx, dword ptr [rbp-0x4]
	mov	byte ptr [rsi+rdx], al
	inc	dword ptr [rbp-0x4]
$_426:	cmp	ecx, 2
	jc	$_428
	xor	edx, edx
	cmp	edi, 10
	jl	$_427
	mov	eax, edi
	mov	ecx, 10
	div	ecx
	mov	edx, eax
	imul	eax, eax, 10
	sub	edi, eax
	mov	ecx, dword ptr [rbx+0x10]
$_427:	lea	eax, [rdx+0x30]
	mov	edx, dword ptr [rbp-0x4]
	mov	byte ptr [rsi+rdx], al
	inc	dword ptr [rbp-0x4]
$_428:	mov	edx, dword ptr [rbp-0x4]
	lea	eax, [rdi+0x30]
	mov	byte ptr [rsi+rdx], al
	inc	edx
$_429:	mov	eax, edx
	sub	eax, dword ptr [rbx+0x1C]
	mov	dword ptr [rbx+0x24], eax
	xor	eax, eax
	mov	byte ptr [rsi+rdx], al
$_430:	leave
	pop	rbx
	pop	rdi
	pop	rsi
	ret

$_431:
	mov	rdi, qword ptr [rbp+0x38]
	lea	rsi, [e_space+rip]
	mov	ecx, 18
	rep movsb
	jmp	$_430


.SECTION .data
	.ALIGN	16

_base2table:
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x03, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x04, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x05, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x06, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x07, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x08, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x09, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x0A, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x0B, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x0C, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0x0D, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xFE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xFD, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xFC, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xFB, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xFA, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF9, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF7, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF6, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF5, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF4, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF3, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF2, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80
	.byte  0xF1, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

_fltpowtable:
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0
	.byte  0x02, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC8
	.byte  0x05, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x9C
	.byte  0x0C, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xBC, 0xBE
	.byte  0x19, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x04, 0xBF, 0xC9, 0x1B, 0x8E
	.byte  0x34, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xF0
	.byte  0x9D, 0xB5, 0x70, 0x2B, 0xA8, 0xAD, 0xC5, 0x9D
	.byte  0x69, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xFE, 0x25, 0x6B, 0xC7, 0x71, 0x6B, 0xBF, 0x3C
	.byte  0xD5, 0xA6, 0xCF, 0xFF, 0x49, 0x1F, 0x78, 0xC2
	.byte  0xD3, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x37, 0x01, 0xB1, 0x36, 0x6C, 0x33, 0x6F, 0xC6
	.byte  0xDF, 0x8C, 0xE9, 0x80, 0xC9, 0x47, 0xBA, 0x93
	.byte  0xA8, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xB7, 0xEA, 0xFE, 0x98, 0x1B, 0x90, 0xBB, 0xDD
	.byte  0x8D, 0xDE, 0xF9, 0x9D, 0xFB, 0xEB, 0x7E, 0xAA
	.byte  0x51, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x59, 0x50, 0xBC, 0x54, 0x5C, 0x65, 0xCC
	.byte  0xC6, 0x91, 0x0E, 0xA6, 0xAE, 0xA0, 0x19, 0xE3
	.byte  0xA3, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xD0, 0x50, 0x8B, 0xF1, 0x28, 0x3D, 0x0D, 0x65
	.byte  0x17, 0x0C, 0x75, 0x81, 0x86, 0x75, 0x76, 0xC9
	.byte  0x48, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x52, 0xCE, 0x9A, 0x32, 0xCE, 0x28, 0x4D, 0xA7
	.byte  0xE4, 0x5D, 0x3D, 0xC5, 0x5D, 0x3B, 0x8B, 0x9E
	.byte  0x92, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x80, 0x4A, 0x80, 0x3F, 0x15, 0x4C, 0xC9
	.byte  0x9A, 0x97, 0x20, 0x8A, 0x02, 0x52, 0x60, 0xC4
	.byte  0x25, 0x75, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC
	.byte  0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC
	.byte  0xFB, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x70, 0x3D, 0x0A, 0xD7, 0xA3, 0x70, 0x3D
	.byte  0x0A, 0xD7, 0xA3, 0x70, 0x3D, 0x0A, 0xD7, 0xA3
	.byte  0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xA8, 0xA4, 0x4E, 0x40, 0x13, 0x61, 0xC3, 0xD3
	.byte  0x2B, 0x65, 0x19, 0xE2, 0x58, 0x17, 0xB7, 0xD1
	.byte  0xF1, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x7C, 0xBA, 0x36, 0x2B, 0x0D, 0xC2, 0xFD
	.byte  0xFC, 0xCE, 0x61, 0x84, 0x11, 0x77, 0xCC, 0xAB
	.byte  0xE4, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0xB0, 0xA9, 0x89, 0x79, 0x68, 0xBE, 0x2E, 0x4C
	.byte  0x5B, 0xE1, 0x4D, 0xC4, 0xBE, 0x94, 0x95, 0xE6
	.byte  0xC9, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x4A, 0x81, 0xA5, 0xED, 0x18, 0xDE, 0x67
	.byte  0xBA, 0x94, 0x39, 0x45, 0xAD, 0x1E, 0xB1, 0xCF
	.byte  0x94, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x60, 0xB3, 0x47, 0xD7, 0x98, 0x23, 0x3F
	.byte  0xA5, 0xE9, 0x39, 0xA5, 0x27, 0xEA, 0x7F, 0xA8
	.byte  0x2A, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0xC0, 0x5D, 0xD0, 0xF6, 0xB3, 0x7C, 0xAC
	.byte  0xA0, 0xE4, 0xBC, 0x64, 0x7C, 0x46, 0xD0, 0xDD
	.byte  0x55, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x40, 0xFB, 0xFE, 0x55, 0x11, 0x91, 0xFA
	.byte  0x39, 0x19, 0x7A, 0x63, 0x25, 0x43, 0x31, 0xC0
	.byte  0xAC, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0xF2, 0xE3, 0x32, 0xD3, 0x32, 0x71
	.byte  0x1C, 0xD2, 0x23, 0xDB, 0x32, 0xEE, 0x49, 0x90
	.byte  0x5A, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0xD4, 0x6B, 0x58, 0x01, 0xA6, 0x87
	.byte  0xBD, 0xC0, 0x57, 0xDA, 0xA5, 0x82, 0xA6, 0xA2
	.byte  0xB5, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0xEB, 0xF2, 0xD4, 0x12, 0x25, 0x49
	.byte  0xE4, 0x2D, 0x36, 0x34, 0x4F, 0x53, 0xAE, 0xCE
	.byte  0x6B, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	.byte  0x00, 0x00, 0xC4, 0xA1, 0x23, 0x81, 0xE3, 0x2D
	.byte  0xDE, 0x9F, 0xCE, 0xD2, 0xC8, 0x04, 0xDD, 0xA6
	.byte  0xD8, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

flt:	.quad  0x0000000000000000
	.quad  0x0000000000000000
	.quad  0x0000000000000000
	.quad  0x0000000000000000
	.quad  0x0000000000000000

qerrno: .int   0x00000000

e_space:
	.byte  0x23, 0x6E, 0x6F, 0x74, 0x20, 0x65, 0x6E, 0x6F
	.byte  0x75, 0x67, 0x68, 0x20, 0x73, 0x70, 0x61, 0x63
	.byte  0x65, 0x00


.att_syntax prefix
