	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function unsharp_opencl_make_filter_params
LCPI0_0:
	.quad	0xc030000000000000              ## double -16
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_unsharp_opencl_make_filter_params:     ## @unsharp_opencl_make_filter_params
	.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	$184, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	(%rdi), %r12
	movl	48(%r12), %edi
	callq	_av_pix_fmt_desc_get
	movl	$0, (%r12)
	cmpl	$0, (%rax)
	jle	LBB0_55
## %bb.1:
	movq	%rax, %r14
	xorl	%eax, %eax
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_2:                                 ## =>This Inner Loop Header: Depth=1
	movq	8(%r14), %rcx
	movq	(%rcx,%rbx,8), %rsi
	incq	%rsi
	movl	%eax, %edi
	callq	_FFMAX
                                        ## kill: def $eax killed $eax def $rax
	movl	%eax, (%r12)
	incq	%rbx
	movslq	(%r14), %rcx
	cmpq	%rcx, %rbx
	jl	LBB0_2
## %bb.3:
	testl	%eax, %eax
	jle	LBB0_55
## %bb.4:
	leaq	16(%r12), %rax
	movq	%rax, -208(%rbp)                ## 8-byte Spill
	leaq	20(%r12), %rax
	movq	%rax, -200(%rbp)                ## 8-byte Spill
	leaq	24(%r12), %rax
	movq	%rax, -192(%rbp)                ## 8-byte Spill
	leaq	4(%r12), %rax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	leaq	8(%r12), %rax
	movq	%rax, -160(%rbp)                ## 8-byte Spill
	leaq	12(%r12), %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	xorl	%r13d, %r13d
	movq	%r12, -144(%rbp)                ## 8-byte Spill
	movq	%r14, -136(%rbp)                ## 8-byte Spill
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_53:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	32(%r12), %rax
	imulq	$56, %r13, %r14
	movq	(%rax,%r14), %rcx
	movl	$8, %edx
	leaq	-48(%rbp), %r8
	callq	_clCreateBuffer
	movq	%rax, %rbx
	movq	_EIO@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_AVERROR
	movl	-48(%rbp), %edx
	movl	%eax, %edi
	leaq	L_.str.1(%rip), %rsi
	callq	_CL_FAIL_ON_ERROR
	movq	32(%r12), %rax
	movq	%rbx, 40(%rax,%r14)
	movq	40(%r12), %rcx
	movq	_CL_MEM_COPY_HOST_PTR@GOTPCREL(%rip), %rdx
	movl	(%rdx), %esi
	orl	(%r15), %esi
	movl	(%rcx), %edi
	movq	_CL_MEM_HOST_NO_ACCESS@GOTPCREL(%rip), %rcx
	orl	(%rcx), %esi
	movq	8(%rax,%r14), %rcx
	movl	$8, %edx
	leaq	-48(%rbp), %r8
	callq	_clCreateBuffer
	movq	%rax, %rbx
	movq	_EIO@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_AVERROR
	movl	-48(%rbp), %edx
	movl	%eax, %edi
	leaq	L_.str.2(%rip), %rsi
	callq	_CL_FAIL_ON_ERROR
	movq	32(%r12), %rax
	movq	%rbx, 32(%rax,%r14)
LBB0_54:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	-136(%rbp), %r14                ## 8-byte Reload
	leaq	-184(%rbp), %rdi
	callq	_av_freep
	movq	32(%r12), %rax
	imulq	$56, %r13, %rcx
	movl	-44(%rbp), %edx                 ## 4-byte Reload
	movl	%edx, 16(%rax,%rcx)
	movl	-76(%rbp), %edx                 ## 4-byte Reload
	movl	%edx, 20(%rax,%rcx)
	movss	-128(%rbp), %xmm0               ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	movss	%xmm0, 24(%rax,%rcx)
	incq	%r13
	movslq	(%r12), %rax
	cmpq	%rax, %r13
	jge	LBB0_55
LBB0_5:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_32 Depth 2
                                        ##     Child Loop BB0_30 Depth 2
                                        ##     Child Loop BB0_16 Depth 2
                                        ##     Child Loop BB0_41 Depth 2
                                        ##     Child Loop BB0_39 Depth 2
                                        ##     Child Loop BB0_22 Depth 2
                                        ##     Child Loop BB0_24 Depth 2
                                        ##       Child Loop BB0_45 Depth 3
                                        ##       Child Loop BB0_49 Depth 3
	movq	-152(%rbp), %rax                ## 8-byte Reload
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	movq	-168(%rbp), %rdx                ## 8-byte Reload
	testq	%r13, %r13
	je	LBB0_8
## %bb.6:                               ##   in Loop: Header=BB0_5 Depth=1
	movq	_AV_PIX_FMT_FLAG_RGB@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	movq	-152(%rbp), %rax                ## 8-byte Reload
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	movq	-168(%rbp), %rdx                ## 8-byte Reload
	testl	%esi, 4(%r14)
	jne	LBB0_8
## %bb.7:                               ##   in Loop: Header=BB0_5 Depth=1
	movq	-192(%rbp), %rax                ## 8-byte Reload
	movq	-200(%rbp), %rcx                ## 8-byte Reload
	movq	-208(%rbp), %rdx                ## 8-byte Reload
LBB0_8:                                 ##   in Loop: Header=BB0_5 Depth=1
	movss	(%rdx), %xmm1                   ## xmm1 = mem[0],zero,zero,zero
	movss	(%rcx), %xmm0                   ## xmm0 = mem[0],zero,zero,zero
	movss	%xmm0, -96(%rbp)                ## 4-byte Spill
	movss	(%rax), %xmm0                   ## xmm0 = mem[0],zero,zero,zero
	movss	%xmm0, -128(%rbp)               ## 4-byte Spill
	movss	%xmm1, -64(%rbp)                ## 4-byte Spill
	movapd	%xmm1, %xmm0
	callq	_ceil
	movq	%rax, %r15
	movl	%r15d, %ebx
	orl	$1, %ebx
	movss	-96(%rbp), %xmm0                ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	callq	_ceil
	movq	%rax, -176(%rbp)                ## 8-byte Spill
                                        ## kill: def $eax killed $eax killed $rax
	orl	$1, %eax
	movl	%eax, -76(%rbp)                 ## 4-byte Spill
	imull	%ebx, %eax
	movslq	%eax, %rdi
	shlq	$2, %rdi
	movq	%rdi, -216(%rbp)                ## 8-byte Spill
	callq	_av_malloc
	movq	%rax, -184(%rbp)
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	testq	%rax, %rax
	je	LBB0_57
## %bb.9:                               ##   in Loop: Header=BB0_5 Depth=1
	movl	%ebx, %r14d
	testl	%ebx, %ebx
	movl	%ebx, -44(%rbp)                 ## 4-byte Spill
	movq	%r13, -88(%rbp)                 ## 8-byte Spill
	jle	LBB0_17
## %bb.10:                              ##   in Loop: Header=BB0_5 Depth=1
	movl	%r15d, %edx
	shrl	%edx
	movss	-64(%rbp), %xmm0                ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	cvtss2sd	%xmm0, %xmm0
	movq	32(%r12), %rax
	imulq	$56, %r13, %rcx
	movq	(%rax,%rcx), %r13
	cmpl	$2, %r15d
	movq	%r15, -104(%rbp)                ## 8-byte Spill
	movq	%rcx, -112(%rbp)                ## 8-byte Spill
	movl	%edx, -124(%rbp)                ## 4-byte Spill
	movsd	%xmm0, -72(%rbp)                ## 8-byte Spill
	jae	LBB0_31
## %bb.11:                              ##   in Loop: Header=BB0_5 Depth=1
	xorps	%xmm0, %xmm0
	movaps	%xmm0, -64(%rbp)                ## 16-byte Spill
	xorl	%r12d, %r12d
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	jmp	LBB0_12
	.p2align	4, 0x90
LBB0_31:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	%edx, %ebx
	negl	%ebx
	leaq	-1(%r14), %r15
	xorps	%xmm0, %xmm0
	movaps	%xmm0, -64(%rbp)                ## 16-byte Spill
	xorl	%r12d, %r12d
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	.p2align	4, 0x90
LBB0_32:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	xorps	%xmm0, %xmm0
	cvtsi2sd	%ebx, %xmm0
	divsd	-72(%rbp), %xmm0                ## 8-byte Folded Reload
	mulsd	%xmm0, %xmm0
	mulsd	%xmm1, %xmm0
	callq	_exp
	movsd	%xmm0, (%r13,%r12,8)
	leal	1(%rbx), %eax
	xorps	%xmm1, %xmm1
	cvtsi2sd	%eax, %xmm1
	movapd	-64(%rbp), %xmm2                ## 16-byte Reload
	addsd	%xmm0, %xmm2
	movapd	%xmm2, -64(%rbp)                ## 16-byte Spill
	divsd	-72(%rbp), %xmm1                ## 8-byte Folded Reload
	mulsd	%xmm1, %xmm1
	mulsd	LCPI0_0(%rip), %xmm1
	movapd	%xmm1, %xmm0
	callq	_exp
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	movsd	%xmm0, 8(%r13,%r12,8)
	movapd	-64(%rbp), %xmm2                ## 16-byte Reload
	addsd	%xmm0, %xmm2
	movapd	%xmm2, -64(%rbp)                ## 16-byte Spill
	addq	$2, %r12
	addl	$2, %ebx
	cmpq	%r12, %r15
	jne	LBB0_32
LBB0_12:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	%r12d, %eax
	subl	-124(%rbp), %eax                ## 4-byte Folded Reload
	xorps	%xmm0, %xmm0
	cvtsi2sd	%eax, %xmm0
	divsd	-72(%rbp), %xmm0                ## 8-byte Folded Reload
	mulsd	%xmm0, %xmm0
	mulsd	%xmm1, %xmm0
	callq	_exp
	movsd	%xmm0, (%r13,%r12,8)
	movapd	-64(%rbp), %xmm3                ## 16-byte Reload
	addsd	%xmm0, %xmm3
	movq	-144(%rbp), %r12                ## 8-byte Reload
	movq	32(%r12), %rax
	movq	-112(%rbp), %rcx                ## 8-byte Reload
	movq	(%rax,%rcx), %rax
	cmpl	$2, -104(%rbp)                  ## 4-byte Folded Reload
	jae	LBB0_27
## %bb.13:                              ##   in Loop: Header=BB0_5 Depth=1
	xorl	%esi, %esi
	movq	-88(%rbp), %r13                 ## 8-byte Reload
	jmp	LBB0_16
	.p2align	4, 0x90
LBB0_27:                                ##   in Loop: Header=BB0_5 Depth=1
	movddup	%xmm3, %xmm0                    ## xmm0 = xmm3[0,0]
	leaq	-3(%r14), %rdx
	movq	%rdx, %rcx
	shrq	%rcx
	incq	%rcx
	testq	%rdx, %rdx
	je	LBB0_28
## %bb.29:                              ##   in Loop: Header=BB0_5 Depth=1
	movq	%rcx, %rsi
	andq	$-2, %rsi
	xorl	%edx, %edx
	movq	-88(%rbp), %r13                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_30:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movupd	(%rax,%rdx,8), %xmm1
	movupd	16(%rax,%rdx,8), %xmm2
	divpd	%xmm0, %xmm1
	movupd	%xmm1, (%rax,%rdx,8)
	divpd	%xmm0, %xmm2
	movupd	%xmm2, 16(%rax,%rdx,8)
	addq	$4, %rdx
	addq	$-2, %rsi
	jne	LBB0_30
	jmp	LBB0_14
LBB0_28:                                ##   in Loop: Header=BB0_5 Depth=1
	xorl	%edx, %edx
	movq	-88(%rbp), %r13                 ## 8-byte Reload
LBB0_14:                                ##   in Loop: Header=BB0_5 Depth=1
	leaq	-1(%r14), %rsi
	testb	$1, %cl
	je	LBB0_16
## %bb.15:                              ##   in Loop: Header=BB0_5 Depth=1
	movupd	(%rax,%rdx,8), %xmm1
	divpd	%xmm0, %xmm1
	movupd	%xmm1, (%rax,%rdx,8)
	.p2align	4, 0x90
LBB0_16:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movsd	(%rax,%rsi,8), %xmm0            ## xmm0 = mem[0],zero
	divsd	%xmm3, %xmm0
	movsd	%xmm0, (%rax,%rsi,8)
	incq	%rsi
	cmpq	%rsi, %r14
	jne	LBB0_16
LBB0_17:                                ##   in Loop: Header=BB0_5 Depth=1
	cmpl	$0, -76(%rbp)                   ## 4-byte Folded Reload
	jle	LBB0_51
## %bb.18:                              ##   in Loop: Header=BB0_5 Depth=1
	movq	-176(%rbp), %rdx                ## 8-byte Reload
	movl	%edx, %esi
	shrl	%esi
	movss	-96(%rbp), %xmm0                ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	cvtss2sd	%xmm0, %xmm0
	movq	32(%r12), %rax
	imulq	$56, %r13, %rcx
	movq	%rcx, -104(%rbp)                ## 8-byte Spill
	movq	8(%rax,%rcx), %r13
	movl	-76(%rbp), %eax                 ## 4-byte Reload
	cmpl	$2, %edx
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	movl	%esi, -112(%rbp)                ## 4-byte Spill
	movsd	%xmm0, -96(%rbp)                ## 8-byte Spill
	jae	LBB0_40
## %bb.19:                              ##   in Loop: Header=BB0_5 Depth=1
	xorps	%xmm0, %xmm0
	movaps	%xmm0, -64(%rbp)                ## 16-byte Spill
	xorl	%r15d, %r15d
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	jmp	LBB0_20
	.p2align	4, 0x90
LBB0_40:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	%esi, %ebx
	negl	%ebx
	leaq	-1(%rax), %r12
	xorps	%xmm0, %xmm0
	movaps	%xmm0, -64(%rbp)                ## 16-byte Spill
	xorl	%r15d, %r15d
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	.p2align	4, 0x90
LBB0_41:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	xorps	%xmm0, %xmm0
	cvtsi2sd	%ebx, %xmm0
	divsd	-96(%rbp), %xmm0                ## 8-byte Folded Reload
	mulsd	%xmm0, %xmm0
	mulsd	%xmm1, %xmm0
	callq	_exp
	movsd	%xmm0, (%r13,%r15,8)
	leal	1(%rbx), %eax
	xorps	%xmm1, %xmm1
	cvtsi2sd	%eax, %xmm1
	movapd	-64(%rbp), %xmm2                ## 16-byte Reload
	addsd	%xmm0, %xmm2
	movapd	%xmm2, -64(%rbp)                ## 16-byte Spill
	divsd	-96(%rbp), %xmm1                ## 8-byte Folded Reload
	mulsd	%xmm1, %xmm1
	mulsd	LCPI0_0(%rip), %xmm1
	movapd	%xmm1, %xmm0
	callq	_exp
	movsd	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero
	movsd	%xmm0, 8(%r13,%r15,8)
	movapd	-64(%rbp), %xmm2                ## 16-byte Reload
	addsd	%xmm0, %xmm2
	movapd	%xmm2, -64(%rbp)                ## 16-byte Spill
	addq	$2, %r15
	addl	$2, %ebx
	cmpq	%r15, %r12
	jne	LBB0_41
LBB0_20:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	%r15d, %eax
	subl	-112(%rbp), %eax                ## 4-byte Folded Reload
	xorps	%xmm0, %xmm0
	cvtsi2sd	%eax, %xmm0
	divsd	-96(%rbp), %xmm0                ## 8-byte Folded Reload
	mulsd	%xmm0, %xmm0
	mulsd	%xmm1, %xmm0
	callq	_exp
	movsd	%xmm0, (%r13,%r15,8)
	movapd	-64(%rbp), %xmm3                ## 16-byte Reload
	addsd	%xmm0, %xmm3
	movq	-144(%rbp), %r12                ## 8-byte Reload
	movq	32(%r12), %rax
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	movq	8(%rax,%rcx), %rax
	cmpl	$2, -176(%rbp)                  ## 4-byte Folded Reload
	jae	LBB0_36
## %bb.21:                              ##   in Loop: Header=BB0_5 Depth=1
	xorl	%esi, %esi
	movq	-88(%rbp), %r13                 ## 8-byte Reload
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_22
	.p2align	4, 0x90
LBB0_36:                                ##   in Loop: Header=BB0_5 Depth=1
	movddup	%xmm3, %xmm0                    ## xmm0 = xmm3[0,0]
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	leaq	-3(%rdi), %rdx
	movq	%rdx, %rcx
	shrq	%rcx
	incq	%rcx
	testq	%rdx, %rdx
	je	LBB0_37
## %bb.38:                              ##   in Loop: Header=BB0_5 Depth=1
	movq	%rcx, %rsi
	andq	$-2, %rsi
	xorl	%edx, %edx
	movq	-88(%rbp), %r13                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_39:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movupd	(%rax,%rdx,8), %xmm1
	movupd	16(%rax,%rdx,8), %xmm2
	divpd	%xmm0, %xmm1
	movupd	%xmm1, (%rax,%rdx,8)
	divpd	%xmm0, %xmm2
	movupd	%xmm2, 16(%rax,%rdx,8)
	addq	$4, %rdx
	addq	$-2, %rsi
	jne	LBB0_39
	jmp	LBB0_33
LBB0_37:                                ##   in Loop: Header=BB0_5 Depth=1
	xorl	%edx, %edx
	movq	-88(%rbp), %r13                 ## 8-byte Reload
LBB0_33:                                ##   in Loop: Header=BB0_5 Depth=1
	leaq	-1(%rdi), %rsi
	testb	$1, %cl
	je	LBB0_35
## %bb.34:                              ##   in Loop: Header=BB0_5 Depth=1
	movupd	(%rax,%rdx,8), %xmm1
	divpd	%xmm0, %xmm1
	movupd	%xmm1, (%rax,%rdx,8)
LBB0_35:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	.p2align	4, 0x90
LBB0_22:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movsd	(%rax,%rsi,8), %xmm0            ## xmm0 = mem[0],zero
	divsd	%xmm3, %xmm0
	movsd	%xmm0, (%rax,%rsi,8)
	incq	%rsi
	cmpq	%rsi, %rdi
	jne	LBB0_22
## %bb.23:                              ##   in Loop: Header=BB0_5 Depth=1
	movslq	%ecx, %rsi
	movl	%r14d, %r15d
	andl	$-4, %r15d
	leaq	-4(%r15), %r10
	movq	%r10, %r11
	shrq	$2, %r11
	incq	%r11
	movq	%r11, %r9
	andq	$-2, %r9
	movq	-120(%rbp), %rdx                ## 8-byte Reload
	movq	%rdx, %rax
	addq	$24, %rax
	movq	%rsi, -64(%rbp)                 ## 8-byte Spill
	leaq	(,%rsi,4), %rdi
	xorl	%esi, %esi
	jmp	LBB0_24
	.p2align	4, 0x90
LBB0_50:                                ##   in Loop: Header=BB0_24 Depth=2
	incq	%rsi
	addq	%rdi, %rax
	addq	%rdi, %rdx
	cmpq	-72(%rbp), %rsi                 ## 8-byte Folded Reload
	je	LBB0_51
LBB0_24:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_45 Depth 3
                                        ##       Child Loop BB0_49 Depth 3
	testl	%ecx, %ecx
	jle	LBB0_50
## %bb.25:                              ##   in Loop: Header=BB0_24 Depth=2
	movq	32(%r12), %rcx
	movq	-104(%rbp), %rbx                ## 8-byte Reload
	movq	(%rcx,%rbx), %r8
	movq	8(%rcx,%rbx), %rcx
	movsd	(%rcx,%rsi,8), %xmm0            ## xmm0 = mem[0],zero
	cmpl	$4, -44(%rbp)                   ## 4-byte Folded Reload
	jae	LBB0_42
## %bb.26:                              ##   in Loop: Header=BB0_24 Depth=2
	xorl	%ebx, %ebx
	jmp	LBB0_48
	.p2align	4, 0x90
LBB0_42:                                ##   in Loop: Header=BB0_24 Depth=2
	movddup	%xmm0, %xmm1                    ## xmm1 = xmm0[0,0]
	testq	%r10, %r10
	je	LBB0_43
## %bb.44:                              ##   in Loop: Header=BB0_24 Depth=2
	movq	%r9, %rbx
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_45:                                ##   Parent Loop BB0_5 Depth=1
                                        ##     Parent Loop BB0_24 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movupd	(%r8,%rcx,8), %xmm2
	movupd	16(%r8,%rcx,8), %xmm3
	mulpd	%xmm1, %xmm2
	mulpd	%xmm1, %xmm3
	cvtpd2ps	%xmm2, %xmm2
	cvtpd2ps	%xmm3, %xmm3
	unpcklpd	%xmm3, %xmm2                    ## xmm2 = xmm2[0],xmm3[0]
	movupd	%xmm2, -24(%rax,%rcx,4)
	movupd	32(%r8,%rcx,8), %xmm2
	movupd	48(%r8,%rcx,8), %xmm3
	mulpd	%xmm1, %xmm2
	mulpd	%xmm1, %xmm3
	cvtpd2ps	%xmm2, %xmm2
	cvtpd2ps	%xmm3, %xmm3
	unpcklpd	%xmm3, %xmm2                    ## xmm2 = xmm2[0],xmm3[0]
	movupd	%xmm2, -8(%rax,%rcx,4)
	addq	$8, %rcx
	addq	$-2, %rbx
	jne	LBB0_45
	jmp	LBB0_46
LBB0_43:                                ##   in Loop: Header=BB0_24 Depth=2
	xorl	%ecx, %ecx
LBB0_46:                                ##   in Loop: Header=BB0_24 Depth=2
	movq	%r15, %rbx
	testb	$1, %r11b
	je	LBB0_48
## %bb.47:                              ##   in Loop: Header=BB0_24 Depth=2
	movq	%rsi, %rbx
	movupd	(%r8,%rcx,8), %xmm2
	movupd	16(%r8,%rcx,8), %xmm3
	mulpd	%xmm1, %xmm2
	mulpd	%xmm1, %xmm3
	cvtpd2ps	%xmm2, %xmm1
	cvtpd2ps	%xmm3, %xmm2
	imulq	-64(%rbp), %rbx                 ## 8-byte Folded Reload
	unpcklpd	%xmm2, %xmm1                    ## xmm1 = xmm1[0],xmm2[0]
	addq	%rcx, %rbx
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	movupd	%xmm1, (%rcx,%rbx,4)
	movq	%r15, %rbx
LBB0_48:                                ##   in Loop: Header=BB0_24 Depth=2
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	.p2align	4, 0x90
LBB0_49:                                ##   Parent Loop BB0_5 Depth=1
                                        ##     Parent Loop BB0_24 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movsd	(%r8,%rbx,8), %xmm1             ## xmm1 = mem[0],zero
	mulsd	%xmm0, %xmm1
	cvtsd2ss	%xmm1, %xmm1
	movss	%xmm1, (%rdx,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r14
	jne	LBB0_49
	jmp	LBB0_50
	.p2align	4, 0x90
LBB0_51:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	_CL_MEM_COPY_HOST_PTR@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	movq	_CL_MEM_READ_ONLY@GOTPCREL(%rip), %r15
	orl	(%r15), %esi
	movq	_CL_MEM_HOST_NO_ACCESS@GOTPCREL(%rip), %rax
	orl	(%rax), %esi
	cmpq	$0, 56(%r12)
	movq	40(%r12), %rax
	movl	(%rax), %edi
	je	LBB0_53
## %bb.52:                              ##   in Loop: Header=BB0_5 Depth=1
	movq	-216(%rbp), %rdx                ## 8-byte Reload
                                        ## kill: def $edx killed $edx killed $rdx
	movq	-120(%rbp), %rcx                ## 8-byte Reload
	leaq	-48(%rbp), %r8
	callq	_clCreateBuffer
	movq	%rax, %rbx
	movq	_EIO@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_AVERROR
	movl	-48(%rbp), %edx
	movl	%eax, %edi
	leaq	L_.str(%rip), %rsi
	callq	_CL_FAIL_ON_ERROR
	movq	32(%r12), %rax
	imulq	$56, %r13, %rcx
	movq	%rbx, 48(%rax,%rcx)
	jmp	LBB0_54
LBB0_55:
	xorl	%ebx, %ebx
	jmp	LBB0_56
LBB0_57:
	movq	_ENOMEM@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_AVERROR
	movl	%eax, %ebx
LBB0_56:
	leaq	-184(%rbp), %rdi
	callq	_av_freep
	movl	%ebx, %eax
	addq	$184, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.comm	_AV_PIX_FMT_FLAG_RGB,4,2        ## @AV_PIX_FMT_FLAG_RGB
	.comm	_ENOMEM,4,2                     ## @ENOMEM
	.comm	_CL_MEM_READ_ONLY,4,2           ## @CL_MEM_READ_ONLY
	.comm	_CL_MEM_COPY_HOST_PTR,4,2       ## @CL_MEM_COPY_HOST_PTR
	.comm	_CL_MEM_HOST_NO_ACCESS,4,2      ## @CL_MEM_HOST_NO_ACCESS
	.comm	_EIO,4,2                        ## @EIO
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"Failed to create matrix buffer: %d.\n"

L_.str.1:                               ## @.str.1
	.asciz	"Failed to create x-coef buffer: %d.\n"

L_.str.2:                               ## @.str.2
	.asciz	"Failed to create y-coef buffer: %d.\n"

	.no_dead_strip	_unsharp_opencl_make_filter_params
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ; -- Begin function unsharp_opencl_make_filter_params
lCPI0_0:
	.long	0                               ; 0x0
	.long	1                               ; 0x1
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	2
_unsharp_opencl_make_filter_params:     ; @unsharp_opencl_make_filter_params
	.cfi_startproc
; %bb.0:
	stp	d15, d14, [sp, #-160]!          ; 16-byte Folded Spill
	.cfi_def_cfa_offset 160
	stp	d13, d12, [sp, #16]             ; 16-byte Folded Spill
	stp	d11, d10, [sp, #32]             ; 16-byte Folded Spill
	stp	d9, d8, [sp, #48]               ; 16-byte Folded Spill
	stp	x28, x27, [sp, #64]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #80]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #96]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #112]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #128]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #144]            ; 16-byte Folded Spill
	add	x29, sp, #144
	.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
	.cfi_offset b8, -104
	.cfi_offset b9, -112
	.cfi_offset b10, -120
	.cfi_offset b11, -128
	.cfi_offset b12, -136
	.cfi_offset b13, -144
	.cfi_offset b14, -152
	.cfi_offset b15, -160
	sub	sp, sp, #352
	ldr	x27, [x0]
	ldr	w0, [x27, #48]
	bl	_av_pix_fmt_desc_get
	str	wzr, [x27]
	ldr	w8, [x0]
	cmp	w8, #1
	b.lt	LBB0_51
; %bb.1:
	mov	x21, x0
	mov	w0, #0
	mov	x19, #0
LBB0_2:                                 ; =>This Inner Loop Header: Depth=1
	ldr	x8, [x21, #8]
	ldr	x8, [x8, x19, lsl #3]
	add	x1, x8, #1
	bl	_FFMAX
	str	w0, [x27]
	add	x19, x19, #1
	ldrsw	x8, [x21]
	cmp	x19, x8
	b.lt	LBB0_2
; %bb.3:
	cmp	w0, #1
	b.lt	LBB0_51
; %bb.4:
	mov	x28, #0
	add	x9, x27, #16
	add	x8, x27, #20
	stp	x8, x9, [sp, #8]                ; 16-byte Folded Spill
	add	x8, x27, #24
	str	x8, [sp]                        ; 8-byte Folded Spill
	fmov	d10, #-16.00000000
	add	x9, x27, #4
	add	x8, x27, #8
	stp	x8, x9, [sp, #64]               ; 16-byte Folded Spill
	add	x8, x27, #12
	str	x8, [sp, #56]                   ; 8-byte Folded Spill
	mov	w19, #56
Lloh0:
	adrp	x8, lCPI0_0@PAGE
Lloh1:
	ldr	d0, [x8, lCPI0_0@PAGEOFF]
	str	d0, [sp, #24]                   ; 8-byte Folded Spill
	movi.2s	v12, #2
	movi.2s	v13, #4
	movi.2s	v14, #6
	fmov.2d	v0, #-16.00000000
	str	q0, [sp, #192]                  ; 16-byte Folded Spill
	movi.2s	v15, #8
	str	x21, [sp, #40]                  ; 8-byte Folded Spill
	b	LBB0_7
LBB0_5:                                 ;   in Loop: Header=BB0_7 Depth=1
	ldr	x8, [x27, #32]
	mov	w9, #56
	mul	x19, x28, x9
	ldr	x3, [x8, x19]
	sub	x4, x29, #164
	mov	w2, #8
	mov	x24, x11
	bl	_clCreateBuffer
	mov	x23, x0
Lloh2:
	adrp	x26, _EIO@GOTPAGE
Lloh3:
	ldr	x26, [x26, _EIO@GOTPAGEOFF]
	ldr	w0, [x26]
	bl	_AVERROR
	ldur	w2, [x29, #-164]
Lloh4:
	adrp	x1, l_.str.1@PAGE
Lloh5:
	add	x1, x1, l_.str.1@PAGEOFF
	bl	_CL_FAIL_ON_ERROR
	ldp	x8, x9, [x27, #32]
	add	x8, x8, x19
	str	x23, [x8, #40]
	ldr	w0, [x9]
	ldr	w9, [x25]
	ldr	w10, [x24]
	orr	w9, w10, w9
Lloh6:
	adrp	x10, _CL_MEM_HOST_NO_ACCESS@GOTPAGE
Lloh7:
	ldr	x10, [x10, _CL_MEM_HOST_NO_ACCESS@GOTPAGEOFF]
Lloh8:
	ldr	w10, [x10]
	orr	w1, w9, w10
	ldr	x3, [x8, #8]
	sub	x4, x29, #164
	mov	w2, #8
	bl	_clCreateBuffer
	mov	x23, x0
	ldr	w0, [x26]
	bl	_AVERROR
	ldur	w2, [x29, #-164]
Lloh9:
	adrp	x1, l_.str.2@PAGE
Lloh10:
	add	x1, x1, l_.str.2@PAGEOFF
	bl	_CL_FAIL_ON_ERROR
	ldr	x8, [x27, #32]
	add	x8, x8, x19
	mov	w19, #56
	str	x23, [x8, #32]
LBB0_6:                                 ;   in Loop: Header=BB0_7 Depth=1
	sub	x0, x29, #160
	bl	_av_freep
	ldr	x8, [x27, #32]
	madd	x8, x28, x19, x8
	stp	w20, w22, [x8, #16]
	str	s11, [x8, #24]
	add	x28, x28, #1
	ldrsw	x8, [x27]
	cmp	x28, x8
	b.ge	LBB0_51
LBB0_7:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_15 Depth 2
                                        ;     Child Loop BB0_18 Depth 2
                                        ;     Child Loop BB0_22 Depth 2
                                        ;     Child Loop BB0_24 Depth 2
                                        ;     Child Loop BB0_29 Depth 2
                                        ;     Child Loop BB0_32 Depth 2
                                        ;     Child Loop BB0_36 Depth 2
                                        ;     Child Loop BB0_38 Depth 2
                                        ;     Child Loop BB0_41 Depth 2
                                        ;       Child Loop BB0_45 Depth 3
                                        ;       Child Loop BB0_48 Depth 3
	ldp	x8, x9, [sp, #56]               ; 16-byte Folded Reload
	ldr	x10, [sp, #72]                  ; 8-byte Folded Reload
	cbz	x28, LBB0_10
; %bb.8:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	w11, [x21, #4]
Lloh11:
	adrp	x8, _AV_PIX_FMT_FLAG_RGB@GOTPAGE
Lloh12:
	ldr	x8, [x8, _AV_PIX_FMT_FLAG_RGB@GOTPAGEOFF]
Lloh13:
	ldr	w12, [x8]
	ldp	x8, x9, [sp, #56]               ; 16-byte Folded Reload
	ldr	x10, [sp, #72]                  ; 8-byte Folded Reload
	tst	w12, w11
	b.ne	LBB0_10
; %bb.9:                                ;   in Loop: Header=BB0_7 Depth=1
	ldp	x8, x9, [sp]                    ; 16-byte Folded Reload
	ldr	x10, [sp, #16]                  ; 8-byte Folded Reload
LBB0_10:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	s9, [x10]
	ldr	s8, [x9]
	ldr	s11, [x8]
	fmov	s0, s9
	bl	_ceil
	mov	x26, x0
	orr	w20, w26, #0x1
	fmov	s0, s8
	bl	_ceil
	mov	x25, x0
	orr	w22, w25, #0x1
	mul	w8, w22, w20
	sbfiz	x0, x8, #2, #32
	str	x0, [sp, #48]                   ; 8-byte Folded Spill
	bl	_av_malloc
	stur	x0, [x29, #-160]
	cbz	x0, LBB0_52
; %bb.11:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x24, x0
	cmp	w20, #1
	b.lt	LBB0_25
; %bb.12:                               ;   in Loop: Header=BB0_7 Depth=1
	lsr	w10, w26, #1
	fcvt	d0, s9
	ldr	x8, [x27, #32]
	mul	x9, x28, x19
	ldr	x26, [x8, x9]
	cmp	w20, #7
	str	q0, [sp, #208]                  ; 16-byte Folded Spill
	b.hi	LBB0_14
; %bb.13:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x23, #0
	movi	d5, #0000000000000000
	b	LBB0_17
LBB0_14:                                ;   in Loop: Header=BB0_7 Depth=1
	str	s11, [sp, #36]                  ; 4-byte Folded Spill
	and	x23, x20, #0xfffffff8
	str	w10, [sp, #32]                  ; 4-byte Folded Spill
	dup.2s	v9, w10
	dup.2d	v0, v0[0]
	str	q0, [sp, #80]                   ; 16-byte Folded Spill
	add	x19, x26, #32
	movi	d5, #0000000000000000
	mov	x21, x23
	ldr	d11, [sp, #24]                  ; 8-byte Folded Reload
LBB0_15:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	stur	q5, [x29, #-192]                ; 16-byte Folded Spill
	sub.2s	v0, v11, v9
	add.2s	v1, v0, v12
	add.2s	v2, v0, v13
	add.2s	v3, v0, v14
	sshll.2d	v0, v0, #0
	scvtf.2d	v0, v0
	sshll.2d	v1, v1, #0
	scvtf.2d	v1, v1
	sshll.2d	v2, v2, #0
	scvtf.2d	v2, v2
	sshll.2d	v3, v3, #0
	scvtf.2d	v3, v3
	ldr	q4, [sp, #80]                   ; 16-byte Folded Reload
	fdiv.2d	v0, v0, v4
	fdiv.2d	v1, v1, v4
	fdiv.2d	v2, v2, v4
	fdiv.2d	v3, v3, v4
	fmul.2d	v0, v0, v0
	fmul.2d	v1, v1, v1
	fmul.2d	v2, v2, v2
	fmul.2d	v3, v3, v3
	ldr	q4, [sp, #192]                  ; 16-byte Folded Reload
	fmul.2d	v5, v0, v4
	stur	q5, [x29, #-240]                ; 16-byte Folded Spill
	fmul.2d	v6, v1, v4
	fmul.2d	v0, v2, v4
	stp	q6, q0, [sp, #224]              ; 32-byte Folded Spill
	fmul.2d	v0, v3, v4
	stur	q0, [x29, #-224]                ; 16-byte Folded Spill
	mov	d0, v5[1]
	bl	_exp
	stur	q0, [x29, #-208]                ; 16-byte Folded Spill
	ldur	q0, [x29, #-240]                ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #160]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldur	q0, [x29, #-208]                ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #176]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	stur	q0, [x29, #-240]                ; 16-byte Folded Spill
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #128]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldur	q0, [x29, #-240]                ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #144]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #240]                  ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	str	q0, [sp, #224]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #240]                  ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #112]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #240]                  ; 16-byte Folded Spill
	ldur	q0, [x29, #-224]                ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	str	q0, [sp, #96]                   ; 16-byte Folded Spill
	ldur	q0, [x29, #-224]                ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	ldur	q1, [x29, #-192]                ; 16-byte Folded Reload
	ldr	q2, [sp, #160]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldur	q2, [x29, #-208]                ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldr	q2, [sp, #128]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldur	q2, [x29, #-240]                ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldp	q3, q2, [sp, #96]               ; 32-byte Folded Reload
	fadd	d1, d1, d2
	ldr	q2, [sp, #224]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	fadd	d1, d1, d0
	mov.d	v0[1], v3[0]
	ldr	q4, [sp, #176]                  ; 16-byte Folded Reload
	ldr	q2, [sp, #144]                  ; 16-byte Folded Reload
	stp	q4, q2, [x19, #-32]
	ldr	q2, [sp, #240]                  ; 16-byte Folded Reload
	stp	q2, q0, [x19], #64
	fadd	d5, d1, d3
	add.2s	v11, v11, v15
	subs	x21, x21, #8
	b.ne	LBB0_15
; %bb.16:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x21, [sp, #40]                  ; 8-byte Folded Reload
	ldr	s11, [sp, #36]                  ; 4-byte Folded Reload
	ldr	w10, [sp, #32]                  ; 4-byte Folded Reload
LBB0_17:                                ;   in Loop: Header=BB0_7 Depth=1
	neg	w19, w10
LBB0_18:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	stur	q5, [x29, #-192]                ; 16-byte Folded Spill
	add	w8, w19, w23
	scvtf	d0, w8
	ldr	q1, [sp, #208]                  ; 16-byte Folded Reload
	fdiv	d0, d0, d1
	fmul	d0, d0, d0
	fmul	d0, d0, d10
	bl	_exp
	ldur	q5, [x29, #-192]                ; 16-byte Folded Reload
	str	d0, [x26, x23, lsl #3]
	fadd	d5, d5, d0
	add	x23, x23, #1
	cmp	x20, x23
	b.ne	LBB0_18
; %bb.19:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x8, [x27, #32]
	mov	w19, #56
	mul	x9, x28, x19
	ldr	x8, [x8, x9]
	cmp	w20, #7
	b.hi	LBB0_21
; %bb.20:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x9, #0
	b	LBB0_23
LBB0_21:                                ;   in Loop: Header=BB0_7 Depth=1
	and	x9, x20, #0xfffffff8
	dup.2d	v0, v5[0]
	add	x10, x8, #32
	mov	x11, x9
LBB0_22:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	q1, q2, [x10, #-32]
	ldp	q3, q4, [x10]
	fdiv.2d	v1, v1, v0
	fdiv.2d	v2, v2, v0
	fdiv.2d	v3, v3, v0
	fdiv.2d	v4, v4, v0
	stp	q1, q2, [x10, #-32]
	stp	q3, q4, [x10], #64
	subs	x11, x11, #8
	b.ne	LBB0_22
LBB0_23:                                ;   in Loop: Header=BB0_7 Depth=1
	add	x8, x8, x9, lsl #3
	sub	x9, x20, x9
LBB0_24:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	d0, [x8]
	fdiv	d0, d0, d5
	str	d0, [x8], #8
	subs	x9, x9, #1
	b.ne	LBB0_24
LBB0_25:                                ;   in Loop: Header=BB0_7 Depth=1
	cmp	w22, #1
	b.lt	LBB0_49
; %bb.26:                               ;   in Loop: Header=BB0_7 Depth=1
	lsr	w23, w25, #1
	fcvt	d0, s8
	ldr	x8, [x27, #32]
	madd	x8, x28, x19, x8
	ldr	x25, [x8, #8]
	cmp	w22, #7
	str	q0, [sp, #208]                  ; 16-byte Folded Spill
	b.hi	LBB0_28
; %bb.27:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x26, #0
	movi	d5, #0000000000000000
	b	LBB0_31
LBB0_28:                                ;   in Loop: Header=BB0_7 Depth=1
	and	x26, x22, #0xfffffff8
	dup.2s	v8, w23
	dup.2d	v0, v0[0]
	str	q0, [sp, #80]                   ; 16-byte Folded Spill
Lloh14:
	adrp	x8, lCPI0_0@PAGE
Lloh15:
	ldr	d9, [x8, lCPI0_0@PAGEOFF]
	add	x19, x25, #32
	movi	d5, #0000000000000000
	mov	x21, x26
LBB0_29:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	stur	q5, [x29, #-192]                ; 16-byte Folded Spill
	sub.2s	v0, v9, v8
	add.2s	v1, v0, v12
	add.2s	v2, v0, v13
	add.2s	v3, v0, v14
	sshll.2d	v0, v0, #0
	scvtf.2d	v0, v0
	sshll.2d	v1, v1, #0
	scvtf.2d	v1, v1
	sshll.2d	v2, v2, #0
	scvtf.2d	v2, v2
	sshll.2d	v3, v3, #0
	scvtf.2d	v3, v3
	ldr	q4, [sp, #80]                   ; 16-byte Folded Reload
	fdiv.2d	v0, v0, v4
	fdiv.2d	v1, v1, v4
	fdiv.2d	v2, v2, v4
	fdiv.2d	v3, v3, v4
	fmul.2d	v0, v0, v0
	fmul.2d	v1, v1, v1
	fmul.2d	v2, v2, v2
	fmul.2d	v3, v3, v3
	ldr	q4, [sp, #192]                  ; 16-byte Folded Reload
	fmul.2d	v5, v0, v4
	stur	q5, [x29, #-240]                ; 16-byte Folded Spill
	fmul.2d	v6, v1, v4
	fmul.2d	v0, v2, v4
	stp	q6, q0, [sp, #224]              ; 32-byte Folded Spill
	fmul.2d	v0, v3, v4
	stur	q0, [x29, #-224]                ; 16-byte Folded Spill
	mov	d0, v5[1]
	bl	_exp
	stur	q0, [x29, #-208]                ; 16-byte Folded Spill
	ldur	q0, [x29, #-240]                ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #160]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldur	q0, [x29, #-208]                ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #176]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	stur	q0, [x29, #-240]                ; 16-byte Folded Spill
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #128]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldur	q0, [x29, #-240]                ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #144]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #240]                  ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	str	q0, [sp, #224]                  ; 16-byte Folded Spill
	ldr	q0, [sp, #240]                  ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	str	q0, [sp, #112]                  ; 16-byte Folded Spill
	mov.16b	v1, v0
	ldr	q0, [sp, #224]                  ; 16-byte Folded Reload
	mov.d	v1[1], v0[0]
	str	q1, [sp, #240]                  ; 16-byte Folded Spill
	ldur	q0, [x29, #-224]                ; 16-byte Folded Reload
	mov	d0, v0[1]
	bl	_exp
	str	q0, [sp, #96]                   ; 16-byte Folded Spill
	ldur	q0, [x29, #-224]                ; 16-byte Folded Reload
                                        ; kill: def $d0 killed $d0 killed $q0
	bl	_exp
                                        ; kill: def $d0 killed $d0 def $q0
	ldur	q1, [x29, #-192]                ; 16-byte Folded Reload
	ldr	q2, [sp, #160]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldur	q2, [x29, #-208]                ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldr	q2, [sp, #128]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldur	q2, [x29, #-240]                ; 16-byte Folded Reload
	fadd	d1, d1, d2
	ldp	q3, q2, [sp, #96]               ; 32-byte Folded Reload
	fadd	d1, d1, d2
	ldr	q2, [sp, #224]                  ; 16-byte Folded Reload
	fadd	d1, d1, d2
	fadd	d1, d1, d0
	mov.d	v0[1], v3[0]
	ldr	q4, [sp, #176]                  ; 16-byte Folded Reload
	ldr	q2, [sp, #144]                  ; 16-byte Folded Reload
	stp	q4, q2, [x19, #-32]
	ldr	q2, [sp, #240]                  ; 16-byte Folded Reload
	stp	q2, q0, [x19], #64
	fadd	d5, d1, d3
	add.2s	v9, v9, v15
	subs	x21, x21, #8
	b.ne	LBB0_29
; %bb.30:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x21, [sp, #40]                  ; 8-byte Folded Reload
LBB0_31:                                ;   in Loop: Header=BB0_7 Depth=1
	neg	w19, w23
LBB0_32:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	stur	q5, [x29, #-192]                ; 16-byte Folded Spill
	add	w8, w19, w26
	scvtf	d0, w8
	ldr	q1, [sp, #208]                  ; 16-byte Folded Reload
	fdiv	d0, d0, d1
	fmul	d0, d0, d0
	fmul	d0, d0, d10
	bl	_exp
	ldur	q5, [x29, #-192]                ; 16-byte Folded Reload
	str	d0, [x25, x26, lsl #3]
	fadd	d5, d5, d0
	add	x26, x26, #1
	cmp	x22, x26
	b.ne	LBB0_32
; %bb.33:                               ;   in Loop: Header=BB0_7 Depth=1
	ldr	x8, [x27, #32]
	mov	w19, #56
	madd	x8, x28, x19, x8
	ldr	x8, [x8, #8]
	cmp	w22, #7
	b.hi	LBB0_35
; %bb.34:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x9, #0
	b	LBB0_37
LBB0_35:                                ;   in Loop: Header=BB0_7 Depth=1
	and	x9, x22, #0xfffffff8
	dup.2d	v0, v5[0]
	add	x10, x8, #32
	mov	x11, x9
LBB0_36:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	q1, q2, [x10, #-32]
	ldp	q3, q4, [x10]
	fdiv.2d	v1, v1, v0
	fdiv.2d	v2, v2, v0
	fdiv.2d	v3, v3, v0
	fdiv.2d	v4, v4, v0
	stp	q1, q2, [x10, #-32]
	stp	q3, q4, [x10], #64
	subs	x11, x11, #8
	b.ne	LBB0_36
LBB0_37:                                ;   in Loop: Header=BB0_7 Depth=1
	add	x8, x8, x9, lsl #3
	sub	x9, x22, x9
LBB0_38:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	d0, [x8]
	fdiv	d0, d0, d5
	str	d0, [x8], #8
	subs	x9, x9, #1
	b.ne	LBB0_38
; %bb.39:                               ;   in Loop: Header=BB0_7 Depth=1
	mov	x8, #0
	mov	x13, x20
	sxtw	x10, w13
	and	x11, x13, #0xfffffff8
	add	x12, x24, #16
	sbfiz	x13, x13, #2, #32
	b	LBB0_41
LBB0_40:                                ;   in Loop: Header=BB0_41 Depth=2
	add	x9, x9, #1
	add	x12, x12, x13
	add	x8, x8, x10
	cmp	x9, x22
	b.eq	LBB0_49
LBB0_41:                                ;   Parent Loop BB0_7 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_45 Depth 3
                                        ;       Child Loop BB0_48 Depth 3
	cmp	w20, #1
	b.lt	LBB0_40
; %bb.42:                               ;   in Loop: Header=BB0_41 Depth=2
	ldr	x14, [x27, #32]
	madd	x15, x28, x19, x14
	ldp	x14, x15, [x15]
	ldr	d0, [x15, x9, lsl #3]
	cmp	w20, #8
	b.hs	LBB0_44
; %bb.43:                               ;   in Loop: Header=BB0_41 Depth=2
	mov	x16, #0
	b	LBB0_47
LBB0_44:                                ;   in Loop: Header=BB0_41 Depth=2
	dup.2d	v1, v0[0]
	add	x15, x14, #32
	mov	x16, x12
	mov	x17, x11
LBB0_45:                                ;   Parent Loop BB0_7 Depth=1
                                        ;     Parent Loop BB0_41 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldp	q2, q3, [x15, #-32]
	ldp	q4, q5, [x15], #64
	fmul.2d	v2, v2, v1
	fmul.2d	v3, v3, v1
	fmul.2d	v4, v4, v1
	fmul.2d	v5, v5, v0[0]
	fcvtn	v2.2s, v2.2d
	fcvtn	v3.2s, v3.2d
	fcvtn	v4.2s, v4.2d
	fcvtn	v5.2s, v5.2d
	stp	d2, d3, [x16, #-16]
	stp	d4, d5, [x16], #32
	subs	x17, x17, #8
	b.ne	LBB0_45
; %bb.46:                               ;   in Loop: Header=BB0_41 Depth=2
	mov	x16, x11
LBB0_47:                                ;   in Loop: Header=BB0_41 Depth=2
	add	x15, x16, x8
	add	x15, x24, x15, lsl #2
	add	x14, x14, x16, lsl #3
	sub	x16, x20, x16
LBB0_48:                                ;   Parent Loop BB0_7 Depth=1
                                        ;     Parent Loop BB0_41 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	d1, [x14], #8
	fmul	d1, d1, d0
	fcvt	s1, d1
	str	s1, [x15], #4
	subs	x16, x16, #1
	b.ne	LBB0_48
	b	LBB0_40
LBB0_49:                                ;   in Loop: Header=BB0_7 Depth=1
	ldr	x8, [x27, #56]
	ldr	x9, [x27, #40]
	ldr	w0, [x9]
Lloh16:
	adrp	x25, _CL_MEM_READ_ONLY@GOTPAGE
Lloh17:
	ldr	x25, [x25, _CL_MEM_READ_ONLY@GOTPAGEOFF]
	ldr	w9, [x25]
Lloh18:
	adrp	x11, _CL_MEM_COPY_HOST_PTR@GOTPAGE
Lloh19:
	ldr	x11, [x11, _CL_MEM_COPY_HOST_PTR@GOTPAGEOFF]
	ldr	w10, [x11]
	orr	w9, w10, w9
Lloh20:
	adrp	x10, _CL_MEM_HOST_NO_ACCESS@GOTPAGE
Lloh21:
	ldr	x10, [x10, _CL_MEM_HOST_NO_ACCESS@GOTPAGEOFF]
Lloh22:
	ldr	w10, [x10]
	orr	w1, w9, w10
	cbz	x8, LBB0_5
; %bb.50:                               ;   in Loop: Header=BB0_7 Depth=1
	sub	x4, x29, #164
	ldr	x2, [sp, #48]                   ; 8-byte Folded Reload
                                        ; kill: def $w2 killed $w2 killed $x2
	mov	x3, x24
	bl	_clCreateBuffer
	mov	x23, x0
Lloh23:
	adrp	x8, _EIO@GOTPAGE
Lloh24:
	ldr	x8, [x8, _EIO@GOTPAGEOFF]
Lloh25:
	ldr	w0, [x8]
	bl	_AVERROR
	ldur	w2, [x29, #-164]
Lloh26:
	adrp	x1, l_.str@PAGE
Lloh27:
	add	x1, x1, l_.str@PAGEOFF
	bl	_CL_FAIL_ON_ERROR
	ldr	x8, [x27, #32]
	madd	x8, x28, x19, x8
	str	x23, [x8, #48]
	b	LBB0_6
LBB0_51:
	mov	w19, #0
	b	LBB0_53
LBB0_52:
Lloh28:
	adrp	x8, _ENOMEM@GOTPAGE
Lloh29:
	ldr	x8, [x8, _ENOMEM@GOTPAGEOFF]
Lloh30:
	ldr	w0, [x8]
	bl	_AVERROR
	mov	x19, x0
LBB0_53:
	sub	x0, x29, #160
	bl	_av_freep
	mov	x0, x19
	add	sp, sp, #352
	ldp	x29, x30, [sp, #144]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #128]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #112]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #96]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #80]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #64]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #48]               ; 16-byte Folded Reload
	ldp	d11, d10, [sp, #32]             ; 16-byte Folded Reload
	ldp	d13, d12, [sp, #16]             ; 16-byte Folded Reload
	ldp	d15, d14, [sp], #160            ; 16-byte Folded Reload
	ret
	.loh AdrpLdr	Lloh0, Lloh1
	.loh AdrpAdd	Lloh9, Lloh10
	.loh AdrpLdrGotLdr	Lloh6, Lloh7, Lloh8
	.loh AdrpAdd	Lloh4, Lloh5
	.loh AdrpLdrGot	Lloh2, Lloh3
	.loh AdrpLdrGotLdr	Lloh11, Lloh12, Lloh13
	.loh AdrpLdr	Lloh14, Lloh15
	.loh AdrpLdrGotLdr	Lloh20, Lloh21, Lloh22
	.loh AdrpLdrGot	Lloh18, Lloh19
	.loh AdrpLdrGot	Lloh16, Lloh17
	.loh AdrpAdd	Lloh26, Lloh27
	.loh AdrpLdrGotLdr	Lloh23, Lloh24, Lloh25
	.loh AdrpLdrGotLdr	Lloh28, Lloh29, Lloh30
	.cfi_endproc
                                        ; -- End function
	.comm	_AV_PIX_FMT_FLAG_RGB,4,2        ; @AV_PIX_FMT_FLAG_RGB
	.comm	_ENOMEM,4,2                     ; @ENOMEM
	.comm	_CL_MEM_READ_ONLY,4,2           ; @CL_MEM_READ_ONLY
	.comm	_CL_MEM_COPY_HOST_PTR,4,2       ; @CL_MEM_COPY_HOST_PTR
	.comm	_CL_MEM_HOST_NO_ACCESS,4,2      ; @CL_MEM_HOST_NO_ACCESS
	.comm	_EIO,4,2                        ; @EIO
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"Failed to create matrix buffer: %d.\n"

l_.str.1:                               ; @.str.1
	.asciz	"Failed to create x-coef buffer: %d.\n"

l_.str.2:                               ; @.str.2
	.asciz	"Failed to create y-coef buffer: %d.\n"

	.no_dead_strip	_unsharp_opencl_make_filter_params
.subsections_via_symbols
