	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.section	__TEXT,__literal4,4byte_literals
	.p2align	2                               ## -- Begin function compare_fields
LCPI0_0:
	.long	0x40c00000                      ## float 6
LCPI0_1:
	.long	0x3f000000                      ## float 0.5
	.section	__TEXT,__literal8,8byte_literals
	.p2align	3
LCPI0_2:
	.quad	0x3f747ae147ae147b              ## double 0.0050000000000000001
	.section	__TEXT,__text,regular,pure_instructions
	.p2align	4, 0x90
_compare_fields:                        ## @compare_fields
	.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	$200, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movl	%edx, -104(%rbp)                ## 4-byte Spill
	movq	%rdi, %r13
	movq	40(%rdi), %rax
	movq	%rax, -208(%rbp)                ## 8-byte Spill
	movl	%ecx, -180(%rbp)                ## 4-byte Spill
	cmpl	$1, %ecx
	sete	%al
	setne	%cl
	movl	%esi, -100(%rbp)                ## 4-byte Spill
	cmpl	$3, %esi
	setge	%dl
	setl	%bl
	andb	%al, %dl
	andb	%cl, %bl
	orb	%dl, %bl
	movb	%bl, -41(%rbp)                  ## 1-byte Spill
	xorl	%ebx, %ebx
	movl	$0, -52(%rbp)                   ## 4-byte Folded Spill
	movl	$0, -80(%rbp)                   ## 4-byte Folded Spill
	movl	$0, -76(%rbp)                   ## 4-byte Folded Spill
	movl	$0, -56(%rbp)                   ## 4-byte Folded Spill
	movl	$0, -48(%rbp)                   ## 4-byte Folded Spill
	movl	$0, -72(%rbp)                   ## 4-byte Folded Spill
	movq	%rdi, -160(%rbp)                ## 8-byte Spill
	jmp	LBB0_2
	.p2align	4, 0x90
LBB0_1:                                 ##   in Loop: Header=BB0_2 Depth=1
	movq	-200(%rbp), %rbx                ## 8-byte Reload
	incq	%rbx
	xorl	%eax, %eax
	movq	-160(%rbp), %r13                ## 8-byte Reload
	cmpq	$0, 32(%r13)
	setne	%al
	addq	%rax, %rax
	incq	%rax
	cmpq	%rax, %rbx
	jae	LBB0_43
LBB0_2:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_12 Depth 2
                                        ##       Child Loop BB0_19 Depth 3
	movq	%rbx, -200(%rbp)                ## 8-byte Spill
	movq	(%r13), %rax
	movq	8(%r13), %rcx
	movq	(%rax,%rbx,8), %r12
	movl	(%rcx,%rbx,4), %eax
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	-208(%rbp), %r14                ## 8-byte Reload
	movq	(%r14), %rax
	movq	8(%r14), %rcx
	movq	(%rax,%rbx,8), %rax
	movq	%rax, -168(%rbp)                ## 8-byte Spill
	movl	(%rcx,%rbx,4), %eax
	movl	%eax, -128(%rbp)                ## 4-byte Spill
	movq	%r13, %rdi
	movq	%r14, %rsi
	movl	%ebx, %edx
	callq	_get_width
	movl	%eax, %r15d
	movq	%r13, %rdi
	movq	%r14, %rsi
	movl	%ebx, %edx
	callq	_get_height
                                        ## kill: def $eax killed $eax def $rax
	movl	16(%r13), %edx
	testq	%rbx, %rbx
	je	LBB0_4
## %bb.3:                               ##   in Loop: Header=BB0_2 Depth=1
	movb	20(%r13), %cl
	sarl	%cl, %edx
	movl	%edx, -108(%rbp)                ## 4-byte Spill
	movl	24(%r13), %edx
	sarl	%cl, %edx
	movl	%edx, -84(%rbp)                 ## 4-byte Spill
	movb	28(%r13), %cl
	movl	$8, %edx
	shrl	%cl, %edx
	movl	%edx, -68(%rbp)                 ## 4-byte Spill
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_4:                                 ##   in Loop: Header=BB0_2 Depth=1
	movl	%edx, -108(%rbp)                ## 4-byte Spill
	movl	24(%r13), %ecx
	movl	%ecx, -84(%rbp)                 ## 4-byte Spill
	movl	$8, -68(%rbp)                   ## 4-byte Folded Spill
LBB0_5:                                 ##   in Loop: Header=BB0_2 Depth=1
	movq	%r12, %rdi
	movl	%r15d, %esi
	movl	%eax, %edx
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	movl	%r14d, %ecx
	xorl	%r8d, %r8d
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	callq	_fill_buf
	movq	%r15, -120(%rbp)                ## 8-byte Spill
	movl	-100(%rbp), %r15d               ## 4-byte Reload
	movl	%r15d, %edi
	movl	-180(%rbp), %ebx                ## 4-byte Reload
	movl	%ebx, %esi
	callq	_get_field_base
	movq	%r12, %rcx
	movl	%eax, %r12d
	imull	%r14d, %eax
	cltq
	movq	%rcx, -176(%rbp)                ## 8-byte Spill
	movq	%rax, -240(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%rax,4), %rax
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	movq	%r13, %rdi
	movl	%r15d, %esi
	callq	_select_frame
	movq	(%rax), %rcx
	movq	8(%rax), %rax
	movq	-200(%rbp), %r15                ## 8-byte Reload
	movl	(%rax,%r15,4), %eax
	leal	(%rax,%rax), %edx
	movq	(%rcx,%r15,8), %rcx
	movl	%r12d, -188(%rbp)               ## 4-byte Spill
	imull	%r12d, %eax
	cltq
	movq	%rcx, -232(%rbp)                ## 8-byte Spill
	movq	%rax, -224(%rbp)                ## 8-byte Spill
	leaq	(%rcx,%rax,4), %rax
	movq	%rax, -152(%rbp)                ## 8-byte Spill
	movl	%edx, -184(%rbp)                ## 4-byte Spill
	movslq	%edx, %rax
	movq	%rax, -136(%rbp)                ## 8-byte Spill
	movl	-104(%rbp), %r12d               ## 4-byte Reload
	movl	%r12d, %edi
	movl	%ebx, %esi
	callq	_get_field_base
	movl	%eax, %ebx
	movq	%r13, %rdi
	movl	%r12d, %esi
	movq	%r14, %r12
	callq	_select_frame
	movq	(%rax), %rcx
	movq	8(%rax), %rax
	movl	(%rax,%r15,4), %eax
	leal	(%rax,%rax), %r8d
	movq	(%rcx,%r15,8), %rdx
	imull	%eax, %ebx
	movslq	%ebx, %r14
	leaq	(%rdx,%r14,4), %rcx
	movslq	%r8d, %rbx
	addl	%r12d, %r12d
	cmpb	$0, -41(%rbp)                   ## 1-byte Folded Reload
	movq	%rdx, -216(%rbp)                ## 8-byte Spill
	je	LBB0_7
## %bb.6:                               ##   in Loop: Header=BB0_2 Depth=1
	movq	-160(%rbp), %rdi                ## 8-byte Reload
	movq	-152(%rbp), %rsi                ## 8-byte Reload
	movl	-184(%rbp), %edx                ## 4-byte Reload
	movq	-64(%rbp), %r9                  ## 8-byte Reload
	pushq	%r15
	movq	-120(%rbp), %r13                ## 8-byte Reload
	pushq	%r13
	movq	-144(%rbp), %r15                ## 8-byte Reload
	pushq	%r15
	pushq	%r12
	jmp	LBB0_8
	.p2align	4, 0x90
LBB0_7:                                 ##   in Loop: Header=BB0_2 Depth=1
	movq	-136(%rbp), %rax                ## 8-byte Reload
	movq	-152(%rbp), %rdx                ## 8-byte Reload
	leaq	(%rdx,%rax,4), %rsi
	leaq	(%rcx,%rbx,4), %rcx
	movq	%rbx, %r8
	movslq	%r12d, %r10
	movq	-64(%rbp), %rdx                 ## 8-byte Reload
	leaq	(%rdx,%r10,4), %r9
	movq	-160(%rbp), %rdi                ## 8-byte Reload
	movl	%eax, %edx
                                        ## kill: def $r8d killed $r8d killed $r8
	pushq	%r15
	movq	-120(%rbp), %r13                ## 8-byte Reload
	pushq	%r13
	movq	-144(%rbp), %r15                ## 8-byte Reload
	pushq	%r15
	pushq	%r10
LBB0_8:                                 ##   in Loop: Header=BB0_2 Depth=1
	callq	_build_diff_map
	addq	$32, %rsp
	movq	%r13, %r9
	movq	%r15, %rax
	cmpl	$5, %eax
	jl	LBB0_1
## %bb.9:                               ##   in Loop: Header=BB0_2 Depth=1
	movl	-188(%rbp), %edx                ## 4-byte Reload
	incl	%edx
	movl	-128(%rbp), %edi                ## 4-byte Reload
	imull	%edi, %edx
	addl	%edi, %edi
	movl	-68(%rbp), %ecx                 ## 4-byte Reload
	subl	%ecx, %r9d
	movslq	%edx, %rdx
	movq	%r12, %rsi
	movslq	%edi, %r12
	addl	$-2, %eax
	movq	%rax, -144(%rbp)                ## 8-byte Spill
	movslq	%esi, %r15
	movq	%r15, -128(%rbp)                ## 8-byte Spill
	movl	%ecx, %edi
	leaq	(%r14,%rbx), %rax
	addq	%rdi, %rax
	movq	-216(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %rax
	movq	%rax, -64(%rbp)                 ## 8-byte Spill
	addq	%rdi, %r14
	leaq	(%rcx,%r14,4), %r13
	movq	-136(%rbp), %r14                ## 8-byte Reload
	movq	-224(%rbp), %rsi                ## 8-byte Reload
	leaq	(%rsi,%r14), %rax
	addq	%rdi, %rax
	movq	-232(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r8
	addq	%rdi, %rsi
	leaq	(%rcx,%rsi,4), %r10
	leaq	(%rdx,%r12), %rax
	addq	%rdi, %rax
	movq	-168(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%rax,4), %r11
	addq	%rdi, %rdx
	leaq	(%rcx,%rdx,4), %rax
	subq	%r12, %rdx
	leaq	(%rcx,%rdx,4), %rdx
	movq	-240(%rbp), %rcx                ## 8-byte Reload
	leaq	(%rcx,%r15), %rsi
	addq	%rdi, %rsi
	movq	-176(%rbp), %r15                ## 8-byte Reload
	leaq	(%r15,%rsi,4), %rsi
	addq	%rdi, %rcx
	leaq	(%r15,%rcx,4), %r15
	movq	%r9, -120(%rbp)                 ## 8-byte Spill
	movl	%r9d, %r9d
	shlq	$2, -128(%rbp)                  ## 8-byte Folded Spill
	shlq	$2, %rbx
	movq	%rbx, -176(%rbp)                ## 8-byte Spill
	shlq	$2, %r14
	movq	%r14, -136(%rbp)                ## 8-byte Spill
	shlq	$2, %r12
	movq	%r12, -168(%rbp)                ## 8-byte Spill
	subq	%rdi, %r9
	movq	%r9, -96(%rbp)                  ## 8-byte Spill
	movl	$2, %ecx
	jmp	LBB0_12
	.p2align	4, 0x90
LBB0_10:                                ##   in Loop: Header=BB0_12 Depth=2
	movq	%r13, %rcx
LBB0_11:                                ##   in Loop: Header=BB0_12 Depth=2
	movq	%rcx, %r13
	movl	-152(%rbp), %ecx                ## 4-byte Reload
	addl	$2, %ecx
	movq	-128(%rbp), %rbx                ## 8-byte Reload
	addq	%rbx, %rsi
	movq	-176(%rbp), %rdi                ## 8-byte Reload
	addq	%rdi, -64(%rbp)                 ## 8-byte Folded Spill
	addq	%rdi, %r13
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	addq	%rdi, %r8
	addq	%rdi, %r10
	movq	-168(%rbp), %rdi                ## 8-byte Reload
	addq	%rdi, %r11
	addq	%rdi, %rax
	addq	%rdi, %rdx
	addq	%rbx, %r15
	cmpl	-144(%rbp), %ecx                ## 4-byte Folded Reload
	jge	LBB0_1
LBB0_12:                                ##   Parent Loop BB0_2 Depth=1
                                        ## =>  This Loop Header: Depth=2
                                        ##       Child Loop BB0_19 Depth 3
	movl	-108(%rbp), %edi                ## 4-byte Reload
	cmpl	-84(%rbp), %edi                 ## 4-byte Folded Reload
	movl	%ecx, -152(%rbp)                ## 4-byte Spill
	je	LBB0_15
## %bb.13:                              ##   in Loop: Header=BB0_12 Depth=2
	cmpl	%edi, %ecx
	jl	LBB0_15
## %bb.14:                              ##   in Loop: Header=BB0_12 Depth=2
	cmpl	-84(%rbp), %ecx                 ## 4-byte Folded Reload
	jle	LBB0_10
LBB0_15:                                ##   in Loop: Header=BB0_12 Depth=2
	movl	-68(%rbp), %edi                 ## 4-byte Reload
	cmpl	-120(%rbp), %edi                ## 4-byte Folded Reload
	jge	LBB0_10
## %bb.16:                              ##   in Loop: Header=BB0_12 Depth=2
	xorl	%r12d, %r12d
	movq	%r13, %rcx
	jmp	LBB0_19
LBB0_17:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%ebx, -72(%rbp)                 ## 4-byte Folded Spill
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_19 Depth=3
	incq	%r12
	cmpq	%r12, -96(%rbp)                 ## 8-byte Folded Reload
	je	LBB0_11
LBB0_19:                                ##   Parent Loop BB0_2 Depth=1
                                        ##     Parent Loop BB0_12 Depth=2
                                        ## =>    This Inner Loop Header: Depth=3
	movl	(%r15,%r12,4), %r14d
	testl	%r14d, %r14d
	jg	LBB0_21
## %bb.20:                              ##   in Loop: Header=BB0_19 Depth=3
	cmpl	$0, (%rsi,%r12,4)
	jle	LBB0_18
LBB0_21:                                ##   in Loop: Header=BB0_19 Depth=3
	movl	(%rax,%r12,4), %r9d
	shll	$2, %r9d
	addl	(%rdx,%r12,4), %r9d
	addl	(%r11,%r12,4), %r9d
	movl	(%r8,%r12,4), %edi
	addl	(%r10,%r12,4), %edi
	leal	(%rdi,%rdi,2), %edi
	subl	%r9d, %edi
	movl	%edi, %r13d
	negl	%r13d
	cmovsl	%edi, %r13d
	cmpl	$24, %r13d
	jb	LBB0_32
## %bb.22:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$1, %r14b
	jne	LBB0_24
## %bb.23:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$1, (%rsi,%r12,4)
	je	LBB0_25
LBB0_24:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%r13d, -52(%rbp)                ## 4-byte Folded Spill
LBB0_25:                                ##   in Loop: Header=BB0_19 Depth=3
	cmpl	$43, %r13d
	jb	LBB0_32
## %bb.26:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$2, %r14b
	jne	LBB0_28
## %bb.27:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$2, (%rsi,%r12,4)
	je	LBB0_29
LBB0_28:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%r13d, -80(%rbp)                ## 4-byte Folded Spill
LBB0_29:                                ##   in Loop: Header=BB0_19 Depth=3
	testb	$4, %r14b
	jne	LBB0_31
## %bb.30:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$4, (%rsi,%r12,4)
	je	LBB0_32
LBB0_31:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%r13d, -76(%rbp)                ## 4-byte Folded Spill
	.p2align	4, 0x90
LBB0_32:                                ##   in Loop: Header=BB0_19 Depth=3
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	movl	(%rdi,%r12,4), %edi
	addl	(%rcx,%r12,4), %edi
	leal	(%rdi,%rdi,2), %edi
	subl	%r9d, %edi
	movl	%edi, %ebx
	negl	%ebx
	cmovsl	%edi, %ebx
	cmpl	$24, %ebx
	jb	LBB0_18
## %bb.33:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$1, %r14b
	jne	LBB0_35
## %bb.34:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$1, (%rsi,%r12,4)
	je	LBB0_36
LBB0_35:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%ebx, -56(%rbp)                 ## 4-byte Folded Spill
LBB0_36:                                ##   in Loop: Header=BB0_19 Depth=3
	cmpl	$43, %ebx
	jb	LBB0_18
## %bb.37:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$2, %r14b
	jne	LBB0_39
## %bb.38:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$2, (%rsi,%r12,4)
	je	LBB0_40
LBB0_39:                                ##   in Loop: Header=BB0_19 Depth=3
	addl	%ebx, -48(%rbp)                 ## 4-byte Folded Spill
LBB0_40:                                ##   in Loop: Header=BB0_19 Depth=3
	testb	$4, %r14b
	jne	LBB0_17
## %bb.41:                              ##   in Loop: Header=BB0_19 Depth=3
	testb	$4, (%rsi,%r12,4)
	jne	LBB0_17
	jmp	LBB0_18
LBB0_43:
	movl	-80(%rbp), %ecx                 ## 4-byte Reload
	cmpl	$499, %ecx                      ## imm = 0x1F3
	jg	LBB0_48
## %bb.44:
	movl	-48(%rbp), %eax                 ## 4-byte Reload
	cmpl	$499, %eax                      ## imm = 0x1F3
	jg	LBB0_49
## %bb.45:
	cmpl	$499, -76(%rbp)                 ## 4-byte Folded Reload
                                        ## imm = 0x1F3
	jg	LBB0_47
## %bb.46:
	cmpl	$500, -72(%rbp)                 ## 4-byte Folded Reload
                                        ## imm = 0x1F4
	jl	LBB0_49
LBB0_47:
	movl	-76(%rbp), %r15d                ## 4-byte Reload
	movl	%r15d, %edi
	movl	-72(%rbp), %ebx                 ## 4-byte Reload
	movl	%ebx, %esi
	callq	_FFMAX
	movl	%eax, %r14d
	movl	%r15d, %edi
	movl	%ebx, %esi
	callq	_FFMIN
	movl	-80(%rbp), %ecx                 ## 4-byte Reload
                                        ## kill: def $eax killed $eax def $rax
	leal	(%rax,%rax,2), %eax
	cmpl	%eax, %r14d
	movl	-48(%rbp), %eax                 ## 4-byte Reload
	cmovgl	%ebx, %eax
	cmovgl	%r15d, %ecx
	jmp	LBB0_49
LBB0_48:
	movl	-48(%rbp), %eax                 ## 4-byte Reload
LBB0_49:
	cvtsi2ssl	-52(%rbp), %xmm0        ## 4-byte Folded Reload
	movss	LCPI0_0(%rip), %xmm1            ## xmm1 = mem[0],zero,zero,zero
	divss	%xmm1, %xmm0
	movss	LCPI0_1(%rip), %xmm2            ## xmm2 = mem[0],zero,zero,zero
	addss	%xmm2, %xmm0
	cvttss2si	%xmm0, %r14d
	xorps	%xmm0, %xmm0
	cvtsi2ssl	-56(%rbp), %xmm0        ## 4-byte Folded Reload
	divss	%xmm1, %xmm0
	addss	%xmm2, %xmm0
	cvttss2si	%xmm0, %r15d
	xorps	%xmm0, %xmm0
	cvtsi2ss	%ecx, %xmm0
	divss	%xmm1, %xmm0
	addss	%xmm2, %xmm0
	cvttss2si	%xmm0, %ebx
	xorps	%xmm0, %xmm0
	cvtsi2ss	%eax, %xmm0
	divss	%xmm1, %xmm0
	addss	%xmm2, %xmm0
	cvttss2si	%xmm0, %r12d
	movl	%r14d, %edi
	movl	%r15d, %esi
	callq	_FFMAX
	movl	%eax, -96(%rbp)                 ## 4-byte Spill
	movl	%r14d, %edi
	movl	%r15d, %esi
	callq	_FFMIN
	movl	%eax, %edi
	movl	$1, %esi
	callq	_FFMAX
	movl	%eax, -64(%rbp)                 ## 4-byte Spill
	movl	%ebx, %edi
	movl	%r12d, %esi
	callq	_FFMAX
	movl	%eax, -56(%rbp)                 ## 4-byte Spill
	movl	%ebx, %edi
	movl	%r12d, %esi
	callq	_FFMIN
	movl	%eax, %edi
	movl	$1, %esi
	callq	_FFMAX
	movl	%eax, %r13d
	movl	%ebx, %edi
	movl	%r12d, %esi
	callq	_FFMAX
	movl	%eax, -52(%rbp)                 ## 4-byte Spill
	movl	%r14d, %edi
	movl	%r15d, %esi
	callq	_FFMAX
	movl	%eax, %edi
	movl	$1, %esi
	callq	_FFMAX
	cmpl	$499, %ebx                      ## imm = 0x1F3
	jg	LBB0_51
## %bb.50:
	cmpl	$500, %r12d                     ## imm = 0x1F4
	jl	LBB0_53
LBB0_51:
	leal	(%rbx,%rbx), %ecx
	cmpl	%r12d, %ecx
	jl	LBB0_63
## %bb.52:
	leal	(%r12,%r12), %ecx
	cmpl	%ebx, %ecx
	jl	LBB0_63
LBB0_53:
	cmpl	$999, %ebx                      ## imm = 0x3E7
	jg	LBB0_55
## %bb.54:
	cmpl	$1000, %r12d                    ## imm = 0x3E8
	jl	LBB0_57
LBB0_55:
	leal	(%rbx,%rbx,2), %ecx
	leal	(%r12,%r12), %edx
	cmpl	%edx, %ecx
	jl	LBB0_63
## %bb.56:
	leal	(%r12,%r12,2), %ecx
	leal	(%rbx,%rbx), %edx
	cmpl	%edx, %ecx
	jl	LBB0_63
LBB0_57:
	cmpl	$1999, %ebx                     ## imm = 0x7CF
	jg	LBB0_59
## %bb.58:
	cmpl	$2000, %r12d                    ## imm = 0x7D0
	jl	LBB0_61
LBB0_59:
	leal	(%rbx,%rbx,4), %ecx
	leal	(,%r12,4), %edx
	cmpl	%edx, %ecx
	jl	LBB0_63
## %bb.60:
	leal	(%r12,%r12,4), %ecx
	leal	(,%rbx,4), %edx
	cmpl	%edx, %ecx
	jl	LBB0_63
LBB0_61:
	cmpl	$4000, %ebx                     ## imm = 0xFA0
	setge	%cl
	cmpl	$4000, %r12d                    ## imm = 0xFA0
	setge	%dl
	orb	%cl, %dl
	cmpb	$1, %dl
	jne	LBB0_65
## %bb.62:
	xorps	%xmm0, %xmm0
	cvtsi2ssl	-96(%rbp), %xmm0        ## 4-byte Folded Reload
	cvtsi2ssl	-64(%rbp), %xmm1        ## 4-byte Folded Reload
	cvtsi2ssl	-56(%rbp), %xmm2        ## 4-byte Folded Reload
	cvtsi2ss	%r13d, %xmm3
	divss	%xmm1, %xmm0
	divss	%xmm3, %xmm2
	ucomiss	%xmm0, %xmm2
	jbe	LBB0_65
LBB0_63:
	cmpl	%r12d, %ebx
LBB0_64:
	setg	%al
	testb	%al, %al
	movl	-100(%rbp), %eax                ## 4-byte Reload
	cmovnel	-104(%rbp), %eax                ## 4-byte Folded Reload
	addq	$200, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_65:
	xorps	%xmm0, %xmm0
	cvtsi2ssl	-52(%rbp), %xmm0        ## 4-byte Folded Reload
	xorps	%xmm1, %xmm1
	cvtsi2ss	%eax, %xmm1
	divss	%xmm1, %xmm0
	cvtss2sd	%xmm0, %xmm0
	ucomisd	LCPI0_2(%rip), %xmm0
	jbe	LBB0_69
## %bb.66:
	movl	%ebx, %edi
	movl	%r12d, %esi
	callq	_FFMAX
	cmpl	$151, %eax
	jl	LBB0_69
## %bb.67:
	leal	(%rbx,%rbx), %eax
	cmpl	%r12d, %eax
	jl	LBB0_63
## %bb.68:
	leal	(%r12,%r12), %eax
	cmpl	%ebx, %eax
	jl	LBB0_63
LBB0_69:
	cmpl	%r15d, %r14d
	jmp	LBB0_64
	.cfi_endproc
                                        ## -- End function
	.no_dead_strip	_compare_fields
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function compare_fields
_compare_fields:                        ; @compare_fields
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #320
	.cfi_def_cfa_offset 320
	stp	x28, x27, [sp, #224]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #240]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #256]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #272]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #288]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #304]            ; 16-byte Folded Spill
	add	x29, sp, #304
	.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
	stp	w1, w2, [sp, #24]               ; 8-byte Folded Spill
	mov	x19, x0
	mov	x11, #0
	mov	w23, #0
	mov	w26, #0
	mov	w21, #0
	mov	w27, #0
	mov	w25, #0
	mov	w22, #0
	ldr	x8, [x0, #40]
	str	x8, [sp, #16]                   ; 8-byte Folded Spill
	cmp	w1, #2
	cset	w8, gt
	cmp	w1, #3
	cset	w9, lt
	stur	w3, [x29, #-140]                ; 4-byte Folded Spill
	cmp	w3, #1
	cset	w10, eq
	and	w8, w8, w10
	cset	w10, ne
	and	w9, w9, w10
	orr	w8, w8, w9
	str	w8, [sp, #12]                   ; 4-byte Folded Spill
	stur	x0, [x29, #-136]                ; 8-byte Folded Spill
	b	LBB0_2
LBB0_1:                                 ;   in Loop: Header=BB0_2 Depth=1
	ldp	x19, x11, [x29, #-136]          ; 16-byte Folded Reload
	add	x11, x11, #1
	ldr	x8, [x19, #32]
	cmp	x8, #0
	mov	w8, #3
	csinc	x8, x8, xzr, ne
	cmp	x11, x8
	b.hs	LBB0_41
LBB0_2:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_11 Depth 2
                                        ;       Child Loop BB0_18 Depth 3
	stur	x11, [x29, #-128]               ; 8-byte Folded Spill
	lsl	x10, x11, #3
	ldp	x8, x9, [x19]
	ldr	x24, [x8, x10]
	lsl	x11, x11, #2
	ldrsw	x8, [x9, x11]
	stur	x8, [x29, #-104]                ; 8-byte Folded Spill
	ldr	x20, [sp, #16]                  ; 8-byte Folded Reload
	ldp	x8, x9, [x20]
	stp	x11, x10, [sp, #144]            ; 16-byte Folded Spill
	ldr	x28, [x8, x10]
	ldr	w8, [x9, x11]
	str	w8, [sp, #84]                   ; 4-byte Folded Spill
	mov	x0, x19
	mov	x1, x20
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
                                        ; kill: def $w2 killed $w2 killed $x2
	bl	_get_width
	stur	w0, [x29, #-120]                ; 4-byte Folded Spill
	mov	x0, x19
	mov	x1, x20
	ldur	x2, [x29, #-128]                ; 8-byte Folded Reload
                                        ; kill: def $w2 killed $w2 killed $x2
	bl	_get_height
	mov	x2, x0
	ldr	w11, [x19, #16]
	ldur	x8, [x29, #-128]                ; 8-byte Folded Reload
	str	x28, [sp, #88]                  ; 8-byte Folded Spill
	str	w25, [sp, #132]                 ; 4-byte Folded Spill
	cbz	x8, LBB0_4
; %bb.3:                                ;   in Loop: Header=BB0_2 Depth=1
	ldur	x10, [x29, #-136]               ; 8-byte Folded Reload
	ldp	w8, w9, [x10, #20]
	asr	w11, w11, w8
	str	w11, [sp, #100]                 ; 4-byte Folded Spill
	asr	w8, w9, w8
	stur	w8, [x29, #-92]                 ; 4-byte Folded Spill
	ldr	w8, [x10, #28]
	mov	w9, #8
	lsr	w8, w9, w8
	b	LBB0_5
LBB0_4:                                 ;   in Loop: Header=BB0_2 Depth=1
	str	w11, [sp, #100]                 ; 4-byte Folded Spill
	ldur	x8, [x29, #-136]                ; 8-byte Folded Reload
	ldr	w8, [x8, #24]
	stur	w8, [x29, #-92]                 ; 4-byte Folded Spill
	mov	w8, #8
LBB0_5:                                 ;   in Loop: Header=BB0_2 Depth=1
	stur	w8, [x29, #-108]                ; 4-byte Folded Spill
	ldur	w1, [x29, #-120]                ; 4-byte Folded Reload
	mov	x0, x24
	ldur	x3, [x29, #-104]                ; 8-byte Folded Reload
	mov	x19, x3
	mov	w4, #0
	str	w2, [sp, #128]                  ; 4-byte Folded Spill
	bl	_fill_buf
	ldr	w20, [sp, #24]                  ; 4-byte Folded Reload
	mov	x0, x20
	ldur	w1, [x29, #-140]                ; 4-byte Folded Reload
	bl	_get_field_base
                                        ; kill: def $w0 killed $w0 def $x0
	str	x0, [sp, #48]                   ; 8-byte Folded Spill
	sxtw	x28, w0
	mul	x8, x28, x19
	str	x24, [sp, #136]                 ; 8-byte Folded Spill
	str	x8, [sp, #72]                   ; 8-byte Folded Spill
	add	x8, x24, x8, lsl #2
	str	x8, [sp, #112]                  ; 8-byte Folded Spill
	ldur	x19, [x29, #-136]               ; 8-byte Folded Reload
	mov	x0, x19
	mov	x1, x20
	bl	_select_frame
	ldp	x9, x8, [x0]
	ldp	x25, x20, [sp, #144]            ; 16-byte Folded Reload
	ldrsw	x8, [x8, x25]
	lsl	w10, w8, #1
	ldr	x9, [x9, x20]
	mul	x8, x8, x28
	stp	x8, x9, [sp, #56]               ; 16-byte Folded Spill
	add	x8, x9, x8, lsl #2
	str	x8, [sp, #104]                  ; 8-byte Folded Spill
	str	x10, [sp, #32]                  ; 8-byte Folded Spill
	sxtw	x8, w10
	str	x8, [sp, #120]                  ; 8-byte Folded Spill
	ldr	w24, [sp, #28]                  ; 4-byte Folded Reload
	mov	x0, x24
	ldur	w1, [x29, #-140]                ; 4-byte Folded Reload
	bl	_get_field_base
	mov	x28, x0
	mov	x0, x19
	mov	x1, x24
	bl	_select_frame
	ldp	x9, x8, [x0]
	ldr	w10, [x8, x25]
	lsl	w8, w10, #1
	ldr	x11, [x9, x20]
	mul	w10, w10, w28
	add	x3, x11, w10, sxtw #2
	sxtw	x4, w8
	ldur	x9, [x29, #-104]                ; 8-byte Folded Reload
	lsl	w28, w9, #1
	ldr	w9, [sp, #12]                   ; 4-byte Folded Reload
	stp	x11, x4, [sp, #144]             ; 16-byte Folded Spill
	str	x10, [sp, #40]                  ; 8-byte Folded Spill
	cbz	w9, LBB0_7
; %bb.6:                                ;   in Loop: Header=BB0_2 Depth=1
	ldur	x8, [x29, #-128]                ; 8-byte Folded Reload
	str	w8, [sp, #4]
	ldur	w20, [x29, #-120]               ; 4-byte Folded Reload
	str	w20, [sp]
	ldur	x0, [x29, #-136]                ; 8-byte Folded Reload
	ldp	x1, x5, [sp, #104]              ; 16-byte Folded Reload
	ldr	x24, [sp, #120]                 ; 8-byte Folded Reload
	b	LBB0_8
LBB0_7:                                 ;   in Loop: Header=BB0_2 Depth=1
	ldr	x9, [sp, #104]                  ; 8-byte Folded Reload
	ldr	x10, [sp, #32]                  ; 8-byte Folded Reload
	add	x1, x9, w10, sxtw #2
	add	x3, x3, w8, sxtw #2
	ldp	x8, x24, [sp, #112]             ; 16-byte Folded Reload
	add	x5, x8, w28, sxtw #2
	ldur	x8, [x29, #-128]                ; 8-byte Folded Reload
	str	w8, [sp, #4]
	ldur	w20, [x29, #-120]               ; 4-byte Folded Reload
	str	w20, [sp]
	ldur	x0, [x29, #-136]                ; 8-byte Folded Reload
LBB0_8:                                 ;   in Loop: Header=BB0_2 Depth=1
	mov	x2, x24
                                        ; kill: def $w4 killed $w4 killed $x4
	mov	x6, x28
	ldr	w19, [sp, #128]                 ; 4-byte Folded Reload
	mov	x7, x19
	bl	_build_diff_map
	ldr	x7, [sp, #136]                  ; 8-byte Folded Reload
	mov	x5, x20
	mov	x10, x19
	ldr	w19, [sp, #100]                 ; 4-byte Folded Reload
	ldr	w25, [sp, #132]                 ; 4-byte Folded Reload
	cmp	w10, #5
	b.lt	LBB0_1
; %bb.9:                                ;   in Loop: Header=BB0_2 Depth=1
	ldr	w9, [sp, #84]                   ; 4-byte Folded Reload
	lsl	w8, w9, #1
	ldr	x11, [sp, #48]                  ; 8-byte Folded Reload
	madd	w9, w9, w11, w9
	sxtw	x1, w9
	sxtw	x2, w8
	ldr	x8, [sp, #40]                   ; 8-byte Folded Reload
	sxtw	x13, w8
	sub	w8, w10, #2
	stur	w8, [x29, #-104]                ; 4-byte Folded Spill
	sxtw	x9, w28
	ldur	w8, [x29, #-108]                ; 4-byte Folded Reload
	mov	w3, w8
	ldp	x17, x6, [sp, #64]              ; 16-byte Folded Reload
	add	x9, x6, x9
	add	x9, x9, x3
	add	x9, x7, x9, lsl #2
	sbfiz	x10, x28, #2, #32
	ldp	x14, x12, [sp, #144]            ; 16-byte Folded Reload
	add	x11, x13, x12
	add	x11, x11, x3
	add	x11, x14, x11, lsl #2
	lsl	x12, x12, #2
	add	x13, x13, x3
	add	x13, x14, x13, lsl #2
	ldr	x16, [sp, #56]                  ; 8-byte Folded Reload
	add	x14, x16, x24
	add	x14, x14, x3
	add	x14, x17, x14, lsl #2
	lsl	x15, x24, #2
	add	x16, x16, x3
	add	x16, x17, x16, lsl #2
	add	x17, x1, x2
	add	x17, x17, x3
	ldr	x4, [sp, #88]                   ; 8-byte Folded Reload
	add	x17, x4, x17, lsl #2
	lsl	x0, x2, #2
	add	x1, x1, x3
	sub	x2, x1, x2
	add	x1, x4, x1, lsl #2
	add	x6, x6, x3
	add	x2, x4, x2, lsl #2
	sub	w8, w5, w8
	stur	x8, [x29, #-120]                ; 8-byte Folded Spill
	sub	x4, x8, x3
	mov	w5, #2
	add	x6, x7, x6, lsl #2
	b	LBB0_11
LBB0_10:                                ;   in Loop: Header=BB0_11 Depth=2
	add	w5, w5, #2
	add	x9, x9, x10
	add	x11, x11, x12
	add	x13, x13, x12
	add	x14, x14, x15
	add	x16, x16, x15
	add	x17, x17, x0
	add	x1, x1, x0
	add	x2, x2, x0
	add	x6, x6, x10
	ldur	w8, [x29, #-104]                ; 4-byte Folded Reload
	cmp	w5, w8
	b.ge	LBB0_1
LBB0_11:                                ;   Parent Loop BB0_2 Depth=1
                                        ; =>  This Loop Header: Depth=2
                                        ;       Child Loop BB0_18 Depth 3
	ldur	w8, [x29, #-92]                 ; 4-byte Folded Reload
	cmp	w19, w8
	b.eq	LBB0_14
; %bb.12:                               ;   in Loop: Header=BB0_11 Depth=2
	cmp	w5, w19
	b.lt	LBB0_14
; %bb.13:                               ;   in Loop: Header=BB0_11 Depth=2
	ldur	w8, [x29, #-92]                 ; 4-byte Folded Reload
	cmp	w5, w8
	b.le	LBB0_10
LBB0_14:                                ;   in Loop: Header=BB0_11 Depth=2
	ldur	w8, [x29, #-108]                ; 4-byte Folded Reload
	ldur	x3, [x29, #-120]                ; 8-byte Folded Reload
	cmp	w8, w3
	b.ge	LBB0_10
; %bb.15:                               ;   in Loop: Header=BB0_11 Depth=2
	mov	x7, #0
	b	LBB0_18
LBB0_16:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w22, w3, w22
LBB0_17:                                ;   in Loop: Header=BB0_18 Depth=3
	add	x7, x7, #1
	cmp	x4, x7
	b.eq	LBB0_10
LBB0_18:                                ;   Parent Loop BB0_2 Depth=1
                                        ;     Parent Loop BB0_11 Depth=2
                                        ; =>    This Inner Loop Header: Depth=3
	ldr	w20, [x6, x7, lsl #2]
	cmp	w20, #0
	b.gt	LBB0_20
; %bb.19:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w3, [x9, x7, lsl #2]
	cmp	w3, #1
	b.lt	LBB0_17
LBB0_20:                                ;   in Loop: Header=BB0_18 Depth=3
	lsl	x28, x7, #2
	ldr	w3, [x2, x28]
	ldr	w30, [x1, x28]
	add	w3, w3, w30, lsl #2
	ldr	w30, [x17, x28]
	ldr	w8, [x16, x28]
	ldr	w24, [x14, x28]
	add	w8, w24, w8
	add	w8, w8, w8, lsl #1
	add	w30, w3, w30
	subs	w8, w8, w30
	cneg	w3, w8, mi
	cmp	w3, #24
	b.lo	LBB0_31
; %bb.21:                               ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #0, LBB0_23
; %bb.22:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbz	w8, #0, LBB0_24
LBB0_23:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w23, w3, w23
LBB0_24:                                ;   in Loop: Header=BB0_18 Depth=3
	cmp	w3, #43
	b.lo	LBB0_31
; %bb.25:                               ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #1, LBB0_27
; %bb.26:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbz	w8, #1, LBB0_28
LBB0_27:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w26, w3, w26
LBB0_28:                                ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #2, LBB0_30
; %bb.29:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbz	w8, #2, LBB0_31
LBB0_30:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w21, w3, w21
LBB0_31:                                ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x13, x28]
	ldr	w3, [x11, x28]
	add	w8, w3, w8
	add	w8, w8, w8, lsl #1
	subs	w8, w8, w30
	cneg	w3, w8, mi
	cmp	w3, #24
	b.lo	LBB0_17
; %bb.32:                               ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #0, LBB0_34
; %bb.33:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbz	w8, #0, LBB0_35
LBB0_34:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w27, w3, w27
LBB0_35:                                ;   in Loop: Header=BB0_18 Depth=3
	cmp	w3, #43
	b.lo	LBB0_17
; %bb.36:                               ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #1, LBB0_38
; %bb.37:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbz	w8, #1, LBB0_39
LBB0_38:                                ;   in Loop: Header=BB0_18 Depth=3
	add	w25, w3, w25
LBB0_39:                                ;   in Loop: Header=BB0_18 Depth=3
	tbnz	w20, #2, LBB0_16
; %bb.40:                               ;   in Loop: Header=BB0_18 Depth=3
	ldr	w8, [x9, x7, lsl #2]
	tbnz	w8, #2, LBB0_16
	b	LBB0_17
LBB0_41:
	cmp	w26, #499
	b.gt	LBB0_46
; %bb.42:
	cmp	w25, #499
	b.gt	LBB0_46
; %bb.43:
	cmp	w21, #499
	b.gt	LBB0_45
; %bb.44:
	cmp	w22, #500
	b.lt	LBB0_46
LBB0_45:
	mov	x0, x21
	mov	x1, x22
	bl	_FFMAX
	mov	x19, x0
	mov	x0, x21
	mov	x1, x22
	bl	_FFMIN
	add	w8, w0, w0, lsl #1
	cmp	w19, w8
	csel	w25, w22, w25, gt
	csel	w26, w21, w26, gt
LBB0_46:
	scvtf	s0, w23
	fmov	s1, #6.00000000
	fdiv	s0, s0, s1
	fmov	s2, #0.50000000
	fadd	s0, s0, s2
	fcvtzs	w21, s0
	scvtf	s0, w27
	fdiv	s0, s0, s1
	fadd	s0, s0, s2
	fcvtzs	w22, s0
	scvtf	s0, w26
	fdiv	s0, s0, s1
	fadd	s0, s0, s2
	fcvtzs	w23, s0
	scvtf	s0, w25
	fdiv	s0, s0, s1
	fadd	s0, s0, s2
	fcvtzs	w19, s0
	mov	x0, x21
	mov	x1, x22
	bl	_FFMAX
	mov	x20, x0
	mov	x0, x21
	mov	x1, x22
	bl	_FFMIN
	mov	w1, #1
	bl	_FFMAX
	mov	x24, x0
	mov	x0, x23
	mov	x1, x19
	bl	_FFMAX
	mov	x25, x0
	mov	x0, x23
	mov	x1, x19
	bl	_FFMIN
	mov	w1, #1
	bl	_FFMAX
	mov	x26, x0
	mov	x0, x23
	mov	x1, x19
	bl	_FFMAX
	mov	x27, x0
	mov	x0, x21
	mov	x1, x22
	bl	_FFMAX
	mov	w1, #1
	bl	_FFMAX
	cmp	w23, #499
	b.gt	LBB0_48
; %bb.47:
	cmp	w19, #500
	b.lt	LBB0_50
LBB0_48:
	cmp	w19, w23, lsl #1
	b.gt	LBB0_60
; %bb.49:
	lsl	w8, w19, #1
	cmp	w8, w23
	b.lt	LBB0_60
LBB0_50:
	cmp	w23, #999
	b.gt	LBB0_52
; %bb.51:
	cmp	w19, #1000
	b.lt	LBB0_54
LBB0_52:
	add	w8, w23, w23, lsl #1
	cmp	w8, w19, lsl #1
	b.lt	LBB0_60
; %bb.53:
	add	w8, w19, w19, lsl #1
	cmp	w8, w23, lsl #1
	b.lt	LBB0_60
LBB0_54:
	cmp	w23, #1999
	b.gt	LBB0_56
; %bb.55:
	cmp	w19, #2000
	b.lt	LBB0_58
LBB0_56:
	add	w8, w23, w23, lsl #2
	cmp	w8, w19, lsl #2
	b.lt	LBB0_60
; %bb.57:
	add	w8, w19, w19, lsl #2
	cmp	w8, w23, lsl #2
	b.lt	LBB0_60
LBB0_58:
	cmp	w19, #3999
	mov	w8, #3999
	ccmp	w23, w8, #0, le
	b.le	LBB0_62
; %bb.59:
	scvtf	s0, w20
	scvtf	s1, w24
	fdiv	s0, s0, s1
	scvtf	s1, w25
	scvtf	s2, w26
	fdiv	s1, s1, s2
	fcmp	s1, s0
	b.le	LBB0_62
LBB0_60:
	cmp	w23, w19
LBB0_61:
	cset	w8, gt
	cmp	w8, #0
	ldp	w9, w8, [sp, #24]               ; 8-byte Folded Reload
	csel	w0, w8, w9, ne
	ldp	x29, x30, [sp, #304]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #288]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #272]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #256]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #240]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #224]            ; 16-byte Folded Reload
	add	sp, sp, #320
	ret
LBB0_62:
	scvtf	s0, w27
	scvtf	s1, w0
	fdiv	s0, s0, s1
	fcvt	d0, s0
	mov	x8, #5243
	movk	x8, #18350, lsl #16
	movk	x8, #31457, lsl #32
	movk	x8, #16244, lsl #48
	fmov	d1, x8
	fcmp	d0, d1
	b.le	LBB0_66
; %bb.63:
	mov	x0, x23
	mov	x1, x19
	bl	_FFMAX
	cmp	w0, #151
	b.lt	LBB0_66
; %bb.64:
	cmp	w19, w23, lsl #1
	b.gt	LBB0_60
; %bb.65:
	lsl	w8, w19, #1
	cmp	w8, w23
	b.lt	LBB0_60
LBB0_66:
	cmp	w21, w22
	b	LBB0_61
	.cfi_endproc
                                        ; -- End function
	.no_dead_strip	_compare_fields
.subsections_via_symbols
