	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	__bt_first                      ## -- Begin function _bt_first
	.p2align	4, 0x90
__bt_first:                             ## @_bt_first
	.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	$184, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%esi, -52(%rbp)                 ## 4-byte Spill
	movq	%rdi, %r15
	movq	%rsp, %r14
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movq	40(%rdi), %r12
	movslq	32(%rdi), %r13
	movq	_INDEX_MAX_KEYS@GOTPCREL(%rip), %rbx
	movl	(%rbx), %eax
	shlq	$3, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -120(%rbp)                ## 8-byte Spill
	movl	(%rbx), %eax
	shlq	$3, %rax
	leaq	(%rax,%rax,4), %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -136(%rbp)                ## 8-byte Spill
	subq	$32, %rsp
	movq	32(%r13), %rax
	movq	%rax, 16(%rsp)
	movups	16(%r13), %xmm0
	movups	%xmm0, (%rsp)
	callq	_BTScanPosIsValid
	addq	$32, %rsp
	xorl	%edi, %edi
	testl	%eax, %eax
	sete	%dil
	callq	_Assert
	movq	%r12, -152(%rbp)                ## 8-byte Spill
	movq	%r12, %rdi
	callq	_pgstat_count_index_scan
	movq	%r15, %rdi
	callq	__bt_preprocess_keys
	xorl	%ebx, %ebx
	cmpl	$0, 48(%r13)
	je	LBB0_78
## %bb.1:
	cmpq	$0, 24(%r15)
	je	LBB0_5
## %bb.2:
	leaq	-216(%rbp), %rsi
	movq	%r15, %rdi
	callq	__bt_parallel_seize
	testl	%eax, %eax
	je	LBB0_78
## %bb.3:
	movq	-216(%rbp), %rsi
	movq	_P_NONE@GOTPCREL(%rip), %rax
	cmpq	(%rax), %rsi
	je	LBB0_50
## %bb.4:
	movq	_InvalidBlockNumber@GOTPCREL(%rip), %rax
	cmpq	(%rax), %rsi
	jne	LBB0_32
LBB0_5:
	movl	(%r13), %eax
	testl	%eax, %eax
	movl	-52(%rbp), %r8d                 ## 4-byte Reload
	jle	LBB0_49
## %bb.6:
	movq	%r15, -128(%rbp)                ## 8-byte Spill
	movq	%r14, -88(%rbp)                 ## 8-byte Spill
	leaq	16(%r13), %rcx
	movq	%rcx, -104(%rbp)                ## 8-byte Spill
	movq	40(%r13), %rbx
	movl	$1, %r15d
	movl	$132, %ecx
	movq	%rcx, -112(%rbp)                ## 8-byte Spill
	xorl	%esi, %esi
	xorl	%edx, %edx
	xorl	%r12d, %r12d
	xorl	%edi, %edi
	movq	%r13, -80(%rbp)                 ## 8-byte Spill
	jmp	LBB0_9
	.p2align	4, 0x90
LBB0_7:                                 ##   in Loop: Header=BB0_9 Depth=1
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	movq	%r12, %rsi
	movq	%r14, %rdx
	movl	-52(%rbp), %r8d                 ## 4-byte Reload
	movq	%rax, %r12
	testq	%rax, %rax
	cmovneq	%rbx, %r12
	cmoveq	%rbx, %rdi
LBB0_8:                                 ##   in Loop: Header=BB0_9 Depth=1
	addq	$40, %rbx
	incl	%esi
	movl	(%r13), %eax
LBB0_9:                                 ## =>This Inner Loop Header: Depth=1
	cmpl	%eax, %esi
	jge	LBB0_11
## %bb.10:                              ##   in Loop: Header=BB0_9 Depth=1
	cmpl	%r15d, (%rbx)
	je	LBB0_24
LBB0_11:                                ##   in Loop: Header=BB0_9 Depth=1
	testq	%r12, %r12
	jne	LBB0_15
## %bb.12:                              ##   in Loop: Header=BB0_9 Depth=1
	testq	%rdi, %rdi
	je	LBB0_15
## %bb.13:                              ##   in Loop: Header=BB0_9 Depth=1
	movq	%rsi, -96(%rbp)                 ## 8-byte Spill
	movq	%rdx, %r14
	movq	_SK_BT_NULLS_FIRST@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%rdi, -72(%rbp)                 ## 8-byte Spill
	testl	%eax, 4(%rdi)
	je	LBB0_17
## %bb.14:                              ##   in Loop: Header=BB0_9 Depth=1
	movl	%r8d, %edi
	callq	_ScanDirectionIsForward
	testq	%rax, %rax
	jne	LBB0_18
	jmp	LBB0_33
	.p2align	4, 0x90
LBB0_15:                                ##   in Loop: Header=BB0_9 Depth=1
	testq	%r12, %r12
	je	LBB0_35
## %bb.16:                              ##   in Loop: Header=BB0_9 Depth=1
	movslq	%edx, %r13
	jmp	LBB0_19
LBB0_17:                                ##   in Loop: Header=BB0_9 Depth=1
	movl	%r8d, %edi
	callq	_ScanDirectionIsBackward
	testq	%rax, %rax
	je	LBB0_33
LBB0_18:                                ##   in Loop: Header=BB0_9 Depth=1
	movslq	%r14d, %r13
	leaq	(,%r13,4), %rax
	addq	%r13, %rax
	movq	_SK_ISNULL@GOTPCREL(%rip), %rcx
	movl	(%rcx), %ecx
	movq	_SK_SEARCHNOTNULL@GOTPCREL(%rip), %rdx
	orl	(%rdx), %ecx
	movq	-136(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rax,8), %r12
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movl	4(%rax), %eax
	movq	_SK_BT_NULLS_FIRST@GOTPCREL(%rip), %rdx
	movl	(%rdx), %edx
	movq	_SK_BT_DESC@GOTPCREL(%rip), %rsi
	movl	(%rsi), %esi
	orl	%edx, %esi
	andl	%eax, %esi
	orl	%ecx, %esi
	xorl	%ecx, %ecx
	testl	%eax, %edx
	setne	%cl
	leal	128(%rcx,%rcx), %ecx
	movq	_InvalidOid@GOTPCREL(%rip), %rax
	movq	(%rax), %r8
	movq	%r12, %rdi
	movl	%r15d, %edx
	movq	%r8, %r9
	pushq	$0
	pushq	%r8
	callq	_ScanKeyEntryInitialize
	movq	%r14, %rdx
	addq	$16, %rsp
	movl	-52(%rbp), %r8d                 ## 4-byte Reload
	movq	-96(%rbp), %rsi                 ## 8-byte Reload
LBB0_19:                                ##   in Loop: Header=BB0_9 Depth=1
	incl	%edx
	movq	-120(%rbp), %rax                ## 8-byte Reload
	movq	%r12, (%rax,%r13,8)
	movl	8(%r12), %eax
	cmpl	$132, %eax
	je	LBB0_21
## %bb.20:                              ##   in Loop: Header=BB0_9 Depth=1
	movl	%eax, %ecx
	andl	$-3, %ecx
	movl	%eax, %edi
	movq	%rdi, -112(%rbp)                ## 8-byte Spill
	cmpl	$128, %ecx
	je	LBB0_34
LBB0_21:                                ##   in Loop: Header=BB0_9 Depth=1
	movq	-80(%rbp), %r13                 ## 8-byte Reload
	cmpl	(%r13), %esi
	jge	LBB0_35
## %bb.22:                              ##   in Loop: Header=BB0_9 Depth=1
	movl	(%rbx), %eax
	incl	%r15d
	cmpl	%r15d, %eax
	jne	LBB0_35
## %bb.23:                              ##   in Loop: Header=BB0_9 Depth=1
	movl	%eax, %r15d
	xorl	%r12d, %r12d
	xorl	%edi, %edi
LBB0_24:                                ##   in Loop: Header=BB0_9 Depth=1
	movl	8(%rbx), %eax
	leal	-128(%rax), %ecx
	cmpl	$2, %ecx
	jb	LBB0_28
## %bb.25:                              ##   in Loop: Header=BB0_9 Depth=1
	leal	-130(%rax), %ecx
	cmpl	$2, %ecx
	jae	LBB0_30
## %bb.26:                              ##   in Loop: Header=BB0_9 Depth=1
	testq	%r12, %r12
	jne	LBB0_8
## %bb.27:                              ##   in Loop: Header=BB0_9 Depth=1
	movq	%rdi, -72(%rbp)                 ## 8-byte Spill
	movl	%r8d, %edi
	movq	%rdx, %r14
	movq	%rsi, %r12
	callq	_ScanDirectionIsForward
	jmp	LBB0_7
	.p2align	4, 0x90
LBB0_28:                                ##   in Loop: Header=BB0_9 Depth=1
	testq	%r12, %r12
	jne	LBB0_8
## %bb.29:                              ##   in Loop: Header=BB0_9 Depth=1
	movq	%rdi, -72(%rbp)                 ## 8-byte Spill
	movl	%r8d, %edi
	movq	%rdx, %r14
	movq	%rsi, %r12
	callq	_ScanDirectionIsBackward
	jmp	LBB0_7
	.p2align	4, 0x90
LBB0_30:                                ##   in Loop: Header=BB0_9 Depth=1
	cmpl	$132, %eax
	jne	LBB0_8
## %bb.31:                              ##   in Loop: Header=BB0_9 Depth=1
	movq	%rbx, %r12
	jmp	LBB0_8
LBB0_32:
	movq	%r15, %rdi
	movl	-52(%rbp), %edx                 ## 4-byte Reload
	callq	__bt_parallel_readpage
	movl	$0, %ebx
	testl	%eax, %eax
	jne	LBB0_76
	jmp	LBB0_78
LBB0_33:
	movq	-80(%rbp), %r13                 ## 8-byte Reload
	movl	-52(%rbp), %r8d                 ## 4-byte Reload
	movq	%r14, %rdx
	jmp	LBB0_35
LBB0_34:
                                        ## kill: def $eax killed $eax def $rax
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	movq	-80(%rbp), %r13                 ## 8-byte Reload
LBB0_35:
	testl	%edx, %edx
	movq	-88(%rbp), %r14                 ## 8-byte Reload
	movq	-128(%rbp), %r15                ## 8-byte Reload
	je	LBB0_49
## %bb.36:
	xorl	%edi, %edi
	movq	_INDEX_MAX_KEYS@GOTPCREL(%rip), %rax
	cmpl	(%rax), %edx
	setle	%dil
	movq	%rdx, -64(%rbp)                 ## 8-byte Spill
	callq	_Assert
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	testl	%eax, %eax
	jle	LBB0_59
## %bb.37:
	leal	-1(%rax), %ecx
	movl	%eax, %eax
	negq	%rcx
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	negq	%rax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	movl	$1, %r15d
	xorl	%r14d, %r14d
	jmp	LBB0_41
LBB0_38:                                ##   in Loop: Header=BB0_41 Depth=1
	movl	(%rbx), %esi
	movq	_BTORDER_PROC@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	%r12, %rdi
	callq	_index_getprocinfo
	movq	-160(%rbp), %rdi
	addq	%r14, %rdi
	movl	(%rbx), %edx
	movl	4(%rbx), %esi
	movq	_InvalidStrategy@GOTPCREL(%rip), %rcx
	movl	(%rcx), %ecx
	movq	16(%rbx), %r8
	movq	24(%rbx), %r9
	movl	32(%rbx), %ebx
	pushq	%rbx
	pushq	%rax
	callq	_ScanKeyEntryInitializeWithInfo
LBB0_39:                                ##   in Loop: Header=BB0_41 Depth=1
	addq	$16, %rsp
LBB0_40:                                ##   in Loop: Header=BB0_41 Depth=1
	addq	$40, %r14
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	addq	%r15, %rax
	incq	%rax
	incq	%r15
	cmpq	$1, %rax
	movq	-80(%rbp), %r13                 ## 8-byte Reload
	je	LBB0_59
LBB0_41:                                ## =>This Inner Loop Header: Depth=1
	movq	-120(%rbp), %rax                ## 8-byte Reload
	movq	-8(%rax,%r15,8), %rbx
	movl	(%rbx), %eax
	xorl	%edi, %edi
	cmpq	%rax, %r15
	sete	%dil
	callq	_Assert
	movq	_SK_ROW_HEADER@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, 4(%rbx)
	je	LBB0_44
## %bb.42:                              ##   in Loop: Header=BB0_41 Depth=1
	movl	32(%rbx), %edi
	callq	_DatumGetPointer
	movslq	%eax, %r12
	movq	_SK_ROW_MEMBER@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	andl	4(%r12), %edi
	callq	_Assert
	movq	_SK_ISNULL@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, 4(%r12)
	jne	LBB0_51
## %bb.43:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	%rbx, -96(%rbp)                 ## 8-byte Spill
	movq	-136(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%r15), %rbx
	movq	-160(%rbp), %r13
	leaq	(%r14,%r13), %rdi
	movq	%r12, %rsi
	movl	$40, %edx
	callq	_memcpy
	cmpq	$1, %rbx
	jne	LBB0_40
	jmp	LBB0_52
	.p2align	4, 0x90
LBB0_44:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	16(%rbx), %rdx
	movq	-152(%rbp), %r12                ## 8-byte Reload
	movq	(%r12), %rax
	movq	-8(%rax,%r15,8), %rsi
	cmpq	%rsi, %rdx
	je	LBB0_38
## %bb.45:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	_InvalidOid@GOTPCREL(%rip), %rax
	cmpq	(%rax), %rdx
	je	LBB0_38
## %bb.46:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	%r14, -96(%rbp)                 ## 8-byte Spill
	movq	8(%r12), %rax
	movl	-4(%rax,%r15,4), %edi
	movq	_BTORDER_PROC@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	callq	_get_opfamily_proc
	movq	%rax, %r13
	movq	%rax, %rdi
	callq	_RegProcedureIsValid
	testl	%eax, %eax
	jne	LBB0_48
## %bb.47:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movl	%eax, -144(%rbp)                ## 4-byte Spill
	movq	_BTORDER_PROC@GOTPCREL(%rip), %rax
	movl	(%rax), %r14d
	movq	(%r12), %rax
	movq	-8(%rax,%r15,8), %rax
	movq	%rax, -208(%rbp)                ## 8-byte Spill
	movq	16(%rbx), %rcx
	movq	%rcx, -200(%rbp)                ## 8-byte Spill
	movl	(%rbx), %eax
	movl	%eax, -140(%rbp)                ## 4-byte Spill
	movq	%r12, %rdi
	callq	_RelationGetRelationName
	movl	%eax, %r10d
	subq	$8, %rsp
	movl	-144(%rbp), %edi                ## 4-byte Reload
	leaq	L_.str(%rip), %rsi
	movl	%r14d, %edx
	movq	-208(%rbp), %rcx                ## 8-byte Reload
	movq	-200(%rbp), %r8                 ## 8-byte Reload
	movl	-140(%rbp), %r9d                ## 4-byte Reload
	xorl	%eax, %eax
	pushq	%r10
	callq	_elog
	addq	$16, %rsp
LBB0_48:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-160(%rbp), %rdi
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	addq	%r14, %rdi
	movl	(%rbx), %edx
	movl	4(%rbx), %esi
	movq	_InvalidStrategy@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	16(%rbx), %r8
	movq	24(%rbx), %r9
	movl	32(%rbx), %eax
	pushq	%rax
	pushq	%r13
	callq	_ScanKeyEntryInitialize
	jmp	LBB0_39
LBB0_49:
	movq	%r15, %rdi
	movl	%r8d, %esi
	callq	__bt_endpoint
	movl	%eax, %ebx
	testl	%eax, %eax
	jne	LBB0_78
LBB0_50:
	movq	%r15, %rdi
	callq	__bt_parallel_done
	xorl	%ebx, %ebx
	jmp	LBB0_78
LBB0_51:
	movq	-128(%rbp), %rdi                ## 8-byte Reload
	callq	__bt_parallel_done
	jmp	LBB0_74
LBB0_52:
	movq	_SK_ROW_END@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	xorl	%edi, %edi
	andl	4(%r12), %eax
	sete	%dil
	callq	_Assert
	movslq	-64(%rbp), %r15                 ## 4-byte Folded Reload
	leaq	(%r15,%r15,4), %rax
	leaq	(,%rax,8), %r14
	addq	%r13, %r14
	addq	$40, %r12
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	-80(%rbp), %r13                 ## 8-byte Reload
LBB0_53:                                ## =>This Inner Loop Header: Depth=1
	movq	_SK_ROW_MEMBER@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	andl	4(%r12), %edi
	callq	_Assert
	movl	(%r12), %ecx
	leal	1(%r15), %eax
	cmpl	%ecx, %eax
	jne	LBB0_57
## %bb.54:                              ##   in Loop: Header=BB0_53 Depth=1
	movl	8(%r12), %eax
	cmpl	8(%rbx), %eax
	jne	LBB0_57
## %bb.55:                              ##   in Loop: Header=BB0_53 Depth=1
	movq	_SK_ISNULL@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, 4(%r12)
	jne	LBB0_57
## %bb.56:                              ##   in Loop: Header=BB0_53 Depth=1
	movq	%rcx, -64(%rbp)                 ## 8-byte Spill
	movq	_INDEX_MAX_KEYS@GOTPCREL(%rip), %rax
	movslq	(%rax), %rax
	xorl	%edi, %edi
	cmpq	%rax, %r15
	setl	%dil
	callq	_Assert
	movq	%r14, %rdi
	movq	%r12, %rsi
	movl	$40, %edx
	callq	_memcpy
	movq	_SK_ROW_END@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	incq	%r15
	addq	$40, %r14
	leaq	40(%r12), %rcx
	testl	%eax, 4(%r12)
	movq	%rcx, %r12
	je	LBB0_53
	jmp	LBB0_59
LBB0_57:
	movq	-112(%rbp), %rcx                ## 8-byte Reload
	cmpl	$130, %ecx
	je	LBB0_65
## %bb.58:
	movl	%r15d, %eax
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	cmpl	$128, %ecx
	je	LBB0_61
LBB0_59:
	movq	-112(%rbp), %rdx                ## 8-byte Reload
	leal	-128(%rdx), %eax
	cmpl	$4, %eax
	ja	LBB0_62
## %bb.60:
	xorl	%edx, %edx
	leaq	LJTI0_0(%rip), %rcx
	movslq	(%rcx,%rax,4), %rax
	addq	%rcx, %rax
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movl	%r12d, %r15d
	xorl	%r14d, %r14d
	jmpq	*%rax
LBB0_61:
	movl	$1, %r14d
	xorl	%edx, %edx
	movl	%r15d, %r12d
	movq	%r12, -64(%rbp)                 ## 8-byte Spill
	jmp	LBB0_68
LBB0_62:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.1(%rip), %rsi
	xorl	%ebx, %ebx
                                        ## kill: def $edx killed $edx killed $rdx
	xorl	%eax, %eax
	callq	_elog
	movq	-88(%rbp), %r14                 ## 8-byte Reload
	jmp	LBB0_78
LBB0_63:
	movl	$1, %r14d
	jmp	LBB0_67
LBB0_64:
	movl	-52(%rbp), %edi                 ## 4-byte Reload
	callq	_ScanDirectionIsBackward
	xorl	%r14d, %r14d
	testq	%rax, %rax
	sete	%dl
	setne	%r14b
	jmp	LBB0_68
LBB0_65:
	movl	%r15d, %r12d
	movq	%r12, -64(%rbp)                 ## 8-byte Spill
LBB0_66:
	xorl	%r14d, %r14d
LBB0_67:
	movb	$1, %dl
LBB0_68:
	movl	%edx, -120(%rbp)                ## 4-byte Spill
	movq	-152(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %rdi
	callq	__bt_heapkeyspace
	movl	%eax, -168(%rbp)
	movl	$0, -192(%rbp)
	movl	%r14d, -188(%rbp)
	movl	$0, -184(%rbp)
	movq	$0, -176(%rbp)
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, -180(%rbp)
	movq	_BT_READ@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	-128(%rbp), %r15                ## 8-byte Reload
	movl	20(%r15), %r8d
	leaq	-192(%rbp), %rsi
	leaq	-56(%rbp), %rdx
	movq	%rbx, %rdi
	callq	__bt_search
	movl	%eax, %edi
	callq	__bt_freestack
	movl	-56(%rbp), %edi
	callq	_BufferIsValid
	testl	%eax, %eax
	je	LBB0_73
## %bb.69:
	movl	-56(%rbp), %edi
	callq	_BufferGetBlockNumber
	movl	20(%r15), %edx
	movq	%rbx, %rdi
	movl	%eax, %esi
	callq	_PredicateLockPage
	movq	%r13, %rdi
	movl	-52(%rbp), %esi                 ## 4-byte Reload
	callq	__bt_initialize_more_data
	movl	-56(%rbp), %edx
	leaq	-192(%rbp), %rsi
	movq	%rbx, %rdi
	callq	__bt_binsrch
	movl	%eax, %r12d
	cmpb	$0, -120(%rbp)                  ## 1-byte Folded Reload
	movq	-88(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_71
## %bb.70:
	movl	%r12d, %edi
	callq	_OffsetNumberPrev
	movl	%eax, %r12d
LBB0_71:
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	subq	$32, %rsp
	movq	16(%rcx), %rax
	movq	%rax, 16(%rsp)
	movups	(%rcx), %xmm0
	movups	%xmm0, (%rsp)
	callq	_BTScanPosIsValid
	addq	$32, %rsp
	xorl	%edi, %edi
	testl	%eax, %eax
	sete	%dil
	callq	_Assert
	movl	-56(%rbp), %eax
	movl	%eax, 32(%r13)
	movq	%r15, %rdi
	movl	-52(%rbp), %ebx                 ## 4-byte Reload
	movl	%ebx, %esi
	movl	%r12d, %edx
	callq	__bt_readpage
	testl	%eax, %eax
	je	LBB0_75
## %bb.72:
	movq	%r15, %rdi
	movq	-104(%rbp), %rsi                ## 8-byte Reload
	callq	__bt_drop_lock_and_maybe_pin
	jmp	LBB0_76
LBB0_73:
	movl	20(%r15), %esi
	movq	%rbx, %rdi
	callq	_PredicateLockRelation
	movq	%r15, %rdi
	callq	__bt_parallel_done
	subq	$32, %rsp
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	movq	16(%rcx), %rax
	movq	%rax, 16(%rsp)
	movups	(%rcx), %xmm0
	movups	%xmm0, (%rsp)
	callq	_BTScanPosInvalidate
	addq	$32, %rsp
LBB0_74:
	xorl	%ebx, %ebx
	movq	-88(%rbp), %r14                 ## 8-byte Reload
	jmp	LBB0_78
LBB0_75:
	movl	32(%r13), %edi
	movq	_BUFFER_LOCK_UNLOCK@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	callq	_LockBuffer
	movq	%r15, %rdi
	movl	%ebx, %esi
	callq	__bt_steppage
	testl	%eax, %eax
	je	LBB0_80
LBB0_76:
	movq	16(%r13), %rax
	movq	24(%r13), %rcx
	shlq	$4, %rax
	movl	8(%rcx,%rax), %edx
	movl	%edx, 16(%r15)
	movl	$1, %ebx
	cmpq	$0, 8(%r15)
	je	LBB0_78
## %bb.77:
	movq	(%rcx,%rax), %rax
	addq	8(%r13), %rax
	movq	%rax, (%r15)
LBB0_78:
	movq	%r14, %rsp
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_81
## %bb.79:
	movl	%ebx, %eax
	leaq	-40(%rbp), %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_80:
	xorl	%ebx, %ebx
	jmp	LBB0_78
LBB0_81:
	callq	___stack_chk_fail
	.cfi_endproc
	.p2align	2, 0x90
	.data_region jt32
.set L0_0_set_68, LBB0_68-LJTI0_0
.set L0_0_set_61, LBB0_61-LJTI0_0
.set L0_0_set_63, LBB0_63-LJTI0_0
.set L0_0_set_66, LBB0_66-LJTI0_0
.set L0_0_set_64, LBB0_64-LJTI0_0
LJTI0_0:
	.long	L0_0_set_68
	.long	L0_0_set_61
	.long	L0_0_set_63
	.long	L0_0_set_66
	.long	L0_0_set_64
	.end_data_region
                                        ## -- End function
	.comm	_INDEX_MAX_KEYS,4,2             ## @INDEX_MAX_KEYS
	.comm	_P_NONE,8,3                     ## @P_NONE
	.comm	_InvalidBlockNumber,8,3         ## @InvalidBlockNumber
	.comm	_SK_BT_NULLS_FIRST,4,2          ## @SK_BT_NULLS_FIRST
	.comm	_SK_SEARCHNOTNULL,4,2           ## @SK_SEARCHNOTNULL
	.comm	_SK_ISNULL,4,2                  ## @SK_ISNULL
	.comm	_SK_BT_DESC,4,2                 ## @SK_BT_DESC
	.comm	_InvalidOid,8,3                 ## @InvalidOid
	.comm	_SK_ROW_HEADER,4,2              ## @SK_ROW_HEADER
	.comm	_SK_ROW_MEMBER,4,2              ## @SK_ROW_MEMBER
	.comm	_SK_ROW_END,4,2                 ## @SK_ROW_END
	.comm	_BTORDER_PROC,4,2               ## @BTORDER_PROC
	.comm	_InvalidStrategy,4,2            ## @InvalidStrategy
	.comm	_ERROR,4,2                      ## @ERROR
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"missing support function %d(%u,%u) for attribute %d of index \"%s\""

L_.str.1:                               ## @.str.1
	.asciz	"unrecognized strat_total: %d"

	.comm	_BT_READ,4,2                    ## @BT_READ
	.comm	_BUFFER_LOCK_UNLOCK,4,2         ## @BUFFER_LOCK_UNLOCK
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	__bt_first                      ; -- Begin function _bt_first
	.p2align	2
__bt_first:                             ; @_bt_first
	.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, #160
	mov	x21, x1
	mov	x25, x0
	mov	x19, sp
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	stur	x8, [x29, #-96]
	ldr	x22, [x0, #40]
	ldrsw	x20, [x0, #32]
Lloh3:
	adrp	x12, _INDEX_MAX_KEYS@GOTPAGE
Lloh4:
	ldr	x12, [x12, _INDEX_MAX_KEYS@GOTPAGEOFF]
	ldr	w8, [x12]
	lsl	x8, x8, #3
	mov	x9, x8
Lloh5:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh6:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x23, x9, x8
	mov	sp, x23
	ldr	w8, [x12]
	add	x8, x8, x8, lsl #2
	lsl	x8, x8, #3
	mov	x9, x8
Lloh7:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh8:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0x7ffffffff0
	sub	x27, x9, x8
	mov	sp, x27
	ldr	q0, [x20, #16]
	stur	q0, [x29, #-144]
	ldr	x8, [x20, #32]
	stur	x8, [x29, #-128]
	sub	x0, x29, #144
	bl	_BTScanPosIsValid
	cmp	w0, #0
	cset	w0, eq
	bl	_Assert
	stur	x22, [x29, #-192]               ; 8-byte Folded Spill
	mov	x0, x22
	bl	_pgstat_count_index_scan
	mov	x0, x25
	bl	__bt_preprocess_keys
	ldr	w8, [x20, #48]
	cbz	w8, LBB0_31
; %bb.1:
	ldr	x8, [x25, #24]
	cbz	x8, LBB0_5
; %bb.2:
	sub	x1, x29, #152
	mov	x0, x25
	bl	__bt_parallel_seize
	cbz	w0, LBB0_78
; %bb.3:
	ldur	x1, [x29, #-152]
Lloh9:
	adrp	x8, _P_NONE@GOTPAGE
Lloh10:
	ldr	x8, [x8, _P_NONE@GOTPAGEOFF]
Lloh11:
	ldr	x8, [x8]
	cmp	x1, x8
	b.eq	LBB0_47
; %bb.4:
Lloh12:
	adrp	x8, _InvalidBlockNumber@GOTPAGE
Lloh13:
	ldr	x8, [x8, _InvalidBlockNumber@GOTPAGEOFF]
Lloh14:
	ldr	x8, [x8]
	cmp	x1, x8
	b.ne	LBB0_32
LBB0_5:
	stur	w21, [x29, #-180]               ; 4-byte Folded Spill
	ldr	w8, [x20]
	cmp	w8, #1
	b.lt	LBB0_46
; %bb.6:
	stp	x25, x19, [x29, #-216]          ; 16-byte Folded Spill
	mov	w21, #0
	mov	w28, #0
	mov	x26, #0
	mov	x24, #0
	ldr	x22, [x20, #40]
	add	x9, x20, #16
	stur	x9, [x29, #-224]                ; 8-byte Folded Spill
	mov	w25, #1
	mov	w9, #132
	stur	w9, [x29, #-196]                ; 4-byte Folded Spill
	b	LBB0_9
LBB0_7:                                 ;   in Loop: Header=BB0_9 Depth=1
	cmp	w8, #132
	csel	x26, x22, x26, eq
LBB0_8:                                 ;   in Loop: Header=BB0_9 Depth=1
	add	x22, x22, #40
	add	w21, w21, #1
	ldr	w8, [x20]
LBB0_9:                                 ; =>This Inner Loop Header: Depth=1
	cmp	w21, w8
	b.ge	LBB0_11
; %bb.10:                               ;   in Loop: Header=BB0_9 Depth=1
	ldr	w8, [x22]
	cmp	w8, w25
	b.eq	LBB0_24
LBB0_11:                                ;   in Loop: Header=BB0_9 Depth=1
	cbnz	x26, LBB0_15
; %bb.12:                               ;   in Loop: Header=BB0_9 Depth=1
	cbz	x24, LBB0_15
; %bb.13:                               ;   in Loop: Header=BB0_9 Depth=1
	ldr	w8, [x24, #4]
Lloh15:
	adrp	x9, _SK_BT_NULLS_FIRST@GOTPAGE
Lloh16:
	ldr	x9, [x9, _SK_BT_NULLS_FIRST@GOTPAGEOFF]
Lloh17:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_17
; %bb.14:                               ;   in Loop: Header=BB0_9 Depth=1
	ldur	w0, [x29, #-180]                ; 4-byte Folded Reload
	bl	_ScanDirectionIsForward
	cbnz	x0, LBB0_18
	b	LBB0_34
LBB0_15:                                ;   in Loop: Header=BB0_9 Depth=1
	cbz	x26, LBB0_34
; %bb.16:                               ;   in Loop: Header=BB0_9 Depth=1
	mov	x8, x28
	sxtw	x19, w8
	b	LBB0_19
LBB0_17:                                ;   in Loop: Header=BB0_9 Depth=1
	ldur	w0, [x29, #-180]                ; 4-byte Folded Reload
	bl	_ScanDirectionIsBackward
	cbz	x0, LBB0_34
LBB0_18:                                ;   in Loop: Header=BB0_9 Depth=1
	sxtw	x19, w28
	mov	w8, #40
	smaddl	x26, w28, w8, x27
Lloh18:
	adrp	x8, _SK_SEARCHNOTNULL@GOTPAGE
Lloh19:
	ldr	x8, [x8, _SK_SEARCHNOTNULL@GOTPAGEOFF]
Lloh20:
	ldr	w8, [x8]
Lloh21:
	adrp	x9, _SK_ISNULL@GOTPAGE
Lloh22:
	ldr	x9, [x9, _SK_ISNULL@GOTPAGEOFF]
Lloh23:
	ldr	w9, [x9]
	orr	w8, w9, w8
	ldr	w9, [x24, #4]
Lloh24:
	adrp	x10, _SK_BT_DESC@GOTPAGE
Lloh25:
	ldr	x10, [x10, _SK_BT_DESC@GOTPAGEOFF]
Lloh26:
	ldr	w10, [x10]
Lloh27:
	adrp	x11, _SK_BT_NULLS_FIRST@GOTPAGE
Lloh28:
	ldr	x11, [x11, _SK_BT_NULLS_FIRST@GOTPAGEOFF]
Lloh29:
	ldr	w11, [x11]
	orr	w10, w11, w10
	and	w10, w10, w9
	orr	w1, w8, w10
	tst	w11, w9
	mov	w8, #130
	mov	w9, #128
	csel	w3, w9, w8, eq
Lloh30:
	adrp	x8, _InvalidOid@GOTPAGE
Lloh31:
	ldr	x8, [x8, _InvalidOid@GOTPAGEOFF]
Lloh32:
	ldr	x4, [x8]
	mov	x0, x26
	mov	x2, x25
	mov	x5, x4
	mov	x6, x4
	mov	w7, #0
	bl	_ScanKeyEntryInitialize
LBB0_19:                                ;   in Loop: Header=BB0_9 Depth=1
	add	w28, w28, #1
	str	x26, [x23, x19, lsl #3]
	ldr	w8, [x26, #8]
	cmp	w8, #132
	b.eq	LBB0_21
; %bb.20:                               ;   in Loop: Header=BB0_9 Depth=1
	and	w9, w8, #0xfffffffd
	stur	w8, [x29, #-196]                ; 4-byte Folded Spill
	cmp	w9, #128
	b.eq	LBB0_33
LBB0_21:                                ;   in Loop: Header=BB0_9 Depth=1
	ldr	w8, [x20]
	cmp	w21, w8
	b.ge	LBB0_34
; %bb.22:                               ;   in Loop: Header=BB0_9 Depth=1
	ldr	w8, [x22]
	add	w9, w25, #1
	cmp	w8, w9
	b.ne	LBB0_34
; %bb.23:                               ;   in Loop: Header=BB0_9 Depth=1
	mov	x26, #0
	mov	x24, #0
	mov	x25, x8
LBB0_24:                                ;   in Loop: Header=BB0_9 Depth=1
	ldr	w8, [x22, #8]
	sub	w9, w8, #128
	cmp	w9, #2
	b.lo	LBB0_28
; %bb.25:                               ;   in Loop: Header=BB0_9 Depth=1
	sub	w9, w8, #130
	cmp	w9, #2
	b.hs	LBB0_7
; %bb.26:                               ;   in Loop: Header=BB0_9 Depth=1
	cbnz	x26, LBB0_8
; %bb.27:                               ;   in Loop: Header=BB0_9 Depth=1
	ldur	w0, [x29, #-180]                ; 4-byte Folded Reload
	bl	_ScanDirectionIsForward
	b	LBB0_30
LBB0_28:                                ;   in Loop: Header=BB0_9 Depth=1
	cbnz	x26, LBB0_8
; %bb.29:                               ;   in Loop: Header=BB0_9 Depth=1
	ldur	w0, [x29, #-180]                ; 4-byte Folded Reload
	bl	_ScanDirectionIsBackward
LBB0_30:                                ;   in Loop: Header=BB0_9 Depth=1
	cmp	x0, #0
	csel	x26, xzr, x22, eq
	csel	x24, x22, x24, eq
	b	LBB0_8
LBB0_31:
	mov	w0, #0
	b	LBB0_78
LBB0_32:
	mov	x0, x25
	mov	x2, x21
	bl	__bt_parallel_readpage
	cbnz	w0, LBB0_75
	b	LBB0_78
LBB0_33:
	stur	w8, [x29, #-196]                ; 4-byte Folded Spill
LBB0_34:
	ldp	x25, x19, [x29, #-216]          ; 16-byte Folded Reload
	cbz	w28, LBB0_46
; %bb.35:
Lloh33:
	adrp	x8, _INDEX_MAX_KEYS@GOTPAGE
Lloh34:
	ldr	x8, [x8, _INDEX_MAX_KEYS@GOTPAGEOFF]
Lloh35:
	ldr	w8, [x8]
	cmp	w28, w8
	cset	w0, le
	bl	_Assert
	subs	w24, w28, #1
	b.lt	LBB0_48
; %bb.36:
	mov	x25, #0
	mov	w21, w28
	ldur	x19, [x29, #-192]               ; 8-byte Folded Reload
	b	LBB0_39
LBB0_37:                                ;   in Loop: Header=BB0_39 Depth=1
	ldr	w1, [x22]
Lloh36:
	adrp	x8, _BTORDER_PROC@GOTPAGE
Lloh37:
	ldr	x8, [x8, _BTORDER_PROC@GOTPAGEOFF]
Lloh38:
	ldr	w2, [x8]
	mov	x0, x19
	bl	_index_getprocinfo
	ldp	w2, w1, [x22]
Lloh39:
	adrp	x8, _InvalidStrategy@GOTPAGE
Lloh40:
	ldr	x8, [x8, _InvalidStrategy@GOTPAGEOFF]
Lloh41:
	ldr	w3, [x8]
	ldp	x4, x5, [x22, #16]
	ldr	w7, [x22, #32]
	mov	x6, x0
	bl	_ScanKeyEntryInitializeWithInfo
LBB0_38:                                ;   in Loop: Header=BB0_39 Depth=1
	mov	x25, x27
	cmp	x21, x27
	b.eq	LBB0_49
LBB0_39:                                ; =>This Inner Loop Header: Depth=1
	ldr	x22, [x23, x25, lsl #3]
	ldr	w8, [x22]
	add	x27, x25, #1
	cmp	x27, x8
	cset	w0, eq
	bl	_Assert
	ldr	w8, [x22, #4]
Lloh42:
	adrp	x9, _SK_ROW_HEADER@GOTPAGE
Lloh43:
	ldr	x9, [x9, _SK_ROW_HEADER@GOTPAGEOFF]
Lloh44:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_42
; %bb.40:                               ;   in Loop: Header=BB0_39 Depth=1
	ldr	w0, [x22, #32]
	bl	_DatumGetPointer
                                        ; kill: def $w0 killed $w0 def $x0
	sxtw	x26, w0
	ldr	w8, [x26, #4]
Lloh45:
	adrp	x9, _SK_ROW_MEMBER@GOTPAGE
Lloh46:
	ldr	x9, [x9, _SK_ROW_MEMBER@GOTPAGEOFF]
Lloh47:
	ldr	w9, [x9]
	and	w0, w9, w8
	bl	_Assert
	ldr	w8, [x26, #4]
Lloh48:
	adrp	x9, _SK_ISNULL@GOTPAGE
Lloh49:
	ldr	x9, [x9, _SK_ISNULL@GOTPAGEOFF]
Lloh50:
	ldr	w9, [x9]
	tst	w9, w8
	b.ne	LBB0_55
; %bb.41:                               ;   in Loop: Header=BB0_39 Depth=1
	mov	x1, x26
	mov	w2, #40
	bl	_memcpy
	cmp	x24, x25
	b.ne	LBB0_38
	b	LBB0_56
LBB0_42:                                ;   in Loop: Header=BB0_39 Depth=1
	ldr	x2, [x22, #16]
	ldr	x8, [x19]
	ldr	x1, [x8, x25, lsl #3]
Lloh51:
	adrp	x8, _InvalidOid@GOTPAGE
Lloh52:
	ldr	x8, [x8, _InvalidOid@GOTPAGEOFF]
Lloh53:
	ldr	x8, [x8]
	cmp	x2, x1
	ccmp	x2, x8, #4, ne
	b.eq	LBB0_37
; %bb.43:                               ;   in Loop: Header=BB0_39 Depth=1
	ldr	x8, [x19, #8]
	ldr	w0, [x8, x25, lsl #2]
Lloh54:
	adrp	x8, _BTORDER_PROC@GOTPAGE
Lloh55:
	ldr	x8, [x8, _BTORDER_PROC@GOTPAGEOFF]
Lloh56:
	ldr	w3, [x8]
	bl	_get_opfamily_proc
	mov	x26, x0
	bl	_RegProcedureIsValid
	cbnz	w0, LBB0_45
; %bb.44:                               ;   in Loop: Header=BB0_39 Depth=1
Lloh57:
	adrp	x8, _ERROR@GOTPAGE
Lloh58:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh59:
	ldr	w8, [x8]
	stur	w8, [x29, #-232]                ; 4-byte Folded Spill
Lloh60:
	adrp	x8, _BTORDER_PROC@GOTPAGE
Lloh61:
	ldr	x8, [x8, _BTORDER_PROC@GOTPAGEOFF]
Lloh62:
	ldr	w8, [x8]
	stur	w8, [x29, #-228]                ; 4-byte Folded Spill
	ldr	x8, [x19]
	ldr	x8, [x8, x25, lsl #3]
	stur	x8, [x29, #-240]                ; 8-byte Folded Spill
	ldr	x25, [x22, #16]
	ldr	w19, [x22]
	ldur	x0, [x29, #-192]                ; 8-byte Folded Reload
	bl	_RelationGetRelationName
                                        ; kill: def $w0 killed $w0 def $x0
	sub	sp, sp, #32
	stp	x19, x0, [sp, #16]
	ldur	x19, [x29, #-192]               ; 8-byte Folded Reload
	str	x25, [sp, #8]
	ldur	x8, [x29, #-240]                ; 8-byte Folded Reload
	str	x8, [sp]
	ldp	w0, w2, [x29, #-232]            ; 8-byte Folded Reload
Lloh63:
	adrp	x1, l_.str@PAGE
Lloh64:
	add	x1, x1, l_.str@PAGEOFF
	bl	_elog
	add	sp, sp, #32
LBB0_45:                                ;   in Loop: Header=BB0_39 Depth=1
	ldp	w2, w1, [x22]
Lloh65:
	adrp	x8, _InvalidStrategy@GOTPAGE
Lloh66:
	ldr	x8, [x8, _InvalidStrategy@GOTPAGEOFF]
Lloh67:
	ldr	w3, [x8]
	ldp	x4, x5, [x22, #16]
	ldr	w7, [x22, #32]
	mov	x6, x26
	bl	_ScanKeyEntryInitialize
	b	LBB0_38
LBB0_46:
	mov	x0, x25
	ldur	w1, [x29, #-180]                ; 4-byte Folded Reload
	bl	__bt_endpoint
	cbnz	w0, LBB0_78
LBB0_47:
	mov	x0, x25
	bl	__bt_parallel_done
	mov	w0, #0
	b	LBB0_78
LBB0_48:
                                        ; kill: def $w28 killed $w28 killed $x28 def $x28
	b	LBB0_51
LBB0_49:
                                        ; kill: def $w28 killed $w28 killed $x28 def $x28
LBB0_50:
	ldp	x25, x19, [x29, #-216]          ; 16-byte Folded Reload
LBB0_51:
	ldur	w2, [x29, #-196]                ; 4-byte Folded Reload
LBB0_52:
	sub	w8, w2, #128
	cmp	w8, #4
	b.hi	LBB0_66
; %bb.53:
	mov	w21, #0
	mov	w22, #0
Lloh68:
	adrp	x9, lJTI0_0@PAGE
Lloh69:
	add	x9, x9, lJTI0_0@PAGEOFF
	adr	x10, LBB0_54
	ldrb	w11, [x9, x8]
	add	x10, x10, x11, lsl #2
	br	x10
LBB0_54:
	mov	w21, #1
	mov	w22, #1
	b	LBB0_68
LBB0_55:
	ldur	x0, [x29, #-216]                ; 8-byte Folded Reload
	bl	__bt_parallel_done
	mov	w0, #0
	ldur	x19, [x29, #-208]               ; 8-byte Folded Reload
	b	LBB0_78
LBB0_56:
	ldr	w8, [x26, #4]
Lloh70:
	adrp	x21, _SK_ROW_END@GOTPAGE
Lloh71:
	ldr	x21, [x21, _SK_ROW_END@GOTPAGEOFF]
	ldr	w9, [x21]
	tst	w9, w8
	cset	w0, eq
	bl	_Assert
                                        ; kill: def $w28 killed $w28 killed $x28 def $x28
	sxtw	x28, w28
	add	x25, x26, #40
LBB0_57:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [x25, #4]
Lloh72:
	adrp	x9, _SK_ROW_MEMBER@GOTPAGE
Lloh73:
	ldr	x9, [x9, _SK_ROW_MEMBER@GOTPAGEOFF]
Lloh74:
	ldr	w9, [x9]
	and	w0, w9, w8
	bl	_Assert
	ldr	w23, [x25]
	add	w8, w28, #1
	cmp	w8, w23
	b.ne	LBB0_62
; %bb.58:                               ;   in Loop: Header=BB0_57 Depth=1
	ldr	w8, [x25, #8]
	ldr	w9, [x22, #8]
	cmp	w8, w9
	b.ne	LBB0_62
; %bb.59:                               ;   in Loop: Header=BB0_57 Depth=1
	ldr	w8, [x25, #4]
Lloh75:
	adrp	x9, _SK_ISNULL@GOTPAGE
Lloh76:
	ldr	x9, [x9, _SK_ISNULL@GOTPAGEOFF]
Lloh77:
	ldr	w9, [x9]
	tst	w9, w8
	b.ne	LBB0_62
; %bb.60:                               ;   in Loop: Header=BB0_57 Depth=1
Lloh78:
	adrp	x8, _INDEX_MAX_KEYS@GOTPAGE
Lloh79:
	ldr	x8, [x8, _INDEX_MAX_KEYS@GOTPAGEOFF]
Lloh80:
	ldrsw	x8, [x8]
	cmp	x28, x8
	cset	w0, lt
	bl	_Assert
	mov	x1, x25
	mov	w2, #40
	bl	_memcpy
	ldr	w8, [x25, #4]
	ldr	w9, [x21]
	add	x28, x28, #1
	add	x25, x25, #40
	tst	w9, w8
	b.eq	LBB0_57
; %bb.61:
	mov	x28, x23
	b	LBB0_50
LBB0_62:
	ldur	w2, [x29, #-196]                ; 4-byte Folded Reload
	cmp	w2, #130
	ldp	x25, x19, [x29, #-216]          ; 16-byte Folded Reload
	b.eq	LBB0_65
; %bb.63:
	cmp	w2, #128
	b.ne	LBB0_52
LBB0_64:
	mov	w21, #0
	mov	w22, #1
	b	LBB0_68
LBB0_65:
	mov	w22, #0
	mov	w21, #1
	b	LBB0_68
LBB0_66:
Lloh81:
	adrp	x8, _ERROR@GOTPAGE
Lloh82:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh83:
	ldr	w0, [x8]
Lloh84:
	adrp	x1, l_.str.1@PAGE
Lloh85:
	add	x1, x1, l_.str.1@PAGEOFF
	bl	_elog
	mov	w0, #0
	b	LBB0_78
LBB0_67:
	ldur	w0, [x29, #-180]                ; 4-byte Folded Reload
	bl	_ScanDirectionIsBackward
	cmp	x0, #0
	cset	w21, eq
	cset	w22, ne
LBB0_68:
	ldur	x24, [x29, #-192]               ; 8-byte Folded Reload
	mov	x0, x24
	bl	__bt_heapkeyspace
	stur	w0, [x29, #-120]
	stp	wzr, w22, [x29, #-144]
	stur	xzr, [x29, #-128]
	stp	wzr, w28, [x29, #-136]
Lloh86:
	adrp	x8, _BT_READ@GOTPAGE
Lloh87:
	ldr	x8, [x8, _BT_READ@GOTPAGEOFF]
Lloh88:
	ldr	w3, [x8]
	ldr	w4, [x25, #20]
	sub	x1, x29, #144
	sub	x2, x29, #100
	mov	x0, x24
	bl	__bt_search
	bl	__bt_freestack
	ldur	w0, [x29, #-100]
	bl	_BufferIsValid
	cbz	w0, LBB0_73
; %bb.69:
	ldur	w0, [x29, #-100]
	bl	_BufferGetBlockNumber
	mov	x1, x0
	ldr	w2, [x25, #20]
	mov	x0, x24
	bl	_PredicateLockPage
	mov	x0, x20
	ldur	w23, [x29, #-180]               ; 4-byte Folded Reload
	mov	x1, x23
	bl	__bt_initialize_more_data
	ldur	w2, [x29, #-100]
	sub	x1, x29, #144
	mov	x0, x24
	bl	__bt_binsrch
	mov	x22, x0
	tbnz	w21, #0, LBB0_71
; %bb.70:
	mov	x0, x22
	bl	_OffsetNumberPrev
	mov	x22, x0
LBB0_71:
	ldur	x21, [x29, #-224]               ; 8-byte Folded Reload
	ldr	q0, [x21]
	stur	q0, [x29, #-176]
	ldr	x8, [x21, #16]
	stur	x8, [x29, #-160]
	sub	x0, x29, #176
	bl	_BTScanPosIsValid
	cmp	w0, #0
	cset	w0, eq
	bl	_Assert
	ldur	w8, [x29, #-100]
	str	w8, [x20, #32]
	mov	x0, x25
	mov	x1, x23
	mov	x2, x22
	bl	__bt_readpage
	cbz	w0, LBB0_74
; %bb.72:
	mov	x0, x25
	mov	x1, x21
	bl	__bt_drop_lock_and_maybe_pin
	b	LBB0_75
LBB0_73:
	ldr	w1, [x25, #20]
	mov	x0, x24
	bl	_PredicateLockRelation
	mov	x0, x25
	bl	__bt_parallel_done
	ldur	x8, [x29, #-224]                ; 8-byte Folded Reload
	ldr	q0, [x8]
	stur	q0, [x29, #-176]
	ldr	x8, [x8, #16]
	stur	x8, [x29, #-160]
	sub	x0, x29, #176
	bl	_BTScanPosInvalidate
	mov	w0, #0
	b	LBB0_78
LBB0_74:
	ldr	w0, [x20, #32]
Lloh89:
	adrp	x8, _BUFFER_LOCK_UNLOCK@GOTPAGE
Lloh90:
	ldr	x8, [x8, _BUFFER_LOCK_UNLOCK@GOTPAGEOFF]
Lloh91:
	ldr	w1, [x8]
	bl	_LockBuffer
	mov	x0, x25
	mov	x1, x23
	bl	__bt_steppage
	cbz	w0, LBB0_78
LBB0_75:
	ldp	x9, x8, [x20, #16]
	add	x10, x8, x9, lsl #4
	ldr	w10, [x10, #8]
	str	w10, [x25, #16]
	ldr	x10, [x25, #8]
	cbz	x10, LBB0_77
; %bb.76:
	ldr	x10, [x20, #8]
	lsl	x9, x9, #4
	ldr	x8, [x8, x9]
	add	x8, x8, x10
	str	x8, [x25]
LBB0_77:
	mov	w0, #1
LBB0_78:
	mov	sp, x19
	ldur	x8, [x29, #-96]
Lloh92:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh93:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh94:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_80
; %bb.79:
	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_80:
	bl	___stack_chk_fail
	.loh AdrpLdrGot	Lloh7, Lloh8
	.loh AdrpLdrGot	Lloh5, Lloh6
	.loh AdrpLdrGot	Lloh3, Lloh4
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh9, Lloh10, Lloh11
	.loh AdrpLdrGotLdr	Lloh12, Lloh13, Lloh14
	.loh AdrpLdrGotLdr	Lloh15, Lloh16, Lloh17
	.loh AdrpLdrGotLdr	Lloh30, Lloh31, Lloh32
	.loh AdrpLdrGotLdr	Lloh27, Lloh28, Lloh29
	.loh AdrpLdrGotLdr	Lloh24, Lloh25, Lloh26
	.loh AdrpLdrGotLdr	Lloh21, Lloh22, Lloh23
	.loh AdrpLdrGotLdr	Lloh18, Lloh19, Lloh20
	.loh AdrpLdrGotLdr	Lloh33, Lloh34, Lloh35
	.loh AdrpLdrGotLdr	Lloh39, Lloh40, Lloh41
	.loh AdrpLdrGotLdr	Lloh36, Lloh37, Lloh38
	.loh AdrpLdrGotLdr	Lloh42, Lloh43, Lloh44
	.loh AdrpLdrGotLdr	Lloh48, Lloh49, Lloh50
	.loh AdrpLdrGotLdr	Lloh45, Lloh46, Lloh47
	.loh AdrpLdrGotLdr	Lloh51, Lloh52, Lloh53
	.loh AdrpLdrGotLdr	Lloh54, Lloh55, Lloh56
	.loh AdrpAdd	Lloh63, Lloh64
	.loh AdrpLdrGotLdr	Lloh60, Lloh61, Lloh62
	.loh AdrpLdrGotLdr	Lloh57, Lloh58, Lloh59
	.loh AdrpLdrGotLdr	Lloh65, Lloh66, Lloh67
	.loh AdrpAdd	Lloh68, Lloh69
	.loh AdrpLdrGot	Lloh70, Lloh71
	.loh AdrpLdrGotLdr	Lloh72, Lloh73, Lloh74
	.loh AdrpLdrGotLdr	Lloh75, Lloh76, Lloh77
	.loh AdrpLdrGotLdr	Lloh78, Lloh79, Lloh80
	.loh AdrpAdd	Lloh84, Lloh85
	.loh AdrpLdrGotLdr	Lloh81, Lloh82, Lloh83
	.loh AdrpLdrGotLdr	Lloh86, Lloh87, Lloh88
	.loh AdrpLdrGotLdr	Lloh89, Lloh90, Lloh91
	.loh AdrpLdrGotLdr	Lloh92, Lloh93, Lloh94
	.cfi_endproc
	.section	__TEXT,__const
lJTI0_0:
	.byte	(LBB0_68-LBB0_54)>>2
	.byte	(LBB0_64-LBB0_54)>>2
	.byte	(LBB0_54-LBB0_54)>>2
	.byte	(LBB0_65-LBB0_54)>>2
	.byte	(LBB0_67-LBB0_54)>>2
                                        ; -- End function
	.comm	_INDEX_MAX_KEYS,4,2             ; @INDEX_MAX_KEYS
	.comm	_P_NONE,8,3                     ; @P_NONE
	.comm	_InvalidBlockNumber,8,3         ; @InvalidBlockNumber
	.comm	_SK_BT_NULLS_FIRST,4,2          ; @SK_BT_NULLS_FIRST
	.comm	_SK_SEARCHNOTNULL,4,2           ; @SK_SEARCHNOTNULL
	.comm	_SK_ISNULL,4,2                  ; @SK_ISNULL
	.comm	_SK_BT_DESC,4,2                 ; @SK_BT_DESC
	.comm	_InvalidOid,8,3                 ; @InvalidOid
	.comm	_SK_ROW_HEADER,4,2              ; @SK_ROW_HEADER
	.comm	_SK_ROW_MEMBER,4,2              ; @SK_ROW_MEMBER
	.comm	_SK_ROW_END,4,2                 ; @SK_ROW_END
	.comm	_BTORDER_PROC,4,2               ; @BTORDER_PROC
	.comm	_InvalidStrategy,4,2            ; @InvalidStrategy
	.comm	_ERROR,4,2                      ; @ERROR
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"missing support function %d(%u,%u) for attribute %d of index \"%s\""

l_.str.1:                               ; @.str.1
	.asciz	"unrecognized strat_total: %d"

	.comm	_BT_READ,4,2                    ; @BT_READ
	.comm	_BUFFER_LOCK_UNLOCK,4,2         ; @BUFFER_LOCK_UNLOCK
.subsections_via_symbols
