	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal4,4byte_literals
	.p2align	2                               ## -- Begin function filter_plane3d2
LCPI0_0:
	.long	0x3f800000                      ## float 1
LCPI0_1:
	.long	0x3f5db3d7                      ## float 0.866025388
LCPI0_2:
	.long	0xbf000000                      ## float -0.5
LCPI0_3:
	.long	0x26901d7d                      ## float 1.0E-15
LCPI0_4:
	.long	0x3eaaaaab                      ## float 0.333333343
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_filter_plane3d2:                       ## @filter_plane3d2
	.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	$168, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rcx, -144(%rbp)                ## 8-byte Spill
	movq	%rdx, -136(%rbp)                ## 8-byte Spill
	movq	8(%rdi), %rax
	movslq	%esi, %rcx
	leaq	(%rcx,%rcx,2), %rcx
	movl	8(%rax,%rcx,8), %edx
	movq	%rdx, -152(%rbp)                ## 8-byte Spill
	testl	%edx, %edx
	jle	LBB0_11
## %bb.1:
	movl	(%rax,%rcx,8), %ebx
	movl	(%rdi), %edx
	imull	%ebx, %edx
	imull	%edx, %edx
	cvtsi2ss	%edx, %xmm8
	movss	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	subss	4(%rdi), %xmm1
	movq	16(%rax,%rcx,8), %rdx
	movq	_CURRENT@GOTPCREL(%rip), %rsi
	movq	(%rsi), %rsi
	movq	(%rdx,%rsi,8), %rdx
	movq	%rdx, -128(%rbp)                ## 8-byte Spill
	movl	4(%rax,%rcx,8), %edx
	movq	%rdx, -112(%rbp)                ## 8-byte Spill
	movl	12(%rax,%rcx,8), %eax
	sarl	$2, %eax
	leal	(%rbx,%rbx), %ecx
	movl	%ecx, -96(%rbp)                 ## 4-byte Spill
	cltq
	movl	%eax, %ecx
	imull	%ebx, %ecx
	movl	%ecx, -92(%rbp)                 ## 4-byte Spill
	shlq	$2, %rax
	movq	%rax, -200(%rbp)                ## 8-byte Spill
	movq	%rbx, -120(%rbp)                ## 8-byte Spill
	leaq	(,%rbx,8), %r12
	xorl	%eax, %eax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movss	LCPI0_1(%rip), %xmm11           ## xmm11 = mem[0],zero,zero,zero
	movss	LCPI0_2(%rip), %xmm9            ## xmm9 = mem[0],zero,zero,zero
	movss	LCPI0_3(%rip), %xmm10           ## xmm10 = mem[0],zero,zero,zero
	xorl	%ecx, %ecx
	movss	%xmm8, -56(%rbp)                ## 4-byte Spill
	movss	%xmm1, -52(%rbp)                ## 4-byte Spill
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_10:                                ##   in Loop: Header=BB0_2 Depth=1
	movq	-160(%rbp), %rcx                ## 8-byte Reload
	incq	%rcx
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	addl	-92(%rbp), %eax                 ## 4-byte Folded Reload
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	cmpq	-152(%rbp), %rcx                ## 8-byte Folded Reload
	je	LBB0_11
LBB0_2:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_4 Depth 2
                                        ##       Child Loop BB0_6 Depth 3
                                        ##         Child Loop BB0_7 Depth 4
	movq	%rcx, -160(%rbp)                ## 8-byte Spill
	cmpl	$0, -112(%rbp)                  ## 4-byte Folded Reload
	jle	LBB0_10
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	movslq	-80(%rbp), %rax                 ## 4-byte Folded Reload
	movq	-128(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rcx
	movq	%rcx, -184(%rbp)                ## 8-byte Spill
	movq	-144(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rcx
	movq	%rcx, -176(%rbp)                ## 8-byte Spill
	movq	-136(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	xorl	%eax, %eax
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	xorl	%ecx, %ecx
	jmp	LBB0_4
	.p2align	4, 0x90
LBB0_9:                                 ##   in Loop: Header=BB0_4 Depth=2
	movq	-192(%rbp), %rcx                ## 8-byte Reload
	incq	%rcx
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	addl	-96(%rbp), %eax                 ## 4-byte Folded Reload
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	cmpq	-112(%rbp), %rcx                ## 8-byte Folded Reload
	je	LBB0_10
LBB0_4:                                 ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_6 Depth 3
                                        ##         Child Loop BB0_7 Depth 4
	movq	%rcx, -192(%rbp)                ## 8-byte Spill
	cmpl	$0, -120(%rbp)                  ## 4-byte Folded Reload
	jle	LBB0_9
## %bb.5:                               ##   in Loop: Header=BB0_4 Depth=2
	movslq	-88(%rbp), %rax                 ## 4-byte Folded Reload
	movq	-184(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r15
	movq	-176(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r14
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rbx
	xorl	%ecx, %ecx
	.p2align	4, 0x90
LBB0_6:                                 ##   Parent Loop BB0_2 Depth=1
                                        ##     Parent Loop BB0_4 Depth=2
                                        ## =>    This Loop Header: Depth=3
                                        ##         Child Loop BB0_7 Depth 4
	movl	%ecx, -100(%rbp)                ## 4-byte Spill
	xorl	%r13d, %r13d
	.p2align	4, 0x90
LBB0_7:                                 ##   Parent Loop BB0_2 Depth=1
                                        ##     Parent Loop BB0_4 Depth=2
                                        ##       Parent Loop BB0_6 Depth=3
                                        ## =>      This Inner Loop Header: Depth=4
	movss	(%rbx,%r13), %xmm5              ## xmm5 = mem[0],zero,zero,zero
	movss	4(%rbx,%r13), %xmm2             ## xmm2 = mem[0],zero,zero,zero
	movss	(%r14,%r13), %xmm0              ## xmm0 = mem[0],zero,zero,zero
	movss	4(%r14,%r13), %xmm3             ## xmm3 = mem[0],zero,zero,zero
	movaps	%xmm5, %xmm7
	addss	%xmm0, %xmm7
	movaps	%xmm2, %xmm4
	addss	%xmm3, %xmm4
	movss	(%r15,%r13), %xmm13             ## xmm13 = mem[0],zero,zero,zero
	movss	4(%r15,%r13), %xmm12            ## xmm12 = mem[0],zero,zero,zero
	movaps	%xmm7, %xmm6
	addss	%xmm13, %xmm6
	movaps	%xmm6, %xmm14
	movss	%xmm6, -60(%rbp)                ## 4-byte Spill
	movaps	%xmm4, %xmm6
	addss	%xmm12, %xmm6
	movss	%xmm6, -64(%rbp)                ## 4-byte Spill
	subss	%xmm5, %xmm0
	mulss	%xmm11, %xmm0
	subss	%xmm3, %xmm2
	mulss	%xmm11, %xmm2
	mulss	%xmm9, %xmm7
	addss	%xmm13, %xmm7
	addss	%xmm2, %xmm7
	movss	%xmm7, -48(%rbp)                ## 4-byte Spill
	movaps	%xmm7, %xmm3
	subss	%xmm2, %xmm3
	subss	%xmm2, %xmm3
	movss	%xmm3, -72(%rbp)                ## 4-byte Spill
	mulss	%xmm9, %xmm4
	addss	%xmm12, %xmm4
	addss	%xmm0, %xmm4
	movss	%xmm4, -44(%rbp)                ## 4-byte Spill
	movaps	%xmm4, %xmm2
	subss	%xmm0, %xmm2
	subss	%xmm0, %xmm2
	movss	%xmm2, -68(%rbp)                ## 4-byte Spill
	movaps	%xmm6, %xmm0
	mulss	%xmm6, %xmm0
	movaps	%xmm14, %xmm2
	mulss	%xmm14, %xmm2
	addss	%xmm0, %xmm2
	addss	%xmm10, %xmm2
	movaps	%xmm2, %xmm0
	subss	%xmm8, %xmm0
	divss	%xmm2, %xmm0
	callq	_FFMAX
	movss	-60(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	movss	%xmm1, -60(%rbp)                ## 4-byte Spill
	movss	-64(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	movss	%xmm1, -64(%rbp)                ## 4-byte Spill
	movss	-44(%rbp), %xmm0                ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm0
	movss	-48(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm1, %xmm1
	addss	%xmm0, %xmm1
	addss	LCPI0_3(%rip), %xmm1
	movaps	%xmm1, %xmm0
	subss	-56(%rbp), %xmm0                ## 4-byte Folded Reload
	divss	%xmm1, %xmm0
	movss	-52(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	callq	_FFMAX
	movss	-48(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	addss	-60(%rbp), %xmm1                ## 4-byte Folded Reload
	movss	%xmm1, -48(%rbp)                ## 4-byte Spill
	movss	-44(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	addss	-64(%rbp), %xmm1                ## 4-byte Folded Reload
	movss	%xmm1, -44(%rbp)                ## 4-byte Spill
	movss	-68(%rbp), %xmm0                ## 4-byte Reload
                                        ## xmm0 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm0
	movss	-72(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm1, %xmm1
	addss	%xmm0, %xmm1
	addss	LCPI0_3(%rip), %xmm1
	movaps	%xmm1, %xmm0
	subss	-56(%rbp), %xmm0                ## 4-byte Folded Reload
	divss	%xmm1, %xmm0
	movss	-52(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	callq	_FFMAX
	movss	LCPI0_3(%rip), %xmm10           ## xmm10 = mem[0],zero,zero,zero
	movss	LCPI0_2(%rip), %xmm9            ## xmm9 = mem[0],zero,zero,zero
	movss	LCPI0_1(%rip), %xmm11           ## xmm11 = mem[0],zero,zero,zero
	movss	-52(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	movss	-56(%rbp), %xmm8                ## 4-byte Reload
                                        ## xmm8 = mem[0],zero,zero,zero
	movss	-72(%rbp), %xmm2                ## 4-byte Reload
                                        ## xmm2 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm2
	addss	-48(%rbp), %xmm2                ## 4-byte Folded Reload
	movss	-68(%rbp), %xmm3                ## 4-byte Reload
                                        ## xmm3 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm3
	movss	LCPI0_4(%rip), %xmm0            ## xmm0 = mem[0],zero,zero,zero
	addss	-44(%rbp), %xmm3                ## 4-byte Folded Reload
	mulss	%xmm0, %xmm2
	movss	%xmm2, (%r15,%r13)
	mulss	%xmm0, %xmm3
	movss	%xmm3, 4(%r15,%r13)
	addq	$8, %r13
	cmpq	%r13, %r12
	jne	LBB0_7
## %bb.8:                               ##   in Loop: Header=BB0_6 Depth=3
	movl	-100(%rbp), %ecx                ## 4-byte Reload
	incl	%ecx
	movq	-200(%rbp), %rax                ## 8-byte Reload
	addq	%rax, %r15
	addq	%rax, %r14
	addq	%rax, %rbx
	cmpl	-120(%rbp), %ecx                ## 4-byte Folded Reload
	jne	LBB0_6
	jmp	LBB0_9
LBB0_11:
	addq	$168, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
	.cfi_endproc
                                        ## -- End function
	.comm	_CURRENT,8,3                    ## @CURRENT
	.no_dead_strip	_filter_plane3d2
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function filter_plane3d2
_filter_plane3d2:                       ; @filter_plane3d2
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #304
	.cfi_def_cfa_offset 304
	stp	d15, d14, [sp, #144]            ; 16-byte Folded Spill
	stp	d13, d12, [sp, #160]            ; 16-byte Folded Spill
	stp	d11, d10, [sp, #176]            ; 16-byte Folded Spill
	stp	d9, d8, [sp, #192]              ; 16-byte Folded Spill
	stp	x28, x27, [sp, #208]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #224]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #240]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #256]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #272]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #288]            ; 16-byte Folded Spill
	add	x29, sp, #288
	.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
	stp	x2, x3, [sp, #8]                ; 16-byte Folded Spill
                                        ; kill: def $w1 killed $w1 def $x1
	ldr	x9, [x0, #8]
	mov	w8, #24
	smaddl	x10, w1, w8, x9
	ldr	w8, [x10, #8]
	str	x8, [sp, #32]                   ; 8-byte Folded Spill
	cmp	w8, #1
	b.lt	LBB0_11
; %bb.1:
	mov	w8, #0
	mov	x13, #0
	sxtw	x11, w1
	ldr	w14, [x10]
	ldr	w12, [x0]
	mul	w12, w12, w14
	mul	w12, w12, w12
	scvtf	s8, w12
	ldr	s0, [x0, #4]
	fmov	s1, #1.00000000
	fsub	s14, s1, s0
	ldr	x10, [x10, #16]
Lloh0:
	adrp	x12, _CURRENT@GOTPAGE
Lloh1:
	ldr	x12, [x12, _CURRENT@GOTPAGEOFF]
Lloh2:
	ldr	x12, [x12]
	ldr	x10, [x10, x12, lsl #3]
	str	x10, [sp]                       ; 8-byte Folded Spill
	mov	w10, #24
	madd	x9, x11, x10, x9
	ldr	w10, [x9, #4]
	str	x10, [sp, #88]                  ; 8-byte Folded Spill
	ldr	w9, [x9, #12]
	asr	w9, w9, #2
	lsl	w10, w14, #1
	str	w10, [sp, #84]                  ; 4-byte Folded Spill
	lsl	x27, x14, #3
	mul	w10, w14, w9
	str	w10, [sp, #28]                  ; 4-byte Folded Spill
	sbfiz	x9, x9, #2, #32
	stp	x9, x14, [sp, #112]             ; 16-byte Folded Spill
	mov	w20, #46039
	movk	w20, #16221, lsl #16
	fmov	s18, #-0.50000000
	mov	w24, #7549
	movk	w24, #9872, lsl #16
	mov	w21, #43691
	movk	w21, #16042, lsl #16
	b	LBB0_3
LBB0_2:                                 ;   in Loop: Header=BB0_3 Depth=1
	ldp	x13, x9, [sp, #40]              ; 16-byte Folded Reload
	add	x13, x13, #1
	ldr	w8, [sp, #28]                   ; 4-byte Folded Reload
	add	w8, w9, w8
	ldr	x9, [sp, #32]                   ; 8-byte Folded Reload
	cmp	x13, x9
	b.eq	LBB0_11
LBB0_3:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_6 Depth 2
                                        ;       Child Loop BB0_8 Depth 3
                                        ;         Child Loop BB0_9 Depth 4
	sxtw	x8, w8
	stp	x13, x8, [sp, #40]              ; 16-byte Folded Spill
	ldr	x8, [sp, #88]                   ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_2
; %bb.4:                                ;   in Loop: Header=BB0_3 Depth=1
	str	xzr, [sp, #104]                 ; 8-byte Folded Spill
	mov	x10, #0
	ldr	x8, [sp, #48]                   ; 8-byte Folded Reload
	lsl	x8, x8, #2
	ldr	x9, [sp, #8]                    ; 8-byte Folded Reload
	add	x9, x9, x8
	str	x9, [sp, #72]                   ; 8-byte Folded Spill
	ldr	x9, [sp]                        ; 8-byte Folded Reload
	add	x9, x9, x8
	str	x9, [sp, #64]                   ; 8-byte Folded Spill
	ldr	x9, [sp, #16]                   ; 8-byte Folded Reload
	add	x8, x9, x8
	str	x8, [sp, #56]                   ; 8-byte Folded Spill
	b	LBB0_6
LBB0_5:                                 ;   in Loop: Header=BB0_6 Depth=2
	ldp	x10, x9, [sp, #96]              ; 16-byte Folded Reload
	add	x10, x10, #1
	ldr	w8, [sp, #84]                   ; 4-byte Folded Reload
	add	w9, w9, w8
	str	x9, [sp, #104]                  ; 8-byte Folded Spill
	ldr	x8, [sp, #88]                   ; 8-byte Folded Reload
	cmp	x10, x8
	b.eq	LBB0_2
LBB0_6:                                 ;   Parent Loop BB0_3 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_8 Depth 3
                                        ;         Child Loop BB0_9 Depth 4
	str	x10, [sp, #96]                  ; 8-byte Folded Spill
	ldr	x8, [sp, #120]                  ; 8-byte Folded Reload
	cmp	w8, #1
	b.lt	LBB0_5
; %bb.7:                                ;   in Loop: Header=BB0_6 Depth=2
	mov	w26, #0
	ldr	x8, [sp, #104]                  ; 8-byte Folded Reload
	sbfiz	x8, x8, #2, #32
	ldr	x9, [sp, #72]                   ; 8-byte Folded Reload
	add	x25, x9, x8
	ldr	x9, [sp, #64]                   ; 8-byte Folded Reload
	add	x28, x9, x8
	ldr	x9, [sp, #56]                   ; 8-byte Folded Reload
	add	x22, x9, x8
LBB0_8:                                 ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_6 Depth=2
                                        ; =>    This Loop Header: Depth=3
                                        ;         Child Loop BB0_9 Depth 4
	mov	x23, #0
LBB0_9:                                 ;   Parent Loop BB0_3 Depth=1
                                        ;     Parent Loop BB0_6 Depth=2
                                        ;       Parent Loop BB0_8 Depth=3
                                        ; =>      This Inner Loop Header: Depth=4
	add	x8, x25, x23
	add	x9, x22, x23
	ldp	s0, s17, [x8]
	ldp	s2, s3, [x9]
	fadd	s4, s0, s2
	fadd	s5, s17, s3
	add	x19, x28, x23
	ldp	s6, s7, [x19]
	fadd	s11, s4, s6
	fadd	s12, s5, s7
	fsub	s0, s2, s0
	fmov	s2, w20
	fmul	s0, s0, s2
	fsub	s3, s17, s3
	fmul	s3, s3, s2
	fmadd	s2, s4, s18, s6
	fadd	s13, s2, s3
	fsub	s2, s13, s3
	fsub	s2, s2, s3
	str	s2, [sp, #132]                  ; 4-byte Folded Spill
	fmadd	s2, s5, s18, s7
	fadd	s15, s0, s2
	fsub	s2, s15, s0
	fsub	s10, s2, s0
	fmul	s0, s12, s12
	fmadd	s0, s11, s11, s0
	fmov	s9, w24
	fadd	s0, s0, s9
	fsub	s2, s0, s8
	fdiv	s0, s2, s0
	fmov	s1, s14
	bl	_FFMAX
	fmul	s11, s11, s0
	fmul	s0, s12, s0
	str	s0, [sp, #128]                  ; 4-byte Folded Spill
	fmul	s0, s15, s15
	fmadd	s0, s13, s13, s0
	fadd	s0, s0, s9
	fsub	s1, s0, s8
	fdiv	s0, s1, s0
	fmov	s1, s14
	bl	_FFMAX
	fmul	s13, s13, s0
	fmul	s15, s15, s0
	fmul	s0, s10, s10
	ldr	s12, [sp, #132]                 ; 4-byte Folded Reload
	fmadd	s0, s12, s12, s0
	fadd	s0, s0, s9
	fsub	s1, s0, s8
	fdiv	s0, s1, s0
	fmov	s1, s14
	bl	_FFMAX
	fmov	s18, #-0.50000000
	fmul	s3, s12, s0
	fmul	s0, s0, s10
	fadd	s2, s11, s13
	fadd	s3, s2, s3
	fmov	s2, w21
	fmul	s4, s3, s2
	ldr	s3, [sp, #128]                  ; 4-byte Folded Reload
	fadd	s3, s3, s15
	fadd	s0, s3, s0
	fmul	s0, s0, s2
	stp	s4, s0, [x19]
	add	x23, x23, #8
	cmp	x27, x23
	b.ne	LBB0_9
; %bb.10:                               ;   in Loop: Header=BB0_8 Depth=3
	add	w26, w26, #1
	ldr	x8, [sp, #112]                  ; 8-byte Folded Reload
	add	x25, x25, x8
	add	x28, x28, x8
	add	x22, x22, x8
	ldr	x8, [sp, #120]                  ; 8-byte Folded Reload
	cmp	w26, w8
	b.ne	LBB0_8
	b	LBB0_5
LBB0_11:
	ldp	x29, x30, [sp, #288]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #272]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #256]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #240]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #224]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #208]            ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #192]              ; 16-byte Folded Reload
	ldp	d11, d10, [sp, #176]            ; 16-byte Folded Reload
	ldp	d13, d12, [sp, #160]            ; 16-byte Folded Reload
	ldp	d15, d14, [sp, #144]            ; 16-byte Folded Reload
	add	sp, sp, #304
	ret
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.cfi_endproc
                                        ; -- End function
	.comm	_CURRENT,8,3                    ; @CURRENT
	.no_dead_strip	_filter_plane3d2
.subsections_via_symbols
