	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ## -- Begin function LockAcquireExtended
LCPI0_0:
	.space	16
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_LockAcquireExtended
	.p2align	4, 0x90
_LockAcquireExtended:                   ## @LockAcquireExtended
	.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	$120, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r9, %r12
	movl	%r8d, -68(%rbp)                 ## 4-byte Spill
	movl	%ecx, -108(%rbp)                ## 4-byte Spill
	movl	%edx, %r14d
	movq	%rsi, %r13
	movq	%rdi, %r15
	movq	(%rdi), %rbx
	testq	%rbx, %rbx
	je	LBB0_2
## %bb.1:
	movq	_LockMethods@GOTPCREL(%rip), %rax
	movq	(%rax), %rdi
	callq	_lengthof
	cmpq	%rax, %rbx
	jb	LBB0_3
LBB0_2:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str(%rip), %rsi
	movq	%rbx, %rdx
	xorl	%eax, %eax
	callq	_elog
LBB0_3:
	movq	_LockMethods@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	(%rax,%rbx,8), %rbx
	testq	%r13, %r13
	je	LBB0_5
## %bb.4:
	cmpq	%r13, (%rbx)
	jae	LBB0_6
LBB0_5:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.1(%rip), %rsi
	movq	%r13, %rdx
	xorl	%eax, %eax
	callq	_elog
LBB0_6:
	xorl	%eax, %eax
	callq	_RecoveryInProgress
	testq	%rax, %rax
	movq	%rbx, -88(%rbp)                 ## 8-byte Spill
	je	LBB0_11
## %bb.7:
	movq	_InRecovery@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	jne	LBB0_11
## %bb.8:
	movq	8(%r15), %rax
	movq	_LOCKTAG_OBJECT@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	sete	%cl
	movq	_LOCKTAG_RELATION@GOTPCREL(%rip), %rdx
	cmpq	(%rdx), %rax
	sete	%al
	orb	%cl, %al
	cmpb	$1, %al
	jne	LBB0_11
## %bb.9:
	movq	_RowExclusiveLock@GOTPCREL(%rip), %rax
	cmpq	%r13, (%rax)
	jae	LBB0_11
## %bb.10:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %ebx
	movq	_ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_errcode
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movq	16(%rax), %rax
	movl	(%rax,%r13,4), %esi
	leaq	L_.str.2(%rip), %rdi
	xorl	%eax, %eax
	callq	_errmsg
	leaq	L_.str.3(%rip), %rdi
	callq	_errhint
	movl	%ebx, %edi
	movl	%eax, %esi
	callq	_ereport
LBB0_11:
	testl	%r14d, %r14d
	jne	LBB0_13
## %bb.12:
	movq	_CurrentResourceOwner@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	jmp	LBB0_14
LBB0_13:
	xorl	%eax, %eax
LBB0_14:
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	leaq	-152(%rbp), %rbx
	movq	%rbx, %rdi
	xorl	%esi, %esi
	movl	$40, %edx
	callq	_MemSet
	movups	(%r15), %xmm0
	movq	%r15, -48(%rbp)                 ## 8-byte Spill
	movups	16(%r15), %xmm1
	movups	%xmm0, -144(%rbp)
	movups	%xmm1, -128(%rbp)
	movq	%r13, -152(%rbp)
	movq	_LockMethodLocalHash@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movq	_HASH_ENTER@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	leaq	-112(%rbp), %rcx
	movq	%rbx, %rsi
	callq	_hash_search
	movq	%rax, %r15
	cmpl	$0, -112(%rbp)
	je	LBB0_17
## %bb.15:
	movl	28(%r15), %esi
	cmpl	%esi, 24(%r15)
	jl	LBB0_18
## %bb.16:
	leal	(%rsi,%rsi), %r14d
	movq	48(%r15), %rdi
	shll	$3, %esi
                                        ## kill: def $esi killed $esi killed $rsi
	callq	_repalloc
	movq	%rax, 48(%r15)
	movl	%r14d, 28(%r15)
	jmp	LBB0_18
LBB0_17:
	leaq	-144(%rbp), %rdi
	xorps	%xmm0, %xmm0
	movups	%xmm0, 32(%r15)
	callq	_LockTagHashCode
	movq	%rax, (%r15)
	xorps	%xmm0, %xmm0
	movups	%xmm0, 8(%r15)
	movabsq	$34359738368, %rax              ## imm = 0x800000000
	movq	%rax, 24(%r15)
	movq	$0, 48(%r15)
	movq	_TopMemoryContext@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movl	$32, %esi
	callq	_MemoryContextAlloc
	movq	%rax, 48(%r15)
LBB0_18:
	movq	(%r15), %r14
	testq	%r12, %r12
	je	LBB0_20
## %bb.19:
	movq	%r12, %rax
	movq	%r15, (%r12)
LBB0_20:
	cmpq	$0, 8(%r15)
	jle	LBB0_23
## %bb.21:
	movq	%r15, %rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_GrantLockLocal
	cmpl	$0, 20(%r15)
	jne	LBB0_28
## %bb.22:
	movq	_LOCKACQUIRE_ALREADY_HELD@GOTPCREL(%rip), %rbx
	jmp	LBB0_75
LBB0_23:
	movq	_AccessExclusiveLock@GOTPCREL(%rip), %rax
	cmpq	%r13, (%rax)
	ja	LBB0_29
## %bb.24:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	movq	8(%rax), %rax
	movq	_LOCKTAG_RELATION@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_29
## %bb.25:
	movb	$1, %al
	movl	%eax, -52(%rbp)                 ## 4-byte Spill
	xorl	%eax, %eax
	callq	_RecoveryInProgress
	testq	%rax, %rax
	jne	LBB0_30
## %bb.26:
	xorl	%eax, %eax
	callq	_XLogStandbyInfoActive
	testq	%rax, %rax
	je	LBB0_30
## %bb.27:
	movl	$0, -52(%rbp)                   ## 4-byte Folded Spill
	xorl	%eax, %eax
	callq	_LogAccessExclusiveLockPrepare
	jmp	LBB0_30
LBB0_28:
	movq	_LOCKACQUIRE_ALREADY_CLEAR@GOTPCREL(%rip), %rbx
	jmp	LBB0_75
LBB0_29:
	movb	$1, %al
	movl	%eax, -52(%rbp)                 ## 4-byte Spill
LBB0_30:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	movq	%r13, %rsi
	callq	_EligibleForRelationFastPath
	testq	%rax, %rax
	movq	%r12, -96(%rbp)                 ## 8-byte Spill
	movq	%r14, -104(%rbp)                ## 8-byte Spill
	je	LBB0_34
## %bb.31:
	movq	_FastPathLocalUseCount@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	_FP_LOCK_SLOTS_PER_BACKEND@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jge	LBB0_34
## %bb.32:
	movq	%r14, %rdi
	callq	_FastPathStrongLockHashPartition
	movq	%rax, %r14
	movq	_MyProc@GOTPCREL(%rip), %r12
	movq	(%r12), %rdi
	addq	$4, %rdi
	movq	_LW_EXCLUSIVE@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	callq	_LWLockAcquire
	movq	_FastPathStrongRelationLocks@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	(%rax), %rax
	cmpq	$0, (%rax,%r14,8)
	je	LBB0_62
## %bb.33:
	movq	(%r12), %rdi
	addq	$4, %rdi
	callq	_LWLockRelease
LBB0_34:
	movq	-48(%rbp), %r14                 ## 8-byte Reload
	movq	%r14, %rdi
	movq	%r13, %rsi
	callq	_ConflictsWithRelationFastPath
	testq	%rax, %rax
	movl	-68(%rbp), %ebx                 ## 4-byte Reload
	je	LBB0_42
## %bb.35:
	movq	-104(%rbp), %r12                ## 8-byte Reload
	movq	%r12, %rdi
	callq	_FastPathStrongLockHashPartition
	movq	%r15, %rdi
	movq	%rax, %rsi
	callq	_BeginStrongLockAcquire
	movq	-88(%rbp), %rdi                 ## 8-byte Reload
	movq	%r14, %rsi
	movq	%r12, %rdx
	callq	_FastPathTransferRelationLocks
	testl	%eax, %eax
	jne	LBB0_42
## %bb.36:
	xorl	%eax, %eax
	callq	_AbortStrongLockAcquire
	cmpq	$0, 8(%r15)
	jne	LBB0_38
## %bb.37:
	movq	%r15, %rdi
	callq	_RemoveLocalLock
LBB0_38:
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	testq	%rax, %rax
	je	LBB0_40
## %bb.39:
	movq	$0, (%rax)
LBB0_40:
	testl	%ebx, %ebx
	je	LBB0_74
## %bb.41:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %r14d
	movq	_ERRCODE_OUT_OF_MEMORY@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_errcode
	leaq	L_.str.4(%rip), %rdi
	xorl	%eax, %eax
	callq	_errmsg
	leaq	L_.str.5(%rip), %rdi
	callq	_errhint
	movl	%r14d, %edi
	movl	%eax, %esi
	callq	_ereport
	movq	-48(%rbp), %r14                 ## 8-byte Reload
LBB0_42:
	movq	-104(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %rdi
	callq	_LockHashPartitionLock
	movq	%rax, %rdi
	movq	_LW_EXCLUSIVE@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	movq	%rdi, -80(%rbp)                 ## 8-byte Spill
	callq	_LWLockAcquire
	movq	_MyProc@GOTPCREL(%rip), %rax
	movq	(%rax), %rsi
	movq	-88(%rbp), %r12                 ## 8-byte Reload
	movq	%r12, %rdi
	movq	%r14, %rdx
	movq	%rbx, %rcx
	movq	%r13, %r8
	callq	_SetupLockInTable
	movq	%rax, %r14
	testq	%rax, %rax
	jne	LBB0_49
## %bb.43:
	xorl	%eax, %eax
	callq	_AbortStrongLockAcquire
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_LWLockRelease
	cmpq	$0, 8(%r15)
	movl	-68(%rbp), %r12d                ## 4-byte Reload
	jne	LBB0_45
## %bb.44:
	movq	%r15, %rdi
	callq	_RemoveLocalLock
LBB0_45:
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	testq	%rax, %rax
	je	LBB0_47
## %bb.46:
	movq	$0, (%rax)
LBB0_47:
	testl	%r12d, %r12d
	je	LBB0_74
## %bb.48:
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %r12d
	movq	_ERRCODE_OUT_OF_MEMORY@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_errcode
	leaq	L_.str.4(%rip), %rdi
	xorl	%eax, %eax
	callq	_errmsg
	leaq	L_.str.5(%rip), %rdi
	callq	_errhint
	movl	%r12d, %edi
	movl	%eax, %esi
	callq	_ereport
	movq	-88(%rbp), %r12                 ## 8-byte Reload
LBB0_49:
	movq	%r14, 40(%r15)
	movq	8(%r14), %rbx
	movq	%rbx, 32(%r15)
	movq	8(%r12), %rax
	movl	(%rbx), %ecx
	testl	%ecx, (%rax,%r13,4)
	je	LBB0_51
## %bb.50:
	movq	_STATUS_FOUND@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	jmp	LBB0_52
LBB0_51:
	movq	%r12, %rdi
	movq	%r13, %rsi
	movq	%rbx, %rdx
	movq	%r14, %rcx
	callq	_LockCheckConflicts
LBB0_52:
	movq	_STATUS_OK@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	jne	LBB0_54
## %bb.53:
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r13, %rdx
	callq	_GrantLock
	movq	%r15, %rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_GrantLockLocal
	movq	-48(%rbp), %r15                 ## 8-byte Reload
	jmp	LBB0_60
LBB0_54:
	movq	_STATUS_FOUND@GOTPCREL(%rip), %rcx
	xorl	%edi, %edi
	cmpl	(%rcx), %eax
	sete	%dil
	callq	_Assert
	cmpl	$0, -108(%rbp)                  ## 4-byte Folded Reload
	je	LBB0_57
## %bb.55:
	xorl	%eax, %eax
	callq	_AbortStrongLockAcquire
	cmpl	$0, (%r14)
	je	LBB0_65
## %bb.56:
	leaq	L_.str.7(%rip), %rdi
	movq	%r14, %rsi
	callq	_PROCLOCK_PRINT
	jmp	LBB0_67
LBB0_74:
	movq	_LOCKACQUIRE_NOT_AVAIL@GOTPCREL(%rip), %rbx
	jmp	LBB0_75
LBB0_57:
	movq	%rbx, %r12
	movl	(%r14), %eax
	movq	_MyProc@GOTPCREL(%rip), %rcx
	movq	(%rcx), %rcx
	movl	%eax, (%rcx)
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	movl	20(%rbx), %edi
	movl	16(%rbx), %esi
	movl	28(%rbx), %edx
	movl	24(%rbx), %ecx
	movq	8(%rbx), %r8
	movq	%r13, %r9
	callq	_TRACE_POSTGRESQL_LOCK_WAIT_START
	movq	%r15, %rdi
	movq	%rbx, %r15
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_WaitOnLock
	movl	20(%rbx), %edi
	movl	16(%rbx), %esi
	movl	28(%rbx), %edx
	movl	24(%rbx), %ecx
	movq	8(%rbx), %r8
	movq	%r13, %r9
	callq	_TRACE_POSTGRESQL_LOCK_WAIT_DONE
	movl	(%r14), %ebx
	movq	%r13, %rdi
	callq	_LOCKBIT_ON
	testl	%ebx, %eax
	jne	LBB0_59
## %bb.58:
	xorl	%eax, %eax
	callq	_AbortStrongLockAcquire
	leaq	L_.str.9(%rip), %rbx
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_PROCLOCK_PRINT
	movq	%rbx, %rdi
	movq	%r12, %rsi
	movq	%r13, %rdx
	callq	_LOCK_PRINT
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_LWLockRelease
	movq	_ERROR@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.10(%rip), %rsi
	xorl	%eax, %eax
	callq	_elog
LBB0_59:
	leaq	L_.str.11(%rip), %rbx
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_PROCLOCK_PRINT
	movq	%rbx, %rdi
	movq	%r12, %rsi
	movq	%r13, %rdx
	callq	_LOCK_PRINT
LBB0_60:
	xorl	%eax, %eax
	callq	_FinishStrongLockAcquire
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_LWLockRelease
	movq	_LOCKACQUIRE_OK@GOTPCREL(%rip), %rbx
	cmpb	$0, -52(%rbp)                   ## 1-byte Folded Reload
	jne	LBB0_75
## %bb.61:
	movl	16(%r15), %esi
	movl	20(%r15), %edi
	callq	_LogAccessExclusiveLock
	jmp	LBB0_75
LBB0_62:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	movl	16(%rax), %edi
	movq	%r13, %rsi
	callq	_FastPathGrantRelationLock
	movl	%eax, %r14d
	movq	(%r12), %rdi
	addq	$4, %rdi
	callq	_LWLockRelease
	testl	%r14d, %r14d
	je	LBB0_34
## %bb.63:
	xorps	%xmm0, %xmm0
	movups	%xmm0, 32(%r15)
	movq	%r15, %rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_GrantLockLocal
	movq	_LOCKACQUIRE_OK@GOTPCREL(%rip), %rbx
	jmp	LBB0_75
LBB0_65:
	movq	%rbx, %r12
	leaq	8(%r14), %rbx
	movq	%rbx, %rdi
	movq	-104(%rbp), %rsi                ## 8-byte Reload
	callq	_ProcLockHashCode
	movq	%rax, -48(%rbp)                 ## 8-byte Spill
	leaq	20(%r14), %rdi
	callq	_SHMQueueDelete
	addq	$16, %r14
	movq	%r14, %rdi
	callq	_SHMQueueDelete
	movq	_LockMethodProcLockHash@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movq	_HASH_REMOVE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	%rbx, %rsi
	movq	%r12, %rbx
	movq	-48(%rbp), %rdx                 ## 8-byte Reload
	xorl	%r8d, %r8d
	callq	_hash_search_with_hash_value
	testl	%eax, %eax
	jne	LBB0_67
## %bb.66:
	movq	_PANIC@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.6(%rip), %rsi
	xorl	%eax, %eax
	callq	_elog
LBB0_67:
	decq	8(%rbx)
	movq	16(%rbx), %rax
	decq	(%rax,%r13,8)
	leaq	L_.str.8(%rip), %rdi
	movq	%rbx, %rsi
	movq	%r13, %rdx
	callq	_LOCK_PRINT
	cmpq	$0, 8(%rbx)
	jle	LBB0_69
## %bb.68:
	movq	16(%rbx), %rax
	movq	(%rax,%r13,8), %rdi
	shrq	$63, %rdi
	xorl	$1, %edi
	jmp	LBB0_70
LBB0_69:
	xorl	%edi, %edi
LBB0_70:
                                        ## kill: def $edi killed $edi killed $rdi
	callq	_Assert
	movq	24(%rbx), %rax
	xorl	%edi, %edi
	cmpq	8(%rbx), %rax
	setle	%dil
	callq	_Assert
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_LWLockRelease
	cmpq	$0, 8(%r15)
	jne	LBB0_72
## %bb.71:
	movq	%r15, %rdi
	callq	_RemoveLocalLock
LBB0_72:
	movq	_LOCKACQUIRE_NOT_AVAIL@GOTPCREL(%rip), %rbx
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	testq	%rax, %rax
	je	LBB0_75
## %bb.73:
	movq	$0, (%rax)
LBB0_75:
	movl	(%rbx), %eax
	addq	$120, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.comm	_LockMethods,8,3                ## @LockMethods
	.comm	_ERROR,4,2                      ## @ERROR
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"unrecognized lock method: %d"

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

	.comm	_InRecovery,4,2                 ## @InRecovery
	.comm	_LOCKTAG_OBJECT,8,3             ## @LOCKTAG_OBJECT
	.comm	_LOCKTAG_RELATION,8,3           ## @LOCKTAG_RELATION
	.comm	_RowExclusiveLock,8,3           ## @RowExclusiveLock
	.comm	_ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE,4,2 ## @ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE
L_.str.2:                               ## @.str.2
	.asciz	"cannot acquire lock mode %s on database objects while recovery is in progress"

L_.str.3:                               ## @.str.3
	.asciz	"Only RowExclusiveLock or less can be acquired on database objects during recovery."

	.comm	_CurrentResourceOwner,8,3       ## @CurrentResourceOwner
	.comm	_LockMethodLocalHash,4,2        ## @LockMethodLocalHash
	.comm	_HASH_ENTER,4,2                 ## @HASH_ENTER
	.comm	_TopMemoryContext,4,2           ## @TopMemoryContext
	.comm	_LOCKACQUIRE_ALREADY_CLEAR,4,2  ## @LOCKACQUIRE_ALREADY_CLEAR
	.comm	_LOCKACQUIRE_ALREADY_HELD,4,2   ## @LOCKACQUIRE_ALREADY_HELD
	.comm	_AccessExclusiveLock,8,3        ## @AccessExclusiveLock
	.comm	_FastPathLocalUseCount,8,3      ## @FastPathLocalUseCount
	.comm	_FP_LOCK_SLOTS_PER_BACKEND,8,3  ## @FP_LOCK_SLOTS_PER_BACKEND
	.comm	_MyProc,8,3                     ## @MyProc
	.comm	_LW_EXCLUSIVE,4,2               ## @LW_EXCLUSIVE
	.comm	_FastPathStrongRelationLocks,8,3 ## @FastPathStrongRelationLocks
	.comm	_LOCKACQUIRE_OK,4,2             ## @LOCKACQUIRE_OK
	.comm	_ERRCODE_OUT_OF_MEMORY,4,2      ## @ERRCODE_OUT_OF_MEMORY
L_.str.4:                               ## @.str.4
	.asciz	"out of shared memory"

L_.str.5:                               ## @.str.5
	.asciz	"You might need to increase max_locks_per_transaction."

	.comm	_LOCKACQUIRE_NOT_AVAIL,4,2      ## @LOCKACQUIRE_NOT_AVAIL
	.comm	_STATUS_FOUND,4,2               ## @STATUS_FOUND
	.comm	_STATUS_OK,4,2                  ## @STATUS_OK
	.comm	_LockMethodProcLockHash,4,2     ## @LockMethodProcLockHash
	.comm	_HASH_REMOVE,4,2                ## @HASH_REMOVE
	.comm	_PANIC,4,2                      ## @PANIC
L_.str.6:                               ## @.str.6
	.asciz	"proclock table corrupted"

L_.str.7:                               ## @.str.7
	.asciz	"LockAcquire: NOWAIT"

L_.str.8:                               ## @.str.8
	.asciz	"LockAcquire: conditional lock failed"

L_.str.9:                               ## @.str.9
	.asciz	"LockAcquire: INCONSISTENT"

L_.str.10:                              ## @.str.10
	.asciz	"LockAcquire failed"

L_.str.11:                              ## @.str.11
	.asciz	"LockAcquire: granted"

	.comm	_LOG,4,2                        ## @LOG
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_LockAcquireExtended            ; -- Begin function LockAcquireExtended
	.p2align	2
_LockAcquireExtended:                   ; @LockAcquireExtended
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #192
	.cfi_def_cfa_offset 192
	stp	x28, x27, [sp, #96]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #112]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #128]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #144]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #160]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #176]            ; 16-byte Folded Spill
	add	x29, sp, #176
	.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
	mov	x20, x5
	mov	x25, x4
	mov	x26, x3
	mov	x22, x2
	mov	x19, x1
	mov	x21, x0
	ldr	x23, [x0]
Lloh0:
	adrp	x24, _LockMethods@GOTPAGE
Lloh1:
	ldr	x24, [x24, _LockMethods@GOTPAGEOFF]
	cbz	x23, LBB0_2
; %bb.1:
	ldr	x0, [x24]
	bl	_lengthof
	cmp	x23, x0
	b.lo	LBB0_3
LBB0_2:
Lloh2:
	adrp	x8, _ERROR@GOTPAGE
Lloh3:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh4:
	ldr	w0, [x8]
	str	x23, [sp]
Lloh5:
	adrp	x1, l_.str@PAGE
Lloh6:
	add	x1, x1, l_.str@PAGEOFF
	bl	_elog
LBB0_3:
	ldr	x8, [x24]
	ldr	x24, [x8, x23, lsl #3]
	cbz	x19, LBB0_5
; %bb.4:
	ldr	x8, [x24]
	cmp	x8, x19
	b.hs	LBB0_6
LBB0_5:
Lloh7:
	adrp	x8, _ERROR@GOTPAGE
Lloh8:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh9:
	ldr	w0, [x8]
	str	x19, [sp]
Lloh10:
	adrp	x1, l_.str.1@PAGE
Lloh11:
	add	x1, x1, l_.str.1@PAGEOFF
	bl	_elog
LBB0_6:
	bl	_RecoveryInProgress
	cbz	x0, LBB0_10
; %bb.7:
Lloh12:
	adrp	x8, _InRecovery@GOTPAGE
Lloh13:
	ldr	x8, [x8, _InRecovery@GOTPAGEOFF]
Lloh14:
	ldr	w8, [x8]
	cbnz	w8, LBB0_10
; %bb.8:
	ldr	x8, [x21, #8]
Lloh15:
	adrp	x9, _LOCKTAG_OBJECT@GOTPAGE
Lloh16:
	ldr	x9, [x9, _LOCKTAG_OBJECT@GOTPAGEOFF]
Lloh17:
	ldr	x9, [x9]
Lloh18:
	adrp	x10, _LOCKTAG_RELATION@GOTPAGE
Lloh19:
	ldr	x10, [x10, _LOCKTAG_RELATION@GOTPAGEOFF]
Lloh20:
	ldr	x10, [x10]
	cmp	x8, x10
	ccmp	x8, x9, #4, ne
Lloh21:
	adrp	x8, _RowExclusiveLock@GOTPAGE
Lloh22:
	ldr	x8, [x8, _RowExclusiveLock@GOTPAGEOFF]
Lloh23:
	ldr	x8, [x8]
	ccmp	x8, x19, #2, eq
	b.hs	LBB0_10
; %bb.9:
Lloh24:
	adrp	x8, _ERROR@GOTPAGE
Lloh25:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh26:
	ldr	w23, [x8]
Lloh27:
	adrp	x8, _ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE@GOTPAGE
Lloh28:
	ldr	x8, [x8, _ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE@GOTPAGEOFF]
Lloh29:
	ldr	w0, [x8]
	bl	_errcode
	ldr	x8, [x24, #16]
	ldr	w8, [x8, x19, lsl #2]
	str	x8, [sp]
Lloh30:
	adrp	x0, l_.str.2@PAGE
Lloh31:
	add	x0, x0, l_.str.2@PAGEOFF
	bl	_errmsg
Lloh32:
	adrp	x0, l_.str.3@PAGE
Lloh33:
	add	x0, x0, l_.str.3@PAGEOFF
	bl	_errhint
	mov	x1, x0
	mov	x0, x23
	bl	_ereport
LBB0_10:
Lloh34:
	adrp	x8, _CurrentResourceOwner@GOTPAGE
Lloh35:
	ldr	x8, [x8, _CurrentResourceOwner@GOTPAGEOFF]
Lloh36:
	ldr	x8, [x8]
	cmp	w22, #0
	csel	x28, x8, xzr, eq
	add	x23, sp, #56
	add	x0, sp, #56
	mov	w1, #0
	mov	w2, #40
	bl	_MemSet
	ldp	q0, q1, [x21]
	stp	q0, q1, [sp, #64]
	str	x19, [sp, #56]
Lloh37:
	adrp	x8, _LockMethodLocalHash@GOTPAGE
Lloh38:
	ldr	x8, [x8, _LockMethodLocalHash@GOTPAGEOFF]
Lloh39:
	ldr	w0, [x8]
Lloh40:
	adrp	x8, _HASH_ENTER@GOTPAGE
Lloh41:
	ldr	x8, [x8, _HASH_ENTER@GOTPAGEOFF]
Lloh42:
	ldr	w2, [x8]
	add	x1, sp, #56
	add	x3, sp, #52
	bl	_hash_search
	mov	x22, x0
	ldr	w8, [sp, #52]
	cbz	w8, LBB0_17
; %bb.11:
	ldp	w9, w8, [x22, #24]
	cmp	w9, w8
	b.lt	LBB0_13
; %bb.12:
	lsl	w23, w8, #1
	ldr	x0, [x22, #48]
	lsl	w1, w8, #3
	bl	_repalloc
	str	x0, [x22, #48]
	str	w23, [x22, #28]
LBB0_13:
	ldr	x27, [x22]
	cbz	x20, LBB0_15
LBB0_14:
	str	x22, [x20]
LBB0_15:
	ldr	x8, [x22, #8]
	cmp	x8, #1
	b.lt	LBB0_18
; %bb.16:
	mov	x0, x22
	mov	x1, x28
	bl	_GrantLockLocal
	ldr	w8, [x22, #20]
Lloh43:
	adrp	x9, _LOCKACQUIRE_ALREADY_CLEAR@GOTPAGE
Lloh44:
	ldr	x9, [x9, _LOCKACQUIRE_ALREADY_CLEAR@GOTPAGEOFF]
Lloh45:
	adrp	x10, _LOCKACQUIRE_ALREADY_HELD@GOTPAGE
Lloh46:
	ldr	x10, [x10, _LOCKACQUIRE_ALREADY_HELD@GOTPAGEOFF]
	cmp	w8, #0
	csel	x8, x10, x9, eq
	b	LBB0_69
LBB0_17:
	add	x0, x23, #8
	stp	xzr, xzr, [x22, #32]
	bl	_LockTagHashCode
	stp	x0, xzr, [x22]
	mov	x8, #34359738368
	stp	xzr, x8, [x22, #16]
	str	xzr, [x22, #48]
Lloh47:
	adrp	x8, _TopMemoryContext@GOTPAGE
Lloh48:
	ldr	x8, [x8, _TopMemoryContext@GOTPAGEOFF]
Lloh49:
	ldr	w0, [x8]
	mov	w1, #32
	bl	_MemoryContextAlloc
	str	x0, [x22, #48]
	ldr	x27, [x22]
	cbnz	x20, LBB0_14
	b	LBB0_15
LBB0_18:
Lloh50:
	adrp	x8, _AccessExclusiveLock@GOTPAGE
Lloh51:
	ldr	x8, [x8, _AccessExclusiveLock@GOTPAGEOFF]
Lloh52:
	ldr	x8, [x8]
	cmp	x8, x19
	str	x28, [sp, #40]                  ; 8-byte Folded Spill
	b.hi	LBB0_21
; %bb.19:
	ldr	x8, [x21, #8]
Lloh53:
	adrp	x9, _LOCKTAG_RELATION@GOTPAGE
Lloh54:
	ldr	x9, [x9, _LOCKTAG_RELATION@GOTPAGEOFF]
Lloh55:
	ldr	x9, [x9]
	cmp	x8, x9
	b.ne	LBB0_21
; %bb.20:
	bl	_RecoveryInProgress
	cbz	x0, LBB0_57
LBB0_21:
	mov	w8, #1
	str	w8, [sp, #36]                   ; 4-byte Folded Spill
LBB0_22:
	mov	x0, x21
	mov	x1, x19
	bl	_EligibleForRelationFastPath
Lloh56:
	adrp	x28, _LW_EXCLUSIVE@GOTPAGE
Lloh57:
	ldr	x28, [x28, _LW_EXCLUSIVE@GOTPAGEOFF]
	cbz	x0, LBB0_26
; %bb.23:
Lloh58:
	adrp	x8, _FastPathLocalUseCount@GOTPAGE
Lloh59:
	ldr	x8, [x8, _FastPathLocalUseCount@GOTPAGEOFF]
Lloh60:
	ldr	x8, [x8]
Lloh61:
	adrp	x9, _FP_LOCK_SLOTS_PER_BACKEND@GOTPAGE
Lloh62:
	ldr	x9, [x9, _FP_LOCK_SLOTS_PER_BACKEND@GOTPAGEOFF]
Lloh63:
	ldr	x9, [x9]
	cmp	x8, x9
	b.ge	LBB0_26
; %bb.24:
	mov	x0, x27
	bl	_FastPathStrongLockHashPartition
	mov	x23, x0
	mov	x9, x28
Lloh64:
	adrp	x28, _MyProc@GOTPAGE
Lloh65:
	ldr	x28, [x28, _MyProc@GOTPAGEOFF]
	ldr	x8, [x28]
	add	x0, x8, #4
	ldr	w1, [x9]
	bl	_LWLockAcquire
Lloh66:
	adrp	x8, _FastPathStrongRelationLocks@GOTPAGE
Lloh67:
	ldr	x8, [x8, _FastPathStrongRelationLocks@GOTPAGEOFF]
Lloh68:
	ldr	x8, [x8]
	ldr	x8, [x8]
	ldr	x8, [x8, x23, lsl #3]
	cbz	x8, LBB0_54
; %bb.25:
	ldr	x8, [x28]
	add	x0, x8, #4
	bl	_LWLockRelease
Lloh69:
	adrp	x28, _LW_EXCLUSIVE@GOTPAGE
Lloh70:
	ldr	x28, [x28, _LW_EXCLUSIVE@GOTPAGEOFF]
LBB0_26:
	mov	x0, x21
	mov	x1, x19
	bl	_ConflictsWithRelationFastPath
	cbz	x0, LBB0_34
; %bb.27:
	mov	x0, x27
	bl	_FastPathStrongLockHashPartition
	mov	x1, x0
	mov	x0, x22
	bl	_BeginStrongLockAcquire
	mov	x0, x24
	mov	x1, x21
	mov	x2, x27
	bl	_FastPathTransferRelationLocks
	cbnz	w0, LBB0_34
; %bb.28:
	bl	_AbortStrongLockAcquire
	ldr	x8, [x22, #8]
	cbnz	x8, LBB0_30
; %bb.29:
	mov	x0, x22
	bl	_RemoveLocalLock
LBB0_30:
	cbz	x20, LBB0_32
; %bb.31:
	str	xzr, [x20]
LBB0_32:
	cbz	w25, LBB0_68
; %bb.33:
Lloh71:
	adrp	x8, _ERROR@GOTPAGE
Lloh72:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh73:
	ldr	w23, [x8]
Lloh74:
	adrp	x8, _ERRCODE_OUT_OF_MEMORY@GOTPAGE
Lloh75:
	ldr	x8, [x8, _ERRCODE_OUT_OF_MEMORY@GOTPAGEOFF]
Lloh76:
	ldr	w0, [x8]
	bl	_errcode
Lloh77:
	adrp	x0, l_.str.4@PAGE
Lloh78:
	add	x0, x0, l_.str.4@PAGEOFF
	bl	_errmsg
Lloh79:
	adrp	x0, l_.str.5@PAGE
Lloh80:
	add	x0, x0, l_.str.5@PAGEOFF
	bl	_errhint
	mov	x1, x0
	mov	x0, x23
	bl	_ereport
LBB0_34:
	mov	x0, x27
	bl	_LockHashPartitionLock
	mov	x23, x0
	ldr	w1, [x28]
	bl	_LWLockAcquire
Lloh81:
	adrp	x8, _MyProc@GOTPAGE
Lloh82:
	ldr	x8, [x8, _MyProc@GOTPAGEOFF]
Lloh83:
	ldr	x1, [x8]
	mov	x0, x24
	mov	x2, x21
	mov	x3, x27
	mov	x4, x19
	bl	_SetupLockInTable
	mov	x28, x0
	cbnz	x0, LBB0_41
; %bb.35:
	bl	_AbortStrongLockAcquire
	mov	x0, x23
	bl	_LWLockRelease
	ldr	x8, [x22, #8]
	cbnz	x8, LBB0_37
; %bb.36:
	mov	x0, x22
	bl	_RemoveLocalLock
LBB0_37:
	cbz	x20, LBB0_39
; %bb.38:
	str	xzr, [x20]
LBB0_39:
	cbz	w25, LBB0_68
; %bb.40:
Lloh84:
	adrp	x8, _ERROR@GOTPAGE
Lloh85:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
	mov	x25, x23
Lloh86:
	ldr	w23, [x8]
Lloh87:
	adrp	x8, _ERRCODE_OUT_OF_MEMORY@GOTPAGE
Lloh88:
	ldr	x8, [x8, _ERRCODE_OUT_OF_MEMORY@GOTPAGEOFF]
Lloh89:
	ldr	w0, [x8]
	bl	_errcode
Lloh90:
	adrp	x0, l_.str.4@PAGE
Lloh91:
	add	x0, x0, l_.str.4@PAGEOFF
	bl	_errmsg
Lloh92:
	adrp	x0, l_.str.5@PAGE
Lloh93:
	add	x0, x0, l_.str.5@PAGEOFF
	bl	_errhint
	mov	x1, x0
	mov	x0, x23
	mov	x23, x25
	bl	_ereport
LBB0_41:
	stp	x20, x23, [sp, #16]             ; 16-byte Folded Spill
	str	x28, [x22, #40]
	mov	x23, x28
	ldr	x25, [x23, #8]!
	str	x25, [x22, #32]
	ldr	x8, [x24, #8]
	ldr	w8, [x8, x19, lsl #2]
	ldr	w9, [x25]
Lloh94:
	adrp	x20, _STATUS_FOUND@GOTPAGE
Lloh95:
	ldr	x20, [x20, _STATUS_FOUND@GOTPAGEOFF]
	tst	w9, w8
	b.eq	LBB0_43
; %bb.42:
	ldr	w0, [x20]
	b	LBB0_44
LBB0_43:
	mov	x0, x24
	mov	x1, x19
	mov	x2, x25
	mov	x3, x28
	bl	_LockCheckConflicts
LBB0_44:
Lloh96:
	adrp	x24, _MyProc@GOTPAGE
Lloh97:
	ldr	x24, [x24, _MyProc@GOTPAGEOFF]
Lloh98:
	adrp	x8, _STATUS_OK@GOTPAGE
Lloh99:
	ldr	x8, [x8, _STATUS_OK@GOTPAGEOFF]
Lloh100:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_46
; %bb.45:
	mov	x0, x25
	mov	x1, x28
	mov	x2, x19
	bl	_GrantLock
	mov	x0, x22
	ldr	x1, [sp, #40]                   ; 8-byte Folded Reload
	bl	_GrantLockLocal
	ldr	x22, [sp, #24]                  ; 8-byte Folded Reload
	b	LBB0_52
LBB0_46:
	ldr	w8, [x20]
	cmp	w0, w8
	cset	w0, eq
	bl	_Assert
	cbz	w26, LBB0_49
; %bb.47:
	bl	_AbortStrongLockAcquire
	ldr	w8, [x28]
	cbz	w8, LBB0_59
; %bb.48:
Lloh101:
	adrp	x0, l_.str.7@PAGE
Lloh102:
	add	x0, x0, l_.str.7@PAGEOFF
	mov	x1, x28
	bl	_PROCLOCK_PRINT
	ldr	x20, [sp, #16]                  ; 8-byte Folded Reload
	b	LBB0_61
LBB0_49:
	ldr	w8, [x28]
	ldr	x9, [x24]
	str	w8, [x9]
	ldp	w1, w0, [x21, #16]
	ldp	w3, w2, [x21, #24]
	ldr	x4, [x21, #8]
	mov	x5, x19
	bl	_TRACE_POSTGRESQL_LOCK_WAIT_START
	mov	x0, x22
	ldr	x1, [sp, #40]                   ; 8-byte Folded Reload
	bl	_WaitOnLock
	ldp	w1, w0, [x21, #16]
	ldp	w3, w2, [x21, #24]
	ldr	x4, [x21, #8]
	mov	x5, x19
	bl	_TRACE_POSTGRESQL_LOCK_WAIT_DONE
	ldr	w20, [x28]
	mov	x0, x19
	bl	_LOCKBIT_ON
	tst	w0, w20
	ldr	x22, [sp, #24]                  ; 8-byte Folded Reload
	b.ne	LBB0_51
; %bb.50:
	bl	_AbortStrongLockAcquire
Lloh103:
	adrp	x20, l_.str.9@PAGE
Lloh104:
	add	x20, x20, l_.str.9@PAGEOFF
	mov	x0, x20
	mov	x1, x28
	bl	_PROCLOCK_PRINT
	mov	x0, x20
	mov	x1, x25
	mov	x2, x19
	bl	_LOCK_PRINT
	mov	x0, x22
	bl	_LWLockRelease
Lloh105:
	adrp	x8, _ERROR@GOTPAGE
Lloh106:
	ldr	x8, [x8, _ERROR@GOTPAGEOFF]
Lloh107:
	ldr	w0, [x8]
Lloh108:
	adrp	x1, l_.str.10@PAGE
Lloh109:
	add	x1, x1, l_.str.10@PAGEOFF
	bl	_elog
LBB0_51:
Lloh110:
	adrp	x20, l_.str.11@PAGE
Lloh111:
	add	x20, x20, l_.str.11@PAGEOFF
	mov	x0, x20
	mov	x1, x28
	bl	_PROCLOCK_PRINT
	mov	x0, x20
	mov	x1, x25
	mov	x2, x19
	bl	_LOCK_PRINT
LBB0_52:
	bl	_FinishStrongLockAcquire
	mov	x0, x22
	bl	_LWLockRelease
	ldr	w8, [sp, #36]                   ; 4-byte Folded Reload
	tbnz	w8, #0, LBB0_56
; %bb.53:
	ldp	w1, w0, [x21, #16]
	bl	_LogAccessExclusiveLock
	b	LBB0_56
LBB0_54:
	ldr	w0, [x21, #16]
	mov	x1, x19
	bl	_FastPathGrantRelationLock
	mov	x23, x0
	ldr	x8, [x28]
	add	x0, x8, #4
	bl	_LWLockRelease
Lloh112:
	adrp	x28, _LW_EXCLUSIVE@GOTPAGE
Lloh113:
	ldr	x28, [x28, _LW_EXCLUSIVE@GOTPAGEOFF]
	cbz	w23, LBB0_26
; %bb.55:
	stp	xzr, xzr, [x22, #32]
	mov	x0, x22
	ldr	x1, [sp, #40]                   ; 8-byte Folded Reload
	bl	_GrantLockLocal
LBB0_56:
Lloh114:
	adrp	x8, _LOCKACQUIRE_OK@GOTPAGE
Lloh115:
	ldr	x8, [x8, _LOCKACQUIRE_OK@GOTPAGEOFF]
	b	LBB0_69
LBB0_57:
	bl	_XLogStandbyInfoActive
	cbz	x0, LBB0_21
; %bb.58:
	bl	_LogAccessExclusiveLockPrepare
	str	wzr, [sp, #36]                  ; 4-byte Folded Spill
	b	LBB0_22
LBB0_59:
	mov	x0, x23
	mov	x1, x27
	bl	_ProcLockHashCode
	mov	x21, x0
	add	x0, x28, #20
	bl	_SHMQueueDelete
	add	x0, x28, #16
	bl	_SHMQueueDelete
Lloh116:
	adrp	x8, _LockMethodProcLockHash@GOTPAGE
Lloh117:
	ldr	x8, [x8, _LockMethodProcLockHash@GOTPAGEOFF]
Lloh118:
	ldr	w0, [x8]
Lloh119:
	adrp	x8, _HASH_REMOVE@GOTPAGE
Lloh120:
	ldr	x8, [x8, _HASH_REMOVE@GOTPAGEOFF]
Lloh121:
	ldr	w3, [x8]
	mov	x1, x23
	mov	x2, x21
	mov	x4, #0
	bl	_hash_search_with_hash_value
	ldr	x20, [sp, #16]                  ; 8-byte Folded Reload
	cbnz	w0, LBB0_61
; %bb.60:
Lloh122:
	adrp	x8, _PANIC@GOTPAGE
Lloh123:
	ldr	x8, [x8, _PANIC@GOTPAGEOFF]
Lloh124:
	ldr	w0, [x8]
Lloh125:
	adrp	x1, l_.str.6@PAGE
Lloh126:
	add	x1, x1, l_.str.6@PAGEOFF
	bl	_elog
LBB0_61:
	ldp	x8, x9, [x25, #8]
	sub	x8, x8, #1
	str	x8, [x25, #8]
	lsl	x8, x19, #3
	ldr	x10, [x9, x8]
	sub	x10, x10, #1
	str	x10, [x9, x8]
Lloh127:
	adrp	x0, l_.str.8@PAGE
Lloh128:
	add	x0, x0, l_.str.8@PAGEOFF
	mov	x1, x25
	mov	x2, x19
	bl	_LOCK_PRINT
	ldr	x8, [x25, #8]
	cmp	x8, #1
	ldr	x21, [sp, #24]                  ; 8-byte Folded Reload
	b.lt	LBB0_63
; %bb.62:
	ldr	x8, [x25, #16]
	ldr	x8, [x8, x19, lsl #3]
	lsr	x8, x8, #63
	eor	w0, w8, #0x1
	b	LBB0_64
LBB0_63:
	mov	w0, #0
LBB0_64:
	bl	_Assert
	ldr	x8, [x25, #24]
	ldr	x9, [x25, #8]
	cmp	x8, x9
	cset	w0, le
	bl	_Assert
	mov	x0, x21
	bl	_LWLockRelease
	ldr	x8, [x22, #8]
	cbnz	x8, LBB0_66
; %bb.65:
	mov	x0, x22
	bl	_RemoveLocalLock
LBB0_66:
	cbz	x20, LBB0_68
; %bb.67:
	str	xzr, [x20]
LBB0_68:
Lloh129:
	adrp	x8, _LOCKACQUIRE_NOT_AVAIL@GOTPAGE
Lloh130:
	ldr	x8, [x8, _LOCKACQUIRE_NOT_AVAIL@GOTPAGEOFF]
LBB0_69:
	ldr	w0, [x8]
	ldp	x29, x30, [sp, #176]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #160]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #144]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #128]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #112]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #96]             ; 16-byte Folded Reload
	add	sp, sp, #192
	ret
	.loh AdrpLdrGot	Lloh0, Lloh1
	.loh AdrpAdd	Lloh5, Lloh6
	.loh AdrpLdrGotLdr	Lloh2, Lloh3, Lloh4
	.loh AdrpAdd	Lloh10, Lloh11
	.loh AdrpLdrGotLdr	Lloh7, Lloh8, Lloh9
	.loh AdrpLdrGotLdr	Lloh12, Lloh13, Lloh14
	.loh AdrpLdrGotLdr	Lloh21, Lloh22, Lloh23
	.loh AdrpLdrGotLdr	Lloh18, Lloh19, Lloh20
	.loh AdrpLdrGotLdr	Lloh15, Lloh16, Lloh17
	.loh AdrpAdd	Lloh32, Lloh33
	.loh AdrpAdd	Lloh30, Lloh31
	.loh AdrpLdrGotLdr	Lloh27, Lloh28, Lloh29
	.loh AdrpLdrGotLdr	Lloh24, Lloh25, Lloh26
	.loh AdrpLdrGotLdr	Lloh40, Lloh41, Lloh42
	.loh AdrpLdrGotLdr	Lloh37, Lloh38, Lloh39
	.loh AdrpLdrGotLdr	Lloh34, Lloh35, Lloh36
	.loh AdrpLdrGot	Lloh45, Lloh46
	.loh AdrpLdrGot	Lloh43, Lloh44
	.loh AdrpLdrGotLdr	Lloh47, Lloh48, Lloh49
	.loh AdrpLdrGotLdr	Lloh50, Lloh51, Lloh52
	.loh AdrpLdrGotLdr	Lloh53, Lloh54, Lloh55
	.loh AdrpLdrGot	Lloh56, Lloh57
	.loh AdrpLdrGotLdr	Lloh61, Lloh62, Lloh63
	.loh AdrpLdrGotLdr	Lloh58, Lloh59, Lloh60
	.loh AdrpLdrGotLdr	Lloh66, Lloh67, Lloh68
	.loh AdrpLdrGot	Lloh64, Lloh65
	.loh AdrpLdrGot	Lloh69, Lloh70
	.loh AdrpAdd	Lloh79, Lloh80
	.loh AdrpAdd	Lloh77, Lloh78
	.loh AdrpLdrGotLdr	Lloh74, Lloh75, Lloh76
	.loh AdrpLdrGotLdr	Lloh71, Lloh72, Lloh73
	.loh AdrpLdrGotLdr	Lloh81, Lloh82, Lloh83
	.loh AdrpAdd	Lloh92, Lloh93
	.loh AdrpAdd	Lloh90, Lloh91
	.loh AdrpLdrGotLdr	Lloh87, Lloh88, Lloh89
	.loh AdrpLdrGotLdr	Lloh84, Lloh85, Lloh86
	.loh AdrpLdrGot	Lloh94, Lloh95
	.loh AdrpLdrGotLdr	Lloh98, Lloh99, Lloh100
	.loh AdrpLdrGot	Lloh96, Lloh97
	.loh AdrpAdd	Lloh101, Lloh102
	.loh AdrpAdd	Lloh108, Lloh109
	.loh AdrpLdrGotLdr	Lloh105, Lloh106, Lloh107
	.loh AdrpAdd	Lloh103, Lloh104
	.loh AdrpAdd	Lloh110, Lloh111
	.loh AdrpLdrGot	Lloh112, Lloh113
	.loh AdrpLdrGot	Lloh114, Lloh115
	.loh AdrpLdrGotLdr	Lloh119, Lloh120, Lloh121
	.loh AdrpLdrGotLdr	Lloh116, Lloh117, Lloh118
	.loh AdrpAdd	Lloh125, Lloh126
	.loh AdrpLdrGotLdr	Lloh122, Lloh123, Lloh124
	.loh AdrpAdd	Lloh127, Lloh128
	.loh AdrpLdrGot	Lloh129, Lloh130
	.cfi_endproc
                                        ; -- End function
	.comm	_LockMethods,8,3                ; @LockMethods
	.comm	_ERROR,4,2                      ; @ERROR
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"unrecognized lock method: %d"

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

	.comm	_InRecovery,4,2                 ; @InRecovery
	.comm	_LOCKTAG_OBJECT,8,3             ; @LOCKTAG_OBJECT
	.comm	_LOCKTAG_RELATION,8,3           ; @LOCKTAG_RELATION
	.comm	_RowExclusiveLock,8,3           ; @RowExclusiveLock
	.comm	_ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE,4,2 ; @ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE
l_.str.2:                               ; @.str.2
	.asciz	"cannot acquire lock mode %s on database objects while recovery is in progress"

l_.str.3:                               ; @.str.3
	.asciz	"Only RowExclusiveLock or less can be acquired on database objects during recovery."

	.comm	_CurrentResourceOwner,8,3       ; @CurrentResourceOwner
	.comm	_LockMethodLocalHash,4,2        ; @LockMethodLocalHash
	.comm	_HASH_ENTER,4,2                 ; @HASH_ENTER
	.comm	_TopMemoryContext,4,2           ; @TopMemoryContext
	.comm	_LOCKACQUIRE_ALREADY_CLEAR,4,2  ; @LOCKACQUIRE_ALREADY_CLEAR
	.comm	_LOCKACQUIRE_ALREADY_HELD,4,2   ; @LOCKACQUIRE_ALREADY_HELD
	.comm	_AccessExclusiveLock,8,3        ; @AccessExclusiveLock
	.comm	_FastPathLocalUseCount,8,3      ; @FastPathLocalUseCount
	.comm	_FP_LOCK_SLOTS_PER_BACKEND,8,3  ; @FP_LOCK_SLOTS_PER_BACKEND
	.comm	_MyProc,8,3                     ; @MyProc
	.comm	_LW_EXCLUSIVE,4,2               ; @LW_EXCLUSIVE
	.comm	_FastPathStrongRelationLocks,8,3 ; @FastPathStrongRelationLocks
	.comm	_LOCKACQUIRE_OK,4,2             ; @LOCKACQUIRE_OK
	.comm	_ERRCODE_OUT_OF_MEMORY,4,2      ; @ERRCODE_OUT_OF_MEMORY
l_.str.4:                               ; @.str.4
	.asciz	"out of shared memory"

l_.str.5:                               ; @.str.5
	.asciz	"You might need to increase max_locks_per_transaction."

	.comm	_LOCKACQUIRE_NOT_AVAIL,4,2      ; @LOCKACQUIRE_NOT_AVAIL
	.comm	_STATUS_FOUND,4,2               ; @STATUS_FOUND
	.comm	_STATUS_OK,4,2                  ; @STATUS_OK
	.comm	_LockMethodProcLockHash,4,2     ; @LockMethodProcLockHash
	.comm	_HASH_REMOVE,4,2                ; @HASH_REMOVE
	.comm	_PANIC,4,2                      ; @PANIC
l_.str.6:                               ; @.str.6
	.asciz	"proclock table corrupted"

l_.str.7:                               ; @.str.7
	.asciz	"LockAcquire: NOWAIT"

l_.str.8:                               ; @.str.8
	.asciz	"LockAcquire: conditional lock failed"

l_.str.9:                               ; @.str.9
	.asciz	"LockAcquire: INCONSISTENT"

l_.str.10:                              ; @.str.10
	.asciz	"LockAcquire failed"

l_.str.11:                              ; @.str.11
	.asciz	"LockAcquire: granted"

	.comm	_LOG,4,2                        ; @LOG
.subsections_via_symbols
