	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function gl_texgen
LCPI0_0:
	.quad	0x3ff0000000000000              ## double 1
	.section	__TEXT,__literal4,4byte_literals
	.p2align	2
LCPI0_1:
	.long	0x3f000000                      ## float 0.5
LCPI0_2:
	.long	0x3f800000                      ## float 1
LCPI0_4:
	.long	0x00000000                      ## float 0
	.section	__TEXT,__literal16,16byte_literals
	.p2align	4
LCPI0_3:
	.long	0x3f000000                      ## float 0.5
	.long	0x3f000000                      ## float 0.5
	.space	4
	.space	4
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_gl_texgen
	.p2align	4, 0x90
_gl_texgen:                             ## @gl_texgen
	.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	$88, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r9, %rbx
	movq	%r8, %r12
	movq	%rcx, %r15
	movq	%rsi, %r14
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movl	(%rdi), %eax
	movq	_S_BIT@GOTPCREL(%rip), %rcx
	movl	(%rcx), %ecx
	movq	_T_BIT@GOTPCREL(%rip), %rsi
	movl	(%rsi), %esi
	orl	%ecx, %esi
	cmpl	%esi, %eax
	jne	LBB0_8
## %bb.1:
	cmpl	$128, 4(%rdi)
	jne	LBB0_8
## %bb.2:
	cmpl	$128, 8(%rdi)
	jne	LBB0_8
## %bb.3:
	testq	%r14, %r14
	je	LBB0_60
## %bb.4:
	addq	$4, %rbx
	leaq	-64(%rbp), %r13
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_7:                                 ##   in Loop: Header=BB0_5 Depth=1
	movss	%xmm1, -4(%rbx)
	extractps	$1, %xmm1, (%rbx)
	addq	$16, %rbx
	addq	$16, %r15
	addq	$12, %r12
	decq	%r14
	je	LBB0_60
LBB0_5:                                 ## =>This Inner Loop Header: Depth=1
	movq	%r13, %rdi
	movq	%r15, %rsi
	callq	_COPY_3V
	movq	%r13, %rdi
	callq	_NORMALIZE_3FV
	movq	%r12, %rdi
	movq	%r13, %rsi
	callq	_DOT3
	addsd	%xmm0, %xmm0
	xorps	%xmm1, %xmm1
	cvtsd2ss	%xmm0, %xmm1
	movsd	-64(%rbp), %xmm3                ## xmm3 = mem[0],zero
	movsd	(%r12), %xmm0                   ## xmm0 = mem[0],zero
	movsldup	%xmm1, %xmm2                    ## xmm2 = xmm1[0,0,2,2]
	mulps	%xmm0, %xmm2
	subps	%xmm2, %xmm3
	movss	-56(%rbp), %xmm0                ## xmm0 = mem[0],zero,zero,zero
	mulss	8(%r12), %xmm1
	subss	%xmm1, %xmm0
	movaps	%xmm3, %xmm1
	mulps	%xmm3, %xmm1
	movshdup	%xmm1, %xmm1                    ## xmm1 = xmm1[1,1,3,3]
	movaps	%xmm3, -112(%rbp)               ## 16-byte Spill
	movaps	%xmm3, %xmm2
	mulss	%xmm3, %xmm2
	addss	%xmm1, %xmm2
	addss	LCPI0_2(%rip), %xmm0
	mulss	%xmm0, %xmm0
	addss	%xmm2, %xmm0
	callq	_GL_SQRT
	addss	%xmm0, %xmm0
	ucomiss	LCPI0_4(%rip), %xmm0
	movaps	LCPI0_3(%rip), %xmm1            ## xmm1 = <5.0E-1,5.0E-1,u,u>
	jne	LBB0_6
	jnp	LBB0_7
LBB0_6:                                 ##   in Loop: Header=BB0_5 Depth=1
	movss	LCPI0_2(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	divss	%xmm0, %xmm1
	movsldup	%xmm1, %xmm0                    ## xmm0 = xmm1[0,0,2,2]
	movaps	-112(%rbp), %xmm1               ## 16-byte Reload
	mulps	%xmm0, %xmm1
	addps	LCPI0_3(%rip), %xmm1
	jmp	LBB0_7
LBB0_8:
	movq	%rdx, -120(%rbp)                ## 8-byte Spill
	movq	%rdi, -112(%rbp)                ## 8-byte Spill
	movq	%r15, -96(%rbp)                 ## 8-byte Spill
	movq	%r14, -72(%rbp)                 ## 8-byte Spill
	movq	%rbx, -80(%rbp)                 ## 8-byte Spill
	testl	%eax, %ecx
	je	LBB0_17
## %bb.9:
	movq	-112(%rbp), %rdi                ## 8-byte Reload
	movl	4(%rdi), %eax
	cmpl	$130, %eax
	je	LBB0_26
## %bb.10:
	cmpl	$129, %eax
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	je	LBB0_29
## %bb.11:
	cmpl	$128, %eax
	jne	LBB0_32
## %bb.12:
	testq	%rcx, %rcx
	je	LBB0_17
## %bb.13:
	movq	%r12, %r13
	movq	-96(%rbp), %r15                 ## 8-byte Reload
	movq	-72(%rbp), %rbx                 ## 8-byte Reload
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	movq	%r12, -128(%rbp)                ## 8-byte Spill
	jmp	LBB0_14
	.p2align	4, 0x90
LBB0_16:                                ##   in Loop: Header=BB0_14 Depth=1
	movss	%xmm1, (%r14)
	addq	$16, %r14
	addq	$16, %r15
	addq	$12, %r13
	decq	%rbx
	movq	-128(%rbp), %r12                ## 8-byte Reload
	je	LBB0_17
LBB0_14:                                ## =>This Inner Loop Header: Depth=1
	leaq	-64(%rbp), %r12
	movq	%r12, %rdi
	movq	%r15, %rsi
	callq	_COPY_3V
	movq	%r12, %rdi
	callq	_NORMALIZE_3FV
	movq	%r13, %rdi
	movq	%r12, %rsi
	callq	_DOT3
	addsd	%xmm0, %xmm0
	cvtsd2ss	%xmm0, %xmm0
	movss	(%r13), %xmm1                   ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	movss	-64(%rbp), %xmm3                ## xmm3 = mem[0],zero,zero,zero
	subss	%xmm1, %xmm3
	movss	-60(%rbp), %xmm1                ## xmm1 = mem[0],zero,zero,zero
	movss	4(%r13), %xmm2                  ## xmm2 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm2
	subss	%xmm2, %xmm1
	mulss	8(%r13), %xmm0
	movss	-56(%rbp), %xmm2                ## xmm2 = mem[0],zero,zero,zero
	subss	%xmm0, %xmm2
	mulss	%xmm1, %xmm1
	movss	%xmm3, -84(%rbp)                ## 4-byte Spill
	movaps	%xmm3, %xmm0
	mulss	%xmm3, %xmm0
	addss	%xmm1, %xmm0
	cvtss2sd	%xmm0, %xmm0
	xorps	%xmm1, %xmm1
	cvtss2sd	%xmm2, %xmm1
	addsd	LCPI0_0(%rip), %xmm1
	mulsd	%xmm1, %xmm1
	addsd	%xmm0, %xmm1
	xorps	%xmm0, %xmm0
	cvtsd2ss	%xmm1, %xmm0
	callq	_GL_SQRT
	addss	%xmm0, %xmm0
	ucomiss	LCPI0_4(%rip), %xmm0
	movss	LCPI0_1(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	jne	LBB0_15
	jnp	LBB0_16
LBB0_15:                                ##   in Loop: Header=BB0_14 Depth=1
	movss	-84(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	divss	%xmm0, %xmm1
	addss	LCPI0_1(%rip), %xmm1
	jmp	LBB0_16
LBB0_29:
	testq	%rcx, %rcx
	je	LBB0_17
## %bb.30:
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	movq	-120(%rbp), %rbx                ## 8-byte Reload
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_31:                                ## =>This Inner Loop Header: Depth=1
	movq	-112(%rbp), %rax                ## 8-byte Reload
	movl	48(%rax), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_31
	jmp	LBB0_17
LBB0_26:
	cmpq	$0, -72(%rbp)                   ## 8-byte Folded Reload
	je	LBB0_17
## %bb.27:
	movq	-80(%rbp), %r14                 ## 8-byte Reload
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_28:                                ## =>This Inner Loop Header: Depth=1
	movq	-112(%rbp), %rax                ## 8-byte Reload
	movl	44(%rax), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_28
LBB0_17:
	movq	_T_BIT@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%r12, %rbx
	movq	-112(%rbp), %r12                ## 8-byte Reload
	testl	%eax, (%r12)
	je	LBB0_40
## %bb.18:
	movl	8(%r12), %eax
	cmpl	$130, %eax
	je	LBB0_34
## %bb.19:
	cmpl	$129, %eax
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	je	LBB0_37
## %bb.20:
	cmpl	$128, %eax
	jne	LBB0_62
## %bb.21:
	testq	%rcx, %rcx
	je	LBB0_40
## %bb.22:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	4(%rax), %r15
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	jmp	LBB0_23
	.p2align	4, 0x90
LBB0_25:                                ##   in Loop: Header=BB0_23 Depth=1
	movss	%xmm1, (%r15)
	addq	$16, %r15
	addq	$16, %r14
	addq	$12, %rbx
	decq	%r13
	movq	-112(%rbp), %r12                ## 8-byte Reload
	je	LBB0_40
LBB0_23:                                ## =>This Inner Loop Header: Depth=1
	leaq	-64(%rbp), %r12
	movq	%r12, %rdi
	movq	%r14, %rsi
	callq	_COPY_3V
	movq	%r12, %rdi
	callq	_NORMALIZE_3FV
	movq	%rbx, %rdi
	movq	%r12, %rsi
	callq	_DOT3
	addsd	%xmm0, %xmm0
	cvtsd2ss	%xmm0, %xmm0
	movss	(%rbx), %xmm1                   ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	movss	-64(%rbp), %xmm2                ## xmm2 = mem[0],zero,zero,zero
	subss	%xmm1, %xmm2
	movss	-60(%rbp), %xmm3                ## xmm3 = mem[0],zero,zero,zero
	movss	4(%rbx), %xmm1                  ## xmm1 = mem[0],zero,zero,zero
	mulss	%xmm0, %xmm1
	subss	%xmm1, %xmm3
	mulss	8(%rbx), %xmm0
	movss	-56(%rbp), %xmm1                ## xmm1 = mem[0],zero,zero,zero
	subss	%xmm0, %xmm1
	movss	%xmm3, -84(%rbp)                ## 4-byte Spill
	movaps	%xmm3, %xmm0
	mulss	%xmm3, %xmm0
	mulss	%xmm2, %xmm2
	addss	%xmm0, %xmm2
	xorps	%xmm0, %xmm0
	cvtss2sd	%xmm2, %xmm0
	cvtss2sd	%xmm1, %xmm1
	addsd	LCPI0_0(%rip), %xmm1
	mulsd	%xmm1, %xmm1
	addsd	%xmm0, %xmm1
	xorps	%xmm0, %xmm0
	cvtsd2ss	%xmm1, %xmm0
	callq	_GL_SQRT
	addss	%xmm0, %xmm0
	ucomiss	LCPI0_4(%rip), %xmm0
	movss	LCPI0_1(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	jne	LBB0_24
	jnp	LBB0_25
LBB0_24:                                ##   in Loop: Header=BB0_23 Depth=1
	movss	-84(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	divss	%xmm0, %xmm1
	addss	LCPI0_1(%rip), %xmm1
	jmp	LBB0_25
LBB0_32:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_61
## %bb.33:
	leaq	L_.str(%rip), %rsi
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_gl_problem                     ## TAILCALL
LBB0_34:
	cmpq	$0, -72(%rbp)                   ## 8-byte Folded Reload
	je	LBB0_40
## %bb.35:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	4(%rax), %r14
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_36:                                ## =>This Inner Loop Header: Depth=1
	movl	36(%r12), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_36
	jmp	LBB0_40
LBB0_37:
	testq	%rcx, %rcx
	je	LBB0_40
## %bb.38:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	4(%rax), %r14
	movq	-120(%rbp), %rbx                ## 8-byte Reload
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_39:                                ## =>This Inner Loop Header: Depth=1
	movl	40(%r12), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_39
LBB0_40:
	movq	_R_BIT@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, (%r12)
	movq	-120(%rbp), %r13                ## 8-byte Reload
	je	LBB0_49
## %bb.41:
	movl	12(%r12), %eax
	cmpl	$129, %eax
	je	LBB0_46
## %bb.42:
	cmpl	$130, %eax
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	jne	LBB0_63
## %bb.43:
	testq	%rax, %rax
	je	LBB0_49
## %bb.44:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	8(%rax), %r14
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_45:                                ## =>This Inner Loop Header: Depth=1
	movl	28(%r12), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_45
	jmp	LBB0_49
LBB0_46:
	cmpq	$0, -72(%rbp)                   ## 8-byte Folded Reload
	je	LBB0_49
## %bb.47:
	movq	-80(%rbp), %rax                 ## 8-byte Reload
	leaq	8(%rax), %r14
	movq	%r13, %rbx
	movq	-72(%rbp), %r15                 ## 8-byte Reload
	.p2align	4, 0x90
LBB0_48:                                ## =>This Inner Loop Header: Depth=1
	movl	32(%r12), %esi
	movq	%rbx, %rdi
	callq	_DOT4
	movss	%xmm0, (%r14)
	addq	$16, %rbx
	addq	$16, %r14
	decq	%r15
	jne	LBB0_48
LBB0_49:
	movq	_Q_BIT@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, (%r12)
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movq	-72(%rbp), %r14                 ## 8-byte Reload
	movq	-96(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_60
## %bb.50:
	movl	16(%r12), %eax
	cmpl	$129, %eax
	je	LBB0_55
## %bb.51:
	cmpl	$130, %eax
	jne	LBB0_58
## %bb.52:
	testq	%r14, %r14
	je	LBB0_60
## %bb.53:
	addq	$12, %rbx
	.p2align	4, 0x90
LBB0_54:                                ## =>This Inner Loop Header: Depth=1
	movl	20(%r12), %esi
	movq	%r15, %rdi
	callq	_DOT4
	movss	%xmm0, (%rbx)
	addq	$16, %r15
	addq	$16, %rbx
	decq	%r14
	jne	LBB0_54
	jmp	LBB0_60
LBB0_63:
	leaq	L_.str.2(%rip), %rsi
	jmp	LBB0_59
LBB0_62:
	leaq	L_.str.1(%rip), %rsi
	jmp	LBB0_59
LBB0_55:
	testq	%r14, %r14
	je	LBB0_60
## %bb.56:
	addq	$12, %rbx
	.p2align	4, 0x90
LBB0_57:                                ## =>This Inner Loop Header: Depth=1
	movl	24(%r12), %esi
	movq	%r13, %rdi
	callq	_DOT4
	movss	%xmm0, (%rbx)
	addq	$16, %r13
	addq	$16, %rbx
	decq	%r14
	jne	LBB0_57
	jmp	LBB0_60
LBB0_58:
	leaq	L_.str.3(%rip), %rsi
LBB0_59:
	movq	%r12, %rdi
	callq	_gl_problem
LBB0_60:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_61
## %bb.64:
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_61:
	callq	___stack_chk_fail
	.cfi_endproc
                                        ## -- End function
	.comm	_S_BIT,4,2                      ## @S_BIT
	.comm	_T_BIT,4,2                      ## @T_BIT
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"Bad S texgen"

L_.str.1:                               ## @.str.1
	.asciz	"Bad T texgen"

	.comm	_R_BIT,4,2                      ## @R_BIT
L_.str.2:                               ## @.str.2
	.asciz	"Bad R texgen"

	.comm	_Q_BIT,4,2                      ## @Q_BIT
L_.str.3:                               ## @.str.3
	.asciz	"Bad Q texgen"

.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_gl_texgen                      ; -- Begin function gl_texgen
	.p2align	2
_gl_texgen:                             ; @gl_texgen
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #176
	.cfi_def_cfa_offset 176
	stp	d11, d10, [sp, #48]             ; 16-byte Folded Spill
	stp	d9, d8, [sp, #64]               ; 16-byte Folded Spill
	stp	x28, x27, [sp, #80]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #96]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #112]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #128]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #144]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #160]            ; 16-byte Folded Spill
	add	x29, sp, #160
	.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
	mov	x27, x5
	mov	x24, x4
	mov	x20, x3
	mov	x23, x2
	mov	x19, x1
	mov	x22, x0
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	str	x8, [sp, #40]
	ldr	w8, [x0]
Lloh3:
	adrp	x9, _S_BIT@GOTPAGE
Lloh4:
	ldr	x9, [x9, _S_BIT@GOTPAGEOFF]
Lloh5:
	ldr	w9, [x9]
Lloh6:
	adrp	x10, _T_BIT@GOTPAGE
Lloh7:
	ldr	x10, [x10, _T_BIT@GOTPAGEOFF]
Lloh8:
	ldr	w10, [x10]
	orr	w10, w10, w9
	cmp	w8, w10
	b.ne	LBB0_8
; %bb.1:
	ldr	w10, [x22, #4]
	cmp	w10, #128
	b.ne	LBB0_8
; %bb.2:
	ldr	w10, [x22, #8]
	cmp	w10, #128
	b.ne	LBB0_8
; %bb.3:
	cbz	x19, LBB0_62
; %bb.4:
	fmov	s8, #1.00000000
	b	LBB0_6
LBB0_5:                                 ;   in Loop: Header=BB0_6 Depth=1
	str	d0, [x27], #16
	add	x20, x20, #16
	add	x24, x24, #12
	subs	x19, x19, #1
	b.eq	LBB0_62
LBB0_6:                                 ; =>This Inner Loop Header: Depth=1
	add	x0, sp, #24
	mov	x1, x20
	bl	_COPY_3V
	add	x0, sp, #24
	bl	_NORMALIZE_3FV
	add	x1, sp, #24
	mov	x0, x24
	bl	_DOT3
	fadd	d0, d0, d0
	fcvt	s0, d0
	ldr	d3, [sp, #24]
	ldr	d1, [x24]
	fmls.2s	v3, v1, v0[0]
	ldr	s1, [sp, #32]
	ldr	s2, [x24, #8]
	fmsub	s0, s2, s0, s1
	fmul.2s	v1, v3, v3
	mov	s1, v1[1]
	str	q3, [sp]                        ; 16-byte Folded Spill
	fmla.s	s1, s3, v3[0]
	fadd	s0, s0, s8
	fmadd	s0, s0, s0, s1
	bl	_GL_SQRT
	fadd	s1, s0, s0
	fcmp	s1, #0.0
	movi.2s	v0, #63, lsl #24
	b.eq	LBB0_5
; %bb.7:                                ;   in Loop: Header=BB0_6 Depth=1
	fdiv	s1, s8, s1
	movi.2s	v0, #63, lsl #24
	ldr	q2, [sp]                        ; 16-byte Folded Reload
	fmla.2s	v0, v2, v1[0]
	b	LBB0_5
LBB0_8:
	tst	w9, w8
	b.eq	LBB0_23
; %bb.9:
	ldr	w8, [x22, #4]
	cmp	w8, #130
	b.eq	LBB0_20
; %bb.10:
	cmp	w8, #129
	b.eq	LBB0_17
; %bb.11:
	cmp	w8, #128
	b.ne	LBB0_32
; %bb.12:
	cbz	x19, LBB0_23
; %bb.13:
	fmov	d8, #1.00000000
	fmov	s9, #0.50000000
	mov	x25, x24
	mov	x26, x20
	mov	x28, x19
	mov	x21, x27
	b	LBB0_15
LBB0_14:                                ;   in Loop: Header=BB0_15 Depth=1
	str	s0, [x21], #16
	add	x26, x26, #16
	add	x25, x25, #12
	subs	x28, x28, #1
	b.eq	LBB0_23
LBB0_15:                                ; =>This Inner Loop Header: Depth=1
	add	x0, sp, #24
	mov	x1, x26
	bl	_COPY_3V
	add	x0, sp, #24
	bl	_NORMALIZE_3FV
	add	x1, sp, #24
	mov	x0, x25
	bl	_DOT3
	fadd	d0, d0, d0
	fcvt	s0, d0
	ldp	s1, s2, [sp, #24]
	ldp	s3, s4, [x25]
	fmsub	s10, s3, s0, s1
	fmsub	s1, s4, s0, s2
	ldr	s2, [sp, #32]
	ldr	s3, [x25, #8]
	fmsub	s0, s3, s0, s2
	fmul	s1, s1, s1
	fmadd	s1, s10, s10, s1
	fcvt	d1, s1
	fcvt	d0, s0
	fadd	d0, d0, d8
	fmadd	d0, d0, d0, d1
	fcvt	s0, d0
	bl	_GL_SQRT
	fadd	s1, s0, s0
	fcmp	s1, #0.0
	fmov	s0, #0.50000000
	b.eq	LBB0_14
; %bb.16:                               ;   in Loop: Header=BB0_15 Depth=1
	fdiv	s0, s10, s1
	fadd	s0, s0, s9
	b	LBB0_14
LBB0_17:
	cbz	x19, LBB0_23
; %bb.18:
	mov	x21, x27
	mov	x25, x23
	mov	x26, x19
LBB0_19:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #48]
	mov	x0, x25
	bl	_DOT4
	str	s0, [x21], #16
	add	x25, x25, #16
	subs	x26, x26, #1
	b.ne	LBB0_19
	b	LBB0_23
LBB0_20:
	cbz	x19, LBB0_23
; %bb.21:
	mov	x21, x27
	mov	x25, x20
	mov	x26, x19
LBB0_22:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #44]
	mov	x0, x25
	bl	_DOT4
	str	s0, [x21], #16
	add	x25, x25, #16
	subs	x26, x26, #1
	b.ne	LBB0_22
LBB0_23:
	ldr	w8, [x22]
Lloh9:
	adrp	x9, _T_BIT@GOTPAGE
Lloh10:
	ldr	x9, [x9, _T_BIT@GOTPAGEOFF]
Lloh11:
	ldr	w9, [x9]
	tst	w9, w8
	mov	x28, x27
	b.eq	LBB0_40
; %bb.24:
	ldr	w8, [x22, #8]
	cmp	w8, #130
	b.eq	LBB0_34
; %bb.25:
	cmp	w8, #129
	b.eq	LBB0_37
; %bb.26:
	cmp	w8, #128
	b.ne	LBB0_56
; %bb.27:
	cbz	x19, LBB0_40
; %bb.28:
	add	x26, x28, #4
	fmov	d8, #1.00000000
	fmov	s9, #0.50000000
	mov	x25, x20
	mov	x27, x19
	b	LBB0_30
LBB0_29:                                ;   in Loop: Header=BB0_30 Depth=1
	str	s0, [x26], #16
	add	x25, x25, #16
	add	x24, x24, #12
	subs	x27, x27, #1
	b.eq	LBB0_40
LBB0_30:                                ; =>This Inner Loop Header: Depth=1
	add	x0, sp, #24
	mov	x1, x25
	bl	_COPY_3V
	add	x0, sp, #24
	bl	_NORMALIZE_3FV
	add	x1, sp, #24
	mov	x0, x24
	bl	_DOT3
	fadd	d0, d0, d0
	fcvt	s0, d0
	ldp	s1, s2, [sp, #24]
	ldp	s3, s4, [x24]
	fmsub	s1, s3, s0, s1
	fmsub	s10, s4, s0, s2
	ldr	s2, [sp, #32]
	ldr	s3, [x24, #8]
	fmsub	s0, s3, s0, s2
	fmul	s2, s10, s10
	fmadd	s1, s1, s1, s2
	fcvt	d1, s1
	fcvt	d0, s0
	fadd	d0, d0, d8
	fmadd	d0, d0, d0, d1
	fcvt	s0, d0
	bl	_GL_SQRT
	fadd	s1, s0, s0
	fcmp	s1, #0.0
	fmov	s0, #0.50000000
	b.eq	LBB0_29
; %bb.31:                               ;   in Loop: Header=BB0_30 Depth=1
	fdiv	s0, s10, s1
	fadd	s0, s0, s9
	b	LBB0_29
LBB0_32:
	ldr	x8, [sp, #40]
Lloh12:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh13:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh14:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_64
; %bb.33:
Lloh15:
	adrp	x1, l_.str@PAGE
Lloh16:
	add	x1, x1, l_.str@PAGEOFF
	mov	x0, x22
	ldp	x29, x30, [sp, #160]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #144]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #112]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #96]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #80]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #64]               ; 16-byte Folded Reload
	ldp	d11, d10, [sp, #48]             ; 16-byte Folded Reload
	add	sp, sp, #176
	b	_gl_problem
LBB0_34:
	cbz	x19, LBB0_40
; %bb.35:
	add	x21, x28, #4
	mov	x24, x20
	mov	x25, x19
LBB0_36:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #36]
	mov	x0, x24
	bl	_DOT4
	str	s0, [x21], #16
	add	x24, x24, #16
	subs	x25, x25, #1
	b.ne	LBB0_36
	b	LBB0_40
LBB0_37:
	cbz	x19, LBB0_40
; %bb.38:
	add	x21, x28, #4
	mov	x24, x23
	mov	x25, x19
LBB0_39:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #40]
	mov	x0, x24
	bl	_DOT4
	str	s0, [x21], #16
	add	x24, x24, #16
	subs	x25, x25, #1
	b.ne	LBB0_39
LBB0_40:
	ldr	w8, [x22]
Lloh17:
	adrp	x9, _R_BIT@GOTPAGE
Lloh18:
	ldr	x9, [x9, _R_BIT@GOTPAGEOFF]
Lloh19:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_49
; %bb.41:
	ldr	w8, [x22, #12]
	cmp	w8, #129
	b.eq	LBB0_46
; %bb.42:
	cmp	w8, #130
	b.ne	LBB0_55
; %bb.43:
	cbz	x19, LBB0_49
; %bb.44:
	add	x21, x28, #8
	mov	x24, x20
	mov	x25, x19
LBB0_45:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #28]
	mov	x0, x24
	bl	_DOT4
	str	s0, [x21], #16
	add	x24, x24, #16
	subs	x25, x25, #1
	b.ne	LBB0_45
	b	LBB0_49
LBB0_46:
	cbz	x19, LBB0_49
; %bb.47:
	add	x21, x28, #8
	mov	x24, x23
	mov	x25, x19
LBB0_48:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #32]
	mov	x0, x24
	bl	_DOT4
	str	s0, [x21], #16
	add	x24, x24, #16
	subs	x25, x25, #1
	b.ne	LBB0_48
LBB0_49:
	ldr	w8, [x22]
Lloh20:
	adrp	x9, _Q_BIT@GOTPAGE
Lloh21:
	ldr	x9, [x9, _Q_BIT@GOTPAGEOFF]
Lloh22:
	ldr	w9, [x9]
	tst	w9, w8
	b.eq	LBB0_62
; %bb.50:
	ldr	w8, [x22, #16]
	cmp	w8, #129
	b.eq	LBB0_57
; %bb.51:
	cmp	w8, #130
	b.ne	LBB0_60
; %bb.52:
	cbz	x19, LBB0_62
; %bb.53:
	add	x21, x28, #12
LBB0_54:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #20]
	mov	x0, x20
	bl	_DOT4
	str	s0, [x21], #16
	add	x20, x20, #16
	subs	x19, x19, #1
	b.ne	LBB0_54
	b	LBB0_62
LBB0_55:
Lloh23:
	adrp	x1, l_.str.2@PAGE
Lloh24:
	add	x1, x1, l_.str.2@PAGEOFF
	b	LBB0_61
LBB0_56:
Lloh25:
	adrp	x1, l_.str.1@PAGE
Lloh26:
	add	x1, x1, l_.str.1@PAGEOFF
	b	LBB0_61
LBB0_57:
	cbz	x19, LBB0_62
; %bb.58:
	add	x20, x28, #12
LBB0_59:                                ; =>This Inner Loop Header: Depth=1
	ldr	w1, [x22, #24]
	mov	x0, x23
	bl	_DOT4
	str	s0, [x20], #16
	add	x23, x23, #16
	subs	x19, x19, #1
	b.ne	LBB0_59
	b	LBB0_62
LBB0_60:
Lloh27:
	adrp	x1, l_.str.3@PAGE
Lloh28:
	add	x1, x1, l_.str.3@PAGEOFF
LBB0_61:
	mov	x0, x22
	bl	_gl_problem
LBB0_62:
	ldr	x8, [sp, #40]
Lloh29:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh30:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh31:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_64
; %bb.63:
	ldp	x29, x30, [sp, #160]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #144]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #112]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #96]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #80]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #64]               ; 16-byte Folded Reload
	ldp	d11, d10, [sp, #48]             ; 16-byte Folded Reload
	add	sp, sp, #176
	ret
LBB0_64:
	bl	___stack_chk_fail
	.loh AdrpLdrGotLdr	Lloh6, Lloh7, Lloh8
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh9, Lloh10, Lloh11
	.loh AdrpLdrGotLdr	Lloh12, Lloh13, Lloh14
	.loh AdrpAdd	Lloh15, Lloh16
	.loh AdrpLdrGotLdr	Lloh17, Lloh18, Lloh19
	.loh AdrpLdrGotLdr	Lloh20, Lloh21, Lloh22
	.loh AdrpAdd	Lloh23, Lloh24
	.loh AdrpAdd	Lloh25, Lloh26
	.loh AdrpAdd	Lloh27, Lloh28
	.loh AdrpLdrGotLdr	Lloh29, Lloh30, Lloh31
	.cfi_endproc
                                        ; -- End function
	.comm	_S_BIT,4,2                      ; @S_BIT
	.comm	_T_BIT,4,2                      ; @T_BIT
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"Bad S texgen"

l_.str.1:                               ; @.str.1
	.asciz	"Bad T texgen"

	.comm	_R_BIT,4,2                      ; @R_BIT
l_.str.2:                               ; @.str.2
	.asciz	"Bad R texgen"

	.comm	_Q_BIT,4,2                      ; @Q_BIT
l_.str.3:                               ; @.str.3
	.asciz	"Bad Q texgen"

.subsections_via_symbols
