	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3                               ## -- Begin function gdImageFilledPolygon
LCPI0_0:
	.quad	0x3fe0000000000000              ## double 0.5
	.section	__TEXT,__text,regular,pure_instructions
	.globl	_gdImageFilledPolygon
	.p2align	4, 0x90
_gdImageFilledPolygon:                  ## @gdImageFilledPolygon
	.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	$40, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	testl	%edx, %edx
	jle	LBB0_52
## %bb.1:
	movl	%ecx, %r14d
	movl	%edx, %r15d
	movq	%rsi, %r13
	movq	%rdi, %rbx
	movl	$4, %edi
	movl	%edx, %esi
	callq	_overflow2
	testq	%rax, %rax
	je	LBB0_2
LBB0_52:
	addq	$40, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_2:
	movq	_gdAntiAliased@GOTPCREL(%rip), %rax
	movl	%r14d, %r9d
	cmpl	%r14d, (%rax)
	jne	LBB0_4
## %bb.3:
	movl	(%rbx), %r9d
LBB0_4:
	movl	4(%rbx), %esi
	testl	%esi, %esi
	je	LBB0_5
## %bb.6:
	cmpl	%r15d, %esi
	jge	LBB0_11
## %bb.7:
	movl	%r9d, %r12d
	.p2align	4, 0x90
LBB0_8:                                 ## =>This Inner Loop Header: Depth=1
	addl	%esi, %esi
	cmpl	%r15d, %esi
	jl	LBB0_8
## %bb.9:
	movl	%esi, 4(%rbx)
	movl	$4, %edi
	callq	_overflow2
	testq	%rax, %rax
	jne	LBB0_52
## %bb.10:
	movq	8(%rbx), %rdi
	movl	4(%rbx), %esi
	shll	$2, %esi
	callq	_gdRealloc
	movq	%rax, 8(%rbx)
	movl	%r12d, %r9d
	jmp	LBB0_11
LBB0_5:
	leal	(,%r15,4), %edi
	movl	%r9d, %r12d
	callq	_gdMalloc
	movl	%r12d, %r9d
	movq	%rax, 8(%rbx)
	movl	%r15d, 4(%rbx)
LBB0_11:
	movl	%r15d, %esi
	movl	(%r13), %r12d
	cmpl	$2, %r15d
	movq	%rsi, -64(%rbp)                 ## 8-byte Spill
	jl	LBB0_12
## %bb.21:
	leaq	-1(%rsi), %r8
	movl	$1, %ecx
	cmpq	$9, %r8
	jae	LBB0_23
## %bb.22:
	movl	%r12d, %edx
	jmp	LBB0_26
LBB0_12:
	movl	%r14d, -44(%rbp)                ## 4-byte Spill
	movl	%r12d, %edx
	jmp	LBB0_13
LBB0_23:
	movl	%r8d, %eax
	andl	$7, %eax
	testq	%rax, %rax
	movl	$8, %ecx
	cmovneq	%rax, %rcx
	movq	%r8, %rax
	subq	%rcx, %rax
	negq	%rcx
	addq	%r8, %rcx
	incq	%rcx
	movd	%r12d, %xmm0
	pshufd	$0, %xmm0, %xmm0                ## xmm0 = xmm0[0,0,0,0]
	xorl	%edx, %edx
	movdqa	%xmm0, %xmm1
	movdqa	%xmm0, %xmm2
	movdqa	%xmm0, %xmm3
	.p2align	4, 0x90
LBB0_24:                                ## =>This Inner Loop Header: Depth=1
	movups	8(%r13,%rdx,8), %xmm4
	movups	24(%r13,%rdx,8), %xmm5
	shufps	$136, %xmm5, %xmm4              ## xmm4 = xmm4[0,2],xmm5[0,2]
	movups	40(%r13,%rdx,8), %xmm5
	movups	56(%r13,%rdx,8), %xmm6
	shufps	$136, %xmm6, %xmm5              ## xmm5 = xmm5[0,2],xmm6[0,2]
	pminsd	%xmm4, %xmm2
	pminsd	%xmm5, %xmm3
	pmaxsd	%xmm4, %xmm0
	pmaxsd	%xmm5, %xmm1
	addq	$8, %rdx
	cmpq	%rdx, %rax
	jne	LBB0_24
## %bb.25:
	pminsd	%xmm3, %xmm2
	pshufd	$238, %xmm2, %xmm3              ## xmm3 = xmm2[2,3,2,3]
	pminsd	%xmm2, %xmm3
	pshufd	$85, %xmm3, %xmm2               ## xmm2 = xmm3[1,1,1,1]
	pminsd	%xmm3, %xmm2
	movd	%xmm2, %edx
	pmaxsd	%xmm1, %xmm0
	pshufd	$238, %xmm0, %xmm1              ## xmm1 = xmm0[2,3,2,3]
	pmaxsd	%xmm0, %xmm1
	pshufd	$85, %xmm1, %xmm0               ## xmm0 = xmm1[1,1,1,1]
	pmaxsd	%xmm1, %xmm0
	movd	%xmm0, %r12d
	.p2align	4, 0x90
LBB0_26:                                ## =>This Inner Loop Header: Depth=1
	movl	(%r13,%rcx,8), %eax
	cmpl	%edx, %eax
	cmovll	%eax, %edx
	cmpl	%r12d, %eax
	cmovgl	%eax, %r12d
	incq	%rcx
	cmpq	%rcx, %rsi
	jne	LBB0_26
## %bb.27:
	cmpl	%r12d, %edx
	jne	LBB0_28
## %bb.29:
	movq	%rbx, %rdi
	movl	4(%r13), %ecx
	cmpl	$2, %r15d
	jne	LBB0_31
## %bb.30:
	movl	$1, %r10d
	movl	%ecx, %esi
LBB0_35:
	testb	$1, %r8b
	je	LBB0_37
## %bb.36:
	movl	4(%r13,%r10,8), %eax
	cmpl	%ecx, %eax
	movl	%ecx, %ebx
	cmovgl	%eax, %ebx
	cmpl	%esi, %eax
	cmovll	%eax, %esi
	cmovgel	%ebx, %ecx
LBB0_37:
	movl	%edx, %r8d
	movl	%r14d, %r9d
	addq	$40, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_gdImageLine                    ## TAILCALL
LBB0_28:
	movl	%r14d, -44(%rbp)                ## 4-byte Spill
LBB0_13:
	movl	%r9d, -56(%rbp)                 ## 4-byte Spill
	xorl	%r14d, %r14d
	testl	%edx, %edx
	cmovgl	%edx, %r14d
	movq	%rbx, %rdi
	callq	_gdImageSY
	movl	%r12d, %ecx
	cmpl	%eax, %r12d
	movl	%r12d, %r11d
	movl	%r12d, -48(%rbp)                ## 4-byte Spill
	jl	LBB0_15
## %bb.14:
	movq	%rbx, %rdi
	callq	_gdImageSY
	movl	-48(%rbp), %r11d                ## 4-byte Reload
	movl	%eax, %ecx
	decl	%ecx
LBB0_15:
	cmpl	%ecx, %r14d
	movq	-64(%rbp), %r10                 ## 8-byte Reload
	jle	LBB0_16
LBB0_51:
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	movq	_gdAntiAliased@GOTPCREL(%rip), %rax
	cmpl	%ecx, (%rax)
	jne	LBB0_52
## %bb.53:
	movq	%rbx, %rdi
	movq	%r13, %rsi
	movl	%r15d, %edx
	addq	$40, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_gdImagePolygon                 ## TAILCALL
LBB0_16:
	movsd	LCPI0_0(%rip), %xmm2            ## xmm2 = mem[0],zero
	movq	%r15, -80(%rbp)                 ## 8-byte Spill
	movq	%r13, -72(%rbp)                 ## 8-byte Spill
	movl	%ecx, -52(%rbp)                 ## 4-byte Spill
	jmp	LBB0_17
	.p2align	4, 0x90
LBB0_50:                                ##   in Loop: Header=BB0_17 Depth=1
	leal	1(%r14), %eax
	movl	-52(%rbp), %ecx                 ## 4-byte Reload
	cmpl	%ecx, %r14d
	movl	%eax, %r14d
	movq	-80(%rbp), %r15                 ## 8-byte Reload
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	movq	-64(%rbp), %r10                 ## 8-byte Reload
	movl	-48(%rbp), %r11d                ## 4-byte Reload
	movsd	LCPI0_0(%rip), %xmm2            ## xmm2 = mem[0],zero
	je	LBB0_51
LBB0_17:                                ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_19 Depth 2
                                        ##     Child Loop BB0_49 Depth 2
	movl	$0, %r12d
	testl	%r15d, %r15d
	jle	LBB0_47
## %bb.18:                              ##   in Loop: Header=BB0_17 Depth=1
	xorl	%eax, %eax
	xorl	%r12d, %r12d
	jmp	LBB0_19
	.p2align	4, 0x90
LBB0_41:                                ##   in Loop: Header=BB0_19 Depth=2
	movl	4(%r13,%r8,8), %ecx
	subl	%ecx, %edx
	imull	%ebx, %edx
	xorps	%xmm0, %xmm0
	cvtsi2ss	%edx, %xmm0
	subl	%edi, %esi
	xorps	%xmm1, %xmm1
	cvtsi2ss	%esi, %xmm1
	divss	%xmm1, %xmm0
	cvtss2sd	%xmm0, %xmm0
	xorps	%xmm1, %xmm1
	cvtsi2sd	%ecx, %xmm1
	addsd	%xmm2, %xmm0
	addsd	%xmm0, %xmm1
	cvttsd2si	%xmm1, %edx
	movq	%r9, %rbx
LBB0_45:                                ##   in Loop: Header=BB0_19 Depth=2
	movq	8(%rbx), %rcx
	movslq	%r12d, %rsi
	incl	%r12d
	movl	%edx, (%rcx,%rsi,4)
LBB0_46:                                ##   in Loop: Header=BB0_19 Depth=2
	incq	%rax
	cmpq	%rax, %r10
	je	LBB0_47
LBB0_19:                                ##   Parent Loop BB0_17 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	testq	%rax, %rax
	movl	%eax, %ecx
	cmovel	%r10d, %ecx
	movslq	%ecx, %rdx
	movl	-8(%r13,%rdx,8), %esi
	decq	%rdx
	movl	(%r13,%rax,8), %ecx
	cmpl	%ecx, %esi
	jge	LBB0_38
## %bb.20:                              ##   in Loop: Header=BB0_19 Depth=2
	movq	%rdx, %r8
	movl	%esi, %edi
	movq	%rax, %rdx
	movl	%ecx, %esi
	jmp	LBB0_39
	.p2align	4, 0x90
LBB0_38:                                ##   in Loop: Header=BB0_19 Depth=2
	movq	%rax, %r8
	movl	%ecx, %edi
	jle	LBB0_46
LBB0_39:                                ##   in Loop: Header=BB0_19 Depth=2
	movq	%rbx, %r9
	movl	4(%r13,%rdx,8), %edx
	movl	%r14d, %ebx
	subl	%edi, %ebx
	jl	LBB0_42
## %bb.40:                              ##   in Loop: Header=BB0_19 Depth=2
	cmpl	%esi, %r14d
	jl	LBB0_41
LBB0_42:                                ##   in Loop: Header=BB0_19 Depth=2
	cmpl	%r11d, %r14d
	jne	LBB0_43
## %bb.44:                              ##   in Loop: Header=BB0_19 Depth=2
	cmpl	%esi, %r14d
	movq	%r9, %rbx
	je	LBB0_45
	jmp	LBB0_46
LBB0_43:                                ##   in Loop: Header=BB0_19 Depth=2
	movq	%r9, %rbx
	jmp	LBB0_46
	.p2align	4, 0x90
LBB0_47:                                ##   in Loop: Header=BB0_17 Depth=1
	movq	8(%rbx), %rdi
	movq	_gdCompareInt@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movl	%r12d, %esi
	movl	$4, %edx
	callq	_qsort
	cmpl	$2, %r12d
	movl	-56(%rbp), %r13d                ## 4-byte Reload
	jl	LBB0_50
## %bb.48:                              ##   in Loop: Header=BB0_17 Depth=1
	decl	%r12d
	xorl	%r15d, %r15d
	.p2align	4, 0x90
LBB0_49:                                ##   Parent Loop BB0_17 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	movq	8(%rbx), %rax
	movl	(%rax,%r15,4), %esi
	movl	4(%rax,%r15,4), %ecx
	movq	%rbx, %rdi
	movl	%r14d, %edx
	movl	%r14d, %r8d
	movl	%r13d, %r9d
	callq	_gdImageLine
	addq	$2, %r15
	cmpl	%r15d, %r12d
	jg	LBB0_49
	jmp	LBB0_50
LBB0_31:
	movq	%r8, %r9
	andq	$-2, %r9
	negq	%r9
	movl	$1, %r10d
	movl	%ecx, %esi
	jmp	LBB0_32
	.p2align	4, 0x90
LBB0_34:                                ##   in Loop: Header=BB0_32 Depth=1
	cmpl	%esi, %ebx
	cmovll	%ebx, %esi
	cmovll	%eax, %ecx
	leaq	(%r9,%r10), %rax
	addq	$2, %rax
	addq	$2, %r10
	cmpq	$1, %rax
	je	LBB0_35
LBB0_32:                                ## =>This Inner Loop Header: Depth=1
	movl	4(%r13,%r10,8), %ebx
	cmpl	%ecx, %ebx
	movl	%ecx, %eax
	cmovgl	%ebx, %eax
	cmpl	%esi, %ebx
	cmovll	%ebx, %esi
	movl	12(%r13,%r10,8), %ebx
	cmovll	%ecx, %eax
	movl	%ebx, %ecx
	cmpl	%eax, %ebx
	jg	LBB0_34
## %bb.33:                              ##   in Loop: Header=BB0_32 Depth=1
	movl	%eax, %ecx
	jmp	LBB0_34
	.cfi_endproc
                                        ## -- End function
	.comm	_gdAntiAliased,4,2              ## @gdAntiAliased
	.comm	_gdCompareInt,4,2               ## @gdCompareInt
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_gdImageFilledPolygon           ; -- Begin function gdImageFilledPolygon
	.p2align	2
_gdImageFilledPolygon:                  ; @gdImageFilledPolygon
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #128
	.cfi_def_cfa_offset 128
	stp	d9, d8, [sp, #16]               ; 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #112]            ; 16-byte Folded Spill
	add	x29, sp, #112
	.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
	cmp	w2, #1
	b.lt	LBB0_2
; %bb.1:
	mov	x19, x3
	mov	x22, x2
	mov	x21, x1
	mov	x20, x0
	mov	w0, #4
	mov	x1, x2
	bl	_overflow2
	cbz	x0, LBB0_3
LBB0_2:
	ldp	x29, x30, [sp, #112]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #96]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #16]               ; 16-byte Folded Reload
	add	sp, sp, #128
	ret
LBB0_3:
Lloh0:
	adrp	x8, _gdAntiAliased@GOTPAGE
Lloh1:
	ldr	x8, [x8, _gdAntiAliased@GOTPAGEOFF]
Lloh2:
	ldr	w8, [x8]
	mov	x23, x19
	cmp	w8, w19
	b.ne	LBB0_5
; %bb.4:
	ldr	w23, [x20]
LBB0_5:
	ldr	w1, [x20, #4]
	cbz	w1, LBB0_10
; %bb.6:
	cmp	w1, w22
	b.ge	LBB0_11
LBB0_7:                                 ; =>This Inner Loop Header: Depth=1
	lsl	w1, w1, #1
	cmp	w1, w22
	b.lt	LBB0_7
; %bb.8:
	str	w1, [x20, #4]
	mov	w0, #4
	bl	_overflow2
	cbnz	x0, LBB0_2
; %bb.9:
	ldr	x0, [x20, #8]
	ldr	w8, [x20, #4]
	lsl	w1, w8, #2
	bl	_gdRealloc
	str	x0, [x20, #8]
	b	LBB0_11
LBB0_10:
	lsl	w0, w22, #2
	bl	_gdMalloc
	str	x0, [x20, #8]
	str	w22, [x20, #4]
LBB0_11:
	mov	w27, w22
	ldr	w28, [x21]
	cmp	w22, #2
	b.lt	LBB0_14
; %bb.12:
	sub	x8, x27, #1
	cmp	x8, #17
	b.hs	LBB0_15
; %bb.13:
	mov	w9, #1
	mov	x2, x28
	b	LBB0_18
LBB0_14:
	str	w19, [sp, #12]                  ; 4-byte Folded Spill
	mov	x2, x28
	b	LBB0_25
LBB0_15:
	ands	x9, x8, #0xf
	mov	w10, #16
	csel	x9, x10, x9, eq
	sub	x10, x8, x9
	add	x9, x10, #1
	dup.4s	v0, w28
	add	x11, x21, #72
	mov.16b	v1, v0
	mov.16b	v2, v0
	mov.16b	v3, v0
	mov.16b	v4, v0
	mov.16b	v5, v0
	mov.16b	v6, v0
	mov.16b	v7, v0
LBB0_16:                                ; =>This Inner Loop Header: Depth=1
	sub	x12, x11, #64
	ld2.4s	{ v16, v17 }, [x12]
	sub	x12, x11, #32
	ld2.4s	{ v18, v19 }, [x12]
	mov	x12, x11
	ld2.4s	{ v20, v21 }, [x12], #32
	ld2.4s	{ v22, v23 }, [x12]
	smin.4s	v4, v16, v4
	smin.4s	v5, v18, v5
	smin.4s	v6, v20, v6
	smin.4s	v7, v22, v7
	smax.4s	v0, v16, v0
	smax.4s	v1, v18, v1
	smax.4s	v2, v20, v2
	smax.4s	v3, v22, v3
	add	x11, x11, #128
	subs	x10, x10, #16
	b.ne	LBB0_16
; %bb.17:
	smin.4s	v4, v4, v5
	smin.4s	v4, v4, v6
	smin.4s	v4, v4, v7
	sminv.4s	s4, v4
	fmov	w2, s4
	smax.4s	v0, v0, v1
	smax.4s	v0, v0, v2
	smax.4s	v0, v0, v3
	smaxv.4s	s0, v0
	fmov	w28, s0
LBB0_18:
	add	x10, x21, x9, lsl #3
	sub	x9, x27, x9
LBB0_19:                                ; =>This Inner Loop Header: Depth=1
	ldr	w11, [x10], #8
	cmp	w11, w2
	csel	w2, w11, w2, lt
	cmp	w11, w28
	csel	w28, w11, w28, gt
	subs	x9, x9, #1
	b.ne	LBB0_19
; %bb.20:
	cmp	w2, w28
	b.ne	LBB0_24
; %bb.21:
	ldr	w3, [x21, #4]
	add	x9, x21, #12
	mov	x1, x3
LBB0_22:                                ; =>This Inner Loop Header: Depth=1
	ldr	w10, [x9], #8
	cmp	w10, w3
	csel	w11, w10, w3, gt
	cmp	w10, w1
	csel	w1, w10, w1, lt
	csel	w3, w3, w11, lt
	subs	x8, x8, #1
	b.ne	LBB0_22
; %bb.23:
	mov	x0, x20
	mov	x4, x2
	mov	x5, x19
	ldp	x29, x30, [sp, #112]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #96]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #16]               ; 16-byte Folded Reload
	add	sp, sp, #128
	b	_gdImageLine
LBB0_24:
	str	w19, [sp, #12]                  ; 4-byte Folded Spill
LBB0_25:
	cmp	w2, #0
	csel	w24, w2, wzr, gt
	mov	x0, x20
	bl	_gdImageSY
	mov	x26, x28
	cmp	w28, w0
	b.lt	LBB0_27
; %bb.26:
	mov	x0, x20
	bl	_gdImageSY
	sub	w26, w0, #1
LBB0_27:
	cmp	w24, w26
	b.le	LBB0_30
LBB0_28:
Lloh3:
	adrp	x8, _gdAntiAliased@GOTPAGE
Lloh4:
	ldr	x8, [x8, _gdAntiAliased@GOTPAGEOFF]
Lloh5:
	ldr	w8, [x8]
	ldr	w3, [sp, #12]                   ; 4-byte Folded Reload
	cmp	w8, w3
	b.ne	LBB0_2
; %bb.29:
	mov	x0, x20
	mov	x1, x21
	mov	x2, x22
	ldp	x29, x30, [sp, #112]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #96]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             ; 16-byte Folded Reload
	ldp	d9, d8, [sp, #16]               ; 16-byte Folded Reload
	add	sp, sp, #128
	b	_gdImagePolygon
LBB0_30:
	fmov	d8, #0.50000000
	b	LBB0_32
LBB0_31:                                ;   in Loop: Header=BB0_32 Depth=1
	add	w8, w24, #1
	cmp	w24, w26
	mov	x24, x8
	b.eq	LBB0_28
LBB0_32:                                ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_37 Depth 2
                                        ;     Child Loop BB0_46 Depth 2
	cmp	w22, #1
	b.lt	LBB0_43
; %bb.33:                               ;   in Loop: Header=BB0_32 Depth=1
	mov	x8, #0
	mov	w25, #0
	mov	x9, x21
	b	LBB0_37
LBB0_34:                                ;   in Loop: Header=BB0_37 Depth=2
	add	x13, x21, x13, lsl #3
	ldr	w13, [x13, #4]
	sub	w11, w11, w13
	mul	w11, w11, w14
	scvtf	s0, w11
	sub	w10, w10, w12
	scvtf	s1, w10
	fdiv	s0, s0, s1
	fcvt	d0, s0
	fadd	d0, d0, d8
	scvtf	d1, w13
	fadd	d0, d0, d1
	fcvtzs	w11, d0
LBB0_35:                                ;   in Loop: Header=BB0_37 Depth=2
	ldr	x10, [x20, #8]
	str	w11, [x10, w25, sxtw #2]
	add	w25, w25, #1
LBB0_36:                                ;   in Loop: Header=BB0_37 Depth=2
	add	x8, x8, #1
	add	x9, x9, #8
	cmp	x27, x8
	b.eq	LBB0_44
LBB0_37:                                ;   Parent Loop BB0_32 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	cmp	x8, #0
	csel	w10, w27, w8, eq
	sxtw	x10, w10
	sub	x11, x10, #1
	lsl	x10, x11, #3
	ldr	w10, [x21, x10]
	ldr	w14, [x9]
	cmp	w10, w14
	b.ge	LBB0_39
; %bb.38:                               ;   in Loop: Header=BB0_37 Depth=2
	mov	x13, x11
	mov	x12, x10
	mov	x11, x8
	mov	x10, x14
	b	LBB0_40
LBB0_39:                                ;   in Loop: Header=BB0_37 Depth=2
	mov	x13, x8
	mov	x12, x14
	b.le	LBB0_36
LBB0_40:                                ;   in Loop: Header=BB0_37 Depth=2
	add	x11, x21, x11, lsl #3
	ldr	w11, [x11, #4]
	subs	w14, w24, w12
	ccmp	w24, w10, #0, ge
	b.lt	LBB0_34
; %bb.41:                               ;   in Loop: Header=BB0_37 Depth=2
	cmp	w24, w28
	b.ne	LBB0_36
; %bb.42:                               ;   in Loop: Header=BB0_37 Depth=2
	cmp	w24, w10
	b.eq	LBB0_35
	b	LBB0_36
LBB0_43:                                ;   in Loop: Header=BB0_32 Depth=1
	mov	w25, #0
LBB0_44:                                ;   in Loop: Header=BB0_32 Depth=1
	ldr	x0, [x20, #8]
Lloh6:
	adrp	x8, _gdCompareInt@GOTPAGE
Lloh7:
	ldr	x8, [x8, _gdCompareInt@GOTPAGEOFF]
Lloh8:
	ldr	w3, [x8]
	mov	x1, x25
	mov	w2, #4
	bl	_qsort
	subs	w25, w25, #1
	b.le	LBB0_31
; %bb.45:                               ;   in Loop: Header=BB0_32 Depth=1
	mov	x19, #0
LBB0_46:                                ;   Parent Loop BB0_32 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	ldr	x8, [x20, #8]
	add	x8, x8, x19, lsl #2
	ldp	w1, w3, [x8]
	mov	x0, x20
	mov	x2, x24
	mov	x4, x24
	mov	x5, x23
	bl	_gdImageLine
	add	x19, x19, #2
	cmp	w25, w19
	b.gt	LBB0_46
	b	LBB0_31
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpLdrGotLdr	Lloh6, Lloh7, Lloh8
	.cfi_endproc
                                        ; -- End function
	.comm	_gdAntiAliased,4,2              ; @gdAntiAliased
	.comm	_gdCompareInt,4,2               ; @gdCompareInt
.subsections_via_symbols
