	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function yvu9_to_yuy2_c
_yvu9_to_yuy2_c:                        ## @yvu9_to_yuy2_c
	.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	$40, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%r8d, -60(%rbp)                 ## 4-byte Spill
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	movq	%rdx, -96(%rbp)                 ## 8-byte Spill
	movq	%rsi, -88(%rbp)                 ## 8-byte Spill
	testl	%r9d, %r9d
	jle	LBB0_20
## %bb.1:
	movl	-60(%rbp), %eax                 ## 4-byte Reload
	movl	%eax, %r10d
	shrl	$31, %r10d
	addl	%eax, %r10d
	sarl	%r10d
	movslq	16(%rbp), %rax
	movq	%rax, -192(%rbp)                ## 8-byte Spill
	movslq	40(%rbp), %rsi
	movl	%r9d, %eax
	movq	%rax, -208(%rbp)                ## 8-byte Spill
	leaq	-1(%r10), %r9
	leaq	(,%r10,8), %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	movl	$4, %ecx
	movl	%r9d, %eax
	mull	%ecx
	movq	-88(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%r10,4), %rcx
	movq	%rcx, -144(%rbp)                ## 8-byte Spill
	leaq	(,%r10,4), %rbx
	seto	%cl
	testl	%eax, %eax
	sets	%al
	movq	%r9, %rdx
	shrq	$32, %rdx
	setne	%dl
	orb	%cl, %dl
	orb	%al, %dl
	movb	%dl, -42(%rbp)                  ## 1-byte Spill
	movl	$32, %ecx
	movq	%r9, %rax
	mulq	%rcx
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	seto	-41(%rbp)                       ## 1-byte Folded Spill
	movl	%r10d, %eax
	andl	$-4, %eax
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	movq	%rbx, -136(%rbp)                ## 8-byte Spill
	andq	$-16, %rbx
	movq	%rbx, -112(%rbp)                ## 8-byte Spill
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%r10,4), %rax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	movq	%rsi, -168(%rbp)                ## 8-byte Spill
	leaq	(,%rsi,4), %rax
	movq	%rax, -200(%rbp)                ## 8-byte Spill
	xorl	%eax, %eax
	movabsq	$17179869184, %rcx              ## imm = 0x400000000
	movq	-80(%rbp), %r11                 ## 8-byte Reload
	movq	%rdi, -72(%rbp)                 ## 8-byte Spill
	movq	%r10, -56(%rbp)                 ## 8-byte Spill
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_2:                                 ##   in Loop: Header=BB0_3 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	incq	%rax
	addq	-200(%rbp), %r11                ## 8-byte Folded Reload
	cmpq	-208(%rbp), %rax                ## 8-byte Folded Reload
	je	LBB0_20
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_13 Depth 2
                                        ##     Child Loop BB0_19 Depth 2
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	cmpl	$2, -60(%rbp)                   ## 4-byte Folded Reload
	jl	LBB0_2
## %bb.4:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%rcx, %r8
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movl	%eax, %edx
	shrl	$2, %edx
	movl	24(%rbp), %esi
	imull	%edx, %esi
	imull	32(%rbp), %edx
	movq	%rax, %r13
	imulq	-192(%rbp), %r13                ## 8-byte Folded Reload
	movslq	%esi, %rsi
	movq	-88(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rsi,4), %r12
	movslq	%edx, %rdx
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rdx,4), %r14
	leaq	(%rdi,%r13,4), %r15
	cmpl	$4, %r10d
	jae	LBB0_6
## %bb.5:                               ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
	jmp	LBB0_18
	.p2align	4, 0x90
LBB0_6:                                 ##   in Loop: Header=BB0_3 Depth=1
	movq	%rdx, -176(%rbp)                ## 8-byte Spill
	movq	%rsi, -184(%rbp)                ## 8-byte Spill
	movq	%rax, %rdx
	imulq	-168(%rbp), %rdx                ## 8-byte Folded Reload
	movq	-80(%rbp), %rsi                 ## 8-byte Reload
	leaq	(%rsi,%rdx,4), %rbx
	addq	$24, %rbx
	leaq	28(%rsi,%rdx,4), %r10
	leaq	(%rsi,%rdx,4), %rax
	addq	$20, %rax
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rbx,%rcx), %r9
	cmpq	%rbx, %r9
	setb	%bl
	movb	-41(%rbp), %dil                 ## 1-byte Reload
	orb	%dil, %bl
	leaq	(%r10,%rcx), %rsi
	cmpq	%r10, %rsi
	setb	%r9b
	leaq	(%rax,%rcx), %rsi
	cmpq	%rax, %rsi
	setb	%al
	orb	-42(%rbp), %bl                  ## 1-byte Folded Reload
	jne	LBB0_15
## %bb.7:                               ##   in Loop: Header=BB0_3 Depth=1
	orb	%dil, %r9b
	jne	LBB0_15
## %bb.8:                               ##   in Loop: Header=BB0_3 Depth=1
	orb	%dil, %al
	movl	$0, %ebx
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	jne	LBB0_18
## %bb.9:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rdx), %rsi
	addq	-136(%rbp), %r13                ## 8-byte Folded Reload
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rdx,4), %rbx
	leaq	(%rcx,%rsi,4), %rsi
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	movq	-184(%rbp), %rax                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rdx
	movq	-128(%rbp), %rcx                ## 8-byte Reload
	movq	-176(%rbp), %rax                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r9
	leaq	(%rdi,%r13,4), %rax
	cmpq	%rdx, %rbx
	setb	%r10b
	cmpq	%rsi, %r12
	setb	%cl
	cmpq	%r9, %rbx
	setb	%dl
	cmpq	%rsi, %r14
	setb	%r9b
	cmpq	%rax, %rbx
	setb	%al
	cmpq	%rsi, %r15
	setb	%sil
	testb	%cl, %r10b
	jne	LBB0_16
## %bb.10:                              ##   in Loop: Header=BB0_3 Depth=1
	andb	%r9b, %dl
	jne	LBB0_16
## %bb.11:                              ##   in Loop: Header=BB0_3 Depth=1
	movl	$0, %ebx
	andb	%sil, %al
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	jne	LBB0_18
## %bb.12:                              ##   in Loop: Header=BB0_3 Depth=1
	xorl	%r13d, %r13d
	xorl	%r10d, %r10d
	movq	-112(%rbp), %rcx                ## 8-byte Reload
	movabsq	$68719476736, %rdx              ## imm = 0x1000000000
	.p2align	4, 0x90
LBB0_13:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%r10, %rax
	sarq	$30, %rax
	movdqu	(%r15,%rax), %xmm10
	movdqu	16(%r15,%rax), %xmm1
	movdqu	32(%r15,%rax), %xmm12
	movdqu	48(%r15,%rax), %xmm8
	movdqa	%xmm12, %xmm3
	punpckldq	%xmm8, %xmm3            ## xmm3 = xmm3[0],xmm8[0],xmm3[1],xmm8[1]
	pshufd	$68, %xmm3, %xmm9               ## xmm9 = xmm3[0,1,0,1]
	pshufd	$85, %xmm10, %xmm6              ## xmm6 = xmm10[1,1,1,1]
	pblendw	$12, %xmm1, %xmm6               ## xmm6 = xmm6[0,1],xmm1[2,3],xmm6[4,5,6,7]
	pshufd	$170, %xmm8, %xmm7              ## xmm7 = xmm8[2,2,2,2]
	pblendw	$63, %xmm12, %xmm7              ## xmm7 = xmm12[0,1,2,3,4,5],xmm7[6,7]
	movdqa	%xmm10, %xmm4
	punpckhdq	%xmm1, %xmm4            ## xmm4 = xmm4[2],xmm1[2],xmm4[3],xmm1[3]
	pshufd	$238, %xmm4, %xmm2              ## xmm2 = xmm4[2,3,2,3]
	movdqu	(%r12,%r13), %xmm0
	movdqu	(%r14,%r13), %xmm11
	punpckldq	%xmm0, %xmm4            ## xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
	punpckldq	%xmm11, %xmm2           ## xmm2 = xmm2[0],xmm11[0],xmm2[1],xmm11[1]
	punpcklqdq	%xmm2, %xmm4            ## xmm4 = xmm4[0],xmm2[0]
	punpckldq	%xmm0, %xmm10           ## xmm10 = xmm10[0],xmm0[0],xmm10[1],xmm0[1]
	punpckldq	%xmm11, %xmm6           ## xmm6 = xmm6[0],xmm11[0],xmm6[1],xmm11[1]
	punpcklqdq	%xmm6, %xmm10           ## xmm10 = xmm10[0],xmm6[0]
	pshufd	$170, %xmm1, %xmm5              ## xmm5 = xmm1[2,2,2,2]
	pblendw	$12, %xmm0, %xmm5               ## xmm5 = xmm5[0,1],xmm0[2,3],xmm5[4,5,6,7]
	pblendw	$240, %xmm2, %xmm5              ## xmm5 = xmm5[0,1,2,3],xmm2[4,5,6,7]
	pblendw	$12, %xmm0, %xmm1               ## xmm1 = xmm1[0,1],xmm0[2,3],xmm1[4,5,6,7]
	pblendw	$240, %xmm6, %xmm1              ## xmm1 = xmm1[0,1,2,3],xmm6[4,5,6,7]
	pshufd	$170, %xmm11, %xmm2             ## xmm2 = xmm11[2,2,2,2]
	punpckhdq	%xmm2, %xmm12           ## xmm12 = xmm12[2],xmm2[2],xmm12[3],xmm2[3]
	punpckhdq	%xmm0, %xmm7            ## xmm7 = xmm7[2],xmm0[2],xmm7[3],xmm0[3]
	pblendw	$15, %xmm7, %xmm12              ## xmm12 = xmm7[0,1,2,3],xmm12[4,5,6,7]
	pblendw	$63, %xmm3, %xmm2               ## xmm2 = xmm3[0,1,2,3,4,5],xmm2[6,7]
	punpckhdq	%xmm0, %xmm9            ## xmm9 = xmm9[2],xmm0[2],xmm9[3],xmm0[3]
	pblendw	$15, %xmm9, %xmm2               ## xmm2 = xmm9[0,1,2,3],xmm2[4,5,6,7]
	punpckhdq	%xmm11, %xmm8           ## xmm8 = xmm8[2],xmm11[2],xmm8[3],xmm11[3]
	punpckhqdq	%xmm8, %xmm7            ## xmm7 = xmm7[1],xmm8[1]
	punpckhdq	%xmm11, %xmm3           ## xmm3 = xmm3[2],xmm11[2],xmm3[3],xmm11[3]
	punpckhqdq	%xmm3, %xmm9            ## xmm9 = xmm9[1],xmm3[1]
	movdqu	%xmm9, 96(%r11,%r13,8)
	movdqu	%xmm7, 112(%r11,%r13,8)
	movdqu	%xmm2, 64(%r11,%r13,8)
	movdqu	%xmm12, 80(%r11,%r13,8)
	movdqu	%xmm1, 32(%r11,%r13,8)
	movdqu	%xmm5, 48(%r11,%r13,8)
	movdqu	%xmm10, (%r11,%r13,8)
	movdqu	%xmm4, 16(%r11,%r13,8)
	addq	%rdx, %r10
	addq	$16, %r13
	cmpq	%r13, %rcx
	jne	LBB0_13
## %bb.14:                              ##   in Loop: Header=BB0_3 Depth=1
	movq	-120(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %rbx
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	cmpq	%r10, %rax
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	movq	%r8, %rcx
	je	LBB0_2
	jmp	LBB0_18
LBB0_15:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_17
LBB0_16:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
LBB0_17:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_3 Depth=1
	leal	3(,%rbx,4), %eax
	movq	%rbx, %rsi
	shlq	$34, %rsi
	movq	%r10, %r9
	subq	%rbx, %r9
	shlq	$2, %rbx
	.p2align	4, 0x90
LBB0_19:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	%rsi, %rdx
	sarq	$30, %rdx
	movl	(%r15,%rdx), %ecx
	movl	%ecx, (%r11,%rbx,8)
	movl	(%r12,%rbx), %ecx
	movl	%ecx, 4(%r11,%rbx,8)
	movq	%rdx, %rcx
	orq	$4, %rcx
	movl	(%r15,%rcx), %ecx
	movl	%ecx, 8(%r11,%rbx,8)
	movl	(%r14,%rbx), %ecx
	movl	%ecx, 12(%r11,%rbx,8)
	orq	$8, %rdx
	movl	(%r15,%rdx), %ecx
	movl	%ecx, 16(%r11,%rbx,8)
	movl	(%r12,%rbx), %ecx
	movl	%ecx, 20(%r11,%rbx,8)
	cltq
	movl	(%r15,%rax,4), %ecx
	movl	%ecx, 24(%r11,%rbx,8)
	movl	(%r14,%rbx), %ecx
	movl	%ecx, 28(%r11,%rbx,8)
	movq	%r8, %rcx
	addl	$4, %eax
	addq	%r8, %rsi
	addq	$4, %rbx
	decq	%r9
	jne	LBB0_19
	jmp	LBB0_2
LBB0_20:
	addq	$40, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_yvu9_to_yuy2_c
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function yvu9_to_yuy2_c
_yvu9_to_yuy2_c:                        ; @yvu9_to_yuy2_c
	.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
	.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
                                        ; kill: def $w6 killed $w6 def $x6
	cmp	w5, #1
	b.lt	LBB0_17
; %bb.1:
	mov	x17, x3
	mov	x8, #0
	ldp	w9, w14, [sp, #144]
	cmp	w4, #0
	cinc	w10, w4, lt
	asr	w10, w10, #1
	sxtw	x11, w6
	sxtw	x12, w14
	str	x12, [sp, #40]                  ; 8-byte Folded Spill
	mov	w13, w5
	sub	x15, x10, #1
	lsl	x12, x10, #3
	str	x12, [sp, #32]                  ; 8-byte Folded Spill
	lsl	x12, x10, #2
	add	x16, x1, x12
	stp	x16, x12, [sp, #16]             ; 16-byte Folded Spill
	add	x12, x2, x12
	str	x12, [sp, #8]                   ; 8-byte Folded Spill
	and	x16, x15, #0xffffffff
	lsl	x16, x16, #2
	tst	x16, #0xffffffff00000000
	ccmp	w16, #0, #8, eq
	cset	w16, lt
	tst	x15, #0xffffffff00000000
	cset	w3, ne
	orr	w5, w16, w3
	lsl	x6, x15, #5
	cmp	xzr, x15, lsr #59
	cset	w19, ne
	and	x12, x10, #0xfffffffe
	str	x12, [sp]                       ; 8-byte Folded Spill
	sbfiz	x21, x14, #2, #32
	mov	x22, #17179869184
	mov	x23, #34359738368
	mov	x3, x17
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x8, x8, #1
	add	x3, x3, x21
	cmp	x8, x13
	b.eq	LBB0_17
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_13 Depth 2
                                        ;     Child Loop BB0_16 Depth 2
	cmp	w4, #2
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	ubfx	x14, x8, #2, #30
	mul	w26, w7, w14
	mul	w27, w9, w14
	mul	x14, x8, x11
	add	x25, x0, x14, lsl #2
	cmp	w10, #2
	b.hs	LBB0_6
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x28, #0
	b	LBB0_15
LBB0_6:                                 ;   in Loop: Header=BB0_3 Depth=1
	mov	x28, #0
	ldr	x12, [sp, #40]                  ; 8-byte Folded Reload
	mul	x24, x8, x12
	add	x20, x17, x24, lsl #2
	add	x15, x20, #24
	add	x30, x20, #28
	add	x16, x20, #20
	add	x12, x15, x6
	cmp	x12, x15
	cset	w12, lo
	add	x15, x30, x6
	cmp	x15, x30
	cset	w15, lo
	add	x30, x16, x6
	cmp	x30, x16
	orr	w12, w12, w19
	cset	w30, lo
	orr	w12, w5, w12
	tbnz	w12, #0, LBB0_15
; %bb.7:                                ;   in Loop: Header=BB0_3 Depth=1
	orr	w12, w15, w19
	tbnz	w12, #0, LBB0_15
; %bb.8:                                ;   in Loop: Header=BB0_3 Depth=1
	orr	w12, w30, w19
	tbnz	w12, #0, LBB0_15
; %bb.9:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x28, #0
	sbfiz	x12, x26, #2, #32
	sbfiz	x15, x27, #2, #32
	add	x30, x2, x15
	ldr	x16, [sp, #32]                  ; 8-byte Folded Reload
	add	x16, x16, x24
	add	x16, x17, x16, lsl #2
	ldr	x24, [sp, #24]                  ; 8-byte Folded Reload
	add	x14, x24, x14
	add	x14, x0, x14, lsl #2
	ldr	x24, [sp, #8]                   ; 8-byte Folded Reload
	add	x15, x24, x15
	cmp	x20, x15
	ccmp	x30, x16, #2, lo
	cset	w24, lo
	cmp	x20, x14
	ccmp	x25, x16, #2, lo
	cset	w15, lo
	add	x14, x1, x12
	cmp	x14, x16
	ldr	x16, [sp, #16]                  ; 8-byte Folded Reload
	add	x12, x16, x12
	ccmp	x20, x12, #2, lo
	b.lo	LBB0_15
; %bb.10:                               ;   in Loop: Header=BB0_3 Depth=1
	tbnz	w24, #0, LBB0_15
; %bb.11:                               ;   in Loop: Header=BB0_3 Depth=1
	tbnz	w15, #0, LBB0_15
; %bb.12:                               ;   in Loop: Header=BB0_3 Depth=1
	mov	x28, #0
	ldr	x20, [sp]                       ; 8-byte Folded Reload
	mov	x24, x3
LBB0_13:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x12, x25, x28, asr #30
	ld4.2s	{ v0, v1, v2, v3 }, [x12]
	ldr	d4, [x14], #8
	mov.d	v0[1], v4[0]
	ldr	d5, [x30], #8
	mov.d	v1[1], v5[0]
	mov.d	v2[1], v4[0]
	mov.d	v3[1], v5[0]
	uzp1.4s	v4, v0, v1
	uzp1.4s	v5, v2, v3
	uzp2.4s	v6, v0, v1
	uzp2.4s	v0, v2, v3
	stp	q6, q0, [x24, #32]
	stp	q4, q5, [x24], #64
	add	x28, x28, x23
	subs	x20, x20, #2
	b.ne	LBB0_13
; %bb.14:                               ;   in Loop: Header=BB0_3 Depth=1
	ldr	x12, [sp]                       ; 8-byte Folded Reload
	mov	x28, x12
	cmp	x12, x10
	b.eq	LBB0_2
LBB0_15:                                ;   in Loop: Header=BB0_3 Depth=1
	sxtw	x12, w26
	sxtw	x15, w27
	mov	w14, #3
	bfi	w14, w28, #2, #30
	lsl	x26, x28, #34
	sub	x27, x10, x28
	add	x12, x28, x12
	add	x30, x1, x12, lsl #2
	add	x12, x28, x15
	add	x20, x2, x12, lsl #2
	add	x24, x3, x28, lsl #5
LBB0_16:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	asr	x12, x26, #30
	ldr	w15, [x25, x12]
	str	w15, [x24]
	ldr	w15, [x30]
	str	w15, [x24, #4]
	orr	x15, x12, #0x4
	ldr	w15, [x25, x15]
	str	w15, [x24, #8]
	ldr	w15, [x20]
	str	w15, [x24, #12]
	orr	x12, x12, #0x8
	ldr	w12, [x25, x12]
	str	w12, [x24, #16]
	ldr	w12, [x30], #4
	str	w12, [x24, #20]
	ldr	w12, [x25, w14, sxtw #2]
	str	w12, [x24, #24]
	ldr	w12, [x20], #4
	str	w12, [x24, #28]
	add	w14, w14, #4
	add	x26, x26, x22
	add	x24, x24, #32
	subs	x27, x27, #1
	b.ne	LBB0_16
	b	LBB0_2
LBB0_17:
	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
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_yvu9_to_yuy2_c
.subsections_via_symbols
