	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function compute_distinct_stats
LCPI0_0:
	.quad	0x3ff0000000000000              ## double 1
LCPI0_1:
	.quad	0x3fe0000000000000              ## double 0.5
LCPI0_3:
	.quad	0x3fb999999999999a              ## double 0.10000000000000001
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4
LCPI0_2:
	.quad	0x8000000000000000              ## double -0
	.quad	0x8000000000000000              ## double -0
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_compute_distinct_stats:                ## @compute_distinct_stats
	.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	$168, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movsd	%xmm0, -112(%rbp)               ## 8-byte Spill
	movl	%edx, %r15d
	movq	%rsi, -200(%rbp)                ## 8-byte Spill
	movq	%rdi, %rbx
	movq	56(%rdi), %rax
	cmpl	$0, 4(%rax)
	je	LBB0_2
## %bb.1:
	movl	$0, -116(%rbp)                  ## 4-byte Folded Spill
	movl	$0, -88(%rbp)                   ## 4-byte Folded Spill
	jmp	LBB0_3
LBB0_2:
	movl	(%rax), %eax
	cmpl	$-1, %eax
	sete	%cl
	movl	%ecx, -116(%rbp)                ## 4-byte Spill
	shrl	$31, %eax
	movl	%eax, -88(%rbp)                 ## 4-byte Spill
LBB0_3:
	movq	112(%rbx), %r14
	movq	120(%rbx), %rax
	movl	(%rax), %eax
	movq	%rax, -136(%rbp)                ## 8-byte Spill
	addl	%eax, %eax
	cmpl	$11, %eax
	movl	$10, %ecx
	cmovgel	%eax, %ecx
	movq	%rcx, -144(%rbp)                ## 8-byte Spill
	leal	(,%rcx,8), %edi
	callq	_palloc
	movq	%rax, %r13
	movq	%r14, -192(%rbp)                ## 8-byte Spill
	movl	4(%r14), %edi
	leaq	-156(%rbp), %rsi
	callq	_fmgr_info
	testl	%r15d, %r15d
	jle	LBB0_97
## %bb.4:
	leaq	4(%r13), %rax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	leaq	8(%r13), %rax
	movq	%rax, -184(%rbp)                ## 8-byte Spill
	leaq	12(%r13), %rax
	movq	%rax, -176(%rbp)                ## 8-byte Spill
	leaq	-8(%r13), %rax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	xorpd	%xmm3, %xmm3
	movq	%rbx, -104(%rbp)                ## 8-byte Spill
	xorl	%ebx, %ebx
	movl	$0, -92(%rbp)                   ## 4-byte Folded Spill
	xorl	%eax, %eax
	movl	$0, -84(%rbp)                   ## 4-byte Folded Spill
	xorl	%r12d, %r12d
	movl	%r15d, -44(%rbp)                ## 4-byte Spill
	jmp	LBB0_8
	.p2align	4, 0x90
LBB0_5:                                 ##   in Loop: Header=BB0_8 Depth=1
	incl	-92(%rbp)                       ## 4-byte Folded Spill
	movl	%r14d, %r12d
	movl	%r15d, %eax
LBB0_6:                                 ##   in Loop: Header=BB0_8 Depth=1
	movl	-44(%rbp), %r15d                ## 4-byte Reload
LBB0_7:                                 ##   in Loop: Header=BB0_8 Depth=1
	movsd	-56(%rbp), %xmm3                ## 8-byte Reload
                                        ## xmm3 = mem[0],zero
	movl	-48(%rbp), %ebx                 ## 4-byte Reload
	incl	%ebx
	cmpl	%r15d, %ebx
	je	LBB0_52
LBB0_8:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_18 Depth 2
                                        ##     Child Loop BB0_27 Depth 2
                                        ##     Child Loop BB0_43 Depth 2
                                        ##     Child Loop BB0_47 Depth 2
	movsd	%xmm3, -56(%rbp)                ## 8-byte Spill
	movl	%eax, %r15d
	movl	%r12d, %r14d
	xorl	%eax, %eax
	callq	_vacuum_delay_point
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	movl	%ebx, -48(%rbp)                 ## 4-byte Spill
	movl	%ebx, %esi
	leaq	-152(%rbp), %rdx
	callq	*-200(%rbp)                     ## 8-byte Folded Reload
	cmpl	$0, -152(%rbp)
	jne	LBB0_5
## %bb.9:                               ##   in Loop: Header=BB0_8 Depth=1
	movq	%r14, -72(%rbp)                 ## 8-byte Spill
	movq	%r12, -80(%rbp)                 ## 8-byte Spill
	incl	%r15d
	cmpb	$0, -116(%rbp)                  ## 1-byte Folded Reload
	movl	%r15d, -60(%rbp)                ## 4-byte Spill
	je	LBB0_12
## %bb.10:                              ##   in Loop: Header=BB0_8 Depth=1
	movl	%eax, %ebx
	movl	%eax, %edi
	callq	_DatumGetPointer
	movl	%eax, %edi
	callq	_VARSIZE_ANY
	xorps	%xmm0, %xmm0
	cvtsi2sd	%rax, %xmm0
	movsd	-56(%rbp), %xmm1                ## 8-byte Reload
                                        ## xmm1 = mem[0],zero
	addsd	%xmm0, %xmm1
	movsd	%xmm1, -56(%rbp)                ## 8-byte Spill
	movl	%ebx, %edi
	callq	_toast_raw_datum_size
	movq	_WIDTH_THRESHOLD@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jle	LBB0_14
## %bb.11:                              ##   in Loop: Header=BB0_8 Depth=1
	incl	-84(%rbp)                       ## 4-byte Folded Spill
	movq	-72(%rbp), %r12                 ## 8-byte Reload
                                        ## kill: def $r12d killed $r12d killed $r12 def $r12
	movl	-60(%rbp), %eax                 ## 4-byte Reload
	jmp	LBB0_6
LBB0_12:                                ##   in Loop: Header=BB0_8 Depth=1
	cmpb	$0, -88(%rbp)                   ## 1-byte Folded Reload
	movq	-104(%rbp), %rbx                ## 8-byte Reload
	movl	%eax, %r12d
	je	LBB0_15
## %bb.13:                              ##   in Loop: Header=BB0_8 Depth=1
	movl	%r12d, %edi
	callq	_DatumGetCString
	movl	%eax, %edi
	callq	_strlen
	incq	%rax
	xorps	%xmm0, %xmm0
	cvtsi2sd	%rax, %xmm0
	movsd	-56(%rbp), %xmm1                ## 8-byte Reload
                                        ## xmm1 = mem[0],zero
	addsd	%xmm0, %xmm1
	movsd	%xmm1, -56(%rbp)                ## 8-byte Spill
	jmp	LBB0_15
LBB0_14:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	%ebx, %edi
	callq	_PG_DETOAST_DATUM
	movl	%eax, %edi
	callq	_PointerGetDatum
	movl	%eax, %r12d
	movq	-104(%rbp), %rbx                ## 8-byte Reload
LBB0_15:                                ##   in Loop: Header=BB0_8 Depth=1
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r14d
	testl	%eax, %eax
	jle	LBB0_21
## %bb.16:                              ##   in Loop: Header=BB0_8 Depth=1
	xorl	%r15d, %r15d
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r14d
	jmp	LBB0_18
	.p2align	4, 0x90
LBB0_17:                                ##   in Loop: Header=BB0_18 Depth=2
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	incq	%r15
	cmpq	%r15, %rax
	je	LBB0_21
LBB0_18:                                ##   Parent Loop BB0_8 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	72(%rbx), %esi
	movl	(%r13,%r15,8), %ecx
	leaq	-156(%rbp), %rdi
	movl	%r12d, %edx
	callq	_FunctionCall2Coll
	movl	%eax, %edi
	callq	_DatumGetBool
	testq	%rax, %rax
	jne	LBB0_24
## %bb.19:                              ##   in Loop: Header=BB0_18 Depth=2
	movslq	%r14d, %rax
	cmpq	%rax, %r15
	jge	LBB0_17
## %bb.20:                              ##   in Loop: Header=BB0_18 Depth=2
	cmpl	$1, 4(%r13,%r15,8)
	cmovel	%r15d, %r14d
	jmp	LBB0_17
LBB0_21:                                ##   in Loop: Header=BB0_8 Depth=1
	xorl	%r11d, %r11d
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	cmpl	-144(%rbp), %eax                ## 4-byte Folded Reload
	setl	%r11b
	leal	(%rax,%r11), %r8d
	addl	%r11d, %eax
	decl	%eax
	cmpl	%r14d, %eax
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	jle	LBB0_48
## %bb.22:                              ##   in Loop: Header=BB0_8 Depth=1
	movslq	%eax, %rdi
	movslq	%r14d, %rcx
	movq	%rdi, %r9
	subq	%rcx, %r9
	cmpq	$2, %r9
	jae	LBB0_30
## %bb.23:                              ##   in Loop: Header=BB0_8 Depth=1
	movl	%r8d, %eax
	jmp	LBB0_47
LBB0_24:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	4(%r13,%r15,8), %eax
	leal	1(%rax), %ecx
	movl	%ecx, 4(%r13,%r15,8)
	testl	%r15d, %r15d
	je	LBB0_29
## %bb.25:                              ##   in Loop: Header=BB0_8 Depth=1
	leal	-1(%r15), %ebx
	cmpl	4(%r13,%rbx,8), %eax
	jl	LBB0_29
## %bb.26:                              ##   in Loop: Header=BB0_8 Depth=1
	leaq	4(,%rbx,8), %r14
	addq	%r13, %r14
	.p2align	4, 0x90
LBB0_27:                                ##   Parent Loop BB0_8 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r13,%r15,8), %edi
	movl	(%r13,%rbx,8), %esi
	callq	_swapDatum
	movl	4(%r13,%r15,8), %edi
	movl	4(%r13,%rbx,8), %esi
	callq	_swapInt
	cmpl	$2, %r15d
	jl	LBB0_29
## %bb.28:                              ##   in Loop: Header=BB0_27 Depth=2
	movl	(%r14), %eax
	leal	-2(%r15), %ebx
	leaq	4(,%rbx,8), %r14
	addq	%r13, %r14
	decq	%r15
	cmpl	4(%r13,%rbx,8), %eax
	jg	LBB0_27
LBB0_29:                                ##   in Loop: Header=BB0_8 Depth=1
	movq	-72(%rbp), %r12                 ## 8-byte Reload
                                        ## kill: def $r12d killed $r12d killed $r12 def $r12
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	jmp	LBB0_51
LBB0_30:                                ##   in Loop: Header=BB0_8 Depth=1
	movq	%rcx, %rsi
	notq	%rsi
	addq	%rdi, %rsi
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leal	(%rax,%r11), %r10d
	addl	$-2, %r10d
	movl	%r10d, %ebx
	subl	%esi, %ebx
	movq	%rsi, %rax
	movl	$8, %edx
	mulq	%rdx
	seto	%r15b
	cmpl	%r10d, %ebx
	jg	LBB0_45
## %bb.31:                              ##   in Loop: Header=BB0_8 Depth=1
	shrq	$32, %rsi
	jne	LBB0_45
## %bb.32:                              ##   in Loop: Header=BB0_8 Depth=1
	movslq	%r10d, %rsi
	leaq	(,%rsi,8), %rdx
	addq	%r13, %rdx
	movq	%rdx, %rbx
	subq	%rax, %rbx
	cmpq	%rdx, %rbx
	ja	LBB0_45
## %bb.33:                              ##   in Loop: Header=BB0_8 Depth=1
	testb	%r15b, %r15b
	jne	LBB0_45
## %bb.34:                              ##   in Loop: Header=BB0_8 Depth=1
	movq	-128(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rsi,8), %rdx
	movq	%rdx, %rsi
	subq	%rax, %rsi
	cmpq	%rdx, %rsi
	ja	LBB0_45
## %bb.35:                              ##   in Loop: Header=BB0_8 Depth=1
	testb	%r15b, %r15b
	jne	LBB0_45
## %bb.36:                              ##   in Loop: Header=BB0_8 Depth=1
	leaq	(,%rdi,8), %rdx
	addq	%r13, %rdx
	movq	%rdx, %rsi
	subq	%rax, %rsi
	cmpq	%rdx, %rsi
	ja	LBB0_45
## %bb.37:                              ##   in Loop: Header=BB0_8 Depth=1
	testb	%r15b, %r15b
	jne	LBB0_45
## %bb.38:                              ##   in Loop: Header=BB0_8 Depth=1
	movq	-128(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rdi,8), %rsi
	movq	%rsi, %rdx
	subq	%rax, %rdx
	cmpq	%rsi, %rdx
	ja	LBB0_45
## %bb.39:                              ##   in Loop: Header=BB0_8 Depth=1
	testb	%r15b, %r15b
	jne	LBB0_45
## %bb.40:                              ##   in Loop: Header=BB0_8 Depth=1
	movl	%r10d, -148(%rbp)               ## 4-byte Spill
	movl	%r12d, -72(%rbp)                ## 4-byte Spill
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	addl	%r11d, %eax
	addl	$-2, %eax
	cltq
	leaq	(%rcx,%rax), %rdx
	subq	%rdi, %rdx
	movq	-184(%rbp), %r10                ## 8-byte Reload
	leaq	(%r10,%rdx,8), %r11
	movq	-128(%rbp), %rbx                ## 8-byte Reload
	leaq	(%rbx,%rax,8), %rbx
	leaq	(%r10,%rcx,8), %r15
	movq	-176(%rbp), %r12                ## 8-byte Reload
	leaq	(%r12,%rdx,8), %rdx
	leaq	(%r10,%rax,8), %rax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	leaq	(%r12,%rcx,8), %r12
	leaq	(%r10,%rdi,8), %rax
	cmpq	%rsi, %r11
	setb	%sil
	cmpq	%rbx, %r15
	setb	%bl
	cmpq	%rax, %rdx
	setb	%al
	cmpq	-80(%rbp), %r12                 ## 8-byte Folded Reload
	setb	%dl
	testb	%bl, %sil
	jne	LBB0_46
## %bb.41:                              ##   in Loop: Header=BB0_8 Depth=1
	andb	%dl, %al
	jne	LBB0_46
## %bb.42:                              ##   in Loop: Header=BB0_8 Depth=1
	movq	%r9, %r11
	andq	$-2, %r11
	movl	%r8d, %eax
	subl	%r11d, %eax
	movq	%r11, %r12
	negq	%r12
	movq	-168(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rdi,8), %r15
	subq	%r11, %rdi
	movl	-148(%rbp), %edx                ## 4-byte Reload
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_43:                                ##   Parent Loop BB0_8 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	leal	(%rdx,%rbx), %esi
	movslq	%esi, %rsi
	movupd	-8(%r13,%rsi,8), %xmm0
	movupd	%xmm0, (%r15,%rbx,8)
	addq	$-2, %rbx
	cmpq	%rbx, %r12
	jne	LBB0_43
## %bb.44:                              ##   in Loop: Header=BB0_8 Depth=1
	cmpq	%r11, %r9
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	movl	-72(%rbp), %r12d                ## 4-byte Reload
	jne	LBB0_47
	jmp	LBB0_48
LBB0_45:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	%r8d, %eax
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	jmp	LBB0_47
LBB0_46:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	%r8d, %eax
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	movl	-72(%rbp), %r12d                ## 4-byte Reload
	.p2align	4, 0x90
LBB0_47:                                ##   Parent Loop BB0_8 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	cltq
	movl	-16(%r13,%rax,8), %edx
	movl	%edx, (%r13,%rdi,8)
	movl	-12(%r13,%rax,8), %eax
	movl	%eax, 4(%r13,%rdi,8)
	movl	%edi, %eax
	leaq	-1(%rdi), %rdx
	movq	%rdx, %rdi
	cmpq	%rcx, %rdx
	jg	LBB0_47
LBB0_48:                                ##   in Loop: Header=BB0_8 Depth=1
	cmpl	%r8d, %r14d
	jge	LBB0_50
## %bb.49:                              ##   in Loop: Header=BB0_8 Depth=1
	movslq	%r14d, %rax
	movl	%r12d, (%r13,%rax,8)
	movl	$1, 4(%r13,%rax,8)
LBB0_50:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	%r8d, %r12d
LBB0_51:                                ##   in Loop: Header=BB0_8 Depth=1
	movl	-60(%rbp), %eax                 ## 4-byte Reload
	jmp	LBB0_7
LBB0_52:
	testl	%eax, %eax
	movsd	-112(%rbp), %xmm2               ## 8-byte Reload
                                        ## xmm2 = mem[0],zero
	jle	LBB0_55
## %bb.53:
	xorps	%xmm1, %xmm1
	cvtsi2sdl	-92(%rbp), %xmm1        ## 4-byte Folded Reload
	xorps	%xmm0, %xmm0
	cvtsi2sd	%r15d, %xmm0
	movq	-104(%rbp), %rbx                ## 8-byte Reload
	movl	$1, (%rbx)
	divsd	%xmm0, %xmm1
	movsd	%xmm1, 8(%rbx)
	cmpb	$0, -88(%rbp)                   ## 1-byte Folded Reload
	movsd	%xmm0, -72(%rbp)                ## 8-byte Spill
	je	LBB0_59
## %bb.54:
	movl	%eax, %edi
	xorps	%xmm0, %xmm0
	cvtsi2sd	%eax, %xmm0
	divsd	%xmm0, %xmm3
	jmp	LBB0_60
LBB0_55:
	cmpl	$0, -92(%rbp)                   ## 4-byte Folded Reload
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	jle	LBB0_97
## %bb.56:
	movl	$1, (%rcx)
	movabsq	$4607182418800017408, %rax      ## imm = 0x3FF0000000000000
	movq	%rax, 8(%rcx)
	xorpd	%xmm0, %xmm0
	cmpb	$0, -88(%rbp)                   ## 1-byte Folded Reload
	jne	LBB0_58
## %bb.57:
	movq	56(%rcx), %rax
	xorps	%xmm0, %xmm0
	cvtsi2sdl	(%rax), %xmm0
LBB0_58:
	movsd	%xmm0, 16(%rcx)
	movq	$0, 24(%rcx)
	jmp	LBB0_97
LBB0_59:
	movl	%eax, %edi
	movq	56(%rbx), %rax
	xorps	%xmm3, %xmm3
	cvtsi2sdl	(%rax), %xmm3
LBB0_60:
	movsd	%xmm3, 16(%rbx)
	testl	%r12d, %r12d
	jle	LBB0_70
## %bb.61:
	movl	%r12d, %edx
	xorl	%eax, %eax
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_62:                                ## =>This Inner Loop Header: Depth=1
	movl	4(%r13,%rax,8), %esi
	cmpl	$1, %esi
	je	LBB0_65
## %bb.63:                              ##   in Loop: Header=BB0_62 Depth=1
	addl	%esi, %ecx
	incq	%rax
	cmpq	%rax, %rdx
	jne	LBB0_62
## %bb.64:
	movl	%edx, %eax
LBB0_65:
	testl	%eax, %eax
	je	LBB0_70
## %bb.66:
	cmpl	-144(%rbp), %r12d               ## 4-byte Folded Reload
	jge	LBB0_71
## %bb.67:
	cmpl	$0, -84(%rbp)                   ## 4-byte Folded Reload
	jne	LBB0_71
## %bb.68:
	cmpl	%r12d, %eax
	jne	LBB0_71
## %bb.69:
	xorps	%xmm0, %xmm0
	cvtsi2sd	%r12d, %xmm0
	movl	$0, -84(%rbp)                   ## 4-byte Folded Spill
	jmp	LBB0_75
LBB0_70:
	movsd	LCPI0_0(%rip), %xmm0            ## xmm0 = mem[0],zero
	subsd	%xmm1, %xmm0
	xorpd	LCPI0_2(%rip), %xmm0
	jmp	LBB0_75
LBB0_71:
	subl	%ecx, %edi
	addl	%edi, %eax
	movsd	LCPI0_0(%rip), %xmm0            ## xmm0 = mem[0],zero
	subsd	%xmm1, %xmm0
	mulsd	%xmm2, %xmm0
	xorpd	%xmm1, %xmm1
	ucomisd	%xmm1, %xmm0
	jbe	LBB0_73
## %bb.72:
	movl	%edi, %ecx
	movl	%edi, %edx
	movl	%r15d, %ecx
	subl	-92(%rbp), %ecx                 ## 4-byte Folded Reload
	xorps	%xmm3, %xmm3
	cvtsi2sd	%ecx, %xmm3
	xorps	%xmm2, %xmm2
	cvtsi2sd	%eax, %xmm2
	movapd	%xmm3, %xmm1
	mulsd	%xmm2, %xmm1
	cvtsi2sd	%edi, %xmm4
	movapd	%xmm3, %xmm5
	subsd	%xmm4, %xmm5
	mulsd	%xmm4, %xmm3
	divsd	%xmm0, %xmm3
	addsd	%xmm5, %xmm3
	divsd	%xmm3, %xmm1
	jmp	LBB0_74
LBB0_73:
	xorps	%xmm2, %xmm2
	cvtsi2sd	%eax, %xmm2
LBB0_74:
	maxsd	%xmm1, %xmm2
	minsd	%xmm2, %xmm0
	addsd	LCPI0_1(%rip), %xmm0
	callq	_floor
	xorps	%xmm0, %xmm0
	cvtsi2sd	%eax, %xmm0
	movsd	-112(%rbp), %xmm2               ## 8-byte Reload
                                        ## xmm2 = mem[0],zero
LBB0_75:
	movq	-136(%rbp), %rax                ## 8-byte Reload
	movsd	LCPI0_3(%rip), %xmm1            ## xmm1 = mem[0],zero
	mulsd	%xmm2, %xmm1
	ucomisd	%xmm1, %xmm0
	jbe	LBB0_77
## %bb.76:
	xorpd	LCPI0_2(%rip), %xmm0
	divsd	%xmm2, %xmm0
LBB0_77:
	movsd	%xmm0, 24(%rbx)
	cmpl	-144(%rbp), %r12d               ## 4-byte Folded Reload
	jge	LBB0_81
## %bb.78:
	cmpl	$0, -84(%rbp)                   ## 4-byte Folded Reload
	jne	LBB0_81
## %bb.79:
	xorpd	%xmm1, %xmm1
	ucomisd	%xmm1, %xmm0
	jbe	LBB0_81
## %bb.80:
	cmpl	%eax, %r12d
	jle	LBB0_93
LBB0_81:
	cmpl	%r12d, %eax
	cmovll	%eax, %r12d
	testl	%r12d, %r12d
	jle	LBB0_97
## %bb.82:
	leal	(,%r12,4), %edi
	callq	_palloc
	movl	%r12d, %ecx
	cmpl	$9, %r12d
	jb	LBB0_85
## %bb.83:
	leaq	(,%rcx,8), %rdx
	addq	%r13, %rdx
	cmpq	%rdx, %rax
	jae	LBB0_86
## %bb.84:
	leaq	(%rax,%rcx,4), %rdx
	cmpq	%rdx, -128(%rbp)                ## 8-byte Folded Reload
	jae	LBB0_86
LBB0_85:
	xorl	%edx, %edx
	jmp	LBB0_88
LBB0_86:
	movl	%ecx, %edx
	andl	$7, %edx
	testq	%rdx, %rdx
	movl	$8, %esi
	cmovneq	%rdx, %rsi
	movq	%rcx, %rdx
	subq	%rsi, %rdx
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_87:                                ## =>This Inner Loop Header: Depth=1
	movups	4(%r13,%rsi,8), %xmm0
	movups	20(%r13,%rsi,8), %xmm1
	shufps	$136, %xmm1, %xmm0              ## xmm0 = xmm0[0,2],xmm1[0,2]
	movups	36(%r13,%rsi,8), %xmm1
	movups	52(%r13,%rsi,8), %xmm2
	shufps	$136, %xmm2, %xmm1              ## xmm1 = xmm1[0,2],xmm2[0,2]
	movups	%xmm0, (%rax,%rsi,4)
	movups	%xmm1, 16(%rax,%rsi,4)
	addq	$8, %rsi
	cmpq	%rsi, %rdx
	jne	LBB0_87
LBB0_88:
	movsd	-112(%rbp), %xmm2               ## 8-byte Reload
                                        ## xmm2 = mem[0],zero
	movl	%ecx, %edi
	subl	%edx, %edi
	movq	%rdx, %rsi
	notq	%rsi
	addq	%rcx, %rsi
	andq	$3, %rdi
	je	LBB0_90
	.p2align	4, 0x90
LBB0_89:                                ## =>This Inner Loop Header: Depth=1
	movl	4(%r13,%rdx,8), %ebx
	movl	%ebx, (%rax,%rdx,4)
	incq	%rdx
	decq	%rdi
	jne	LBB0_89
LBB0_90:
	cmpq	$3, %rsi
	jb	LBB0_92
	.p2align	4, 0x90
LBB0_91:                                ## =>This Inner Loop Header: Depth=1
	movl	4(%r13,%rdx,8), %esi
	movl	%esi, (%rax,%rdx,4)
	movl	12(%r13,%rdx,8), %esi
	movl	%esi, 4(%rax,%rdx,4)
	movl	20(%r13,%rdx,8), %esi
	movl	%esi, 8(%rax,%rdx,4)
	movl	28(%r13,%rdx,8), %esi
	movl	%esi, 12(%rax,%rdx,4)
	addq	$4, %rdx
	cmpq	%rdx, %rcx
	jne	LBB0_91
LBB0_92:
	movq	-104(%rbp), %rbx                ## 8-byte Reload
	movsd	8(%rbx), %xmm1                  ## xmm1 = mem[0],zero
	movsd	24(%rbx), %xmm0                 ## xmm0 = mem[0],zero
	movq	%rax, %rdi
	movl	%r12d, %esi
	movl	%r15d, %edx
	callq	_analyze_mcv_list
	movl	%eax, %r12d
LBB0_93:
	testl	%r12d, %r12d
	jle	LBB0_97
## %bb.94:
	movl	104(%rbx), %edi
	callq	_MemoryContextSwitchTo
	movl	%eax, -48(%rbp)                 ## 4-byte Spill
	leal	(,%r12,4), %edi
	callq	_palloc
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	leal	(,%r12,8), %edi
	callq	_palloc
	movq	%rax, %r14
	movq	%r12, -80(%rbp)                 ## 8-byte Spill
	movl	%r12d, %r12d
	movq	%rbx, %r15
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_95:                                ## =>This Inner Loop Header: Depth=1
	movl	(%r13,%rbx,8), %edi
	movq	56(%r15), %rax
	movl	4(%rax), %esi
	xorps	%xmm0, %xmm0
	cvtsi2sdl	(%rax), %xmm0
	callq	_datumCopy
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	movl	%eax, (%rcx,%rbx,4)
	xorps	%xmm0, %xmm0
	cvtsi2sdl	4(%r13,%rbx,8), %xmm0
	divsd	-72(%rbp), %xmm0                ## 8-byte Folded Reload
	movsd	%xmm0, (%r14,%rbx,8)
	incq	%rbx
	cmpq	%rbx, %r12
	jne	LBB0_95
## %bb.96:
	movl	-48(%rbp), %edi                 ## 4-byte Reload
	callq	_MemoryContextSwitchTo
	movq	_STATISTIC_KIND_MCV@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	96(%r15), %rcx
	movl	%eax, (%rcx)
	movq	-192(%rbp), %rax                ## 8-byte Reload
	movl	(%rax), %eax
	movq	88(%r15), %rcx
	movl	%eax, (%rcx)
	movl	72(%r15), %eax
	movq	80(%r15), %rcx
	movl	%eax, (%rcx)
	movq	32(%r15), %rax
	movq	%r14, (%rax)
	movq	40(%r15), %rax
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	movl	%ecx, (%rax)
	movq	64(%r15), %rax
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movq	%rdx, (%rax)
	movq	48(%r15), %rax
	movl	%ecx, (%rax)
LBB0_97:
	addq	$168, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.comm	_WIDTH_THRESHOLD,8,3            ## @WIDTH_THRESHOLD
	.comm	_STATISTIC_KIND_MCV,4,2         ## @STATISTIC_KIND_MCV
	.no_dead_strip	_compute_distinct_stats
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function compute_distinct_stats
_compute_distinct_stats:                ; @compute_distinct_stats
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #240
	.cfi_def_cfa_offset 240
	stp	d11, d10, [sp, #112]            ; 16-byte Folded Spill
	stp	d9, d8, [sp, #128]              ; 16-byte Folded Spill
	stp	x28, x27, [sp, #144]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #160]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #176]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #192]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #208]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #224]            ; 16-byte Folded Spill
	add	x29, sp, #224
	.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
	.cfi_offset b8, -104
	.cfi_offset b9, -112
	.cfi_offset b10, -120
	.cfi_offset b11, -128
	fmov	d8, d0
	mov	x27, x2
	str	x1, [sp, #80]                   ; 8-byte Folded Spill
	mov	x19, x0
	ldr	x8, [x0, #56]
	ldr	w9, [x8, #4]
	cbz	w9, LBB0_2
; %bb.1:
	str	wzr, [sp, #92]                  ; 4-byte Folded Spill
	str	wzr, [sp, #56]                  ; 4-byte Folded Spill
	b	LBB0_3
LBB0_2:
	ldr	w8, [x8]
	cmn	w8, #1
	cset	w9, eq
	str	w9, [sp, #92]                   ; 4-byte Folded Spill
	lsr	w8, w8, #31
	str	w8, [sp, #56]                   ; 4-byte Folded Spill
LBB0_3:
	ldp	x21, x8, [x19, #112]
	ldr	w22, [x8]
	lsl	w8, w22, #1
	mov	w9, #10
	cmp	w8, #10
	csel	w8, w8, w9, gt
	str	w8, [sp, #60]                   ; 4-byte Folded Spill
	lsl	w0, w8, #3
	bl	_palloc
	mov	x20, x0
	str	x21, [sp, #40]                  ; 8-byte Folded Spill
	ldr	w0, [x21, #4]
	add	x1, sp, #108
	bl	_fmgr_info
	cmp	w27, #1
	b.lt	LBB0_102
; %bb.4:
	str	w22, [sp, #20]                  ; 4-byte Folded Spill
	mov	w24, #0
	mov	w28, #0
	mov	w21, #0
	str	wzr, [sp, #52]                  ; 4-byte Folded Spill
	mov	w23, #0
	add	x8, x20, #4
	str	x8, [sp, #64]                   ; 8-byte Folded Spill
	add	x9, x20, #8
	add	x8, x20, #12
	stp	x8, x9, [sp, #24]               ; 16-byte Folded Spill
	sub	x8, x20, #24
	str	x8, [sp, #8]                    ; 8-byte Folded Spill
	movi	d9, #0000000000000000
	str	w27, [sp, #76]                  ; 4-byte Folded Spill
	ldr	x22, [sp, #80]                  ; 8-byte Folded Reload
	b	LBB0_7
LBB0_5:                                 ;   in Loop: Header=BB0_7 Depth=1
	mov	x23, x8
	ldr	w28, [sp, #100]                 ; 4-byte Folded Reload
LBB0_6:                                 ;   in Loop: Header=BB0_7 Depth=1
	add	w24, w24, #1
	cmp	w24, w27
	b.eq	LBB0_60
LBB0_7:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_19 Depth 2
                                        ;     Child Loop BB0_30 Depth 2
                                        ;     Child Loop BB0_46 Depth 2
                                        ;     Child Loop BB0_25 Depth 2
	mov	w26, w23
	bl	_vacuum_delay_point
	add	x2, sp, #104
	mov	x0, x19
	mov	x1, x24
	blr	x22
	ldr	w8, [sp, #104]
	cbz	w8, LBB0_10
; %bb.8:                                ;   in Loop: Header=BB0_7 Depth=1
	add	w28, w28, #1
LBB0_9:                                 ;   in Loop: Header=BB0_7 Depth=1
	mov	x23, x26
	b	LBB0_6
LBB0_10:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x25, x0
	add	w21, w21, #1
	ldr	w8, [sp, #92]                   ; 4-byte Folded Reload
	cbz	w8, LBB0_13
; %bb.11:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x0, x25
	bl	_DatumGetPointer
	bl	_VARSIZE_ANY
	scvtf	d0, x0
	fadd	d9, d9, d0
	mov	x0, x25
	bl	_toast_raw_datum_size
Lloh0:
	adrp	x8, _WIDTH_THRESHOLD@GOTPAGE
Lloh1:
	ldr	x8, [x8, _WIDTH_THRESHOLD@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	cmp	x0, x8
	b.le	LBB0_15
; %bb.12:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	w8, [sp, #52]                   ; 4-byte Folded Reload
	add	w8, w8, #1
	str	w8, [sp, #52]                   ; 4-byte Folded Spill
	b	LBB0_9
LBB0_13:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	w8, [sp, #56]                   ; 4-byte Folded Reload
	stp	w21, w28, [sp, #96]             ; 8-byte Folded Spill
	cbz	w8, LBB0_16
; %bb.14:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x0, x25
	bl	_DatumGetCString
	bl	_strlen
	add	x8, x0, #1
	scvtf	d0, x8
	fadd	d9, d9, d0
	b	LBB0_16
LBB0_15:                                ;   in Loop: Header=BB0_7 Depth=1
	stp	w21, w28, [sp, #96]             ; 8-byte Folded Spill
	mov	x0, x25
	bl	_PG_DETOAST_DATUM
	bl	_PointerGetDatum
	mov	x25, x0
LBB0_16:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x28, x23
	cmp	w23, #1
	b.lt	LBB0_22
; %bb.17:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	w21, #0
	mov	x27, #0
	ldr	x22, [sp, #64]                  ; 8-byte Folded Reload
	mov	x28, x23
	b	LBB0_19
LBB0_18:                                ;   in Loop: Header=BB0_19 Depth=2
	add	x27, x27, #1
	add	x22, x22, #8
	add	w21, w21, #1
	cmp	x26, x27
	b.eq	LBB0_22
LBB0_19:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w1, [x19, #72]
	ldur	w3, [x22, #-4]
	add	x0, sp, #108
	mov	x2, x25
	bl	_FunctionCall2Coll
	bl	_DatumGetBool
	cbnz	x0, LBB0_28
; %bb.20:                               ;   in Loop: Header=BB0_19 Depth=2
	cmp	x27, w28, sxtw
	b.ge	LBB0_18
; %bb.21:                               ;   in Loop: Header=BB0_19 Depth=2
	ldr	w8, [x22]
	cmp	w8, #1
	csel	w28, w27, w28, eq
	b	LBB0_18
LBB0_22:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	w8, [sp, #60]                   ; 4-byte Folded Reload
	cmp	w23, w8
	cset	w13, lt
	cinc	w8, w23, lt
	sub	w9, w8, #1
	cmp	w9, w28
	ldr	w27, [sp, #76]                  ; 4-byte Folded Reload
	ldr	w21, [sp, #96]                  ; 4-byte Folded Reload
	ldr	x22, [sp, #80]                  ; 8-byte Folded Reload
	b.le	LBB0_26
; %bb.23:                               ;   in Loop: Header=BB0_7 Depth=1
	sxtw	x10, w9
	sxtw	x9, w28
	sub	x11, x10, x9
	cmp	x11, #8
	b.hs	LBB0_33
; %bb.24:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
LBB0_25:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x11, x20, w13, sxtw #3
	ldur	d0, [x11, #-16]
	str	d0, [x20, x10, lsl #3]
	mov	x13, x10
	sub	x11, x10, #1
	mov	x10, x11
	cmp	x11, x9
	b.gt	LBB0_25
LBB0_26:                                ;   in Loop: Header=BB0_7 Depth=1
	cmp	w28, w8
	b.ge	LBB0_5
; %bb.27:                               ;   in Loop: Header=BB0_7 Depth=1
	add	x9, x20, w28, sxtw #3
	mov	w10, #1
	stp	w25, w10, [x9]
	b	LBB0_5
LBB0_28:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	w9, [x22]
	add	w8, w9, #1
	str	w8, [x22]
	cbz	w27, LBB0_48
; %bb.29:                               ;   in Loop: Header=BB0_7 Depth=1
	sub	w8, w27, #1
	add	x23, x20, w8, uxtw #3
	ldr	w10, [x23, #4]!
	cmp	w9, w10
	ldr	w28, [sp, #100]                 ; 4-byte Folded Reload
	b.lt	LBB0_32
LBB0_30:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldur	w0, [x22, #-4]
	lsl	x8, x8, #3
	ldr	w1, [x20, x8]
	bl	_swapDatum
	ldr	w0, [x22]
	ldr	w1, [x23]
	bl	_swapInt
	subs	w8, w21, #2
	b.lt	LBB0_32
; %bb.31:                               ;   in Loop: Header=BB0_30 Depth=2
	ldr	w9, [x23]
	add	x23, x20, w8, uxtw #3
	ldr	w10, [x23, #4]!
	sub	x22, x22, #8
	sub	w21, w21, #1
	cmp	w9, w10
	b.gt	LBB0_30
LBB0_32:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x23, x26
	ldr	w27, [sp, #76]                  ; 4-byte Folded Reload
	b	LBB0_49
LBB0_33:                                ;   in Loop: Header=BB0_7 Depth=1
	mvn	x14, x9
	add	w12, w23, w13
	sub	w12, w12, #2
	add	x15, x14, x10
	sub	w16, w12, w15
	cmp	xzr, x15, lsr #61
	cset	w14, ne
	cmp	w16, w12
	b.gt	LBB0_56
; %bb.34:                               ;   in Loop: Header=BB0_7 Depth=1
	lsr	x16, x15, #32
	cbnz	x16, LBB0_57
; %bb.35:                               ;   in Loop: Header=BB0_7 Depth=1
	sbfiz	x17, x12, #3, #32
	lsl	x16, x15, #3
	add	x15, x20, x17
	sub	x0, x15, x16
	cmp	x0, x15
	b.hi	LBB0_58
; %bb.36:                               ;   in Loop: Header=BB0_7 Depth=1
	tbnz	w14, #0, LBB0_59
; %bb.37:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x15, [sp, #64]                  ; 8-byte Folded Reload
	add	x15, x15, x17
	sub	x17, x15, x16
	cmp	x17, x15
	b.hi	LBB0_54
; %bb.38:                               ;   in Loop: Header=BB0_7 Depth=1
	tbnz	w14, #0, LBB0_55
; %bb.39:                               ;   in Loop: Header=BB0_7 Depth=1
	lsl	x15, x10, #3
	add	x17, x20, x15
	sub	x0, x17, x16
	cmp	x0, x17
	b.hi	LBB0_52
; %bb.40:                               ;   in Loop: Header=BB0_7 Depth=1
	tbnz	w14, #0, LBB0_53
; %bb.41:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x17, [sp, #64]                  ; 8-byte Folded Reload
	add	x17, x17, x15
	sub	x16, x17, x16
	cmp	x16, x17
	b.hi	LBB0_50
; %bb.42:                               ;   in Loop: Header=BB0_7 Depth=1
	tbnz	w14, #0, LBB0_51
; %bb.43:                               ;   in Loop: Header=BB0_7 Depth=1
	add	w13, w23, w13
	sub	w13, w13, #2
	sxtw	x14, w13
	add	x14, x9, x14
	sub	x14, x14, x10
	lsl	x14, x14, #3
	ldp	x2, x3, [sp, #24]               ; 16-byte Folded Reload
	add	x16, x3, x14
	sbfiz	x13, x13, #3, #32
	ldr	x1, [sp, #64]                   ; 8-byte Folded Reload
	add	x17, x1, x13
	lsl	x0, x9, #3
	add	x1, x1, x15
	add	x14, x2, x14
	add	x13, x3, x13
	add	x2, x2, x0
	add	x15, x3, x15
	cmp	x14, x15
	ccmp	x2, x13, #2, lo
	cset	w14, lo
	add	x13, x3, x0
	cmp	x13, x17
	mov	x13, x8
	ccmp	x16, x1, #2, lo
	b.lo	LBB0_25
; %bb.44:                               ;   in Loop: Header=BB0_7 Depth=1
	tbnz	w14, #0, LBB0_25
; %bb.45:                               ;   in Loop: Header=BB0_7 Depth=1
	and	x14, x11, #0xfffffffffffffff8
	sub	x15, x10, x14
	sub	w13, w8, w14
	ldr	x16, [sp, #8]                   ; 8-byte Folded Reload
	add	x10, x16, x10, lsl #3
	mov	x16, x14
LBB0_46:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	sub	w17, w12, #4
	add	x0, x20, w12, sxtw #3
	sub	x0, x0, #24
	ld2.4s	{ v0, v1 }, [x0]
	add	x17, x20, w17, sxtw #3
	sub	x17, x17, #24
	ld2.4s	{ v2, v3 }, [x17]
	st2.4s	{ v0, v1 }, [x10]
	sub	x17, x10, #32
	st2.4s	{ v2, v3 }, [x17]
	sub	w12, w12, #8
	sub	x10, x10, #64
	sub	x16, x16, #8
	cbnz	x16, LBB0_46
; %bb.47:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x10, x15
	cmp	x11, x14
	b.ne	LBB0_25
	b	LBB0_26
LBB0_48:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x23, x26
	ldr	w27, [sp, #76]                  ; 4-byte Folded Reload
	ldr	w28, [sp, #100]                 ; 4-byte Folded Reload
LBB0_49:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	w21, [sp, #96]                  ; 4-byte Folded Reload
	ldr	x22, [sp, #80]                  ; 8-byte Folded Reload
	b	LBB0_6
LBB0_50:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_51:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_52:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_53:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_54:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_55:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_56:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_57:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_58:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_59:                                ;   in Loop: Header=BB0_7 Depth=1
	mov	x13, x8
	b	LBB0_25
LBB0_60:
	cmp	w21, #1
	b.lt	LBB0_63
; %bb.61:
	mov	w8, #1
	str	w8, [x19]
	scvtf	d0, w28
	scvtf	d10, w27
	fdiv	d0, d0, d10
	str	d0, [x19, #8]
	ldr	w8, [sp, #56]                   ; 4-byte Folded Reload
	cbz	w8, LBB0_67
; %bb.62:
	mov	x13, x21
	scvtf	d1, w21
	fdiv	d1, d9, d1
	b	LBB0_68
LBB0_63:
	cmp	w28, #1
	b.lt	LBB0_102
; %bb.64:
	mov	w8, #1
	str	w8, [x19]
	mov	x8, #4607182418800017408
	str	x8, [x19, #8]
	movi	d0, #0000000000000000
	ldr	w8, [sp, #56]                   ; 4-byte Folded Reload
	tbnz	w8, #0, LBB0_66
; %bb.65:
	ldr	x8, [x19, #56]
	ldr	s0, [x8]
	sshll.2d	v0, v0, #0
	scvtf	d0, d0
LBB0_66:
	str	d0, [x19, #16]
	str	xzr, [x19, #24]
	b	LBB0_102
LBB0_67:
	mov	x13, x21
	ldr	x8, [x19, #56]
	ldr	s1, [x8]
	sshll.2d	v1, v1, #0
	scvtf	d1, d1
LBB0_68:
	ldr	w21, [sp, #20]                  ; 4-byte Folded Reload
	ldr	w22, [sp, #52]                  ; 4-byte Folded Reload
	str	d1, [x19, #16]
	cmp	w23, #1
	b.lt	LBB0_78
; %bb.69:
	mov	x9, #0
	mov	w8, #0
	add	x11, x20, #4
	mov	w10, w23
LBB0_70:                                ; =>This Inner Loop Header: Depth=1
	ldr	w12, [x11]
	cmp	w12, #1
	b.eq	LBB0_73
; %bb.71:                               ;   in Loop: Header=BB0_70 Depth=1
	add	w8, w12, w8
	add	x9, x9, #1
	add	x11, x11, #8
	cmp	x10, x9
	b.ne	LBB0_70
; %bb.72:
	mov	x9, x10
LBB0_73:
	cbz	w9, LBB0_78
; %bb.74:
	ldr	w10, [sp, #60]                  ; 4-byte Folded Reload
	cmp	w23, w10
	b.ge	LBB0_79
; %bb.75:
	cbnz	w22, LBB0_79
; %bb.76:
	cmp	w9, w23
	b.ne	LBB0_79
; %bb.77:
	mov	w22, #0
	scvtf	d0, w23
	b	LBB0_83
LBB0_78:
	fmov	d1, #1.00000000
	fsub	d0, d1, d0
	fneg	d0, d0
	b	LBB0_83
LBB0_79:
	sub	w8, w13, w8
	add	w9, w8, w9
	fmov	d1, #1.00000000
	fsub	d0, d1, d0
	fmul	d0, d0, d8
	fcmp	d0, #0.0
	b.le	LBB0_81
; %bb.80:
	sub	w10, w27, w28
	scvtf	d2, w10
	scvtf	d1, w9
	scvtf	d3, w8
	fmul	d4, d2, d1
	fsub	d5, d2, d3
	fmul	d2, d2, d3
	fdiv	d2, d2, d0
	fadd	d2, d5, d2
	fdiv	d2, d4, d2
	b	LBB0_82
LBB0_81:
	scvtf	d1, w9
	movi	d2, #0000000000000000
LBB0_82:
	fcmp	d2, d1
	fcsel	d1, d1, d2, mi
	fcmp	d1, d0
	fcsel	d0, d0, d1, gt
	fmov	d1, #0.50000000
	fadd	d0, d0, d1
	bl	_floor
	scvtf	d0, w0
LBB0_83:
	mov	x8, #-7378697629483820647
	movk	x8, #39322
	movk	x8, #16313, lsl #48
	fmov	d1, x8
	fmul	d1, d8, d1
	fcmp	d0, d1
	b.le	LBB0_85
; %bb.84:
	fneg	d0, d0
	fdiv	d0, d0, d8
LBB0_85:
	str	d0, [x19, #24]
	ldr	w8, [sp, #60]                   ; 4-byte Folded Reload
	cmp	w23, w8
	b.ge	LBB0_88
; %bb.86:
	cbnz	w22, LBB0_88
; %bb.87:
	fcmp	d0, #0.0
	ccmp	w23, w21, #0, gt
	b.le	LBB0_98
LBB0_88:
	cmp	w21, w23
	csel	w22, w21, w23, lt
	cmp	w22, #1
	b.lt	LBB0_102
; %bb.89:
	lsl	w0, w22, #2
	bl	_palloc
	cmp	w22, #17
	b.lo	LBB0_92
; %bb.90:
	add	x8, x20, x22, lsl #3
	cmp	x0, x8
	b.hs	LBB0_93
; %bb.91:
	add	x8, x0, x22, lsl #2
	add	x9, x20, #4
	cmp	x9, x8
	b.hs	LBB0_93
LBB0_92:
	mov	x8, #0
	b	LBB0_95
LBB0_93:
	ands	x8, x22, #0xf
	mov	w9, #16
	csel	x8, x9, x8, eq
	sub	x8, x22, x8
	add	x11, x20, #68
	add	x9, x0, #32
	mov	x10, x8
LBB0_94:                                ; =>This Inner Loop Header: Depth=1
	sub	x12, x11, #64
	ld2.4s	{ v0, v1 }, [x12]
	sub	x12, x11, #32
	ld2.4s	{ v2, v3 }, [x12]
	add	x12, x11, #128
	ld2.4s	{ v4, v5 }, [x11], #32
	ld2.4s	{ v6, v7 }, [x11]
	stp	q0, q2, [x9, #-32]
	stp	q4, q6, [x9], #64
	mov	x11, x12
	subs	x10, x10, #16
	b.ne	LBB0_94
LBB0_95:
	add	x9, x20, x8, lsl #3
	add	x9, x9, #4
LBB0_96:                                ; =>This Inner Loop Header: Depth=1
	ldr	w10, [x9], #8
	str	w10, [x0, x8, lsl #2]
	add	x8, x8, #1
	cmp	x22, x8
	b.ne	LBB0_96
; %bb.97:
	ldr	d0, [x19, #24]
	ldr	d1, [x19, #8]
	mov	x1, x22
	mov	x2, x27
	fmov	d2, d8
	bl	_analyze_mcv_list
	mov	x23, x0
LBB0_98:
	cmp	w23, #1
	b.lt	LBB0_102
; %bb.99:
	ldr	w0, [x19, #104]
	bl	_MemoryContextSwitchTo
	mov	x22, x0
	lsl	w0, w23, #2
	bl	_palloc
	mov	x21, x0
	lsl	w0, w23, #3
	bl	_palloc
	mov	x24, x0
	mov	x25, #0
	add	x20, x20, #4
	mov	w26, w23
LBB0_100:                               ; =>This Inner Loop Header: Depth=1
	ldur	w0, [x20, #-4]
	ldr	x8, [x19, #56]
	ldr	w1, [x8, #4]
	ldr	s0, [x8]
	sshll.2d	v0, v0, #0
	scvtf	d0, d0
	bl	_datumCopy
	str	w0, [x21, x25, lsl #2]
	ldr	s0, [x20], #8
	sshll.2d	v0, v0, #0
	scvtf	d0, d0
	fdiv	d0, d0, d10
	str	d0, [x24, x25, lsl #3]
	add	x25, x25, #1
	cmp	x26, x25
	b.ne	LBB0_100
; %bb.101:
	mov	x0, x22
	bl	_MemoryContextSwitchTo
Lloh3:
	adrp	x8, _STATISTIC_KIND_MCV@GOTPAGE
Lloh4:
	ldr	x8, [x8, _STATISTIC_KIND_MCV@GOTPAGEOFF]
Lloh5:
	ldr	w8, [x8]
	ldr	x9, [x19, #96]
	str	w8, [x9]
	ldr	x8, [sp, #40]                   ; 8-byte Folded Reload
	ldr	w8, [x8]
	ldp	x10, x9, [x19, #80]
	str	w8, [x9]
	ldr	w8, [x19, #72]
	str	w8, [x10]
	ldr	x8, [x19, #32]
	str	x24, [x8]
	ldr	x8, [x19, #40]
	str	w23, [x8]
	ldr	x8, [x19, #64]
	str	x21, [x8]
	ldr	x8, [x19, #48]
	str	w23, [x8]
LBB0_102:
	ldp	x29, x30, [sp, #224]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #208]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #192]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #176]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #160]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #144]            ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #128]              ; 16-byte Folded Reload
	ldp	d11, d10, [sp, #112]            ; 16-byte Folded Reload
	add	sp, sp, #240
	ret
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.cfi_endproc
                                        ; -- End function
	.comm	_WIDTH_THRESHOLD,8,3            ; @WIDTH_THRESHOLD
	.comm	_STATISTIC_KIND_MCV,4,2         ; @STATISTIC_KIND_MCV
	.no_dead_strip	_compute_distinct_stats
.subsections_via_symbols
