	.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_53
LCPI0_0:
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.long	2                               ## 0x2
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_vc2_subband_dwt_53:                    ## @vc2_subband_dwt_53
	.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	$32, %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
	movq	(%rdi), %r11
	leal	(%rcx,%rcx), %r13d
	movq	%r8, -120(%rbp)                 ## 8-byte Spill
	leal	(%r8,%r8), %eax
	movl	%r13d, %r10d
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	testl	%eax, %eax
	movq	%rcx, -192(%rbp)                ## 8-byte Spill
	movq	%r11, -64(%rbp)                 ## 8-byte Spill
	movq	%r10, -56(%rbp)                 ## 8-byte Spill
	movq	%r13, -88(%rbp)                 ## 8-byte Spill
	movl	%edx, -172(%rbp)                ## 4-byte Spill
	movq	%rsi, -184(%rbp)                ## 8-byte Spill
	movslq	%r13d, %rax
	jle	LBB0_33
## %bb.1:
	movslq	%edx, %r15
	movq	%r11, %rdx
	movq	%rax, -48(%rbp)                 ## 8-byte Spill
	leaq	(,%rax,4), %r14
	shlq	$2, %r15
	movl	%r10d, %r9d
	andl	$-8, %r9d
	leaq	-8(%r9), %rax
	movq	%r10, %r8
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movq	%rax, %r10
	shrq	$3, %r10
	incq	%r10
	movq	%r10, %rax
	andq	$-2, %rax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
                                        ## kill: def $r8d killed $r8d killed $r8 def $r8
	andl	$2, %r8d
	xorl	%r12d, %r12d
	movq	%rsi, %rdi
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_2:                                 ##   in Loop: Header=BB0_3 Depth=1
	addq	%r14, %rdx
	addq	%r15, %rdi
	incq	%r12
	cmpl	-112(%rbp), %r12d               ## 4-byte Folded Reload
	je	LBB0_19
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_8 Depth 2
                                        ##     Child Loop BB0_15 Depth 2
                                        ##     Child Loop BB0_17 Depth 2
	testl	%r13d, %r13d
	jle	LBB0_2
## %bb.4:                               ##   in Loop: Header=BB0_3 Depth=1
	cmpl	$8, %r13d
	jb	LBB0_12
## %bb.5:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	%r15, %rax
	imulq	%r12, %rax
	addq	-184(%rbp), %rax                ## 8-byte Folded Reload
	movq	%r14, %rbx
	imulq	%r12, %rbx
	addq	-64(%rbp), %rbx                 ## 8-byte Folded Reload
	subq	%rax, %rbx
	movl	$0, %r11d
	cmpq	$32, %rbx
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	jb	LBB0_13
## %bb.6:                               ##   in Loop: Header=BB0_3 Depth=1
	cmpq	$0, -80(%rbp)                   ## 8-byte Folded Reload
	je	LBB0_18
## %bb.7:                               ##   in Loop: Header=BB0_3 Depth=1
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_8:                                 ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	(%rdi,%rbx,4), %xmm0
	movdqu	16(%rdi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, (%rdx,%rbx,4)
	movdqu	%xmm1, 16(%rdx,%rbx,4)
	movdqu	32(%rdi,%rbx,4), %xmm0
	movdqu	48(%rdi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, 32(%rdx,%rbx,4)
	movdqu	%xmm1, 48(%rdx,%rbx,4)
	addq	$16, %rbx
	addq	$-2, %rax
	jne	LBB0_8
## %bb.9:                               ##   in Loop: Header=BB0_3 Depth=1
	testb	$1, %r10b
	je	LBB0_11
LBB0_10:                                ##   in Loop: Header=BB0_3 Depth=1
	movdqu	(%rdi,%rbx,4), %xmm0
	movdqu	16(%rdi,%rbx,4), %xmm1
	paddd	%xmm0, %xmm0
	paddd	%xmm1, %xmm1
	movdqu	%xmm0, (%rdx,%rbx,4)
	movdqu	%xmm1, 16(%rdx,%rbx,4)
LBB0_11:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	%r9, %r11
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	cmpq	%rax, %r9
	je	LBB0_2
	jmp	LBB0_13
LBB0_12:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%r11d, %r11d
	movq	-56(%rbp), %rax                 ## 8-byte Reload
LBB0_13:                                ##   in Loop: Header=BB0_3 Depth=1
	movq	%r11, %rbx
	notq	%rbx
	addq	%rax, %rbx
	testq	%r8, %r8
	je	LBB0_16
## %bb.14:                              ##   in Loop: Header=BB0_3 Depth=1
	movq	%r8, %rax
	.p2align	4, 0x90
LBB0_15:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdi,%r11,4), %esi
	addl	%esi, %esi
	movl	%esi, (%rdx,%r11,4)
	incq	%r11
	decq	%rax
	jne	LBB0_15
LBB0_16:                                ##   in Loop: Header=BB0_3 Depth=1
	cmpq	$3, %rbx
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	jb	LBB0_2
	.p2align	4, 0x90
LBB0_17:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdi,%r11,4), %eax
	addl	%eax, %eax
	movl	%eax, (%rdx,%r11,4)
	movl	4(%rdi,%r11,4), %eax
	addl	%eax, %eax
	movl	%eax, 4(%rdx,%r11,4)
	movl	8(%rdi,%r11,4), %eax
	addl	%eax, %eax
	movl	%eax, 8(%rdx,%r11,4)
	movl	12(%rdi,%r11,4), %eax
	addl	%eax, %eax
	movl	%eax, 12(%rdx,%r11,4)
	addq	$4, %r11
	cmpq	%r11, %rsi
	jne	LBB0_17
	jmp	LBB0_2
LBB0_18:                                ##   in Loop: Header=BB0_3 Depth=1
	xorl	%ebx, %ebx
	testb	$1, %r10b
	jne	LBB0_10
	jmp	LBB0_11
LBB0_19:
	leal	-1(%rcx), %r8d
	leal	-2(%r13), %eax
	movslq	%eax, %r9
	leal	-1(%r13), %eax
	movslq	%eax, %r15
	leal	-3(%r13), %eax
	cltq
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	leaq	-1(%r8), %r11
	movl	%r8d, %r10d
	andl	$-2, %r10d
	movq	%r11, %rdi
	andq	$-2, %rdi
	negq	%rdi
	xorl	%r12d, %r12d
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	jmp	LBB0_21
	.p2align	4, 0x90
LBB0_20:                                ##   in Loop: Header=BB0_21 Depth=1
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	movl	(%rdx,%rax,4), %eax
	movl	(%rdx,%r15,4), %esi
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, (%rdx,%r9,4)
	addq	%r14, %rdx
	incl	%r12d
	cmpl	-112(%rbp), %r12d               ## 4-byte Folded Reload
	movq	-192(%rbp), %rcx                ## 8-byte Reload
	movq	-88(%rbp), %r13                 ## 8-byte Reload
	je	LBB0_32
LBB0_21:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_23 Depth 2
                                        ##     Child Loop BB0_29 Depth 2
	cmpl	$2, %ecx
	jl	LBB0_26
## %bb.22:                              ##   in Loop: Header=BB0_21 Depth=1
	xorl	%eax, %eax
	testq	%r11, %r11
	je	LBB0_24
	.p2align	4, 0x90
LBB0_23:                                ##   Parent Loop BB0_21 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdx,%rax,8), %esi
	movl	8(%rdx,%rax,8), %ebx
	addl	%ebx, %esi
	incl	%esi
	sarl	%esi
	subl	%esi, 4(%rdx,%rax,8)
	movl	16(%rdx,%rax,8), %esi
	addl	%ebx, %esi
	incl	%esi
	sarl	%esi
	subl	%esi, 12(%rdx,%rax,8)
	addq	$2, %rax
	cmpq	%rax, %r10
	jne	LBB0_23
LBB0_24:                                ##   in Loop: Header=BB0_21 Depth=1
	testb	$1, %r8b
	je	LBB0_26
## %bb.25:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	(%rdx,%rax,8), %esi
	movl	8(%rdx,%rax,8), %ebx
	addl	%ebx, %esi
	incl	%esi
	sarl	%esi
	subl	%esi, 4(%rdx,%rax,8)
LBB0_26:                                ##   in Loop: Header=BB0_21 Depth=1
	movl	(%rdx,%r9,4), %eax
	subl	%eax, (%rdx,%r15,4)
	movl	4(%rdx), %eax
	addl	%eax, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, (%rdx)
	cmpl	$3, %ecx
	jl	LBB0_20
## %bb.27:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	$1, %r13d
	cmpl	$2, %r8d
	je	LBB0_30
## %bb.28:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	$1, %r13d
	.p2align	4, 0x90
LBB0_29:                                ##   Parent Loop BB0_21 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	-4(%rdx,%r13,8), %eax
	movl	4(%rdx,%r13,8), %esi
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, (%rdx,%r13,8)
	movl	12(%rdx,%r13,8), %eax
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, 8(%rdx,%r13,8)
	leaq	(%rdi,%r13), %rax
	addq	$2, %rax
	addq	$2, %r13
	cmpq	$1, %rax
	jne	LBB0_29
LBB0_30:                                ##   in Loop: Header=BB0_21 Depth=1
	testb	$1, %r11b
	je	LBB0_20
## %bb.31:                              ##   in Loop: Header=BB0_21 Depth=1
	movl	-4(%rdx,%r13,8), %eax
	movl	4(%rdx,%r13,8), %esi
	addl	%esi, %eax
	addl	$2, %eax
	sarl	$2, %eax
	addl	%eax, (%rdx,%r13,8)
	jmp	LBB0_20
LBB0_32:
	movq	-64(%rbp), %r11                 ## 8-byte Reload
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	movq	-48(%rbp), %rax                 ## 8-byte Reload
LBB0_33:
	movq	%rax, -48(%rbp)                 ## 8-byte Spill
	leaq	(%r11,%rax,4), %r14
	testl	%r13d, %r13d
	jle	LBB0_39
## %bb.34:
	cmpl	$8, %r13d
	jae	LBB0_56
## %bb.35:
	xorl	%edi, %edi
LBB0_36:
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
LBB0_37:
	leaq	(%r11,%rdi,4), %rax
	addq	$4, %rax
	movq	%r10, %rdx
	subq	%rdi, %rdx
	.p2align	4, 0x90
LBB0_38:                                ## =>This Inner Loop Header: Depth=1
	movl	-4(%rax), %edi
	movl	-4(%rax,%rbx,8), %esi
	addl	%edi, %esi
	incl	%esi
	sarl	%esi
	subl	%esi, -4(%rax,%rbx,4)
	movl	(%rax), %edi
	movl	(%rax,%rbx,8), %esi
	addl	%edi, %esi
	incl	%esi
	sarl	%esi
	subl	%esi, (%rax,%rbx,4)
	addq	$8, %rax
	addq	$-2, %rdx
	jne	LBB0_38
LBB0_39:
	movq	%r14, -200(%rbp)                ## 8-byte Spill
	leal	(,%rcx,4), %eax
	cltq
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	leaq	(%r11,%rax,4), %r8
	movq	-120(%rbp), %rax                ## 8-byte Reload
	leal	-1(%rax), %ecx
	movl	%ecx, -80(%rbp)                 ## 4-byte Spill
	cmpl	$3, %eax
	jl	LBB0_53
## %bb.40:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rax,%rcx), %rdx
	leaq	(%rdx,%r10), %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%r10), %rax
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%rcx), %rax
	movq	%rax, -136(%rbp)                ## 8-byte Spill
	leaq	(%r10,%rcx,2), %rax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	movl	%r10d, %eax
	andl	$-8, %eax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rax,%rcx,4), %r12
	addq	$16, %r12
	leaq	(,%rcx,4), %r9
	leaq	16(%rax,%rcx,8), %r13
	leaq	(%rax,%rcx,8), %r14
	movq	%rdx, -160(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rdx,4), %rsi
	movl	$1, %r11d
	xorl	%r15d, %r15d
	pcmpeqd	%xmm0, %xmm0
	movq	%r8, %rdi
	jmp	LBB0_42
	.p2align	4, 0x90
LBB0_41:                                ##   in Loop: Header=BB0_42 Depth=1
	addq	%r9, %rdi
	incl	%r11d
	incq	%r15
	addq	%r9, %r12
	addq	%r9, %r13
	addq	%r9, %r14
	addq	%r9, %rsi
	cmpl	-80(%rbp), %r11d                ## 4-byte Folded Reload
	je	LBB0_53
LBB0_42:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_50 Depth 2
                                        ##     Child Loop BB0_46 Depth 2
	cmpl	$0, -88(%rbp)                   ## 4-byte Folded Reload
	jle	LBB0_41
## %bb.43:                              ##   in Loop: Header=BB0_42 Depth=1
	cmpl	$8, -88(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_47
## %bb.44:                              ##   in Loop: Header=BB0_42 Depth=1
	xorl	%eax, %eax
LBB0_45:                                ##   in Loop: Header=BB0_42 Depth=1
	leaq	(%rdi,%rax,4), %rdx
	.p2align	4, 0x90
LBB0_46:                                ##   Parent Loop BB0_42 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rdx), %ebx
	movl	(%r14,%rax,4), %ecx
	addl	%ebx, %ecx
	incl	%ecx
	sarl	%ecx
	subl	%ecx, (%rsi,%rax,4)
	movl	4(%rdx), %ecx
	movl	4(%r14,%rax,4), %ebx
	addl	%ebx, %ecx
	incl	%ecx
	sarl	%ecx
	subl	%ecx, 4(%rsi,%rax,4)
	addq	$2, %rax
	addq	$8, %rdx
	cmpq	%rax, %r10
	jne	LBB0_46
	jmp	LBB0_41
	.p2align	4, 0x90
LBB0_47:                                ##   in Loop: Header=BB0_42 Depth=1
	movq	%r15, %rax
	imulq	-104(%rbp), %rax                ## 8-byte Folded Reload
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %rdx
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %r10
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %rbx
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	addq	%rax, %rcx
	movq	%rcx, -72(%rbp)                 ## 8-byte Spill
	addq	-128(%rbp), %rax                ## 8-byte Folded Reload
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rdx,4), %rdx
	leaq	(%rcx,%r10,4), %r10
	leaq	(%rcx,%rbx,4), %rbx
	leaq	(%rcx,%rax,4), %rax
	cmpq	%rbx, %rdx
	setb	-168(%rbp)                      ## 1-byte Folded Spill
	cmpq	%r10, %rdi
	setb	%bl
	cmpq	%rax, %rdx
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rax
	setb	%dl
	cmpq	%r10, %rax
	setb	%r10b
	testb	%bl, -168(%rbp)                 ## 1-byte Folded Reload
	jne	LBB0_52
## %bb.48:                              ##   in Loop: Header=BB0_42 Depth=1
	movl	$0, %eax
	andb	%r10b, %dl
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	jne	LBB0_45
## %bb.49:                              ##   in Loop: Header=BB0_42 Depth=1
	movq	-96(%rbp), %rax                 ## 8-byte Reload
	movq	%r13, %r10
	movq	%r12, %rdx
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_50:                                ##   Parent Loop BB0_42 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	-16(%rdx), %xmm1
	movdqu	(%rdx), %xmm2
	movdqu	-16(%r10), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	(%r10), %xmm1
	paddd	%xmm2, %xmm1
	psubd	%xmm0, %xmm3
	psubd	%xmm0, %xmm1
	psrad	$1, %xmm3
	psrad	$1, %xmm1
	movdqu	-16(%rdx,%rcx,4), %xmm2
	psubd	%xmm3, %xmm2
	movdqu	(%rdx,%rcx,4), %xmm3
	psubd	%xmm1, %xmm3
	movdqu	%xmm2, -16(%rdx,%rcx,4)
	movdqu	%xmm3, (%rdx,%rcx,4)
	addq	$32, %rdx
	addq	$32, %r10
	addq	$-8, %rax
	jne	LBB0_50
## %bb.51:                              ##   in Loop: Header=BB0_42 Depth=1
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	movq	%rcx, %rax
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	cmpq	%r10, %rcx
	je	LBB0_41
	jmp	LBB0_45
LBB0_52:                                ##   in Loop: Header=BB0_42 Depth=1
	xorl	%eax, %eax
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	jmp	LBB0_45
LBB0_53:
	movq	-88(%rbp), %r15                 ## 8-byte Reload
	testl	%r15d, %r15d
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	jle	LBB0_82
## %bb.54:
	movq	-112(%rbp), %rax                ## 8-byte Reload
	decl	%eax
	imull	%r15d, %eax
	movslq	%eax, %rcx
	cmpl	$8, %r15d
	jb	LBB0_55
## %bb.61:
	leaq	(%rbx,%rcx,4), %r9
	leaq	(%rcx,%r10), %rax
	movq	%rax, %rdx
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
	subq	%rsi, %rdx
	leaq	(%rbx,%rdx,4), %rdx
	cmpq	%rdx, %r9
	jae	LBB0_64
## %bb.62:
	leaq	(%rbx,%rax,4), %rax
	movq	%rcx, %rdx
	subq	%rsi, %rdx
	leaq	(%rbx,%rdx,4), %rdx
	cmpq	%rax, %rdx
	jae	LBB0_64
LBB0_55:
	xorl	%r11d, %r11d
LBB0_70:
	addq	%r11, %rcx
	leaq	(%rbx,%rcx,4), %rax
	subq	-48(%rbp), %rcx                 ## 8-byte Folded Reload
	leaq	(%rbx,%rcx,4), %rcx
	movq	%r10, %rdx
	subq	%r11, %rdx
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_71:                                ## =>This Inner Loop Header: Depth=1
	movl	(%rcx,%rsi,4), %edi
	subl	%edi, (%rax,%rsi,4)
	movl	4(%rcx,%rsi,4), %edi
	subl	%edi, 4(%rax,%rsi,4)
	addq	$2, %rsi
	cmpq	%rsi, %rdx
	jne	LBB0_71
LBB0_72:
	cmpl	$8, %r15d
	jb	LBB0_73
## %bb.74:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	addq	%r10, %rax
	leaq	(%rbx,%rax,4), %rax
	cmpq	%rax, %rbx
	jae	LBB0_77
## %bb.75:
	leaq	(%rbx,%r10,4), %rax
	cmpq	%rax, -200(%rbp)                ## 8-byte Folded Reload
	jae	LBB0_77
LBB0_73:
	xorl	%ecx, %ecx
LBB0_80:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rbx,%rax,4), %rax
	addq	$4, %rax
	.p2align	4, 0x90
LBB0_81:                                ## =>This Inner Loop Header: Depth=1
	movl	-4(%rax,%rcx,4), %edx
	addl	%edx, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, (%rbx,%rcx,4)
	movl	(%rax,%rcx,4), %edx
	addl	%edx, %edx
	addl	$2, %edx
	sarl	$2, %edx
	addl	%edx, 4(%rbx,%rcx,4)
	addq	$2, %rcx
	cmpq	%rcx, %r10
	jne	LBB0_81
LBB0_82:
	cmpl	$3, -120(%rbp)                  ## 4-byte Folded Reload
	jl	LBB0_96
## %bb.83:
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	leaq	(%rdi,%rax), %r9
	movq	-48(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rdi), %rdx
	leaq	(%rdx,%rax), %rbx
	movq	%rbx, -144(%rbp)                ## 8-byte Spill
	movq	%rdi, %rsi
	subq	%rcx, %rsi
	movq	%r9, -160(%rbp)                 ## 8-byte Spill
	subq	%rcx, %r9
	movq	%r9, -128(%rbp)                 ## 8-byte Spill
                                        ## kill: def $eax killed $eax killed $rax def $rax
	andl	$-8, %eax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movq	%rdx, -152(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rdx,4), %r14
	addq	$16, %r14
	leaq	(,%rdi,4), %rcx
	movq	%rcx, -168(%rbp)                ## 8-byte Spill
	leaq	16(%rax,%rsi,4), %rdx
	movq	%rsi, -136(%rbp)                ## 8-byte Spill
	leaq	(%rax,%rsi,4), %r10
	leaq	(%rax,%rdi,4), %r9
	addq	$4, %r9
	movl	$1, %r11d
	xorl	%eax, %eax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	jmp	LBB0_85
	.p2align	4, 0x90
LBB0_84:                                ##   in Loop: Header=BB0_85 Depth=1
	movq	-168(%rbp), %rax                ## 8-byte Reload
	addq	%rax, %r8
	incl	%r11d
	incq	-72(%rbp)                       ## 8-byte Folded Spill
	addq	%rax, %r14
	addq	%rax, %rdx
	addq	%rax, %r10
	addq	%rax, %r9
	cmpl	-80(%rbp), %r11d                ## 4-byte Folded Reload
	movq	-88(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_96
LBB0_85:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_93 Depth 2
                                        ##     Child Loop BB0_89 Depth 2
	testl	%r15d, %r15d
	jle	LBB0_84
## %bb.86:                              ##   in Loop: Header=BB0_85 Depth=1
	cmpl	$8, -88(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_90
LBB0_87:                                ##   in Loop: Header=BB0_85 Depth=1
	xorl	%ebx, %ebx
LBB0_88:                                ##   in Loop: Header=BB0_85 Depth=1
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	addq	%rbx, %rax
	leaq	(%r8,%rax,4), %rax
	leaq	(%r10,%rbx,4), %rsi
	leaq	(%r9,%rbx,4), %rdi
	movq	-56(%rbp), %r12                 ## 8-byte Reload
	subq	%rbx, %r12
	xorl	%r15d, %r15d
	.p2align	4, 0x90
LBB0_89:                                ##   Parent Loop BB0_85 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%rax,%r15,4), %ebx
	movl	(%rsi,%r15,4), %r13d
	addl	%r13d, %ebx
	addl	$2, %ebx
	sarl	$2, %ebx
	addl	%ebx, -4(%rdi,%r15,4)
	movl	4(%rax,%r15,4), %ebx
	movl	4(%rsi,%r15,4), %ecx
	addl	%ebx, %ecx
	addl	$2, %ecx
	sarl	$2, %ecx
	addl	%ecx, (%rdi,%r15,4)
	addq	$2, %r15
	cmpq	%r15, %r12
	jne	LBB0_89
	jmp	LBB0_84
	.p2align	4, 0x90
LBB0_90:                                ##   in Loop: Header=BB0_85 Depth=1
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	imulq	-104(%rbp), %rax                ## 8-byte Folded Reload
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %rsi
	movq	-152(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %rdi
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %rbx
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax), %r15
	addq	-128(%rbp), %rax                ## 8-byte Folded Reload
	movq	-64(%rbp), %rcx                 ## 8-byte Reload
	leaq	(%rcx,%rbx,4), %rbx
	cmpq	%rbx, %r8
	leaq	(%rcx,%rsi,4), %rsi
	leaq	(%rcx,%rdi,4), %rdi
	setb	%r12b
	cmpq	%rsi, %rdi
	leaq	(%rcx,%rax,4), %rax
	setb	%bl
	cmpq	%rax, %r8
	leaq	(%rcx,%r15,4), %rdi
	setb	%al
	cmpq	%rsi, %rdi
	setb	%sil
	testb	%bl, %r12b
	jne	LBB0_87
## %bb.91:                              ##   in Loop: Header=BB0_85 Depth=1
	movl	$0, %ebx
	andb	%sil, %al
	jne	LBB0_88
## %bb.92:                              ##   in Loop: Header=BB0_85 Depth=1
	xorl	%eax, %eax
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_93:                                ##   Parent Loop BB0_85 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	-16(%r14,%rax,4), %xmm1
	movdqu	(%r14,%rax,4), %xmm2
	movdqu	-16(%rdx,%rax,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	(%rdx,%rax,4), %xmm1
	paddd	%xmm2, %xmm1
	paddd	%xmm0, %xmm3
	paddd	%xmm0, %xmm1
	psrad	$2, %xmm3
	psrad	$2, %xmm1
	movdqu	(%r8,%rax,4), %xmm2
	paddd	%xmm3, %xmm2
	movdqu	16(%r8,%rax,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	%xmm2, (%r8,%rax,4)
	movdqu	%xmm3, 16(%r8,%rax,4)
	addq	$8, %rax
	cmpq	%rax, %rcx
	jne	LBB0_93
## %bb.94:                              ##   in Loop: Header=BB0_85 Depth=1
	movq	%rcx, %rbx
	cmpq	-56(%rbp), %rcx                 ## 8-byte Folded Reload
	je	LBB0_84
	jmp	LBB0_88
LBB0_96:
	testl	%r15d, %r15d
	movq	-192(%rbp), %rdx                ## 8-byte Reload
	movq	-64(%rbp), %r8                  ## 8-byte Reload
	jle	LBB0_102
## %bb.97:
	movq	-112(%rbp), %rax                ## 8-byte Reload
	addl	$-2, %eax
	imull	%r15d, %eax
	movslq	%eax, %rcx
	cmpl	$8, %r15d
	jae	LBB0_103
## %bb.98:
	xorl	%r9d, %r9d
LBB0_99:
	movq	-56(%rbp), %r14                 ## 8-byte Reload
LBB0_100:
	leaq	(%r9,%rcx), %rsi
	leaq	(%r8,%rsi,4), %r10
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	subq	%rax, %rsi
	leaq	(%r8,%rsi,4), %rsi
	addq	%r9, %rax
	addq	%rcx, %rax
	leaq	(%r8,%rax,4), %rcx
	subq	%r9, %r14
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_101:                               ## =>This Inner Loop Header: Depth=1
	movl	(%rsi,%rax,4), %edi
	movl	(%rcx,%rax,4), %ebx
	addl	%ebx, %edi
	addl	$2, %edi
	sarl	$2, %edi
	addl	%edi, (%r10,%rax,4)
	movl	4(%rsi,%rax,4), %edi
	movl	4(%rcx,%rax,4), %ebx
	addl	%ebx, %edi
	addl	$2, %edi
	sarl	$2, %edi
	addl	%edi, 4(%r10,%rax,4)
	addq	$2, %rax
	cmpq	%rax, %r14
	jne	LBB0_101
LBB0_102:
	movq	-184(%rbp), %rdi                ## 8-byte Reload
	movl	-172(%rbp), %esi                ## 4-byte Reload
                                        ## kill: def $edx killed $edx killed $rdx
	movq	-120(%rbp), %rcx                ## 8-byte Reload
                                        ## kill: def $ecx killed $ecx killed $rcx
	addq	$32, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_deinterleave                   ## TAILCALL
LBB0_56:
	movq	-48(%rbp), %rdx                 ## 8-byte Reload
	leaq	(%rdx,%r10), %rax
	leaq	(%r11,%rax,4), %rdi
	leaq	(%r11,%r10,4), %rax
	leaq	(%r11,%rdx,8), %r8
	leaq	(%r10,%rdx,2), %rsi
	leaq	(%r11,%rsi,4), %rsi
	cmpq	%rax, %r14
	setb	%r9b
	cmpq	%rdi, %r11
	setb	%dl
	cmpq	%rsi, %r14
	setb	%al
	cmpq	%rdi, %r8
	setb	%sil
	xorl	%edi, %edi
	testb	%dl, %r9b
	jne	LBB0_36
## %bb.57:
	andb	%sil, %al
	movq	-48(%rbp), %rbx                 ## 8-byte Reload
	jne	LBB0_37
## %bb.58:
	movl	%r10d, %edi
	andl	$-8, %edi
	leaq	16(%r11), %rax
	pcmpeqd	%xmm0, %xmm0
	movq	%rdi, %rdx
	.p2align	4, 0x90
LBB0_59:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rax), %xmm1
	movdqu	(%rax), %xmm2
	movdqu	-16(%rax,%rbx,8), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	(%rax,%rbx,8), %xmm1
	paddd	%xmm2, %xmm1
	psubd	%xmm0, %xmm3
	psubd	%xmm0, %xmm1
	psrad	$1, %xmm3
	psrad	$1, %xmm1
	movdqu	-16(%rax,%rbx,4), %xmm2
	psubd	%xmm3, %xmm2
	movdqu	(%rax,%rbx,4), %xmm3
	psubd	%xmm1, %xmm3
	movdqu	%xmm2, -16(%rax,%rbx,4)
	movdqu	%xmm3, (%rax,%rbx,4)
	addq	$32, %rax
	addq	$-8, %rdx
	jne	LBB0_59
## %bb.60:
	cmpq	%r10, %rdi
	jne	LBB0_37
	jmp	LBB0_39
LBB0_103:
	leaq	(%r8,%rcx,4), %r15
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rcx,%rax), %rbx
	leaq	(%r8,%rbx,4), %r12
	movq	%rcx, %rsi
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
	subq	%rdi, %rsi
	leaq	(%r8,%rsi,4), %r14
	subq	%rdi, %rbx
	leaq	(%r8,%rbx,4), %rsi
	leaq	(%rdi,%rcx), %r11
	leaq	(%r8,%r11,4), %r9
	leaq	(%r11,%rax), %rbx
	leaq	(%r8,%rbx,4), %rbx
	cmpq	%rsi, %r15
	setb	%r10b
	cmpq	%r12, %r14
	setb	%sil
	cmpq	%rbx, %r15
	setb	%al
	cmpq	%r12, %r9
	setb	%bl
	xorl	%r9d, %r9d
	testb	%sil, %r10b
	jne	LBB0_99
## %bb.104:
	andb	%bl, %al
	movq	-56(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_100
## %bb.105:
	movl	%r14d, %r9d
	andl	$-8, %r9d
	leaq	4(%rcx), %rax
	subq	-48(%rbp), %rax                 ## 8-byte Folded Reload
	leaq	(%r8,%rax,4), %rax
	leaq	(%r8,%r11,4), %rsi
	addq	$16, %rsi
	leaq	(%r8,%rcx,4), %rdi
	addq	$16, %rdi
	xorl	%ebx, %ebx
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	.p2align	4, 0x90
LBB0_106:                               ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rax,%rbx,4), %xmm1
	movdqu	(%rax,%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, %r9
	jne	LBB0_106
## %bb.107:
	cmpq	%r14, %r9
	jne	LBB0_100
	jmp	LBB0_102
LBB0_64:
	movl	%r10d, %r11d
	andl	$-8, %r11d
	leaq	-8(%r11), %rax
	movq	%rax, %r10
	shrq	$3, %r10
	incq	%r10
	testq	%rax, %rax
	je	LBB0_110
## %bb.65:
	movq	%r10, %rdi
	andq	$-2, %rdi
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	negq	%rax
	addq	%rcx, %rax
	addq	$12, %rax
	leaq	(%rbx,%rax,4), %rax
	leaq	(%rbx,%rcx,4), %rdx
	addq	$48, %rdx
	xorl	%esi, %esi
	.p2align	4, 0x90
LBB0_66:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-48(%rax,%rsi,4), %xmm0
	movdqu	-32(%rax,%rsi,4), %xmm1
	movdqu	-48(%rdx,%rsi,4), %xmm2
	psubd	%xmm0, %xmm2
	movdqu	-32(%rdx,%rsi,4), %xmm0
	psubd	%xmm1, %xmm0
	movdqu	-16(%rdx,%rsi,4), %xmm1
	movdqu	(%rdx,%rsi,4), %xmm3
	movdqu	%xmm2, -48(%rdx,%rsi,4)
	movdqu	%xmm0, -32(%rdx,%rsi,4)
	movdqu	-16(%rax,%rsi,4), %xmm0
	psubd	%xmm0, %xmm1
	movdqu	(%rax,%rsi,4), %xmm0
	psubd	%xmm0, %xmm3
	movdqu	%xmm1, -16(%rdx,%rsi,4)
	movdqu	%xmm3, (%rdx,%rsi,4)
	addq	$16, %rsi
	addq	$-2, %rdi
	jne	LBB0_66
## %bb.67:
	testb	$1, %r10b
	je	LBB0_69
LBB0_68:
	movq	%rsi, %rax
	subq	-48(%rbp), %rax                 ## 8-byte Folded Reload
	movdqu	(%r9,%rax,4), %xmm0
	movdqu	16(%r9,%rax,4), %xmm1
	movdqu	(%r9,%rsi,4), %xmm2
	psubd	%xmm0, %xmm2
	movdqu	16(%r9,%rsi,4), %xmm0
	psubd	%xmm1, %xmm0
	movdqu	%xmm2, (%r9,%rsi,4)
	movdqu	%xmm0, 16(%r9,%rsi,4)
LBB0_69:
	movq	-56(%rbp), %r10                 ## 8-byte Reload
	cmpq	%r10, %r11
	je	LBB0_72
	jmp	LBB0_70
LBB0_77:
	movl	%r10d, %ecx
	andl	$-8, %ecx
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	leaq	(%rbx,%rax,4), %rax
	addq	$16, %rax
	xorl	%edx, %edx
	movdqa	LCPI0_0(%rip), %xmm0            ## xmm0 = [2,2,2,2]
	.p2align	4, 0x90
LBB0_78:                                ## =>This Inner Loop Header: Depth=1
	movdqu	-16(%rax,%rdx,4), %xmm1
	movdqu	(%rax,%rdx,4), %xmm2
	paddd	%xmm1, %xmm1
	paddd	%xmm2, %xmm2
	paddd	%xmm0, %xmm1
	paddd	%xmm0, %xmm2
	psrad	$2, %xmm1
	psrad	$2, %xmm2
	movdqu	(%rbx,%rdx,4), %xmm3
	paddd	%xmm1, %xmm3
	movdqu	16(%rbx,%rdx,4), %xmm1
	paddd	%xmm2, %xmm1
	movdqu	%xmm3, (%rbx,%rdx,4)
	movdqu	%xmm1, 16(%rbx,%rdx,4)
	addq	$8, %rdx
	cmpq	%rdx, %rcx
	jne	LBB0_78
## %bb.79:
	cmpq	%r10, %rcx
	je	LBB0_82
	jmp	LBB0_80
LBB0_110:
	xorl	%esi, %esi
	testb	$1, %r10b
	jne	LBB0_68
	jmp	LBB0_69
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_vc2_subband_dwt_53
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function vc2_subband_dwt_53
_vc2_subband_dwt_53:                    ; @vc2_subband_dwt_53
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #128
	.cfi_def_cfa_offset 128
	stp	x28, x27, [sp, #32]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #112]            ; 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
	mov	x8, x4
                                        ; kill: def $w2 killed $w2 def $x2
	ldr	x4, [x0]
	lsl	w9, w3, #1
	str	w8, [sp, #28]                   ; 4-byte Folded Spill
	lsl	w11, w8, #1
	cmp	w11, #1
	stp	x1, x2, [sp, #8]                ; 16-byte Folded Spill
	b.lt	LBB0_28
; %bb.1:
	mov	x12, #0
	mov	x13, x9
	sxtw	x10, w13
	sbfiz	x13, x13, #2, #32
	sbfiz	x14, x2, #2, #32
	and	x15, x9, #0xfffffff0
	mov	x16, x1
	mov	x17, x4
	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	x5, x14, x12, x1
	madd	x6, x13, x12, x4
	sub	x5, x6, x5
	cmp	x5, #64
	b.lo	LBB0_9
; %bb.6:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	x0, #0
	mov	x5, x15
LBB0_7:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x6, x16, x0
	ldp	q0, q1, [x6]
	ldp	q2, q3, [x6, #32]
	shl.4s	v0, v0, #1
	shl.4s	v1, v1, #1
	shl.4s	v2, v2, #1
	shl.4s	v3, v3, #1
	add	x6, x17, x0
	stp	q0, q1, [x6]
	stp	q2, q3, [x6, #32]
	add	x0, x0, #64
	subs	x5, x5, #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	x5, x0, #2
	ldr	w6, [x16, x5]
	lsl	w6, w6, #1
	str	w6, [x17, x5]
	add	x0, x0, #1
	cmp	x9, x0
	b.ne	LBB0_9
	b	LBB0_2
LBB0_10:
	mov	w12, #0
	sub	w13, w3, #1
	mov	x14, x9
	sxtw	x16, w14
	sub	x14, x16, #2
	sub	x15, x16, #1
	sub	x16, x16, #3
	sub	x17, x13, #1
	and	x0, x13, #0xfffffffc
	and	x5, x17, #0xfffffffffffffffc
	orr	x6, x5, #0x1
	add	x7, x4, #16
	lsl	x19, x10, #2
	add	x20, x4, #20
	mov	x21, x4
	b	LBB0_12
LBB0_11:                                ;   in Loop: Header=BB0_12 Depth=1
	ldr	w8, [x21, x16, lsl #2]
	ldr	w1, [x21, x15, lsl #2]
	add	w8, w8, w1
	add	w8, w8, #2
	lsl	x1, x14, #2
	ldr	w2, [x21, x1]
	add	w8, w2, w8, asr #2
	str	w8, [x21, x1]
	add	x21, x21, x19
	add	w12, w12, #1
	add	x7, x7, x19
	add	x20, x20, x19
	cmp	w12, w11
	b.eq	LBB0_29
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
	cmp	w3, #2
	b.lt	LBB0_20
; %bb.13:                               ;   in Loop: Header=BB0_12 Depth=1
	cmp	w13, #4
	b.hs	LBB0_15
; %bb.14:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	x23, #0
	b	LBB0_18
LBB0_15:                                ;   in Loop: Header=BB0_12 Depth=1
	mov	x22, x7
	mov	x23, x0
LBB0_16:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	w1, w24, [x22, #12]
	ldp	w25, w26, [x22, #-16]
	ldp	w27, w28, [x22, #-8]
	add	w25, w25, w27
	ldp	w30, w2, [x22]
	add	w27, w27, w30
	ldr	w8, [x22, #8]
	add	w30, w30, w8
	add	w8, w8, w24
	add	w24, w25, #1
	add	w25, w27, #1
	add	w27, w30, #1
	sub	w24, w26, w24, asr #1
	add	w8, w8, #1
	sub	w25, w28, w25, asr #1
	sub	w2, w2, w27, asr #1
	sub	w8, w1, w8, asr #1
	stur	w24, [x22, #-12]
	stur	w25, [x22, #-4]
	str	w2, [x22, #4]
	str	w8, [x22, #12]
	add	x22, x22, #32
	subs	x23, x23, #4
	b.ne	LBB0_16
; %bb.17:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	x23, x0
	cmp	x0, x13
	b.eq	LBB0_20
LBB0_18:                                ;   in Loop: Header=BB0_12 Depth=1
	lsl	x22, x23, #3
	sub	x23, x13, x23
LBB0_19:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x8, x21, x22
	ldp	w24, w1, [x8, #4]
	ldr	w2, [x8]
	add	w1, w2, w1
	add	w1, w1, #1
	sub	w1, w24, w1, asr #1
	str	w1, [x8, #4]
	add	x22, x22, #8
	subs	x23, x23, #1
	b.ne	LBB0_19
LBB0_20:                                ;   in Loop: Header=BB0_12 Depth=1
	ldr	w8, [x21, x14, lsl #2]
	lsl	x1, x15, #2
	ldr	w2, [x21, x1]
	sub	w8, w2, w8
	str	w8, [x21, x1]
	ldp	w1, w8, [x21]
	lsl	w8, w8, #1
	add	w8, w8, #2
	add	w8, w1, w8, asr #2
	str	w8, [x21]
	cmp	w3, #2
	b.le	LBB0_11
; %bb.21:                               ;   in Loop: Header=BB0_12 Depth=1
	cmp	x17, #4
	b.hs	LBB0_23
; %bb.22:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	w23, #1
	b	LBB0_26
LBB0_23:                                ;   in Loop: Header=BB0_12 Depth=1
	mov	x22, x20
	mov	x23, x5
LBB0_24:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	w30, w8, [x22, #12]
	ldp	w1, w2, [x22, #-16]
	ldp	w24, w25, [x22, #-8]
	add	w1, w1, w24
	ldp	w26, w27, [x22]
	add	w24, w24, w26
	ldr	w28, [x22, #8]
	add	w26, w26, w28
	add	w8, w28, w8
	add	w1, w1, #2
	add	w24, w24, #2
	add	w26, w26, #2
	add	w1, w2, w1, asr #2
	add	w8, w8, #2
	add	w2, w25, w24, asr #2
	add	w24, w27, w26, asr #2
	add	w8, w30, w8, asr #2
	stur	w1, [x22, #-12]
	stur	w2, [x22, #-4]
	str	w24, [x22, #4]
	str	w8, [x22, #12]
	add	x22, x22, #32
	subs	x23, x23, #4
	b.ne	LBB0_24
; %bb.25:                               ;   in Loop: Header=BB0_12 Depth=1
	mov	x23, x6
	cmp	x17, x5
	b.eq	LBB0_11
LBB0_26:                                ;   in Loop: Header=BB0_12 Depth=1
	lsl	x22, x23, #3
	sub	x23, x13, x23
LBB0_27:                                ;   Parent Loop BB0_12 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x8, x21, x22
	ldp	w1, w24, [x8, #-4]
	ldr	w2, [x8, #4]
	add	w1, w1, w2
	add	w1, w1, #2
	add	w1, w24, w1, asr #2
	str	w1, [x8]
	add	x22, x22, #8
	subs	x23, x23, #1
	b.ne	LBB0_27
	b	LBB0_11
LBB0_28:
	mov	x10, x9
	sxtw	x10, w10
LBB0_29:
	add	x15, x4, x10, lsl #2
	cmp	w9, #1
	b.lt	LBB0_39
; %bb.30:
	lsl	x12, x10, #3
	cmp	w9, #16
	b.hs	LBB0_32
; %bb.31:
	mov	x13, #0
	b	LBB0_37
LBB0_32:
	mov	x13, #0
	add	x8, x10, x9
	add	x8, x4, x8, lsl #2
	add	x16, x4, x9, lsl #2
	add	x14, x4, x10, lsl #3
	add	x17, x9, x10, lsl #1
	add	x17, x4, x17, lsl #2
	cmp	x15, x17
	ccmp	x14, x8, #2, lo
	cset	w14, lo
	cmp	x4, x8
	ccmp	x15, x16, #2, lo
	b.lo	LBB0_37
; %bb.33:
	tbnz	w14, #0, LBB0_37
; %bb.34:
	and	x13, x9, #0xfffffff0
	lsl	x14, x10, #2
	add	x16, x4, #32
	mov	x17, x13
LBB0_35:                                ; =>This Inner Loop Header: Depth=1
	ldp	q0, q1, [x16, #-32]
	ldp	q2, q3, [x16]
	add	x8, x16, x12
	ldp	q4, q5, [x8, #-32]
	ldp	q6, q7, [x8]
	mvn.16b	v0, v0
	sub.4s	v0, v4, v0
	mvn.16b	v1, v1
	sub.4s	v1, v5, v1
	mvn.16b	v2, v2
	sub.4s	v2, v6, v2
	mvn.16b	v3, v3
	sub.4s	v3, v7, v3
	sshr.4s	v0, v0, #1
	sshr.4s	v1, v1, #1
	sshr.4s	v2, v2, #1
	sshr.4s	v3, v3, #1
	add	x8, x16, x14
	ldp	q4, q5, [x8, #-32]
	ldp	q6, q7, [x8]
	sub.4s	v0, v4, v0
	sub.4s	v1, v5, v1
	sub.4s	v2, v6, v2
	sub.4s	v3, v7, v3
	stp	q0, q1, [x8, #-32]
	stp	q2, q3, [x8]
	add	x16, x16, #64
	subs	x17, x17, #16
	b.ne	LBB0_35
; %bb.36:
	cmp	x13, x9
	b.eq	LBB0_39
LBB0_37:
	sub	x14, x9, x13
	lsl	x16, x10, #2
	add	x13, x4, x13, lsl #2
LBB0_38:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [x13]
	ldr	w17, [x13, x12]
	add	w8, w8, w17
	ldr	w17, [x13, x16]
	add	w8, w8, #1
	sub	w8, w17, w8, asr #1
	str	w8, [x13, x16]
	add	x13, x13, #4
	subs	x14, x14, #1
	b.ne	LBB0_38
LBB0_39:
	lsl	w8, w3, #2
	sxtw	x12, w8
	add	x13, x4, w8, sxtw #2
	ldr	w8, [sp, #28]                   ; 4-byte Folded Reload
	sub	w14, w8, #1
	cmp	w8, #3
	b.lt	LBB0_51
; %bb.40:
	mov	x16, #0
	add	x17, x10, x12
	add	x0, x17, x9
	lsl	x5, x12, #1
	lsl	x6, x12, #2
	add	x7, x12, x9
	add	x19, x5, x9
	and	x20, x9, #0xfffffff0
	mov	w21, #1
	mov	x22, x13
	add	x23, x4, x12, lsl #3
	add	x24, x4, x17, lsl #2
	b	LBB0_42
LBB0_41:                                ;   in Loop: Header=BB0_42 Depth=1
	add	x22, x22, x6
	add	w21, w21, #1
	add	x16, x16, #1
	add	x24, x24, x6
	add	x23, x23, x6
	cmp	w21, w14
	b.eq	LBB0_51
LBB0_42:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_48 Depth 2
                                        ;     Child Loop BB0_50 Depth 2
	cmp	w9, #1
	b.lt	LBB0_41
; %bb.43:                               ;   in Loop: Header=BB0_42 Depth=1
	cmp	w9, #16
	b.hs	LBB0_45
; %bb.44:                               ;   in Loop: Header=BB0_42 Depth=1
	mov	x25, #0
	b	LBB0_50
LBB0_45:                                ;   in Loop: Header=BB0_42 Depth=1
	mov	x25, #0
	mul	x8, x16, x12
	add	x1, x17, x8
	add	x1, x4, x1, lsl #2
	add	x2, x0, x8
	add	x2, x4, x2, lsl #2
	add	x26, x19, x8
	add	x26, x4, x26, lsl #2
	cmp	x1, x26
	add	x26, x7, x8
	add	x27, x4, x26, lsl #2
	add	x8, x5, x8
	add	x8, x4, x8, lsl #2
	ccmp	x8, x2, #2, lo
	cset	w26, lo
	cmp	x22, x2
	ccmp	x1, x27, #2, lo
	b.lo	LBB0_50
; %bb.46:                               ;   in Loop: Header=BB0_42 Depth=1
	tbnz	w26, #0, LBB0_50
; %bb.47:                               ;   in Loop: Header=BB0_42 Depth=1
	mov	x25, #0
	mov	x26, x20
LBB0_48:                                ;   Parent Loop BB0_42 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x8, x22, x25
	ldp	q0, q1, [x8]
	ldp	q2, q3, [x8, #32]
	add	x8, x23, x25
	ldp	q4, q5, [x8]
	ldp	q6, q7, [x8, #32]
	mvn.16b	v0, v0
	sub.4s	v0, v4, v0
	mvn.16b	v1, v1
	sub.4s	v1, v5, v1
	mvn.16b	v2, v2
	sub.4s	v2, v6, v2
	mvn.16b	v3, v3
	sub.4s	v3, v7, v3
	sshr.4s	v0, v0, #1
	sshr.4s	v1, v1, #1
	sshr.4s	v2, v2, #1
	sshr.4s	v3, v3, #1
	add	x8, x24, x25
	ldp	q4, q5, [x8]
	ldp	q6, q7, [x8, #32]
	sub.4s	v0, v4, v0
	sub.4s	v1, v5, v1
	sub.4s	v2, v6, v2
	sub.4s	v3, v7, v3
	stp	q0, q1, [x8]
	stp	q2, q3, [x8, #32]
	add	x25, x25, #64
	subs	x26, x26, #16
	b.ne	LBB0_48
; %bb.49:                               ;   in Loop: Header=BB0_42 Depth=1
	mov	x25, x20
	cmp	x20, x9
	b.eq	LBB0_41
LBB0_50:                                ;   Parent Loop BB0_42 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x8, x25, #2
	ldr	w1, [x22, x8]
	ldr	w2, [x23, x8]
	add	w1, w1, w2
	ldr	w2, [x24, x8]
	add	w1, w1, #1
	sub	w1, w2, w1, asr #1
	str	w1, [x24, x8]
	add	x25, x25, #1
	cmp	x9, x25
	b.ne	LBB0_50
	b	LBB0_41
LBB0_51:
	sxtw	x11, w11
	mov	x8, x9
	sxtw	x16, w8
	cmp	w9, #1
	b.lt	LBB0_64
; %bb.52:
	sub	x8, x11, #1
	mul	x17, x8, x16
	cmp	w9, #16
	b.lo	LBB0_55
; %bb.53:
	add	x8, x4, x17, lsl #2
	add	x0, x17, x9
	sub	x1, x0, x10
	add	x1, x4, x1, lsl #2
	cmp	x8, x1
	b.hs	LBB0_87
; %bb.54:
	add	x8, x4, x0, lsl #2
	sub	x0, x17, x10
	add	x0, x4, x0, lsl #2
	cmp	x0, x8
	b.hs	LBB0_87
LBB0_55:
	mov	x0, #0
LBB0_56:
	neg	x5, x10, lsl #2
	add	x8, x0, x17
	add	x17, x4, x8, lsl #2
	sub	x0, x9, x0
LBB0_57:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [x17, x5]
	ldr	w1, [x17]
	sub	w8, w1, w8
	str	w8, [x17], #4
	subs	x0, x0, #1
	b.ne	LBB0_57
LBB0_58:
	cmp	w9, #16
	b.lo	LBB0_61
; %bb.59:
	add	x8, x10, x9
	add	x8, x4, x8, lsl #2
	cmp	x4, x8
	b.hs	LBB0_90
; %bb.60:
	add	x8, x4, x9, lsl #2
	cmp	x15, x8
	b.hs	LBB0_90
LBB0_61:
	mov	x15, #0
LBB0_62:
	add	x8, x15, x10
	add	x17, x4, x8, lsl #2
	add	x0, x4, x15, lsl #2
	sub	x15, x9, x15
LBB0_63:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [x17], #4
	lsl	w8, w8, #1
	add	w8, w8, #2
	ldr	w1, [x0]
	add	w8, w1, w8, asr #2
	str	w8, [x0], #4
	subs	x15, x15, #1
	b.ne	LBB0_63
LBB0_64:
	ldr	w8, [sp, #28]                   ; 4-byte Folded Reload
	cmp	w8, #3
	b.lt	LBB0_76
; %bb.65:
	mov	x15, #0
	add	x17, x10, x12
	add	x0, x17, x9
	sub	x5, x12, x10
	lsl	x6, x12, #2
	lsl	x8, x10, #2
	movi.4s	v0, #2
	add	x7, x12, x9
	sub	x19, x7, x10
	and	x20, x9, #0xfffffff0
	add	x21, x8, #32
	neg	x22, x8
	mov	w23, #1
	add	x24, x4, x5, lsl #2
	add	x25, x4, x17, lsl #2
	b	LBB0_67
LBB0_66:                                ;   in Loop: Header=BB0_67 Depth=1
	add	x13, x13, x6
	add	w23, w23, #1
	add	x15, x15, #1
	add	x24, x24, x6
	add	x25, x25, x6
	cmp	w23, w14
	b.eq	LBB0_76
LBB0_67:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_73 Depth 2
                                        ;     Child Loop BB0_75 Depth 2
	cmp	w9, #1
	b.lt	LBB0_66
; %bb.68:                               ;   in Loop: Header=BB0_67 Depth=1
	cmp	w9, #16
	b.hs	LBB0_70
; %bb.69:                               ;   in Loop: Header=BB0_67 Depth=1
	mov	x26, #0
	b	LBB0_75
LBB0_70:                                ;   in Loop: Header=BB0_67 Depth=1
	mov	x26, #0
	mul	x8, x15, x12
	add	x1, x7, x8
	add	x1, x4, x1, lsl #2
	add	x2, x17, x8
	add	x2, x4, x2, lsl #2
	add	x27, x19, x8
	add	x27, x4, x27, lsl #2
	cmp	x13, x27
	add	x27, x0, x8
	add	x28, x4, x27, lsl #2
	add	x8, x5, x8
	add	x8, x4, x8, lsl #2
	ccmp	x8, x1, #2, lo
	cset	w27, lo
	cmp	x2, x1
	ccmp	x13, x28, #2, lo
	b.lo	LBB0_75
; %bb.71:                               ;   in Loop: Header=BB0_67 Depth=1
	tbnz	w27, #0, LBB0_75
; %bb.72:                               ;   in Loop: Header=BB0_67 Depth=1
	mov	x26, x13
	mov	x27, x20
LBB0_73:                                ;   Parent Loop BB0_67 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	x8, x26, x21
	ldp	q1, q2, [x8, #-32]
	ldp	q3, q4, [x8]
	add	x8, x26, x22
	ldp	q5, q6, [x8]
	ldp	q7, q16, [x8, #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, [x26]
	ldp	q7, q16, [x26, #32]
	ssra.4s	v5, v1, #2
	ssra.4s	v6, v2, #2
	ssra.4s	v7, v3, #2
	ssra.4s	v16, v4, #2
	stp	q5, q6, [x26]
	stp	q7, q16, [x26, #32]
	add	x26, x26, #64
	subs	x27, x27, #16
	b.ne	LBB0_73
; %bb.74:                               ;   in Loop: Header=BB0_67 Depth=1
	mov	x26, x20
	cmp	x20, x9
	b.eq	LBB0_66
LBB0_75:                                ;   Parent Loop BB0_67 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	lsl	x8, x26, #2
	ldr	w1, [x25, x8]
	ldr	w2, [x24, x8]
	add	w1, w1, w2
	ldr	w2, [x13, x8]
	add	w1, w1, #2
	add	w1, w2, w1, asr #2
	str	w1, [x13, x8]
	add	x26, x26, #1
	cmp	x9, x26
	b.ne	LBB0_75
	b	LBB0_66
LBB0_76:
	cmp	w9, #1
	ldr	x0, [sp, #8]                    ; 8-byte Folded Reload
	b.lt	LBB0_86
; %bb.77:
	sub	x8, x11, #2
	mul	x11, x8, x16
	cmp	w9, #16
	b.hs	LBB0_79
; %bb.78:
	mov	x12, #0
	b	LBB0_84
LBB0_79:
	mov	x12, #0
	add	x13, x4, x11, lsl #2
	add	x8, x11, x9
	sub	x14, x8, x10
	add	x8, x4, x8, lsl #2
	add	x15, x10, x11
	add	x16, x15, x9
	add	x16, x4, x16, lsl #2
	cmp	x13, x16
	sub	x16, x11, x10
	add	x16, x4, x16, lsl #2
	add	x17, x4, x14, lsl #2
	add	x14, x4, x15, lsl #2
	ccmp	x14, x8, #2, lo
	cset	w14, lo
	cmp	x16, x8
	ccmp	x13, x17, #2, lo
	b.lo	LBB0_84
; %bb.80:
	tbnz	w14, #0, LBB0_84
; %bb.81:
	and	x12, x9, #0xfffffff0
	lsl	x14, x10, #2
	mov	w8, #32
	sub	x15, x8, x14
	movi.4s	v0, #2
	mov	x16, x12
LBB0_82:                                ; =>This Inner Loop Header: Depth=1
	add	x8, x13, x15
	ldp	q1, q2, [x8, #-32]
	ldp	q3, q4, [x8]
	add	x8, x13, x14
	ldp	q5, q6, [x8]
	ldp	q7, q16, [x8, #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_82
; %bb.83:
	cmp	x12, x9
	b.eq	LBB0_86
LBB0_84:
	add	x8, x12, x10
	add	x8, x8, x11
	add	x13, x4, x8, lsl #2
	neg	x10, x10, lsl #2
	add	x8, x12, x11
	sub	x9, x9, x12
	add	x11, x4, x8, lsl #2
LBB0_85:                                ; =>This Inner Loop Header: Depth=1
	ldr	w8, [x11, x10]
	ldr	w12, [x13], #4
	add	w8, w8, w12
	add	w8, w8, #2
	ldr	w12, [x11]
	add	w8, w12, w8, asr #2
	str	w8, [x11], #4
	subs	x9, x9, #1
	b.ne	LBB0_85
LBB0_86:
	ldr	x1, [sp, #16]                   ; 8-byte Folded Reload
                                        ; kill: def $w1 killed $w1 killed $x1
	mov	x2, x3
	ldr	w3, [sp, #28]                   ; 4-byte Folded Reload
	ldp	x29, x30, [sp, #112]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #96]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             ; 16-byte Folded Reload
	add	sp, sp, #128
	b	_deinterleave
LBB0_87:
	and	x0, x9, #0xfffffff0
	add	x8, x4, x17, lsl #2
	add	x5, x8, #32
	neg	x6, x10, lsl #2
	mov	x7, x0
LBB0_88:                                ; =>This Inner Loop Header: Depth=1
	add	x8, x5, x6
	ldp	q0, q1, [x8, #-32]
	ldp	q2, q3, [x8]
	ldp	q4, q5, [x5, #-32]
	ldp	q6, q7, [x5]
	sub.4s	v0, v4, v0
	sub.4s	v1, v5, v1
	sub.4s	v2, v6, v2
	sub.4s	v3, v7, v3
	stp	q0, q1, [x5, #-32]
	stp	q2, q3, [x5], #64
	subs	x7, x7, #16
	b.ne	LBB0_88
; %bb.89:
	cmp	x0, x9
	b.eq	LBB0_58
	b	LBB0_56
LBB0_90:
	and	x15, x9, #0xfffffff0
	add	x17, x4, #32
	lsl	x0, x10, #2
	movi.4s	v0, #2
	mov	x5, x15
LBB0_91:                                ; =>This Inner Loop Header: Depth=1
	add	x8, x17, x0
	ldp	q1, q2, [x8, #-32]
	ldp	q3, q4, [x8]
	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	x5, x5, #16
	b.ne	LBB0_91
; %bb.92:
	cmp	x15, x9
	b.eq	LBB0_64
	b	LBB0_62
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_vc2_subband_dwt_53
.subsections_via_symbols
