	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function dm_integrity_map_continue
_dm_integrity_map_continue:             ## @dm_integrity_map_continue
	.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	$88, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%esi, %r15d
	movq	%rdi, %r13
	movq	72(%rdi), %r14
	movl	$80, %esi
	callq	_dm_bio_from_per_bio_data
	movq	%rax, %rbx
	cmpq	$0, 88(%r14)
	je	LBB0_1
## %bb.2:
	movq	64(%r13), %rax
	testq	%rax, %rax
	sete	%cl
	testl	%r15d, %r15d
	setne	-41(%rbp)                       ## 1-byte Folded Spill
	je	LBB0_4
## %bb.3:
	testq	%rax, %rax
	jne	LBB0_4
## %bb.59:
	movq	_integrity_bio_wait@GOTPCREL(%rip), %rsi
	movq	%r13, %rdi
	callq	_INIT_WORK
	movl	28(%r14), %edi
	movq	%r13, %rsi
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_queue_work                     ## TAILCALL
LBB0_1:
	testl	%r15d, %r15d
	setne	-41(%rbp)                       ## 1-byte Folded Spill
	xorl	%ecx, %ecx
LBB0_4:
	movl	%ecx, -76(%rbp)                 ## 4-byte Spill
	leaq	64(%r14), %r15
	leaq	8(%r13), %rax
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	leaq	4(%r14), %rax
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	leaq	-64(%rbp), %r12
	movq	%rbx, -88(%rbp)                 ## 8-byte Spill
	movq	%r15, -72(%rbp)                 ## 8-byte Spill
LBB0_5:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_6 Depth 2
                                        ##       Child Loop BB0_27 Depth 3
                                        ##     Child Loop BB0_14 Depth 2
	movq	%r15, %rdi
	callq	_spin_lock_irq
	.p2align	4, 0x90
LBB0_6:                                 ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_27 Depth 3
	movq	%r14, %rdi
	callq	_dm_integrity_failed
	movl	%eax, %edi
	callq	_unlikely
	testq	%rax, %rax
	jne	LBB0_7
## %bb.8:                               ##   in Loop: Header=BB0_6 Depth=2
	movq	%rbx, %rdi
	callq	_bio_sectors
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	movl	%eax, (%rcx)
	movq	_NOT_FOUND@GOTPCREL(%rip), %rax
	movl	(%rax), %r15d
	xorl	%edi, %edi
	cmpb	$74, (%r14)
	sete	%dil
	callq	_likely
	testq	%rax, %rax
	je	LBB0_30
## %bb.9:                               ##   in Loop: Header=BB0_6 Depth=2
	cmpq	$0, 64(%r13)
	je	LBB0_22
## %bb.10:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	%rbx, %r15
	movq	-56(%rbp), %rbx                 ## 8-byte Reload
	movl	(%rbx), %edi
	movq	40(%r14), %rax
	movq	80(%r14), %rsi
	movb	(%rax), %cl
	shlq	%cl, %rsi
	callq	_min
	movl	%eax, (%rbx)
	xorl	%edi, %edi
	testl	%eax, %eax
	sete	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_13
## %bb.11:                              ##   in Loop: Header=BB0_6 Depth=2
	cmpb	$0, -41(%rbp)                   ## 1-byte Folded Reload
	jne	LBB0_32
## %bb.12:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	%r14, %rdi
	callq	_sleep_on_endio_wait
	movq	%r15, %rbx
	jmp	LBB0_6
	.p2align	4, 0x90
LBB0_22:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	16(%r13), %rsi
	movq	%r14, %rdi
	movq	%r12, %rdx
	callq	_find_journal_node
	movl	%eax, %r15d
	xorl	%edi, %edi
	movq	_NOT_FOUND@GOTPCREL(%rip), %rax
	cmpl	(%rax), %r15d
	sete	%dil
	callq	_likely
	testq	%rax, %rax
	je	LBB0_25
## %bb.23:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	-64(%rbp), %rax
	subq	16(%r13), %rax
	movl	8(%r13), %ecx
	xorl	%edi, %edi
	cmpq	%rcx, %rax
	setl	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_30
## %bb.24:                              ##   in Loop: Header=BB0_6 Depth=2
	movl	-64(%rbp), %ebx
	subl	16(%r13), %ebx
	jmp	LBB0_29
LBB0_25:                                ##   in Loop: Header=BB0_6 Depth=2
	movl	20(%r14), %ebx
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	cmpl	(%rax), %ebx
	jae	LBB0_29
## %bb.26:                              ##   in Loop: Header=BB0_6 Depth=2
	leal	1(%r15), %r12d
	.p2align	4, 0x90
LBB0_27:                                ##   Parent Loop BB0_5 Depth=1
                                        ##     Parent Loop BB0_6 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movl	%ebx, %edx
	addq	16(%r13), %rdx
	movq	%r14, %rdi
	movl	%r12d, %esi
	callq	_test_journal_node
	testl	%eax, %eax
	je	LBB0_29
## %bb.28:                              ##   in Loop: Header=BB0_27 Depth=3
	addl	20(%r14), %ebx
	incl	%r12d
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	cmpl	(%rax), %ebx
	jb	LBB0_27
LBB0_29:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	movl	%ebx, (%rax)
	movq	-88(%rbp), %rbx                 ## 8-byte Reload
	leaq	-64(%rbp), %r12
LBB0_30:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	%r14, %rdi
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	movl	$1, %edx
	callq	_add_new_range
	xorl	%edi, %edi
	testl	%eax, %eax
	sete	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_38
## %bb.31:                              ##   in Loop: Header=BB0_6 Depth=2
	cmpb	$0, -41(%rbp)                   ## 1-byte Folded Reload
	jne	LBB0_32
## %bb.33:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	_NOT_FOUND@GOTPCREL(%rip), %rax
	cmpl	(%rax), %r15d
	je	LBB0_35
## %bb.34:                              ##   in Loop: Header=BB0_6 Depth=2
	movl	20(%r14), %eax
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	movl	%eax, (%rcx)
LBB0_35:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	%r14, %rdi
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	callq	_wait_and_add_new_range
	movq	_NOT_FOUND@GOTPCREL(%rip), %rax
	cmpl	(%rax), %r15d
	je	LBB0_38
## %bb.36:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	16(%r13), %rsi
	movq	%r14, %rdi
	movq	%r12, %rdx
	callq	_find_journal_node
	xorl	%edi, %edi
	cmpl	%r15d, %eax
	setne	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_38
## %bb.37:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	%r14, %rdi
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	callq	_remove_range_unlocked
	jmp	LBB0_6
	.p2align	4, 0x90
LBB0_38:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	callq	_spin_unlock_irq
	xorl	%edi, %edi
	movq	_NOT_FOUND@GOTPCREL(%rip), %rax
	cmpl	(%rax), %r15d
	setne	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_40
## %bb.39:                              ##   in Loop: Header=BB0_5 Depth=1
	movl	%r15d, %eax
	xorl	%edx, %edx
	divl	12(%r14)
	movl	%edx, %ecx
	movl	%eax, %edx
	movq	-72(%rbp), %r15                 ## 8-byte Reload
LBB0_20:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	%r13, %rdi
	movq	%rbx, %rsi
                                        ## kill: def $edx killed $edx killed $rdx
                                        ## kill: def $ecx killed $ecx killed $rcx
	callq	___journal_read_write
	movl	%eax, %edi
	callq	_unlikely
	testq	%rax, %rax
	jne	LBB0_5
	jmp	LBB0_21
LBB0_13:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	%r13, -96(%rbp)                 ## 8-byte Spill
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	movl	(%rax), %eax
	movq	40(%r14), %rcx
	movb	(%rcx), %cl
	shrq	%cl, %rax
	subq	%rax, 80(%r14)
	movl	4(%r14), %ebx
	movl	8(%r14), %r15d
	addl	%r15d, %eax
	xorl	%edx, %edx
	divl	12(%r14)
                                        ## kill: def $eax killed $eax def $rax
	xorl	%r12d, %r12d
	movl	%edx, 8(%r14)
	leal	(%rax,%rbx), %ecx
	movl	%ecx, 4(%r14)
	addl	%eax, 16(%r14)
	movq	%r14, %rdi
	movq	-120(%rbp), %rsi                ## 8-byte Reload
	callq	_wraparound_section
	movl	12(%r14), %r13d
	imull	%ebx, %r13d
	addl	%r15d, %r13d
	movq	%rbx, -104(%rbp)                ## 8-byte Spill
	movl	%ebx, -64(%rbp)
	movq	%r15, -112(%rbp)                ## 8-byte Spill
                                        ## kill: def $r15d killed $r15d killed $r15
	jmp	LBB0_14
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_14 Depth=2
	addl	20(%r14), %r12d
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	cmpl	(%rax), %r12d
	jae	LBB0_19
LBB0_14:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	%r13d, %esi
	shlq	$2, %rsi
	addq	72(%r14), %rsi
	movl	%r12d, %edx
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	addq	16(%rax), %rdx
	movq	%r14, %rdi
	callq	_add_journal_node
	incl	%r13d
	xorl	%edi, %edi
	cmpl	24(%r14), %r13d
	setae	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_16
## %bb.15:                              ##   in Loop: Header=BB0_14 Depth=2
	xorl	%r13d, %r13d
LBB0_16:                                ##   in Loop: Header=BB0_14 Depth=2
	movl	-64(%rbp), %esi
	movq	%r14, %rdi
	movl	%r15d, %edx
	callq	_access_journal_entry
	movq	%rax, %rbx
	movq	%rax, %rdi
	callq	_journal_entry_is_unused
	xorl	%edi, %edi
	testl	%eax, %eax
	sete	%dil
	callq	_BUG_ON
	movq	%rbx, %rdi
	callq	_journal_entry_set_inprogress
	incl	%r15d
	xorl	%edi, %edi
	cmpl	12(%r14), %r15d
	sete	%dil
	callq	_unlikely
	testq	%rax, %rax
	je	LBB0_18
## %bb.17:                              ##   in Loop: Header=BB0_14 Depth=2
	incl	-64(%rbp)
	movq	%r14, %rdi
	leaq	-64(%rbp), %rsi
	callq	_wraparound_section
	xorl	%r15d, %r15d
	jmp	LBB0_18
LBB0_19:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	movq	%r15, %rdi
	callq	_spin_unlock_irq
	movq	-96(%rbp), %r13                 ## 8-byte Reload
	movq	-88(%rbp), %rbx                 ## 8-byte Reload
	leaq	-64(%rbp), %r12
	movq	-112(%rbp), %rcx                ## 8-byte Reload
	movq	-104(%rbp), %rdx                ## 8-byte Reload
	jmp	LBB0_20
LBB0_7:
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	callq	_spin_unlock_irq
	movq	%r14, %rdi
	movq	%rbx, %rsi
	callq	_do_endio
	jmp	LBB0_58
LBB0_32:
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	callq	_spin_unlock_irq
	movq	_integrity_bio_wait@GOTPCREL(%rip), %rsi
	movq	%r13, %rdi
	callq	_INIT_WORK
	movl	68(%r14), %edi
LBB0_56:
	movq	%r13, %rsi
LBB0_57:
	callq	_queue_work
LBB0_58:
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_21:
	movq	%r14, %rdi
	movq	%r13, %rsi
	callq	_do_endio_flush
	jmp	LBB0_58
LBB0_40:
	cmpb	$66, (%r14)
	jne	LBB0_44
## %bb.41:
	cmpq	$0, 64(%r13)
	je	LBB0_44
## %bb.42:
	movl	60(%r14), %esi
	movq	16(%r13), %rdx
	movl	8(%r13), %ecx
	movq	_BITMAP_OP_TEST_ALL_SET@GOTPCREL(%rip), %rax
	movl	(%rax), %r8d
	movq	%r14, %rdi
	callq	_block_bitmap_op
	testl	%eax, %eax
	je	LBB0_43
LBB0_44:
	movl	$2, %edi
	callq	_ATOMIC_INIT
	movq	%rax, 56(%r13)
	cmpb	$0, -76(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_45
## %bb.46:
	movq	%r12, %rdi
	callq	_init_completion
	jmp	LBB0_47
LBB0_45:
	xorl	%r12d, %r12d
LBB0_47:
	movq	%r12, 48(%r13)
	movl	4(%rbx), %eax
	movl	%eax, 40(%r13)
	movl	28(%rbx), %eax
	movl	%eax, 36(%r13)
	movl	24(%rbx), %eax
	movl	%eax, 32(%r13)
	movq	48(%r14), %rax
	movl	(%rax), %esi
	movq	%rbx, %rdi
	callq	_bio_set_dev
	movq	%rbx, %rdi
	callq	_bio_integrity
	movl	%eax, 28(%r13)
	movq	$0, 16(%rbx)
	movq	_REQ_INTEGRITY@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	notl	%eax
	andl	%eax, 12(%rbx)
	movl	8(%rbx), %eax
	movl	%eax, 24(%r13)
	movq	_integrity_end_io@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movl	%eax, 8(%rbx)
	movl	8(%r13), %eax
	movq	_SECTOR_SHIFT@GOTPCREL(%rip), %rcx
	movb	(%rcx), %cl
	shll	%cl, %eax
	movl	%eax, 4(%rbx)
	movq	%rbx, %rdi
	callq	_generic_make_request
	cmpb	$0, -76(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_55
## %bb.48:
	leaq	-64(%rbp), %rdi
	callq	_wait_for_completion_io
	movq	40(%r14), %rax
	movl	8(%rax), %r15d
	movq	_SB_FLAG_RECALCULATING@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_cpu_to_le32
	testl	%r15d, %eax
	je	LBB0_50
## %bb.49:
	movl	8(%r13), %r15d
	addq	16(%r13), %r15
	movq	40(%r14), %rax
	movl	12(%rax), %edi
	callq	_le64_to_cpu
	cmpq	%rax, %r15
	jg	LBB0_54
LBB0_50:
	cmpb	$66, (%r14)
	jne	LBB0_52
## %bb.51:
	movl	32(%r14), %esi
	movq	16(%r13), %rdx
	movl	8(%r13), %ecx
	movq	_BITMAP_OP_TEST_ALL_CLEAR@GOTPCREL(%rip), %rax
	movl	(%rax), %r8d
	movq	%r14, %rdi
	callq	_block_bitmap_op
	testl	%eax, %eax
	je	LBB0_54
LBB0_52:
	xorl	%edi, %edi
	cmpl	$0, (%rbx)
	sete	%dil
	callq	_likely
	testq	%rax, %rax
	je	LBB0_54
## %bb.53:
	movq	%r13, %rdi
	callq	_integrity_metadata
	jmp	LBB0_58
LBB0_55:
	movq	_integrity_metadata@GOTPCREL(%rip), %rsi
	movq	%r13, %rdi
	callq	_INIT_WORK
	movl	28(%r14), %edi
	jmp	LBB0_56
LBB0_54:
	movq	%r13, %rdi
	callq	_dec_in_flight
	jmp	LBB0_58
LBB0_43:
	movq	16(%r13), %rsi
	movq	%r14, %rdi
	callq	_sector_to_bitmap_block
	movq	%rbx, %r12
	movq	%rax, %rbx
	leaq	4(%rax), %r15
	movq	%r15, %rdi
	callq	_spin_lock
	leaq	8(%rbx), %rdi
	movq	%r12, %rsi
	callq	_bio_list_add
	movq	%r15, %rdi
	callq	_spin_unlock
	movl	56(%r14), %edi
	movq	%rbx, %rsi
	jmp	LBB0_57
	.cfi_endproc
                                        ## -- End function
	.comm	_NOT_FOUND,4,2                  ## @NOT_FOUND
	.comm	_BITMAP_OP_TEST_ALL_SET,4,2     ## @BITMAP_OP_TEST_ALL_SET
	.comm	_REQ_INTEGRITY,4,2              ## @REQ_INTEGRITY
	.comm	_integrity_end_io,4,2           ## @integrity_end_io
	.comm	_SECTOR_SHIFT,4,2               ## @SECTOR_SHIFT
	.comm	_SB_FLAG_RECALCULATING,4,2      ## @SB_FLAG_RECALCULATING
	.comm	_BITMAP_OP_TEST_ALL_CLEAR,4,2   ## @BITMAP_OP_TEST_ALL_CLEAR
	.no_dead_strip	_dm_integrity_map_continue
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function dm_integrity_map_continue
_dm_integrity_map_continue:             ; @dm_integrity_map_continue
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #144
	.cfi_def_cfa_offset 144
	stp	x28, x27, [sp, #48]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #64]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #80]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #96]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #112]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #128]            ; 16-byte Folded Spill
	add	x29, sp, #128
	.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	x22, x1
	mov	x19, x0
	ldr	x20, [x0, #72]
	mov	w1, #80
	bl	_dm_bio_from_per_bio_data
	mov	x21, x0
	ldr	x8, [x20, #88]
	cbz	x8, LBB0_4
; %bb.1:
	ldr	x8, [x19, #64]
	cmp	x8, #0
	cset	w28, eq
	cmp	w22, #0
	cset	w24, ne
	cbz	w22, LBB0_5
; %bb.2:
	cbnz	x8, LBB0_5
; %bb.3:
Lloh0:
	adrp	x1, _integrity_bio_wait@GOTPAGE
Lloh1:
	ldr	x1, [x1, _integrity_bio_wait@GOTPAGEOFF]
	mov	x0, x19
	bl	_INIT_WORK
	ldr	w0, [x20, #28]
	mov	x1, x19
	ldp	x29, x30, [sp, #128]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #112]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #96]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #80]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #64]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #48]             ; 16-byte Folded Reload
	add	sp, sp, #144
	b	_queue_work
LBB0_4:
	mov	w28, #0
	cmp	w22, #0
	cset	w24, ne
LBB0_5:
	add	x25, x20, #64
	add	x23, x19, #8
	add	x8, x20, #4
	str	x8, [sp, #24]                   ; 8-byte Folded Spill
Lloh2:
	adrp	x22, _NOT_FOUND@GOTPAGE
Lloh3:
	ldr	x22, [x22, _NOT_FOUND@GOTPAGEOFF]
	str	x25, [sp, #32]                  ; 8-byte Folded Spill
LBB0_6:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_7 Depth 2
                                        ;       Child Loop BB0_18 Depth 3
                                        ;     Child Loop BB0_33 Depth 2
	mov	x0, x25
	bl	_spin_lock_irq
LBB0_7:                                 ;   Parent Loop BB0_6 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_18 Depth 3
	mov	x0, x20
	bl	_dm_integrity_failed
	bl	_unlikely
	cbnz	x0, LBB0_36
; %bb.8:                                ;   in Loop: Header=BB0_7 Depth=2
	mov	x0, x21
	bl	_bio_sectors
	str	w0, [x23]
	ldr	w25, [x22]
	ldrb	w8, [x20]
	cmp	w8, #74
	cset	w0, eq
	bl	_likely
	cbz	x0, LBB0_21
; %bb.9:                                ;   in Loop: Header=BB0_7 Depth=2
	ldr	x8, [x19, #64]
	cbz	x8, LBB0_13
; %bb.10:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	w0, [x23]
	ldr	x8, [x20, #80]
	ldr	x9, [x20, #40]
	ldr	x9, [x9]
	lsl	x1, x8, x9
	bl	_min
	str	w0, [x23]
	cmp	w0, #0
	cset	w0, eq
	bl	_unlikely
	cbz	x0, LBB0_31
; %bb.11:                               ;   in Loop: Header=BB0_7 Depth=2
	cbnz	w24, LBB0_37
; %bb.12:                               ;   in Loop: Header=BB0_7 Depth=2
	mov	x0, x20
	bl	_sleep_on_endio_wait
	b	LBB0_7
LBB0_13:                                ;   in Loop: Header=BB0_7 Depth=2
	ldr	x1, [x19, #16]
	add	x2, sp, #40
	mov	x0, x20
	bl	_find_journal_node
	mov	x25, x0
	ldr	w8, [x22]
	cmp	w0, w8
	cset	w0, eq
	bl	_likely
	cbz	x0, LBB0_16
; %bb.14:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	w8, [x19, #8]
	ldr	x9, [sp, #40]
	ldr	x10, [x19, #16]
	sub	x9, x9, x10
	cmp	x9, x8
	cset	w0, lt
	bl	_unlikely
	cbz	x0, LBB0_21
; %bb.15:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	w8, [sp, #40]
	ldr	w9, [x19, #16]
	sub	w27, w8, w9
	b	LBB0_20
LBB0_16:                                ;   in Loop: Header=BB0_7 Depth=2
	ldr	w27, [x20, #20]
	ldr	w8, [x23]
	cmp	w27, w8
	b.hs	LBB0_20
; %bb.17:                               ;   in Loop: Header=BB0_7 Depth=2
	add	w26, w25, #1
LBB0_18:                                ;   Parent Loop BB0_6 Depth=1
                                        ;     Parent Loop BB0_7 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	x8, [x19, #16]
	add	x2, x8, w27, uxtw
	mov	x0, x20
	mov	x1, x26
	bl	_test_journal_node
	cbz	w0, LBB0_20
; %bb.19:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x20, #20]
	ldr	w9, [x23]
	add	w26, w26, #1
	add	w27, w8, w27
	cmp	w27, w9
	b.lo	LBB0_18
LBB0_20:                                ;   in Loop: Header=BB0_7 Depth=2
	str	w27, [x23]
LBB0_21:                                ;   in Loop: Header=BB0_7 Depth=2
	mov	x0, x20
	mov	x1, x23
	mov	w2, #1
	bl	_add_new_range
	cmp	w0, #0
	cset	w0, eq
	bl	_unlikely
	cbz	x0, LBB0_28
; %bb.22:                               ;   in Loop: Header=BB0_7 Depth=2
	cbnz	w24, LBB0_37
; %bb.23:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	w8, [x22]
	cmp	w25, w8
	b.eq	LBB0_25
; %bb.24:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	w8, [x20, #20]
	str	w8, [x23]
LBB0_25:                                ;   in Loop: Header=BB0_7 Depth=2
	mov	x0, x20
	mov	x1, x23
	bl	_wait_and_add_new_range
	ldr	w8, [x22]
	cmp	w25, w8
	b.eq	LBB0_28
; %bb.26:                               ;   in Loop: Header=BB0_7 Depth=2
	ldr	x1, [x19, #16]
	add	x2, sp, #40
	mov	x0, x20
	bl	_find_journal_node
	cmp	w0, w25
	cset	w0, ne
	bl	_unlikely
	cbz	x0, LBB0_28
; %bb.27:                               ;   in Loop: Header=BB0_7 Depth=2
	mov	x0, x20
	mov	x1, x23
	bl	_remove_range_unlocked
	b	LBB0_7
LBB0_28:                                ;   in Loop: Header=BB0_6 Depth=1
	ldr	x0, [sp, #32]                   ; 8-byte Folded Reload
	bl	_spin_unlock_irq
	ldr	w8, [x22]
	cmp	w25, w8
	cset	w0, ne
	bl	_unlikely
	cbz	x0, LBB0_41
; %bb.29:                               ;   in Loop: Header=BB0_6 Depth=1
	ldr	w8, [x20, #12]
	udiv	w2, w25, w8
	msub	w3, w2, w8, w25
	ldr	x25, [sp, #32]                  ; 8-byte Folded Reload
LBB0_30:                                ;   in Loop: Header=BB0_6 Depth=1
	mov	x0, x19
	mov	x1, x21
	bl	___journal_read_write
	bl	_unlikely
	cbnz	x0, LBB0_6
	b	LBB0_40
LBB0_31:                                ;   in Loop: Header=BB0_6 Depth=1
	str	w28, [sp, #20]                  ; 4-byte Folded Spill
	ldr	w8, [x23]
	ldr	x9, [x20, #40]
	ldr	w9, [x9]
	lsr	x8, x8, x9
	ldr	x9, [x20, #80]
	sub	x9, x9, x8
	str	x9, [x20, #80]
	ldp	w27, w28, [x20, #4]
	add	w8, w28, w8
	ldp	w9, w10, [x20, #12]
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	add	w9, w11, w27
	stp	w9, w8, [x20, #4]
	add	w8, w10, w11
	str	w8, [x20, #16]
	mov	x0, x20
	ldr	x1, [sp, #24]                   ; 8-byte Folded Reload
	bl	_wraparound_section
	mov	w25, #0
	ldr	w8, [x20, #12]
	madd	w26, w8, w27, w28
	stp	w28, w27, [sp, #12]             ; 8-byte Folded Spill
	str	w27, [sp, #40]
	mov	x27, x28
	b	LBB0_33
LBB0_32:                                ;   in Loop: Header=BB0_33 Depth=2
	ldr	w8, [x20, #20]
	ldr	w9, [x23]
	add	w25, w8, w25
	cmp	w25, w9
	b.hs	LBB0_35
LBB0_33:                                ;   Parent Loop BB0_6 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [x20, #72]
	add	x1, x8, w26, uxtw #2
	ldr	x8, [x19, #16]
	add	x2, x8, w25, uxtw
	mov	x0, x20
	bl	_add_journal_node
	add	w8, w26, #1
	ldr	w9, [x20, #24]
	cmp	w8, w9
	cset	w0, hs
	bl	_unlikely
	cmp	x0, #0
	csinc	w26, wzr, w26, ne
	ldr	w1, [sp, #40]
	mov	x0, x20
	mov	x2, x27
	bl	_access_journal_entry
	mov	x28, x0
	bl	_journal_entry_is_unused
	cmp	w0, #0
	cset	w0, eq
	bl	_BUG_ON
	mov	x0, x28
	bl	_journal_entry_set_inprogress
	add	w27, w27, #1
	ldr	w8, [x20, #12]
	cmp	w27, w8
	cset	w0, eq
	bl	_unlikely
	cbz	x0, LBB0_32
; %bb.34:                               ;   in Loop: Header=BB0_33 Depth=2
	ldr	w8, [sp, #40]
	add	w8, w8, #1
	str	w8, [sp, #40]
	add	x1, sp, #40
	mov	x0, x20
	bl	_wraparound_section
	mov	w27, #0
	b	LBB0_32
LBB0_35:                                ;   in Loop: Header=BB0_6 Depth=1
	ldr	x25, [sp, #32]                  ; 8-byte Folded Reload
	mov	x0, x25
	bl	_spin_unlock_irq
	ldp	w2, w28, [sp, #16]              ; 8-byte Folded Reload
	ldr	w3, [sp, #12]                   ; 4-byte Folded Reload
	b	LBB0_30
LBB0_36:
	ldr	x0, [sp, #32]                   ; 8-byte Folded Reload
	bl	_spin_unlock_irq
	mov	x0, x20
	mov	x1, x21
	bl	_do_endio
	b	LBB0_39
LBB0_37:
	ldr	x0, [sp, #32]                   ; 8-byte Folded Reload
	bl	_spin_unlock_irq
Lloh4:
	adrp	x1, _integrity_bio_wait@GOTPAGE
Lloh5:
	ldr	x1, [x1, _integrity_bio_wait@GOTPAGEOFF]
	mov	x0, x19
	bl	_INIT_WORK
	ldr	w0, [x20, #68]
LBB0_38:
	mov	x1, x19
	bl	_queue_work
LBB0_39:
	ldp	x29, x30, [sp, #128]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #112]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #96]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #80]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #64]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #48]             ; 16-byte Folded Reload
	add	sp, sp, #144
	ret
LBB0_40:
	mov	x0, x20
	mov	x1, x19
	bl	_do_endio_flush
	b	LBB0_39
LBB0_41:
	ldrb	w8, [x20]
	cmp	w8, #66
	b.ne	LBB0_44
; %bb.42:
	ldr	x8, [x19, #64]
	cbz	x8, LBB0_44
; %bb.43:
	ldr	w1, [x20, #60]
	ldr	x2, [x19, #16]
	ldr	w3, [x19, #8]
Lloh6:
	adrp	x8, _BITMAP_OP_TEST_ALL_SET@GOTPAGE
Lloh7:
	ldr	x8, [x8, _BITMAP_OP_TEST_ALL_SET@GOTPAGEOFF]
Lloh8:
	ldr	w4, [x8]
	mov	x0, x20
	bl	_block_bitmap_op
	cbz	w0, LBB0_56
LBB0_44:
	mov	w0, #2
	bl	_ATOMIC_INIT
	str	x0, [x19, #56]
	cbz	w28, LBB0_46
; %bb.45:
	add	x22, sp, #40
	add	x0, sp, #40
	bl	_init_completion
	b	LBB0_47
LBB0_46:
	mov	x22, #0
LBB0_47:
	str	x22, [x19, #48]
	ldr	w8, [x21, #4]
	str	w8, [x19, #40]
	ldr	d0, [x21, #24]
	str	d0, [x19, #32]
	ldr	x8, [x20, #48]
	ldr	w1, [x8]
	mov	x0, x21
	bl	_bio_set_dev
	mov	x0, x21
	bl	_bio_integrity
Lloh9:
	adrp	x8, _REQ_INTEGRITY@GOTPAGE
Lloh10:
	ldr	x8, [x8, _REQ_INTEGRITY@GOTPAGEOFF]
	str	w0, [x19, #28]
Lloh11:
	ldr	w8, [x8]
	ldp	w10, w9, [x21, #8]
	bic	w8, w9, w8
	str	xzr, [x21, #16]
	str	w8, [x21, #12]
	str	w10, [x19, #24]
Lloh12:
	adrp	x8, _integrity_end_io@GOTPAGE
Lloh13:
	ldr	x8, [x8, _integrity_end_io@GOTPAGEOFF]
Lloh14:
	ldr	w8, [x8]
	str	w8, [x21, #8]
	ldr	w8, [x19, #8]
Lloh15:
	adrp	x9, _SECTOR_SHIFT@GOTPAGE
Lloh16:
	ldr	x9, [x9, _SECTOR_SHIFT@GOTPAGEOFF]
Lloh17:
	ldr	w9, [x9]
	lsl	w8, w8, w9
	str	w8, [x21, #4]
	mov	x0, x21
	bl	_generic_make_request
	cbz	w28, LBB0_54
; %bb.48:
	add	x0, sp, #40
	bl	_wait_for_completion_io
	ldr	x8, [x20, #40]
	ldr	w22, [x8, #8]
Lloh18:
	adrp	x8, _SB_FLAG_RECALCULATING@GOTPAGE
Lloh19:
	ldr	x8, [x8, _SB_FLAG_RECALCULATING@GOTPAGEOFF]
Lloh20:
	ldr	w0, [x8]
	bl	_cpu_to_le32
	tst	w0, w22
	b.eq	LBB0_50
; %bb.49:
	ldr	x8, [x19, #16]
	ldr	w9, [x19, #8]
	add	x22, x8, x9
	ldr	x8, [x20, #40]
	ldr	w0, [x8, #12]
	bl	_le64_to_cpu
	cmp	x22, x0
	b.gt	LBB0_55
LBB0_50:
	ldrb	w8, [x20]
	cmp	w8, #66
	b.ne	LBB0_52
; %bb.51:
	ldr	w1, [x20, #32]
	ldr	x2, [x19, #16]
	ldr	w3, [x19, #8]
Lloh21:
	adrp	x8, _BITMAP_OP_TEST_ALL_CLEAR@GOTPAGE
Lloh22:
	ldr	x8, [x8, _BITMAP_OP_TEST_ALL_CLEAR@GOTPAGEOFF]
Lloh23:
	ldr	w4, [x8]
	mov	x0, x20
	bl	_block_bitmap_op
	cbz	w0, LBB0_55
LBB0_52:
	ldr	w8, [x21]
	cmp	w8, #0
	cset	w0, eq
	bl	_likely
	cbz	x0, LBB0_55
; %bb.53:
	mov	x0, x19
	bl	_integrity_metadata
	b	LBB0_39
LBB0_54:
Lloh24:
	adrp	x1, _integrity_metadata@GOTPAGE
Lloh25:
	ldr	x1, [x1, _integrity_metadata@GOTPAGEOFF]
	mov	x0, x19
	bl	_INIT_WORK
	ldr	w0, [x20, #28]
	b	LBB0_38
LBB0_55:
	mov	x0, x19
	bl	_dec_in_flight
	b	LBB0_39
LBB0_56:
	ldr	x1, [x19, #16]
	mov	x0, x20
	bl	_sector_to_bitmap_block
	mov	x19, x0
	add	x22, x0, #4
	mov	x0, x22
	bl	_spin_lock
	add	x0, x19, #8
	mov	x1, x21
	bl	_bio_list_add
	mov	x0, x22
	bl	_spin_unlock
	ldr	w0, [x20, #56]
	b	LBB0_38
	.loh AdrpLdrGot	Lloh0, Lloh1
	.loh AdrpLdrGot	Lloh2, Lloh3
	.loh AdrpLdrGot	Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh6, Lloh7, Lloh8
	.loh AdrpLdrGotLdr	Lloh15, Lloh16, Lloh17
	.loh AdrpLdrGotLdr	Lloh12, Lloh13, Lloh14
	.loh AdrpLdrGotLdr	Lloh9, Lloh10, Lloh11
	.loh AdrpLdrGotLdr	Lloh18, Lloh19, Lloh20
	.loh AdrpLdrGotLdr	Lloh21, Lloh22, Lloh23
	.loh AdrpLdrGot	Lloh24, Lloh25
	.cfi_endproc
                                        ; -- End function
	.comm	_NOT_FOUND,4,2                  ; @NOT_FOUND
	.comm	_BITMAP_OP_TEST_ALL_SET,4,2     ; @BITMAP_OP_TEST_ALL_SET
	.comm	_REQ_INTEGRITY,4,2              ; @REQ_INTEGRITY
	.comm	_integrity_end_io,4,2           ; @integrity_end_io
	.comm	_SECTOR_SHIFT,4,2               ; @SECTOR_SHIFT
	.comm	_SB_FLAG_RECALCULATING,4,2      ; @SB_FLAG_RECALCULATING
	.comm	_BITMAP_OP_TEST_ALL_CLEAR,4,2   ; @BITMAP_OP_TEST_ALL_CLEAR
	.no_dead_strip	_dm_integrity_map_continue
.subsections_via_symbols
