	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function draw_depth_pixels
LCPI0_0:
	.quad	0x3ff0000000000000              ## double 1
LCPI0_3:
	.quad	0x0000000000000000              ## double 0
	.section	__TEXT,__literal4,4byte_literals
	.p2align	2
LCPI0_1:
	.long	0x3f000000                      ## float 0.5
LCPI0_2:
	.long	0x3f800000                      ## float 1
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_draw_depth_pixels:                     ## @draw_depth_pixels
	.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	$216, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%r8, -104(%rbp)                 ## 8-byte Spill
                                        ## kill: def $ecx killed $ecx def $rcx
	movq	%rcx, -88(%rbp)                 ## 8-byte Spill
	movq	%rdx, -160(%rbp)                ## 8-byte Spill
	movq	%rsi, %r13
	movq	%rdi, %r15
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	movq	%rax, -48(%rbp)
	movq	_MAX_WIDTH@GOTPCREL(%rip), %rax
	movl	(%rax), %r14d
	leaq	(,%r14,4), %rbx
	movq	%rbx, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -144(%rbp)                ## 8-byte Spill
	movq	%rbx, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -136(%rbp)                ## 8-byte Spill
	movq	%rbx, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -128(%rbp)                ## 8-byte Spill
	movq	%rbx, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, -120(%rbp)                ## 8-byte Spill
	shlq	$3, %r14
	movq	%r14, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %rbx
	movsd	8(%r15), %xmm0                  ## xmm0 = mem[0],zero
	movb	$1, %al
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	xorpd	%xmm1, %xmm1
	ucomisd	%xmm1, %xmm0
	movb	$1, %r8b
	jne	LBB0_2
	jp	LBB0_2
## %bb.1:
	movsd	LCPI0_0(%rip), %xmm0            ## xmm0 = mem[0],zero
	cmpneqsd	16(%r15), %xmm0
	movq	%xmm0, %r8
	andl	$1, %r8d
LBB0_2:
	movsd	24(%r15), %xmm0                 ## xmm0 = mem[0],zero
	ucomisd	LCPI0_0(%rip), %xmm0
	jne	LBB0_4
	jp	LBB0_4
## %bb.3:
	movsd	LCPI0_0(%rip), %xmm0            ## xmm0 = mem[0],zero
	cmpneqsd	32(%r15), %xmm0
	movq	%xmm0, %rax
	andl	$1, %eax
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
LBB0_4:
	movq	(%r15), %rax
	movq	56(%r15), %rcx
	xorps	%xmm1, %xmm1
	cvtsi2ssq	(%rcx), %xmm1
	movss	LCPI0_1(%rip), %xmm0            ## xmm0 = mem[0],zero,zero,zero
	cvtsi2ssq	8(%rcx), %xmm2
	addss	%xmm0, %xmm1
	addss	%xmm0, %xmm2
	cmpq	$0, 16(%rax)
	movq	%r15, -64(%rbp)                 ## 8-byte Spill
	movq	%rbx, -184(%rbp)                ## 8-byte Spill
	je	LBB0_6
## %bb.5:
	movq	40(%r15), %rcx
	movslq	(%rcx), %rdx
	movslq	(%rax), %rsi
	imulq	%rdx, %rsi
	movslq	4(%rcx), %rdx
	movslq	4(%rax), %r12
	imulq	%rdx, %r12
	movslq	8(%rcx), %rdx
	movslq	8(%rax), %r14
	imulq	%rdx, %r14
	movslq	12(%rcx), %rcx
	movslq	12(%rax), %r15
	imulq	%rcx, %r15
	movq	-144(%rbp), %rdi                ## 8-byte Reload
	movq	%r13, %rdx
	movq	%r8, %rbx
	movss	%xmm1, -56(%rbp)                ## 4-byte Spill
	movss	%xmm2, -72(%rbp)                ## 4-byte Spill
	callq	_MEMSET
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	movq	%r12, %rsi
	movq	%r13, %rdx
	callq	_MEMSET
	movq	-128(%rbp), %rdi                ## 8-byte Reload
	movq	%r14, %rsi
	movq	%r13, %rdx
	callq	_MEMSET
	movq	-120(%rbp), %rdi                ## 8-byte Reload
	movq	%r15, %rsi
	movq	%r13, %rdx
	callq	_MEMSET
	movss	-72(%rbp), %xmm2                ## 4-byte Reload
                                        ## xmm2 = mem[0],zero,zero,zero
	movss	-56(%rbp), %xmm1                ## 4-byte Reload
                                        ## xmm1 = mem[0],zero,zero,zero
	movq	%rbx, %r8
	jmp	LBB0_18
LBB0_6:
	testq	%r13, %r13
	je	LBB0_18
## %bb.7:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movq	48(%rax), %rax
	cmpq	$4, %r13
	jae	LBB0_9
## %bb.8:
	xorl	%ecx, %ecx
	jmp	LBB0_17
LBB0_9:
	movq	%r13, %rcx
	andq	$-4, %rcx
	movq	%rax, %xmm0
	pshufd	$68, %xmm0, %xmm0               ## xmm0 = xmm0[0,1,0,1]
	leaq	-4(%rcx), %rdi
	movq	%rdi, %rsi
	shrq	$2, %rsi
	incq	%rsi
	movl	%esi, %edx
	andl	$7, %edx
	cmpq	$28, %rdi
	jae	LBB0_11
## %bb.10:
	xorl	%edi, %edi
	jmp	LBB0_13
LBB0_11:
	andq	$-8, %rsi
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_12:                                ## =>This Inner Loop Header: Depth=1
	movdqa	%xmm0, (%rbx,%rdi,8)
	movdqa	%xmm0, 16(%rbx,%rdi,8)
	movdqa	%xmm0, 32(%rbx,%rdi,8)
	movdqa	%xmm0, 48(%rbx,%rdi,8)
	movdqa	%xmm0, 64(%rbx,%rdi,8)
	movdqa	%xmm0, 80(%rbx,%rdi,8)
	movdqa	%xmm0, 96(%rbx,%rdi,8)
	movdqa	%xmm0, 112(%rbx,%rdi,8)
	movdqa	%xmm0, 128(%rbx,%rdi,8)
	movdqa	%xmm0, 144(%rbx,%rdi,8)
	movdqa	%xmm0, 160(%rbx,%rdi,8)
	movdqa	%xmm0, 176(%rbx,%rdi,8)
	movdqa	%xmm0, 192(%rbx,%rdi,8)
	movdqa	%xmm0, 208(%rbx,%rdi,8)
	movdqa	%xmm0, 224(%rbx,%rdi,8)
	movdqa	%xmm0, 240(%rbx,%rdi,8)
	addq	$32, %rdi
	addq	$-8, %rsi
	jne	LBB0_12
LBB0_13:
	testq	%rdx, %rdx
	je	LBB0_16
## %bb.14:
	leaq	(%rbx,%rdi,8), %rsi
	addq	$16, %rsi
	shlq	$5, %rdx
	xorl	%edi, %edi
	.p2align	4, 0x90
LBB0_15:                                ## =>This Inner Loop Header: Depth=1
	movdqa	%xmm0, -16(%rsi,%rdi)
	movdqa	%xmm0, (%rsi,%rdi)
	addq	$32, %rdi
	cmpq	%rdi, %rdx
	jne	LBB0_15
LBB0_16:
	cmpq	%r13, %rcx
	je	LBB0_18
	.p2align	4, 0x90
LBB0_17:                                ## =>This Inner Loop Header: Depth=1
	movq	%rax, (%rbx,%rcx,8)
	incq	%rcx
	cmpq	%rcx, %r13
	jne	LBB0_17
LBB0_18:
	cvttss2si	%xmm1, %rax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	cvttss2si	%xmm2, %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	cmpl	$129, -88(%rbp)                 ## 4-byte Folded Reload
	setne	%al
	orb	%r8b, %al
	orb	-80(%rbp), %al                  ## 1-byte Folded Reload
	jne	LBB0_36
## %bb.19:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movq	(%rax), %rax
	cmpq	$0, 16(%rax)
	je	LBB0_36
## %bb.20:
	movq	_MAX_DEPTH@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	xorl	%r12d, %r12d
	testl	$-2147483648, %eax              ## imm = 0x80000000
	jne	LBB0_22
	.p2align	4, 0x90
LBB0_21:                                ## =>This Inner Loop Header: Depth=1
	leaq	(%rax,%rax), %rcx
	incq	%r12
	testl	$1073741824, %eax               ## imm = 0x40000000
	movq	%rcx, %rax
	je	LBB0_21
LBB0_22:
	cmpq	$0, -160(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_89
## %bb.23:
	leaq	-4(%r13), %rax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	shrq	$2, %rax
	incq	%rax
	movq	%r13, %rcx
	andq	$-4, %rcx
	movq	%rcx, -80(%rbp)                 ## 8-byte Spill
	movq	%r12, %xmm2
	movabsq	$9223372036854775800, %rdx      ## imm = 0x7FFFFFFFFFFFFFF8
	orq	$6, %rdx
	movq	%rax, %rcx
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	andq	%rax, %rdx
	movq	%rdx, -112(%rbp)                ## 8-byte Spill
	movq	-104(%rbp), %r15                ## 8-byte Reload
	leaq	48(%r15), %r14
	leaq	(,%r13,8), %rax
	movq	%rax, -176(%rbp)                ## 8-byte Spill
	xorl	%eax, %eax
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	movdqa	%xmm2, -208(%rbp)               ## 16-byte Spill
	jmp	LBB0_25
	.p2align	4, 0x90
LBB0_24:                                ##   in Loop: Header=BB0_25 Depth=1
	movq	_GL_BITMAP@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%r13, %rsi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	movq	-152(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %rcx
	movq	-144(%rbp), %r9                 ## 8-byte Reload
	pushq	%rax
	pushq	-120(%rbp)                      ## 8-byte Folded Reload
	pushq	-128(%rbp)                      ## 8-byte Folded Reload
	pushq	-136(%rbp)                      ## 8-byte Folded Reload
	callq	_gl_write_color_span
	movdqa	-208(%rbp), %xmm2               ## 16-byte Reload
	addq	$32, %rsp
	movq	-72(%rbp), %rsp                 ## 8-byte Reload
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	incq	%rcx
	incq	%rbx
	movq	%rbx, -152(%rbp)                ## 8-byte Spill
	movq	-176(%rbp), %rax                ## 8-byte Reload
	addq	%rax, %r14
	addq	%rax, %r15
	movq	%rcx, %rax
	movq	%rcx, -56(%rbp)                 ## 8-byte Spill
	cmpq	-160(%rbp), %rcx                ## 8-byte Folded Reload
	je	LBB0_89
LBB0_25:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_31 Depth 2
                                        ##     Child Loop BB0_35 Depth 2
	movq	%rsp, -72(%rbp)                 ## 8-byte Spill
	movq	_MAX_WIDTH@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	shlq	$3, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r8
	testq	%r13, %r13
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	je	LBB0_24
## %bb.26:                              ##   in Loop: Header=BB0_25 Depth=1
	cmpq	$4, %r13
	jae	LBB0_28
## %bb.27:                              ##   in Loop: Header=BB0_25 Depth=1
	xorl	%eax, %eax
	jmp	LBB0_35
	.p2align	4, 0x90
LBB0_28:                                ##   in Loop: Header=BB0_25 Depth=1
	cmpq	$4, -168(%rbp)                  ## 8-byte Folded Reload
	jae	LBB0_30
## %bb.29:                              ##   in Loop: Header=BB0_25 Depth=1
	xorl	%eax, %eax
	jmp	LBB0_32
LBB0_30:                                ##   in Loop: Header=BB0_25 Depth=1
	movq	-112(%rbp), %rcx                ## 8-byte Reload
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_31:                                ##   Parent Loop BB0_25 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqu	-48(%r14,%rax,8), %xmm0
	movdqu	-32(%r14,%rax,8), %xmm1
	psrlq	%xmm2, %xmm0
	psrlq	%xmm2, %xmm1
	movdqa	%xmm0, (%r8,%rax,8)
	movdqa	%xmm1, 16(%r8,%rax,8)
	movdqu	-16(%r14,%rax,8), %xmm0
	movdqu	(%r14,%rax,8), %xmm1
	psrlq	%xmm2, %xmm0
	psrlq	%xmm2, %xmm1
	movdqa	%xmm0, 32(%r8,%rax,8)
	movdqa	%xmm1, 48(%r8,%rax,8)
	addq	$8, %rax
	addq	$-2, %rcx
	jne	LBB0_31
LBB0_32:                                ##   in Loop: Header=BB0_25 Depth=1
	testb	$1, -88(%rbp)                   ## 1-byte Folded Reload
	je	LBB0_34
## %bb.33:                              ##   in Loop: Header=BB0_25 Depth=1
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	imulq	%r13, %rcx
	movq	-104(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rcx,8), %rcx
	movdqu	(%rcx,%rax,8), %xmm0
	movdqu	16(%rcx,%rax,8), %xmm1
	psrlq	%xmm2, %xmm0
	psrlq	%xmm2, %xmm1
	movdqa	%xmm0, (%r8,%rax,8)
	movdqa	%xmm1, 16(%r8,%rax,8)
LBB0_34:                                ##   in Loop: Header=BB0_25 Depth=1
	movq	-80(%rbp), %rcx                 ## 8-byte Reload
	movq	%rcx, %rax
	cmpq	%r13, %rcx
	je	LBB0_24
	.p2align	4, 0x90
LBB0_35:                                ##   Parent Loop BB0_25 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	(%r15,%rax,8), %rdx
	movl	%r12d, %ecx
	shrq	%cl, %rdx
	movq	%rdx, (%r8,%rax,8)
	incq	%rax
	cmpq	%rax, %r13
	jne	LBB0_35
	jmp	LBB0_24
LBB0_36:
	cmpq	$0, -160(%rbp)                  ## 8-byte Folded Reload
	je	LBB0_89
## %bb.37:
	leaq	(,%r13,4), %rax
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	cmpq	$2, %r13
	movl	$1, %eax
	cmovaeq	%r13, %rax
	leaq	-8(%rax), %rcx
	movq	%rcx, -240(%rbp)                ## 8-byte Spill
	shrq	$3, %rcx
	incq	%rcx
	movq	%rax, -192(%rbp)                ## 8-byte Spill
	andq	$-8, %rax
	movq	%rax, -224(%rbp)                ## 8-byte Spill
	movq	%rcx, %rax
	movq	%rcx, -232(%rbp)                ## 8-byte Spill
	andq	$-2, %rcx
	movq	%rcx, -216(%rbp)                ## 8-byte Spill
	leaq	(,%r13,8), %rax
	movq	%rax, -248(%rbp)                ## 8-byte Spill
	xorl	%eax, %eax
	movq	%rax, -72(%rbp)                 ## 8-byte Spill
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	addl	$-128, %eax
	movq	%rax, -88(%rbp)                 ## 8-byte Spill
	movq	-104(%rbp), %rax                ## 8-byte Reload
	movq	%rax, %r15
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	movq	-152(%rbp), %rbx                ## 8-byte Reload
	jmp	LBB0_41
	.p2align	4, 0x90
LBB0_38:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	_GL_BITMAP@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	%r13, %rsi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	movq	%rbx, %rcx
	movq	%r14, %r8
	movq	-144(%rbp), %r9                 ## 8-byte Reload
	pushq	%rax
	pushq	-120(%rbp)                      ## 8-byte Folded Reload
	pushq	-128(%rbp)                      ## 8-byte Folded Reload
	pushq	-136(%rbp)                      ## 8-byte Folded Reload
	callq	_gl_write_color_span
LBB0_39:                                ##   in Loop: Header=BB0_41 Depth=1
	addq	$32, %rsp
LBB0_40:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-208(%rbp), %rsp                ## 8-byte Reload
	movq	-72(%rbp), %rcx                 ## 8-byte Reload
	incq	%rcx
	incq	%rbx
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	addq	-248(%rbp), %rax                ## 8-byte Folded Reload
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	addq	-112(%rbp), %r15                ## 8-byte Folded Reload
	movq	%rcx, %rax
	movq	%rcx, -72(%rbp)                 ## 8-byte Spill
	cmpq	-160(%rbp), %rcx                ## 8-byte Folded Reload
	je	LBB0_89
LBB0_41:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_62 Depth 2
                                        ##     Child Loop BB0_57 Depth 2
                                        ##     Child Loop BB0_54 Depth 2
                                        ##     Child Loop BB0_51 Depth 2
                                        ##     Child Loop BB0_48 Depth 2
                                        ##     Child Loop BB0_45 Depth 2
                                        ##     Child Loop BB0_73 Depth 2
                                        ##     Child Loop BB0_77 Depth 2
                                        ##     Child Loop BB0_80 Depth 2
	movq	%rbx, -176(%rbp)                ## 8-byte Spill
	movq	%rsp, -208(%rbp)                ## 8-byte Spill
	movq	_MAX_WIDTH@GOTPCREL(%rip), %rbx
	movl	(%rbx), %eax
	shlq	$2, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r12
	movl	(%rbx), %eax
	shlq	$3, %rax
	callq	____chkstk_darwin
	addq	$15, %rax
	andq	$-16, %rax
	subq	%rax, %rsp
	movq	%rsp, %r14
	movq	-88(%rbp), %rax                 ## 8-byte Reload
	cmpl	$6, %eax
	ja	LBB0_88
## %bb.42:                              ##   in Loop: Header=BB0_41 Depth=1
	leaq	LJTI0_0(%rip), %rcx
	movslq	(%rcx,%rax,4), %rax
	addq	%rcx, %rax
	movq	%r15, -168(%rbp)                ## 8-byte Spill
	jmpq	*%rax
LBB0_43:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.44:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_45:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r15,%rbx,4), %edi
	callq	_USHORT_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_45
	jmp	LBB0_63
LBB0_46:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.47:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_48:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	movl	(%rax,%rbx,8), %edi
	callq	_UINT_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_48
	jmp	LBB0_63
LBB0_49:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.50:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_51:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r15,%rbx,4), %edi
	callq	_UBYTE_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_51
	jmp	LBB0_63
LBB0_52:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.53:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_54:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r15,%rbx,4), %edi
	callq	_SHORT_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_54
	jmp	LBB0_63
LBB0_55:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.56:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_57:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	-56(%rbp), %rax                 ## 8-byte Reload
	movl	(%rax,%rbx,8), %edi
	callq	_INT_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_57
	jmp	LBB0_63
LBB0_58:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.59:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	-72(%rbp), %rax                 ## 8-byte Reload
	imulq	%r13, %rax
	movq	-104(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rsi
	movq	%r12, %rdi
	movq	-112(%rbp), %rdx                ## 8-byte Reload
	callq	_memcpy
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movsd	16(%rax), %xmm8                 ## xmm8 = mem[0],zero
	ucomisd	LCPI0_0(%rip), %xmm8
	jne	LBB0_65
	jp	LBB0_65
	jmp	LBB0_66
LBB0_60:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_63
## %bb.61:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_62:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r15,%rbx,4), %edi
	callq	_BYTE_TO_FLOAT
	movl	%eax, (%r12,%rbx,4)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_62
	.p2align	4, 0x90
LBB0_63:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movsd	16(%rax), %xmm8                 ## xmm8 = mem[0],zero
	ucomisd	LCPI0_0(%rip), %xmm8
	jne	LBB0_64
	jnp	LBB0_66
LBB0_64:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_81
LBB0_65:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movsd	8(%rax), %xmm9                  ## xmm9 = mem[0],zero
	movq	-192(%rbp), %rdx                ## 8-byte Reload
	jmp	LBB0_68
	.p2align	4, 0x90
LBB0_66:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movsd	8(%rax), %xmm9                  ## xmm9 = mem[0],zero
	ucomisd	LCPI0_3(%rip), %xmm9
	movq	-192(%rbp), %rdx                ## 8-byte Reload
	jne	LBB0_67
	jnp	LBB0_78
LBB0_67:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	je	LBB0_78
LBB0_68:                                ##   in Loop: Header=BB0_41 Depth=1
	cmpq	$8, %rdx
	jae	LBB0_70
## %bb.69:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%eax, %eax
	jmp	LBB0_77
	.p2align	4, 0x90
LBB0_70:                                ##   in Loop: Header=BB0_41 Depth=1
	movddup	%xmm8, %xmm3                    ## xmm3 = xmm8[0,0]
	movddup	%xmm9, %xmm2                    ## xmm2 = xmm9[0,0]
	cmpq	$8, -240(%rbp)                  ## 8-byte Folded Reload
	jae	LBB0_72
## %bb.71:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%eax, %eax
	jmp	LBB0_74
LBB0_72:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-216(%rbp), %rcx                ## 8-byte Reload
	xorl	%eax, %eax
	.p2align	4, 0x90
LBB0_73:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movdqa	(%r12,%rax,4), %xmm5
	movdqa	16(%r12,%rax,4), %xmm6
	movdqa	32(%r12,%rax,4), %xmm4
	cvtdq2pd	%xmm5, %xmm7
	pshufd	$238, %xmm5, %xmm5              ## xmm5 = xmm5[2,3,2,3]
	cvtdq2pd	%xmm5, %xmm5
	cvtdq2pd	%xmm6, %xmm0
	movdqa	48(%r12,%rax,4), %xmm1
	pshufd	$238, %xmm6, %xmm6              ## xmm6 = xmm6[2,3,2,3]
	cvtdq2pd	%xmm6, %xmm6
	mulpd	%xmm3, %xmm5
	addpd	%xmm2, %xmm5
	mulpd	%xmm3, %xmm7
	addpd	%xmm2, %xmm7
	mulpd	%xmm3, %xmm6
	addpd	%xmm2, %xmm6
	mulpd	%xmm3, %xmm0
	addpd	%xmm2, %xmm0
	cvttpd2dq	%xmm7, %xmm7
	cvttpd2dq	%xmm5, %xmm5
	cvttpd2dq	%xmm0, %xmm0
	cvttpd2dq	%xmm6, %xmm6
	unpcklpd	%xmm5, %xmm7                    ## xmm7 = xmm7[0],xmm5[0]
	unpcklpd	%xmm6, %xmm0                    ## xmm0 = xmm0[0],xmm6[0]
	cvtdq2pd	%xmm4, %xmm5
	movapd	%xmm7, (%r12,%rax,4)
	pshufd	$238, %xmm4, %xmm4              ## xmm4 = xmm4[2,3,2,3]
	cvtdq2pd	%xmm4, %xmm4
	movapd	%xmm0, 16(%r12,%rax,4)
	cvtdq2pd	%xmm1, %xmm0
	pshufd	$238, %xmm1, %xmm1              ## xmm1 = xmm1[2,3,2,3]
	cvtdq2pd	%xmm1, %xmm1
	mulpd	%xmm3, %xmm4
	addpd	%xmm2, %xmm4
	mulpd	%xmm3, %xmm5
	addpd	%xmm2, %xmm5
	mulpd	%xmm3, %xmm1
	addpd	%xmm2, %xmm1
	mulpd	%xmm3, %xmm0
	addpd	%xmm2, %xmm0
	cvttpd2dq	%xmm5, %xmm5
	cvttpd2dq	%xmm4, %xmm4
	cvttpd2dq	%xmm0, %xmm0
	unpcklpd	%xmm4, %xmm5                    ## xmm5 = xmm5[0],xmm4[0]
	cvttpd2dq	%xmm1, %xmm1
	unpcklpd	%xmm1, %xmm0                    ## xmm0 = xmm0[0],xmm1[0]
	movapd	%xmm5, 32(%r12,%rax,4)
	movapd	%xmm0, 48(%r12,%rax,4)
	addq	$16, %rax
	addq	$-2, %rcx
	jne	LBB0_73
LBB0_74:                                ##   in Loop: Header=BB0_41 Depth=1
	testb	$1, -232(%rbp)                  ## 1-byte Folded Reload
	je	LBB0_76
## %bb.75:                              ##   in Loop: Header=BB0_41 Depth=1
	movdqa	(%r12,%rax,4), %xmm0
	movdqa	16(%r12,%rax,4), %xmm1
	cvtdq2pd	%xmm0, %xmm4
	pshufd	$238, %xmm0, %xmm0              ## xmm0 = xmm0[2,3,2,3]
	cvtdq2pd	%xmm0, %xmm0
	cvtdq2pd	%xmm1, %xmm5
	pshufd	$238, %xmm1, %xmm1              ## xmm1 = xmm1[2,3,2,3]
	cvtdq2pd	%xmm1, %xmm1
	mulpd	%xmm3, %xmm0
	addpd	%xmm2, %xmm0
	mulpd	%xmm3, %xmm4
	addpd	%xmm2, %xmm4
	mulpd	%xmm3, %xmm1
	addpd	%xmm2, %xmm1
	mulpd	%xmm3, %xmm5
	addpd	%xmm2, %xmm5
	cvttpd2dq	%xmm4, %xmm2
	cvttpd2dq	%xmm0, %xmm0
	cvttpd2dq	%xmm5, %xmm3
	cvttpd2dq	%xmm1, %xmm1
	unpcklpd	%xmm0, %xmm2                    ## xmm2 = xmm2[0],xmm0[0]
	unpcklpd	%xmm1, %xmm3                    ## xmm3 = xmm3[0],xmm1[0]
	movapd	%xmm2, (%r12,%rax,4)
	movapd	%xmm3, 16(%r12,%rax,4)
LBB0_76:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-224(%rbp), %rcx                ## 8-byte Reload
	movq	%rcx, %rax
	cmpq	%rcx, %rdx
	je	LBB0_78
	.p2align	4, 0x90
LBB0_77:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	xorps	%xmm0, %xmm0
	cvtsi2sdl	(%r12,%rax,4), %xmm0
	mulsd	%xmm8, %xmm0
	addsd	%xmm9, %xmm0
	cvttsd2si	%xmm0, %ecx
	movl	%ecx, (%r12,%rax,4)
	incq	%rax
	cmpq	%rax, %rdx
	jne	LBB0_77
LBB0_78:                                ##   in Loop: Header=BB0_41 Depth=1
	testq	%r13, %r13
	movq	_DEPTH_SCALE@GOTPCREL(%rip), %r15
	je	LBB0_81
## %bb.79:                              ##   in Loop: Header=BB0_41 Depth=1
	xorl	%ebx, %ebx
	.p2align	4, 0x90
LBB0_80:                                ##   Parent Loop BB0_41 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movl	(%r12,%rbx,4), %edi
	xorps	%xmm0, %xmm0
	movss	LCPI0_2(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	callq	_CLAMP
	movslq	(%r15), %rcx
	cltq
	imulq	%rcx, %rax
	movq	%rax, (%r14,%rbx,8)
	incq	%rbx
	cmpq	%rbx, %r13
	jne	LBB0_80
LBB0_81:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	movq	(%rdi), %rax
	cmpq	$0, 16(%rax)
	je	LBB0_84
## %bb.82:                              ##   in Loop: Header=BB0_41 Depth=1
	cmpb	$0, -80(%rbp)                   ## 1-byte Folded Reload
	movq	-168(%rbp), %r15                ## 8-byte Reload
	movq	-176(%rbp), %rbx                ## 8-byte Reload
	je	LBB0_38
## %bb.83:                              ##   in Loop: Header=BB0_41 Depth=1
	movq	%r13, %rsi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	movq	%rbx, %rcx
	movq	%r14, %r8
	movq	-144(%rbp), %r9                 ## 8-byte Reload
	pushq	-152(%rbp)                      ## 8-byte Folded Reload
	pushq	-120(%rbp)                      ## 8-byte Folded Reload
	pushq	-128(%rbp)                      ## 8-byte Folded Reload
	pushq	-136(%rbp)                      ## 8-byte Folded Reload
	callq	_gl_write_zoomed_color_span
	jmp	LBB0_39
	.p2align	4, 0x90
LBB0_84:                                ##   in Loop: Header=BB0_41 Depth=1
	movq	_GL_BITMAP@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpb	$0, -80(%rbp)                   ## 1-byte Folded Reload
	movq	-168(%rbp), %r15                ## 8-byte Reload
	movq	-176(%rbp), %rbx                ## 8-byte Reload
	je	LBB0_86
## %bb.85:                              ##   in Loop: Header=BB0_41 Depth=1
	subq	$8, %rsp
	movq	%r13, %rsi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	movq	%rbx, %rcx
	movq	%r14, %r8
	movq	-184(%rbp), %r9                 ## 8-byte Reload
	pushq	%rax
	callq	_gl_write_zoomed_index_span
	jmp	LBB0_87
LBB0_86:                                ##   in Loop: Header=BB0_41 Depth=1
	subq	$8, %rsp
	movq	%r13, %rsi
	movq	-96(%rbp), %rdx                 ## 8-byte Reload
	movq	%rbx, %rcx
	movq	%r14, %r8
	movq	-184(%rbp), %r9                 ## 8-byte Reload
	pushq	%rax
	callq	_gl_write_index_span
LBB0_87:                                ##   in Loop: Header=BB0_41 Depth=1
	addq	$16, %rsp
	jmp	LBB0_40
LBB0_88:
	leaq	L_.str(%rip), %rsi
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	callq	_gl_problem
	movq	-208(%rbp), %rsp                ## 8-byte Reload
LBB0_89:
	movq	___stack_chk_guard@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	cmpq	-48(%rbp), %rax
	jne	LBB0_91
## %bb.90:
	leaq	-40(%rbp), %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_91:
	callq	___stack_chk_fail
	.cfi_endproc
	.p2align	2, 0x90
	.data_region jt32
.set L0_0_set_43, LBB0_43-LJTI0_0
.set L0_0_set_46, LBB0_46-LJTI0_0
.set L0_0_set_49, LBB0_49-LJTI0_0
.set L0_0_set_52, LBB0_52-LJTI0_0
.set L0_0_set_55, LBB0_55-LJTI0_0
.set L0_0_set_58, LBB0_58-LJTI0_0
.set L0_0_set_60, LBB0_60-LJTI0_0
LJTI0_0:
	.long	L0_0_set_43
	.long	L0_0_set_46
	.long	L0_0_set_49
	.long	L0_0_set_52
	.long	L0_0_set_55
	.long	L0_0_set_58
	.long	L0_0_set_60
	.end_data_region
                                        ## -- End function
	.comm	_MAX_WIDTH,4,2                  ## @MAX_WIDTH
	.comm	_MAX_DEPTH,8,3                  ## @MAX_DEPTH
	.comm	_GL_BITMAP,4,2                  ## @GL_BITMAP
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"Bad type in draw_depth_pixels"

	.comm	_DEPTH_SCALE,4,2                ## @DEPTH_SCALE
	.no_dead_strip	_draw_depth_pixels
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function draw_depth_pixels
_draw_depth_pixels:                     ; @draw_depth_pixels
	.cfi_startproc
; %bb.0:
	stp	d9, d8, [sp, #-112]!            ; 16-byte Folded Spill
	.cfi_def_cfa_offset 112
	stp	x28, x27, [sp, #16]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #96]             ; 16-byte Folded Spill
	add	x29, sp, #96
	.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
	sub	sp, sp, #160
	mov	x22, x4
	mov	x24, x3
	stur	x2, [x29, #-120]                ; 8-byte Folded Spill
	mov	x23, x1
	mov	x20, x0
Lloh0:
	adrp	x8, ___stack_chk_guard@GOTPAGE
Lloh1:
	ldr	x8, [x8, ___stack_chk_guard@GOTPAGEOFF]
Lloh2:
	ldr	x8, [x8]
	stur	x8, [x29, #-112]
Lloh3:
	adrp	x8, _MAX_WIDTH@GOTPAGE
Lloh4:
	ldr	x8, [x8, _MAX_WIDTH@GOTPAGEOFF]
Lloh5:
	ldr	w12, [x8]
	lsl	x8, x12, #2
	mov	x9, x8
Lloh6:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh7:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x10, x8, #15
	and	x13, x10, #0x7fffffff0
	sub	x9, x9, x13
	stur	x9, [x29, #-168]                ; 8-byte Folded Spill
	mov	sp, x9
	mov	x9, x8
Lloh8:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh9:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x9, x9, x13
	stur	x9, [x29, #-176]                ; 8-byte Folded Spill
	mov	sp, x9
	mov	x9, x8
Lloh10:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh11:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	sub	x9, x9, x13
	stur	x9, [x29, #-184]                ; 8-byte Folded Spill
	mov	sp, x9
	mov	x9, x8
Lloh12:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh13:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x8, sp
	sub	x8, x8, x13
	stur	x8, [x29, #-192]                ; 8-byte Folded Spill
	mov	sp, x8
	lsl	x8, x12, #3
	mov	x9, x8
Lloh14:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh15:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x8, x9, x8
	stur	x8, [x29, #-240]                ; 8-byte Folded Spill
	mov	sp, x8
	ldr	d0, [x0, #8]
	fcmp	d0, #0.0
	b.eq	LBB0_2
; %bb.1:
	mov	w19, #1
	b	LBB0_3
LBB0_2:
	ldr	d0, [x20, #16]
	fmov	d1, #1.00000000
	fcmp	d0, d1
	cset	w19, ne
LBB0_3:
	ldr	d1, [x20, #24]
	fmov	d0, #1.00000000
	fcmp	d1, d0
	b.eq	LBB0_5
; %bb.4:
	mov	w8, #1
	b	LBB0_6
LBB0_5:
	ldr	d1, [x20, #32]
	fcmp	d1, d0
	cset	w8, ne
LBB0_6:
	stur	w8, [x29, #-204]                ; 4-byte Folded Spill
	ldr	x8, [x20, #56]
	ldp	x9, x8, [x8]
	scvtf	s0, x9
	fmov	s1, #0.50000000
	fadd	s0, s0, s1
	fcvtzs	x9, s0
	stur	x9, [x29, #-128]                ; 8-byte Folded Spill
	scvtf	s0, x8
	fadd	s8, s0, s1
	ldr	x8, [x20]
	ldr	x9, [x8, #16]
	stur	x20, [x29, #-216]               ; 8-byte Folded Spill
	cbz	x9, LBB0_8
; %bb.7:
	ldr	x9, [x20, #40]
	ldpsw	x10, x11, [x9]
	ldpsw	x12, x13, [x8]
	mul	x1, x12, x10
	mul	x20, x13, x11
	ldpsw	x10, x9, [x9, #8]
	ldpsw	x11, x8, [x8, #8]
	mul	x25, x11, x10
	mul	x26, x8, x9
	ldur	x0, [x29, #-168]                ; 8-byte Folded Reload
	mov	x2, x23
	bl	_MEMSET
	ldur	x0, [x29, #-176]                ; 8-byte Folded Reload
	mov	x1, x20
	ldur	x20, [x29, #-216]               ; 8-byte Folded Reload
	mov	x2, x23
	bl	_MEMSET
	ldur	x0, [x29, #-184]                ; 8-byte Folded Reload
	mov	x1, x25
	mov	x2, x23
	bl	_MEMSET
	ldur	x0, [x29, #-192]                ; 8-byte Folded Reload
	mov	x1, x26
	mov	x2, x23
	bl	_MEMSET
	b	LBB0_16
LBB0_8:
	cbz	x23, LBB0_16
; %bb.9:
	ldr	x8, [x20, #48]
	cmp	x23, #8
	b.hs	LBB0_11
; %bb.10:
	mov	x9, #0
	b	LBB0_14
LBB0_11:
	and	x9, x23, #0xfffffffffffffff8
	dup.2d	v0, x8
	ldur	x10, [x29, #-240]               ; 8-byte Folded Reload
	add	x10, x10, #32
	mov	x11, x9
LBB0_12:                                ; =>This Inner Loop Header: Depth=1
	stp	q0, q0, [x10, #-32]
	stp	q0, q0, [x10], #64
	subs	x11, x11, #8
	b.ne	LBB0_12
; %bb.13:
	cmp	x9, x23
	b.eq	LBB0_16
LBB0_14:
	sub	x10, x23, x9
	ldur	x11, [x29, #-240]               ; 8-byte Folded Reload
	add	x9, x11, x9, lsl #3
LBB0_15:                                ; =>This Inner Loop Header: Depth=1
	str	x8, [x9], #8
	subs	x10, x10, #1
	b.ne	LBB0_15
LBB0_16:
	fcvtzs	x8, s8
	stur	x8, [x29, #-136]                ; 8-byte Folded Spill
	cmp	w24, #129
	cset	w8, ne
	orr	w8, w8, w19
	ldur	w9, [x29, #-204]                ; 4-byte Folded Reload
	orr	w8, w8, w9
	tbnz	w8, #0, LBB0_29
; %bb.17:
	ldr	x8, [x20]
	ldr	x8, [x8, #16]
	cbz	x8, LBB0_29
; %bb.18:
Lloh16:
	adrp	x8, _MAX_DEPTH@GOTPAGE
Lloh17:
	ldr	x8, [x8, _MAX_DEPTH@GOTPAGEOFF]
Lloh18:
	ldr	x8, [x8]
	and	x9, x8, #0x7fffffff
	clz	x9, x9
	sub	x9, x9, #32
	tst	x8, #0x80000000
	csel	x19, x9, xzr, eq
	ldur	x8, [x29, #-120]                ; 8-byte Folded Reload
	cbz	x8, LBB0_77
; %bb.19:
	mov	x21, #0
	dup.2d	v0, x19
	and	x24, x23, #0xfffffffffffffff8
	add	x25, x22, #32
	lsl	x26, x23, #3
	neg.2d	v4, v0
	stur	q4, [x29, #-160]                ; 16-byte Folded Spill
	b	LBB0_21
LBB0_20:                                ;   in Loop: Header=BB0_21 Depth=1
Lloh19:
	adrp	x8, _GL_BITMAP@GOTPAGE
Lloh20:
	ldr	x8, [x8, _GL_BITMAP@GOTPAGEOFF]
Lloh21:
	ldr	w8, [x8]
	sub	sp, sp, #16
	str	w8, [sp, #8]
	ldur	x8, [x29, #-192]                ; 8-byte Folded Reload
	str	x8, [sp]
	mov	x0, x20
	mov	x1, x23
	ldp	x27, x2, [x29, #-136]           ; 16-byte Folded Reload
	mov	x3, x27
	ldp	x6, x5, [x29, #-176]            ; 16-byte Folded Reload
	ldur	x7, [x29, #-184]                ; 8-byte Folded Reload
	bl	_gl_write_color_span
	ldur	q4, [x29, #-160]                ; 16-byte Folded Reload
	add	sp, sp, #16
	mov	sp, x28
	add	x21, x21, #1
	add	x27, x27, #1
	stur	x27, [x29, #-136]               ; 8-byte Folded Spill
	add	x25, x25, x26
	add	x22, x22, x26
	ldur	x8, [x29, #-120]                ; 8-byte Folded Reload
	cmp	x21, x8
	b.eq	LBB0_77
LBB0_21:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_25 Depth 2
                                        ;     Child Loop BB0_28 Depth 2
	mov	x28, sp
Lloh22:
	adrp	x8, _MAX_WIDTH@GOTPAGE
Lloh23:
	ldr	x8, [x8, _MAX_WIDTH@GOTPAGEOFF]
Lloh24:
	ldr	w8, [x8]
	lsl	x8, x8, #3
	mov	x9, x8
Lloh25:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh26:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x4, x9, x8
	mov	sp, x4
	cbz	x23, LBB0_20
; %bb.22:                               ;   in Loop: Header=BB0_21 Depth=1
	cmp	x23, #8
	b.hs	LBB0_24
; %bb.23:                               ;   in Loop: Header=BB0_21 Depth=1
	mov	x9, #0
	b	LBB0_27
LBB0_24:                                ;   in Loop: Header=BB0_21 Depth=1
	add	x8, x4, #32
	mov	x9, x25
	mov	x10, x24
LBB0_25:                                ;   Parent Loop BB0_21 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	q0, q1, [x9, #-32]
	ldp	q2, q3, [x9], #64
	ushl.2d	v0, v0, v4
	ushl.2d	v1, v1, v4
	ushl.2d	v2, v2, v4
	ushl.2d	v3, v3, v4
	stp	q0, q1, [x8, #-32]
	stp	q2, q3, [x8], #64
	subs	x10, x10, #8
	b.ne	LBB0_25
; %bb.26:                               ;   in Loop: Header=BB0_21 Depth=1
	mov	x9, x24
	cmp	x24, x23
	b.eq	LBB0_20
LBB0_27:                                ;   in Loop: Header=BB0_21 Depth=1
	sub	x8, x23, x9
	lsl	x10, x9, #3
	add	x9, x4, x10
	add	x10, x22, x10
LBB0_28:                                ;   Parent Loop BB0_21 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x11, [x10], #8
	lsr	x11, x11, x19
	str	x11, [x9], #8
	subs	x8, x8, #1
	b.ne	LBB0_28
	b	LBB0_20
LBB0_29:
	ldur	x8, [x29, #-120]                ; 8-byte Folded Reload
	cbz	x8, LBB0_77
; %bb.30:
	mov	x21, #0
	lsl	x8, x23, #2
	stur	x8, [x29, #-248]                ; 8-byte Folded Spill
	cmp	x23, #1
	csinc	x8, x23, xzr, hi
	stur	x8, [x29, #-160]                ; 8-byte Folded Spill
	and	x8, x8, #0xfffffffffffffff8
	stur	x8, [x29, #-232]                ; 8-byte Folded Spill
	sub	w13, w24, #128
	fmov	d8, #1.00000000
Lloh27:
	adrp	x27, _DEPTH_SCALE@GOTPAGE
Lloh28:
	ldr	x27, [x27, _DEPTH_SCALE@GOTPAGEOFF]
	ldur	x28, [x29, #-136]               ; 8-byte Folded Reload
	stur	x22, [x29, #-200]               ; 8-byte Folded Spill
	stur	x13, [x29, #-224]               ; 8-byte Folded Spill
	b	LBB0_34
LBB0_31:                                ;   in Loop: Header=BB0_34 Depth=1
Lloh29:
	adrp	x8, _GL_BITMAP@GOTPAGE
Lloh30:
	ldr	x8, [x8, _GL_BITMAP@GOTPAGEOFF]
Lloh31:
	ldr	w8, [x8]
	sub	sp, sp, #16
	str	w8, [sp, #8]
	ldur	x8, [x29, #-192]                ; 8-byte Folded Reload
	str	x8, [sp]
	mov	x0, x20
	mov	x1, x23
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
	mov	x3, x28
	mov	x4, x24
	ldp	x6, x5, [x29, #-176]            ; 16-byte Folded Reload
	ldur	x7, [x29, #-184]                ; 8-byte Folded Reload
	bl	_gl_write_color_span
LBB0_32:                                ;   in Loop: Header=BB0_34 Depth=1
	add	sp, sp, #16
LBB0_33:                                ;   in Loop: Header=BB0_34 Depth=1
	mov	sp, x19
	add	x21, x21, #1
	add	x28, x28, #1
	ldur	x8, [x29, #-120]                ; 8-byte Folded Reload
	cmp	x21, x8
	ldur	x13, [x29, #-224]               ; 8-byte Folded Reload
	b.eq	LBB0_77
LBB0_34:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_55 Depth 2
                                        ;     Child Loop BB0_50 Depth 2
                                        ;     Child Loop BB0_47 Depth 2
                                        ;     Child Loop BB0_44 Depth 2
                                        ;     Child Loop BB0_41 Depth 2
                                        ;     Child Loop BB0_38 Depth 2
                                        ;     Child Loop BB0_63 Depth 2
                                        ;     Child Loop BB0_66 Depth 2
                                        ;     Child Loop BB0_69 Depth 2
	mov	x19, sp
Lloh32:
	adrp	x12, _MAX_WIDTH@GOTPAGE
Lloh33:
	ldr	x12, [x12, _MAX_WIDTH@GOTPAGEOFF]
	ldr	w8, [x12]
	lsl	x8, x8, #2
	mov	x9, x8
Lloh34:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh35:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0x7fffffff0
	sub	x25, x9, x8
	mov	sp, x25
	ldr	w8, [x12]
	lsl	x8, x8, #3
	mov	x9, x8
Lloh36:
	adrp	x16, ___chkstk_darwin@GOTPAGE
Lloh37:
	ldr	x16, [x16, ___chkstk_darwin@GOTPAGEOFF]
	blr	x16
	mov	x9, sp
	add	x8, x8, #15
	and	x8, x8, #0xffffffff0
	sub	x24, x9, x8
	mov	sp, x24
	cmp	w13, #6
	b.hi	LBB0_76
; %bb.35:                               ;   in Loop: Header=BB0_34 Depth=1
	mul	x8, x21, x23
	add	x26, x22, x8, lsl #2
Lloh38:
	adrp	x11, lJTI0_0@PAGE
Lloh39:
	add	x11, x11, lJTI0_0@PAGEOFF
	adr	x9, LBB0_36
	ldrb	w10, [x11, x13]
	add	x9, x9, x10, lsl #2
	br	x9
LBB0_36:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.37:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x22, x25
	mov	x20, x23
LBB0_38:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x26], #4
	bl	_USHORT_TO_FLOAT
	str	w0, [x22], #4
	subs	x20, x20, #1
	b.ne	LBB0_38
	b	LBB0_56
LBB0_39:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.40:                               ;   in Loop: Header=BB0_34 Depth=1
	ldur	x9, [x29, #-200]                ; 8-byte Folded Reload
	add	x22, x9, x8, lsl #3
	mov	x26, x25
	mov	x20, x23
LBB0_41:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x22], #8
	bl	_UINT_TO_FLOAT
	str	w0, [x26], #4
	subs	x20, x20, #1
	b.ne	LBB0_41
	b	LBB0_56
LBB0_42:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.43:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x22, x25
	mov	x20, x23
LBB0_44:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x26], #4
	bl	_UBYTE_TO_FLOAT
	str	w0, [x22], #4
	subs	x20, x20, #1
	b.ne	LBB0_44
	b	LBB0_56
LBB0_45:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.46:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x22, x25
	mov	x20, x23
LBB0_47:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x26], #4
	bl	_SHORT_TO_FLOAT
	str	w0, [x22], #4
	subs	x20, x20, #1
	b.ne	LBB0_47
	b	LBB0_56
LBB0_48:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.49:                               ;   in Loop: Header=BB0_34 Depth=1
	ldur	x9, [x29, #-200]                ; 8-byte Folded Reload
	add	x22, x9, x8, lsl #3
	mov	x26, x25
	mov	x20, x23
LBB0_50:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x22], #8
	bl	_INT_TO_FLOAT
	str	w0, [x26], #4
	subs	x20, x20, #1
	b.ne	LBB0_50
	b	LBB0_56
LBB0_51:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.52:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x0, x25
	mov	x1, x26
	ldur	x2, [x29, #-248]                ; 8-byte Folded Reload
	bl	_memcpy
	ldur	x20, [x29, #-216]               ; 8-byte Folded Reload
	ldr	d0, [x20, #16]
	fcmp	d0, d8
	b.ne	LBB0_58
	b	LBB0_59
LBB0_53:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_56
; %bb.54:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x22, x25
	mov	x20, x23
LBB0_55:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x26], #4
	bl	_BYTE_TO_FLOAT
	str	w0, [x22], #4
	subs	x20, x20, #1
	b.ne	LBB0_55
LBB0_56:                                ;   in Loop: Header=BB0_34 Depth=1
	ldur	x20, [x29, #-216]               ; 8-byte Folded Reload
	ldr	d0, [x20, #16]
	fcmp	d0, d8
	b.eq	LBB0_59
; %bb.57:                               ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_70
LBB0_58:                                ;   in Loop: Header=BB0_34 Depth=1
	ldr	d1, [x20, #8]
	b	LBB0_60
LBB0_59:                                ;   in Loop: Header=BB0_34 Depth=1
	ldr	d1, [x20, #8]
	fcmp	d1, #0.0
	ccmp	x23, #0, #4, ne
	b.eq	LBB0_67
LBB0_60:                                ;   in Loop: Header=BB0_34 Depth=1
	ldur	x8, [x29, #-160]                ; 8-byte Folded Reload
	cmp	x8, #8
	b.hs	LBB0_62
; %bb.61:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x9, #0
	b	LBB0_65
LBB0_62:                                ;   in Loop: Header=BB0_34 Depth=1
	dup.2d	v2, v0[0]
	dup.2d	v3, v1[0]
	add	x8, x25, #16
	ldur	x9, [x29, #-232]                ; 8-byte Folded Reload
LBB0_63:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldp	d4, d5, [x8, #-16]
	ldp	d6, d7, [x8]
	sshll.2d	v4, v4, #0
	scvtf.2d	v4, v4
	sshll.2d	v5, v5, #0
	scvtf.2d	v5, v5
	sshll.2d	v6, v6, #0
	scvtf.2d	v6, v6
	sshll.2d	v7, v7, #0
	scvtf.2d	v7, v7
	mov.16b	v16, v3
	fmla.2d	v16, v2, v4
	mov.16b	v4, v3
	fmla.2d	v4, v2, v5
	mov.16b	v5, v3
	fmla.2d	v5, v2, v6
	mov.16b	v6, v3
	fmla.2d	v6, v2, v7
	fcvtzs.2d	v7, v16
	xtn.2s	v7, v7
	fcvtzs.2d	v4, v4
	xtn.2s	v4, v4
	fcvtzs.2d	v5, v5
	xtn.2s	v5, v5
	fcvtzs.2d	v6, v6
	stp	d7, d4, [x8, #-16]
	xtn.2s	v4, v6
	stp	d5, d4, [x8], #32
	subs	x9, x9, #8
	b.ne	LBB0_63
; %bb.64:                               ;   in Loop: Header=BB0_34 Depth=1
	ldur	x10, [x29, #-232]               ; 8-byte Folded Reload
	mov	x9, x10
	ldur	x8, [x29, #-160]                ; 8-byte Folded Reload
	cmp	x8, x10
	b.eq	LBB0_67
LBB0_65:                                ;   in Loop: Header=BB0_34 Depth=1
	ldur	x8, [x29, #-160]                ; 8-byte Folded Reload
	sub	x8, x8, x9
	add	x9, x25, x9, lsl #2
LBB0_66:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	s2, [x9]
	sshll.2d	v2, v2, #0
	scvtf	d2, d2
	fmadd	d2, d2, d0, d1
	fcvtzs	w10, d2
	str	w10, [x9], #4
	subs	x8, x8, #1
	b.ne	LBB0_66
LBB0_67:                                ;   in Loop: Header=BB0_34 Depth=1
	cbz	x23, LBB0_70
; %bb.68:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x26, x24
	mov	x22, x23
LBB0_69:                                ;   Parent Loop BB0_34 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	w0, [x25], #4
	movi	d0, #0000000000000000
	fmov	s1, #1.00000000
	bl	_CLAMP
                                        ; kill: def $w0 killed $w0 def $x0
	ldrsw	x8, [x27]
	sxtw	x9, w0
	mul	x8, x8, x9
	str	x8, [x26], #8
	subs	x22, x22, #1
	b.ne	LBB0_69
LBB0_70:                                ;   in Loop: Header=BB0_34 Depth=1
	ldr	x8, [x20]
	ldr	x8, [x8, #16]
	cbz	x8, LBB0_73
; %bb.71:                               ;   in Loop: Header=BB0_34 Depth=1
	ldur	x22, [x29, #-200]               ; 8-byte Folded Reload
	ldur	w8, [x29, #-204]                ; 4-byte Folded Reload
	cbz	w8, LBB0_31
; %bb.72:                               ;   in Loop: Header=BB0_34 Depth=1
	sub	sp, sp, #16
	ldur	x8, [x29, #-136]                ; 8-byte Folded Reload
	str	x8, [sp, #8]
	ldur	x8, [x29, #-192]                ; 8-byte Folded Reload
	str	x8, [sp]
	mov	x0, x20
	mov	x1, x23
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
	mov	x3, x28
	mov	x4, x24
	ldp	x6, x5, [x29, #-176]            ; 16-byte Folded Reload
	ldur	x7, [x29, #-184]                ; 8-byte Folded Reload
	bl	_gl_write_zoomed_color_span
	b	LBB0_32
LBB0_73:                                ;   in Loop: Header=BB0_34 Depth=1
Lloh40:
	adrp	x8, _GL_BITMAP@GOTPAGE
Lloh41:
	ldr	x8, [x8, _GL_BITMAP@GOTPAGEOFF]
Lloh42:
	ldr	w6, [x8]
	ldur	x22, [x29, #-200]               ; 8-byte Folded Reload
	ldur	w8, [x29, #-204]                ; 4-byte Folded Reload
	cbz	w8, LBB0_75
; %bb.74:                               ;   in Loop: Header=BB0_34 Depth=1
	mov	x0, x20
	mov	x1, x23
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
	mov	x3, x28
	mov	x4, x24
	ldur	x5, [x29, #-240]                ; 8-byte Folded Reload
	bl	_gl_write_zoomed_index_span
	b	LBB0_33
LBB0_75:                                ;   in Loop: Header=BB0_34 Depth=1
	mov	x0, x20
	mov	x1, x23
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
	mov	x3, x28
	mov	x4, x24
	ldur	x5, [x29, #-240]                ; 8-byte Folded Reload
	bl	_gl_write_index_span
	b	LBB0_33
LBB0_76:
Lloh43:
	adrp	x1, l_.str@PAGE
Lloh44:
	add	x1, x1, l_.str@PAGEOFF
	mov	x0, x20
	bl	_gl_problem
	mov	sp, x19
LBB0_77:
	ldur	x8, [x29, #-112]
Lloh45:
	adrp	x9, ___stack_chk_guard@GOTPAGE
Lloh46:
	ldr	x9, [x9, ___stack_chk_guard@GOTPAGEOFF]
Lloh47:
	ldr	x9, [x9]
	cmp	x9, x8
	b.ne	LBB0_79
; %bb.78:
	sub	sp, x29, #96
	ldp	x29, x30, [sp, #96]             ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #80]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp], #112              ; 16-byte Folded Reload
	ret
LBB0_79:
	bl	___stack_chk_fail
	.loh AdrpLdrGot	Lloh14, Lloh15
	.loh AdrpLdrGot	Lloh12, Lloh13
	.loh AdrpLdrGot	Lloh10, Lloh11
	.loh AdrpLdrGot	Lloh8, Lloh9
	.loh AdrpLdrGot	Lloh6, Lloh7
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh16, Lloh17, Lloh18
	.loh AdrpLdrGotLdr	Lloh19, Lloh20, Lloh21
	.loh AdrpLdrGot	Lloh25, Lloh26
	.loh AdrpLdrGotLdr	Lloh22, Lloh23, Lloh24
	.loh AdrpLdrGot	Lloh27, Lloh28
	.loh AdrpLdrGotLdr	Lloh29, Lloh30, Lloh31
	.loh AdrpLdrGot	Lloh36, Lloh37
	.loh AdrpLdrGot	Lloh34, Lloh35
	.loh AdrpLdrGot	Lloh32, Lloh33
	.loh AdrpAdd	Lloh38, Lloh39
	.loh AdrpLdrGotLdr	Lloh40, Lloh41, Lloh42
	.loh AdrpAdd	Lloh43, Lloh44
	.loh AdrpLdrGotLdr	Lloh45, Lloh46, Lloh47
	.cfi_endproc
	.section	__TEXT,__const
lJTI0_0:
	.byte	(LBB0_36-LBB0_36)>>2
	.byte	(LBB0_39-LBB0_36)>>2
	.byte	(LBB0_42-LBB0_36)>>2
	.byte	(LBB0_45-LBB0_36)>>2
	.byte	(LBB0_48-LBB0_36)>>2
	.byte	(LBB0_51-LBB0_36)>>2
	.byte	(LBB0_53-LBB0_36)>>2
                                        ; -- End function
	.comm	_MAX_WIDTH,4,2                  ; @MAX_WIDTH
	.comm	_MAX_DEPTH,8,3                  ; @MAX_DEPTH
	.comm	_GL_BITMAP,4,2                  ; @GL_BITMAP
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"Bad type in draw_depth_pixels"

	.comm	_DEPTH_SCALE,4,2                ; @DEPTH_SCALE
	.no_dead_strip	_draw_depth_pixels
.subsections_via_symbols
