	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function copy_region_enc
_copy_region_enc:                       ## @copy_region_enc
	.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
	pushq	%rax
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
                                        ## kill: def $r9d killed $r9d def $r9
                                        ## kill: def $ecx killed $ecx def $rcx
	testl	%r8d, %r8d
	jle	LBB0_1
## %bb.2:
	movq	24(%rbp), %r10
	addl	%edx, %r8d
	leal	(%rcx,%rcx,2), %eax
	cltq
	leal	(%r9,%r9,2), %ecx
	movslq	%ecx, %r12
	cmpl	$2, %r12d
	movl	$1, %r14d
	cmovgel	%r12d, %r14d
	movslq	%r8d, %r13
	movslq	16(%rbp), %r8
	leaq	(%rdi,%rax,4), %rcx
	movq	%rcx, -152(%rbp)                ## 8-byte Spill
	leaq	(%r10,%rax,4), %rcx
	movq	%rcx, -144(%rbp)                ## 8-byte Spill
	movq	%r8, %rcx
	imulq	%r13, %rcx
	leaq	(%r10,%rcx,4), %rbx
	leaq	(%rbx,%rax,4), %rbx
	movq	%rbx, -120(%rbp)                ## 8-byte Spill
	leaq	(%rdi,%rcx,4), %rbx
	leaq	(%rbx,%rax,4), %rbx
	movq	%rbx, -112(%rbp)                ## 8-byte Spill
	addq	%rax, %rcx
	leaq	(%rdi,%rcx,4), %r11
	addq	$48, %r11
	leaq	(%rdi,%rcx,4), %rdi
	leaq	48(%r10,%rcx,4), %rax
	leaq	(%r10,%rcx,4), %r15
	movq	%r12, %r10
	movslq	%edx, %rcx
	movq	%rcx, -168(%rbp)                ## 8-byte Spill
	shlq	$2, %r10
	movq	%r8, -160(%rbp)                 ## 8-byte Spill
	leaq	(,%r8,4), %rcx
	negq	%rcx
	movq	%rcx, -72(%rbp)                 ## 8-byte Spill
	movl	%r14d, %ecx
	andl	$2147483640, %ecx               ## imm = 0x7FFFFFF8
	movq	%rcx, -104(%rbp)                ## 8-byte Spill
	addq	$-8, %rcx
	movq	%rcx, -96(%rbp)                 ## 8-byte Spill
	movq	%rcx, %rdx
	shrq	$3, %rdx
	incq	%rdx
	movq	%rdx, %rcx
	movq	%rdx, -88(%rbp)                 ## 8-byte Spill
	andq	$-2, %rdx
	movq	%rdx, -80(%rbp)                 ## 8-byte Spill
	movq	%r14, %rcx
	negq	%rcx
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	xorl	%ebx, %ebx
	movq	%rsi, -128(%rbp)                ## 8-byte Spill
	movq	%rsi, %r12
	xorl	%ecx, %ecx
	movq	%r10, -48(%rbp)                 ## 8-byte Spill
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_4:                                 ##   in Loop: Header=BB0_3 Depth=1
	movl	%ecx, %edx
LBB0_23:                                ##   in Loop: Header=BB0_3 Depth=1
	addq	%r10, %r12
	decq	%r13
	movq	-176(%rbp), %rbx                ## 8-byte Reload
	incq	%rbx
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	addq	%rcx, %rax
	addq	%rcx, %r11
	addq	%rcx, %rdi
	addq	%rcx, %r15
	movl	%edx, %ecx
	cmpq	-168(%rbp), %r13                ## 8-byte Folded Reload
	jle	LBB0_24
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_13 Depth 2
                                        ##     Child Loop BB0_22 Depth 2
	testl	%r9d, %r9d
	movq	%rbx, -176(%rbp)                ## 8-byte Spill
	jle	LBB0_4
## %bb.5:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%r13, %rdx
	imulq	-160(%rbp), %rdx                ## 8-byte Folded Reload
	movq	-152(%rbp), %rsi                ## 8-byte Reload
	leaq	(%rsi,%rdx,4), %rsi
	movq	%rsi, -64(%rbp)                 ## 8-byte Spill
	movq	-144(%rbp), %rsi                ## 8-byte Reload
	leaq	(%rsi,%rdx,4), %rdx
	movq	%rdx, -56(%rbp)                 ## 8-byte Spill
	cmpl	$8, %r14d
	jae	LBB0_7
## %bb.6:                               ##   in Loop: Header=BB0_3 Depth=1
	xorl	%r8d, %r8d
	testb	$1, %r14b
	je	LBB0_18
	jmp	LBB0_19
	.p2align	4, 0x90
LBB0_7:                                 ##   in Loop: Header=BB0_3 Depth=1
	imulq	%rbx, %r10
	addq	-128(%rbp), %r10                ## 8-byte Folded Reload
	movq	-72(%rbp), %rsi                 ## 8-byte Reload
	imulq	%rbx, %rsi
	movq	-120(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rsi), %r8
	movq	%r10, %rdx
	subq	%r8, %rdx
	cmpq	$32, %rdx
	jb	LBB0_8
## %bb.9:                               ##   in Loop: Header=BB0_3 Depth=1
	addq	-112(%rbp), %rsi                ## 8-byte Folded Reload
	subq	%rsi, %r10
	cmpq	$32, %r10
	jb	LBB0_8
## %bb.10:                              ##   in Loop: Header=BB0_3 Depth=1
	movd	%ecx, %xmm0
	cmpq	$0, -96(%rbp)                   ## 8-byte Folded Reload
	movq	-48(%rbp), %r10                 ## 8-byte Reload
	pxor	%xmm1, %xmm1
	je	LBB0_11
## %bb.12:                              ##   in Loop: Header=BB0_3 Depth=1
	movq	-80(%rbp), %rsi                 ## 8-byte Reload
	xorl	%edx, %edx
	.p2align	4, 0x90
LBB0_13:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	-48(%rax,%rdx,4), %xmm2
	movdqu	-32(%rax,%rdx,4), %xmm3
	movdqu	-48(%r11,%rdx,4), %xmm4
	movdqu	-32(%r11,%rdx,4), %xmm5
	pxor	%xmm4, %xmm2
	por	%xmm0, %xmm2
	pxor	%xmm5, %xmm3
	por	%xmm1, %xmm3
	movdqu	%xmm4, (%r12,%rdx,4)
	movdqu	%xmm5, 16(%r12,%rdx,4)
	movdqu	-16(%rax,%rdx,4), %xmm0
	movdqu	(%rax,%rdx,4), %xmm1
	movdqu	-16(%r11,%rdx,4), %xmm4
	movdqu	(%r11,%rdx,4), %xmm5
	pxor	%xmm4, %xmm0
	por	%xmm2, %xmm0
	pxor	%xmm5, %xmm1
	por	%xmm3, %xmm1
	movdqu	%xmm4, 32(%r12,%rdx,4)
	movdqu	%xmm5, 48(%r12,%rdx,4)
	addq	$16, %rdx
	addq	$-2, %rsi
	jne	LBB0_13
## %bb.14:                              ##   in Loop: Header=BB0_3 Depth=1
	testb	$1, -88(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_16
LBB0_15:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	movdqu	(%rcx,%rdx,4), %xmm2
	movdqu	16(%rcx,%rdx,4), %xmm3
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	movdqu	(%rcx,%rdx,4), %xmm4
	movdqu	16(%rcx,%rdx,4), %xmm5
	pxor	%xmm4, %xmm2
	por	%xmm2, %xmm0
	pxor	%xmm5, %xmm3
	por	%xmm3, %xmm1
	movdqu	%xmm4, (%r12,%rdx,4)
	movdqu	%xmm5, 16(%r12,%rdx,4)
LBB0_16:                                ##   in Loop: Header=BB0_3 Depth=1
	por	%xmm1, %xmm0
	pshufd	$238, %xmm0, %xmm1              ## xmm1 = xmm0[2,3,2,3]
	por	%xmm0, %xmm1
	pshufd	$85, %xmm1, %xmm0               ## xmm0 = xmm1[1,1,1,1]
	por	%xmm1, %xmm0
	movd	%xmm0, %ecx
	movq	-104(%rbp), %rsi                ## 8-byte Reload
	movq	%rsi, %r8
	movl	%ecx, %edx
	cmpq	%r14, %rsi
	je	LBB0_23
	.p2align	4, 0x90
## %bb.17:                              ##   in Loop: Header=BB0_3 Depth=1
	testb	$1, %r14b
	jne	LBB0_19
LBB0_18:                                ##   in Loop: Header=BB0_3 Depth=1
                                        ## implicit-def: $edx
	movq	%r8, %rsi
	jmp	LBB0_20
LBB0_8:                                 ##   in Loop: Header=BB0_3 Depth=1
	xorl	%r8d, %r8d
	movq	-48(%rbp), %r10                 ## 8-byte Reload
	testb	$1, %r14b
	je	LBB0_18
LBB0_19:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	movl	(%rdx,%r8,4), %esi
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movl	(%rdx,%r8,4), %edx
	xorl	%esi, %edx
	orl	%ecx, %edx
	movl	%esi, (%r12,%r8,4)
	movq	%r8, %rsi
	orq	$1, %rsi
	movl	%edx, %ecx
LBB0_20:                                ##   in Loop: Header=BB0_3 Depth=1
	notq	%r8
	cmpq	-136(%rbp), %r8                 ## 8-byte Folded Reload
	je	LBB0_23
## %bb.21:                              ##   in Loop: Header=BB0_3 Depth=1
	movl	%ecx, %edx
	.p2align	4, 0x90
LBB0_22:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdi,%rsi,4), %ecx
	movl	(%r15,%rsi,4), %ebx
	xorl	%ecx, %ebx
	orl	%edx, %ebx
	movl	%ecx, (%r12,%rsi,4)
	movl	4(%rdi,%rsi,4), %ecx
	movl	4(%r15,%rsi,4), %edx
	xorl	%ecx, %edx
	orl	%ebx, %edx
	movl	%ecx, 4(%r12,%rsi,4)
	addq	$2, %rsi
	cmpq	%rsi, %r14
	jne	LBB0_22
	jmp	LBB0_23
LBB0_11:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%edx, %edx
	testb	$1, -88(%rbp)                   ## 1-byte Folded Reload
	jne	LBB0_15
	jmp	LBB0_16
LBB0_1:
	xorl	%edx, %edx
LBB0_24:
	xorl	%eax, %eax
	testl	%edx, %edx
	setne	%al
	addq	$8, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_copy_region_enc
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function copy_region_enc
_copy_region_enc:                       ; @copy_region_enc
	.cfi_startproc
; %bb.0:
	stp	x20, x19, [sp, #-16]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 16
	.cfi_offset w19, -8
	.cfi_offset w20, -16
                                        ; kill: def $w2 killed $w2 def $x2
	cmp	w4, #1
	b.lt	LBB0_12
; %bb.1:
	mov	x8, #0
	mov	w19, #0
	add	w16, w4, w2
	add	w13, w3, w3, lsl #1
	sxtw	x17, w13
	add	w12, w5, w5, lsl #1
	cmp	w12, #1
	csinc	w9, w12, wzr, gt
	sxtw	x10, w16
	sxtw	x11, w2
	sbfiz	x12, x12, #2, #32
	smull	x14, w6, w16
	lsl	x14, x14, #2
	sbfiz	x15, x13, #2, #32
	add	x13, x14, x7
	add	x13, x13, x15
	add	x14, x14, x0
	add	x14, x14, x15
	sub	x15, x8, w6, sxtw #2
	smaddl	x17, w6, w16, x17
	and	x16, x9, #0x7ffffff0
	lsl	x3, x17, #2
	add	x17, x7, x3
	add	x2, x17, #32
	add	x0, x0, x3
	mov	x3, x1
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	sub	x10, x10, #1
	add	x8, x8, #1
	add	x3, x3, x12
	add	x2, x2, x15
	add	x0, x0, x15
	add	x17, x17, x15
	cmp	x10, x11
	b.le	LBB0_13
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_9 Depth 2
                                        ;     Child Loop BB0_11 Depth 2
	cmp	w5, #1
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	cmp	w9, #16
	b.hs	LBB0_6
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x4, #0
	b	LBB0_11
LBB0_6:                                 ;   in Loop: Header=BB0_3 Depth=1
	mov	x4, #0
	madd	x6, x12, x8, x1
	mul	x7, x15, x8
	add	x20, x13, x7
	sub	x20, x6, x20
	cmp	x20, #64
	b.lo	LBB0_11
; %bb.7:                                ;   in Loop: Header=BB0_3 Depth=1
	add	x7, x14, x7
	sub	x6, x6, x7
	cmp	x6, #64
	b.lo	LBB0_11
; %bb.8:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x4, #0
	movi.2d	v0, #0000000000000000
	mov.s	v0[0], w19
	movi.2d	v1, #0000000000000000
	mov	x6, x16
	movi.2d	v2, #0000000000000000
	movi.2d	v3, #0000000000000000
LBB0_9:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x7, x2, x4
	ldp	q4, q5, [x7, #-32]
	ldp	q6, q7, [x7]
	add	x7, x0, x4
	ldp	q16, q17, [x7]
	ldp	q18, q19, [x7, #32]
	eor.16b	v4, v16, v4
	eor.16b	v5, v17, v5
	eor.16b	v6, v18, v6
	eor.16b	v7, v19, v7
	orr.16b	v0, v4, v0
	orr.16b	v1, v5, v1
	orr.16b	v2, v6, v2
	orr.16b	v3, v7, v3
	add	x7, x3, x4
	stp	q16, q17, [x7]
	stp	q18, q19, [x7, #32]
	add	x4, x4, #64
	subs	x6, x6, #16
	b.ne	LBB0_9
; %bb.10:                               ;   in Loop: Header=BB0_3 Depth=1
	orr.16b	v0, v1, v0
	orr.16b	v0, v2, v0
	orr.16b	v0, v3, v0
	ext.16b	v1, v0, v0, #8
	orr.8b	v0, v0, v1
	fmov	w4, s0
	mov.s	w6, v0[1]
	orr	w19, w4, w6
	mov	x4, x16
	cmp	x16, x9
	b.eq	LBB0_2
LBB0_11:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x6, x4, #2
	ldr	w7, [x17, x6]
	ldr	w20, [x0, x6]
	eor	w7, w20, w7
	orr	w19, w7, w19
	str	w20, [x3, x6]
	add	x4, x4, #1
	cmp	x9, x4
	b.ne	LBB0_11
	b	LBB0_2
LBB0_12:
	mov	w19, #0
LBB0_13:
	cmp	w19, #0
	cset	w0, ne
	ldp	x20, x19, [sp], #16             ; 16-byte Folded Reload
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_copy_region_enc
.subsections_via_symbols
