	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ## -- Begin function vc2_subband_dwt_97
LCPI0_0:
	.long	9                               ## 0x9
	.long	9                               ## 0x9
	.long	9                               ## 0x9
	.long	9                               ## 0x9
LCPI0_1:
	.long	8                               ## 0x8
	.long	8                               ## 0x8
	.long	8                               ## 0x8
	.long	8                               ## 0x8
LCPI0_2:
	.long	17                              ## 0x11
	.long	17                              ## 0x11
	.long	17                              ## 0x11
	.long	17                              ## 0x11
LCPI0_3:
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_vc2_subband_dwt_97:                    ## @vc2_subband_dwt_97
	.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	$96, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
                                        ## kill: def $r8d killed $r8d def $r8
                                        ## kill: def $ecx killed $ecx def $rcx
	movl	%edx, %ebx
	movq	(%rdi), %r12
	movq	%rcx, -104(%rbp)                ## 8-byte Spill
	leal	(%rcx,%rcx), %edx
	movq	%r8, -112(%rbp)                 ## 8-byte Spill
	leal	(%r8,%r8), %eax
	movl	%edx, %ecx
	movq	%rax, -176(%rbp)                ## 8-byte Spill
	testl	%eax, %eax
	movq	%r12, -64(%rbp)                 ## 8-byte Spill
	movq	%rcx, %rax
	movq	%rcx, -48(%rbp)                 ## 8-byte Spill
	movq	%rdx, %rax
	movq	%rdx, -56(%rbp)                 ## 8-byte Spill
	movl	%ebx, -220(%rbp)                ## 4-byte Spill
	movq	%rsi, -232(%rbp)                ## 8-byte Spill
	jle	LBB0_31
## %bb.1:
	movslq	%edx, %rax
	movslq	%ebx, %r10
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	leaq	(,%rax,4), %r15
	shlq	$2, %r10
	movl	%ecx, %r11d
	andl	$-8, %r11d
	leaq	-8(%r11), %r8
	movq	%r8, %r14
	shrq	$3, %r14
	incq	%r14
	movq	%r14, %r9
	andq	$-2, %r9
	movq	%r12, %rdi
	movl	%ecx, %r12d
	andl	$2, %r12d
	xorl	%r13d, %r13d
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_2:                                 ##   in Loop: Header=BB0_3 Depth=1
	addq	%r15, %rdi
	addq	%r10, %rsi
	incq	%r13
	cmpl	-176(%rbp), %r13d               ## 4-byte Folded Reload
	je	LBB0_19
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_8 Depth 2
                                        ##     Child Loop BB0_16 Depth 2
                                        ##     Child Loop BB0_18 Depth 2
	testl	%edx, %edx
	jle	LBB0_2
## %bb.4:                               ##   in Loop: Header=BB0_3 Depth=1
	cmpl	$8, %edx
	jb	LBB0_9
## %bb.5:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%r10, %rax
	imulq	%r13, %rax
	addq	-232(%rbp), %rax                ## 8-byte Folded Reload
	movq	%r15, %rdx
	imulq	%r13, %rdx
	addq	-64(%rbp), %rdx                 ## 8-byte Folded Reload
	subq	%rax, %rdx
	movl	$0, %ebx
	cmpq	$32, %rdx
	jb	LBB0_14
## %bb.6:                               ##   in Loop: Header=BB0_3 Depth=1
	testq	%r8, %r8
	je	LBB0_10
## %bb.7:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%r9, %rdx
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_8:                                 ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%rsi,%rbx,4), %xmm0
	movdqu	16(%rsi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, (%rdi,%rbx,4)
	movdqu	%xmm1, 16(%rdi,%rbx,4)
	movdqu	32(%rsi,%rbx,4), %xmm0
	movdqu	48(%rsi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, 32(%rdi,%rbx,4)
	movdqu	%xmm1, 48(%rdi,%rbx,4)
	addq	$16, %rbx
	addq	$-2, %rdx
	jne	LBB0_8
	jmp	LBB0_11
LBB0_9:                                 ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
	jmp	LBB0_14
LBB0_10:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
LBB0_11:                                ##   in Loop: Header=BB0_3 Depth=1
	testb	$1, %r14b
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	je	LBB0_13
## %bb.12:                              ##   in Loop: Header=BB0_3 Depth=1
	movdqu	(%rsi,%rbx,4), %xmm0
	movdqu	16(%rsi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, (%rdi,%rbx,4)
	movdqu	%xmm1, 16(%rdi,%rbx,4)
LBB0_13:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	%r11, %rbx
	cmpq	%rcx, %r11
	je	LBB0_2
LBB0_14:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	%rbx, %rdx
	notq	%rdx
	addq	%rcx, %rdx
	testq	%r12, %r12
	je	LBB0_17
## %bb.15:                              ##   in Loop: Header=BB0_3 Depth=1
	movq	%r12, %rax
	.p2align	4, 0x90
LBB0_16:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rsi,%rbx,4), %ecx
	addl	%ecx, %ecx
	movl	%ecx, (%rdi,%rbx,4)
	incq	%rbx
	decq	%rax
	jne	LBB0_16
LBB0_17:                                ##   in Loop: Header=BB0_3 Depth=1
	cmpq	$3, %rdx
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	jb	LBB0_2
	.p2align	4, 0x90
LBB0_18:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rsi,%rbx,4), %eax
	addl	%eax, %eax
	movl	%eax, (%rdi,%rbx,4)
	movl	4(%rsi,%rbx,4), %eax
	addl	%eax, %eax
	movl	%eax, 4(%rdi,%rbx,4)
	movl	8(%rsi,%rbx,4), %eax
	addl	%eax, %eax
	movl	%eax, 8(%rdi,%rbx,4)
	movl	12(%rsi,%rbx,4), %eax
	addl	%eax, %eax
	movl	%eax, 12(%rdi,%rbx,4)
	addq	$4, %rbx
	cmpq	%rbx, %rcx
	jne	LBB0_18
	jmp	LBB0_2
LBB0_19:
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movq	%rdx, %rsi
	movq	%rax, %rdx
	addl	$-2, %eax
	leal	-2(%rsi), %ecx
	movslq	%ecx, %r12
	leal	-4(%rsi), %ecx
	movslq	%ecx, %r8
	leal	-1(%rsi), %ecx
	movslq	%ecx, %r10
	leal	-6(%rsi), %ecx
	movslq	%ecx, %r14
	leal	-3(%rsi), %ecx
	movslq	%ecx, %r13
	leal	-1(%rdx), %ecx
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	leaq	-1(%rcx), %rsi
	movq	%rsi, %rcx
	movq	%rsi, -88(%rbp)                 ## 8-byte Spill
	andq	$-2, %rsi
	negq	%rsi
	xorl	%r11d, %r11d
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	jmp	LBB0_21
	.p2align	4, 0x90
LBB0_20:                                ##   in Loop: Header=BB0_21 Depth=1
	movl	(%rcx,%r13,4), %edx
	movl	(%rcx,%r10,4), %edi
	addl	%edi, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%rcx,%r12,4)
	addq	%r15, %rcx
	incl	%r11d
	cmpl	-176(%rbp), %r11d               ## 4-byte Folded Reload
	je	LBB0_30
LBB0_21:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_23 Depth 2
                                        ##     Child Loop BB0_27 Depth 2
	movl	(%rcx), %edi
	movl	8(%rcx), %edx
	leal	(%rdx,%rdx,8), %edx
	leal	(%rdx,%rdi,8), %edx
	subl	16(%rcx), %edx
	addl	$8, %edx
	sarl	$4, %edx
	subl	%edx, 4(%rcx)
	cmpl	$4, -104(%rbp)                  ## 4-byte Folded Reload
	jl	LBB0_24
## %bb.22:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	$1, %edi
	.p2align	4, 0x90
LBB0_23:                                ##   Parent Loop BB0_21 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	8(%rcx,%rdi,8), %edx
	movl	16(%rcx,%rdi,8), %ebx
	addl	(%rcx,%rdi,8), %edx
	leal	(%rdx,%rdx,8), %edx
	addl	-8(%rcx,%rdi,8), %ebx
	subl	%ebx, %edx
	addl	$8, %edx
	sarl	$4, %edx
	subl	%edx, 4(%rcx,%rdi,8)
	incq	%rdi
	cmpq	%rdi, %rax
	jne	LBB0_23
LBB0_24:                                ##   in Loop: Header=BB0_21 Depth=1
	movl	(%rcx,%r12,4), %edx
	movl	%edx, %edi
	shll	$4, %edi
	addl	%edx, %edi
	movl	(%rcx,%r8,4), %ebx
	subl	%ebx, %edi
	addl	$8, %edi
	sarl	$4, %edi
	subl	%edi, (%rcx,%r10,4)
	leal	(%rbx,%rbx,8), %edi
	leal	(%rdi,%rdx,8), %edx
	subl	(%rcx,%r14,4), %edx
	addl	$8, %edx
	sarl	$4, %edx
	subl	%edx, (%rcx,%r13,4)
	movl	4(%rcx), %edx
	addl	%edx, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%rcx)
	cmpl	$3, -104(%rbp)                  ## 4-byte Folded Reload
	jl	LBB0_20
## %bb.25:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	$1, %r9d
	cmpl	$2, -80(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_28
## %bb.26:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	$1, %r9d
	.p2align	4, 0x90
LBB0_27:                                ##   Parent Loop BB0_21 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	-4(%rcx,%r9,8), %edx
	movl	4(%rcx,%r9,8), %edi
	addl	%edi, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%rcx,%r9,8)
	movl	12(%rcx,%r9,8), %edx
	addl	%edi, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, 8(%rcx,%r9,8)
	leaq	(%rsi,%r9), %rdx
	addq	$2, %rdx
	addq	$2, %r9
	cmpq	$1, %rdx
	jne	LBB0_27
LBB0_28:                                ##   in Loop: Header=BB0_21 Depth=1
	testb	$1, -88(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_20
## %bb.29:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	-4(%rcx,%r9,8), %edx
	movl	4(%rcx,%r9,8), %edi
	addl	%edi, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%rcx,%r9,8)
	jmp	LBB0_20
LBB0_30:
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movq	-72(%rbp), %rbx                 ## 8-byte Reload
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	jmp	LBB0_32
LBB0_31:
	movslq	%edx, %rbx
LBB0_32:
	leaq	(%r12,%rbx,4), %r15
	testl	%edx, %edx
	jle	LBB0_43
## %bb.33:
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	leal	(%rcx,%rcx,2), %eax
	movslq	%eax, %r14
	cmpl	$8, %ecx
	jae	LBB0_35
## %bb.34:
	xorl	%ecx, %ecx
	jmp	LBB0_41
LBB0_35:
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	leaq	(%rbx,%rsi), %rcx
	leaq	(%r12,%rcx,4), %rcx
	leaq	(%r12,%rsi,4), %rdx
	leaq	(%r12,%rbx,8), %r11
	leaq	(%rsi,%rbx,2), %rdi
	leaq	(%r12,%rdi,4), %rdi
	leaq	(%rbx,%r14), %rax
	leaq	(%r12,%rax,4), %r8
	addq	%rsi, %rax
	leaq	(%r12,%rax,4), %rax
	cmpq	%rdx, %r15
	setb	%r9b
	cmpq	%rcx, %r12
	setb	%r10b
	cmpq	%rdi, %r15
	setb	%dl
	cmpq	%rcx, %r11
	setb	%sil
	cmpq	%rax, %r15
	setb	%al
	cmpq	%rcx, %r8
	setb	%dil
	xorl	%ecx, %ecx
	testb	%r10b, %r9b
	jne	LBB0_41
## %bb.36:
	andb	%sil, %dl
	jne	LBB0_41
## %bb.37:
	andb	%dil, %al
	jne	LBB0_41
## %bb.38:
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx def $rcx
	andl	$-8, %ecx
	leaq	16(%r12), %rdx
	leaq	(,%r14,4), %rsi
	leaq	(%rsi,%rbx,4), %rsi
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [9,9,9,9]
	movdqa	LCPI0_1(%rip), %xmm1            ## xmm1 = [8,8,8,8]
	movq	%rcx, %rdi
	.p2align	4, 0x90
LBB0_39:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rdx), %xmm2
	movdqu	(%rdx), %xmm3
	pslld	$3, %xmm2
	pslld	$3, %xmm3
	movdqu	-16(%rdx,%rbx,8), %xmm4
	movdqu	(%rdx,%rbx,8), %xmm5
	pmulld	%xmm0, %xmm4
	paddd	%xmm2, %xmm4
	pmulld	%xmm0, %xmm5
	paddd	%xmm3, %xmm5
	movdqu	-16(%rdx,%rsi), %xmm2
	psubd	%xmm2, %xmm4
	movdqu	(%rdx,%rsi), %xmm2
	psubd	%xmm2, %xmm5
	paddd	%xmm1, %xmm4
	paddd	%xmm1, %xmm5
	psrad	$4, %xmm4
	psrad	$4, %xmm5
	movdqu	-16(%rdx,%rbx,4), %xmm2
	psubd	%xmm4, %xmm2
	movdqu	(%rdx,%rbx,4), %xmm3
	psubd	%xmm5, %xmm3
	movdqu	%xmm2, -16(%rdx,%rbx,4)
	movdqu	%xmm3, (%rdx,%rbx,4)
	addq	$32, %rdx
	addq	$-8, %rdi
	jne	LBB0_39
## %bb.40:
	cmpq	-48(%rbp), %rcx                 ## 8-byte Folded Reload
	je	LBB0_43
LBB0_41:
	leaq	(%r12,%rcx,4), %rdx
	addq	%rcx, %r14
	addq	%rbx, %r14
	leaq	(%r12,%r14,4), %rax
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	subq	%rcx, %rsi
	.p2align	4, 0x90
LBB0_42:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rdx), %ecx
	movl	(%rdx,%rbx,8), %edi
	leal	(%rdi,%rdi,8), %edi
	leal	(%rdi,%rcx,8), %ecx
	subl	(%rax), %ecx
	addl	$8, %ecx
	sarl	$4, %ecx
	subl	%ecx, (%rdx,%rbx,4)
	addq	$4, %rdx
	addq	$4, %rax
	decq	%rsi
	jne	LBB0_42
LBB0_43:
	movq	%r15, -240(%rbp)                ## 8-byte Spill
	movq	%rbx, -72(%rbp)                 ## 8-byte Spill
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leal	(,%rax,4), %eax
	movl	%eax, -156(%rbp)                ## 4-byte Spill
	cltq
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	leaq	(%r12,%rax,4), %rax
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	cmpl	$4, -112(%rbp)                  ## 4-byte Folded Reload
	jl	LBB0_61
## %bb.44:
	movq	-104(%rbp), %rax                ## 8-byte Reload
	leal	(,%rax,8), %eax
	movslq	%eax, %rdx
	movq	-112(%rbp), %rax                ## 8-byte Reload
	addl	$-3, %eax
	movl	%eax, -144(%rbp)                ## 4-byte Spill
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rax,%rcx), %rsi
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rsi,%rax), %rdi
	movq	%rdi, -208(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%rax), %rdi
	movq	%rdi, -200(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%rcx), %rdi
	movq	%rdi, -192(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rcx,2), %rdi
	movq	%rdi, -184(%rbp)                ## 8-byte Spill
	movq	%rdx, -120(%rbp)                ## 8-byte Spill
	addq	%rcx, %rdx
	leaq	(%rdx,%rax), %rdi
	movq	%rdi, -256(%rbp)                ## 8-byte Spill
                                        ## kill: def $eax killed $eax killed $rax def $rax
	andl	$-4, %eax
	movq	%rax, -248(%rbp)                ## 8-byte Spill
	leaq	(,%rcx,4), %rax
	movq	%rax, -136(%rbp)                ## 8-byte Spill
	movq	-64(%rbp), %r8                  ## 8-byte Reload
	leaq	(%r8,%rcx,8), %r12
	movq	%rdx, -264(%rbp)                ## 8-byte Spill
	leaq	(%r8,%rdx,4), %rdx
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [9,9,9,9]
	movdqa	LCPI0_1(%rip), %xmm1            ## xmm1 = [8,8,8,8]
	movq	%rsi, -216(%rbp)                ## 8-byte Spill
	leaq	(%r8,%rsi,4), %r9
	movl	$1, %ecx
	xorl	%eax, %eax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	-88(%rbp), %r14                 ## 8-byte Reload
	jmp	LBB0_46
	.p2align	4, 0x90
LBB0_45:                                ##   in Loop: Header=BB0_46 Depth=1
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	addq	%rcx, %r14
	movq	-152(%rbp), %rsi                ## 8-byte Reload
	leal	1(%rsi), %eax
	incq	-96(%rbp)                       ## 8-byte Folded Spill
	addq	%rcx, %r12
	addq	%rcx, %r8
	movq	-80(%rbp), %rdx                 ## 8-byte Reload
	addq	%rcx, %rdx
	addq	%rcx, %r9
	cmpl	-144(%rbp), %esi                ## 4-byte Folded Reload
	movl	%eax, %ecx
	je	LBB0_61
LBB0_46:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_54 Depth 2
                                        ##     Child Loop BB0_60 Depth 2
	movq	%rcx, -152(%rbp)                ## 8-byte Spill
	movq	%rdx, -80(%rbp)                 ## 8-byte Spill
	cmpl	$0, -56(%rbp)                   ## 4-byte Folded Reload
	jle	LBB0_45
## %bb.47:                              ##   in Loop: Header=BB0_46 Depth=1
	cmpl	$4, -56(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_49
LBB0_58:                                ##   in Loop: Header=BB0_46 Depth=1
	xorl	%eax, %eax
LBB0_59:                                ##   in Loop: Header=BB0_46 Depth=1
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	addq	%rax, %rcx
	leaq	(%r14,%rcx,4), %r15
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	addq	%rax, %rcx
	leaq	(%r14,%rcx,4), %rdx
	leaq	(%r8,%rax,4), %r13
	leaq	(%r12,%rax,4), %r10
	leaq	(%r14,%rax,4), %rcx
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	subq	%rax, %rdi
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_60:                                ##   Parent Loop BB0_46 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r10,%rax,4), %r11d
	addl	(%rcx,%rax,4), %r11d
	leal	(%r11,%r11,8), %ebx
	movl	(%r13,%rax,4), %esi
	addl	(%rdx,%rax,4), %esi
	subl	%esi, %ebx
	addl	$8, %ebx
	sarl	$4, %ebx
	subl	%ebx, (%r15,%rax,4)
	incq	%rax
	cmpq	%rax, %rdi
	jne	LBB0_60
	jmp	LBB0_45
	.p2align	4, 0x90
LBB0_49:                                ##   in Loop: Header=BB0_46 Depth=1
	movq	-96(%rbp), %rsi                 ## 8-byte Reload
	imulq	-168(%rbp), %rsi                ## 8-byte Folded Reload
	movq	-216(%rbp), %rax                ## 8-byte Reload
	addq	%rsi, %rax
	movq	-208(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rsi), %rcx
	movq	-200(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rsi), %rdx
	movq	-192(%rbp), %rdi                ## 8-byte Reload
	leaq	(%rdi,%rsi), %rdi
	movq	-184(%rbp), %rbx                ## 8-byte Reload
	leaq	(%rbx,%rsi), %r10
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	leaq	(%rsi,%rbx), %r11
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	leaq	(%rbx,%rax,4), %rax
	leaq	(%rbx,%rcx,4), %rcx
	leaq	(%rbx,%rdx,4), %rdx
	leaq	(%rbx,%rdi,4), %rdi
	leaq	(%rbx,%r10,4), %r10
	cmpq	%rdx, %rax
	setb	%r15b
	cmpq	%rcx, %r14
	setb	-128(%rbp)                      ## 1-byte Folded Spill
	cmpq	%r10, %rax
	setb	%r13b
	cmpq	%rcx, %rdi
	leaq	(%rbx,%rsi,4), %rdi
	leaq	(%rbx,%r11,4), %rdx
	setb	%r10b
	cmpq	%rdx, %rax
	setb	%dl
	cmpq	%rcx, %rdi
	movq	-256(%rbp), %rdi                ## 8-byte Reload
	leaq	(%rdi,%rsi), %rdi
	leaq	(%rbx,%rdi,4), %rdi
	setb	%r11b
	cmpq	%rdi, %rax
	movq	-264(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%rsi), %rax
	leaq	(%rbx,%rax,4), %rax
	setb	%sil
	cmpq	%rcx, %rax
	setb	%cl
	testb	%r15b, -128(%rbp)               ## 1-byte Folded Reload
	jne	LBB0_58
## %bb.50:                              ##   in Loop: Header=BB0_46 Depth=1
	andb	%r10b, %r13b
	jne	LBB0_58
## %bb.51:                              ##   in Loop: Header=BB0_46 Depth=1
	andb	%r11b, %dl
	jne	LBB0_58
## %bb.52:                              ##   in Loop: Header=BB0_46 Depth=1
	movl	$0, %eax
	andb	%cl, %sil
	jne	LBB0_59
## %bb.53:                              ##   in Loop: Header=BB0_46 Depth=1
	xorl	%edx, %edx
	movq	-248(%rbp), %rcx                ## 8-byte Reload
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_54:                                ##   Parent Loop BB0_46 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%r14,%rdx,4), %xmm2
	movdqu	(%r12,%rdx,4), %xmm3
	paddd	%xmm2, %xmm3
	pmulld	%xmm0, %xmm3
	movdqu	(%r8,%rdx,4), %xmm2
	movdqu	(%rax,%rdx,4), %xmm4
	paddd	%xmm2, %xmm4
	psubd	%xmm4, %xmm3
	paddd	%xmm1, %xmm3
	psrad	$4, %xmm3
	movdqu	(%r9,%rdx,4), %xmm2
	psubd	%xmm3, %xmm2
	movdqu	%xmm2, (%r9,%rdx,4)
	addq	$4, %rdx
	cmpq	%rdx, %rcx
	jne	LBB0_54
## %bb.55:                              ##   in Loop: Header=BB0_46 Depth=1
	movq	%rcx, %rax
	cmpq	-48(%rbp), %rcx                 ## 8-byte Folded Reload
	je	LBB0_45
	jmp	LBB0_59
LBB0_61:
	cmpl	$0, -56(%rbp)                   ## 4-byte Folded Reload
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	jle	LBB0_92
## %bb.62:
	movq	-176(%rbp), %rax                ## 8-byte Reload
	decl	%eax
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	imull	%ecx, %eax
	movslq	%eax, %r15
	leaq	(%r12,%r15,4), %rax
	cmpl	$4, %ecx
	jae	LBB0_68
## %bb.63:
	xorl	%ecx, %ecx
LBB0_64:
	addq	%rcx, %r15
	movq	%r15, %rdx
	subq	%r13, %rdx
	leaq	(%r12,%rdx,4), %rdx
	movl	%ecx, %r8d
	subl	-156(%rbp), %r8d                ## 4-byte Folded Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	leal	(%rdi,%rdi,4), %esi
	movl	%ecx, %r9d
	subl	%esi, %r9d
	leal	(%rdi,%rdi,2), %esi
	movl	%ecx, %r10d
	subl	%esi, %r10d
	leaq	(%r12,%r15,4), %r11
	movq	-48(%rbp), %r14                 ## 8-byte Reload
	subq	%rcx, %r14
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_65:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rdx,%rsi,4), %ebx
	movl	%ebx, %ecx
	shll	$4, %ecx
	addl	%ebx, %ecx
	leal	(%r10,%rsi), %ebx
	movslq	%ebx, %rbx
	subl	(%rax,%rbx,4), %ecx
	addl	$8, %ecx
	sarl	$4, %ecx
	subl	%ecx, (%r11,%rsi,4)
	movl	(%rax,%rbx,4), %ecx
	leal	(%rcx,%rcx,8), %ecx
	movl	(%rdx,%rsi,4), %ebx
	leal	(%r9,%rsi), %edi
	movslq	%edi, %rdi
	leal	(%rcx,%rbx,8), %ecx
	subl	(%rax,%rdi,4), %ecx
	addl	$8, %ecx
	sarl	$4, %ecx
	leal	(%r8,%rsi), %edi
	movslq	%edi, %rdi
	subl	%ecx, (%rax,%rdi,4)
	incq	%rsi
	cmpq	%rsi, %r14
	jne	LBB0_65
LBB0_66:
	cmpl	$8, -56(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_84
## %bb.67:
	xorl	%eax, %eax
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	jmp	LBB0_90
LBB0_68:
	movl	-156(%rbp), %ecx                ## 4-byte Reload
	movl	%ecx, %r9d
	negl	%r9d
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	leaq	-1(%rcx), %rdx
	leal	(%r9,%rdx), %esi
	xorl	%ecx, %ecx
	cmpl	%r9d, %esi
	jl	LBB0_64
## %bb.69:
	movq	%rdx, %rdi
	shrq	$32, %rdi
	jne	LBB0_64
## %bb.70:
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	leal	(%rsi,%rsi,2), %r10d
	negl	%r10d
	leal	(%r10,%rdx), %ebx
	cmpl	%r10d, %ebx
	jl	LBB0_64
## %bb.71:
	testq	%rdi, %rdi
	jne	LBB0_64
## %bb.72:
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	leal	(%rsi,%rsi,4), %r8d
	negl	%r8d
	addl	%r8d, %edx
	cmpl	%r8d, %edx
	jl	LBB0_64
## %bb.73:
	testq	%rdi, %rdi
	jne	LBB0_64
## %bb.74:
	movq	%r13, %rsi
	movq	-48(%rbp), %r13                 ## 8-byte Reload
	leaq	(%r15,%r13), %rcx
	leaq	(%r12,%rcx,4), %rdi
	movslq	%r9d, %rdx
	addq	%r15, %rdx
	leaq	(%r12,%rdx,4), %r11
	addq	%r13, %rdx
	leaq	(%r12,%rdx,4), %rbx
	movq	%r15, %rdx
	subq	%rsi, %rdx
	leaq	(%r12,%rdx,4), %rdx
	subq	%rsi, %rcx
	leaq	(%r12,%rcx,4), %r14
	movslq	%r10d, %rcx
	addq	%r15, %rcx
	leaq	(%r12,%rcx,4), %rsi
	movq	%rsi, -96(%rbp)                 ## 8-byte Spill
	addq	%r13, %rcx
	leaq	(%r12,%rcx,4), %rcx
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	movslq	%r8d, %rsi
	addq	%r15, %rsi
	leaq	(%r12,%rsi,4), %rcx
	movq	%rcx, -144(%rbp)                ## 8-byte Spill
	addq	%r13, %rsi
	leaq	(%r12,%rsi,4), %rsi
	cmpq	%rbx, %rax
	setb	-80(%rbp)                       ## 1-byte Folded Spill
	cmpq	%rdi, %r11
	setb	-152(%rbp)                      ## 1-byte Folded Spill
	cmpq	%r14, %rax
	setb	-128(%rbp)                      ## 1-byte Folded Spill
	cmpq	%rdi, %rdx
	setb	-120(%rbp)                      ## 1-byte Folded Spill
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	cmpq	%rcx, %rax
	setb	-216(%rbp)                      ## 1-byte Folded Spill
	movq	-96(%rbp), %r12                 ## 8-byte Reload
	cmpq	%rdi, %r12
	setb	-208(%rbp)                      ## 1-byte Folded Spill
	cmpq	%rsi, %rax
	setb	-200(%rbp)                      ## 1-byte Folded Spill
	movq	-144(%rbp), %r13                ## 8-byte Reload
	cmpq	%rdi, %r13
	setb	-192(%rbp)                      ## 1-byte Folded Spill
	cmpq	%r14, %r11
	setb	%dil
	cmpq	%rbx, %rdx
	setb	-184(%rbp)                      ## 1-byte Folded Spill
	cmpq	%rcx, %r11
	setb	%r14b
	cmpq	%rbx, %r12
	setb	%r12b
	cmpq	%rsi, %r11
	setb	%r11b
	cmpq	%rbx, %r13
	setb	%sil
	xorl	%ecx, %ecx
	movb	-152(%rbp), %bl                 ## 1-byte Reload
	testb	%bl, -80(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_118
## %bb.75:
	movb	-120(%rbp), %bl                 ## 1-byte Reload
	andb	%bl, -128(%rbp)                 ## 1-byte Folded Spill
	jne	LBB0_118
## %bb.76:
	movb	-208(%rbp), %bl                 ## 1-byte Reload
	andb	%bl, -216(%rbp)                 ## 1-byte Folded Spill
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	jne	LBB0_119
## %bb.77:
	movb	%sil, -80(%rbp)                 ## 1-byte Spill
	movl	%r12d, %esi
	movb	-192(%rbp), %bl                 ## 1-byte Reload
	andb	%bl, -200(%rbp)                 ## 1-byte Folded Spill
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	jne	LBB0_64
## %bb.78:
	andb	-184(%rbp), %dil                ## 1-byte Folded Reload
	jne	LBB0_64
## %bb.79:
	andb	%sil, %r14b
	jne	LBB0_64
## %bb.80:
	andb	-80(%rbp), %r11b                ## 1-byte Folded Reload
	jne	LBB0_64
## %bb.81:
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx def $rcx
	andl	$-4, %ecx
	movl	%r10d, %r11d
	movl	%r8d, %r8d
	movl	%r9d, %edi
	xorl	%esi, %esi
	movdqa	LCPI0_2(%rip), %xmm0            ## xmm0 = [17,17,17,17]
	movdqa	LCPI0_1(%rip), %xmm1            ## xmm1 = [8,8,8,8]
	movdqa	LCPI0_0(%rip), %xmm2            ## xmm2 = [9,9,9,9]
	.p2align	4, 0x90
LBB0_82:                                ## =>This Inner Loop Header: Depth=1
	movdqu	(%rdx,%rsi,4), %xmm3
	pmulld	%xmm0, %xmm3
	leal	(%r11,%rsi), %ebx
	movslq	%ebx, %rbx
	movdqu	(%rax,%rbx,4), %xmm4
	psubd	%xmm4, %xmm3
	paddd	%xmm1, %xmm3
	psrad	$4, %xmm3
	movdqu	(%rax,%rsi,4), %xmm4
	psubd	%xmm3, %xmm4
	movdqu	%xmm4, (%rax,%rsi,4)
	movdqu	(%rax,%rbx,4), %xmm3
	pmulld	%xmm2, %xmm3
	movdqu	(%rdx,%rsi,4), %xmm4
	pslld	$3, %xmm4
	paddd	%xmm3, %xmm4
	leal	(%r8,%rsi), %ebx
	movslq	%ebx, %rbx
	movdqu	(%rax,%rbx,4), %xmm3
	psubd	%xmm3, %xmm4
	paddd	%xmm1, %xmm4
	psrad	$4, %xmm4
	leal	(%rdi,%rsi), %ebx
	movslq	%ebx, %rbx
	movdqu	(%rax,%rbx,4), %xmm3
	psubd	%xmm4, %xmm3
	movdqu	%xmm3, (%rax,%rbx,4)
	addq	$4, %rsi
	cmpq	%rsi, %rcx
	jne	LBB0_82
## %bb.83:
	cmpq	-48(%rbp), %rcx                 ## 8-byte Folded Reload
	jne	LBB0_64
	jmp	LBB0_66
LBB0_84:
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%r13), %rax
	leaq	(%r12,%rax,4), %rax
	cmpq	%rax, %r12
	jae	LBB0_87
## %bb.85:
	leaq	(%r12,%rcx,4), %rax
	cmpq	%rax, -240(%rbp)                ## 8-byte Folded Reload
	jae	LBB0_87
## %bb.86:
	xorl	%eax, %eax
	movq	%rcx, %rsi
	jmp	LBB0_90
LBB0_87:
	movl	%ecx, %eax
	andl	$-8, %eax
	leaq	(%r12,%r13,4), %rdx
	addq	$16, %rdx
	xorl	%esi, %esi
	movdqa	LCPI0_3(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	.p2align	4, 0x90
LBB0_88:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rdx,%rsi,4), %xmm1
	movdqu	(%rdx,%rsi,4), %xmm2
	paddd	%xmm1, %xmm1
	paddd	%xmm2, %xmm2
	paddd	%xmm0, %xmm1
	paddd	%xmm0, %xmm2
	psrad	$2, %xmm1
	psrad	$2, %xmm2
	movdqu	(%r12,%rsi,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	16(%r12,%rsi,4), %xmm1
	paddd	%xmm2, %xmm1
	movdqu	%xmm3, (%r12,%rsi,4)
	movdqu	%xmm1, 16(%r12,%rsi,4)
	addq	$8, %rsi
	cmpq	%rsi, %rax
	jne	LBB0_88
## %bb.89:
	cmpq	%rcx, %rax
	movq	%rcx, %rsi
	je	LBB0_92
LBB0_90:
	leaq	(%r12,%r13,4), %rcx
	addq	$4, %rcx
	.p2align	4, 0x90
LBB0_91:                                ## =>This Inner Loop Header: Depth=1
	movl	-4(%rcx,%rax,4), %edx
	addl	%edx, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%r12,%rax,4)
	movl	(%rcx,%rax,4), %edx
	addl	%edx, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, 4(%r12,%rax,4)
	addq	$2, %rax
	cmpq	%rax, %rsi
	jne	LBB0_91
LBB0_92:
	cmpl	$3, -112(%rbp)                  ## 4-byte Folded Reload
	jl	LBB0_106
## %bb.93:
	movq	-112(%rbp), %rax                ## 8-byte Reload
	addl	$-2, %eax
	movl	%eax, -80(%rbp)                 ## 4-byte Spill
	movq	-48(%rbp), %r13                 ## 8-byte Reload
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%r13), %rdx
	movq	%rcx, %rsi
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	subq	%rax, %rsi
	movq	%rdx, -96(%rbp)                 ## 8-byte Spill
	subq	%rax, %rdx
	movq	%rdx, -136(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rcx), %rdx
	leaq	(%rdx,%r13), %rax
	movq	%rax, -120(%rbp)                ## 8-byte Spill
                                        ## kill: def $r13d killed $r13d killed $r13 def $r13
	andl	$-8, %r13d
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rsi,4), %r10
	addq	$16, %r10
	leaq	(,%rcx,4), %rdi
	movq	%rdi, -152(%rbp)                ## 8-byte Spill
	movq	%rdx, -128(%rbp)                ## 8-byte Spill
	leaq	16(%rax,%rdx,4), %r14
	movq	%rsi, -144(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rsi,4), %r15
	leaq	(%rax,%rcx,4), %r12
	addq	$4, %r12
	movl	$1, %r9d
	movdqa	LCPI0_3(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	xorl	%r8d, %r8d
	jmp	LBB0_95
	.p2align	4, 0x90
LBB0_94:                                ##   in Loop: Header=BB0_95 Depth=1
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	addq	%rcx, -88(%rbp)                 ## 8-byte Folded Spill
	leal	1(%r9), %eax
	incq	%r8
	addq	%rcx, %r10
	addq	%rcx, %r14
	addq	%rcx, %r15
	addq	%rcx, %r12
	cmpl	-80(%rbp), %r9d                 ## 4-byte Folded Reload
	movl	%eax, %r9d
	je	LBB0_106
LBB0_95:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_101 Depth 2
                                        ##     Child Loop BB0_105 Depth 2
	cmpl	$0, -56(%rbp)                   ## 4-byte Folded Reload
	jle	LBB0_94
## %bb.96:                              ##   in Loop: Header=BB0_95 Depth=1
	cmpl	$8, -56(%rbp)                   ## 4-byte Folded Reload
	jb	LBB0_103
## %bb.98:                              ##   in Loop: Header=BB0_95 Depth=1
	movq	%r8, %rcx
	imulq	-168(%rbp), %rcx                ## 8-byte Folded Reload
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rcx), %rdx
	movq	-144(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%rcx), %rbx
	movq	-136(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%rcx), %rdi
	movq	-128(%rbp), %rax                ## 8-byte Reload
	leaq	(%rax,%rcx), %r11
	addq	-120(%rbp), %rcx                ## 8-byte Folded Reload
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rdi,4), %rdi
	movq	-88(%rbp), %rsi                 ## 8-byte Reload
	cmpq	%rdi, %rsi
	leaq	(%rax,%rdx,4), %rdx
	leaq	(%rax,%rbx,4), %rbx
	setb	%dil
	cmpq	%rdx, %rbx
	leaq	(%rax,%rcx,4), %rcx
	setb	%bl
	cmpq	%rcx, %rsi
	leaq	(%rax,%r11,4), %rsi
	setb	%cl
	cmpq	%rdx, %rsi
	setb	%dl
	testb	%bl, %dil
	jne	LBB0_103
## %bb.99:                              ##   in Loop: Header=BB0_95 Depth=1
	movl	$0, %edi
	andb	%dl, %cl
	jne	LBB0_104
## %bb.100:                             ##   in Loop: Header=BB0_95 Depth=1
	xorl	%r11d, %r11d
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_101:                               ##   Parent Loop BB0_95 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	-16(%r10,%r11,4), %xmm1
	movdqu	(%r10,%r11,4), %xmm2
	movdqu	-16(%r14,%r11,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	(%r14,%r11,4), %xmm1
	paddd	%xmm2, %xmm1
	paddd	%xmm0, %xmm3
	paddd	%xmm0, %xmm1
	psrad	$2, %xmm3
	psrad	$2, %xmm1
	movdqu	(%rax,%r11,4), %xmm2
	paddd	%xmm3, %xmm2
	movdqu	16(%rax,%r11,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	%xmm2, (%rax,%r11,4)
	movdqu	%xmm3, 16(%rax,%r11,4)
	addq	$8, %r11
	cmpq	%r11, %r13
	jne	LBB0_101
## %bb.102:                             ##   in Loop: Header=BB0_95 Depth=1
	movq	%r13, %rdi
	cmpq	-48(%rbp), %r13                 ## 8-byte Folded Reload
	je	LBB0_94
	jmp	LBB0_104
	.p2align	4, 0x90
LBB0_103:                               ##   in Loop: Header=BB0_95 Depth=1
	xorl	%edi, %edi
LBB0_104:                               ##   in Loop: Header=BB0_95 Depth=1
	leaq	(%r15,%rdi,4), %rbx
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rdi), %rcx
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rcx,4), %rdx
	leaq	(%r12,%rdi,4), %rcx
	movq	-48(%rbp), %r11                 ## 8-byte Reload
	subq	%rdi, %r11
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_105:                               ##   Parent Loop BB0_95 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rbx,%rdi,4), %eax
	movl	(%rdx,%rdi,4), %esi
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, -4(%rcx,%rdi,4)
	movl	4(%rbx,%rdi,4), %eax
	movl	4(%rdx,%rdi,4), %esi
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, (%rcx,%rdi,4)
	addq	$2, %rdi
	cmpq	%rdi, %r11
	jne	LBB0_105
	jmp	LBB0_94
LBB0_106:
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	testl	%ecx, %ecx
	movq	-64(%rbp), %r8                  ## 8-byte Reload
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	jle	LBB0_117
## %bb.107:
	movq	-176(%rbp), %rdx                ## 8-byte Reload
	addl	$-2, %edx
	imull	%ecx, %edx
	movslq	%edx, %r14
	cmpl	$8, %ecx
	jae	LBB0_109
## %bb.108:
	xorl	%ecx, %ecx
	jmp	LBB0_114
LBB0_109:
	leaq	(%r8,%r14,4), %rcx
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	leaq	(%r14,%rbx), %rdx
	leaq	(%r8,%rdx,4), %rdi
	movq	%r14, %rsi
	subq	%rax, %rsi
	leaq	(%r8,%rsi,4), %r11
	subq	%rax, %rdx
	leaq	(%r8,%rdx,4), %rdx
	leaq	(%rax,%r14), %rsi
	leaq	(%r8,%rsi,4), %r9
	addq	%rsi, %rbx
	leaq	(%r8,%rbx,4), %rbx
	cmpq	%rdx, %rcx
	setb	%r10b
	cmpq	%rdi, %r11
	setb	%r11b
	cmpq	%rbx, %rcx
	setb	%dl
	cmpq	%rdi, %r9
	setb	%bl
	xorl	%ecx, %ecx
	testb	%r11b, %r10b
	jne	LBB0_114
## %bb.110:
	andb	%bl, %dl
	movq	-48(%rbp), %r9                  ## 8-byte Reload
	jne	LBB0_115
## %bb.111:
	movl	%r9d, %ecx
	andl	$-8, %ecx
	leaq	4(%r14), %rdx
	subq	%rax, %rdx
	leaq	(%r8,%rdx,4), %rdx
	leaq	(%r8,%rsi,4), %rsi
	addq	$16, %rsi
	leaq	(%r8,%r14,4), %rdi
	addq	$16, %rdi
	xorl	%ebx, %ebx
	movdqa	LCPI0_3(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	.p2align	4, 0x90
LBB0_112:                               ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rdx,%rbx,4), %xmm1
	movdqu	(%rdx,%rbx,4), %xmm2
	movdqu	-16(%rsi,%rbx,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	(%rsi,%rbx,4), %xmm1
	paddd	%xmm2, %xmm1
	paddd	%xmm0, %xmm3
	paddd	%xmm0, %xmm1
	psrad	$2, %xmm3
	psrad	$2, %xmm1
	movdqu	-16(%rdi,%rbx,4), %xmm2
	paddd	%xmm3, %xmm2
	movdqu	(%rdi,%rbx,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	%xmm2, -16(%rdi,%rbx,4)
	movdqu	%xmm3, (%rdi,%rbx,4)
	addq	$8, %rbx
	cmpq	%rbx, %rcx
	jne	LBB0_112
## %bb.113:
	movq	-48(%rbp), %r9                  ## 8-byte Reload
	cmpq	%r9, %rcx
	je	LBB0_117
	jmp	LBB0_115
LBB0_114:
	movq	-48(%rbp), %r9                  ## 8-byte Reload
LBB0_115:
	leaq	(%rcx,%r14), %rsi
	leaq	(%r8,%rsi,4), %rdx
	subq	%rax, %rsi
	leaq	(%r8,%rsi,4), %rsi
	addq	%rcx, %rax
	addq	%r14, %rax
	leaq	(%r8,%rax,4), %rax
	subq	%rcx, %r9
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_116:                               ## =>This Inner Loop Header: Depth=1
	movl	(%rsi,%rcx,4), %edi
	movl	(%rax,%rcx,4), %ebx
	addl	%ebx, %edi
	addl	$2, %edi
	sarl	$2, %edi
	addl	%edi, (%rdx,%rcx,4)
	movl	4(%rsi,%rcx,4), %edi
	movl	4(%rax,%rcx,4), %ebx
	addl	%ebx, %edi
	addl	$2, %edi
	sarl	$2, %edi
	addl	%edi, 4(%rdx,%rcx,4)
	addq	$2, %rcx
	cmpq	%rcx, %r9
	jne	LBB0_116
LBB0_117:
	movq	-232(%rbp), %rdi                ## 8-byte Reload
	movl	-220(%rbp), %esi                ## 4-byte Reload
	movq	-104(%rbp), %rdx                ## 8-byte Reload
                                        ## kill: def $edx killed $edx killed $rdx
	movq	-112(%rbp), %rcx                ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	addq	$96, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_deinterleave                   ## TAILCALL
LBB0_118:
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	jmp	LBB0_64
LBB0_119:
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	jmp	LBB0_64
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_vc2_subband_dwt_97
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4                               ; -- Begin function vc2_subband_dwt_97
lCPI0_0:
	.quad	3                               ; 0x3
	.quad	4                               ; 0x4
lCPI0_1:
	.quad	1                               ; 0x1
	.quad	2                               ; 0x2
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	2
_vc2_subband_dwt_97:                    ; @vc2_subband_dwt_97
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #192
	.cfi_def_cfa_offset 192
	stp	x28, x27, [sp, #96]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #112]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #128]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #144]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #160]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #176]            ; 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 $w2 killed $w2 def $x2
	ldr	x8, [x0]
	lsl	w9, w3, #1
	lsl	w11, w4, #1
	cmp	w11, #1
	str	w3, [sp, #84]                   ; 4-byte Folded Spill
	str	w4, [sp, #28]                   ; 4-byte Folded Spill
	stp	x1, x2, [sp, #8]                ; 16-byte Folded Spill
	b.lt	LBB0_29
; %bb.1:
	mov	x12, #0
	mov	x10, x9
	sxtw	x5, w10
	sbfiz	x13, x10, #2, #32
	sbfiz	x14, x2, #2, #32
	and	x15, x9, #0xfffffff0
	mov	x16, x1
	mov	x17, x8
	mov	x2, x1
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	x12, x12, #1
	add	x17, x17, x13
	add	x16, x16, x14
	cmp	w12, w11
	b.eq	LBB0_10
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_7 Depth 2
                                        ;     Child Loop BB0_9 Depth 2
	cmp	w9, #1
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x0, #0
	cmp	w9, #16
	b.lo	LBB0_9
; %bb.5:                                ;   in Loop: Header=BB0_3 Depth=1
	madd	x10, x14, x12, x2
	madd	x1, x13, x12, x8
	sub	x10, x1, x10
	cmp	x10, #64
	b.lo	LBB0_9
; %bb.6:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x10, #0
	mov	x0, x15
LBB0_7:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x1, x16, x10
	ldp	q0, q1, [x1]
	ldp	q2, q3, [x1, #32]
	shl.4s	v0, v0, #1
	shl.4s	v1, v1, #1
	shl.4s	v2, v2, #1
	shl.4s	v3, v3, #1
	add	x1, x17, x10
	stp	q0, q1, [x1]
	stp	q2, q3, [x1, #32]
	add	x10, x10, #64
	subs	x0, x0, #16
	b.ne	LBB0_7
; %bb.8:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x0, x15
	cmp	x15, x9
	b.eq	LBB0_2
LBB0_9:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x10, x0, #2
	ldr	w1, [x16, x10]
	lsl	w1, w1, #1
	str	w1, [x17, x10]
	add	x0, x0, #1
	cmp	x9, x0
	b.ne	LBB0_9
	b	LBB0_2
LBB0_10:
	mov	w12, #0
	sub	w13, w3, #2
	mov	x10, x9
	sxtw	x10, w10
	sub	x14, x10, #2
	sub	x15, x10, #4
	sub	x16, x10, #1
	sub	x17, x10, #6
	sub	x0, x10, #3
	sub	w10, w3, #1
	str	x10, [sp, #88]                  ; 8-byte Folded Spill
	sub	x6, x10, #1
	sub	x7, x13, #1
	ands	x10, x7, #0x3
	mov	w19, #4
	csel	x10, x19, x10, eq
	sub	x10, x7, x10
	str	x10, [sp, #72]                  ; 8-byte Folded Spill
	add	x10, x10, #1
	str	x10, [sp, #64]                  ; 8-byte Folded Spill
	and	x22, x6, #0xfffffffffffffffc
	orr	x10, x22, #0x1
	stp	x5, x10, [sp, #48]              ; 16-byte Folded Spill
	lsl	x24, x5, #2
	add	x25, x8, #20
	mov	w26, #1
Lloh0:
	adrp	x10, lCPI0_0@PAGE
Lloh1:
	ldr	q0, [x10, lCPI0_0@PAGEOFF]
Lloh2:
	adrp	x10, lCPI0_1@PAGE
Lloh3:
	ldr	q1, [x10, lCPI0_1@PAGEOFF]
	movi.4s	v2, #9
	movi.4s	v3, #8
	mov	x27, x8
	b	LBB0_12
LBB0_11:                                ;   in Loop: Header=BB0_12 Depth=1
	ldr	w10, [x27, x0, lsl #2]
	ldr	w1, [x27, x16, lsl #2]
	add	w10, w10, w1
	add	w10, w10, #2
	lsl	x1, x14, #2
	ldr	w2, [x27, x1]
	add	w10, w2, w10, asr #2
	str	w10, [x27, x1]
	add	x27, x27, x24
	add	w12, w12, #1
	add	x25, x25, x24
	cmp	w12, w11
	b.eq	LBB0_28
LBB0_12:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_16 Depth 2
                                        ;     Child Loop BB0_19 Depth 2
                                        ;     Child Loop BB0_24 Depth 2
                                        ;     Child Loop BB0_27 Depth 2
	ldp	w4, w10, [x27, #4]
	add	w10, w10, w10, lsl #3
	ldr	w1, [x27, #16]
	ldr	w2, [x27]
	add	w10, w10, w2, lsl #3
	sub	w10, w10, w1
	add	w10, w10, #8
	sub	w10, w4, w10, asr #4
	str	w10, [x27, #4]
	cmp	w3, #3
	b.le	LBB0_20
; %bb.13:                               ;   in Loop: Header=BB0_12 Depth=1
	cmp	x7, #5
	b.hs	LBB0_15
; %bb.14:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	w1, #1
	b	LBB0_18
LBB0_15:                                ;   in Loop: Header=BB0_12 Depth=1
	sub	x2, x27, #4
	ldr	x4, [sp, #72]                   ; 8-byte Folded Reload
	mov.16b	v4, v1
	mov.16b	v5, v0
LBB0_16:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	dup.2d	v6, x26
	shl.2d	v7, v4, #1
	orr.16b	v16, v7, v6
	fmov	x10, d7
	lsl	x10, x10, #2
	add	x1, x27, x10
	ld2.4s	{ v17, v18 }, [x1]
	add	x10, x10, x2
	add	x10, x10, #8
	ld2.4s	{ v19, v20 }, [x10]
	shl.2d	v7, v5, #1
	add	x10, x1, #16
	ld2.4s	{ v21, v22 }, [x10]
	add.4s	v17, v20, v17
	sub	x10, x1, #8
	ld2.4s	{ v23, v24 }, [x10]
	add.4s	v18, v21, v23
	neg.4s	v18, v18
	mla.4s	v18, v17, v2
	add.4s	v17, v18, v3
	sshr.4s	v17, v17, #4
	orr.16b	v6, v7, v6
	mov.d	x10, v16[1]
	fmov	x1, d16
	add	x10, x27, x10, lsl #2
	mov.d	x28, v6[1]
	fmov	x30, d6
	add	x30, x27, x30, lsl #2
	add	x28, x27, x28, lsl #2
	sub.4s	v6, v19, v17
	str	s6, [x27, x1, lsl #2]
	st1.s	{ v6 }[1], [x10]
	st1.s	{ v6 }[2], [x30]
	st1.s	{ v6 }[3], [x28]
	dup.2d	v6, x19
	add.2d	v5, v5, v6
	add.2d	v4, v4, v6
	subs	x4, x4, #4
	b.ne	LBB0_16
; %bb.17:                               ;   in Loop: Header=BB0_12 Depth=1
	ldr	x1, [sp, #64]                   ; 8-byte Folded Reload
LBB0_18:                                ;   in Loop: Header=BB0_12 Depth=1
	sub	x10, x13, x1
	add	x2, x27, x1, lsl #3
	mov	x1, x2
LBB0_19:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w4, [x1, #8]!
	ldp	w28, w30, [x2]
	add	w4, w4, w28
	add	w4, w4, w4, lsl #3
	ldr	w28, [x2, #16]
	ldur	w21, [x2, #-8]
	add	w21, w28, w21
	sub	w4, w4, w21
	add	w4, w4, #8
	sub	w4, w30, w4, asr #4
	str	w4, [x2, #4]
	mov	x2, x1
	subs	x10, x10, #1
	b.ne	LBB0_19
LBB0_20:                                ;   in Loop: Header=BB0_12 Depth=1
	ldr	w10, [x27, x14, lsl #2]
	add	w1, w10, w10, lsl #4
	ldr	w2, [x27, x15, lsl #2]
	sub	w1, w1, w2
	add	w1, w1, #8
	lsl	x4, x16, #2
	ldr	w21, [x27, x4]
	sub	w1, w21, w1, asr #4
	str	w1, [x27, x4]
	add	w1, w2, w2, lsl #3
	ldr	w2, [x27, x17, lsl #2]
	add	w10, w1, w10, lsl #3
	sub	w10, w10, w2
	add	w10, w10, #8
	lsl	x1, x0, #2
	ldr	w2, [x27, x1]
	sub	w10, w2, w10, asr #4
	str	w10, [x27, x1]
	ldp	w1, w10, [x27]
	lsl	w10, w10, #1
	add	w10, w10, #2
	add	w10, w1, w10, asr #2
	str	w10, [x27]
	cmp	w3, #3
	b.lt	LBB0_11
; %bb.21:                               ;   in Loop: Header=BB0_12 Depth=1
	cmp	x6, #4
	b.hs	LBB0_23
; %bb.22:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	w1, #1
	b	LBB0_26
LBB0_23:                                ;   in Loop: Header=BB0_12 Depth=1
	mov	x2, x25
	mov	x4, x22
LBB0_24:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	w3, w10, [x2, #12]
	ldp	w1, w21, [x2, #-16]
	ldp	w28, w30, [x2, #-8]
	add	w1, w1, w28
	ldp	w23, w20, [x2]
	add	w28, w28, w23
	ldr	w5, [x2, #8]
	add	w23, w23, w5
	add	w10, w5, w10
	add	w1, w1, #2
	add	w5, w28, #2
	add	w23, w23, #2
	add	w1, w21, w1, asr #2
	add	w10, w10, #2
	add	w5, w30, w5, asr #2
	add	w20, w20, w23, asr #2
	add	w10, w3, w10, asr #2
	stur	w1, [x2, #-12]
	stur	w5, [x2, #-4]
	str	w20, [x2, #4]
	str	w10, [x2, #12]
	add	x2, x2, #32
	subs	x4, x4, #4
	b.ne	LBB0_24
; %bb.25:                               ;   in Loop: Header=BB0_12 Depth=1
	ldr	x1, [sp, #56]                   ; 8-byte Folded Reload
	cmp	x6, x22
	ldr	w3, [sp, #84]                   ; 4-byte Folded Reload
	b.eq	LBB0_11
LBB0_26:                                ;   in Loop: Header=BB0_12 Depth=1
	lsl	x10, x1, #3
	ldr	x2, [sp, #88]                   ; 8-byte Folded Reload
	sub	x1, x2, x1
LBB0_27:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x2, x27, x10
	ldp	w20, w5, [x2, #-4]
	ldr	w4, [x2, #4]
	add	w4, w20, w4
	add	w4, w4, #2
	add	w4, w5, w4, asr #2
	str	w4, [x2]
	add	x10, x10, #8
	subs	x1, x1, #1
	b.ne	LBB0_27
	b	LBB0_11
LBB0_28:
	ldr	w4, [sp, #28]                   ; 4-byte Folded Reload
	ldr	x19, [sp, #48]                  ; 8-byte Folded Reload
	b	LBB0_30
LBB0_29:
	mov	x10, x9
	sxtw	x19, w10
LBB0_30:
	add	x2, x8, x19, lsl #2
	cmp	w9, #1
	b.lt	LBB0_35
; %bb.31:
	add	w10, w3, w3, lsl #1
	lsl	w10, w10, #1
	sxtw	x13, w10
	lsl	x12, x19, #3
	cmp	w9, #16
	b.hs	LBB0_80
; %bb.32:
	mov	x14, #0
LBB0_33:
	add	x15, x8, x14, lsl #2
	add	x16, x14, x13
	sub	x13, x9, x14
	lsl	x10, x19, #2
	add	x14, x8, x16, lsl #2
LBB0_34:                                ; =>This Inner Loop Header: Depth=1
	ldr	w16, [x15]
	ldr	w17, [x15, x12]
	ldr	w0, [x14, x10]
	add	w17, w17, w17, lsl #3
	add	w16, w17, w16, lsl #3
	sub	w16, w16, w0
	add	w16, w16, #8
	ldr	w17, [x15, x10]
	sub	w16, w17, w16, asr #4
	str	w16, [x15, x10]
	add	x15, x15, #4
	add	x14, x14, #4
	subs	x13, x13, #1
	b.ne	LBB0_34
LBB0_35:
	str	x2, [sp]                        ; 8-byte Folded Spill
	lsl	w10, w3, #2
	sxtw	x12, w10
	add	x13, x8, w10, sxtw #2
	str	x12, [sp, #88]                  ; 8-byte Folded Spill
	lsl	x14, x12, #2
	cmp	w4, #4
	b.lt	LBB0_50
; %bb.36:
	mov	x16, #0
	ldr	w10, [sp, #84]                  ; 4-byte Folded Reload
	lsl	w10, w10, #3
	sxtw	x17, w10
	ldr	w12, [sp, #28]                  ; 4-byte Folded Reload
	sub	w0, w12, #3
	mov	x1, x19
	ldr	x12, [sp, #88]                  ; 8-byte Folded Reload
	add	x15, x19, x12
	str	x15, [sp, #72]                  ; 8-byte Folded Spill
	add	x15, x15, x9
	str	x15, [sp, #64]                  ; 8-byte Folded Spill
	add	x15, x12, x9
	str	x15, [sp, #56]                  ; 8-byte Folded Spill
	lsl	x15, x12, #1
	str	x15, [sp, #48]                  ; 8-byte Folded Spill
	add	x15, x15, x9
	str	x15, [sp, #40]                  ; 8-byte Folded Spill
	add	x21, x17, x12
	add	x15, x21, x9
	str	x15, [sp, #32]                  ; 8-byte Folded Spill
	and	x15, x9, #0xfffffff0
	lsl	x12, x12, #3
	movi.4s	v0, #9
	movi.4s	v1, #8
	add	x24, x12, #32
	add	x25, x8, x12
	mov	w2, #1
	mov	x26, x13
	mov	x4, x8
	add	x28, x14, x19, lsl #2
	add	x30, x14, w10, sxtw #2
	b	LBB0_38
LBB0_37:                                ;   in Loop: Header=BB0_38 Depth=1
	add	x26, x26, x14
	add	w10, w2, #1
	add	x16, x16, #1
	add	x4, x4, x14
	add	x25, x25, x14
	cmp	w2, w0
	mov	x2, x10
	b.eq	LBB0_50
LBB0_38:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_48 Depth 2
                                        ;     Child Loop BB0_42 Depth 2
	cmp	w9, #1
	b.lt	LBB0_37
; %bb.39:                               ;   in Loop: Header=BB0_38 Depth=1
	cmp	w9, #16
	b.hs	LBB0_43
; %bb.40:                               ;   in Loop: Header=BB0_38 Depth=1
	mov	x23, #0
LBB0_41:                                ;   in Loop: Header=BB0_38 Depth=1
	mov	x27, #0
	add	x3, x19, x23
	lsl	x12, x23, #2
	add	x7, x17, x23
	add	x1, x4, x12
	add	x10, x25, x12
	add	x12, x26, x12
	sub	x23, x9, x23
	add	x6, x26, x3, lsl #2
	add	x7, x26, x7, lsl #2
LBB0_42:                                ;   Parent Loop BB0_38 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x3, x27, #2
	ldr	w20, [x12, x3]
	ldr	w22, [x10, x3]
	add	w20, w22, w20
	add	w20, w20, w20, lsl #3
	ldr	w22, [x1, x3]
	ldr	w5, [x7, x3]
	add	w5, w22, w5
	sub	w5, w20, w5
	ldr	w20, [x6, x3]
	add	w5, w5, #8
	sub	w5, w20, w5, asr #4
	str	w5, [x6, x3]
	add	x27, x27, #1
	cmp	x23, x27
	b.ne	LBB0_42
	b	LBB0_37
LBB0_43:                                ;   in Loop: Header=BB0_38 Depth=1
	mov	x23, #0
	ldr	x10, [sp, #88]                  ; 8-byte Folded Reload
	mul	x10, x16, x10
	ldr	x12, [sp, #72]                  ; 8-byte Folded Reload
	add	x12, x12, x10
	add	x3, x8, x12, lsl #2
	ldr	x12, [sp, #64]                  ; 8-byte Folded Reload
	add	x12, x12, x10
	add	x6, x8, x12, lsl #2
	ldr	x12, [sp, #56]                  ; 8-byte Folded Reload
	add	x12, x12, x10
	add	x7, x8, x12, lsl #2
	ldp	x1, x12, [sp, #40]              ; 16-byte Folded Reload
	add	x12, x12, x10
	add	x12, x8, x12, lsl #2
	add	x1, x1, x10
	add	x1, x8, x1, lsl #2
	add	x27, x8, x10, lsl #2
	add	x20, x10, x9
	add	x20, x8, x20, lsl #2
	cmp	x3, x1
	add	x1, x21, x10
	add	x1, x8, x1, lsl #2
	ldr	x5, [sp, #32]                   ; 8-byte Folded Reload
	add	x10, x5, x10
	add	x22, x8, x10, lsl #2
	ccmp	x12, x6, #2, lo
	cset	w10, lo
	cmp	x3, x20
	ccmp	x27, x6, #2, lo
	cset	w12, lo
	cmp	x3, x22
	ccmp	x1, x6, #2, lo
	cset	w1, lo
	cmp	x26, x6
	ccmp	x3, x7, #2, lo
	b.lo	LBB0_41
; %bb.44:                               ;   in Loop: Header=BB0_38 Depth=1
	tbnz	w10, #0, LBB0_41
; %bb.45:                               ;   in Loop: Header=BB0_38 Depth=1
	tbnz	w12, #0, LBB0_41
; %bb.46:                               ;   in Loop: Header=BB0_38 Depth=1
	tbnz	w1, #0, LBB0_41
; %bb.47:                               ;   in Loop: Header=BB0_38 Depth=1
	mov	x27, x4
	mov	x23, x15
LBB0_48:                                ;   Parent Loop BB0_38 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x10, x27, x14
	ldp	q2, q3, [x10]
	ldp	q4, q5, [x10, #32]
	add	x10, x27, x24
	ldp	q6, q7, [x10, #-32]
	ldp	q16, q17, [x10]
	add.4s	v2, v6, v2
	add.4s	v3, v7, v3
	add.4s	v4, v16, v4
	add.4s	v5, v17, v5
	ldp	q6, q7, [x27]
	ldp	q16, q17, [x27, #32]
	add	x10, x27, x30
	ldp	q18, q19, [x10]
	ldp	q20, q21, [x10, #32]
	add.4s	v6, v6, v18
	add.4s	v7, v7, v19
	add.4s	v16, v16, v20
	add.4s	v17, v17, v21
	neg.4s	v6, v6
	mla.4s	v6, v2, v0
	add.4s	v2, v6, v1
	neg.4s	v6, v7
	mla.4s	v6, v3, v0
	add.4s	v3, v6, v1
	neg.4s	v6, v16
	mla.4s	v6, v4, v0
	add.4s	v4, v6, v1
	neg.4s	v6, v17
	mla.4s	v6, v5, v0
	add.4s	v5, v6, v1
	sshr.4s	v2, v2, #4
	sshr.4s	v3, v3, #4
	sshr.4s	v4, v4, #4
	sshr.4s	v5, v5, #4
	add	x10, x27, x28
	ldp	q6, q7, [x10]
	ldp	q16, q17, [x10, #32]
	sub.4s	v2, v6, v2
	sub.4s	v3, v7, v3
	sub.4s	v4, v16, v4
	sub.4s	v5, v17, v5
	stp	q2, q3, [x10]
	stp	q4, q5, [x10, #32]
	add	x27, x27, #64
	subs	x23, x23, #16
	b.ne	LBB0_48
; %bb.49:                               ;   in Loop: Header=BB0_38 Depth=1
	mov	x23, x15
	cmp	x15, x9
	b.eq	LBB0_37
	b	LBB0_41
LBB0_50:
	sxtw	x11, w11
	mov	x10, x9
	sxtw	x16, w10
	cmp	w9, #1
	ldr	w3, [sp, #28]                   ; 4-byte Folded Reload
	mov	x27, x19
	b.lt	LBB0_62
; %bb.51:
	sub	x10, x11, #1
	mul	x5, x10, x16
	add	x17, x8, x5, lsl #2
	cmp	w9, #4
	b.hs	LBB0_86
; %bb.52:
	mov	x0, #0
LBB0_53:
	ldr	w20, [sp, #84]                  ; 4-byte Folded Reload
LBB0_54:
	mov	x15, #0
	add	x10, x0, x5
	sub	x12, x10, x27
	ldr	x1, [sp, #88]                   ; 8-byte Folded Reload
	sub	w2, w0, w1
	mov	w1, #10
	msub	w4, w20, w1, w0
	mov	w1, #6
	msub	w5, w20, w1, w0
	sub	x0, x9, x0
	add	x6, x8, x12, lsl #2
	add	x7, x8, x10, lsl #2
LBB0_55:                                ; =>This Inner Loop Header: Depth=1
	lsl	x10, x15, #2
	ldr	w12, [x6, x10]
	add	w12, w12, w12, lsl #4
	add	w1, w5, w15
	sbfiz	x1, x1, #2, #32
	ldr	w19, [x17, x1]
	sub	w12, w12, w19
	ldr	w19, [x7, x10]
	add	w12, w12, #8
	sub	w12, w19, w12, asr #4
	str	w12, [x7, x10]
	ldr	w12, [x17, x1]
	add	w12, w12, w12, lsl #3
	ldr	w10, [x6, x10]
	add	w1, w4, w15
	ldr	w1, [x17, w1, sxtw #2]
	add	w10, w12, w10, lsl #3
	sub	w10, w10, w1
	add	w12, w2, w15
	sbfiz	x12, x12, #2, #32
	ldr	w1, [x17, x12]
	add	w10, w10, #8
	sub	w10, w1, w10, asr #4
	str	w10, [x17, x12]
	add	x15, x15, #1
	cmp	x0, x15
	b.ne	LBB0_55
LBB0_56:
	cmp	w9, #16
	b.lo	LBB0_59
; %bb.57:
	add	x10, x27, x9
	add	x10, x8, x10, lsl #2
	cmp	x8, x10
	b.hs	LBB0_107
; %bb.58:
	add	x10, x8, x9, lsl #2
	ldr	x12, [sp]                       ; 8-byte Folded Reload
	cmp	x12, x10
	b.hs	LBB0_107
LBB0_59:
	mov	x15, #0
LBB0_60:
	add	x10, x15, x27
	add	x17, x8, x10, lsl #2
	add	x10, x8, x15, lsl #2
	sub	x12, x9, x15
LBB0_61:                                ; =>This Inner Loop Header: Depth=1
	ldr	w15, [x17], #4
	lsl	w15, w15, #1
	add	w15, w15, #2
	ldr	w0, [x10]
	add	w15, w0, w15, asr #2
	str	w15, [x10], #4
	subs	x12, x12, #1
	b.ne	LBB0_61
LBB0_62:
	cmp	w3, #3
	b.lt	LBB0_74
; %bb.63:
	mov	x15, #0
	sub	w17, w3, #2
	ldr	x10, [sp, #88]                  ; 8-byte Folded Reload
	sub	x0, x10, x27
	add	x2, x10, x9
	sub	x5, x2, x27
	lsl	x6, x27, #2
	movi.4s	v0, #2
	add	x7, x27, x10
	add	x19, x7, x9
	and	x20, x9, #0xfffffff0
	mov	w10, #32
	sub	x21, x10, x6
	mov	w24, #1
	add	x22, x8, x7, lsl #2
	add	x23, x8, x0, lsl #2
	b	LBB0_65
LBB0_64:                                ;   in Loop: Header=BB0_65 Depth=1
	add	x13, x13, x14
	add	w10, w24, #1
	add	x15, x15, #1
	add	x22, x22, x14
	add	x23, x23, x14
	cmp	w24, w17
	mov	x24, x10
	b.eq	LBB0_74
LBB0_65:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_72 Depth 2
                                        ;     Child Loop BB0_68 Depth 2
	cmp	w9, #1
	b.lt	LBB0_64
; %bb.66:                               ;   in Loop: Header=BB0_65 Depth=1
	cmp	w9, #16
	b.hs	LBB0_69
; %bb.67:                               ;   in Loop: Header=BB0_65 Depth=1
	mov	x4, #0
LBB0_68:                                ;   Parent Loop BB0_65 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x10, x4, #2
	ldr	w12, [x23, x10]
	ldr	w1, [x22, x10]
	add	w12, w12, w1
	ldr	w1, [x13, x10]
	add	w12, w12, #2
	add	w12, w1, w12, asr #2
	str	w12, [x13, x10]
	add	x4, x4, #1
	cmp	x9, x4
	b.ne	LBB0_68
	b	LBB0_64
LBB0_69:                                ;   in Loop: Header=BB0_65 Depth=1
	mov	x4, #0
	ldr	x10, [sp, #88]                  ; 8-byte Folded Reload
	mul	x10, x15, x10
	add	x12, x2, x10
	add	x12, x8, x12, lsl #2
	add	x1, x0, x10
	add	x1, x8, x1, lsl #2
	add	x25, x19, x10
	add	x25, x8, x25, lsl #2
	cmp	x13, x25
	add	x25, x5, x10
	add	x25, x8, x25, lsl #2
	add	x10, x7, x10
	add	x10, x8, x10, lsl #2
	ccmp	x10, x12, #2, lo
	cset	w10, lo
	cmp	x1, x12
	ccmp	x13, x25, #2, lo
	b.lo	LBB0_68
; %bb.70:                               ;   in Loop: Header=BB0_65 Depth=1
	tbnz	w10, #0, LBB0_68
; %bb.71:                               ;   in Loop: Header=BB0_65 Depth=1
	mov	x4, x13
	mov	x25, x20
LBB0_72:                                ;   Parent Loop BB0_65 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x10, x4, x21
	ldp	q1, q2, [x10, #-32]
	ldp	q3, q4, [x10]
	add	x10, x4, x6
	ldp	q5, q6, [x10]
	ldp	q7, q16, [x10, #32]
	add.4s	v1, v1, v5
	add.4s	v2, v2, v6
	add.4s	v3, v3, v7
	add.4s	v4, v4, v16
	add.4s	v1, v1, v0
	add.4s	v2, v2, v0
	add.4s	v3, v3, v0
	add.4s	v4, v4, v0
	ldp	q5, q6, [x4]
	ldp	q7, q16, [x4, #32]
	ssra.4s	v5, v1, #2
	ssra.4s	v6, v2, #2
	ssra.4s	v7, v3, #2
	ssra.4s	v16, v4, #2
	stp	q5, q6, [x4]
	stp	q7, q16, [x4, #32]
	add	x4, x4, #64
	subs	x25, x25, #16
	b.ne	LBB0_72
; %bb.73:                               ;   in Loop: Header=BB0_65 Depth=1
	mov	x4, x20
	cmp	x20, x9
	b.ne	LBB0_68
	b	LBB0_64
LBB0_74:
	cmp	w9, #1
	ldr	w2, [sp, #84]                   ; 4-byte Folded Reload
	b.lt	LBB0_79
; %bb.75:
	sub	x10, x11, #2
	mul	x11, x10, x16
	cmp	w9, #16
	b.hs	LBB0_102
; %bb.76:
	mov	x12, #0
LBB0_77:
	add	x10, x12, x27
	add	x10, x10, x11
	add	x13, x8, x10, lsl #2
	neg	x10, x27, lsl #2
	add	x11, x12, x11
	sub	x9, x9, x12
	add	x11, x8, x11, lsl #2
LBB0_78:                                ; =>This Inner Loop Header: Depth=1
	ldr	w12, [x11, x10]
	ldr	w14, [x13], #4
	add	w12, w12, w14
	add	w12, w12, #2
	ldr	w14, [x11]
	add	w12, w14, w12, asr #2
	str	w12, [x11], #4
	subs	x9, x9, #1
	b.ne	LBB0_78
LBB0_79:
	ldp	x0, x1, [sp, #8]                ; 16-byte Folded Reload
                                        ; kill: def $w1 killed $w1 killed $x1
	mov	x4, x8
	ldp	x29, x30, [sp, #176]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #160]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #144]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #128]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #112]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #96]             ; 16-byte Folded Reload
	add	sp, sp, #192
	b	_deinterleave
LBB0_80:
	mov	x14, #0
	add	x10, x19, x9
	add	x16, x8, x10, lsl #2
	add	x17, x8, x9, lsl #2
	add	x10, x8, x19, lsl #3
	add	x15, x9, x19, lsl #1
	add	x15, x8, x15, lsl #2
	cmp	x2, x15
	add	x15, x19, x13
	add	x0, x15, x9
	add	x1, x8, x15, lsl #2
	add	x0, x8, x0, lsl #2
	ccmp	x10, x16, #2, lo
	cset	w15, lo
	cmp	x2, x0
	ccmp	x1, x16, #2, lo
	cset	w10, lo
	cmp	x8, x16
	ccmp	x2, x17, #2, lo
	b.lo	LBB0_33
; %bb.81:
	tbnz	w15, #0, LBB0_33
; %bb.82:
	tbnz	w10, #0, LBB0_33
; %bb.83:
	and	x14, x9, #0xfffffff0
	lsl	x15, x19, #2
	add	x16, x15, x13, lsl #2
	movi.4s	v0, #9
	movi.4s	v1, #8
	mov	x17, x8
	mov	x0, x14
LBB0_84:                                ; =>This Inner Loop Header: Depth=1
	ldp	q2, q3, [x17]
	ldp	q4, q5, [x17, #32]
	shl.4s	v2, v2, #3
	shl.4s	v3, v3, #3
	shl.4s	v4, v4, #3
	shl.4s	v5, v5, #3
	add	x10, x17, x12
	ldp	q6, q7, [x10]
	ldp	q16, q17, [x10, #32]
	add	x10, x17, x16
	ldp	q18, q19, [x10]
	ldp	q20, q21, [x10, #32]
	mla.4s	v2, v6, v0
	mla.4s	v3, v7, v0
	mla.4s	v4, v16, v0
	mla.4s	v5, v17, v0
	sub.4s	v2, v2, v18
	add.4s	v2, v2, v1
	sub.4s	v3, v3, v19
	add.4s	v3, v3, v1
	sub.4s	v4, v4, v20
	add.4s	v4, v4, v1
	sub.4s	v5, v5, v21
	add.4s	v5, v5, v1
	sshr.4s	v2, v2, #4
	sshr.4s	v3, v3, #4
	sshr.4s	v4, v4, #4
	sshr.4s	v5, v5, #4
	add	x10, x17, x15
	ldp	q6, q7, [x10]
	ldp	q16, q17, [x10, #32]
	sub.4s	v2, v6, v2
	sub.4s	v3, v7, v3
	sub.4s	v4, v16, v4
	sub.4s	v5, v17, v5
	stp	q2, q3, [x10]
	stp	q4, q5, [x10, #32]
	add	x17, x17, #64
	subs	x0, x0, #16
	b.ne	LBB0_84
; %bb.85:
	cmp	x14, x9
	b.ne	LBB0_33
	b	LBB0_35
LBB0_86:
	mov	x0, #0
	ldr	w20, [sp, #84]                  ; 4-byte Folded Reload
	neg	w2, w20, lsl #2
	sub	x10, x9, #1
	add	w12, w2, w10
	cmp	w12, w2
	b.lt	LBB0_54
; %bb.87:
	lsr	x12, x10, #32
	cbnz	x12, LBB0_54
; %bb.88:
	mov	w15, #-6
	mul	w6, w20, w15
	add	w15, w6, w10
	cmp	w15, w6
	b.lt	LBB0_54
; %bb.89:
	cbnz	x12, LBB0_54
; %bb.90:
	mov	w15, #-10
	mul	w7, w20, w15
	add	w10, w7, w10
	cmp	w10, w7
	b.lt	LBB0_54
; %bb.91:
	cbnz	x12, LBB0_54
; %bb.92:
	mov	x0, #0
	add	x10, x5, x9
	sub	x12, x10, x27
	add	x26, x8, x10, lsl #2
	add	x1, x5, w2, sxtw
	add	x20, x8, x1, lsl #2
	sub	x10, x5, x27
	add	x4, x8, x10, lsl #2
	add	x19, x8, x12, lsl #2
	add	x10, x5, w6, sxtw
	add	x21, x8, x10, lsl #2
	add	x10, x10, x9
	add	x22, x8, x10, lsl #2
	add	x10, x5, w7, sxtw
	add	x23, x8, x10, lsl #2
	add	x10, x10, x9
	add	x24, x8, x10, lsl #2
	cmp	x17, x19
	ccmp	x4, x26, #2, lo
	cset	w10, lo
	cmp	x17, x22
	ccmp	x21, x26, #2, lo
	cset	w12, lo
	cmp	x17, x24
	ccmp	x23, x26, #2, lo
	cset	w15, lo
	cmp	x20, x19
	add	x1, x1, x9
	add	x25, x8, x1, lsl #2
	ccmp	x4, x25, #2, lo
	cset	w1, lo
	cmp	x20, x22
	ccmp	x21, x25, #2, lo
	cset	w4, lo
	cmp	x20, x24
	ccmp	x23, x25, #2, lo
	cset	w19, lo
	cmp	x20, x26
	ccmp	x17, x25, #2, lo
	b.lo	LBB0_53
; %bb.93:
	ldr	w20, [sp, #84]                  ; 4-byte Folded Reload
	tbnz	w10, #0, LBB0_54
; %bb.94:
	tbnz	w12, #0, LBB0_54
; %bb.95:
	tbnz	w15, #0, LBB0_54
; %bb.96:
	tbnz	w1, #0, LBB0_54
; %bb.97:
	tbnz	w4, #0, LBB0_54
; %bb.98:
	tbnz	w19, #0, LBB0_54
; %bb.99:
	and	x0, x9, #0xfffffffc
	neg	x15, x27, lsl #2
	movi.4s	v0, #17
	movi.4s	v1, #8
	movi.4s	v2, #9
	mov	x4, x0
	mov	x19, x17
LBB0_100:                               ; =>This Inner Loop Header: Depth=1
	ldr	q3, [x19, x15]
	sbfiz	x10, x6, #2, #32
	ldr	q4, [x17, x10]
	neg.4s	v5, v4
	mla.4s	v5, v3, v0
	add.4s	v5, v5, v1
	sshr.4s	v5, v5, #4
	ldr	q6, [x19]
	sub.4s	v5, v6, v5
	shl.4s	v3, v3, #3
	sbfiz	x10, x7, #2, #32
	ldr	q6, [x17, x10]
	mla.4s	v3, v4, v2
	sub.4s	v3, v3, v6
	add.4s	v3, v3, v1
	sshr.4s	v3, v3, #4
	sbfiz	x10, x2, #2, #32
	ldr	q4, [x17, x10]
	sub.4s	v3, v4, v3
	str	q3, [x17, x10]
	str	q5, [x19], #16
	add	w6, w6, #4
	add	w7, w7, #4
	add	w2, w2, #4
	subs	x4, x4, #4
	b.ne	LBB0_100
; %bb.101:
	cmp	x0, x9
	b.ne	LBB0_54
	b	LBB0_56
LBB0_102:
	mov	x12, #0
	add	x13, x8, x11, lsl #2
	add	x10, x11, x9
	sub	x14, x10, x27
	add	x15, x8, x10, lsl #2
	add	x10, x27, x11
	add	x16, x10, x9
	add	x16, x8, x16, lsl #2
	cmp	x13, x16
	sub	x16, x11, x27
	add	x16, x8, x16, lsl #2
	add	x14, x8, x14, lsl #2
	add	x10, x8, x10, lsl #2
	ccmp	x10, x15, #2, lo
	cset	w10, lo
	cmp	x16, x15
	ccmp	x13, x14, #2, lo
	b.lo	LBB0_77
; %bb.103:
	tbnz	w10, #0, LBB0_77
; %bb.104:
	and	x12, x9, #0xfffffff0
	lsl	x14, x27, #2
	mov	w10, #32
	sub	x15, x10, x14
	movi.4s	v0, #2
	mov	x16, x12
LBB0_105:                               ; =>This Inner Loop Header: Depth=1
	add	x10, x13, x15
	ldp	q1, q2, [x10, #-32]
	ldp	q3, q4, [x10]
	add	x10, x13, x14
	ldp	q5, q6, [x10]
	ldp	q7, q16, [x10, #32]
	add.4s	v1, v1, v5
	add.4s	v2, v2, v6
	add.4s	v3, v3, v7
	add.4s	v4, v4, v16
	add.4s	v1, v1, v0
	add.4s	v2, v2, v0
	add.4s	v3, v3, v0
	add.4s	v4, v4, v0
	ldp	q5, q6, [x13]
	ldp	q7, q16, [x13, #32]
	ssra.4s	v5, v1, #2
	ssra.4s	v6, v2, #2
	ssra.4s	v7, v3, #2
	ssra.4s	v16, v4, #2
	stp	q5, q6, [x13]
	stp	q7, q16, [x13, #32]
	add	x13, x13, #64
	subs	x16, x16, #16
	b.ne	LBB0_105
; %bb.106:
	cmp	x12, x9
	b.ne	LBB0_77
	b	LBB0_79
LBB0_107:
	and	x15, x9, #0xfffffff0
	add	x17, x8, #32
	lsl	x0, x27, #2
	movi.4s	v0, #2
	mov	x2, x15
LBB0_108:                               ; =>This Inner Loop Header: Depth=1
	add	x10, x17, x0
	ldp	q1, q2, [x10, #-32]
	ldp	q3, q4, [x10]
	shl.4s	v1, v1, #1
	shl.4s	v2, v2, #1
	shl.4s	v3, v3, #1
	shl.4s	v4, v4, #1
	add.4s	v1, v1, v0
	add.4s	v2, v2, v0
	add.4s	v3, v3, v0
	add.4s	v4, v4, v0
	ldp	q5, q6, [x17, #-32]
	ldp	q7, q16, [x17]
	ssra.4s	v5, v1, #2
	ssra.4s	v6, v2, #2
	ssra.4s	v7, v3, #2
	ssra.4s	v16, v4, #2
	stp	q5, q6, [x17, #-32]
	stp	q7, q16, [x17], #64
	subs	x2, x2, #16
	b.ne	LBB0_108
; %bb.109:
	cmp	x15, x9
	b.eq	LBB0_62
	b	LBB0_60
	.loh AdrpLdr	Lloh2, Lloh3
	.loh AdrpAdrp	Lloh0, Lloh2
	.loh AdrpLdr	Lloh0, Lloh1
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_vc2_subband_dwt_97
.subsections_via_symbols
