	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ## -- Begin function gbr16ptopacked16
LCPI0_0:
	.long	65535                           ## 0xffff
	.long	65535                           ## 0xffff
	.long	65535                           ## 0xffff
	.long	65535                           ## 0xffff
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_gbr16ptopacked16:                      ## @gbr16ptopacked16
	.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	$216, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rdx, -80(%rbp)                 ## 8-byte Spill
	testl	%r8d, %r8d
	jle	LBB0_82
## %bb.1:
	movq	%rdi, %rbx
	movl	24(%rbp), %eax
	movl	$16, %r13d
	subl	%eax, %r13d
	leal	(%rax,%rax), %r12d
	addl	$-16, %r12d
	movq	24(%rdi), %rax
	xorl	%edi, %edi
	movq	%rax, -256(%rbp)                ## 8-byte Spill
	testq	%rax, %rax
	setne	%dil
	testl	%r9d, %r9d
	sete	%al
	setne	%dl
	orb	%dil, %al
	movb	%al, -50(%rbp)                  ## 1-byte Spill
	andb	%dil, %dl
	movb	%dl, -49(%rbp)                  ## 1-byte Spill
	movslq	%ecx, %rax
	movl	%r8d, %ecx
	movq	%rcx, -240(%rbp)                ## 8-byte Spill
	movl	32(%rbp), %r8d
	addq	$3, %rdi
	movq	%rdi, -120(%rbp)                ## 8-byte Spill
	movl	%edi, %edx
	andl	$-4, %edx
	movq	%rdx, -224(%rbp)                ## 8-byte Spill
	addq	$-4, %rdx
	movq	%rdx, -216(%rbp)                ## 8-byte Spill
	movq	%rdx, %rdi
	shrq	$2, %rdi
	incq	%rdi
	movl	%r8d, %ecx
	andl	$-4, %ecx
	movd	%r13d, %xmm0
	movd	%r12d, %xmm1
	movq	%rdi, %rdx
	movq	%rdi, -208(%rbp)                ## 8-byte Spill
	andq	$-2, %rdi
	movq	%rdi, -200(%rbp)                ## 8-byte Spill
	leaq	(,%r8,4), %rdx
	movq	%rdx, -72(%rbp)                 ## 8-byte Spill
	andq	$-16, %rdx
	movq	%rdx, -88(%rbp)                 ## 8-byte Spill
	pmovzxdq	%xmm0, %xmm0                    ## xmm0 = xmm0[0],zero,xmm0[1],zero
	movdqa	%xmm0, -176(%rbp)               ## 16-byte Spill
	pmovzxdq	%xmm1, %xmm0                    ## xmm0 = xmm1[0],zero,xmm1[1],zero
	movdqa	%xmm0, -160(%rbp)               ## 16-byte Spill
	movl	16(%rbp), %edx
	leaq	(%r8,%r8,2), %rdi
	movq	%rdi, -192(%rbp)                ## 8-byte Spill
	leaq	(,%rcx,4), %rdi
	movq	%rdi, -104(%rbp)                ## 8-byte Spill
	movq	%rcx, -96(%rbp)                 ## 8-byte Spill
	leaq	(%rcx,%rcx,2), %rcx
	movq	%rcx, -184(%rbp)                ## 8-byte Spill
	movq	%rax, -248(%rbp)                ## 8-byte Spill
	leaq	(,%rax,4), %rax
	movq	%rax, -232(%rbp)                ## 8-byte Spill
	xorl	%r8d, %r8d
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	movl	%r13d, -48(%rbp)                ## 4-byte Spill
	movl	%r12d, -44(%rbp)                ## 4-byte Spill
	movq	%rsi, -128(%rbp)                ## 8-byte Spill
	movq	%rbx, -112(%rbp)                ## 8-byte Spill
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_81:                                ##   in Loop: Header=BB0_2 Depth=1
	incq	%r8
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	addq	-232(%rbp), %rax                ## 8-byte Folded Reload
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	cmpq	-240(%rbp), %r8                 ## 8-byte Folded Reload
	movl	16(%rbp), %edx
	je	LBB0_82
LBB0_2:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_46 Depth 2
                                        ##     Child Loop BB0_48 Depth 2
                                        ##     Child Loop BB0_57 Depth 2
                                        ##     Child Loop BB0_59 Depth 2
                                        ##     Child Loop BB0_68 Depth 2
                                        ##     Child Loop BB0_70 Depth 2
                                        ##     Child Loop BB0_8 Depth 2
                                        ##     Child Loop BB0_12 Depth 2
                                        ##     Child Loop BB0_15 Depth 2
                                        ##     Child Loop BB0_19 Depth 2
                                        ##     Child Loop BB0_23 Depth 2
                                        ##     Child Loop BB0_26 Depth 2
                                        ##     Child Loop BB0_30 Depth 2
                                        ##     Child Loop BB0_34 Depth 2
                                        ##     Child Loop BB0_37 Depth 2
                                        ##     Child Loop BB0_76 Depth 2
                                        ##     Child Loop BB0_80 Depth 2
	movq	%r8, %rdi
	imulq	-248(%rbp), %rdi                ## 8-byte Folded Reload
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rdi,4), %r14
	cmpl	$1, %edx
	movq	%r8, -136(%rbp)                 ## 8-byte Spill
	je	LBB0_27
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$2, %edx
	je	LBB0_16
## %bb.4:                               ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$3, %edx
	jne	LBB0_38
## %bb.5:                               ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -50(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_6
## %bb.9:                               ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -49(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_10
## %bb.13:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.14:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r13d, %r14d
	movl	%r12d, %r13d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_15:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r13d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	movl	%eax, (%r15,%rbx,4)
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r13d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r15,%rbx,4)
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r13d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r15,%rbx,4)
	movq	24(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r13d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 12(%r15,%rbx,4)
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_15
	jmp	LBB0_71
	.p2align	4, 0x90
LBB0_27:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -50(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_28
## %bb.31:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -49(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_32
## %bb.35:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.36:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_37:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	-48(%rbp), %r13d                ## 4-byte Reload
	movl	%r13d, %ecx
	shll	%cl, %r14d
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	movl	%eax, (%r15,%rbx,4)
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	%r13d, %ecx
	shll	%cl, %r14d
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movl	%eax, 4(%r15,%rbx,4)
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	%r13d, %ecx
	shll	%cl, %r14d
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movl	%eax, 8(%r15,%rbx,4)
	movq	24(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	%r13d, %ecx
	shll	%cl, %r14d
	movq	24(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movl	%eax, 12(%r15,%rbx,4)
	movl	-44(%rbp), %r15d                ## 4-byte Reload
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_37
	jmp	LBB0_71
	.p2align	4, 0x90
LBB0_16:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -50(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_17
## %bb.20:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -49(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_21
## %bb.24:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.25:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r13d, %r14d
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_26:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movl	%eax, (%r13,%rbx,4)
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r13,%rbx,4)
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r13,%rbx,4)
	movq	24(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 12(%r13,%rbx,4)
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_26
	jmp	LBB0_71
	.p2align	4, 0x90
LBB0_38:                                ##   in Loop: Header=BB0_2 Depth=1
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	addq	%rdi, %rax
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rcx
	cmpb	$0, -50(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_39
## %bb.49:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpb	$0, -49(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_50
## %bb.60:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.61:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	(%rbx), %r11
	movq	8(%rbx), %r10
	movq	16(%rbx), %r13
	movq	24(%rbx), %r15
	cmpl	$4, 32(%rbp)
	jb	LBB0_62
## %bb.63:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	32(%rbp), %eax
	leaq	(%r11,%rax,4), %rbx
	leaq	(%r10,%rax,4), %r8
	leaq	(,%rax,4), %r9
	addq	%r13, %r9
	leaq	(%r15,%rax,4), %rsi
	cmpq	%rbx, %r14
	setb	%dil
	cmpq	%rcx, %r11
	setb	%dl
	cmpq	%r8, %r14
	setb	%bl
	cmpq	%rcx, %r10
	setb	%al
	cmpq	%r9, %r14
	setb	%r8b
	cmpq	%rcx, %r13
	setb	%r12b
	cmpq	%rsi, %r14
	setb	%r9b
	cmpq	%rcx, %r15
	setb	%cl
	testb	%dl, %dil
	jne	LBB0_62
## %bb.64:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%al, %bl
	jne	LBB0_62
## %bb.65:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%r12b, %r8b
	jne	LBB0_62
## %bb.66:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%cl, %r9b
	jne	LBB0_62
## %bb.67:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leaq	(%r14,%rax,4), %r14
	xorl	%ecx, %ecx
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movdqa	-176(%rbp), %xmm8               ## 16-byte Reload
	movdqa	-160(%rbp), %xmm9               ## 16-byte Reload
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_68:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%r11,%rcx), %xmm0
	movdqa	%xmm0, %xmm2
	pslld	%xmm8, %xmm2
	psrad	%xmm9, %xmm0
	movdqu	(%r10,%rcx), %xmm1
	movdqa	%xmm1, %xmm3
	pslld	%xmm8, %xmm3
	psrad	%xmm9, %xmm1
	por	%xmm2, %xmm0
	movdqu	(%r13,%rcx), %xmm2
	movdqa	%xmm2, %xmm4
	pslld	%xmm8, %xmm4
	por	%xmm3, %xmm1
	psrad	%xmm9, %xmm2
	movdqu	(%r15,%rcx), %xmm3
	movdqa	%xmm3, %xmm5
	pslld	%xmm8, %xmm5
	psrad	%xmm9, %xmm3
	por	%xmm4, %xmm2
	por	%xmm5, %xmm3
	movdqa	%xmm2, %xmm4
	punpckldq	%xmm3, %xmm4            ## xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
	pshufd	$85, %xmm0, %xmm5               ## xmm5 = xmm0[1,1,1,1]
	pblendw	$12, %xmm1, %xmm5               ## xmm5 = xmm5[0,1],xmm1[2,3],xmm5[4,5,6,7]
	pblendw	$240, %xmm4, %xmm5              ## xmm5 = xmm5[0,1,2,3],xmm4[4,5,6,7]
	movdqa	%xmm0, %xmm6
	punpckhdq	%xmm1, %xmm6            ## xmm6 = xmm6[2],xmm1[2],xmm6[3],xmm1[3]
	pshufd	$170, %xmm3, %xmm7              ## xmm7 = xmm3[2,2,2,2]
	pblendw	$63, %xmm2, %xmm7               ## xmm7 = xmm2[0,1,2,3,4,5],xmm7[6,7]
	pblendw	$15, %xmm6, %xmm7               ## xmm7 = xmm6[0,1,2,3],xmm7[4,5,6,7]
	punpckldq	%xmm1, %xmm0            ## xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
	punpcklqdq	%xmm4, %xmm0            ## xmm0 = xmm0[0],xmm4[0]
	punpckhdq	%xmm3, %xmm2            ## xmm2 = xmm2[2],xmm3[2],xmm2[3],xmm3[3]
	punpckhqdq	%xmm2, %xmm6            ## xmm6 = xmm6[1],xmm2[1]
	movdqu	%xmm6, 48(%rdx,%rcx,4)
	movdqu	%xmm0, (%rdx,%rcx,4)
	movdqu	%xmm7, 32(%rdx,%rcx,4)
	movdqu	%xmm5, 16(%rdx,%rcx,4)
	addq	$16, %rcx
	cmpq	%rcx, %rax
	jne	LBB0_68
## %bb.69:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	movq	%rcx, %rbx
	movl	32(%rbp), %eax
	cmpq	%rax, %rcx
	movl	-48(%rbp), %esi                 ## 4-byte Reload
	movl	-44(%rbp), %edi                 ## 4-byte Reload
	jne	LBB0_70
	jmp	LBB0_71
LBB0_6:                                 ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.7:                               ##   in Loop: Header=BB0_2 Depth=1
	movl	%r13d, %r14d
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_8:                                 ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movl	%eax, (%r13,%rbx,4)
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r13,%rbx,4)
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r14d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r13,%rbx,4)
	movl	$65535, 12(%r13,%rbx,4)         ## imm = 0xFFFF
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_8
	jmp	LBB0_71
LBB0_28:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.29:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	%rbx, %r15
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_30:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	%r13d, %ecx
	shll	%cl, %r14d
	movq	(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%r12d, %ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movl	%eax, (%r13,%rbx,4)
	movq	8(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	-48(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	shll	%cl, %r14d
	movq	8(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%r12d, %ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movl	%eax, 4(%r13,%rbx,4)
	movq	16(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%eax, %r14d
	movl	-48(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	shll	%cl, %r14d
	movq	16(%r15), %rax
	movl	(%rax,%rbx), %edi
	callq	_av_bswap16
	movl	%r12d, %ecx
	sarl	%cl, %eax
	orl	%r14d, %eax
	movl	%eax, 8(%r13,%rbx,4)
	movl	$65535, 12(%r13,%rbx,4)         ## imm = 0xFFFF
	movl	-48(%rbp), %r13d                ## 4-byte Reload
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_30
	jmp	LBB0_71
LBB0_17:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.18:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r13d, %r14d
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_19:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movl	%eax, (%r13,%rbx,4)
	movq	8(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r13,%rbx,4)
	movq	16(%r12), %rax
	movl	(%rax,%rbx), %edi
	movl	%edi, %eax
	movl	%r14d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r13,%rbx,4)
	movl	$65535, 12(%r13,%rbx,4)         ## imm = 0xFFFF
	addq	$4, %rbx
	cmpq	%rbx, -72(%rbp)                 ## 8-byte Folded Reload
	jne	LBB0_19
	jmp	LBB0_71
LBB0_39:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.40:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	(%rbx), %r13
	movq	8(%rbx), %r8
	movq	16(%rbx), %r15
	cmpl	$4, 32(%rbp)
	jb	LBB0_41
## %bb.42:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	32(%rbp), %eax
	leaq	(,%rax,4), %rdi
	addq	%r13, %rdi
	leaq	(%r8,%rax,4), %rbx
	leaq	(%r15,%rax,4), %r9
	cmpq	%rdi, %r14
	setb	%r10b
	cmpq	%rcx, %r13
	setb	%r11b
	cmpq	%rbx, %r14
	setb	%bl
	cmpq	%rcx, %r8
	setb	%al
	cmpq	%r9, %r14
	setb	%dil
	cmpq	%rcx, %r15
	setb	%cl
	testb	%r11b, %r10b
	jne	LBB0_41
## %bb.43:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%al, %bl
	jne	LBB0_41
## %bb.44:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%cl, %dil
	jne	LBB0_41
## %bb.45:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leaq	(%r14,%rax,4), %r14
	xorl	%ecx, %ecx
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movdqa	-176(%rbp), %xmm8               ## 16-byte Reload
	movdqa	-160(%rbp), %xmm7               ## 16-byte Reload
	movdqa	LCPI0_0(%rip), %xmm9            ## xmm9 = [65535,65535,65535,65535]
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_46:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%r13,%rcx), %xmm0
	movdqa	%xmm0, %xmm2
	pslld	%xmm8, %xmm2
	psrad	%xmm7, %xmm0
	movdqu	(%r8,%rcx), %xmm1
	movdqa	%xmm1, %xmm3
	pslld	%xmm8, %xmm3
	por	%xmm2, %xmm0
	psrad	%xmm7, %xmm1
	movdqu	(%r15,%rcx), %xmm2
	movdqa	%xmm2, %xmm4
	pslld	%xmm8, %xmm4
	psrad	%xmm7, %xmm2
	por	%xmm3, %xmm1
	por	%xmm4, %xmm2
	movdqa	%xmm1, %xmm3
	shufps	$0, %xmm2, %xmm3                ## xmm3 = xmm3[0,0],xmm2[0,0]
	movdqa	%xmm0, %xmm4
	pblendw	$240, %xmm9, %xmm4              ## xmm4 = xmm4[0,1,2,3],xmm9[4,5,6,7]
	pblendw	$60, %xmm3, %xmm4               ## xmm4 = xmm4[0,1],xmm3[2,3,4,5],xmm4[6,7]
	movdqa	%xmm1, %xmm3
	insertps	$105, %xmm2, %xmm3              ## xmm3 = zero,xmm3[1],xmm2[1],zero
	movdqa	%xmm9, %xmm5
	insertps	$70, %xmm0, %xmm5               ## xmm5 = xmm0[1],zero,zero,xmm5[3]
	orps	%xmm3, %xmm5
	movaps	%xmm2, %xmm3
	insertps	$153, %xmm1, %xmm3              ## xmm3 = zero,xmm1[2],xmm3[2],zero
	movdqa	%xmm9, %xmm6
	insertps	$198, %xmm0, %xmm6              ## xmm6 = xmm0[3],zero,zero,xmm6[3]
	punpckhqdq	%xmm9, %xmm0            ## xmm0 = xmm0[1],xmm9[1]
	pblendw	$60, %xmm3, %xmm0               ## xmm0 = xmm0[0,1],xmm3[2,3,4,5],xmm0[6,7]
	shufps	$255, %xmm2, %xmm1              ## xmm1 = xmm1[3,3],xmm2[3,3]
	blendps	$9, %xmm6, %xmm1                ## xmm1 = xmm6[0],xmm1[1,2],xmm6[3]
	movups	%xmm1, 48(%rdx,%rcx,4)
	movdqu	%xmm0, 32(%rdx,%rcx,4)
	movups	%xmm5, 16(%rdx,%rcx,4)
	movdqu	%xmm4, (%rdx,%rcx,4)
	addq	$16, %rcx
	cmpq	%rcx, %rax
	jne	LBB0_46
## %bb.47:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	movq	%rcx, %rdi
	movl	32(%rbp), %eax
	cmpq	%rax, %rcx
	movl	-48(%rbp), %edx                 ## 4-byte Reload
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	jne	LBB0_48
	jmp	LBB0_71
LBB0_10:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.11:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_12:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r13d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, (%r14)
	movq	8(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r13d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r14)
	movq	16(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	callq	_av_bswap16
	movl	%eax, %edi
	movl	%r13d, %ecx
	shll	%cl, %edi
	movl	%r15d, %ecx
	sarl	%cl, %eax
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r14)
	incq	%rbx
	addq	$12, %r14
	movl	32(%rbp), %eax
	cmpq	%rbx, %rax
	jne	LBB0_12
	jmp	LBB0_71
LBB0_32:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.33:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	%rbx, %r12
	xorl	%r13d, %r13d
	.p2align	4, 0x90
LBB0_34:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	%eax, %ebx
	movl	-48(%rbp), %r15d                ## 4-byte Reload
	movl	%r15d, %ecx
	shll	%cl, %ebx
	movq	(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, (%r14)
	movq	8(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	%eax, %ebx
	movl	%r15d, %ecx
	shll	%cl, %ebx
	movq	8(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 4(%r14)
	movq	16(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	%eax, %ebx
	movl	%r15d, %ecx
	shll	%cl, %ebx
	movq	16(%r12), %rax
	movl	(%rax,%r13,4), %edi
	callq	_av_bswap16
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $cl killed $cl killed $ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 8(%r14)
	incq	%r13
	addq	$12, %r14
	movl	32(%rbp), %eax
	cmpq	%r13, %rax
	jne	LBB0_34
	jmp	LBB0_71
LBB0_21:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.22:                              ##   in Loop: Header=BB0_2 Depth=1
	movl	%r12d, %r15d
	movq	%rbx, %r12
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_23:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	movl	%edi, %eax
	movl	%r13d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, (%r14)
	movq	8(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	movl	%edi, %eax
	movl	%r13d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 4(%r14)
	movq	16(%r12), %rax
	movl	(%rax,%rbx,4), %edi
	movl	%edi, %eax
	movl	%r13d, %ecx
	shll	%cl, %eax
	movl	%r15d, %ecx
	sarl	%cl, %edi
	orl	%eax, %edi
	callq	_av_bswap16
	movl	%eax, 8(%r14)
	incq	%rbx
	addq	$12, %r14
	movl	32(%rbp), %eax
	cmpq	%rbx, %rax
	jne	LBB0_23
	jmp	LBB0_71
LBB0_50:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpl	$0, 32(%rbp)
	jle	LBB0_71
## %bb.51:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	(%rbx), %r13
	movq	8(%rbx), %r9
	movq	16(%rbx), %r15
	cmpl	$4, 32(%rbp)
	jb	LBB0_52
## %bb.53:                              ##   in Loop: Header=BB0_2 Depth=1
	addq	-192(%rbp), %rdi                ## 8-byte Folded Reload
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rdi,4), %rdi
	movl	32(%rbp), %eax
	leaq	(,%rax,4), %rcx
	addq	%r13, %rcx
	leaq	(%r9,%rax,4), %rbx
	leaq	(%r15,%rax,4), %r8
	cmpq	%rcx, %r14
	setb	%r10b
	cmpq	%rdi, %r13
	setb	%r11b
	cmpq	%rbx, %r14
	setb	%cl
	cmpq	%rdi, %r9
	setb	%al
	cmpq	%r8, %r14
	setb	%bl
	cmpq	%rdi, %r15
	setb	%r8b
	testb	%r11b, %r10b
	jne	LBB0_52
## %bb.54:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%al, %cl
	jne	LBB0_52
## %bb.55:                              ##   in Loop: Header=BB0_2 Depth=1
	andb	%r8b, %bl
	jne	LBB0_52
## %bb.56:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-184(%rbp), %rax                ## 8-byte Reload
	leaq	(%r14,%rax,4), %r14
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	xorl	%edi, %edi
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	movdqa	-176(%rbp), %xmm5               ## 16-byte Reload
	movdqa	-160(%rbp), %xmm6               ## 16-byte Reload
	.p2align	4, 0x90
LBB0_57:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%r13,%rdi), %xmm0
	movdqa	%xmm0, %xmm1
	pslld	%xmm5, %xmm1
	psrad	%xmm6, %xmm0
	por	%xmm1, %xmm0
	movdqu	(%r9,%rdi), %xmm1
	movdqa	%xmm1, %xmm2
	pslld	%xmm5, %xmm2
	psrad	%xmm6, %xmm1
	por	%xmm2, %xmm1
	movdqu	(%r15,%rdi), %xmm2
	movdqa	%xmm2, %xmm3
	pslld	%xmm5, %xmm3
	psrad	%xmm6, %xmm2
	por	%xmm3, %xmm2
	pshufd	$80, %xmm1, %xmm3               ## xmm3 = xmm1[0,0,1,1]
	pshufd	$68, %xmm0, %xmm4               ## xmm4 = xmm0[0,1,0,1]
	pblendw	$12, %xmm3, %xmm4               ## xmm4 = xmm4[0,1],xmm3[2,3],xmm4[4,5,6,7]
	pshufd	$68, %xmm2, %xmm3               ## xmm3 = xmm2[0,1,0,1]
	pblendw	$207, %xmm4, %xmm3              ## xmm3 = xmm4[0,1,2,3],xmm3[4,5],xmm4[6,7]
	pshufd	$165, %xmm1, %xmm4              ## xmm4 = xmm1[1,1,2,2]
	pblendw	$48, %xmm0, %xmm4               ## xmm4 = xmm4[0,1,2,3],xmm0[4,5],xmm4[6,7]
	pblendw	$12, %xmm2, %xmm4               ## xmm4 = xmm4[0,1],xmm2[2,3],xmm4[4,5,6,7]
	shufps	$255, %xmm1, %xmm0              ## xmm0 = xmm0[3,3],xmm1[3,3]
	pshufd	$238, %xmm2, %xmm1              ## xmm1 = xmm2[2,3,2,3]
	pblendw	$60, %xmm0, %xmm1               ## xmm1 = xmm1[0,1],xmm0[2,3,4,5],xmm1[6,7]
	movdqu	%xmm1, 32(%rcx)
	movdqu	%xmm4, 16(%rcx)
	movdqu	%xmm3, (%rcx)
	addq	$16, %rdi
	addq	$48, %rcx
	cmpq	%rdi, %rax
	jne	LBB0_57
## %bb.58:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	movq	%rcx, %rdi
	movl	32(%rbp), %eax
	cmpq	%rax, %rcx
	movl	-48(%rbp), %edx                 ## 4-byte Reload
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	jne	LBB0_59
	jmp	LBB0_71
LBB0_41:                                ##   in Loop: Header=BB0_2 Depth=1
	xorl	%edi, %edi
	movl	-48(%rbp), %edx                 ## 4-byte Reload
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	.p2align	4, 0x90
LBB0_48:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r13,%rdi,4), %ebx
	movl	%ebx, %eax
	movl	%edx, %ecx
	shll	%cl, %eax
	movl	%esi, %ecx
	sarl	%cl, %ebx
	orl	%eax, %ebx
	movl	%ebx, (%r14)
	movl	(%r8,%rdi,4), %eax
	movl	%eax, %ebx
	movl	%edx, %ecx
	shll	%cl, %ebx
	movl	%esi, %ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 4(%r14)
	movl	(%r15,%rdi,4), %eax
	movl	%eax, %ebx
	movl	%edx, %ecx
	shll	%cl, %ebx
	movl	%esi, %ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 8(%r14)
	movl	$65535, 12(%r14)                ## imm = 0xFFFF
	incq	%rdi
	addq	$16, %r14
	movl	32(%rbp), %eax
	cmpq	%rdi, %rax
	jne	LBB0_48
	jmp	LBB0_71
LBB0_62:                                ##   in Loop: Header=BB0_2 Depth=1
	xorl	%ebx, %ebx
	movl	-48(%rbp), %esi                 ## 4-byte Reload
	movl	-44(%rbp), %edi                 ## 4-byte Reload
	.p2align	4, 0x90
LBB0_70:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r11,%rbx,4), %eax
	movl	%eax, %edx
	movl	%esi, %ecx
	shll	%cl, %edx
	movl	%edi, %ecx
	sarl	%cl, %eax
	orl	%edx, %eax
	movl	%eax, (%r14)
	movl	(%r10,%rbx,4), %eax
	movl	%eax, %edx
	movl	%esi, %ecx
	shll	%cl, %edx
	movl	%edi, %ecx
	sarl	%cl, %eax
	orl	%edx, %eax
	movl	%eax, 4(%r14)
	movl	(%r13,%rbx,4), %eax
	movl	%eax, %edx
	movl	%esi, %ecx
	shll	%cl, %edx
	movl	%edi, %ecx
	sarl	%cl, %eax
	orl	%edx, %eax
	movl	%eax, 8(%r14)
	movl	(%r15,%rbx,4), %eax
	movl	%eax, %edx
	movl	%esi, %ecx
	shll	%cl, %edx
	movl	%edi, %ecx
	sarl	%cl, %eax
	orl	%edx, %eax
	movl	%eax, 12(%r14)
	incq	%rbx
	addq	$16, %r14
	movl	32(%rbp), %eax
	cmpq	%rbx, %rax
	jne	LBB0_70
	jmp	LBB0_71
LBB0_52:                                ##   in Loop: Header=BB0_2 Depth=1
	xorl	%edi, %edi
	movl	-48(%rbp), %edx                 ## 4-byte Reload
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	.p2align	4, 0x90
LBB0_59:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r13,%rdi,4), %ebx
	movl	%ebx, %eax
	movl	%edx, %ecx
	shll	%cl, %eax
	movl	%esi, %ecx
	sarl	%cl, %ebx
	orl	%eax, %ebx
	movl	%ebx, (%r14)
	movl	(%r9,%rdi,4), %eax
	movl	%eax, %ebx
	movl	%edx, %ecx
	shll	%cl, %ebx
	movl	%esi, %ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 4(%r14)
	movl	(%r15,%rdi,4), %eax
	movl	%eax, %ebx
	movl	%edx, %ecx
	shll	%cl, %ebx
	movl	%esi, %ecx
	sarl	%cl, %eax
	orl	%ebx, %eax
	movl	%eax, 8(%r14)
	incq	%rdi
	addq	$12, %r14
	movl	32(%rbp), %eax
	cmpq	%rdi, %rax
	jne	LBB0_59
	.p2align	4, 0x90
LBB0_71:                                ##   in Loop: Header=BB0_2 Depth=1
	cmpq	$0, -256(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_72
## %bb.73:                              ##   in Loop: Header=BB0_2 Depth=1
	cmpq	$0, -216(%rbp)                  ## 8-byte Folded Reload
	movl	-48(%rbp), %r13d                ## 4-byte Reload
	movl	-44(%rbp), %r12d                ## 4-byte Reload
	movq	-128(%rbp), %rdx                ## 8-byte Reload
	movq	-120(%rbp), %rsi                ## 8-byte Reload
	movq	-136(%rbp), %r8                 ## 8-byte Reload
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	je	LBB0_74
## %bb.75:                              ##   in Loop: Header=BB0_2 Depth=1
	movq	-200(%rbp), %rcx                ## 8-byte Reload
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_76:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%rdx,%rax,4), %xmm0            ## xmm0 = mem[0],zero
	movq	8(%rdx,%rax,4), %xmm1           ## xmm1 = mem[0],zero
	psrad	$1, %xmm0
	psrad	$1, %xmm1
	pmovsxdq	%xmm0, %xmm0
	pmovsxdq	%xmm1, %xmm1
	psllq	$2, %xmm0
	movdqu	(%rbx,%rax,8), %xmm2
	paddq	%xmm0, %xmm2
	movdqu	16(%rbx,%rax,8), %xmm0
	movdqu	32(%rbx,%rax,8), %xmm3
	movdqu	48(%rbx,%rax,8), %xmm4
	psllq	$2, %xmm1
	paddq	%xmm0, %xmm1
	movdqu	%xmm2, (%rbx,%rax,8)
	movdqu	%xmm1, 16(%rbx,%rax,8)
	movq	16(%rdx,%rax,4), %xmm0          ## xmm0 = mem[0],zero
	movq	24(%rdx,%rax,4), %xmm1          ## xmm1 = mem[0],zero
	psrad	$1, %xmm0
	psrad	$1, %xmm1
	pmovsxdq	%xmm0, %xmm0
	pmovsxdq	%xmm1, %xmm1
	psllq	$2, %xmm0
	paddq	%xmm3, %xmm0
	psllq	$2, %xmm1
	paddq	%xmm4, %xmm1
	movdqu	%xmm0, 32(%rbx,%rax,8)
	movdqu	%xmm1, 48(%rbx,%rax,8)
	addq	$8, %rax
	addq	$-2, %rcx
	jne	LBB0_76
## %bb.77:                              ##   in Loop: Header=BB0_2 Depth=1
	testb	$1, -208(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_79
LBB0_78:                                ##   in Loop: Header=BB0_2 Depth=1
	movq	(%rdx,%rax,4), %xmm0            ## xmm0 = mem[0],zero
	movq	8(%rdx,%rax,4), %xmm1           ## xmm1 = mem[0],zero
	psrad	$1, %xmm0
	psrad	$1, %xmm1
	movdqu	(%rbx,%rax,8), %xmm2
	movdqu	16(%rbx,%rax,8), %xmm3
	pmovsxdq	%xmm0, %xmm0
	pmovsxdq	%xmm1, %xmm1
	psllq	$2, %xmm0
	paddq	%xmm2, %xmm0
	psllq	$2, %xmm1
	paddq	%xmm3, %xmm1
	movdqu	%xmm0, (%rbx,%rax,8)
	movdqu	%xmm1, 16(%rbx,%rax,8)
LBB0_79:                                ##   in Loop: Header=BB0_2 Depth=1
	movq	-224(%rbp), %rcx                ## 8-byte Reload
	movq	%rcx, %rax
	cmpq	%rcx, %rsi
	jne	LBB0_80
	jmp	LBB0_81
	.p2align	4, 0x90
LBB0_72:                                ##   in Loop: Header=BB0_2 Depth=1
	xorl	%eax, %eax
	movl	-48(%rbp), %r13d                ## 4-byte Reload
	movl	-44(%rbp), %r12d                ## 4-byte Reload
	movq	-128(%rbp), %rdx                ## 8-byte Reload
	movq	-120(%rbp), %rsi                ## 8-byte Reload
	movq	-136(%rbp), %r8                 ## 8-byte Reload
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_80:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdx,%rax,4), %ecx
	sarl	%ecx
	movslq	%ecx, %rcx
	shlq	$2, %rcx
	addq	%rcx, (%rbx,%rax,8)
	incq	%rax
	cmpq	%rax, %rsi
	jne	LBB0_80
	jmp	LBB0_81
	.p2align	4, 0x90
LBB0_74:                                ##   in Loop: Header=BB0_2 Depth=1
	xorl	%eax, %eax
	testb	$1, -208(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_78
	jmp	LBB0_79
LBB0_82:
	addq	$216, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_gbr16ptopacked16
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function gbr16ptopacked16
_gbr16ptopacked16:                      ; @gbr16ptopacked16
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #336
	.cfi_def_cfa_offset 336
	stp	x28, x27, [sp, #240]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #256]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #272]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #288]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #304]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #320]            ; 16-byte Folded Spill
	add	x29, sp, #320
	.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
                                        ; kill: def $w3 killed $w3 def $x3
	stp	x1, x2, [sp, #136]              ; 16-byte Folded Spill
	cmp	w4, #1
	b.lt	LBB0_77
; %bb.1:
	mov	x22, x0
	mov	x23, #0
	ldr	w11, [x29, #16]
	mov	w8, #16
	sub	w25, w8, w7
	lsl	w8, w7, #1
	sub	w26, w8, #16
	ldr	x8, [x0, #24]
	cmp	w5, #0
	cset	w9, eq
	cset	w10, ne
	cmp	x8, #0
	cset	w8, ne
	orr	w9, w9, w8
	and	w8, w10, w8
	stp	w8, w9, [sp, #88]               ; 8-byte Folded Spill
	sxtw	x9, w3
	mov	w8, w4
	stp	x8, x9, [sp, #112]              ; 16-byte Folded Spill
	mov	w8, #3
	cinc	x10, x8, ne
	lsl	x27, x11, #2
	add	x8, x11, w11, uxtw #1
	str	x8, [sp, #24]                   ; 8-byte Folded Spill
	and	x8, x11, #0xfffffffc
	lsl	x9, x8, #2
	str	x9, [sp, #40]                   ; 8-byte Folded Spill
	dup.4s	v1, w25
	dup.4s	v0, w26
	str	x8, [sp, #80]                   ; 8-byte Folded Spill
	add	x8, x8, x8, lsl #1
	str	x8, [sp, #16]                   ; 8-byte Folded Spill
	sbfiz	x8, x3, #2, #32
	stp	x8, x10, [sp, #96]              ; 16-byte Folded Spill
	str	x11, [sp, #152]                 ; 8-byte Folded Spill
	lsr	x8, x11, #2
	lsl	x9, x8, #6
	str	x9, [sp, #32]                   ; 8-byte Folded Spill
	add	x8, x8, x8, lsl #1
	lsl	x8, x8, #4
	str	x8, [sp, #8]                    ; 8-byte Folded Spill
	mov	w21, #65535
	neg.4s	v0, v0
	stp	q0, q1, [sp, #48]               ; 32-byte Folded Spill
	movi.2d	v3, #0x00ffff0000ffff
	ldr	x20, [sp, #144]                 ; 8-byte Folded Reload
	str	w6, [sp, #132]                  ; 4-byte Folded Spill
LBB0_2:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_53 Depth 2
                                        ;     Child Loop BB0_56 Depth 2
                                        ;     Child Loop BB0_70 Depth 2
                                        ;     Child Loop BB0_73 Depth 2
                                        ;     Child Loop BB0_62 Depth 2
                                        ;     Child Loop BB0_65 Depth 2
                                        ;     Child Loop BB0_27 Depth 2
                                        ;     Child Loop BB0_39 Depth 2
                                        ;     Child Loop BB0_9 Depth 2
                                        ;     Child Loop BB0_33 Depth 2
                                        ;     Child Loop BB0_45 Depth 2
                                        ;     Child Loop BB0_19 Depth 2
                                        ;     Child Loop BB0_30 Depth 2
                                        ;     Child Loop BB0_42 Depth 2
                                        ;     Child Loop BB0_14 Depth 2
                                        ;     Child Loop BB0_75 Depth 2
	ldr	x8, [sp, #120]                  ; 8-byte Folded Reload
	mul	x12, x23, x8
	ldr	x8, [sp, #144]                  ; 8-byte Folded Reload
	add	x28, x8, x12, lsl #2
	cmp	w6, #1
	add	x8, sp, #160
	st1.2d	{ v0, v1, v2, v3 }, [x8]        ; 64-byte Folded Spill
	b.eq	LBB0_10
; %bb.3:                                ;   in Loop: Header=BB0_2 Depth=1
	cmp	w6, #2
	b.eq	LBB0_15
; %bb.4:                                ;   in Loop: Header=BB0_2 Depth=1
	cmp	w6, #3
	b.ne	LBB0_20
; %bb.5:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #92]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_25
; %bb.6:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #88]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_37
; %bb.7:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.8:                                ;   in Loop: Header=BB0_2 Depth=1
	mov	x28, #0
LBB0_9:                                 ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x24, x20, x28, lsl #2
	ldr	x8, [x22]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x24]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x24, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x24, #8]
	ldr	x8, [x22, #24]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x24, #12]
	add	x28, x28, #4
	cmp	x27, x28
	b.ne	LBB0_9
	b	LBB0_74
LBB0_10:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #92]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_28
; %bb.11:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #88]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_40
; %bb.12:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.13:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x28, #0
LBB0_14:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x24, x20, x28, lsl #2
	ldr	x8, [x22]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x24]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x24, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x24, #8]
	ldr	x8, [x22, #24]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #24]
	ldr	w0, [x8, x28]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x24, #12]
	add	x28, x28, #4
	cmp	x27, x28
	b.ne	LBB0_14
	b	LBB0_74
LBB0_15:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #92]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_31
; %bb.16:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #88]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_43
; %bb.17:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.18:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_19:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x28, x20, x24, lsl #2
	ldr	x8, [x22]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28]
	ldr	x8, [x22, #8]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #8]
	ldr	x8, [x22, #24]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #12]
	add	x24, x24, #4
	cmp	x27, x24
	b.ne	LBB0_19
	b	LBB0_74
LBB0_20:                                ;   in Loop: Header=BB0_2 Depth=1
	add	x8, x27, x12
	ldr	x9, [sp, #144]                  ; 8-byte Folded Reload
	add	x13, x9, x8, lsl #2
	ldr	w8, [sp, #92]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_34
; %bb.21:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	w8, [sp, #88]                   ; 4-byte Folded Reload
	tbz	w8, #0, LBB0_46
; %bb.22:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.23:                               ;   in Loop: Header=BB0_2 Depth=1
	ldp	x8, x9, [x22]
	ldp	x10, x11, [x22, #16]
	ldr	x12, [sp, #152]                 ; 8-byte Folded Reload
	cmp	w12, #4
	b.hs	LBB0_57
; %bb.24:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x12, #0
	b	LBB0_64
LBB0_25:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.26:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_27:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x28, x20, x24, lsl #2
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x28]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	stp	w0, w21, [x28, #8]
	add	x24, x24, #4
	cmp	x27, x24
	b.ne	LBB0_27
	b	LBB0_74
LBB0_28:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.29:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_30:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x28, x20, x24, lsl #2
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x28]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	stp	w8, w21, [x28, #8]
	add	x24, x24, #4
	cmp	x27, x24
	b.ne	LBB0_30
	b	LBB0_74
LBB0_31:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.32:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_33:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x28, x20, x24, lsl #2
	ldr	x8, [x22]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28]
	ldr	x8, [x22, #8]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	stp	w0, w21, [x28, #8]
	add	x24, x24, #4
	cmp	x27, x24
	b.ne	LBB0_33
	b	LBB0_74
LBB0_34:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.35:                               ;   in Loop: Header=BB0_2 Depth=1
	ldp	x8, x9, [x22]
	ldr	x10, [x22, #16]
	ldr	x11, [sp, #152]                 ; 8-byte Folded Reload
	cmp	w11, #4
	b.hs	LBB0_49
; %bb.36:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	b	LBB0_55
LBB0_37:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.38:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_39:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x28]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w8, w0, w25
	asr	w9, w0, w26
	orr	w0, w8, w9
	bl	_av_bswap16
	str	w0, [x28, #8]
	add	x24, x24, #4
	add	x28, x28, #12
	cmp	x27, x24
	b.ne	LBB0_39
	b	LBB0_74
LBB0_40:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.41:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_42:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x28]
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #8]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	lsl	w19, w0, w25
	ldr	x8, [x22, #16]
	ldr	w0, [x8, x24]
	bl	_av_bswap16
	asr	w8, w0, w26
	orr	w8, w8, w19
	str	w8, [x28, #8]
	add	x24, x24, #4
	add	x28, x28, #12
	cmp	x27, x24
	b.ne	LBB0_42
	b	LBB0_74
LBB0_43:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.44:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x24, #0
LBB0_45:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [x22]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28]
	ldr	x8, [x22, #8]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #4]
	ldr	x8, [x22, #16]
	ldr	w8, [x8, x24]
	lsl	w9, w8, w25
	asr	w8, w8, w26
	orr	w0, w9, w8
	bl	_av_bswap16
	str	w0, [x28, #8]
	add	x24, x24, #4
	add	x28, x28, #12
	cmp	x27, x24
	b.ne	LBB0_45
	b	LBB0_74
LBB0_46:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #152]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_74
; %bb.47:                               ;   in Loop: Header=BB0_2 Depth=1
	ldp	x8, x9, [x22]
	ldr	x10, [x22, #16]
	ldr	x11, [sp, #152]                 ; 8-byte Folded Reload
	cmp	w11, #4
	b.hs	LBB0_66
; %bb.48:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	b	LBB0_72
LBB0_49:                                ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	add	x15, x8, x27
	add	x12, x9, x27
	cmp	x28, x12
	ccmp	x9, x13, #2, lo
	cset	w14, lo
	add	x12, x10, x27
	cmp	x28, x12
	ccmp	x10, x13, #2, lo
	cset	w12, lo
	cmp	x8, x13
	ccmp	x28, x15, #2, lo
	b.lo	LBB0_55
; %bb.50:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w14, #0, LBB0_55
; %bb.51:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w12, #0, LBB0_55
; %bb.52:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	mov	x12, x10
	mov	x13, x9
	mov	x14, x8
	ldp	x16, x15, [sp, #32]             ; 16-byte Folded Reload
	add	x28, x28, x15, lsl #2
	ldp	q3, q2, [sp, #48]               ; 32-byte Folded Reload
	add	x15, sp, #160
	ld1.2d	{ v4, v5, v6, v7 }, [x15]       ; 64-byte Folded Reload
LBB0_53:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	q0, [x14], #16
	ushl.4s	v1, v0, v2
	sshl.4s	v0, v0, v3
	orr.16b	v4, v1, v0
	ldr	q0, [x13], #16
	ushl.4s	v1, v0, v2
	sshl.4s	v0, v0, v3
	orr.16b	v5, v1, v0
	ldr	q0, [x12], #16
	ushl.4s	v1, v0, v2
	sshl.4s	v0, v0, v3
	orr.16b	v6, v1, v0
	add	x15, x20, x11
	st4.4s	{ v4, v5, v6, v7 }, [x15]
	add	x11, x11, #64
	cmp	x16, x11
	b.ne	LBB0_53
; %bb.54:                               ;   in Loop: Header=BB0_2 Depth=1
	add	x11, sp, #160
	st1.2d	{ v4, v5, v6, v7 }, [x11]       ; 64-byte Folded Spill
	ldr	x13, [sp, #80]                  ; 8-byte Folded Reload
	mov	x11, x13
	ldr	x12, [sp, #152]                 ; 8-byte Folded Reload
	cmp	x13, x12
	b.eq	LBB0_74
LBB0_55:                                ;   in Loop: Header=BB0_2 Depth=1
	lsl	x12, x11, #2
	add	x10, x10, x12
	add	x9, x9, x12
	add	x8, x8, x12
	ldr	x12, [sp, #152]                 ; 8-byte Folded Reload
	sub	x11, x12, x11
LBB0_56:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w12, [x8], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	str	w12, [x28]
	ldr	w12, [x9], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	str	w12, [x28, #4]
	ldr	w12, [x10], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	stp	w12, w21, [x28, #8]
	add	x28, x28, #16
	subs	x11, x11, #1
	b.ne	LBB0_56
	b	LBB0_74
LBB0_57:                                ;   in Loop: Header=BB0_2 Depth=1
	mov	x12, #0
	add	x14, x9, x27
	cmp	x28, x14
	ccmp	x9, x13, #2, lo
	cset	w14, lo
	add	x15, x10, x27
	cmp	x28, x15
	ccmp	x10, x13, #2, lo
	cset	w16, lo
	add	x15, x11, x27
	cmp	x28, x15
	ccmp	x11, x13, #2, lo
	cset	w15, lo
	cmp	x8, x13
	add	x13, x8, x27
	ccmp	x28, x13, #2, lo
	b.lo	LBB0_64
; %bb.58:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w14, #0, LBB0_64
; %bb.59:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w16, #0, LBB0_64
; %bb.60:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w15, #0, LBB0_64
; %bb.61:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x12, #0
	mov	x13, x11
	mov	x14, x10
	mov	x15, x9
	mov	x16, x8
	ldp	x0, x17, [sp, #32]              ; 16-byte Folded Reload
	add	x28, x28, x17, lsl #2
	ldp	q7, q6, [sp, #48]               ; 32-byte Folded Reload
LBB0_62:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	q0, [x16], #16
	ushl.4s	v1, v0, v6
	sshl.4s	v0, v0, v7
	orr.16b	v0, v1, v0
	ldr	q4, [x15], #16
	ushl.4s	v5, v4, v6
	sshl.4s	v4, v4, v7
	orr.16b	v1, v5, v4
	ldr	q4, [x14], #16
	ushl.4s	v5, v4, v6
	sshl.4s	v4, v4, v7
	orr.16b	v2, v5, v4
	ldr	q4, [x13], #16
	ushl.4s	v5, v4, v6
	sshl.4s	v4, v4, v7
	orr.16b	v3, v5, v4
	add	x17, x20, x12
	st4.4s	{ v0, v1, v2, v3 }, [x17]
	add	x12, x12, #64
	cmp	x0, x12
	b.ne	LBB0_62
; %bb.63:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	x14, [sp, #80]                  ; 8-byte Folded Reload
	mov	x12, x14
	ldr	x13, [sp, #152]                 ; 8-byte Folded Reload
	cmp	x14, x13
	b.eq	LBB0_74
LBB0_64:                                ;   in Loop: Header=BB0_2 Depth=1
	lsl	x13, x12, #2
	add	x11, x11, x13
	add	x10, x10, x13
	add	x9, x9, x13
	add	x8, x8, x13
	ldr	x13, [sp, #152]                 ; 8-byte Folded Reload
	sub	x12, x13, x12
LBB0_65:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w13, [x8], #4
	lsl	w14, w13, w25
	asr	w13, w13, w26
	orr	w13, w14, w13
	str	w13, [x28]
	ldr	w13, [x9], #4
	lsl	w14, w13, w25
	asr	w13, w13, w26
	orr	w13, w14, w13
	str	w13, [x28, #4]
	ldr	w13, [x10], #4
	lsl	w14, w13, w25
	asr	w13, w13, w26
	orr	w13, w14, w13
	str	w13, [x28, #8]
	ldr	w13, [x11], #4
	lsl	w14, w13, w25
	asr	w13, w13, w26
	orr	w13, w14, w13
	str	w13, [x28, #12]
	add	x28, x28, #16
	subs	x12, x12, #1
	b.ne	LBB0_65
	b	LBB0_74
LBB0_66:                                ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	ldr	x13, [sp, #24]                  ; 8-byte Folded Reload
	add	x12, x13, x12
	ldr	x13, [sp, #144]                 ; 8-byte Folded Reload
	add	x14, x13, x12, lsl #2
	add	x15, x8, x27
	add	x12, x9, x27
	cmp	x28, x12
	ccmp	x9, x14, #2, lo
	cset	w13, lo
	add	x12, x10, x27
	cmp	x28, x12
	ccmp	x10, x14, #2, lo
	cset	w12, lo
	cmp	x8, x14
	ccmp	x28, x15, #2, lo
	b.lo	LBB0_72
; %bb.67:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w13, #0, LBB0_72
; %bb.68:                               ;   in Loop: Header=BB0_2 Depth=1
	tbnz	w12, #0, LBB0_72
; %bb.69:                               ;   in Loop: Header=BB0_2 Depth=1
	mov	x11, #0
	mov	x12, x10
	mov	x13, x9
	mov	x14, x8
	ldp	x16, x15, [sp, #8]              ; 16-byte Folded Reload
	add	x28, x28, x15, lsl #2
	ldp	q6, q5, [sp, #48]               ; 32-byte Folded Reload
LBB0_70:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	q0, [x14], #16
	ushl.4s	v1, v0, v5
	sshl.4s	v0, v0, v6
	orr.16b	v0, v1, v0
	ldr	q3, [x13], #16
	ushl.4s	v4, v3, v5
	sshl.4s	v3, v3, v6
	orr.16b	v1, v4, v3
	ldr	q3, [x12], #16
	ushl.4s	v4, v3, v5
	sshl.4s	v3, v3, v6
	orr.16b	v2, v4, v3
	add	x15, x20, x11
	st3.4s	{ v0, v1, v2 }, [x15]
	add	x11, x11, #48
	cmp	x16, x11
	b.ne	LBB0_70
; %bb.71:                               ;   in Loop: Header=BB0_2 Depth=1
	ldr	x13, [sp, #80]                  ; 8-byte Folded Reload
	mov	x11, x13
	ldr	x12, [sp, #152]                 ; 8-byte Folded Reload
	cmp	x13, x12
	b.eq	LBB0_74
LBB0_72:                                ;   in Loop: Header=BB0_2 Depth=1
	lsl	x12, x11, #2
	add	x10, x10, x12
	add	x9, x9, x12
	add	x8, x8, x12
	ldr	x12, [sp, #152]                 ; 8-byte Folded Reload
	sub	x11, x12, x11
LBB0_73:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w12, [x8], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	str	w12, [x28]
	ldr	w12, [x9], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	str	w12, [x28, #4]
	ldr	w12, [x10], #4
	lsl	w13, w12, w25
	asr	w12, w12, w26
	orr	w12, w13, w12
	str	w12, [x28, #8]
	add	x28, x28, #12
	subs	x11, x11, #1
	b.ne	LBB0_73
LBB0_74:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	x8, [sp, #104]                  ; 8-byte Folded Reload
	ldr	x9, [sp, #136]                  ; 8-byte Folded Reload
	mov	x10, x22
LBB0_75:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w11, [x9], #4
	asr	w11, w11, #1
	ldr	x12, [x10]
	add	x11, x12, w11, sxtw #2
	str	x11, [x10], #8
	subs	x8, x8, #1
	b.ne	LBB0_75
; %bb.76:                               ;   in Loop: Header=BB0_2 Depth=1
	add	x23, x23, #1
	ldr	x8, [sp, #96]                   ; 8-byte Folded Reload
	add	x20, x20, x8
	ldr	x8, [sp, #112]                  ; 8-byte Folded Reload
	cmp	x23, x8
	ldr	w6, [sp, #132]                  ; 4-byte Folded Reload
	add	x8, sp, #160
	ld1.2d	{ v0, v1, v2, v3 }, [x8]        ; 64-byte Folded Reload
	b.ne	LBB0_2
LBB0_77:
	ldp	x29, x30, [sp, #320]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #304]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #288]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #272]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #256]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #240]            ; 16-byte Folded Reload
	add	sp, sp, #336
	ret
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_gbr16ptopacked16
.subsections_via_symbols
