	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ## -- Begin function create_pa_curve
LCPI0_0:
	.long	0                               ## 0x0
	.long	32                              ## 0x20
	.long	64                              ## 0x40
	.long	96                              ## 0x60
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_create_pa_curve:                       ## @create_pa_curve
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	pushq	%r15
	pushq	%r14
	pushq	%r13
	pushq	%r12
	pushq	%rbx
	subq	$152, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rcx, -192(%rbp)                ## 8-byte Spill
	movq	%rdx, -176(%rbp)                ## 8-byte Spill
	movq	%rsi, %r13
	movq	%rdi, %r15
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movq	_NUM_BIN@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	leal	1(%rax), %r12d
	shlq	$2, %r12
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -56(%rbp)                 ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -64(%rbp)                 ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r14
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -104(%rbp)                ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -120(%rbp)                ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -112(%rbp)                ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -136(%rbp)                ## 8-byte Spill
	movq	%r12, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %rbx
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	leal	4(,%rax,4), %r12d
	movq	%r14, %rdi
	xorl	%esi, %esi
	movl	%r12d, %edx
	callq	_memset
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%esi, %esi
	movl	%r12d, %edx
	callq	_memset
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	xorl	%esi, %esi
	movl	%r12d, %edx
	callq	_memset
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	xorl	%esi, %esi
	movl	%r12d, %edx
	callq	_memset
	movq	%rbx, -72(%rbp)                 ## 8-byte Spill
	movq	%rbx, %rdi
	xorl	%esi, %esi
	movl	%r12d, %edx
	xorl	%r12d, %r12d
	callq	_memset
	movq	_NUM_BIN@GOTPCREL(%rip), %rax
	movl	(%rax), %r8d
	testl	%r8d, %r8d
	jle	LBB0_5
## %bb.1:
	xorl	%ebx, %ebx
	xorl	%r12d, %r12d
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_4:                                 ##   in Loop: Header=BB0_2 Depth=1
	incq	%rbx
	cmpq	%rbx, %r8
	je	LBB0_5
LBB0_2:                                 ## =>This Inner Loop Header: Depth=1
	movl	(%r15,%rbx,4), %eax
	movzwl	%ax, %edi
	cmpl	$17, %edi
	jb	LBB0_4
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	movl	(%r13,%rbx,4), %edx
	shrdl	$16, %edx, %eax
	movl	92(%r13,%rbx,4), %ecx
	shrl	$11, %edx
	andl	$31, %edx
	movl	92(%r15,%rbx,4), %esi
	shldl	$16, %esi, %ecx
	movzwl	%si, %esi
	shll	$5, %esi
	orl	%edx, %esi
	shll	$5, %eax
	shll	$5, %esi
	addl	%edi, %eax
	xorl	%edx, %edx
	divl	%edi
	addl	$32, %eax
	shrl	$5, %eax
	movslq	%r12d, %r9
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movl	%eax, 4(%rdx,%r9,4)
	addl	%edi, %esi
	movl	%esi, %eax
	xorl	%edx, %edx
	divl	%edi
                                        ## kill: def $eax killed $eax def $rax
	addl	$32, %eax
	shrl	$5, %eax
	movl	%ebx, %edx
	shll	$5, %edx
	addl	%edx, %eax
	addl	$16, %eax
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	movl	%eax, 4(%rdx,%r9,4)
	shll	$5, %ecx
	addl	%edi, %ecx
	movl	%ecx, %eax
	xorl	%edx, %edx
	divl	%edi
	movl	%eax, 4(%r14,%r9,4)
	leal	1(%r12), %eax
	movl	%eax, %r12d
	jmp	LBB0_4
LBB0_5:
	movl	8(%r14), %eax
	addl	4(%r14), %eax
	addl	12(%r14), %eax
	addl	16(%r14), %eax
	addl	20(%r14), %eax
	cltq
	imulq	$1717986919, %rax, %rax         ## imm = 0x66666667
	movq	%rax, %rcx
	shrq	$63, %rcx
	sarq	$33, %rax
	addl	%ecx, %eax
	movl	%eax, 16(%r14)
	movl	%eax, 20(%r14)
	movd	%eax, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	movdqa	%xmm0, (%r14)
	testl	%r12d, %r12d
	movq	-136(%rbp), %r11                ## 8-byte Reload
	movq	-56(%rbp), %r15                 ## 8-byte Reload
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	js	LBB0_17
## %bb.6:
	movl	$0, (%r14)
	je	LBB0_17
## %bb.7:
	leal	1(%r12), %ecx
	leaq	-1(%rcx), %r8
	movl	$1, %edx
	cmpq	$8, %r8
	jb	LBB0_16
## %bb.8:
	movq	%r8, %rdx
	andq	$-8, %rdx
	leaq	-8(%rdx), %rdi
	movq	%rdi, %rsi
	shrq	$3, %rsi
	incq	%rsi
	testq	%rdi, %rdi
	je	LBB0_9
## %bb.10:
	movq	%rsi, %rbx
	andq	$-2, %rbx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_11:                                ## =>This Inner Loop Header: Depth=1
	movdqu	4(%r14,%rdi,4), %xmm1
	movdqu	20(%r14,%rdi,4), %xmm2
	movdqu	36(%r14,%rdi,4), %xmm3
	movdqu	52(%r14,%rdi,4), %xmm4
	psubd	%xmm0, %xmm1
	psubd	%xmm0, %xmm2
	movdqu	%xmm1, 4(%r14,%rdi,4)
	movdqu	%xmm2, 20(%r14,%rdi,4)
	psubd	%xmm0, %xmm3
	psubd	%xmm0, %xmm4
	movdqu	%xmm3, 36(%r14,%rdi,4)
	movdqu	%xmm4, 52(%r14,%rdi,4)
	addq	$16, %rdi
	addq	$-2, %rbx
	jne	LBB0_11
## %bb.12:
	testb	$1, %sil
	je	LBB0_14
LBB0_13:
	shlq	$2, %rdi
	orq	$4, %rdi
	movdqu	(%r14,%rdi), %xmm1
	movdqu	16(%r14,%rdi), %xmm2
	psubd	%xmm0, %xmm1
	psubd	%xmm0, %xmm2
	movdqu	%xmm1, (%r14,%rdi)
	movdqu	%xmm2, 16(%r14,%rdi)
LBB0_14:
	cmpq	%rdx, %r8
	je	LBB0_17
## %bb.15:
	orq	$1, %rdx
	.p2align	4, 0x90
LBB0_16:                                ## =>This Inner Loop Header: Depth=1
	subl	%eax, (%r14,%rdx,4)
	incq	%rdx
	cmpq	%rdx, %rcx
	jne	LBB0_16
LBB0_17:
	movl	$0, (%r13)
	movl	12(%r15), %ecx
	movl	24(%r15), %edi
	xorl	%r9d, %r9d
	subl	%ecx, %edi
	je	LBB0_69
## %bb.18:
	movl	12(%r13), %esi
	movl	24(%r13), %eax
	subl	%esi, %eax
	shll	$8, %eax
	addl	%edi, %eax
	cltd
	idivl	%edi
	testl	%eax, %eax
	je	LBB0_69
## %bb.19:
	movl	%eax, %r10d
	testl	%r12d, %r12d
	js	LBB0_31
## %bb.20:
	imull	%r10d, %ecx
	movl	$256, %edx                      ## imm = 0x100
	subl	%ecx, %edx
	movl	$511, %eax                      ## imm = 0x1FF
	subl	%ecx, %eax
	testl	%edx, %edx
	cmovnsl	%edx, %eax
	sarl	$8, %eax
	addl	%esi, %eax
	negl	%eax
	movl	%eax, (%r11)
	testl	%r12d, %r12d
	je	LBB0_31
## %bb.21:
	leal	1(%r12), %ecx
	leaq	-1(%rcx), %r8
	movl	$1, %edx
	cmpq	$8, %r8
	jb	LBB0_30
## %bb.22:
	movq	%r8, %rdx
	andq	$-8, %rdx
	movd	%eax, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	leaq	-8(%rdx), %rdi
	movq	%rdi, %rsi
	shrq	$3, %rsi
	incq	%rsi
	testq	%rdi, %rdi
	je	LBB0_23
## %bb.24:
	movq	%rsi, %rbx
	andq	$-2, %rbx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_25:                                ## =>This Inner Loop Header: Depth=1
	movdqu	4(%r13,%rdi,4), %xmm1
	movdqu	20(%r13,%rdi,4), %xmm2
	paddd	%xmm0, %xmm1
	paddd	%xmm0, %xmm2
	movdqu	%xmm1, 4(%r11,%rdi,4)
	movdqu	%xmm2, 20(%r11,%rdi,4)
	movdqu	36(%r13,%rdi,4), %xmm1
	movdqu	52(%r13,%rdi,4), %xmm2
	paddd	%xmm0, %xmm1
	paddd	%xmm0, %xmm2
	movdqu	%xmm1, 36(%r11,%rdi,4)
	movdqu	%xmm2, 52(%r11,%rdi,4)
	addq	$16, %rdi
	addq	$-2, %rbx
	jne	LBB0_25
## %bb.26:
	testb	$1, %sil
	je	LBB0_28
LBB0_27:
	shlq	$2, %rdi
	orq	$4, %rdi
	movdqu	(%r13,%rdi), %xmm1
	movdqu	16(%r13,%rdi), %xmm2
	paddd	%xmm0, %xmm1
	paddd	%xmm0, %xmm2
	movdqu	%xmm1, (%r11,%rdi)
	movdqu	%xmm2, 16(%r11,%rdi)
LBB0_28:
	cmpq	%rdx, %r8
	je	LBB0_31
## %bb.29:
	orq	$1, %rdx
	.p2align	4, 0x90
LBB0_30:                                ## =>This Inner Loop Header: Depth=1
	movl	(%r13,%rdx,4), %esi
	addl	%eax, %esi
	movl	%esi, (%r11,%rdx,4)
	incq	%rdx
	cmpq	%rdx, %rcx
	jne	LBB0_30
LBB0_31:
	movl	$1, (%r15)
	leal	8192(%r10), %eax
	cltd
	idivl	%r10d
	movl	%eax, 4(%r15)
	leal	16384(%r10), %eax
	cltd
	idivl	%r10d
	movl	%eax, 8(%r15)
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [0,32,64,96]
	movdqa	%xmm0, (%r11)
	leal	24576(%r10), %eax
	cltd
	idivl	%r10d
	movl	%eax, 12(%r15)
	movslq	%r12d, %rcx
	movl	(%r11,%rcx,4), %esi
	testl	%esi, %esi
	je	LBB0_69
## %bb.32:
	movl	%esi, %eax
	shll	$8, %eax
	addl	%r10d, %eax
	cltd
	movq	%r10, -64(%rbp)                 ## 8-byte Spill
	idivl	%r10d
	movl	(%r15,%rcx,4), %ecx
	addl	%esi, %ecx
	subl	%eax, %ecx
	movl	%ecx, %eax
	cltd
	idivl	%esi
	xorl	%ecx, %ecx
	cmpl	$1, %eax
	sete	%cl
	orl	$8, %ecx
	testl	%eax, %eax
	movl	$10, %eax
	cmovnel	%ecx, %eax
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	movl	%r12d, %eax
	sarl	%eax
	cmpl	$16, %r12d
	movl	$7, %ecx
	cmovll	%eax, %ecx
	subl	%ecx, %r12d
	movl	$0, %edi
	movq	%r12, %rax
	movl	$0, %r12d
	movl	$0, %r13d
	movl	$0, %ebx
	movq	%r15, %rdx
	movl	$0, %r15d
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movl	%ecx, -156(%rbp)                ## 4-byte Spill
	js	LBB0_44
## %bb.33:
	leal	1(%rax), %r11d
	movslq	%ecx, %rax
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r8
	leaq	(%rdx,%rax,4), %r10
	xorl	%r9d, %r9d
	xorl	%r15d, %r15d
	xorl	%edi, %edi
	xorl	%r12d, %r12d
	xorl	%r13d, %r13d
	.p2align	4, 0x90
LBB0_34:                                ## =>This Inner Loop Header: Depth=1
	movl	(%r8,%r15,4), %esi
	testl	%esi, %esi
	je	LBB0_69
## %bb.35:                              ##   in Loop: Header=BB0_34 Depth=1
	movl	(%r10,%r15,4), %ebx
	movl	%esi, %eax
	shll	$8, %eax
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	addl	%ecx, %eax
	cltd
	idivl	%ecx
	subl	%eax, %ebx
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	shll	%cl, %ebx
	addl	%esi, %ebx
	movl	%ebx, %eax
	cltd
	idivl	%esi
	shll	%cl, %eax
	addl	%esi, %eax
	cltd
	idivl	%esi
                                        ## kill: def $cl killed $cl killed $rcx
	shll	%cl, %eax
	addl	%esi, %eax
	cltd
	idivl	%esi
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	movl	%eax, (%rcx,%r15,4)
	imull	%esi, %esi
	addl	$64, %esi
	shrl	$6, %esi
	movl	%eax, %ecx
	negl	%ecx
	cmovsl	%eax, %ecx
	cmpl	%edi, %ecx
	cmoval	%ecx, %edi
	movl	%esi, %eax
	imull	%esi, %eax
	addl	%eax, %r13d
	movl	%esi, %eax
	imull	%r11d, %eax
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	movl	%eax, (%rcx,%r15,4)
	addl	%esi, %r12d
	movq	-112(%rbp), %rax                ## 8-byte Reload
	movl	%esi, (%rax,%r15,4)
	incq	%r15
	cmpq	%r15, %r11
	jne	LBB0_34
## %bb.36:
	cmpl	$8, %r11d
	jae	LBB0_38
## %bb.37:
	xorl	%eax, %eax
	xorl	%r15d, %r15d
	xorl	%ebx, %ebx
	jmp	LBB0_41
LBB0_9:
	xorl	%edi, %edi
	testb	$1, %sil
	jne	LBB0_13
	jmp	LBB0_14
LBB0_38:
	movl	%r11d, %eax
	andl	$-8, %eax
	movd	%r12d, %xmm0
	pshufd	$0, %xmm0, %xmm9                ## xmm9 = xmm0[0,0,0,0]
	movd	%r13d, %xmm0
	pshufd	$0, %xmm0, %xmm8                ## xmm8 = xmm0[0,0,0,0]
	pxor	%xmm10, %xmm10
	xorl	%ecx, %ecx
	pxor	%xmm1, %xmm1
	pxor	%xmm4, %xmm4
	pxor	%xmm5, %xmm5
	movq	-120(%rbp), %rdx                ## 8-byte Reload
	movq	-112(%rbp), %rsi                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_39:                                ## =>This Inner Loop Header: Depth=1
	movdqa	(%rdx,%rcx,4), %xmm6
	movdqa	16(%rdx,%rcx,4), %xmm7
	psubd	%xmm9, %xmm6
	psubd	%xmm9, %xmm7
	movdqa	%xmm6, (%rdx,%rcx,4)
	movdqa	%xmm7, 16(%rdx,%rcx,4)
	movdqa	(%rsi,%rcx,4), %xmm3
	pmulld	%xmm9, %xmm3
	movdqa	16(%rsi,%rcx,4), %xmm2
	pmulld	%xmm9, %xmm2
	movdqa	%xmm8, %xmm0
	psubd	%xmm3, %xmm0
	movdqa	%xmm8, %xmm3
	psubd	%xmm2, %xmm3
	movdqa	%xmm0, (%rsi,%rcx,4)
	movdqa	%xmm3, 16(%rsi,%rcx,4)
	pabsd	%xmm6, %xmm2
	pmaxud	%xmm2, %xmm10
	pabsd	%xmm7, %xmm2
	pmaxud	%xmm2, %xmm1
	pabsd	%xmm0, %xmm0
	pmaxud	%xmm0, %xmm4
	pabsd	%xmm3, %xmm0
	pmaxud	%xmm0, %xmm5
	addq	$8, %rcx
	cmpq	%rcx, %rax
	jne	LBB0_39
## %bb.40:
	pmaxud	%xmm5, %xmm4
	pshufd	$238, %xmm4, %xmm0              ## xmm0 = xmm4[2,3,2,3]
	pmaxud	%xmm4, %xmm0
	pshufd	$85, %xmm0, %xmm2               ## xmm2 = xmm0[1,1,1,1]
	pmaxud	%xmm0, %xmm2
	movd	%xmm2, %ebx
	pmaxud	%xmm1, %xmm10
	pshufd	$238, %xmm10, %xmm0             ## xmm0 = xmm10[2,3,2,3]
	pmaxud	%xmm10, %xmm0
	pshufd	$85, %xmm0, %xmm1               ## xmm1 = xmm0[1,1,1,1]
	pmaxud	%xmm0, %xmm1
	movd	%xmm1, %r15d
	cmpq	%r11, %rax
	je	LBB0_43
LBB0_41:
	movq	-120(%rbp), %r9                 ## 8-byte Reload
	movq	-112(%rbp), %r10                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_42:                                ## =>This Inner Loop Header: Depth=1
	movl	%r15d, %r8d
	movl	(%r9,%rax,4), %edx
	subl	%r12d, %edx
	movl	(%r10,%rax,4), %esi
	imull	%r12d, %esi
	movl	%r13d, %ecx
	subl	%esi, %ecx
	movl	%edx, %r15d
	negl	%r15d
	cmovsl	%edx, %r15d
	cmpl	%r8d, %r15d
	cmovbel	%r8d, %r15d
	movl	%ebx, %esi
	movl	%ecx, %ebx
	negl	%ebx
	cmovsl	%ecx, %ebx
	cmpl	%esi, %ebx
	cmovbel	%esi, %ebx
	movl	%edx, (%r9,%rax,4)
	movl	%ecx, (%r10,%rax,4)
	incq	%rax
	cmpq	%rax, %r11
	jne	LBB0_42
LBB0_43:
	movq	-96(%rbp), %rax                 ## 8-byte Reload
LBB0_44:
	movq	%r14, -184(%rbp)                ## 8-byte Spill
	movq	%rax, %r14
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, -128(%rbp)                ## 4-byte Spill
	movl	%r15d, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, -88(%rbp)                 ## 4-byte Spill
	movl	%ebx, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, -80(%rbp)                 ## 4-byte Spill
	movl	$0, %ebx
	testl	%r14d, %r14d
	movq	-120(%rbp), %r15                ## 8-byte Reload
	movq	-112(%rbp), %r14                ## 8-byte Reload
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	movl	$0, %r8d
	js	LBB0_47
## %bb.45:
	movl	$1, %eax
	movl	-128(%rbp), %ecx                ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	shll	%cl, %eax
	movl	%eax, -56(%rbp)                 ## 4-byte Spill
	movl	$1, %r9d
	movl	-88(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	shll	%cl, %r9d
	movl	$1, %r10d
	movl	-80(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	shll	%cl, %r10d
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	leal	1(%rax), %r11d
	xorl	%esi, %esi
	xorl	%ebx, %ebx
	xorl	%r8d, %r8d
	.p2align	4, 0x90
LBB0_46:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rdi,%rsi,4), %eax
	cltd
	idivl	-56(%rbp)                       ## 4-byte Folded Reload
	movl	%eax, %ecx
	movl	%eax, (%rdi,%rsi,4)
	movl	(%r15,%rsi,4), %eax
	cltd
	idivl	%r9d
	movl	%eax, (%r15,%rsi,4)
	movl	(%r14,%rsi,4), %edx
	imull	%ecx, %eax
	addl	%eax, %r8d
	movl	%edx, %eax
	cltd
	idivl	%r10d
	movl	%eax, (%r14,%rsi,4)
	imull	%ecx, %eax
	addl	%eax, %ebx
	incq	%rsi
	cmpq	%rsi, %r11
	jne	LBB0_46
LBB0_47:
	movl	%r8d, -56(%rbp)                 ## 4-byte Spill
	leal	7(%r13), %eax
	testl	%r13d, %r13d
	cmovnsl	%r13d, %eax
	shrl	$3, %eax
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	leal	1(%rcx), %r13d
	imull	%r13d, %eax
	leal	7(%r12), %r15d
	testl	%r12d, %r12d
	cmovnsl	%r12d, %r15d
	shrl	$3, %r15d
	negl	%r15d
	imull	%r12d, %r15d
	addl	%eax, %r15d
	shll	$3, %r15d
	movl	%r15d, %edi
	negl	%edi
	cmovsl	%r15d, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, %ecx
	movl	$1, %esi
	shll	%cl, %esi
	movl	$1, %r12d
	movl	%r15d, %eax
	cltd
	idivl	%esi
	testl	%eax, %eax
	je	LBB0_48
## %bb.49:
	movl	%eax, %r14d
	movl	%r13d, -148(%rbp)               ## 4-byte Spill
	movq	%rcx, -168(%rbp)                ## 8-byte Spill
	movl	-56(%rbp), %r15d                ## 4-byte Reload
	movl	%r15d, %edi
	negl	%edi
	cmovsl	%r15d, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, %r13d
	movl	%ebx, %edi
	negl	%edi
	cmovsl	%ebx, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, %edi
	movl	$1, %esi
	movl	%r13d, %ecx
	shll	%cl, %esi
	movl	%edi, %ecx
	shll	%cl, %r12d
	movl	%r15d, %eax
	cltd
	idivl	%esi
	movl	%eax, %ecx
	movl	%ebx, %eax
	cltd
	idivl	%r12d
	shll	$10, %eax
	cltd
	idivl	%r14d
	movl	%eax, %r15d
	shll	$10, %ecx
	movl	%ecx, %eax
	cltd
	movl	%r14d, -152(%rbp)               ## 4-byte Spill
	idivl	%r14d
	movl	%eax, %r14d
	movq	-144(%rbp), %rax                ## 8-byte Reload
	leal	(%rax,%rax,2), %ecx
	subl	-128(%rbp), %ecx                ## 4-byte Folded Reload
	movl	%ecx, %eax
	subl	-88(%rbp), %eax                 ## 4-byte Folded Reload
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	subl	-80(%rbp), %ecx                 ## 4-byte Folded Reload
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	movq	_PAPRD_TABLE_SZ@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	testl	%eax, %eax
	movq	-104(%rbp), %rax                ## 8-byte Reload
	jle	LBB0_56
## %bb.50:
	movl	$0, (%rax)
	cmpl	$1, -56(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_56
## %bb.51:
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	addl	%ecx, %eax
	addl	$10, %eax
	subl	%r13d, %eax
	movq	-80(%rbp), %rdx                 ## 8-byte Reload
	addl	%edx, %ecx
	addl	$10, %ecx
	subl	%edi, %ecx
	movslq	%eax, %rbx
	imulq	$1717986919, %rbx, %rdi         ## imm = 0x66666667
	movq	%rdi, %rax
	shrq	$63, %rax
	shrq	$32, %rdi
	sarl	%edi
	addl	%eax, %edi
	movslq	%ecx, %rsi
	imulq	$1431655766, %rsi, %r11         ## imm = 0x55555556
	movq	%r11, %rax
	shrq	$63, %rax
	shrq	$32, %r11
	addl	%eax, %r11d
	leal	(%rdi,%rdi,4), %eax
	subl	%eax, %ebx
	movl	%r14d, %eax
	sarl	%eax
	movl	%edi, %ecx
	sarl	%cl, %eax
	shll	$5, %eax
	sarl	%cl, %eax
	shll	$5, %eax
	sarl	%cl, %eax
	shll	$5, %eax
	sarl	%cl, %eax
	shll	$5, %eax
	sarl	%cl, %eax
	leal	(%r11,%r11,2), %edx
	movq	%rbx, -72(%rbp)                 ## 8-byte Spill
	movl	%ebx, %ecx
	sarl	%cl, %eax
	movl	%r15d, %r12d
	shll	$5, %r12d
	movl	%r12d, %ebx
	movl	%r11d, %ecx
	sarl	%cl, %ebx
	shll	$5, %ebx
	sarl	%cl, %ebx
	shll	$5, %ebx
	sarl	%cl, %ebx
	subl	%edx, %esi
	movq	%rsi, -128(%rbp)                ## 8-byte Spill
	movl	%esi, %ecx
	sarl	%cl, %ebx
	addl	%eax, %ebx
	movl	$8192, %eax                     ## imm = 0x2000
	xorl	%edx, %edx
	idivl	-64(%rbp)                       ## 4-byte Folded Reload
	addl	%ebx, %eax
	cmpl	$1400, %eax                     ## imm = 0x578
	movl	$1400, %ecx                     ## imm = 0x578
	cmovgel	%ecx, %eax
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	movl	%eax, 4(%rcx)
	cmpl	$2, -56(%rbp)                   ## 4-byte Folded Reload
	jne	LBB0_52
LBB0_56:
	cmpl	$0, -96(%rbp)                   ## 4-byte Folded Reload
	js	LBB0_57
## %bb.58:
	movslq	-156(%rbp), %rax                ## 4-byte Folded Reload
	movl	-148(%rbp), %r8d                ## 4-byte Reload
	movq	-184(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r9
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r10
	xorl	%edi, %edi
	xorl	%r14d, %r14d
	xorl	%ebx, %ebx
	movq	-120(%rbp), %r11                ## 8-byte Reload
	movq	-112(%rbp), %r15                ## 8-byte Reload
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_59:                                ## =>This Inner Loop Header: Depth=1
	movl	(%r9,%rdi,4), %eax
	shll	%cl, %eax
	movl	(%r10,%rdi,4), %esi
	addl	%esi, %eax
	cltd
	idivl	%esi
	shll	%cl, %eax
	addl	%esi, %eax
	cltd
	idivl	%esi
	shll	%cl, %eax
	addl	%esi, %eax
	cltd
	idivl	%esi
	movl	(%r11,%rdi,4), %edx
	imull	%eax, %edx
	imull	(%r15,%rdi,4), %eax
	addl	%edx, %ebx
	addl	%eax, %r14d
	incq	%rdi
	cmpq	%rdi, %r8
	jne	LBB0_59
	jmp	LBB0_60
LBB0_48:
	xorl	%r9d, %r9d
	jmp	LBB0_69
LBB0_57:
	xorl	%ebx, %ebx
	xorl	%r14d, %r14d
LBB0_60:
	movl	%ebx, %edi
	negl	%edi
	cmovsl	%ebx, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, %r15d
	movl	%r14d, %edi
	negl	%edi
	cmovsl	%r14d, %edi
	callq	_find_expn
	movl	%eax, %edi
	movl	$10, %esi
	callq	_find_proper_scale
	movl	%eax, %r8d
	movl	$1, %r9d
	movl	$1, %esi
	movl	%r15d, %ecx
	shll	%cl, %esi
	movl	$1, %edi
	movl	%r8d, %ecx
	shll	%cl, %edi
	movl	%ebx, %eax
	cltd
	idivl	%esi
	movl	%eax, %ecx
	movl	%r14d, %eax
	cltd
	idivl	%edi
	shll	$10, %eax
	cltd
	movl	-152(%rbp), %esi                ## 4-byte Reload
	idivl	%esi
	movl	%eax, %r10d
	shll	$10, %ecx
	movl	%ecx, %eax
	cltd
	idivl	%esi
	movl	%eax, %r14d
	movq	_PAPRD_TABLE_SZ@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	jle	LBB0_68
## %bb.61:
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	addl	%ecx, %eax
	subl	%r8d, %eax
	addl	$15, %eax
	movslq	%eax, %r8
	imulq	$1431655766, %r8, %rdx          ## imm = 0x55555556
	movq	%rdx, %rax
	shrq	$63, %rax
	shrq	$32, %rdx
	addl	%eax, %edx
	leal	(%rdx,%rdx,2), %eax
	subl	%eax, %r8d
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	addl	%ecx, %eax
	subl	%r15d, %eax
	addl	$15, %eax
	cltq
	imulq	$1717986919, %rax, %rcx         ## imm = 0x66666667
	movq	%rcx, %rsi
	shrq	$63, %rsi
	sarq	$33, %rcx
	addl	%esi, %ecx
	leal	(%rcx,%rcx,4), %esi
	subl	%esi, %eax
	movl	$1, %r13d
                                        ## kill: def $cl killed $cl killed $rcx
	shll	%cl, %r13d
	movl	$1, %esi
	movl	%eax, %ecx
	shll	%cl, %esi
	movl	%esi, -56(%rbp)                 ## 4-byte Spill
	movl	$1, %r12d
	movl	%edx, %ecx
	shll	%cl, %r12d
	movl	$1, %r15d
	movl	%r8d, %ecx
	shll	%cl, %r15d
	movl	%r12d, %ecx
	negl	%ecx
	movl	%r13d, %r8d
	negl	%r8d
	testl	%r14d, %r14d
	cmovlel	%r12d, %ecx
	cmovlel	%r13d, %r8d
	shll	$5, %r14d
	shll	$5, %r10d
	movl	$-64, %ebx
	xorl	%edi, %edi
	xorl	%r11d, %r11d
	jmp	LBB0_62
	.p2align	4, 0x90
LBB0_67:                                ##   in Loop: Header=BB0_62 Depth=1
	incq	%r11
	movq	_PAPRD_TABLE_SZ@GOTPCREL(%rip), %rax
	movslq	(%rax), %rax
	addl	%r14d, %ebx
	addl	$32, %edi
	addl	%r10d, %ecx
	cmpq	%rax, %r11
	jge	LBB0_68
LBB0_62:                                ## =>This Inner Loop Header: Depth=1
	cmpq	$4, %r11
	je	LBB0_67
## %bb.63:                              ##   in Loop: Header=BB0_62 Depth=1
	xorl	%eax, %eax
	cmpq	$4, %r11
	jb	LBB0_65
## %bb.64:                              ##   in Loop: Header=BB0_62 Depth=1
	movl	%ebx, %eax
	sarl	$6, %eax
	addl	%r8d, %eax
	cltd
	idivl	%r13d
	imull	%edi, %eax
	cltd
	idivl	%r13d
	imull	%edi, %eax
	cltd
	idivl	%r13d
	imull	%edi, %eax
	cltd
	idivl	%r13d
	imull	%edi, %eax
	cltd
	idivl	%r13d
	cltd
	idivl	-56(%rbp)                       ## 4-byte Folded Reload
	movl	%eax, %esi
	movl	%ecx, %eax
	cltd
	idivl	%r12d
	imull	%edi, %eax
	cltd
	idivl	%r12d
	imull	%edi, %eax
	cltd
	idivl	%r12d
	cltd
	idivl	%r15d
	addl	%esi, %eax
	cmpl	$150, %eax
	movl	$150, %edx
	cmovgel	%edx, %eax
	cmpl	$-149, %eax
	movl	$-150, %edx
	cmovll	%edx, %eax
LBB0_65:                                ##   in Loop: Header=BB0_62 Depth=1
	movq	-104(%rbp), %rdx                ## 8-byte Reload
	movl	(%rdx,%r11,4), %edx
	shll	$11, %edx
	andl	$4192256, %edx                  ## imm = 0x3FF800
	movl	%eax, %esi
	andl	$2047, %esi                     ## imm = 0x7FF
	orl	%edx, %esi
	movq	-176(%rbp), %rdx                ## 8-byte Reload
	movl	%esi, (%rdx,%r11,4)
	cmpq	$5, %r11
	jne	LBB0_67
## %bb.66:                              ##   in Loop: Header=BB0_62 Depth=1
	addl	$2, %eax
	shrl	%eax
	movq	-104(%rbp), %rdx                ## 8-byte Reload
	movl	16(%rdx), %edx
	shll	$11, %edx
	andl	$4192256, %edx                  ## imm = 0x3FF800
	andl	$2047, %eax                     ## imm = 0x7FF
	orl	%edx, %eax
	movq	-176(%rbp), %rdx                ## 8-byte Reload
	movl	%eax, 16(%rdx)
	jmp	LBB0_67
LBB0_68:
	movq	-192(%rbp), %rax                ## 8-byte Reload
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	movl	%ecx, (%rax)
LBB0_69:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_71
## %bb.70:
	movl	%r9d, %eax
	leaq	-40(%rbp), %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_23:
	xorl	%edi, %edi
	testb	$1, %sil
	jne	LBB0_27
	jmp	LBB0_28
LBB0_52:
	movl	%r14d, %r8d
	shll	$6, %r8d
	shll	$5, %r14d
	shll	$6, %r15d
	movl	$2, %r13d
	movabsq	$4294967296, %r9                ## imm = 0x100000000
	movl	$16384, %ebx                    ## imm = 0x4000
	movl	$64, %r10d
	jmp	LBB0_53
	.p2align	4, 0x90
LBB0_55:                                ##   in Loop: Header=BB0_53 Depth=1
	cmpl	$1400, %eax                     ## imm = 0x578
	movl	$1400, %ecx                     ## imm = 0x578
	cmovgel	%ecx, %eax
	movl	%eax, (%rdx,%r13,4)
	incq	%r13
	incq	%r9
	addl	$8192, %ebx                     ## imm = 0x2000
	addl	%r14d, %r8d
	addl	$32, %r10d
	addl	%r12d, %r15d
	cmpq	%r13, -56(%rbp)                 ## 8-byte Folded Reload
	je	LBB0_56
LBB0_53:                                ## =>This Inner Loop Header: Depth=1
	movl	%r8d, %eax
	sarl	$6, %eax
	movl	%edi, %ecx
	sarl	%cl, %eax
	imull	%r10d, %eax
	sarl	%cl, %eax
	imull	%r10d, %eax
	sarl	%cl, %eax
	imull	%r10d, %eax
	sarl	%cl, %eax
	imull	%r10d, %eax
	sarl	%cl, %eax
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $cl killed $cl killed $rcx
	sarl	%cl, %eax
	movl	%r15d, %esi
	movl	%r11d, %ecx
	sarl	%cl, %esi
	imull	%r10d, %esi
	sarl	%cl, %esi
	imull	%r10d, %esi
	sarl	%cl, %esi
	movq	-128(%rbp), %rcx                ## 8-byte Reload
                                        ## kill: def $cl killed $cl killed $rcx
	sarl	%cl, %esi
	addl	%eax, %esi
	movl	%ebx, %eax
	cltd
	idivl	-64(%rbp)                       ## 4-byte Folded Reload
	movq	-104(%rbp), %rdx                ## 8-byte Reload
	addl	%esi, %eax
	movl	%eax, (%rdx,%r13,4)
	leal	1(%r9), %ecx
	movl	(%rdx,%rcx,4), %ecx
	cmpl	%ecx, %eax
	jge	LBB0_55
## %bb.54:                              ##   in Loop: Header=BB0_53 Depth=1
	movl	%r9d, %eax
	addl	%ecx, %ecx
	subl	(%rdx,%rax,4), %ecx
	movl	%ecx, %eax
	jmp	LBB0_55
LBB0_71:
	callq	___stack_chk_fail
	.cfi_endproc
                                        ## -- End function
	.comm	_NUM_BIN,4,2                    ## @NUM_BIN
	.comm	_PAPRD_TABLE_SZ,4,2             ## @PAPRD_TABLE_SZ
	.no_dead_strip	_create_pa_curve
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ; -- Begin function create_pa_curve
lCPI0_0:
	.long	0                               ; 0x0
	.long	32                              ; 0x20
	.long	64                              ; 0x40
	.long	96                              ; 0x60
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	2
_create_pa_curve:                       ; @create_pa_curve
	.cfi_startproc
; %bb.0:
	stp	x28, x27, [sp, #-96]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 96
	stp	x26, x25, [sp, #16]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #32]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #48]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #64]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #80]             ; 16-byte Folded Spill
	add	x29, sp, #80
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w19, -24
	.cfi_offset w20, -32
	.cfi_offset w21, -40
	.cfi_offset w22, -48
	.cfi_offset w23, -56
	.cfi_offset w24, -64
	.cfi_offset w25, -72
	.cfi_offset w26, -80
	.cfi_offset w27, -88
	.cfi_offset w28, -96
	sub	sp, sp, #80
	stp	x2, x3, [x29, #-128]            ; 16-byte Folded Spill
	mov	x26, x1
	mov	x27, x0
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	stur	x8, [x29, #-88]
Lloh3:
	adrp	x22, _NUM_BIN@GOTPAGE
Lloh4:
	ldr	x22, [x22, _NUM_BIN@GOTPAGEOFF]
	ldr	w8, [x22]
	add	w12, w8, #1
	lsl	x8, x12, #2
	mov	x9, x8
Lloh5:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh6:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x10, x8, #15
	and	x13, x10, #0x7fffffff0
	sub	x24, x9, x13
	mov	sp, x24
	mov	x9, x8
Lloh7:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh8:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x25, x9, x13
	mov	sp, x25
	mov	x9, x8
Lloh9:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh10:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x21, x9, x13
	mov	sp, x21
	mov	x9, x8
Lloh11:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh12:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x9, x9, x13
	stur	x9, [x29, #-112]                ; 8-byte Folded Spill
	mov	sp, x9
	mov	x9, x8
Lloh13:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh14:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x9, x9, x13
	stur	x9, [x29, #-104]                ; 8-byte Folded Spill
	mov	sp, x9
	mov	x9, x8
Lloh15:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh16:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x19, x9, x13
	mov	sp, x19
	mov	x9, x8
Lloh17:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh18:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x20, x9, x13
	mov	sp, x20
	mov	x9, x8
Lloh19:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh20:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x8, sp
	sub	x23, x8, x13
	mov	sp, x23
	lsl	w28, w12, #2
	mov	x0, x21
	mov	w1, #0
	mov	x2, x28
	bl	_memset
	mov	x0, x24
	mov	w1, #0
	mov	x2, x28
	bl	_memset
	mov	x0, x25
	mov	w1, #0
	mov	x2, x28
	bl	_memset
	stur	x20, [x29, #-96]                ; 8-byte Folded Spill
	mov	x0, x20
	mov	w1, #0
	mov	x2, x28
	bl	_memset
	mov	x0, x23
	mov	w1, #0
	mov	x2, x28
	bl	_memset
	ldr	w9, [x22]
	cmp	w9, #1
	b.lt	LBB0_5
; %bb.1:
	mov	x10, #0
	mov	w8, #0
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x10, x10, #1
	add	x26, x26, #4
	add	x27, x27, #4
	subs	x9, x9, #1
	b.eq	LBB0_6
LBB0_3:                                 ; =>This Inner Loop Header: Depth=1
	ldr	w12, [x27]
	and	w11, w12, #0xffff
	cmp	w11, #17
	b.lo	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	add	w8, w8, #1
	ldr	w13, [x26]
	extr	w12, w13, w12, #16
	ubfx	w13, w13, #11, #5
	ldr	w14, [x27, #92]
	bfi	w13, w14, #5, #16
	ldr	w15, [x26, #92]
	extr	w14, w15, w14, #16
	add	w12, w11, w12, lsl #5
	udiv	w12, w12, w11
	add	w12, w12, #32
	lsr	w12, w12, #5
	sbfiz	x15, x8, #2, #32
	str	w12, [x24, x15]
	add	w12, w11, w13, lsl #5
	udiv	w12, w12, w11
	add	w12, w12, #32
	lsr	w12, w12, #5
	add	w12, w12, w10, lsl #5
	add	w12, w12, #16
	str	w12, [x25, x15]
	add	w12, w11, w14, lsl #5
	udiv	w11, w12, w11
	str	w11, [x21, x15]
	b	LBB0_2
LBB0_5:
	mov	w8, #0
LBB0_6:
	ldp	w9, w10, [x21, #4]
	ldp	w11, w12, [x21, #12]
	add	w9, w10, w9
	add	w9, w11, w9
	ldr	w10, [x21, #20]
	add	w9, w12, w9
	add	w9, w10, w9
	mov	w10, #26215
	movk	w10, #26214, lsl #16
	smull	x9, w9, w10
	lsr	x10, x9, #63
	asr	x9, x9, #33
	add	w9, w9, w10
	stp	w9, w9, [x21, #16]
	dup.4s	v0, w9
	str	q0, [x21]
	tbnz	w8, #31, LBB0_15
; %bb.7:
	str	wzr, [x21]
	cbz	w8, LBB0_15
; %bb.8:
	add	w10, w8, #1
	sub	x12, x10, #1
	cmp	x12, #16
	b.hs	LBB0_10
; %bb.9:
	mov	w11, #1
	b	LBB0_13
LBB0_10:
	and	x13, x12, #0xfffffffffffffff0
	orr	x11, x13, #0x1
	add	x14, x21, #36
	mov	x15, x13
LBB0_11:                                ; =>This Inner Loop Header: Depth=1
	ldp	q1, q2, [x14, #-32]
	ldp	q3, q4, [x14]
	sub.4s	v1, v1, v0
	sub.4s	v2, v2, v0
	sub.4s	v3, v3, v0
	sub.4s	v4, v4, v0
	stp	q1, q2, [x14, #-32]
	stp	q3, q4, [x14], #64
	subs	x15, x15, #16
	b.ne	LBB0_11
; %bb.12:
	cmp	x12, x13
	b.eq	LBB0_15
LBB0_13:
	sub	x10, x10, x11
	add	x11, x21, x11, lsl #2
LBB0_14:                                ; =>This Inner Loop Header: Depth=1
	ldr	w12, [x11]
	sub	w12, w12, w9
	str	w12, [x11], #4
	subs	x10, x10, #1
	b.ne	LBB0_14
LBB0_15:
	mov	w0, #0
	str	wzr, [x25]
	ldr	w10, [x24, #24]
	ldr	w9, [x24, #12]
	subs	w11, w10, w9
	b.eq	LBB0_51
; %bb.16:
	ldr	w12, [x25, #24]
	ldr	w10, [x25, #12]
	sub	w12, w12, w10
	add	w12, w11, w12, lsl #8
	sdiv	w20, w12, w11
	cbz	w20, LBB0_50
; %bb.17:
	ldur	x17, [x29, #-96]                ; 8-byte Folded Reload
	tbnz	w8, #31, LBB0_26
; %bb.18:
	mul	w9, w20, w9
	mov	w11, #256
	sub	w11, w11, w9
	mov	w12, #511
	sub	w9, w12, w9
	cmp	w11, #0
	csel	w9, w9, w11, lt
	add	w9, w10, w9, asr #8
	neg	w9, w9
	str	w9, [x17]
	cbz	w8, LBB0_26
; %bb.19:
	add	w10, w8, #1
	sub	x12, x10, #1
	cmp	x12, #16
	b.hs	LBB0_21
; %bb.20:
	mov	w11, #1
	b	LBB0_24
LBB0_21:
	and	x13, x12, #0xfffffffffffffff0
	orr	x11, x13, #0x1
	dup.4s	v0, w9
	add	x14, x17, #36
	add	x15, x25, #36
	mov	x16, x13
LBB0_22:                                ; =>This Inner Loop Header: Depth=1
	ldp	q1, q2, [x15, #-32]
	ldp	q3, q4, [x15], #64
	add.4s	v1, v0, v1
	add.4s	v2, v0, v2
	add.4s	v3, v0, v3
	add.4s	v4, v0, v4
	stp	q1, q2, [x14, #-32]
	stp	q3, q4, [x14], #64
	subs	x16, x16, #16
	b.ne	LBB0_22
; %bb.23:
	cmp	x12, x13
	b.eq	LBB0_26
LBB0_24:
	sub	x10, x10, x11
	lsl	x12, x11, #2
	add	x11, x17, x12
	add	x12, x25, x12
LBB0_25:                                ; =>This Inner Loop Header: Depth=1
	ldr	w13, [x12], #4
	add	w13, w9, w13
	str	w13, [x11], #4
	subs	x10, x10, #1
	b.ne	LBB0_25
LBB0_26:
	mov	w9, #1
	add	w10, w20, #2, lsl #12           ; =8192
	sdiv	w10, w10, w20
	stp	w9, w10, [x24]
	add	w9, w20, #4, lsl #12            ; =16384
	sdiv	w9, w9, w20
Lloh21:
	adrp	x10, lCPI0_0@PAGE
Lloh22:
	ldr	q0, [x10, lCPI0_0@PAGEOFF]
	str	q0, [x17]
	add	w10, w20, #6, lsl #12           ; =24576
	sdiv	w10, w10, w20
	stp	w9, w10, [x24, #8]
	ldr	w9, [x17, w8, sxtw #2]
	cbz	w9, LBB0_50
; %bb.27:
	mov	x10, x8
	sxtw	x10, w10
	ldr	w10, [x24, x10, lsl #2]
	add	w11, w20, w9, lsl #8
	sdiv	w11, w11, w20
	add	w10, w10, w9
	sub	w10, w10, w11
	sdiv	w9, w10, w9
	cmp	w9, #1
	mov	w10, #8
	cinc	w10, w10, eq
	mov	w11, #10
	cmp	w9, #0
	csel	w27, w11, w10, eq
	asr	w9, w8, #1
	mov	w10, #7
	cmp	w8, #15
	csel	w2, w10, w9, gt
	subs	w3, w8, w2
	b.mi	LBB0_33
; %bb.28:
	mov	w0, #0
	mov	w22, #0
	mov	w28, #0
	add	w8, w3, #1
	sbfiz	x10, x2, #2, #32
	ldp	x14, x9, [x29, #-104]           ; 16-byte Folded Reload
	add	x9, x9, x10
	add	x10, x24, x10
	orr	w11, wzr, #0x40
	mov	x12, x8
	mov	x13, x23
	mov	x15, x19
LBB0_29:                                ; =>This Inner Loop Header: Depth=1
	ldr	w16, [x9]
	cbz	w16, LBB0_50
; %bb.30:                               ;   in Loop: Header=BB0_29 Depth=1
	ldr	w17, [x10], #4
	add	w1, w20, w16, lsl #8
	sdiv	w1, w1, w20
	sub	w17, w17, w1
	lsl	w17, w17, w27
	add	w17, w17, w16
	sdiv	w17, w17, w16
	lsl	w17, w17, w27
	add	w17, w17, w16
	sdiv	w17, w17, w16
	lsl	w17, w17, w27
	add	w17, w17, w16
	sdiv	w17, w17, w16
	str	w17, [x13], #4
	madd	w16, w16, w16, w11
	lsr	w16, w16, #6
	cmp	w17, #0
	cneg	w17, w17, mi
	cmp	w17, w0
	csel	w0, w17, w0, hi
	add	w22, w16, w22
	madd	w28, w16, w16, w28
	mul	w17, w16, w8
	str	w17, [x14], #4
	str	w16, [x15], #4
	add	x9, x9, #4
	subs	x12, x12, #1
	b.ne	LBB0_29
; %bb.31:
	cmp	w8, #16
	stur	x2, [x29, #-152]                ; 8-byte Folded Spill
	stur	w3, [x29, #-132]                ; 4-byte Folded Spill
	b.hs	LBB0_34
; %bb.32:
	mov	x9, #0
	mov	w25, #0
	mov	w26, #0
	ldur	x13, [x29, #-104]               ; 8-byte Folded Reload
	b	LBB0_37
LBB0_33:
	stur	w3, [x29, #-132]                ; 4-byte Folded Spill
	stur	x2, [x29, #-152]                ; 8-byte Folded Spill
	mov	w0, #0
	mov	w22, #0
	mov	w28, #0
	mov	w26, #0
	mov	w25, #0
	b	LBB0_39
LBB0_34:
	dup.4s	v1, w22
	dup.4s	v2, w28
	movi.2d	v0, #0000000000000000
	and	x9, x8, #0xfffffff0
	movi.2d	v3, #0000000000000000
	add	x10, x19, #32
	ldur	x13, [x29, #-104]               ; 8-byte Folded Reload
	add	x11, x13, #32
	mov	x12, x9
	movi.2d	v5, #0000000000000000
	movi.2d	v4, #0000000000000000
	movi.2d	v6, #0000000000000000
	movi.2d	v7, #0000000000000000
	movi.2d	v16, #0000000000000000
	movi.2d	v17, #0000000000000000
LBB0_35:                                ; =>This Inner Loop Header: Depth=1
	ldp	q18, q19, [x11, #-32]
	ldp	q20, q21, [x11]
	sub.4s	v18, v18, v1
	sub.4s	v19, v19, v1
	sub.4s	v20, v20, v1
	sub.4s	v21, v21, v1
	stp	q18, q19, [x11, #-32]
	stp	q20, q21, [x11], #64
	ldp	q22, q23, [x10, #-32]
	ldp	q24, q25, [x10]
	mov.16b	v26, v2
	mls.4s	v26, v22, v1
	mov.16b	v22, v2
	mls.4s	v22, v23, v1
	mov.16b	v23, v2
	mls.4s	v23, v24, v1
	mov.16b	v24, v2
	mls.4s	v24, v25, v1
	stp	q26, q22, [x10, #-32]
	stp	q23, q24, [x10], #64
	abs.4s	v18, v18
	abs.4s	v19, v19
	abs.4s	v20, v20
	abs.4s	v21, v21
	umax.4s	v0, v18, v0
	umax.4s	v3, v19, v3
	umax.4s	v5, v20, v5
	umax.4s	v4, v21, v4
	abs.4s	v18, v26
	abs.4s	v19, v22
	abs.4s	v20, v23
	abs.4s	v21, v24
	umax.4s	v6, v18, v6
	umax.4s	v7, v19, v7
	umax.4s	v16, v20, v16
	umax.4s	v17, v21, v17
	subs	x12, x12, #16
	b.ne	LBB0_35
; %bb.36:
	umax.4s	v1, v6, v7
	umax.4s	v1, v1, v16
	umax.4s	v1, v1, v17
	umaxv.4s	s1, v1
	fmov	w26, s1
	umax.4s	v0, v0, v3
	umax.4s	v0, v0, v5
	umax.4s	v0, v0, v4
	umaxv.4s	s0, v0
	fmov	w25, s0
	cmp	x9, x8
	b.eq	LBB0_39
LBB0_37:
	lsl	x11, x9, #2
	add	x10, x19, x11
	add	x11, x13, x11
	sub	x8, x8, x9
LBB0_38:                                ; =>This Inner Loop Header: Depth=1
	ldr	w9, [x11]
	subs	w9, w9, w22
	str	w9, [x11], #4
	ldr	w12, [x10]
	msub	w12, w12, w22, w28
	str	w12, [x10], #4
	cneg	w9, w9, mi
	cmp	w9, w25
	csel	w25, w9, w25, hi
	cmp	w12, #0
	cneg	w9, w12, mi
	cmp	w9, w26
	csel	w26, w9, w26, hi
	subs	x8, x8, #1
	b.ne	LBB0_38
LBB0_39:
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	stur	w0, [x29, #-136]                ; 4-byte Folded Spill
	mov	x0, x25
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	mov	x24, x0
	mov	x0, x26
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	ldur	w17, [x29, #-132]               ; 4-byte Folded Reload
	stp	w0, w24, [x29, #-144]           ; 8-byte Folded Spill
	tbnz	w17, #31, LBB0_42
; %bb.40:
	mov	w25, #0
	mov	w26, #0
	mov	w10, #1
	ldur	w14, [x29, #-136]               ; 4-byte Folded Reload
	lsl	w8, w10, w14
	lsl	w9, w10, w24
	lsl	w10, w10, w0
	add	w11, w17, #1
	ldur	x12, [x29, #-104]               ; 8-byte Folded Reload
	mov	x13, x19
	mov	x24, x14
LBB0_41:                                ; =>This Inner Loop Header: Depth=1
	ldr	w14, [x23]
	sdiv	w14, w14, w8
	str	w14, [x23], #4
	ldr	w15, [x12]
	sdiv	w15, w15, w9
	str	w15, [x12], #4
	ldr	w16, [x13]
	sdiv	w16, w16, w10
	str	w16, [x13], #4
	madd	w26, w15, w14, w26
	madd	w25, w16, w14, w25
	subs	x11, x11, #1
	b.ne	LBB0_41
	b	LBB0_43
LBB0_42:
	mov	w26, #0
	mov	w25, #0
	ldur	w24, [x29, #-136]               ; 4-byte Folded Reload
LBB0_43:
	add	w8, w28, #7
	cmp	w28, #0
	csel	w8, w8, w28, lt
	lsr	w8, w8, #3
	add	w28, w17, #1
	add	w9, w22, #7
	cmp	w22, #0
	csel	w9, w9, w22, lt
	lsr	w9, w9, #3
	mneg	w9, w9, w22
	madd	w8, w8, w28, w9
	lsl	w23, w8, #3
	cmp	w23, #0
	cneg	w0, w23, mi
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	mov	w22, #1
	lsl	w8, w22, w0
	sdiv	w8, w23, w8
	cbz	w8, LBB0_50
; %bb.44:
	stur	w0, [x29, #-156]                ; 4-byte Folded Spill
	stur	w8, [x29, #-136]                ; 4-byte Folded Spill
	cmp	w26, #0
	cneg	w0, w26, mi
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	mov	x23, x0
	cmp	w25, #0
	cneg	w0, w25, mi
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	add	w8, w27, w27, lsl #1
	sub	w8, w8, w24
	ldur	w9, [x29, #-140]                ; 4-byte Folded Reload
	sub	w30, w8, w9
	ldur	w9, [x29, #-144]                ; 4-byte Folded Reload
	sub	w8, w8, w9
	stur	w8, [x29, #-140]                ; 4-byte Folded Spill
Lloh23:
	adrp	x24, _PAPRD_TABLE_SZ@GOTPAGE
Lloh24:
	ldr	x24, [x24, _PAPRD_TABLE_SZ@GOTPAGEOFF]
	ldr	w17, [x24]
	cmp	w17, #1
	ldur	x7, [x29, #-112]                ; 8-byte Folded Reload
	b.lt	LBB0_47
; %bb.45:
	str	wzr, [x7]
	cmp	w17, #1
	b.eq	LBB0_47
; %bb.46:
	lsl	w8, w22, w23
	sdiv	w8, w26, w8
	lsl	w9, w22, w0
	sdiv	w9, w25, w9
	lsl	w9, w9, #10
	ldur	w14, [x29, #-136]               ; 4-byte Folded Reload
	sdiv	w1, w9, w14
	lsl	w10, w8, #10
	ldur	w8, [x29, #-156]                ; 4-byte Folded Reload
	add	w8, w8, #10
	add	w9, w8, w30
	sub	w11, w9, w23
	ldur	w9, [x29, #-140]                ; 4-byte Folded Reload
	add	w8, w8, w9
	sub	w12, w8, w0
	mov	w8, #26215
	movk	w8, #26214, lsl #16
	smull	x8, w11, w8
	lsr	x9, x8, #32
	lsr	x8, x8, #63
	add	w8, w8, w9, asr #1
	mov	w9, #21846
	movk	w9, #21845, lsl #16
	smull	x9, w12, w9
	lsr	x13, x9, #63
	lsr	x9, x9, #32
	add	w9, w9, w13
	sdiv	w15, w10, w14
	add	w10, w8, w8, lsl #2
	sub	w10, w11, w10
	sub	w11, w9, w9, lsl #2
	add	w11, w11, w12
	asr	w12, w15, #1
	asr	w12, w12, w8
	lsl	w12, w12, #5
	asr	w12, w12, w8
	lsl	w12, w12, #5
	asr	w12, w12, w8
	lsl	w12, w12, #5
	asr	w12, w12, w8
	lsl	w12, w12, #5
	asr	w12, w12, w8
	asr	w13, w12, w10
	lsl	w12, w1, #5
	asr	w14, w12, w9
	lsl	w14, w14, #5
	asr	w14, w14, w9
	lsl	w14, w14, #5
	asr	w14, w14, w9
	asr	w14, w14, w11
	mov	w16, #8192
	sdiv	w16, w16, w20
	add	w13, w13, w14
	add	w14, w13, w16
	mov	w13, #1400
	cmp	w14, #1400
	csel	w14, w14, w13, lt
	str	w14, [x7, #4]
	cmp	w17, #2
	b.ne	LBB0_64
LBB0_47:
	ldur	w8, [x29, #-132]                ; 4-byte Folded Reload
	tbnz	w8, #31, LBB0_53
; %bb.48:
	mov	x22, x30
	mov	w23, #0
	mov	w25, #0
	ldur	x8, [x29, #-152]                ; 8-byte Folded Reload
                                        ; kill: def $w8 killed $w8 killed $x8 def $x8
	sbfiz	x9, x8, #2, #32
	add	x8, x21, x9
	ldp	x13, x10, [x29, #-104]          ; 16-byte Folded Reload
	add	x9, x10, x9
LBB0_49:                                ; =>This Inner Loop Header: Depth=1
	ldr	w10, [x8], #4
	lsl	w10, w10, w27
	ldr	w11, [x9], #4
	add	w10, w10, w11
	sdiv	w10, w10, w11
	lsl	w10, w10, w27
	add	w10, w10, w11
	sdiv	w10, w10, w11
	lsl	w10, w10, w27
	add	w10, w10, w11
	ldr	w12, [x13], #4
	sdiv	w10, w10, w11
	madd	w25, w12, w10, w25
	ldr	w11, [x19], #4
	madd	w23, w11, w10, w23
	subs	x28, x28, #1
	b.ne	LBB0_49
	b	LBB0_54
LBB0_50:
	mov	w0, #0
LBB0_51:
	ldur	x8, [x29, #-88]
Lloh25:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh26:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh27:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_68
; %bb.52:
	sub	sp, x29, #80
	ldp	x29, x30, [sp, #80]             ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #64]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #16]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp], #96             ; 16-byte Folded Reload
	ret
LBB0_53:
	mov	x22, x30
	mov	w25, #0
	mov	w23, #0
LBB0_54:
	cmp	w25, #0
	cneg	w0, w25, mi
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	mov	x21, x0
	cmp	w23, #0
	cneg	w0, w23, mi
	bl	_find_expn
	mov	w1, #10
	bl	_find_proper_scale
	ldr	w8, [x24]
	cmp	w8, #1
	ldur	x7, [x29, #-128]                ; 8-byte Folded Reload
	ldur	x19, [x29, #-112]               ; 8-byte Folded Reload
	b.lt	LBB0_63
; %bb.55:
	mov	w8, #0
	mov	x9, #0
	mov	w13, #1
	lsl	w10, w13, w21
	sdiv	w10, w25, w10
	lsl	w11, w13, w0
	sdiv	w11, w23, w11
	lsl	w15, w11, #10
	lsl	w10, w10, #10
	ldur	w1, [x29, #-136]                ; 4-byte Folded Reload
	sdiv	w16, w10, w1
	ldur	w17, [x29, #-156]               ; 4-byte Folded Reload
	ldur	w10, [x29, #-140]               ; 4-byte Folded Reload
	add	w10, w10, w17
	sub	w10, w10, w0
	add	w10, w10, #15
	mov	w11, #21846
	movk	w11, #21845, lsl #16
	smull	x11, w10, w11
	lsr	x12, x11, #63
	lsr	x11, x11, #32
	add	w12, w11, w12
	sub	w11, w12, w12, lsl #2
	add	w14, w11, w10
	add	w10, w22, w17
	sub	w10, w10, w21
	add	w10, w10, #15
	mov	w11, #26215
	movk	w11, #26214, lsl #16
	smull	x11, w10, w11
	lsr	x17, x11, #63
	asr	x11, x11, #33
	add	w11, w11, w17
	add	w17, w11, w11, lsl #2
	sub	w17, w10, w17
	lsl	w10, w13, w11
	lsl	w11, w13, w17
	lsl	w12, w13, w12
	lsl	w13, w13, w14
	cmp	w16, #0
	cneg	w14, w12, gt
	sdiv	w17, w15, w1
	cneg	w15, w10, gt
	lsl	w16, w16, #5
	lsl	w17, w17, #5
	mov	w0, #-64
	mov	w1, #150
	mov	w2, #-150
	b	LBB0_57
LBB0_56:                                ;   in Loop: Header=BB0_57 Depth=1
	add	x9, x9, #1
	ldrsw	x3, [x24]
	add	w0, w0, w16
	add	w8, w8, #32
	add	w14, w14, w17
	cmp	x9, x3
	b.ge	LBB0_63
LBB0_57:                                ; =>This Inner Loop Header: Depth=1
	cmp	x9, #4
	b.eq	LBB0_56
; %bb.58:                               ;   in Loop: Header=BB0_57 Depth=1
	b.hs	LBB0_60
; %bb.59:                               ;   in Loop: Header=BB0_57 Depth=1
	mov	w3, #0
	b	LBB0_61
LBB0_60:                                ;   in Loop: Header=BB0_57 Depth=1
	add	w3, w15, w0, asr #6
	sdiv	w3, w3, w10
	mul	w3, w3, w8
	sdiv	w3, w3, w10
	mul	w3, w3, w8
	sdiv	w3, w3, w10
	mul	w3, w3, w8
	sdiv	w3, w3, w10
	mul	w3, w3, w8
	sdiv	w3, w3, w10
	sdiv	w3, w3, w11
	sdiv	w4, w14, w12
	mul	w4, w4, w8
	sdiv	w4, w4, w12
	mul	w4, w4, w8
	sdiv	w4, w4, w12
	sdiv	w4, w4, w13
	add	w3, w4, w3
	cmp	w3, #150
	csel	w3, w3, w1, lt
	cmn	w3, #150
	csel	w3, w3, w2, gt
LBB0_61:                                ;   in Loop: Header=BB0_57 Depth=1
	lsl	x4, x9, #2
	ldr	w5, [x19, x4]
	and	w6, w3, #0x7ff
	bfi	w6, w5, #11, #11
	str	w6, [x7, x4]
	cmp	x9, #5
	b.ne	LBB0_56
; %bb.62:                               ;   in Loop: Header=BB0_57 Depth=1
	add	w3, w3, #2
	ldr	w4, [x19, #16]
	ubfx	w3, w3, #1, #11
	bfi	w3, w4, #11, #11
	str	w3, [x7, #16]
	b	LBB0_56
LBB0_63:
	ldur	x8, [x29, #-120]                ; 8-byte Folded Reload
	str	w20, [x8]
	mov	w0, #1
	b	LBB0_51
LBB0_64:
	lsl	w14, w15, #6
	lsl	w15, w15, #5
	add	x16, x7, #8
	sub	x17, x17, #2
	lsl	w0, w1, #6
	mov	x1, #4294967296
	mov	w2, #16384
	mov	w3, #64
	b	LBB0_66
LBB0_65:                                ;   in Loop: Header=BB0_66 Depth=1
	cmp	w4, #1400
	csel	w4, w4, w13, lt
	str	w4, [x16], #4
	add	x1, x1, #1
	add	w2, w2, #2, lsl #12             ; =8192
	add	w14, w14, w15
	add	w3, w3, #32
	add	w0, w0, w12
	subs	x17, x17, #1
	b.eq	LBB0_47
LBB0_66:                                ; =>This Inner Loop Header: Depth=1
	asr	w4, w14, #6
	asr	w4, w4, w8
	mul	w4, w4, w3
	asr	w4, w4, w8
	mul	w4, w4, w3
	asr	w4, w4, w8
	mul	w4, w4, w3
	asr	w4, w4, w8
	mul	w4, w4, w3
	asr	w4, w4, w8
	asr	w4, w4, w10
	asr	w5, w0, w9
	mul	w5, w5, w3
	asr	w5, w5, w9
	mul	w5, w5, w3
	asr	w5, w5, w9
	asr	w5, w5, w11
	sdiv	w6, w2, w20
	add	w4, w4, w5
	add	w4, w4, w6
	str	w4, [x16]
	add	w5, w1, #1
	ldr	w5, [x7, w5, uxtw #2]
	cmp	w4, w5
	b.ge	LBB0_65
; %bb.67:                               ;   in Loop: Header=BB0_66 Depth=1
	ldr	w4, [x7, w1, uxtw #2]
	lsl	w5, w5, #1
	sub	w4, w5, w4
	b	LBB0_65
LBB0_68:
	bl	___stack_chk_fail
	.loh AdrpLdrGot	Lloh19, Lloh20
	.loh AdrpLdrGot	Lloh17, Lloh18
	.loh AdrpLdrGot	Lloh15, Lloh16
	.loh AdrpLdrGot	Lloh13, Lloh14
	.loh AdrpLdrGot	Lloh11, Lloh12
	.loh AdrpLdrGot	Lloh9, Lloh10
	.loh AdrpLdrGot	Lloh7, Lloh8
	.loh AdrpLdrGot	Lloh5, Lloh6
	.loh AdrpLdrGot	Lloh3, Lloh4
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdr	Lloh21, Lloh22
	.loh AdrpLdrGot	Lloh23, Lloh24
	.loh AdrpLdrGotLdr	Lloh25, Lloh26, Lloh27
	.cfi_endproc
                                        ; -- End function
	.comm	_NUM_BIN,4,2                    ; @NUM_BIN
	.comm	_PAPRD_TABLE_SZ,4,2             ; @PAPRD_TABLE_SZ
	.no_dead_strip	_create_pa_curve
.subsections_via_symbols
