	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function kmemcheck_copy
_kmemcheck_copy:                        ## @kmemcheck_copy
	.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	$104, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%ecx, %r15d
	movq	%rdx, -96(%rbp)                 ## 8-byte Spill
	movq	%rsi, %r13
	movq	%rdi, -136(%rbp)                ## 8-byte Spill
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movl	%ecx, %ebx
	xorl	%edi, %edi
	cmpl	$33, %ecx
	setae	%dil
	callq	_BUG_ON
	movq	_PAGE_MASK@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	leaq	(%rbx,%r13), %r12
	decq	%r12
	andq	%rax, %r12
	andq	%r13, %rax
	movq	%rbx, -104(%rbp)                ## 8-byte Spill
	leaq	-1(%rbx), %r14
	xorl	%edi, %edi
	cmpq	%r12, %rax
	sete	%dil
	callq	_likely
	testq	%rax, %rax
	movl	%r15d, -84(%rbp)                ## 4-byte Spill
	movq	%r13, -128(%rbp)                ## 8-byte Spill
	je	LBB0_29
## %bb.1:
	movq	%r13, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_2
## %bb.14:
	movq	%rax, %rbx
	movq	%r13, %rdi
	callq	_kmemcheck_save_addr
	testl	%r15d, %r15d
	movq	%r14, %r15
	movq	-104(%rbp), %r12                ## 8-byte Reload
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	je	LBB0_78
## %bb.15:
	xorl	%eax, %eax
	cmpl	$8, -84(%rbp)                   ## 4-byte Folded Reload
	jb	LBB0_25
## %bb.16:
	leaq	-80(%rbp), %rcx
	subq	%rbx, %rcx
	cmpq	$32, %rcx
	jb	LBB0_25
## %bb.17:
	movl	%r12d, %eax
	andl	$-8, %eax
	leaq	-8(%rax), %rsi
	movq	%rsi, %rdx
	shrq	$3, %rdx
	incq	%rdx
	movl	%edx, %ecx
	andl	$3, %ecx
	cmpq	$24, %rsi
	jae	LBB0_19
## %bb.18:
	xorl	%esi, %esi
	jmp	LBB0_21
LBB0_29:
	movq	%r12, -120(%rbp)                ## 8-byte Spill
	subq	%r13, %r12
	movq	%r13, %r15
	movl	%r12d, %r13d
	xorl	%edi, %edi
	cmpq	$33, %r13
	setae	%dil
	callq	_BUG_ON
	movq	%r15, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_30
## %bb.37:
	movq	%rax, %rbx
	movq	%r15, %rdi
	callq	_kmemcheck_save_addr
	testl	%r12d, %r12d
	movq	%r14, %r8
	movq	-96(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_47
## %bb.38:
	xorl	%eax, %eax
	cmpl	$8, %r13d
	jb	LBB0_43
## %bb.39:
	leaq	-80(%rbp), %rcx
	subq	%rbx, %rcx
	cmpq	$32, %rcx
	jb	LBB0_43
## %bb.40:
	movl	%r12d, %ecx
	andl	$7, %ecx
	movq	%r13, %rax
	subq	%rcx, %rax
	xorl	%edx, %edx
	.p2align	4, 0x90
LBB0_41:                                ## =>This Inner Loop Header: Depth=1
	movdqu	(%rbx,%rdx,4), %xmm0
	movups	16(%rbx,%rdx,4), %xmm1
	movdqa	%xmm0, -80(%rbp,%rdx,4)
	movaps	%xmm1, -64(%rbp,%rdx,4)
	addq	$8, %rdx
	cmpq	%rdx, %rax
	jne	LBB0_41
## %bb.42:
	testq	%rcx, %rcx
	je	LBB0_47
LBB0_43:
	movl	%r12d, %edx
	subl	%eax, %edx
	movq	%rax, %rcx
	notq	%rcx
	addq	%r13, %rcx
	andq	$3, %rdx
	je	LBB0_45
	.p2align	4, 0x90
LBB0_44:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rbx,%rax,4), %esi
	movl	%esi, -80(%rbp,%rax,4)
	incq	%rax
	decq	%rdx
	jne	LBB0_44
LBB0_45:
	cmpq	$3, %rcx
	jb	LBB0_47
	.p2align	4, 0x90
LBB0_46:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rbx,%rax,4), %ecx
	movl	%ecx, -80(%rbp,%rax,4)
	movl	4(%rbx,%rax,4), %ecx
	movl	%ecx, -76(%rbp,%rax,4)
	movl	8(%rbx,%rax,4), %ecx
	movl	%ecx, -72(%rbp,%rax,4)
	movl	12(%rbx,%rax,4), %ecx
	movl	%ecx, -68(%rbp,%rax,4)
	addq	$4, %rax
	cmpq	%rax, %r13
	jne	LBB0_46
	jmp	LBB0_47
LBB0_2:
	testl	%r15d, %r15d
	movq	%r14, %r15
	movq	-104(%rbp), %r12                ## 8-byte Reload
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	je	LBB0_78
## %bb.3:
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	$8, -84(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_5
## %bb.4:
	xorl	%ecx, %ecx
	jmp	LBB0_13
LBB0_30:
	testl	%r12d, %r12d
	movq	%r14, %r8
	movq	-96(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_47
## %bb.31:
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	$8, %r13d
	jae	LBB0_33
## %bb.32:
	xorl	%ecx, %ecx
	jmp	LBB0_36
LBB0_5:
	movl	%r12d, %ecx
	andl	$-8, %ecx
	movd	%eax, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	leaq	-8(%rcx), %rdi
	movq	%rdi, %rsi
	shrq	$3, %rsi
	incq	%rsi
	movl	%esi, %edx
	andl	$7, %edx
	cmpq	$56, %rdi
	jae	LBB0_7
## %bb.6:
	xorl	%edi, %edi
	jmp	LBB0_9
LBB0_19:
	andq	$-4, %rdx
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_20:                                ## =>This Inner Loop Header: Depth=1
	movups	(%rbx,%rsi,4), %xmm0
	movups	16(%rbx,%rsi,4), %xmm1
	movaps	%xmm0, -80(%rbp,%rsi,4)
	movaps	%xmm1, -64(%rbp,%rsi,4)
	movups	32(%rbx,%rsi,4), %xmm0
	movups	48(%rbx,%rsi,4), %xmm1
	movaps	%xmm0, -48(%rbp,%rsi,4)
	movaps	%xmm1, -32(%rbp,%rsi,4)
	movups	64(%rbx,%rsi,4), %xmm0
	movups	80(%rbx,%rsi,4), %xmm1
	movaps	%xmm0, -16(%rbp,%rsi,4)
	movaps	%xmm1, (%rbp,%rsi,4)
	movdqu	96(%rbx,%rsi,4), %xmm0
	movups	112(%rbx,%rsi,4), %xmm1
	movdqa	%xmm0, 16(%rbp,%rsi,4)
	movaps	%xmm1, 32(%rbp,%rsi,4)
	addq	$32, %rsi
	addq	$-4, %rdx
	jne	LBB0_20
LBB0_21:
	testq	%rcx, %rcx
	je	LBB0_24
## %bb.22:
	leaq	-64(,%rsi,4), %rdx
	addq	%rbp, %rdx
	leaq	(%rbx,%rsi,4), %rsi
	addq	$16, %rsi
	shlq	$5, %rcx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_23:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rsi,%rdi), %xmm0
	movups	(%rsi,%rdi), %xmm1
	movdqa	%xmm0, -16(%rdx,%rdi)
	movaps	%xmm1, (%rdx,%rdi)
	addq	$32, %rdi
	cmpq	%rdi, %rcx
	jne	LBB0_23
LBB0_24:
	cmpq	%r12, %rax
	je	LBB0_78
LBB0_25:
	movq	%rax, %rcx
	notq	%rcx
	addq	%r12, %rcx
	movq	%r12, %rdx
	andq	$3, %rdx
	je	LBB0_27
	.p2align	4, 0x90
LBB0_26:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rbx,%rax,4), %esi
	movl	%esi, -80(%rbp,%rax,4)
	incq	%rax
	decq	%rdx
	jne	LBB0_26
LBB0_27:
	cmpq	$3, %rcx
	jb	LBB0_78
	.p2align	4, 0x90
LBB0_28:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rbx,%rax,4), %ecx
	movl	%ecx, -80(%rbp,%rax,4)
	movl	4(%rbx,%rax,4), %ecx
	movl	%ecx, -76(%rbp,%rax,4)
	movl	8(%rbx,%rax,4), %ecx
	movl	%ecx, -72(%rbp,%rax,4)
	movl	12(%rbx,%rax,4), %ecx
	movl	%ecx, -68(%rbp,%rax,4)
	addq	$4, %rax
	cmpq	%rax, %r12
	jne	LBB0_28
	jmp	LBB0_78
LBB0_33:
	movl	%r12d, %edx
	andl	$7, %edx
	movq	%r13, %rcx
	subq	%rdx, %rcx
	movd	%eax, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_34:                                ## =>This Inner Loop Header: Depth=1
	movdqa	%xmm0, -80(%rbp,%rsi,4)
	movdqa	%xmm0, -64(%rbp,%rsi,4)
	addq	$8, %rsi
	cmpq	%rsi, %rcx
	jne	LBB0_34
## %bb.35:
	testq	%rdx, %rdx
	je	LBB0_47
	.p2align	4, 0x90
LBB0_36:                                ## =>This Inner Loop Header: Depth=1
	movl	%eax, -80(%rbp,%rcx,4)
	incq	%rcx
	cmpq	%rcx, %r13
	jne	LBB0_36
LBB0_47:
	movq	%r8, -112(%rbp)                 ## 8-byte Spill
	movq	-120(%rbp), %r14                ## 8-byte Reload
	movq	%r14, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_48
## %bb.60:
	movq	%rax, %rbx
	movq	%r14, %rdi
	callq	_kmemcheck_save_addr
	cmpl	-84(%rbp), %r12d                ## 4-byte Folded Reload
	movq	%r15, %r14
	movq	-112(%rbp), %r15                ## 8-byte Reload
	movq	-104(%rbp), %r12                ## 8-byte Reload
	jae	LBB0_78
## %bb.61:
	movq	%r12, %r8
	subq	%r13, %r8
	movq	%r13, %rax
	cmpq	$8, %r8
	jb	LBB0_72
## %bb.62:
	leaq	-80(,%r13,4), %rcx
	addq	%rbp, %rcx
	subq	%rbx, %rcx
	movq	%r13, %rax
	cmpq	$32, %rcx
	jb	LBB0_72
## %bb.63:
	movq	%r8, %rax
	andq	$-8, %rax
	leaq	-8(%rax), %rcx
	movq	%rcx, %rsi
	shrq	$3, %rsi
	incq	%rsi
	movl	%esi, %edx
	andl	$3, %edx
	cmpq	$24, %rcx
	jae	LBB0_65
## %bb.64:
	xorl	%edi, %edi
	jmp	LBB0_67
LBB0_48:
	cmpl	-84(%rbp), %r12d                ## 4-byte Folded Reload
	movq	%r15, %r14
	movq	-112(%rbp), %r15                ## 8-byte Reload
	movq	-104(%rbp), %r12                ## 8-byte Reload
	jae	LBB0_78
## %bb.49:
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%r12, %rcx
	subq	%r13, %rcx
	cmpq	$8, %rcx
	jb	LBB0_59
## %bb.50:
	movq	%rcx, %r8
	andq	$-8, %r8
	movd	%eax, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	leaq	-8(%r8), %rdx
	movq	%rdx, %rdi
	shrq	$3, %rdi
	incq	%rdi
	movl	%edi, %esi
	andl	$3, %esi
	cmpq	$24, %rdx
	jae	LBB0_52
## %bb.51:
	xorl	%ebx, %ebx
	jmp	LBB0_54
LBB0_7:
	movabsq	$4611686018427387900, %rdi      ## imm = 0x3FFFFFFFFFFFFFFC
	addq	$-4, %rdi
	andq	%rdi, %rsi
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_8:                                 ## =>This Inner Loop Header: Depth=1
	movdqa	%xmm0, -80(%rbp,%rdi,4)
	movdqa	%xmm0, -64(%rbp,%rdi,4)
	movdqa	%xmm0, -48(%rbp,%rdi,4)
	movdqa	%xmm0, -32(%rbp,%rdi,4)
	movdqa	%xmm0, -16(%rbp,%rdi,4)
	movdqa	%xmm0, (%rbp,%rdi,4)
	movdqa	%xmm0, 16(%rbp,%rdi,4)
	movdqa	%xmm0, 32(%rbp,%rdi,4)
	movdqa	%xmm0, 48(%rbp,%rdi,4)
	movdqa	%xmm0, 64(%rbp,%rdi,4)
	movdqa	%xmm0, 80(%rbp,%rdi,4)
	movdqa	%xmm0, 96(%rbp,%rdi,4)
	movdqa	%xmm0, 112(%rbp,%rdi,4)
	movdqa	%xmm0, 128(%rbp,%rdi,4)
	movdqa	%xmm0, 144(%rbp,%rdi,4)
	movdqa	%xmm0, 160(%rbp,%rdi,4)
	addq	$64, %rdi
	addq	$-8, %rsi
	jne	LBB0_8
LBB0_9:
	testq	%rdx, %rdx
	je	LBB0_12
## %bb.10:
	leaq	-64(,%rdi,4), %rsi
	addq	%rbp, %rsi
	shlq	$5, %rdx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_11:                                ## =>This Inner Loop Header: Depth=1
	movdqa	%xmm0, -16(%rsi,%rdi)
	movdqa	%xmm0, (%rsi,%rdi)
	addq	$32, %rdi
	cmpq	%rdi, %rdx
	jne	LBB0_11
LBB0_12:
	cmpq	%r12, %rcx
	je	LBB0_78
	.p2align	4, 0x90
LBB0_13:                                ## =>This Inner Loop Header: Depth=1
	movl	%eax, -80(%rbp,%rcx,4)
	incq	%rcx
	cmpq	%rcx, %r12
	jne	LBB0_13
	jmp	LBB0_78
LBB0_52:
	andq	$-4, %rdi
	leaq	32(,%r13,4), %rdx
	addq	%rbp, %rdx
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_53:                                ## =>This Inner Loop Header: Depth=1
	movdqu	%xmm0, -112(%rdx,%rbx,4)
	movdqu	%xmm0, -96(%rdx,%rbx,4)
	movdqu	%xmm0, -80(%rdx,%rbx,4)
	movdqu	%xmm0, -64(%rdx,%rbx,4)
	movdqu	%xmm0, -48(%rdx,%rbx,4)
	movdqu	%xmm0, -32(%rdx,%rbx,4)
	movdqu	%xmm0, -16(%rdx,%rbx,4)
	movdqu	%xmm0, (%rdx,%rbx,4)
	addq	$32, %rbx
	addq	$-4, %rdi
	jne	LBB0_53
LBB0_54:
	testq	%rsi, %rsi
	je	LBB0_57
## %bb.55:
	addq	%r13, %rbx
	leaq	-64(,%rbx,4), %rdx
	addq	%rbp, %rdx
	shlq	$5, %rsi
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_56:                                ## =>This Inner Loop Header: Depth=1
	movdqu	%xmm0, -16(%rdx,%rdi)
	movdqu	%xmm0, (%rdx,%rdi)
	addq	$32, %rdi
	cmpq	%rdi, %rsi
	jne	LBB0_56
LBB0_57:
	cmpq	%r8, %rcx
	je	LBB0_78
## %bb.58:
	addq	%r8, %r13
	.p2align	4, 0x90
LBB0_59:                                ## =>This Inner Loop Header: Depth=1
	movl	%eax, -80(%rbp,%r13,4)
	incq	%r13
	cmpq	%r13, %r12
	jne	LBB0_59
	jmp	LBB0_78
LBB0_65:
	andq	$-4, %rsi
	leaq	32(,%r13,4), %rcx
	addq	%rbp, %rcx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_66:                                ## =>This Inner Loop Header: Depth=1
	movups	(%rbx,%rdi,4), %xmm0
	movups	16(%rbx,%rdi,4), %xmm1
	movups	%xmm0, -112(%rcx,%rdi,4)
	movups	%xmm1, -96(%rcx,%rdi,4)
	movups	32(%rbx,%rdi,4), %xmm0
	movups	48(%rbx,%rdi,4), %xmm1
	movups	%xmm0, -80(%rcx,%rdi,4)
	movups	%xmm1, -64(%rcx,%rdi,4)
	movups	64(%rbx,%rdi,4), %xmm0
	movups	80(%rbx,%rdi,4), %xmm1
	movups	%xmm0, -48(%rcx,%rdi,4)
	movups	%xmm1, -32(%rcx,%rdi,4)
	movdqu	96(%rbx,%rdi,4), %xmm0
	movups	112(%rbx,%rdi,4), %xmm1
	movdqu	%xmm0, -16(%rcx,%rdi,4)
	movups	%xmm1, (%rcx,%rdi,4)
	addq	$32, %rdi
	addq	$-4, %rsi
	jne	LBB0_66
LBB0_67:
	testq	%rdx, %rdx
	je	LBB0_70
## %bb.68:
	leaq	(%rbx,%rdi,4), %rcx
	addq	$16, %rcx
	addq	%r13, %rdi
	leaq	-64(,%rdi,4), %rsi
	addq	%rbp, %rsi
	shlq	$5, %rdx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_69:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rcx,%rdi), %xmm0
	movups	(%rcx,%rdi), %xmm1
	movdqu	%xmm0, -16(%rsi,%rdi)
	movups	%xmm1, (%rsi,%rdi)
	addq	$32, %rdi
	cmpq	%rdi, %rdx
	jne	LBB0_69
LBB0_70:
	cmpq	%rax, %r8
	je	LBB0_78
## %bb.71:
	addq	%r13, %rax
LBB0_72:
	movl	%r12d, %edx
	subl	%eax, %edx
	movq	%rax, %rcx
	notq	%rcx
	addq	%r12, %rcx
	andq	$3, %rdx
	je	LBB0_75
## %bb.73:
	leaq	(,%r13,4), %rdi
	movq	%rbx, %rsi
	subq	%rdi, %rsi
	.p2align	4, 0x90
LBB0_74:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rsi,%rax,4), %edi
	movl	%edi, -80(%rbp,%rax,4)
	incq	%rax
	decq	%rdx
	jne	LBB0_74
LBB0_75:
	cmpq	$3, %rcx
	jb	LBB0_78
## %bb.76:
	movl	$3, %ecx
	subq	%r13, %rcx
	leaq	(%rbx,%rcx,4), %rcx
	.p2align	4, 0x90
LBB0_77:                                ## =>This Inner Loop Header: Depth=1
	movl	-12(%rcx,%rax,4), %edx
	movl	%edx, -80(%rbp,%rax,4)
	movl	-8(%rcx,%rax,4), %edx
	movl	%edx, -76(%rbp,%rax,4)
	movl	-4(%rcx,%rax,4), %edx
	movl	%edx, -72(%rbp,%rax,4)
	movl	(%rcx,%rax,4), %edx
	movl	%edx, -68(%rbp,%rax,4)
	addq	$4, %rax
	cmpq	%rax, %r12
	jne	LBB0_77
LBB0_78:
	movq	_PAGE_MASK@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	addq	%r14, %r15
	andq	%rax, %r15
	andq	%r14, %rax
	xorl	%edi, %edi
	cmpq	%r15, %rax
	sete	%dil
	callq	_likely
	testq	%rax, %rax
	je	LBB0_98
## %bb.79:
	movq	%r14, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_132
## %bb.80:
	movq	%rax, %rbx
	movq	%r14, %rdi
	callq	_kmemcheck_save_addr
	cmpl	$0, -84(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_132
## %bb.81:
	cmpl	$8, -84(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_83
## %bb.82:
	xorl	%eax, %eax
LBB0_93:
	movq	%rax, %rcx
	notq	%rcx
	testb	$1, %r12b
	je	LBB0_95
## %bb.94:
	movl	-80(%rbp,%rax,4), %edx
	movl	%edx, (%rbx,%rax,4)
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rdx
	movl	(%rdx), %edx
	movl	%edx, -80(%rbp,%rax,4)
	orq	$1, %rax
LBB0_95:
	addq	%r12, %rcx
	je	LBB0_132
## %bb.96:
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rcx
	.p2align	4, 0x90
LBB0_97:                                ## =>This Inner Loop Header: Depth=1
	movl	-80(%rbp,%rax,4), %edx
	movl	%edx, (%rbx,%rax,4)
	movl	(%rcx), %edx
	movl	%edx, -80(%rbp,%rax,4)
	movl	-76(%rbp,%rax,4), %edx
	movl	%edx, 4(%rbx,%rax,4)
	movl	(%rcx), %edx
	movl	%edx, -76(%rbp,%rax,4)
	addq	$2, %rax
	cmpq	%rax, %r12
	jne	LBB0_97
	jmp	LBB0_132
LBB0_98:
	movq	%r15, %r13
	subq	%r14, %r15
	movq	%r15, -96(%rbp)                 ## 8-byte Spill
	movl	%r15d, %r15d
	xorl	%edi, %edi
	cmpq	$33, %r15
	setae	%dil
	callq	_BUG_ON
	movq	%r14, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_113
## %bb.99:
	movq	%rax, %rbx
	movq	%r14, %rdi
	callq	_kmemcheck_save_addr
	cmpl	$0, -96(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_113
## %bb.100:
	cmpl	$8, %r15d
	jae	LBB0_102
## %bb.101:
	xorl	%eax, %eax
	jmp	LBB0_108
LBB0_83:
	leaq	(%rbx,%r12,4), %rax
	leaq	-80(,%r12,4), %rdi
	addq	%rbp, %rdi
	cmpq	%rdi, %rbx
	setb	%r9b
	leaq	-80(%rbp), %r11
	cmpq	%rax, %r11
	setb	%r10b
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %r8
	leaq	4(%r8), %rcx
	cmpq	%rcx, %rbx
	setb	%dl
	cmpq	%r8, %rax
	seta	%sil
	cmpq	%rcx, %r11
	setb	%cl
	cmpq	%r8, %rdi
	seta	%dil
	xorl	%eax, %eax
	testb	%r10b, %r9b
	jne	LBB0_93
## %bb.84:
	andb	%sil, %dl
	jne	LBB0_93
## %bb.85:
	andb	%dil, %cl
	jne	LBB0_93
## %bb.86:
	movl	%r12d, %eax
	andl	$-8, %eax
	leaq	-8(%rax), %rcx
	movq	%rcx, %rdx
	shrq	$3, %rdx
	incq	%rdx
	testq	%rcx, %rcx
	je	LBB0_87
## %bb.88:
	movabsq	$4611686018427387900, %rdi      ## imm = 0x3FFFFFFFFFFFFFFC
	orq	$2, %rdi
	andq	%rdx, %rdi
	movd	(%r8), %xmm0                    ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_89:                                ## =>This Inner Loop Header: Depth=1
	movaps	-80(%rbp,%rsi,4), %xmm1
	movaps	-64(%rbp,%rsi,4), %xmm2
	movups	%xmm1, (%rbx,%rsi,4)
	movups	%xmm2, 16(%rbx,%rsi,4)
	movdqa	%xmm0, -80(%rbp,%rsi,4)
	movdqa	%xmm0, -64(%rbp,%rsi,4)
	movaps	-48(%rbp,%rsi,4), %xmm1
	movaps	-32(%rbp,%rsi,4), %xmm2
	movups	%xmm1, 32(%rbx,%rsi,4)
	movups	%xmm2, 48(%rbx,%rsi,4)
	movdqa	%xmm0, -48(%rbp,%rsi,4)
	movdqa	%xmm0, -32(%rbp,%rsi,4)
	addq	$16, %rsi
	addq	$-2, %rdi
	jne	LBB0_89
## %bb.90:
	testb	$1, %dl
	je	LBB0_92
LBB0_91:
	movaps	-80(%rbp,%rsi,4), %xmm0
	movaps	-64(%rbp,%rsi,4), %xmm1
	movups	%xmm0, (%rbx,%rsi,4)
	movups	%xmm1, 16(%rbx,%rsi,4)
	movd	(%r8), %xmm0                    ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	movdqa	%xmm0, -80(%rbp,%rsi,4)
	movdqa	%xmm0, -64(%rbp,%rsi,4)
LBB0_92:
	cmpq	%r12, %rax
	jne	LBB0_93
	jmp	LBB0_132
LBB0_102:
	leaq	(%rbx,%r15,4), %rax
	leaq	-80(,%r15,4), %rsi
	addq	%rbp, %rsi
	cmpq	%rsi, %rbx
	setb	%r10b
	leaq	-80(%rbp), %r8
	cmpq	%rax, %r8
	setb	%r11b
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %r9
	leaq	4(%r9), %rcx
	cmpq	%rcx, %rbx
	setb	%dl
	cmpq	%r9, %rax
	seta	%dil
	cmpq	%rcx, %r8
	setb	%cl
	cmpq	%r9, %rsi
	seta	%r8b
	xorl	%eax, %eax
	testb	%r11b, %r10b
	jne	LBB0_108
## %bb.103:
	andb	%dil, %dl
	jne	LBB0_108
## %bb.104:
	andb	%r8b, %cl
	jne	LBB0_108
## %bb.105:
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
                                        ## kill: def $edx killed $edx killed $rdx def $rdx
	andl	$7, %edx
	movq	%r15, %rax
	subq	%rdx, %rax
	movd	(%r9), %xmm0                    ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_106:                               ## =>This Inner Loop Header: Depth=1
	movaps	-80(%rbp,%rcx,4), %xmm1
	movaps	-64(%rbp,%rcx,4), %xmm2
	movups	%xmm1, (%rbx,%rcx,4)
	movups	%xmm2, 16(%rbx,%rcx,4)
	movdqa	%xmm0, -80(%rbp,%rcx,4)
	movdqa	%xmm0, -64(%rbp,%rcx,4)
	addq	$8, %rcx
	cmpq	%rcx, %rax
	jne	LBB0_106
## %bb.107:
	testq	%rdx, %rdx
	je	LBB0_113
LBB0_108:
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
                                        ## kill: def $edx killed $edx killed $rdx def $rdx
	subl	%eax, %edx
	leaq	1(%rax), %rcx
	testb	$1, %dl
	je	LBB0_110
## %bb.109:
	movl	-80(%rbp,%rax,4), %edx
	movl	%edx, (%rbx,%rax,4)
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rdx
	movl	(%rdx), %edx
	movl	%edx, -80(%rbp,%rax,4)
	movq	%rcx, %rax
LBB0_110:
	cmpq	%rcx, %r15
	je	LBB0_113
## %bb.111:
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rcx
	.p2align	4, 0x90
LBB0_112:                               ## =>This Inner Loop Header: Depth=1
	movl	-80(%rbp,%rax,4), %edx
	movl	%edx, (%rbx,%rax,4)
	movl	(%rcx), %edx
	movl	%edx, -80(%rbp,%rax,4)
	movl	-76(%rbp,%rax,4), %edx
	movl	%edx, 4(%rbx,%rax,4)
	movl	(%rcx), %edx
	movl	%edx, -76(%rbp,%rax,4)
	addq	$2, %rax
	cmpq	%rax, %r15
	jne	LBB0_112
LBB0_113:
	movq	%r13, %rdi
	callq	_kmemcheck_shadow_lookup
	testq	%rax, %rax
	je	LBB0_132
## %bb.114:
	movq	%rax, %rbx
	movq	%r13, %rdi
	callq	_kmemcheck_save_addr
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	cmpl	-84(%rbp), %eax                 ## 4-byte Folded Reload
	jae	LBB0_132
## %bb.115:
	movq	%r12, %rcx
	subq	%r15, %rcx
	movq	%r15, %rax
	cmpq	$8, %rcx
	jae	LBB0_116
LBB0_127:
	movl	%r12d, %edx
	subl	%eax, %edx
	movq	%rax, %rcx
	notq	%rcx
	testb	$1, %dl
	je	LBB0_129
## %bb.128:
	movl	-80(%rbp,%rax,4), %edx
	movq	%rax, %rsi
	subq	%r15, %rsi
	movl	%edx, (%rbx,%rsi,4)
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rdx
	movl	(%rdx), %edx
	movl	%edx, -80(%rbp,%rax,4)
	incq	%rax
LBB0_129:
	addq	%r12, %rcx
	je	LBB0_132
## %bb.130:
	movl	$1, %ecx
	subq	%r15, %rcx
	leaq	(%rbx,%rcx,4), %rcx
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rdx
	.p2align	4, 0x90
LBB0_131:                               ## =>This Inner Loop Header: Depth=1
	movl	-80(%rbp,%rax,4), %esi
	movl	%esi, -4(%rcx,%rax,4)
	movl	(%rdx), %esi
	movl	%esi, -80(%rbp,%rax,4)
	movl	-76(%rbp,%rax,4), %esi
	movl	%esi, (%rcx,%rax,4)
	movl	(%rdx), %esi
	movl	%esi, -76(%rbp,%rax,4)
	addq	$2, %rax
	cmpq	%rax, %r12
	jne	LBB0_131
	jmp	LBB0_132
LBB0_116:
	leaq	(%rbx,%rcx,4), %rax
	leaq	-80(,%r15,4), %rsi
	addq	%rbp, %rsi
	leaq	-80(,%r12,4), %rdi
	addq	%rbp, %rdi
	cmpq	%rdi, %rbx
	setb	%r10b
	cmpq	%rax, %rsi
	setb	%r11b
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %r8
	leaq	4(%r8), %rdx
	cmpq	%rdx, %rbx
	setb	%r14b
	cmpq	%r8, %rax
	seta	%r9b
	cmpq	%rdx, %rsi
	setb	%sil
	cmpq	%r8, %rdi
	seta	%dil
	movq	%r15, %rax
	testb	%r11b, %r10b
	jne	LBB0_127
## %bb.117:
	movq	%r15, %rax
	andb	%r9b, %r14b
	jne	LBB0_127
## %bb.118:
	movq	%r15, %rax
	andb	%dil, %sil
	jne	LBB0_127
## %bb.119:
	movq	%rcx, %rax
	andq	$-8, %rax
	leaq	-8(%rax), %rdx
	movq	%rdx, %r9
	shrq	$3, %r9
	incq	%r9
	testq	%rdx, %rdx
	je	LBB0_120
## %bb.121:
	movabsq	$4611686018427387900, %rdx      ## imm = 0x3FFFFFFFFFFFFFFC
	orq	$2, %rdx
	andq	%r9, %rdx
	movd	(%r8), %xmm0                    ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	leaq	-32(,%r15,4), %rsi
	addq	%rbp, %rsi
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_122:                               ## =>This Inner Loop Header: Depth=1
	movups	-48(%rsi,%rdi,4), %xmm1
	movups	-32(%rsi,%rdi,4), %xmm2
	movups	%xmm1, (%rbx,%rdi,4)
	movups	%xmm2, 16(%rbx,%rdi,4)
	movdqu	%xmm0, -48(%rsi,%rdi,4)
	movdqu	%xmm0, -32(%rsi,%rdi,4)
	movups	-16(%rsi,%rdi,4), %xmm1
	movups	(%rsi,%rdi,4), %xmm2
	movups	%xmm1, 32(%rbx,%rdi,4)
	movups	%xmm2, 48(%rbx,%rdi,4)
	movdqu	%xmm0, -16(%rsi,%rdi,4)
	movdqu	%xmm0, (%rsi,%rdi,4)
	addq	$16, %rdi
	addq	$-2, %rdx
	jne	LBB0_122
	jmp	LBB0_123
LBB0_87:
	xorl	%esi, %esi
	testb	$1, %dl
	jne	LBB0_91
	jmp	LBB0_92
LBB0_120:
	xorl	%edi, %edi
LBB0_123:
	testb	$1, %r9b
	je	LBB0_125
## %bb.124:
	leaq	(%r15,%rdi), %rdx
	movups	-80(%rbp,%rdx,4), %xmm0
	movups	-64(%rbp,%rdx,4), %xmm1
	movups	%xmm0, (%rbx,%rdi,4)
	movups	%xmm1, 16(%rbx,%rdi,4)
	movd	(%r8), %xmm0                    ## xmm0 = mem[0],zero,zero,zero
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	movdqu	%xmm0, -80(%rbp,%rdx,4)
	movdqu	%xmm0, -64(%rbp,%rdx,4)
LBB0_125:
	cmpq	%rax, %rcx
	jne	LBB0_126
LBB0_132:
	leaq	-80(%rbp), %rdi
	movl	-84(%rbp), %esi                 ## 4-byte Reload
	callq	_kmemcheck_shadow_test
	movq	_KMEMCHECK_SHADOW_INITIALIZED@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	je	LBB0_136
## %bb.133:
	movq	_kmemcheck_enabled@GOTPCREL(%rip), %rbx
	cmpl	$0, (%rbx)
	je	LBB0_136
## %bb.134:
	movl	%eax, %edi
	movq	-128(%rbp), %rsi                ## 8-byte Reload
	movl	-84(%rbp), %edx                 ## 4-byte Reload
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	callq	_kmemcheck_error_save
	cmpl	$2, (%rbx)
	jne	LBB0_136
## %bb.135:
	movl	$0, (%rbx)
LBB0_136:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_138
## %bb.137:
	addq	$104, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_126:
	addq	%r15, %rax
	jmp	LBB0_127
LBB0_138:
	callq	___stack_chk_fail
	.cfi_endproc
                                        ## -- End function
	.comm	_PAGE_MASK,8,3                  ## @PAGE_MASK
	.comm	_KMEMCHECK_SHADOW_INITIALIZED,4,2 ## @KMEMCHECK_SHADOW_INITIALIZED
	.comm	_kmemcheck_enabled,4,2          ## @kmemcheck_enabled
	.no_dead_strip	_kmemcheck_copy
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function kmemcheck_copy
_kmemcheck_copy:                        ; @kmemcheck_copy
	.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	x19, x3
	mov	x22, x2
	mov	x21, x1
	str	x0, [sp]                        ; 8-byte Folded Spill
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	str	x8, [sp, #40]
	mov	w26, w3
	cmp	w3, #32
	cset	w0, hi
	bl	_BUG_ON
Lloh3:
	adrp	x27, _PAGE_MASK@GOTPAGE
Lloh4:
	ldr	x27, [x27, _PAGE_MASK@GOTPAGEOFF]
	ldr	x8, [x27]
	and	x9, x8, x21
	sub	x28, x26, #1
	add	x10, x28, x21
	and	x23, x8, x10
	cmp	x9, x23
	cset	w0, eq
	bl	_likely
Lloh5:
	adrp	x25, _KMEMCHECK_SHADOW_INITIALIZED@GOTPAGE
Lloh6:
	ldr	x25, [x25, _KMEMCHECK_SHADOW_INITIALIZED@GOTPAGEOFF]
	cbz	x0, LBB0_10
; %bb.1:
	mov	x0, x21
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_19
; %bb.2:
	mov	x23, x0
	mov	x0, x21
	bl	_kmemcheck_save_addr
	cbz	w19, LBB0_52
; %bb.3:
	mov	x8, #0
	add	x9, sp, #8
	cmp	w19, #16
	b.lo	LBB0_8
; %bb.4:
	sub	x10, x9, x23
	cmp	x10, #64
	b.lo	LBB0_8
; %bb.5:
	and	x8, x26, #0xfffffff0
	add	x10, sp, #8
	add	x10, x10, #32
	add	x11, x23, #32
	mov	x12, x8
LBB0_6:                                 ; =>This Inner Loop Header: Depth=1
	ldp	q0, q1, [x11, #-32]
	ldp	q2, q3, [x11], #64
	stp	q0, q1, [x10, #-32]
	stp	q2, q3, [x10], #64
	subs	x12, x12, #16
	b.ne	LBB0_6
; %bb.7:
	cmp	x8, x26
	b.eq	LBB0_52
LBB0_8:
	lsl	x11, x8, #2
	add	x10, x23, x11
	add	x9, x9, x11
	sub	x8, x26, x8
LBB0_9:                                 ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x10], #4
	str	w11, [x9], #4
	subs	x8, x8, #1
	b.ne	LBB0_9
	b	LBB0_52
LBB0_10:
	sub	x27, x23, x21
	and	x20, x27, #0xffffffff
	cmp	x20, #32
	cset	w0, hi
	bl	_BUG_ON
	mov	x0, x21
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_22
; %bb.11:
	mov	x24, x0
	mov	x0, x21
	bl	_kmemcheck_save_addr
	cbz	w27, LBB0_35
; %bb.12:
	mov	x9, #0
	add	x8, sp, #8
	cmp	x20, #16
	b.lo	LBB0_17
; %bb.13:
	sub	x10, x8, x24
	cmp	x10, #64
	b.lo	LBB0_17
; %bb.14:
	and	x10, x27, #0xf
	sub	x9, x20, x10
	add	x11, sp, #8
	add	x11, x11, #32
	add	x12, x24, #32
	mov	x13, x9
LBB0_15:                                ; =>This Inner Loop Header: Depth=1
	ldp	q0, q1, [x12, #-32]
	ldp	q2, q3, [x12], #64
	stp	q0, q1, [x11, #-32]
	stp	q2, q3, [x11], #64
	subs	x13, x13, #16
	b.ne	LBB0_15
; %bb.16:
	cbz	x10, LBB0_35
LBB0_17:
	lsl	x11, x9, #2
	add	x10, x24, x11
	add	x8, x8, x11
	sub	x9, x20, x9
LBB0_18:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x10], #4
	str	w11, [x8], #4
	subs	x9, x9, #1
	b.ne	LBB0_18
	b	LBB0_35
LBB0_19:
	cbz	w19, LBB0_52
; %bb.20:
	ldr	w8, [x25]
	cmp	w19, #16
	b.hs	LBB0_25
; %bb.21:
	mov	x9, #0
	b	LBB0_28
LBB0_22:
	cbz	w27, LBB0_35
; %bb.23:
	ldr	w8, [x25]
	cmp	x20, #16
	b.hs	LBB0_30
; %bb.24:
	mov	x9, #0
	b	LBB0_33
LBB0_25:
	and	x9, x26, #0xfffffff0
	dup.4s	v0, w8
	add	x10, sp, #8
	add	x10, x10, #32
	mov	x11, x9
LBB0_26:                                ; =>This Inner Loop Header: Depth=1
	stp	q0, q0, [x10, #-32]
	stp	q0, q0, [x10], #64
	subs	x11, x11, #16
	b.ne	LBB0_26
; %bb.27:
	cmp	x9, x26
	b.eq	LBB0_52
LBB0_28:
	add	x10, sp, #8
	add	x10, x10, x9, lsl #2
	sub	x9, x26, x9
LBB0_29:                                ; =>This Inner Loop Header: Depth=1
	str	w8, [x10], #4
	subs	x9, x9, #1
	b.ne	LBB0_29
	b	LBB0_52
LBB0_30:
	and	x10, x27, #0xf
	sub	x9, x20, x10
	dup.4s	v0, w8
	add	x11, sp, #8
	add	x11, x11, #32
	mov	x12, x9
LBB0_31:                                ; =>This Inner Loop Header: Depth=1
	stp	q0, q0, [x11, #-32]
	stp	q0, q0, [x11], #64
	subs	x12, x12, #16
	b.ne	LBB0_31
; %bb.32:
	cbz	x10, LBB0_35
LBB0_33:
	add	x10, sp, #8
	add	x10, x10, x9, lsl #2
	sub	x9, x20, x9
LBB0_34:                                ; =>This Inner Loop Header: Depth=1
	str	w8, [x10], #4
	subs	x9, x9, #1
	b.ne	LBB0_34
LBB0_35:
	mov	x0, x23
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_39
; %bb.36:
	mov	x24, x0
	mov	x0, x23
	bl	_kmemcheck_save_addr
	cmp	w27, w19
Lloh7:
	adrp	x27, _PAGE_MASK@GOTPAGE
Lloh8:
	ldr	x27, [x27, _PAGE_MASK@GOTPAGEOFF]
	b.hs	LBB0_52
; %bb.37:
	sub	x9, x26, x20
	cmp	x9, #16
	b.hs	LBB0_46
; %bb.38:
	mov	x8, x20
	b	LBB0_50
LBB0_39:
	cmp	w27, w19
Lloh9:
	adrp	x27, _PAGE_MASK@GOTPAGE
Lloh10:
	ldr	x27, [x27, _PAGE_MASK@GOTPAGEOFF]
	b.hs	LBB0_52
; %bb.40:
	ldr	w8, [x25]
	sub	x9, x26, x20
	cmp	x9, #16
	b.lo	LBB0_44
; %bb.41:
	and	x10, x9, #0xfffffffffffffff0
	add	x11, x20, x10
	dup.4s	v0, w8
	add	x12, sp, #8
	add	x12, x12, x20, lsl #2
	add	x12, x12, #32
	mov	x13, x10
LBB0_42:                                ; =>This Inner Loop Header: Depth=1
	stp	q0, q0, [x12, #-32]
	stp	q0, q0, [x12], #64
	subs	x13, x13, #16
	b.ne	LBB0_42
; %bb.43:
	mov	x20, x11
	cmp	x9, x10
	b.eq	LBB0_52
LBB0_44:
	add	x9, sp, #8
	add	x9, x9, x20, lsl #2
	sub	x10, x26, x20
LBB0_45:                                ; =>This Inner Loop Header: Depth=1
	str	w8, [x9], #4
	subs	x10, x10, #1
	b.ne	LBB0_45
	b	LBB0_52
LBB0_46:
	add	x8, sp, #8
	add	x11, x8, x20, lsl #2
	sub	x10, x11, x24
	mov	x8, x20
	cmp	x10, #64
	b.lo	LBB0_50
; %bb.47:
	and	x10, x9, #0xfffffffffffffff0
	add	x8, x20, x10
	add	x11, x11, #32
	add	x12, x24, #32
	mov	x13, x10
LBB0_48:                                ; =>This Inner Loop Header: Depth=1
	ldp	q0, q1, [x12, #-32]
	ldp	q2, q3, [x12], #64
	stp	q0, q1, [x11, #-32]
	stp	q2, q3, [x11], #64
	subs	x13, x13, #16
	b.ne	LBB0_48
; %bb.49:
	cmp	x9, x10
	b.eq	LBB0_52
LBB0_50:
	add	x9, sp, #8
	add	x9, x9, x8, lsl #2
	sub	x10, x8, x20
	add	x10, x24, x10, lsl #2
	sub	x8, x26, x8
LBB0_51:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x10], #4
	str	w11, [x9], #4
	subs	x8, x8, #1
	b.ne	LBB0_51
LBB0_52:
	ldr	x8, [x27]
	and	x9, x8, x22
	add	x10, x28, x22
	and	x23, x8, x10
	cmp	x9, x23
	cset	w0, eq
	bl	_likely
	cbz	x0, LBB0_59
; %bb.53:
	mov	x0, x22
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_83
; %bb.54:
	mov	x23, x0
	mov	x0, x22
	bl	_kmemcheck_save_addr
	cbz	w19, LBB0_83
; %bb.55:
	cmp	w19, #8
	b.hs	LBB0_63
; %bb.56:
	mov	x8, #0
LBB0_57:
	lsl	x10, x8, #2
	add	x9, sp, #8
	add	x9, x9, x10
	add	x10, x23, x10
	sub	x8, x26, x8
LBB0_58:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x9]
	str	w11, [x10], #4
	ldr	w11, [x25]
	str	w11, [x9], #4
	subs	x8, x8, #1
	b.ne	LBB0_58
	b	LBB0_83
LBB0_59:
	sub	x27, x23, x22
	and	x20, x27, #0xffffffff
	cmp	x20, #32
	cset	w0, hi
	bl	_BUG_ON
	mov	x0, x22
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_77
; %bb.60:
	mov	x24, x0
	mov	x0, x22
	bl	_kmemcheck_save_addr
	cbz	w27, LBB0_77
; %bb.61:
	cmp	x20, #8
	b.hs	LBB0_69
; %bb.62:
	mov	x8, #0
	b	LBB0_75
LBB0_63:
	mov	x8, #0
	lsl	x9, x26, #2
	add	x11, sp, #8
	add	x12, x11, x9
	add	x10, x25, #4
	cmp	x23, x10
	add	x13, x23, x9
	ccmp	x13, x25, #0, lo
	cset	w9, hi
	cmp	x11, x10
	ccmp	x12, x25, #0, lo
	cset	w10, hi
	cmp	x11, x13
	ccmp	x23, x12, #2, lo
	b.lo	LBB0_57
; %bb.64:
	tbnz	w9, #0, LBB0_57
; %bb.65:
	tbnz	w10, #0, LBB0_57
; %bb.66:
	and	x8, x26, #0xfffffff8
	ld1r.4s	{ v0 }, [x25]
	add	x9, sp, #8
	add	x9, x9, #16
	add	x10, x23, #16
	mov	x11, x8
LBB0_67:                                ; =>This Inner Loop Header: Depth=1
	ldp	q1, q2, [x9, #-16]
	stp	q1, q2, [x10, #-16]
	stp	q0, q0, [x9, #-16]
	add	x9, x9, #32
	add	x10, x10, #32
	subs	x11, x11, #8
	b.ne	LBB0_67
; %bb.68:
	cmp	x8, x26
	b.ne	LBB0_57
	b	LBB0_83
LBB0_69:
	mov	x8, #0
	lsl	x9, x20, #2
	add	x11, sp, #8
	add	x12, x11, x9
	add	x10, x25, #4
	cmp	x24, x10
	add	x13, x24, x9
	ccmp	x13, x25, #0, lo
	cset	w9, hi
	cmp	x11, x10
	ccmp	x12, x25, #0, lo
	cset	w10, hi
	cmp	x11, x13
	ccmp	x24, x12, #2, lo
	b.lo	LBB0_75
; %bb.70:
	tbnz	w9, #0, LBB0_75
; %bb.71:
	tbnz	w10, #0, LBB0_75
; %bb.72:
	and	x9, x27, #0x7
	sub	x8, x20, x9
	ld1r.4s	{ v0 }, [x25]
	add	x10, sp, #8
	add	x10, x10, #16
	add	x11, x24, #16
	mov	x12, x8
LBB0_73:                                ; =>This Inner Loop Header: Depth=1
	ldp	q1, q2, [x10, #-16]
	stp	q1, q2, [x11, #-16]
	stp	q0, q0, [x10, #-16]
	add	x10, x10, #32
	add	x11, x11, #32
	subs	x12, x12, #8
	b.ne	LBB0_73
; %bb.74:
	cbz	x9, LBB0_77
LBB0_75:
	lsl	x10, x8, #2
	add	x9, sp, #8
	add	x9, x9, x10
	add	x10, x24, x10
	sub	x8, x20, x8
LBB0_76:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x9]
	str	w11, [x10], #4
	ldr	w11, [x25]
	str	w11, [x9], #4
	subs	x8, x8, #1
	b.ne	LBB0_76
LBB0_77:
	mov	x0, x23
	bl	_kmemcheck_shadow_lookup
	cbz	x0, LBB0_83
; %bb.78:
	mov	x22, x0
	mov	x0, x23
	bl	_kmemcheck_save_addr
	cmp	w27, w19
	b.hs	LBB0_83
; %bb.79:
	sub	x8, x26, x20
	cmp	x8, #8
	b.hs	LBB0_88
LBB0_80:
	mov	x9, x20
LBB0_81:
	sub	x8, x9, x20
	add	x8, x22, x8, lsl #2
	add	x10, sp, #8
	add	x10, x10, x9, lsl #2
	sub	x9, x26, x9
LBB0_82:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x10]
	str	w11, [x8], #4
	ldr	w11, [x25]
	str	w11, [x10], #4
	subs	x9, x9, #1
	b.ne	LBB0_82
LBB0_83:
	add	x0, sp, #8
	mov	x1, x19
	bl	_kmemcheck_shadow_test
	ldr	w8, [x25]
Lloh11:
	adrp	x20, _kmemcheck_enabled@GOTPAGE
Lloh12:
	ldr	x20, [x20, _kmemcheck_enabled@GOTPAGEOFF]
	ldr	w9, [x20]
	cmp	w0, w8
	ccmp	w9, #0, #4, ne
	b.eq	LBB0_86
; %bb.84:
	mov	x1, x21
	mov	x2, x19
	ldr	x3, [sp]                        ; 8-byte Folded Reload
	bl	_kmemcheck_error_save
	ldr	w8, [x20]
	cmp	w8, #2
	b.ne	LBB0_86
; %bb.85:
	str	wzr, [x20]
LBB0_86:
	ldr	x8, [sp, #40]
Lloh13:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh14:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh15:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_94
; %bb.87:
	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_88:
	add	x11, x22, x8, lsl #2
	add	x9, sp, #8
	add	x12, x9, x20, lsl #2
	add	x13, x9, x26, lsl #2
	add	x10, x25, #4
	cmp	x22, x10
	ccmp	x11, x25, #0, lo
	cset	w9, hi
	cmp	x12, x10
	ccmp	x13, x25, #0, lo
	cset	w10, hi
	cmp	x12, x11
	ccmp	x22, x13, #2, lo
	b.lo	LBB0_80
; %bb.89:
	tbnz	w9, #0, LBB0_80
; %bb.90:
	mov	x9, x20
	tbnz	w10, #0, LBB0_81
; %bb.91:
	and	x10, x8, #0xfffffffffffffff8
	ld1r.4s	{ v0 }, [x25]
	add	x9, x20, x10
	add	x11, x22, #16
	add	x12, sp, #8
	add	x12, x12, x20, lsl #2
	add	x12, x12, #16
	mov	x13, x10
LBB0_92:                                ; =>This Inner Loop Header: Depth=1
	ldp	q1, q2, [x12, #-16]
	stp	q1, q2, [x11, #-16]
	stp	q0, q0, [x12, #-16]
	add	x11, x11, #32
	add	x12, x12, #32
	subs	x13, x13, #8
	b.ne	LBB0_92
; %bb.93:
	cmp	x8, x10
	b.ne	LBB0_81
	b	LBB0_83
LBB0_94:
	bl	___stack_chk_fail
	.loh AdrpLdrGot	Lloh5, Lloh6
	.loh AdrpLdrGot	Lloh3, Lloh4
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGot	Lloh7, Lloh8
	.loh AdrpLdrGot	Lloh9, Lloh10
	.loh AdrpLdrGot	Lloh11, Lloh12
	.loh AdrpLdrGotLdr	Lloh13, Lloh14, Lloh15
	.cfi_endproc
                                        ; -- End function
	.comm	_PAGE_MASK,8,3                  ; @PAGE_MASK
	.comm	_KMEMCHECK_SHADOW_INITIALIZED,4,2 ; @KMEMCHECK_SHADOW_INITIALIZED
	.comm	_kmemcheck_enabled,4,2          ; @kmemcheck_enabled
	.no_dead_strip	_kmemcheck_copy
.subsections_via_symbols
