	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	__mesa_upscale_teximage2d       ## -- Begin function _mesa_upscale_teximage2d
	.p2align	4, 0x90
__mesa_upscale_teximage2d:              ## @_mesa_upscale_teximage2d
	.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	$200, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r9, %rbx
	movl	%r8d, %r15d
	movl	%ecx, %r14d
	movl	%esi, %r12d
	movl	%edi, %eax
	movq	24(%rbp), %r13
	movabsq	$4611686018427387902, %rcx      ## imm = 0x3FFFFFFFFFFFFFFE
	movq	%rcx, -208(%rbp)                ## 8-byte Spill
	xorl	%edi, %edi
	movl	%edx, -48(%rbp)                 ## 4-byte Spill
	movl	%eax, -44(%rbp)                 ## 4-byte Spill
	cmpl	%eax, %edx
	setae	%dil
	callq	_assert
	xorl	%edi, %edi
	movl	%r14d, -164(%rbp)               ## 4-byte Spill
	cmpl	%r12d, %r14d
	movl	16(%rbp), %r14d
	setae	%dil
	callq	_assert
	movl	%r15d, %r8d
	movl	%r14d, %eax
	movq	%rax, -216(%rbp)                ## 8-byte Spill
	movl	%r12d, -64(%rbp)                ## 4-byte Spill
	testl	%r12d, %r12d
	movl	%r15d, -56(%rbp)                ## 4-byte Spill
	je	LBB0_57
## %bb.1:
	leaq	-1(%r8), %rax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movl	%r15d, %ecx
	imull	-44(%rbp), %ecx                 ## 4-byte Folded Reload
	movl	%r15d, %edx
	imull	-48(%rbp), %edx                 ## 4-byte Folded Reload
	movl	%r8d, %eax
	andl	$-8, %eax
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	addq	$-8, %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	movq	%rax, %rsi
	shrq	$3, %rsi
	incq	%rsi
	movq	%rsi, %rax
	movq	%rsi, -144(%rbp)                ## 8-byte Spill
	movabsq	$4611686018427387902, %rax      ## imm = 0x3FFFFFFFFFFFFFFE
	andq	%rax, %rsi
	movq	%rsi, -120(%rbp)                ## 8-byte Spill
	movl	%r8d, %r10d
	andl	$3, %r10d
	xorl	%eax, %eax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movl	$8, -60(%rbp)                   ## 4-byte Folded Spill
	movq	%rcx, -192(%rbp)                ## 8-byte Spill
	movq	%rcx, -136(%rbp)                ## 8-byte Spill
	xorl	%eax, %eax
	movq	%rax, -184(%rbp)                ## 8-byte Spill
	movl	$8, -68(%rbp)                   ## 4-byte Folded Spill
	xorl	%ecx, %ecx
	movq	%r10, -88(%rbp)                 ## 8-byte Spill
	movq	%rdx, -176(%rbp)                ## 8-byte Spill
	jmp	LBB0_3
	.p2align	4, 0x90
LBB0_2:                                 ##   in Loop: Header=BB0_3 Depth=1
	movl	-52(%rbp), %ecx                 ## 4-byte Reload
	incl	%ecx
	movl	16(%rbp), %r14d
	addl	%r14d, -68(%rbp)                ## 4-byte Folded Spill
	movq	-176(%rbp), %rdx                ## 8-byte Reload
	addl	%edx, -60(%rbp)                 ## 4-byte Folded Spill
	addq	%rdx, -184(%rbp)                ## 8-byte Folded Spill
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	addq	-216(%rbp), %rax                ## 8-byte Folded Reload
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	addq	%rdx, -136(%rbp)                ## 8-byte Folded Spill
	cmpl	-64(%rbp), %ecx                 ## 4-byte Folded Reload
	movq	-88(%rbp), %r10                 ## 8-byte Reload
	je	LBB0_57
LBB0_3:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_6 Depth 2
                                        ##       Child Loop BB0_16 Depth 3
                                        ##       Child Loop BB0_27 Depth 3
                                        ##       Child Loop BB0_29 Depth 3
                                        ##     Child Loop BB0_33 Depth 2
                                        ##       Child Loop BB0_43 Depth 3
                                        ##       Child Loop BB0_54 Depth 3
                                        ##       Child Loop BB0_56 Depth 3
                                        ## kill: def $edx killed $edx killed $rdx def $rdx
	imull	%ecx, %edx
	movq	%rdx, -104(%rbp)                ## 8-byte Spill
	movl	%ecx, -52(%rbp)                 ## 4-byte Spill
	imull	%r14d, %ecx
	movl	%ecx, -128(%rbp)                ## 4-byte Spill
	cmpl	$0, -44(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_30
## %bb.4:                               ##   in Loop: Header=BB0_3 Depth=1
	movl	-52(%rbp), %eax                 ## 4-byte Reload
                                        ## kill: def $eax killed $eax def $rax
	imull	-48(%rbp), %eax                 ## 4-byte Folded Reload
	movq	%rax, -200(%rbp)                ## 8-byte Spill
	xorl	%r14d, %r14d
	movq	-80(%rbp), %r11                 ## 8-byte Reload
	movq	-184(%rbp), %r12                ## 8-byte Reload
	movl	-60(%rbp), %r9d                 ## 4-byte Reload
	movl	-68(%rbp), %eax                 ## 4-byte Reload
	movl	%eax, -112(%rbp)                ## 4-byte Spill
	jmp	LBB0_6
	.p2align	4, 0x90
LBB0_5:                                 ##   in Loop: Header=BB0_6 Depth=2
	incl	%r14d
	addl	%r15d, -112(%rbp)               ## 4-byte Folded Spill
	addl	%r15d, %r9d
	addq	%r8, %r12
	addq	%r8, %r11
	cmpl	-44(%rbp), %r14d                ## 4-byte Folded Reload
	je	LBB0_30
LBB0_6:                                 ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_16 Depth 3
                                        ##       Child Loop BB0_27 Depth 3
                                        ##       Child Loop BB0_29 Depth 3
	testl	%r15d, %r15d
	je	LBB0_5
## %bb.7:                               ##   in Loop: Header=BB0_6 Depth=2
	cmpl	$8, %r15d
	movl	%r9d, %esi
	jae	LBB0_9
LBB0_24:                                ##   in Loop: Header=BB0_6 Depth=2
	xorl	%ecx, %ecx
LBB0_25:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	%rcx, %r9
	notq	%r9
	addq	%r8, %r9
	testq	%r10, %r10
	je	LBB0_28
## %bb.26:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	%r10, %rdi
	.p2align	4, 0x90
LBB0_27:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_6 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	(%r11,%rcx), %eax
	movl	(%rbx,%rax,4), %eax
	leal	(%r12,%rcx), %edx
	movl	%eax, (%r13,%rdx,4)
	incq	%rcx
	decq	%rdi
	jne	LBB0_27
LBB0_28:                                ##   in Loop: Header=BB0_6 Depth=2
	cmpq	$3, %r9
	movl	%esi, %r9d
	jb	LBB0_5
	.p2align	4, 0x90
LBB0_29:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_6 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leaq	(%r11,%rcx), %rax
	movl	%eax, %edx
	movl	(%rbx,%rdx,4), %edx
	leaq	(%r12,%rcx), %rdi
	movl	%edi, %esi
	movl	%edx, (%r13,%rsi,4)
	leal	1(%rax), %edx
	movl	(%rbx,%rdx,4), %edx
	leal	1(%rdi), %esi
	movl	%edx, (%r13,%rsi,4)
	leal	2(%rax), %edx
	movl	(%rbx,%rdx,4), %edx
	leal	2(%rdi), %esi
	movl	%edx, (%r13,%rsi,4)
	addl	$3, %eax
	movl	(%rbx,%rax,4), %eax
	addl	$3, %edi
	movl	%eax, (%r13,%rdi,4)
	addq	$4, %rcx
	cmpq	%rcx, %r8
	jne	LBB0_29
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_9:                                 ##   in Loop: Header=BB0_6 Depth=2
	movl	%r14d, %eax
	imull	%r15d, %eax
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	addl	%eax, %ecx
	addl	-128(%rbp), %eax                ## 4-byte Folded Reload
	movl	%eax, %edi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	addl	%edx, %edi
	setb	%r9b
	movl	%ecx, %edi
	addl	%edx, %edi
	jb	LBB0_24
## %bb.10:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	%rdx, %rdi
	shrq	$32, %rdi
	jne	LBB0_24
## %bb.11:                              ##   in Loop: Header=BB0_6 Depth=2
	testb	%r9b, %r9b
	jne	LBB0_24
## %bb.12:                              ##   in Loop: Header=BB0_6 Depth=2
	testq	%rdi, %rdi
	jne	LBB0_24
## %bb.13:                              ##   in Loop: Header=BB0_6 Depth=2
	leaq	(,%rcx,4), %rdi
	addq	%r13, %rdi
	leaq	(%rbx,%rax,4), %rcx
	subq	%rcx, %rdi
	movl	$0, %ecx
	cmpq	$32, %rdi
	jb	LBB0_25
## %bb.14:                              ##   in Loop: Header=BB0_6 Depth=2
	cmpq	$0, -152(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_17
## %bb.15:                              ##   in Loop: Header=BB0_6 Depth=2
	movl	%esi, %edx
	movq	-120(%rbp), %r15                ## 8-byte Reload
	movl	%esi, %r10d
	movl	-112(%rbp), %ecx                ## 4-byte Reload
	movl	%ecx, %r9d
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_16:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_6 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	-8(%r9), %edi
	movups	(%rbx,%rdi,4), %xmm0
	movups	16(%rbx,%rdi,4), %xmm1
	leal	-8(%r10), %edi
	movups	%xmm0, (%r13,%rdi,4)
	movups	%xmm1, 16(%r13,%rdi,4)
	movl	%r9d, %edi
	movups	(%rbx,%rdi,4), %xmm0
	movups	16(%rbx,%rdi,4), %xmm1
	movl	%r10d, %edi
	movups	%xmm0, (%r13,%rdi,4)
	movups	%xmm1, 16(%r13,%rdi,4)
	addq	$16, %rcx
	addl	$16, %r9d
	addl	$16, %r10d
	addq	$-2, %r15
	jne	LBB0_16
	jmp	LBB0_18
LBB0_17:                                ##   in Loop: Header=BB0_6 Depth=2
	xorl	%ecx, %ecx
LBB0_18:                                ##   in Loop: Header=BB0_6 Depth=2
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	movl	-56(%rbp), %r15d                ## 4-byte Reload
	movq	-88(%rbp), %r10                 ## 8-byte Reload
	je	LBB0_20
## %bb.19:                              ##   in Loop: Header=BB0_6 Depth=2
	movq	-200(%rbp), %rdx                ## 8-byte Reload
	leal	(%r14,%rdx), %edi
	imull	%r15d, %edi
	addl	%ecx, %eax
	movups	(%rbx,%rax,4), %xmm0
	movups	16(%rbx,%rax,4), %xmm1
	addl	%ecx, %edi
	movups	%xmm0, (%r13,%rdi,4)
	movups	%xmm1, 16(%r13,%rdi,4)
LBB0_20:                                ##   in Loop: Header=BB0_6 Depth=2
	movq	-160(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %rcx
	cmpq	%r8, %rax
	movl	%esi, %r9d
	je	LBB0_5
	jmp	LBB0_25
	.p2align	4, 0x90
LBB0_30:                                ##   in Loop: Header=BB0_3 Depth=1
	movl	-44(%rbp), %eax                 ## 4-byte Reload
	cmpl	-48(%rbp), %eax                 ## 4-byte Folded Reload
	jae	LBB0_2
## %bb.31:                              ##   in Loop: Header=BB0_3 Depth=1
	movq	-104(%rbp), %rax                ## 8-byte Reload
	addl	-192(%rbp), %eax                ## 4-byte Folded Reload
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movl	-52(%rbp), %eax                 ## 4-byte Reload
                                        ## kill: def $eax killed $eax def $rax
	imull	-48(%rbp), %eax                 ## 4-byte Folded Reload
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	xorl	%r9d, %r9d
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	movq	-136(%rbp), %r11                ## 8-byte Reload
	movl	-68(%rbp), %r10d                ## 4-byte Reload
	movl	-44(%rbp), %eax                 ## 4-byte Reload
	movl	%eax, %r12d
	jmp	LBB0_33
	.p2align	4, 0x90
LBB0_32:                                ##   in Loop: Header=BB0_33 Depth=2
	incl	%r12d
	incl	%r9d
	addl	%r15d, %r10d
	addq	%r8, %r11
	addq	%r8, %r14
	cmpl	-48(%rbp), %r12d                ## 4-byte Folded Reload
	je	LBB0_2
LBB0_33:                                ##   Parent Loop BB0_3 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_43 Depth 3
                                        ##       Child Loop BB0_54 Depth 3
                                        ##       Child Loop BB0_56 Depth 3
	testl	%r15d, %r15d
	je	LBB0_32
## %bb.34:                              ##   in Loop: Header=BB0_33 Depth=2
	cmpl	$8, %r15d
	jae	LBB0_36
LBB0_51:                                ##   in Loop: Header=BB0_33 Depth=2
	xorl	%ecx, %ecx
LBB0_52:                                ##   in Loop: Header=BB0_33 Depth=2
	movq	%rcx, %rax
	notq	%rax
	addq	%r8, %rax
	testb	$3, %r8b
	je	LBB0_55
## %bb.53:                              ##   in Loop: Header=BB0_33 Depth=2
	movq	-88(%rbp), %rsi                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_54:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_33 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	(%r14,%rcx), %edx
	movl	(%rbx,%rdx,4), %edx
	leal	(%r11,%rcx), %edi
	movl	%edx, (%r13,%rdi,4)
	incq	%rcx
	decq	%rsi
	jne	LBB0_54
LBB0_55:                                ##   in Loop: Header=BB0_33 Depth=2
	cmpq	$3, %rax
	jb	LBB0_32
	.p2align	4, 0x90
LBB0_56:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_33 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leaq	(%r14,%rcx), %rax
	movl	%eax, %edx
	movl	(%rbx,%rdx,4), %edx
	leaq	(%r11,%rcx), %rsi
	movl	%esi, %edi
	movl	%edx, (%r13,%rdi,4)
	leal	1(%rax), %edx
	movl	(%rbx,%rdx,4), %edx
	leal	1(%rsi), %edi
	movl	%edx, (%r13,%rdi,4)
	leal	2(%rax), %edx
	movl	(%rbx,%rdx,4), %edx
	leal	2(%rsi), %edi
	movl	%edx, (%r13,%rdi,4)
	addl	$3, %eax
	movl	(%rbx,%rax,4), %eax
	addl	$3, %esi
	movl	%eax, (%r13,%rsi,4)
	addq	$4, %rcx
	cmpq	%rcx, %r8
	jne	LBB0_56
	jmp	LBB0_32
	.p2align	4, 0x90
LBB0_36:                                ##   in Loop: Header=BB0_33 Depth=2
	movl	%r9d, %eax
	imull	%r15d, %eax
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	addl	%eax, %ecx
	addl	-128(%rbp), %eax                ## 4-byte Folded Reload
	movl	%eax, %esi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	addl	%edx, %esi
	setb	%sil
	movl	%ecx, %edi
	addl	%edx, %edi
	jb	LBB0_51
## %bb.37:                              ##   in Loop: Header=BB0_33 Depth=2
	movq	%rdx, %rdi
	shrq	$32, %rdi
	jne	LBB0_51
## %bb.38:                              ##   in Loop: Header=BB0_33 Depth=2
	testb	%sil, %sil
	jne	LBB0_51
## %bb.39:                              ##   in Loop: Header=BB0_33 Depth=2
	testq	%rdi, %rdi
	jne	LBB0_51
## %bb.40:                              ##   in Loop: Header=BB0_33 Depth=2
	leaq	(,%rcx,4), %rsi
	addq	%r13, %rsi
	leaq	(%rbx,%rax,4), %rax
	subq	%rax, %rsi
	movl	$0, %ecx
	cmpq	$32, %rsi
	jb	LBB0_52
## %bb.41:                              ##   in Loop: Header=BB0_33 Depth=2
	cmpq	$0, -152(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_47
## %bb.42:                              ##   in Loop: Header=BB0_33 Depth=2
	movq	-120(%rbp), %rsi                ## 8-byte Reload
	movl	%r11d, %edi
	movl	%r10d, %eax
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_43:                                ##   Parent Loop BB0_3 Depth=1
                                        ##     Parent Loop BB0_33 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	-8(%rax), %edx
	movups	(%rbx,%rdx,4), %xmm0
	movups	16(%rbx,%rdx,4), %xmm1
	movl	%edi, %edx
	movups	%xmm0, (%r13,%rdx,4)
	movups	%xmm1, 16(%r13,%rdx,4)
	movl	%eax, %edx
	movups	(%rbx,%rdx,4), %xmm0
	movups	16(%rbx,%rdx,4), %xmm1
	leal	8(%rdi), %edx
	movups	%xmm0, (%r13,%rdx,4)
	movups	%xmm1, 16(%r13,%rdx,4)
	addq	$16, %rcx
	addl	$16, %eax
	addl	$16, %edi
	addq	$-2, %rsi
	jne	LBB0_43
## %bb.44:                              ##   in Loop: Header=BB0_33 Depth=2
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_46
LBB0_45:                                ##   in Loop: Header=BB0_33 Depth=2
	movl	%r12d, %eax
	subl	-44(%rbp), %eax                 ## 4-byte Folded Reload
	movq	-112(%rbp), %rdx                ## 8-byte Reload
	addl	%r12d, %edx
	imull	%r15d, %eax
	imull	%r15d, %edx
	addl	-128(%rbp), %eax                ## 4-byte Folded Reload
	addl	%ecx, %eax
	movups	(%rbx,%rax,4), %xmm0
	movups	16(%rbx,%rax,4), %xmm1
	addl	%ecx, %edx
	movups	%xmm0, (%r13,%rdx,4)
	movups	%xmm1, 16(%r13,%rdx,4)
LBB0_46:                                ##   in Loop: Header=BB0_33 Depth=2
	movq	-160(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %rcx
	cmpq	%r8, %rax
	je	LBB0_32
	jmp	LBB0_52
LBB0_47:                                ##   in Loop: Header=BB0_33 Depth=2
	xorl	%ecx, %ecx
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_45
	jmp	LBB0_46
LBB0_57:
	movl	-64(%rbp), %eax                 ## 4-byte Reload
	cmpl	-164(%rbp), %eax                ## 4-byte Folded Reload
	jae	LBB0_113
## %bb.58:
	leaq	-1(%r8), %rax
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movl	-48(%rbp), %eax                 ## 4-byte Reload
	movl	%eax, %edx
	movl	-64(%rbp), %r9d                 ## 4-byte Reload
	imull	%r9d, %edx
	addl	-44(%rbp), %edx                 ## 4-byte Folded Reload
	imull	%r15d, %edx
	movl	%r15d, %esi
	imull	%eax, %esi
	movl	%esi, %eax
	imull	%r9d, %eax
	movl	%r8d, %edi
	andl	$-8, %edi
	movq	%rdi, -160(%rbp)                ## 8-byte Spill
	addq	$-8, %rdi
	movq	%rdi, -152(%rbp)                ## 8-byte Spill
	shrq	$3, %rdi
	incq	%rdi
	movq	%rdi, %rcx
	movq	%rdi, -144(%rbp)                ## 8-byte Spill
	andq	%rdi, -208(%rbp)                ## 8-byte Folded Spill
	movl	%r8d, %ecx
	andl	$3, %ecx
	movq	%rcx, -112(%rbp)                ## 8-byte Spill
	xorl	%ecx, %ecx
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	movl	$8, -60(%rbp)                   ## 4-byte Folded Spill
	movq	%rdx, -224(%rbp)                ## 8-byte Spill
	movq	%rdx, -176(%rbp)                ## 8-byte Spill
	movq	%rax, -232(%rbp)                ## 8-byte Spill
	movq	%rax, -136(%rbp)                ## 8-byte Spill
	xorl	%edx, %edx
	movl	%r9d, -52(%rbp)                 ## 4-byte Spill
	movq	%rsi, -192(%rbp)                ## 8-byte Spill
	jmp	LBB0_60
	.p2align	4, 0x90
LBB0_59:                                ##   in Loop: Header=BB0_60 Depth=1
	movl	-52(%rbp), %edi                 ## 4-byte Reload
	incl	%edi
	movl	-184(%rbp), %edx                ## 4-byte Reload
	incl	%edx
	addl	%r14d, -60(%rbp)                ## 4-byte Folded Spill
	movq	-192(%rbp), %rsi                ## 8-byte Reload
	addq	%rsi, -136(%rbp)                ## 8-byte Folded Spill
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	addq	-216(%rbp), %rcx                ## 8-byte Folded Reload
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	addq	%rsi, -176(%rbp)                ## 8-byte Folded Spill
	movl	%edi, -52(%rbp)                 ## 4-byte Spill
	cmpl	-164(%rbp), %edi                ## 4-byte Folded Reload
	movl	%eax, %r15d
	je	LBB0_113
LBB0_60:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_63 Depth 2
                                        ##       Child Loop BB0_73 Depth 3
                                        ##       Child Loop BB0_83 Depth 3
                                        ##       Child Loop BB0_85 Depth 3
                                        ##     Child Loop BB0_89 Depth 2
                                        ##       Child Loop BB0_99 Depth 3
                                        ##       Child Loop BB0_110 Depth 3
                                        ##       Child Loop BB0_112 Depth 3
                                        ## kill: def $esi killed $esi killed $rsi def $rsi
	imull	%edx, %esi
	movq	%rsi, -96(%rbp)                 ## 8-byte Spill
	movl	%edx, -184(%rbp)                ## 4-byte Spill
	movl	%edx, %eax
	imull	%r14d, %eax
	movq	%rax, -128(%rbp)                ## 8-byte Spill
	cmpl	$0, -44(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_86
## %bb.61:                              ##   in Loop: Header=BB0_60 Depth=1
	movq	-232(%rbp), %rax                ## 8-byte Reload
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	leal	(%rax,%rcx), %edx
	movq	%rdx, -120(%rbp)                ## 8-byte Spill
	addl	%ecx, %eax
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	movl	-52(%rbp), %eax                 ## 4-byte Reload
	movl	%eax, %ecx
	imull	-48(%rbp), %ecx                 ## 4-byte Folded Reload
	movq	%rcx, -200(%rbp)                ## 8-byte Spill
	subl	-64(%rbp), %eax                 ## 4-byte Folded Reload
	imull	16(%rbp), %eax
	movl	%eax, -68(%rbp)                 ## 4-byte Spill
	xorl	%r14d, %r14d
	movq	-80(%rbp), %r9                  ## 8-byte Reload
	movq	-136(%rbp), %r10                ## 8-byte Reload
	movl	-60(%rbp), %r12d                ## 4-byte Reload
	jmp	LBB0_63
	.p2align	4, 0x90
LBB0_62:                                ##   in Loop: Header=BB0_63 Depth=2
	incl	%r14d
	movl	-56(%rbp), %r15d                ## 4-byte Reload
	addl	%r15d, %r12d
	addq	%r8, %r10
	addq	%r8, %r9
	cmpl	-44(%rbp), %r14d                ## 4-byte Folded Reload
	je	LBB0_86
LBB0_63:                                ##   Parent Loop BB0_60 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_73 Depth 3
                                        ##       Child Loop BB0_83 Depth 3
                                        ##       Child Loop BB0_85 Depth 3
	testl	%r15d, %r15d
	je	LBB0_62
## %bb.64:                              ##   in Loop: Header=BB0_63 Depth=2
	movl	-56(%rbp), %eax                 ## 4-byte Reload
	cmpl	$8, %eax
	jae	LBB0_66
LBB0_81:                                ##   in Loop: Header=BB0_63 Depth=2
	xorl	%edx, %edx
LBB0_82:                                ##   in Loop: Header=BB0_63 Depth=2
	movq	%rdx, %r11
	notq	%r11
	addq	%r8, %r11
	movq	-112(%rbp), %rsi                ## 8-byte Reload
	testq	%rsi, %rsi
	je	LBB0_84
	.p2align	4, 0x90
LBB0_83:                                ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_63 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	(%r9,%rdx), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	(%r10,%rdx), %eax
	movl	%ecx, (%r13,%rax,4)
	incq	%rdx
	decq	%rsi
	jne	LBB0_83
LBB0_84:                                ##   in Loop: Header=BB0_63 Depth=2
	cmpq	$3, %r11
	jb	LBB0_62
	.p2align	4, 0x90
LBB0_85:                                ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_63 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leaq	(%r9,%rdx), %rax
	movl	%eax, %ecx
	movl	(%rbx,%rcx,4), %ecx
	leaq	(%r10,%rdx), %rsi
	movl	%esi, %edi
	movl	%ecx, (%r13,%rdi,4)
	leal	1(%rax), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	1(%rsi), %edi
	movl	%ecx, (%r13,%rdi,4)
	leal	2(%rax), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	2(%rsi), %edi
	movl	%ecx, (%r13,%rdi,4)
	addl	$3, %eax
	movl	(%rbx,%rax,4), %eax
	addl	$3, %esi
	movl	%eax, (%r13,%rsi,4)
	addq	$4, %rdx
	cmpq	%rdx, %r8
	jne	LBB0_85
	jmp	LBB0_62
	.p2align	4, 0x90
LBB0_66:                                ##   in Loop: Header=BB0_63 Depth=2
	movl	%r14d, %r15d
	imull	%eax, %r15d
	movq	-128(%rbp), %rax                ## 8-byte Reload
	addl	%r15d, %eax
	movq	-88(%rbp), %rcx                 ## 8-byte Reload
	leal	(%rcx,%r15), %esi
	movl	%eax, %edx
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	addl	%ecx, %edx
	setb	%dl
	addl	%ecx, %esi
	jb	LBB0_81
## %bb.67:                              ##   in Loop: Header=BB0_63 Depth=2
	movq	%rcx, %rsi
	shrq	$32, %rsi
	jne	LBB0_81
## %bb.68:                              ##   in Loop: Header=BB0_63 Depth=2
	testb	%dl, %dl
	jne	LBB0_81
## %bb.69:                              ##   in Loop: Header=BB0_63 Depth=2
	testq	%rsi, %rsi
	jne	LBB0_81
## %bb.70:                              ##   in Loop: Header=BB0_63 Depth=2
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	leal	(%rcx,%r15), %edx
	leaq	(,%rdx,4), %rsi
	addq	%r13, %rsi
	leaq	(%rbx,%rax,4), %rax
	subq	%rax, %rsi
	movl	$0, %edx
	cmpq	$32, %rsi
	jb	LBB0_82
## %bb.71:                              ##   in Loop: Header=BB0_63 Depth=2
	cmpq	$0, -152(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_77
## %bb.72:                              ##   in Loop: Header=BB0_63 Depth=2
	movq	-208(%rbp), %rsi                ## 8-byte Reload
	movl	%r10d, %r11d
	movl	%r12d, %eax
	xorl	%edx, %edx
	.p2align	4, 0x90
LBB0_73:                                ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_63 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	-8(%rax), %ecx
	movups	(%rbx,%rcx,4), %xmm0
	movups	16(%rbx,%rcx,4), %xmm1
	movl	%r11d, %ecx
	movups	%xmm0, (%r13,%rcx,4)
	movups	%xmm1, 16(%r13,%rcx,4)
	movl	%eax, %ecx
	movups	(%rbx,%rcx,4), %xmm0
	movups	16(%rbx,%rcx,4), %xmm1
	leal	8(%r11), %ecx
	movups	%xmm0, (%r13,%rcx,4)
	movups	%xmm1, 16(%r13,%rcx,4)
	addq	$16, %rdx
	addl	$16, %eax
	addl	$16, %r11d
	addq	$-2, %rsi
	jne	LBB0_73
## %bb.74:                              ##   in Loop: Header=BB0_63 Depth=2
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_76
LBB0_75:                                ##   in Loop: Header=BB0_63 Depth=2
	movq	-200(%rbp), %rax                ## 8-byte Reload
	addl	%r14d, %eax
	imull	-56(%rbp), %eax                 ## 4-byte Folded Reload
	addl	-68(%rbp), %r15d                ## 4-byte Folded Reload
	addl	%edx, %r15d
	movups	(%rbx,%r15,4), %xmm0
	movups	16(%rbx,%r15,4), %xmm1
	addl	%edx, %eax
	movups	%xmm0, (%r13,%rax,4)
	movups	%xmm1, 16(%r13,%rax,4)
LBB0_76:                                ##   in Loop: Header=BB0_63 Depth=2
	movq	-160(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %rdx
	cmpq	%r8, %rax
	je	LBB0_62
	jmp	LBB0_82
LBB0_77:                                ##   in Loop: Header=BB0_63 Depth=2
	xorl	%edx, %edx
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_75
	jmp	LBB0_76
	.p2align	4, 0x90
LBB0_86:                                ##   in Loop: Header=BB0_60 Depth=1
	movl	-44(%rbp), %eax                 ## 4-byte Reload
	cmpl	-48(%rbp), %eax                 ## 4-byte Folded Reload
	movl	%r15d, %eax
	movl	16(%rbp), %r14d
	jae	LBB0_59
## %bb.87:                              ##   in Loop: Header=BB0_60 Depth=1
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	addl	-224(%rbp), %ecx                ## 4-byte Folded Reload
	movq	%rcx, -96(%rbp)                 ## 8-byte Spill
	movl	-52(%rbp), %ecx                 ## 4-byte Reload
	movl	%ecx, %edx
	imull	-48(%rbp), %edx                 ## 4-byte Folded Reload
	movq	%rdx, -88(%rbp)                 ## 8-byte Spill
	subl	-64(%rbp), %ecx                 ## 4-byte Folded Reload
	imull	%r14d, %ecx
	movl	%ecx, -120(%rbp)                ## 4-byte Spill
	xorl	%r15d, %r15d
	movq	-80(%rbp), %r10                 ## 8-byte Reload
	movq	-176(%rbp), %r9                 ## 8-byte Reload
	movl	-60(%rbp), %r11d                ## 4-byte Reload
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	movl	%ecx, %r12d
	jmp	LBB0_89
	.p2align	4, 0x90
LBB0_88:                                ##   in Loop: Header=BB0_89 Depth=2
	incl	%r12d
	incl	%r15d
	movl	-56(%rbp), %eax                 ## 4-byte Reload
	addl	%eax, %r11d
	addq	%r8, %r9
	addq	%r8, %r10
	cmpl	-48(%rbp), %r12d                ## 4-byte Folded Reload
	je	LBB0_59
LBB0_89:                                ##   Parent Loop BB0_60 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_99 Depth 3
                                        ##       Child Loop BB0_110 Depth 3
                                        ##       Child Loop BB0_112 Depth 3
	testl	%eax, %eax
	je	LBB0_88
## %bb.90:                              ##   in Loop: Header=BB0_89 Depth=2
	movl	-56(%rbp), %ecx                 ## 4-byte Reload
	cmpl	$8, %ecx
	jae	LBB0_92
LBB0_107:                               ##   in Loop: Header=BB0_89 Depth=2
	xorl	%edx, %edx
LBB0_108:                               ##   in Loop: Header=BB0_89 Depth=2
	movq	%rdx, %rax
	notq	%rax
	addq	%r8, %rax
	testb	$3, %r8b
	je	LBB0_111
## %bb.109:                             ##   in Loop: Header=BB0_89 Depth=2
	movq	-112(%rbp), %rsi                ## 8-byte Reload
	.p2align	4, 0x90
LBB0_110:                               ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_89 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	(%r10,%rdx), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	(%r9,%rdx), %edi
	movl	%ecx, (%r13,%rdi,4)
	incq	%rdx
	decq	%rsi
	jne	LBB0_110
LBB0_111:                               ##   in Loop: Header=BB0_89 Depth=2
	cmpq	$3, %rax
	jb	LBB0_88
	.p2align	4, 0x90
LBB0_112:                               ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_89 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leaq	(%r10,%rdx), %rax
	movl	%eax, %ecx
	movl	(%rbx,%rcx,4), %ecx
	leaq	(%r9,%rdx), %rsi
	movl	%esi, %edi
	movl	%ecx, (%r13,%rdi,4)
	leal	1(%rax), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	1(%rsi), %edi
	movl	%ecx, (%r13,%rdi,4)
	leal	2(%rax), %ecx
	movl	(%rbx,%rcx,4), %ecx
	leal	2(%rsi), %edi
	movl	%ecx, (%r13,%rdi,4)
	addl	$3, %eax
	movl	(%rbx,%rax,4), %eax
	addl	$3, %esi
	movl	%eax, (%r13,%rsi,4)
	addq	$4, %rdx
	cmpq	%rdx, %r8
	jne	LBB0_112
	jmp	LBB0_88
	.p2align	4, 0x90
LBB0_92:                                ##   in Loop: Header=BB0_89 Depth=2
	movl	%r15d, %eax
	imull	%ecx, %eax
	movq	-96(%rbp), %rcx                 ## 8-byte Reload
	leal	(%rcx,%rax), %edx
	addl	-128(%rbp), %eax                ## 4-byte Folded Reload
	movl	%eax, %esi
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	addl	%ecx, %esi
	setb	%sil
	movl	%edx, %edi
	addl	%ecx, %edi
	jb	LBB0_107
## %bb.93:                              ##   in Loop: Header=BB0_89 Depth=2
	movq	%rcx, %rdi
	shrq	$32, %rdi
	jne	LBB0_107
## %bb.94:                              ##   in Loop: Header=BB0_89 Depth=2
	testb	%sil, %sil
	jne	LBB0_107
## %bb.95:                              ##   in Loop: Header=BB0_89 Depth=2
	testq	%rdi, %rdi
	jne	LBB0_107
## %bb.96:                              ##   in Loop: Header=BB0_89 Depth=2
	leaq	(,%rdx,4), %rsi
	addq	%r13, %rsi
	leaq	(%rbx,%rax,4), %rax
	subq	%rax, %rsi
	movl	$0, %edx
	cmpq	$32, %rsi
	jb	LBB0_108
## %bb.97:                              ##   in Loop: Header=BB0_89 Depth=2
	cmpq	$0, -152(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_103
## %bb.98:                              ##   in Loop: Header=BB0_89 Depth=2
	movq	-208(%rbp), %rsi                ## 8-byte Reload
	movl	%r9d, %edi
	movl	%r11d, %eax
	xorl	%edx, %edx
	.p2align	4, 0x90
LBB0_99:                                ##   Parent Loop BB0_60 Depth=1
                                        ##     Parent Loop BB0_89 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	leal	-8(%rax), %ecx
	movups	(%rbx,%rcx,4), %xmm0
	movups	16(%rbx,%rcx,4), %xmm1
	movl	%edi, %ecx
	movups	%xmm0, (%r13,%rcx,4)
	movups	%xmm1, 16(%r13,%rcx,4)
	movl	%eax, %ecx
	movups	(%rbx,%rcx,4), %xmm0
	movups	16(%rbx,%rcx,4), %xmm1
	leal	8(%rdi), %ecx
	movups	%xmm0, (%r13,%rcx,4)
	movups	%xmm1, 16(%r13,%rcx,4)
	addq	$16, %rdx
	addl	$16, %eax
	addl	$16, %edi
	addq	$-2, %rsi
	jne	LBB0_99
## %bb.100:                             ##   in Loop: Header=BB0_89 Depth=2
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_102
LBB0_101:                               ##   in Loop: Header=BB0_89 Depth=2
	movl	%r12d, %eax
	subl	-44(%rbp), %eax                 ## 4-byte Folded Reload
	movq	-88(%rbp), %rcx                 ## 8-byte Reload
	addl	%r12d, %ecx
	movl	-56(%rbp), %esi                 ## 4-byte Reload
	imull	%esi, %eax
	addl	-120(%rbp), %eax                ## 4-byte Folded Reload
	imull	%esi, %ecx
	addl	%edx, %eax
	movups	(%rbx,%rax,4), %xmm0
	movups	16(%rbx,%rax,4), %xmm1
	addl	%edx, %ecx
	movups	%xmm0, (%r13,%rcx,4)
	movups	%xmm1, 16(%r13,%rcx,4)
LBB0_102:                               ##   in Loop: Header=BB0_89 Depth=2
	movq	-160(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %rdx
	cmpq	%r8, %rax
	je	LBB0_88
	jmp	LBB0_108
LBB0_103:                               ##   in Loop: Header=BB0_89 Depth=2
	xorl	%edx, %edx
	testb	$1, -144(%rbp)                  ## 1-byte Folded Reload
	jne	LBB0_101
	jmp	LBB0_102
LBB0_113:
	addq	$200, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	__mesa_upscale_teximage2d       ; -- Begin function _mesa_upscale_teximage2d
	.p2align	2
__mesa_upscale_teximage2d:              ; @_mesa_upscale_teximage2d
	.cfi_startproc
; %bb.0:
	stp	x28, x27, [sp, #-96]!           ; 16-byte Folded Spill
	.cfi_def_cfa_offset 96
	stp	x26, x25, [sp, #16]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #32]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #48]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #64]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #80]             ; 16-byte Folded Spill
	add	x29, sp, #80
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w19, -24
	.cfi_offset w20, -32
	.cfi_offset w21, -40
	.cfi_offset w22, -48
	.cfi_offset w23, -56
	.cfi_offset w24, -64
	.cfi_offset w25, -72
	.cfi_offset w26, -80
	.cfi_offset w27, -88
	.cfi_offset w28, -96
	mov	x19, x7
	mov	x20, x6
	mov	x21, x5
	mov	x22, x4
	mov	x23, x3
	mov	x24, x2
	mov	x25, x1
	mov	x26, x0
	cmp	w2, w0
	cset	w0, hs
	bl	_assert
	cmp	w23, w25
	cset	w0, hs
	bl	_assert
	cbz	w25, LBB0_35
; %bb.1:
	mov	w8, #0
	mov	w9, #0
	mov	w10, #0
	mov	w11, w22
	sub	x12, x11, #1
	mul	w13, w22, w26
	mul	w14, w22, w24
	and	x15, x11, #0xfffffff0
	mov	x16, x13
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	add	w10, w10, #1
	add	w9, w9, w20
	add	w8, w8, w14
	add	w16, w16, w14
	cmp	w10, w25
	b.eq	LBB0_35
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_6 Depth 2
                                        ;       Child Loop BB0_15 Depth 3
                                        ;       Child Loop BB0_18 Depth 3
                                        ;     Child Loop BB0_22 Depth 2
                                        ;       Child Loop BB0_31 Depth 3
                                        ;       Child Loop BB0_34 Depth 3
	mul	w17, w10, w20
	cbz	w26, LBB0_19
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	mov	w0, #0
	mul	w1, w14, w10
	mov	x2, x8
	mov	x3, x9
	b	LBB0_6
LBB0_5:                                 ;   in Loop: Header=BB0_6 Depth=2
	add	w0, w0, #1
	add	w3, w3, w22
	add	w2, w2, w22
	cmp	w0, w26
	b.eq	LBB0_19
LBB0_6:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_15 Depth 3
                                        ;       Child Loop BB0_18 Depth 3
	cbz	w22, LBB0_5
; %bb.7:                                ;   in Loop: Header=BB0_6 Depth=2
	cmp	w22, #16
	b.hs	LBB0_9
; %bb.8:                                ;   in Loop: Header=BB0_6 Depth=2
	mov	x4, #0
	b	LBB0_17
LBB0_9:                                 ;   in Loop: Header=BB0_6 Depth=2
	mov	x4, #0
	mul	w6, w0, w22
	add	w5, w1, w6
	cmn	w5, w12
	cset	w27, hs
	add	w6, w17, w6
	cmn	w6, w12
	cset	w7, hs
	tbnz	w27, #0, LBB0_17
; %bb.10:                               ;   in Loop: Header=BB0_6 Depth=2
	lsr	x27, x12, #32
	cbnz	x27, LBB0_17
; %bb.11:                               ;   in Loop: Header=BB0_6 Depth=2
	tbnz	w7, #0, LBB0_17
; %bb.12:                               ;   in Loop: Header=BB0_6 Depth=2
	cbnz	x27, LBB0_17
; %bb.13:                               ;   in Loop: Header=BB0_6 Depth=2
	add	x5, x19, w5, uxtw #2
	add	x6, x21, w6, uxtw #2
	sub	x5, x5, x6
	cmp	x5, #64
	b.lo	LBB0_17
; %bb.14:                               ;   in Loop: Header=BB0_6 Depth=2
	mov	x4, x2
	mov	x5, x3
	mov	x6, x15
LBB0_15:                                ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_6 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	x7, x21, w5, uxtw #2
	ldp	q0, q1, [x7]
	ldp	q2, q3, [x7, #32]
	add	x7, x19, w4, uxtw #2
	stp	q0, q1, [x7]
	stp	q2, q3, [x7, #32]
	add	w5, w5, #16
	add	w4, w4, #16
	subs	x6, x6, #16
	b.ne	LBB0_15
; %bb.16:                               ;   in Loop: Header=BB0_6 Depth=2
	mov	x4, x15
	cmp	x15, x11
	b.eq	LBB0_5
LBB0_17:                                ;   in Loop: Header=BB0_6 Depth=2
	sub	x5, x11, x4
LBB0_18:                                ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_6 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	w6, w3, w4
	ldr	w6, [x21, w6, uxtw #2]
	add	w7, w2, w4
	str	w6, [x19, w7, uxtw #2]
	add	w4, w4, #1
	subs	x5, x5, #1
	b.ne	LBB0_18
	b	LBB0_5
LBB0_19:                                ;   in Loop: Header=BB0_3 Depth=1
	cmp	w26, w24
	b.hs	LBB0_2
; %bb.20:                               ;   in Loop: Header=BB0_3 Depth=1
	mov	w0, #0
	madd	w1, w14, w10, w13
	mov	x2, x16
	mov	x3, x9
	mov	x4, x26
	b	LBB0_22
LBB0_21:                                ;   in Loop: Header=BB0_22 Depth=2
	add	w4, w4, #1
	add	w0, w0, #1
	add	w3, w3, w22
	add	w2, w2, w22
	cmp	w4, w24
	b.eq	LBB0_2
LBB0_22:                                ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_31 Depth 3
                                        ;       Child Loop BB0_34 Depth 3
	cbz	w22, LBB0_21
; %bb.23:                               ;   in Loop: Header=BB0_22 Depth=2
	cmp	w22, #16
	b.hs	LBB0_25
; %bb.24:                               ;   in Loop: Header=BB0_22 Depth=2
	mov	x5, #0
	b	LBB0_33
LBB0_25:                                ;   in Loop: Header=BB0_22 Depth=2
	mov	x5, #0
	mul	w7, w0, w22
	add	w6, w1, w7
	cmn	w6, w12
	cset	w28, hs
	add	w7, w17, w7
	cmn	w7, w12
	cset	w27, hs
	tbnz	w28, #0, LBB0_33
; %bb.26:                               ;   in Loop: Header=BB0_22 Depth=2
	lsr	x28, x12, #32
	cbnz	x28, LBB0_33
; %bb.27:                               ;   in Loop: Header=BB0_22 Depth=2
	tbnz	w27, #0, LBB0_33
; %bb.28:                               ;   in Loop: Header=BB0_22 Depth=2
	cbnz	x28, LBB0_33
; %bb.29:                               ;   in Loop: Header=BB0_22 Depth=2
	add	x6, x19, w6, uxtw #2
	add	x7, x21, w7, uxtw #2
	sub	x6, x6, x7
	cmp	x6, #64
	b.lo	LBB0_33
; %bb.30:                               ;   in Loop: Header=BB0_22 Depth=2
	mov	x5, x2
	mov	x6, x3
	mov	x7, x15
LBB0_31:                                ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_22 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	x27, x21, w6, uxtw #2
	ldp	q0, q1, [x27]
	ldp	q2, q3, [x27, #32]
	add	x27, x19, w5, uxtw #2
	stp	q0, q1, [x27]
	stp	q2, q3, [x27, #32]
	add	w6, w6, #16
	add	w5, w5, #16
	subs	x7, x7, #16
	b.ne	LBB0_31
; %bb.32:                               ;   in Loop: Header=BB0_22 Depth=2
	mov	x5, x15
	cmp	x15, x11
	b.eq	LBB0_21
LBB0_33:                                ;   in Loop: Header=BB0_22 Depth=2
	sub	x6, x11, x5
LBB0_34:                                ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_22 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	w7, w3, w5
	ldr	w7, [x21, w7, uxtw #2]
	add	w27, w2, w5
	str	w7, [x19, w27, uxtw #2]
	add	w5, w5, #1
	subs	x6, x6, #1
	b.ne	LBB0_34
	b	LBB0_21
LBB0_35:
	cmp	w25, w23
	b.hs	LBB0_70
; %bb.36:
	mov	w8, #0
	mov	w9, #0
	mov	w10, w22
	sub	x11, x10, #1
	madd	w12, w24, w25, w26
	mul	w12, w12, w22
	mul	w13, w22, w24
	mul	w14, w13, w25
	and	x15, x10, #0xfffffff0
	mov	x16, x12
	mov	x17, x14
	b	LBB0_38
LBB0_37:                                ;   in Loop: Header=BB0_38 Depth=1
	add	w25, w25, #1
	add	w9, w9, #1
	add	w8, w8, w20
	add	w17, w17, w13
	add	w16, w16, w13
	cmp	w25, w23
	b.eq	LBB0_70
LBB0_38:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_41 Depth 2
                                        ;       Child Loop BB0_50 Depth 3
                                        ;       Child Loop BB0_53 Depth 3
                                        ;     Child Loop BB0_57 Depth 2
                                        ;       Child Loop BB0_66 Depth 3
                                        ;       Child Loop BB0_69 Depth 3
	mul	w0, w9, w20
	cbz	w26, LBB0_54
; %bb.39:                               ;   in Loop: Header=BB0_38 Depth=1
	mov	w1, #0
	madd	w2, w13, w9, w14
	mov	x3, x17
	mov	x4, x8
	b	LBB0_41
LBB0_40:                                ;   in Loop: Header=BB0_41 Depth=2
	add	w1, w1, #1
	add	w4, w4, w22
	add	w3, w3, w22
	cmp	w1, w26
	b.eq	LBB0_54
LBB0_41:                                ;   Parent Loop BB0_38 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_50 Depth 3
                                        ;       Child Loop BB0_53 Depth 3
	cbz	w22, LBB0_40
; %bb.42:                               ;   in Loop: Header=BB0_41 Depth=2
	cmp	w22, #16
	b.hs	LBB0_44
; %bb.43:                               ;   in Loop: Header=BB0_41 Depth=2
	mov	x5, #0
	b	LBB0_52
LBB0_44:                                ;   in Loop: Header=BB0_41 Depth=2
	mov	x5, #0
	mul	w7, w1, w22
	add	w6, w2, w7
	cmn	w6, w11
	cset	w28, hs
	add	w7, w0, w7
	cmn	w7, w11
	cset	w27, hs
	tbnz	w28, #0, LBB0_52
; %bb.45:                               ;   in Loop: Header=BB0_41 Depth=2
	lsr	x28, x11, #32
	cbnz	x28, LBB0_52
; %bb.46:                               ;   in Loop: Header=BB0_41 Depth=2
	tbnz	w27, #0, LBB0_52
; %bb.47:                               ;   in Loop: Header=BB0_41 Depth=2
	cbnz	x28, LBB0_52
; %bb.48:                               ;   in Loop: Header=BB0_41 Depth=2
	add	x6, x19, w6, uxtw #2
	add	x7, x21, w7, uxtw #2
	sub	x6, x6, x7
	cmp	x6, #64
	b.lo	LBB0_52
; %bb.49:                               ;   in Loop: Header=BB0_41 Depth=2
	mov	x5, x3
	mov	x6, x4
	mov	x7, x15
LBB0_50:                                ;   Parent Loop BB0_38 Depth=1
                                        ;     Parent Loop BB0_41 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	x27, x21, w6, uxtw #2
	ldp	q0, q1, [x27]
	ldp	q2, q3, [x27, #32]
	add	x27, x19, w5, uxtw #2
	stp	q0, q1, [x27]
	stp	q2, q3, [x27, #32]
	add	w6, w6, #16
	add	w5, w5, #16
	subs	x7, x7, #16
	b.ne	LBB0_50
; %bb.51:                               ;   in Loop: Header=BB0_41 Depth=2
	mov	x5, x15
	cmp	x15, x10
	b.eq	LBB0_40
LBB0_52:                                ;   in Loop: Header=BB0_41 Depth=2
	sub	x6, x10, x5
LBB0_53:                                ;   Parent Loop BB0_38 Depth=1
                                        ;     Parent Loop BB0_41 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	w7, w4, w5
	ldr	w7, [x21, w7, uxtw #2]
	add	w27, w3, w5
	str	w7, [x19, w27, uxtw #2]
	add	w5, w5, #1
	subs	x6, x6, #1
	b.ne	LBB0_53
	b	LBB0_40
LBB0_54:                                ;   in Loop: Header=BB0_38 Depth=1
	cmp	w26, w24
	b.hs	LBB0_37
; %bb.55:                               ;   in Loop: Header=BB0_38 Depth=1
	mov	w1, #0
	madd	w2, w13, w9, w12
	mov	x3, x16
	mov	x4, x8
	mov	x5, x26
	b	LBB0_57
LBB0_56:                                ;   in Loop: Header=BB0_57 Depth=2
	add	w5, w5, #1
	add	w1, w1, #1
	add	w4, w4, w22
	add	w3, w3, w22
	cmp	w5, w24
	b.eq	LBB0_37
LBB0_57:                                ;   Parent Loop BB0_38 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_66 Depth 3
                                        ;       Child Loop BB0_69 Depth 3
	cbz	w22, LBB0_56
; %bb.58:                               ;   in Loop: Header=BB0_57 Depth=2
	cmp	w22, #16
	b.hs	LBB0_60
; %bb.59:                               ;   in Loop: Header=BB0_57 Depth=2
	mov	x6, #0
	b	LBB0_68
LBB0_60:                                ;   in Loop: Header=BB0_57 Depth=2
	mov	x6, #0
	mul	w27, w1, w22
	add	w7, w2, w27
	cmn	w7, w11
	cset	w30, hs
	add	w27, w0, w27
	cmn	w27, w11
	cset	w28, hs
	tbnz	w30, #0, LBB0_68
; %bb.61:                               ;   in Loop: Header=BB0_57 Depth=2
	lsr	x30, x11, #32
	cbnz	x30, LBB0_68
; %bb.62:                               ;   in Loop: Header=BB0_57 Depth=2
	tbnz	w28, #0, LBB0_68
; %bb.63:                               ;   in Loop: Header=BB0_57 Depth=2
	cbnz	x30, LBB0_68
; %bb.64:                               ;   in Loop: Header=BB0_57 Depth=2
	add	x7, x19, w7, uxtw #2
	add	x27, x21, w27, uxtw #2
	sub	x7, x7, x27
	cmp	x7, #64
	b.lo	LBB0_68
; %bb.65:                               ;   in Loop: Header=BB0_57 Depth=2
	mov	x6, x3
	mov	x7, x4
	mov	x27, x15
LBB0_66:                                ;   Parent Loop BB0_38 Depth=1
                                        ;     Parent Loop BB0_57 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	x28, x21, w7, uxtw #2
	ldp	q0, q1, [x28]
	ldp	q2, q3, [x28, #32]
	add	x28, x19, w6, uxtw #2
	stp	q0, q1, [x28]
	stp	q2, q3, [x28, #32]
	add	w7, w7, #16
	add	w6, w6, #16
	subs	x27, x27, #16
	b.ne	LBB0_66
; %bb.67:                               ;   in Loop: Header=BB0_57 Depth=2
	mov	x6, x15
	cmp	x15, x10
	b.eq	LBB0_56
LBB0_68:                                ;   in Loop: Header=BB0_57 Depth=2
	sub	x7, x10, x6
LBB0_69:                                ;   Parent Loop BB0_38 Depth=1
                                        ;     Parent Loop BB0_57 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	add	w27, w4, w6
	ldr	w27, [x21, w27, uxtw #2]
	add	w28, w3, w6
	str	w27, [x19, w28, uxtw #2]
	add	w6, w6, #1
	subs	x7, x7, #1
	b.ne	LBB0_69
	b	LBB0_56
LBB0_70:
	ldp	x29, x30, [sp, #80]             ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #64]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #16]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp], #96             ; 16-byte Folded Reload
	ret
	.cfi_endproc
                                        ; -- End function
.subsections_via_symbols
