	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	4, 0x90                         ## -- Begin function fold_comparison
_fold_comparison:                       ## @fold_comparison
	.cfi_startproc
## %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	pushq	%r15
	pushq	%r14
	pushq	%r13
	pushq	%r12
	pushq	%rbx
	subq	$88, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rcx, %r15
	movq	%rdx, %r13
	movq	%rsi, %r14
	movl	%edi, %ebx
	movq	%rdx, %rdi
	callq	_STRIP_SIGN_NOPS
	movq	%r15, %rdi
	callq	_STRIP_SIGN_NOPS
	movq	%rbx, -48(%rbp)                 ## 8-byte Spill
	movl	%ebx, %edi
	movq	%r14, %rsi
	movq	%r13, %rdx
	movq	%r15, %rcx
	callq	_fold_relational_const
	movq	_NULL_TREE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_143
## %bb.1:
	movq	%r13, %rdi
	movq	%r15, %rsi
	movl	$1, %edx
	callq	_tree_swap_operands_p
	testq	%rax, %rax
	movq	%r15, %rbx
	je	LBB0_4
## %bb.2:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	callq	_swap_tree_comparison
	movl	%eax, %edi
	movq	%r14, %rsi
	movq	%rbx, %rdx
	movq	%r13, %rcx
LBB0_3:
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_fold_build2                    ## TAILCALL
LBB0_4:
	movq	%r14, -64(%rbp)                 ## 8-byte Spill
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_PLUS_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	je	LBB0_6
## %bb.5:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_8
LBB0_6:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_INTEGER_CST@GOTPCREL(%rip), %r14
	cmpq	(%r14), %rax
	jne	LBB0_8
## %bb.7:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_OVERFLOW
	testl	%eax, %eax
	je	LBB0_29
LBB0_8:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_POINTER_TYPE_P
	testq	%rax, %rax
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_11
## %bb.9:
	movq	_flag_wrapv@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	jne	LBB0_11
## %bb.10:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_OVERFLOW_TRAPS
	testl	%eax, %eax
	je	LBB0_24
LBB0_11:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_FLOAT_TYPE_P
	testq	%rax, %rax
	movq	%rbx, %r14
	je	LBB0_69
## %bb.12:
	movq	%r13, %rdi
	callq	_strip_float_extensions
	movq	%rax, %rbx
	movq	%r14, -56(%rbp)                 ## 8-byte Spill
	movq	%r14, %rdi
	callq	_strip_float_extensions
	movq	%rax, %r14
	movq	%rbx, -96(%rbp)                 ## 8-byte Spill
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r15
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movq	%rax, %r12
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	cmpq	%rax, %r12
	jle	LBB0_14
## %bb.13:
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r15
LBB0_14:
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	movq	%rax, %rbx
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	cmpq	%rax, %rbx
	jge	LBB0_16
## %bb.15:
	movq	%r15, %rdi
	movq	-96(%rbp), %rsi                 ## 8-byte Reload
	callq	_fold_convert
	movq	%rax, %rbx
	movq	%r15, %rdi
	movq	%r14, %rsi
	callq	_fold_convert
	jmp	LBB0_19
LBB0_16:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_NEGATE_EXPR@GOTPCREL(%rip), %rbx
	cmpq	(%rbx), %rax
	movq	-56(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_21
## %bb.17:
	movq	%r14, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_21
## %bb.18:
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rbx
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
LBB0_19:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	%rbx, %rdx
LBB0_20:
	movq	%rax, %rcx
	callq	_fold_build2
	jmp	LBB0_143
LBB0_21:
	movq	%r14, %rdi
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	jne	LBB0_49
## %bb.22:
	movq	%r14, %rdi
	callq	_TREE_REAL_CST
	movl	%eax, %r12d
	movq	%r13, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_38
## %bb.23:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	callq	_swap_tree_comparison
	movl	%eax, -48(%rbp)                 ## 4-byte Spill
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %r15
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rbx
	movl	%r12d, %edi
	callq	_REAL_VALUE_NEGATE
	movq	%rbx, %rdi
	movl	%eax, %esi
	callq	_build_real
	movl	-48(%rbp), %edi                 ## 4-byte Reload
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	%r15, %rdx
	jmp	LBB0_20
LBB0_24:
	leaq	-80(%rbp), %rsi
	leaq	-72(%rbp), %rdx
	movq	%r13, %rdi
	callq	_extract_array_ref
	testq	%rax, %rax
	je	LBB0_11
## %bb.25:
	leaq	-88(%rbp), %rsi
	leaq	-112(%rbp), %rdx
	movq	%rbx, %rdi
	callq	_extract_array_ref
	testq	%rax, %rax
	je	LBB0_11
## %bb.26:
	movq	-80(%rbp), %rdi
	movq	-88(%rbp), %rsi
	xorl	%edx, %edx
	callq	_operand_equal_p
	testq	%rax, %rax
	je	LBB0_11
## %bb.27:
	movq	_size_type_node@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	callq	_signed_type_for
	movq	%rax, %rbx
	movq	-72(%rbp), %rsi
	movq	_NULL_TREE@GOTPCREL(%rip), %r14
	cmpq	(%r14), %rsi
	jne	LBB0_40
## %bb.28:
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_build_int_cst
	jmp	LBB0_41
LBB0_29:
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_OVERFLOW_UNDEFINED
	testq	%rax, %rax
	je	LBB0_8
## %bb.30:
	movq	%rbx, %rdi
	callq	_TREE_CODE
	cmpq	(%r14), %rax
	jne	LBB0_8
## %bb.31:
	movq	%rbx, %rdi
	callq	_TREE_OVERFLOW
	testl	%eax, %eax
	jne	LBB0_8
## %bb.32:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %r15
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_PLUS_EXPR@GOTPCREL(%rip), %rcx
	movq	(%rcx), %r12
	cmpq	%r12, %rax
	jne	LBB0_34
## %bb.33:
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rax
	movl	(%rax), %r12d
LBB0_34:
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movl	%r12d, %edi
	movq	%rax, %rsi
	movq	%rbx, %rdx
	movq	%r15, %rcx
	callq	_fold_build2
	movq	%rax, %r15
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	%rax, %r12
	movq	%rbx, %rdi
	callq	_TREE_CODE
	cmpq	%rax, %r12
	jne	LBB0_8
## %bb.35:
	movq	%r15, %rdi
	callq	_TREE_CODE
	cmpq	(%r14), %rax
	jne	LBB0_37
## %bb.36:
	movq	%r15, %rdi
	callq	_TREE_OVERFLOW
	testl	%eax, %eax
	jne	LBB0_8
LBB0_37:
	movq	_WARN_STRICT_OVERFLOW_COMPARISON@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	leaq	L_.str(%rip), %rdi
	callq	_fold_overflow_warning
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movq	%r15, %rcx
	jmp	LBB0_3
LBB0_38:
	movl	%r12d, %edi
	callq	_REAL_VALUE_MINUS_ZERO
	testq	%rax, %rax
	je	LBB0_45
## %bb.39:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	_dconst0@GOTPCREL(%rip), %rcx
	movl	(%rcx), %esi
	movq	%rax, %rdi
	callq	_build_real
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	movq	%r13, %rdx
	jmp	LBB0_20
LBB0_40:
	movq	%rbx, %rdi
	callq	_fold_convert
LBB0_41:
	movq	%rax, -72(%rbp)
	movq	-112(%rbp), %rsi
	cmpq	(%r14), %rsi
	jne	LBB0_43
## %bb.42:
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_build_int_cst
	jmp	LBB0_44
LBB0_43:
	movq	%rbx, %rdi
	callq	_fold_convert
LBB0_44:
	movq	%rax, -112(%rbp)
	movq	-72(%rbp), %rdx
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	jmp	LBB0_20
LBB0_45:
	movl	%r12d, %edi
	callq	_REAL_VALUE_ISNAN
	testq	%rax, %rax
	je	LBB0_47
## %bb.46:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MODE
	movl	%eax, %edi
	callq	_HONOR_SNANS
	testl	%eax, %eax
	je	LBB0_144
LBB0_47:
	movl	%r12d, %edi
	callq	_REAL_VALUE_ISINF
	testq	%rax, %rax
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	je	LBB0_49
## %bb.48:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	movq	%r13, %rdx
	callq	_fold_inf_compare
	movq	_NULL_TREE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_143
LBB0_49:
	movq	_flag_unsafe_math_optimizations@GOTPCREL(%rip), %r12
	cmpq	$0, (%r12)
	je	LBB0_64
## %bb.50:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_58
## %bb.51:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_PLUS_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	je	LBB0_53
## %bb.52:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_58
LBB0_53:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_58
## %bb.54:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_PLUS_EXPR@GOTPCREL(%rip), %rcx
	movq	(%rcx), %r14
	cmpq	%r14, %rax
	jne	LBB0_56
## %bb.55:
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rax
	movq	(%rax), %r14
LBB0_56:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%r14, %rdi
	movq	-56(%rbp), %rsi                 ## 8-byte Reload
	movq	%rax, %rdx
	xorl	%ecx, %ecx
	callq	_const_binop
	testq	%rax, %rax
	je	LBB0_58
## %bb.57:
	movq	%rax, %r14
	movq	%rax, %rdi
	callq	_TREE_CONSTANT_OVERFLOW
	testl	%eax, %eax
	je	LBB0_146
LBB0_58:
	cmpq	$0, (%r12)
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	je	LBB0_64
## %bb.59:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_64
## %bb.60:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rbx
	cmpq	(%rbx), %rax
	jne	LBB0_64
## %bb.61:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_64
## %bb.62:
	movq	(%rbx), %r14
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%r14, %rdi
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	movq	%rax, %rsi
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	xorl	%ecx, %ecx
	callq	_const_binop
	testq	%rax, %rax
	je	LBB0_64
## %bb.63:
	movq	%rax, %rbx
	movq	%rax, %rdi
	callq	_TREE_CONSTANT_OVERFLOW
	testl	%eax, %eax
	je	LBB0_150
LBB0_64:
	movq	-56(%rbp), %r14                 ## 8-byte Reload
	movq	%r14, %rdi
	callq	_TREE_CODE
	movq	_REAL_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_69
## %bb.65:
	cmpq	$0, (%r12)
	je	LBB0_69
## %bb.66:
	movq	_flag_errno_math@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	jne	LBB0_69
## %bb.67:
	movq	%r13, %rdi
	callq	_builtin_mathfn_code
	movq	_END_BUILTINS@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	je	LBB0_69
## %bb.68:
	movl	%eax, %edi
	movq	-48(%rbp), %rsi                 ## 8-byte Reload
                                        ## kill: def $esi killed $esi killed $rsi
	movq	%r15, %rdx
	movq	%r13, %rcx
	movq	%r14, %r8
	callq	_fold_mathfn_compare
	movq	_NULL_TREE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_143
LBB0_69:
	movq	%r14, %rdi
	callq	_TREE_CONSTANT
	testq	%rax, %rax
	movq	%r14, %r12
	je	LBB0_82
## %bb.70:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_POSTINCREMENT_EXPR@GOTPCREL(%rip), %rbx
	cmpq	(%rbx), %rax
	je	LBB0_72
## %bb.71:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_POSTDECREMENT_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_82
LBB0_72:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_POINTER_TYPE_P
	testq	%rax, %rax
	je	LBB0_79
LBB0_73:
	movq	%r13, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	movq	_MINUS_EXPR@GOTPCREL(%rip), %rax
	cmoveq	_PLUS_EXPR@GOTPCREL(%rip), %rax
	movl	(%rax), %r14d
	movq	_PREDECREMENT_EXPR@GOTPCREL(%rip), %rbx
	cmoveq	_PREINCREMENT_EXPR@GOTPCREL(%rip), %rbx
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r15
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movl	%r14d, %edi
	movq	%r15, %rsi
	movq	%r12, %rdx
	movq	%rax, %rcx
	callq	_fold_build2
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	movl	(%rbx), %r14d
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r15
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rbx
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movl	%r14d, %edi
	movq	%r15, %rsi
	movq	%rbx, %rdx
	movq	%rax, %rcx
	callq	_build2
	movq	%rax, %rbx
	movq	%rax, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_COMPONENT_REF@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_78
## %bb.74:
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_BIT_FIELD
	testq	%rax, %rax
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	je	LBB0_96
## %bb.75:
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_SIZE
	movl	%eax, %edi
	movl	$1, %esi
	callq	_host_integerp
	testq	%rax, %rax
	je	LBB0_96
## %bb.76:
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_SIZE
	movl	%eax, %edi
	movl	$1, %esi
	callq	_tree_low_cst
	movq	%rax, %r14
	movq	%rbx, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r13, %rsi
	movq	%rax, %rdx
	movq	%r12, %rcx
	callq	_fold_build2
	movq	%rax, %r15
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_INTEGER_CST@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_101
## %bb.77:
	movq	%r13, %rdi
	movq	%r15, %rsi
	movq	%rbx, %rdx
	callq	_omit_one_operand
	jmp	LBB0_143
LBB0_78:
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	jmp	LBB0_102
LBB0_79:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_INTEGRAL_TYPE_P
	testq	%rax, %rax
	je	LBB0_82
## %bb.80:
	cmpl	$133, -48(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_73
## %bb.81:
	cmpl	$128, -48(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_73
LBB0_82:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_87
## %bb.83:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_NOP_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	je	LBB0_85
## %bb.84:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_CONVERT_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_87
LBB0_85:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	movq	%r13, %rdx
	movq	%r12, %rcx
	callq	_fold_widened_comparison
	testq	%rax, %rax
	jne	LBB0_143
## %bb.86:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	movq	%r13, %rdx
	movq	%r12, %rcx
	callq	_fold_sign_changed_comparison
	testq	%rax, %rax
	jne	LBB0_143
LBB0_87:
	movq	%r12, %rdi
	callq	_TREE_CODE
	movq	_INTEGER_CST@GOTPCREL(%rip), %rbx
	cmpq	(%rbx), %rax
	jne	LBB0_92
## %bb.88:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_MIN_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	je	LBB0_90
## %bb.89:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_MAX_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_92
LBB0_90:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_92
## %bb.91:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r15, %rsi
	movq	%r13, %rdx
	movq	%r12, %rcx
	callq	_optimize_minmax_comparison
	testq	%rax, %rax
	jne	LBB0_143
LBB0_92:
	movq	%r13, %rdi
	movq	%r12, %rsi
	xorl	%edx, %edx
	callq	_operand_equal_p
	testq	%rax, %rax
	je	LBB0_108
## %bb.93:
	movq	-48(%rbp), %rax                 ## 8-byte Reload
	addl	$-128, %eax
	cmpl	$5, %eax
	ja	LBB0_103
## %bb.94:
	leaq	LJTI0_0(%rip), %rcx
	movslq	(%rcx,%rax,4), %rax
	addq	%rcx, %rax
	jmpq	*%rax
LBB0_95:
	xorl	%edi, %edi
	jmp	LBB0_142
LBB0_96:
	movq	-56(%rbp), %rcx                 ## 8-byte Reload
	jmp	LBB0_102
LBB0_97:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_FLOAT_TYPE_P
	testq	%rax, %rax
	je	LBB0_141
## %bb.98:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MODE
	movl	%eax, %edi
	callq	_HONOR_NANS
	testl	%eax, %eax
	je	LBB0_141
## %bb.99:
	movl	$133, %edi
	movq	%r15, %rsi
	movq	%r13, %rdx
	movq	%r12, %rcx
	callq	_fold_build2
	jmp	LBB0_143
LBB0_101:
	movq	_NULL_TREE@GOTPCREL(%rip), %rax
	movq	(%rax), %r15
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	subq	%r14, %rax
	movq	%r15, %rdi
	movq	%rax, %rsi
	callq	_build_int_cst
	movq	%rax, %r14
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	movq	%r14, %rsi
	callq	_fold_convert
	movq	%rax, %r14
	movq	_LSHIFT_EXPR@GOTPCREL(%rip), %rax
	movl	(%rax), %r15d
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movl	%r15d, %edi
	movq	%rax, %rsi
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movq	%r14, %rcx
	callq	_fold_build2
	movq	%rax, %r15
	movq	_RSHIFT_EXPR@GOTPCREL(%rip), %rax
	movl	(%rax), %r12d
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movl	%r12d, %edi
	movq	%rax, %rsi
	movq	%r15, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
	movq	%rax, %rcx
LBB0_102:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%r13, %rsi
	movq	%rbx, %rdx
	callq	_fold_build2
	jmp	LBB0_143
LBB0_103:
	xorl	%eax, %eax
	callq	_gcc_unreachable
	jmp	LBB0_108
LBB0_104:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_FLOAT_TYPE_P
	testq	%rax, %rax
	je	LBB0_95
## %bb.105:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MODE
	movl	%eax, %edi
	callq	_HONOR_NANS
	testl	%eax, %eax
	jne	LBB0_108
	jmp	LBB0_95
LBB0_106:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_FLOAT_TYPE_P
	testq	%rax, %rax
	je	LBB0_141
## %bb.107:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MODE
	movl	%eax, %edi
	callq	_HONOR_NANS
	testl	%eax, %eax
	je	LBB0_141
LBB0_108:
	movq	%r12, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_126
## %bb.109:
	movq	%r13, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	je	LBB0_126
## %bb.110:
	movq	$0, -80(%rbp)
	movq	$0, -72(%rbp)
	movl	$0, -88(%rbp)
	leaq	-80(%rbp), %rsi
	leaq	-72(%rbp), %rdx
	leaq	-88(%rbp), %rcx
	movq	%r13, %rdi
	callq	_twoval_comparison_p
	testq	%rax, %rax
	je	LBB0_126
## %bb.111:
	movq	-80(%rbp), %rdi
	testq	%rdi, %rdi
	je	LBB0_126
## %bb.112:
	cmpq	$0, -72(%rbp)
	je	LBB0_126
## %bb.113:
	callq	_TREE_CONSTANT
	testq	%rax, %rax
	je	LBB0_115
## %bb.114:
	movq	-72(%rbp), %rdi
	callq	_TREE_CONSTANT
	testq	%rax, %rax
	jne	LBB0_126
LBB0_115:
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %r14
	movq	-72(%rbp), %rdi
	callq	_TREE_TYPE
	cmpq	%rax, %r14
	jne	LBB0_126
## %bb.116:
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_INTEGRAL_TYPE_P
	testq	%rax, %rax
	je	LBB0_126
## %bb.117:
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAX_VALUE
	testq	%rax, %rax
	je	LBB0_126
## %bb.118:
	movq	-72(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAX_VALUE
	testq	%rax, %rax
	je	LBB0_126
## %bb.119:
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MIN_VALUE
	movq	%rax, %r14
	movq	-72(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAX_VALUE
	movq	%r14, %rdi
	movq	%rax, %rsi
	xorl	%edx, %edx
	callq	_operand_equal_p
	testq	%rax, %rax
	jne	LBB0_126
## %bb.120:
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAX_VALUE
	movq	%rax, %r14
	movq	%rax, -56(%rbp)                 ## 8-byte Spill
	movq	-80(%rbp), %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MIN_VALUE
	movq	%rax, -120(%rbp)                ## 8-byte Spill
	movq	-80(%rbp), %rsi
	movq	-72(%rbp), %rcx
	movq	%r13, %rdi
	movq	%r14, %rdx
	movq	%rax, %r8
	callq	_eval_subst
	movq	%r12, %r14
	movq	-48(%rbp), %r12                 ## 8-byte Reload
	movl	%r12d, %edi
	movq	-64(%rbp), %r15                 ## 8-byte Reload
	movq	%r15, %rsi
	movq	%rax, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	-80(%rbp), %rsi
	movq	-72(%rbp), %rcx
	movq	%r13, %rdi
	movq	-56(%rbp), %rdx                 ## 8-byte Reload
	movq	%rdx, %r8
	callq	_eval_subst
	movl	%r12d, %edi
	movq	%r15, %rsi
	movq	%rax, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movq	-80(%rbp), %rsi
	movq	-72(%rbp), %rcx
	movq	%r13, %rdi
	movq	-120(%rbp), %rdx                ## 8-byte Reload
	movq	-56(%rbp), %r8                  ## 8-byte Reload
	callq	_eval_subst
	movl	%r12d, %edi
	movq	%r14, %r12
	movq	%r15, %rsi
	movq	%rax, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
	movq	%rax, %r14
	movq	-96(%rbp), %rdi                 ## 8-byte Reload
	movq	%rdi, %r15
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_126
## %bb.121:
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_126
## %bb.122:
	movq	%r14, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_126
## %bb.123:
	movq	%r15, %rdi
	callq	_integer_onep
	movl	%eax, %ebx
	shll	$2, %ebx
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_integer_onep
                                        ## kill: def $eax killed $eax def $rax
	leal	(%rbx,%rax,2), %ebx
	movq	%r14, %rdi
	callq	_integer_onep
                                        ## kill: def $eax killed $eax def $rax
	addl	%ebx, %eax
	cmpl	$7, %eax
	ja	LBB0_158
## %bb.124:
	leaq	LJTI0_1(%rip), %rcx
	movslq	(%rcx,%rax,4), %rax
	addq	%rcx, %rax
	jmpq	*%rax
LBB0_125:
	movq	_integer_zero_node@GOTPCREL(%rip), %rax
	jmp	LBB0_162
LBB0_126:
	movq	%rbx, %r15
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_ADDR_EXPR@GOTPCREL(%rip), %rbx
	cmpq	(%rbx), %rax
	jne	LBB0_132
## %bb.127:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_COMPONENT_REF@GOTPCREL(%rip), %r14
	cmpq	(%r14), %rax
	jne	LBB0_132
## %bb.128:
	movq	%r12, %rdi
	callq	_TREE_CODE
	cmpq	(%rbx), %rax
	jne	LBB0_132
## %bb.129:
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	cmpq	(%r14), %rax
	jne	LBB0_132
## %bb.130:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rbx
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %r14
	movq	%rbx, -56(%rbp)                 ## 8-byte Spill
	movq	%rbx, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%r12, %rbx
	movq	%rax, %r12
	movq	%r14, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	cmpq	%rax, %r12
	movq	%rbx, %r12
	jne	LBB0_132
## %bb.131:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %r15
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rbx
	movq	%r15, %rdi
	callq	_build_fold_addr_expr
	movq	%rax, %r14
	movq	%rbx, %rdi
	callq	_build_fold_addr_expr
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	%r14, %rdx
	jmp	LBB0_20
LBB0_132:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_TRUNC_DIV_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	je	LBB0_134
## %bb.133:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_EXACT_DIV_EXPR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_140
LBB0_134:
	movq	%r12, %rdi
	callq	_TREE_CODE
	cmpq	(%r15), %rax
	jne	LBB0_140
## %bb.135:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	cmpq	(%r15), %rax
	jne	LBB0_140
## %bb.136:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_integer_zerop
	testl	%eax, %eax
	jne	LBB0_140
## %bb.137:
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_OVERFLOW
	testl	%eax, %eax
	jne	LBB0_140
## %bb.138:
	movq	%r12, %rdi
	callq	_TREE_OVERFLOW
	testl	%eax, %eax
	jne	LBB0_140
## %bb.139:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%rbx, %rsi
	movq	%r13, %rdx
	movq	%r12, %rcx
	callq	_fold_div_compare
	movq	_NULL_TREE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_143
LBB0_140:
	movq	_NULL_TREE@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
	jmp	LBB0_143
LBB0_141:
	movl	$1, %edi
LBB0_142:
	movq	%r15, %rsi
	callq	_constant_boolean_node
LBB0_143:
	addq	$88, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_144:
	cmpl	$128, -48(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_147
## %bb.145:
	movq	_integer_one_node@GOTPCREL(%rip), %rax
	jmp	LBB0_148
LBB0_146:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	movq	%rax, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
	jmp	LBB0_143
LBB0_147:
	movq	_integer_zero_node@GOTPCREL(%rip), %rax
LBB0_148:
	movq	(%rax), %rsi
	movq	%r15, %rdi
LBB0_149:
	movq	%r13, %rdx
	callq	_omit_one_operand
	jmp	LBB0_143
LBB0_150:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	callq	_swap_tree_comparison
	movl	%eax, %r14d
	movq	%r13, %rdi
	movl	$1, %esi
	callq	_TREE_OPERAND
	movl	%r14d, %edi
	movq	%r15, %rsi
	movq	%rax, %rdx
	movq	%rbx, %rcx
	callq	_fold_build2
	jmp	LBB0_143
LBB0_151:
	movl	$129, %eax
	jmp	LBB0_157
LBB0_152:
	movl	$133, %eax
	jmp	LBB0_157
LBB0_153:
	movl	$130, %eax
	jmp	LBB0_157
LBB0_154:
	movl	$131, %eax
	jmp	LBB0_157
LBB0_155:
	movl	$128, %eax
	jmp	LBB0_157
LBB0_156:
	movl	$132, %eax
LBB0_157:
	movq	%rax, -48(%rbp)                 ## 8-byte Spill
LBB0_158:
	cmpl	$0, -88(%rbp)
	movq	-80(%rbp), %rdx
	movq	-72(%rbp), %rcx
	je	LBB0_160
## %bb.159:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_build2
	movq	%rax, %rdi
	callq	_save_expr
	jmp	LBB0_143
LBB0_160:
	movq	-48(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	-64(%rbp), %rsi                 ## 8-byte Reload
	callq	_fold_build2
	jmp	LBB0_143
LBB0_161:
	movq	_integer_one_node@GOTPCREL(%rip), %rax
LBB0_162:
	movq	(%rax), %rsi
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_149
	.cfi_endproc
	.p2align	2, 0x90
	.data_region jt32
.set L0_0_set_104, LBB0_104-LJTI0_0
.set L0_0_set_95, LBB0_95-LJTI0_0
.set L0_0_set_97, LBB0_97-LJTI0_0
.set L0_0_set_106, LBB0_106-LJTI0_0
LJTI0_0:
	.long	L0_0_set_104
	.long	L0_0_set_95
	.long	L0_0_set_97
	.long	L0_0_set_95
	.long	L0_0_set_97
	.long	L0_0_set_106
.set L0_1_set_125, LBB0_125-LJTI0_1
.set L0_1_set_151, LBB0_151-LJTI0_1
.set L0_1_set_152, LBB0_152-LJTI0_1
.set L0_1_set_153, LBB0_153-LJTI0_1
.set L0_1_set_154, LBB0_154-LJTI0_1
.set L0_1_set_155, LBB0_155-LJTI0_1
.set L0_1_set_156, LBB0_156-LJTI0_1
.set L0_1_set_161, LBB0_161-LJTI0_1
LJTI0_1:
	.long	L0_1_set_125
	.long	L0_1_set_151
	.long	L0_1_set_152
	.long	L0_1_set_153
	.long	L0_1_set_154
	.long	L0_1_set_155
	.long	L0_1_set_156
	.long	L0_1_set_161
	.end_data_region
                                        ## -- End function
	.comm	_NULL_TREE,8,3                  ## @NULL_TREE
	.comm	_PLUS_EXPR,8,3                  ## @PLUS_EXPR
	.comm	_MINUS_EXPR,8,3                 ## @MINUS_EXPR
	.comm	_INTEGER_CST,8,3                ## @INTEGER_CST
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C1 +- C2"

	.comm	_WARN_STRICT_OVERFLOW_COMPARISON,4,2 ## @WARN_STRICT_OVERFLOW_COMPARISON
	.comm	_flag_wrapv,4,2                 ## @flag_wrapv
	.comm	_size_type_node,4,2             ## @size_type_node
	.comm	_NEGATE_EXPR,8,3                ## @NEGATE_EXPR
	.comm	_REAL_CST,8,3                   ## @REAL_CST
	.comm	_dconst0,4,2                    ## @dconst0
	.comm	_integer_one_node,8,3           ## @integer_one_node
	.comm	_integer_zero_node,8,3          ## @integer_zero_node
	.comm	_flag_unsafe_math_optimizations,8,3 ## @flag_unsafe_math_optimizations
	.comm	_flag_errno_math,4,2            ## @flag_errno_math
	.comm	_END_BUILTINS,4,2               ## @END_BUILTINS
	.comm	_POSTINCREMENT_EXPR,8,3         ## @POSTINCREMENT_EXPR
	.comm	_POSTDECREMENT_EXPR,8,3         ## @POSTDECREMENT_EXPR
	.comm	_PREINCREMENT_EXPR,4,2          ## @PREINCREMENT_EXPR
	.comm	_PREDECREMENT_EXPR,4,2          ## @PREDECREMENT_EXPR
	.comm	_COMPONENT_REF,8,3              ## @COMPONENT_REF
	.comm	_LSHIFT_EXPR,4,2                ## @LSHIFT_EXPR
	.comm	_RSHIFT_EXPR,4,2                ## @RSHIFT_EXPR
	.comm	_INTEGER_TYPE,8,3               ## @INTEGER_TYPE
	.comm	_NOP_EXPR,8,3                   ## @NOP_EXPR
	.comm	_CONVERT_EXPR,8,3               ## @CONVERT_EXPR
	.comm	_MIN_EXPR,8,3                   ## @MIN_EXPR
	.comm	_MAX_EXPR,8,3                   ## @MAX_EXPR
	.comm	_ADDR_EXPR,8,3                  ## @ADDR_EXPR
	.comm	_TRUNC_DIV_EXPR,8,3             ## @TRUNC_DIV_EXPR
	.comm	_EXACT_DIV_EXPR,8,3             ## @EXACT_DIV_EXPR
	.no_dead_strip	_fold_comparison
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.p2align	2                               ; -- Begin function fold_comparison
_fold_comparison:                       ; @fold_comparison
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #128
	.cfi_def_cfa_offset 128
	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
	mov	x21, x3
	mov	x22, x2
	mov	x19, x1
	mov	x20, x0
	mov	x0, x2
	bl	_STRIP_SIGN_NOPS
	mov	x0, x21
	bl	_STRIP_SIGN_NOPS
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_relational_const
Lloh0:
	adrp	x27, _NULL_TREE@GOTPAGE
Lloh1:
	ldr	x27, [x27, _NULL_TREE@GOTPAGEOFF]
	ldr	x8, [x27]
	cmp	x0, x8
	b.ne	LBB0_141
; %bb.1:
	mov	x0, x22
	mov	x1, x21
	mov	w2, #1
	bl	_tree_swap_operands_p
	cbz	x0, LBB0_4
; %bb.2:
	mov	x0, x20
	bl	_swap_tree_comparison
	mov	x1, x19
	mov	x2, x21
	mov	x3, x22
LBB0_3:
	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
	add	sp, sp, #128
	b	_fold_build2
LBB0_4:
	mov	x0, x22
	bl	_TREE_CODE
Lloh2:
	adrp	x28, _PLUS_EXPR@GOTPAGE
Lloh3:
	ldr	x28, [x28, _PLUS_EXPR@GOTPAGEOFF]
	ldr	x8, [x28]
	cmp	x0, x8
	b.eq	LBB0_6
; %bb.5:
	mov	x0, x22
	bl	_TREE_CODE
Lloh4:
	adrp	x8, _MINUS_EXPR@GOTPAGE
Lloh5:
	ldr	x8, [x8, _MINUS_EXPR@GOTPAGEOFF]
Lloh6:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_8
LBB0_6:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh7:
	adrp	x26, _INTEGER_CST@GOTPAGE
Lloh8:
	ldr	x26, [x26, _INTEGER_CST@GOTPAGEOFF]
	ldr	x8, [x26]
	cmp	x0, x8
	b.ne	LBB0_8
; %bb.7:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_OVERFLOW
	cbz	w0, LBB0_28
LBB0_8:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_POINTER_TYPE_P
	cbz	x0, LBB0_11
; %bb.9:
Lloh9:
	adrp	x8, _flag_wrapv@GOTPAGE
Lloh10:
	ldr	x8, [x8, _flag_wrapv@GOTPAGEOFF]
Lloh11:
	ldr	w8, [x8]
	cbnz	w8, LBB0_11
; %bb.10:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_OVERFLOW_TRAPS
	cbz	w0, LBB0_23
LBB0_11:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_FLOAT_TYPE_P
	cbz	x0, LBB0_66
; %bb.12:
	mov	x0, x22
	bl	_strip_float_extensions
	mov	x24, x0
	mov	x0, x21
	bl	_strip_float_extensions
	mov	x23, x0
	mov	x0, x24
	bl	_TREE_TYPE
	mov	x25, x0
	mov	x0, x23
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x26, x0
	mov	x0, x25
	bl	_TYPE_PRECISION
	cmp	x26, x0
	b.le	LBB0_14
; %bb.13:
	mov	x0, x23
	bl	_TREE_TYPE
	mov	x25, x0
LBB0_14:
	mov	x0, x25
	bl	_TYPE_PRECISION
	mov	x26, x0
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	cmp	x26, x0
	b.ge	LBB0_16
; %bb.15:
	mov	x0, x25
	mov	x1, x24
	bl	_fold_convert
	mov	x21, x0
	mov	x0, x25
	mov	x1, x23
	bl	_fold_convert
	b	LBB0_19
LBB0_16:
	mov	x0, x22
	bl	_TREE_CODE
Lloh12:
	adrp	x25, _NEGATE_EXPR@GOTPAGE
Lloh13:
	ldr	x25, [x25, _NEGATE_EXPR@GOTPAGEOFF]
	ldr	x8, [x25]
	cmp	x0, x8
	b.ne	LBB0_20
; %bb.17:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x25]
	cmp	x0, x8
	b.ne	LBB0_20
; %bb.18:
	mov	x0, x21
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x21, x0
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
LBB0_19:
	mov	x3, x0
	mov	x0, x20
	mov	x1, x19
	mov	x2, x21
	bl	_fold_build2
	b	LBB0_141
LBB0_20:
	mov	x0, x21
	bl	_TREE_CODE
Lloh14:
	adrp	x24, _REAL_CST@GOTPAGE
Lloh15:
	ldr	x24, [x24, _REAL_CST@GOTPAGEOFF]
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_48
; %bb.21:
	mov	x0, x21
	bl	_TREE_REAL_CST
	mov	x23, x0
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x25]
	cmp	x0, x8
	b.ne	LBB0_35
; %bb.22:
	mov	x0, x20
	bl	_swap_tree_comparison
	mov	x20, x0
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x22, x0
	mov	x0, x21
	bl	_TREE_TYPE
	mov	x21, x0
	mov	x0, x23
	bl	_REAL_VALUE_NEGATE
	mov	x1, x0
	mov	x0, x21
	b	LBB0_37
LBB0_23:
	add	x1, sp, #24
	add	x2, sp, #16
	mov	x0, x22
	bl	_extract_array_ref
	cbz	x0, LBB0_11
; %bb.24:
	add	x1, sp, #8
	mov	x2, sp
	mov	x0, x21
	bl	_extract_array_ref
	cbz	x0, LBB0_11
; %bb.25:
	ldr	x0, [sp, #24]
	ldr	x1, [sp, #8]
	mov	w2, #0
	bl	_operand_equal_p
	cbz	x0, LBB0_11
; %bb.26:
Lloh16:
	adrp	x8, _size_type_node@GOTPAGE
Lloh17:
	ldr	x8, [x8, _size_type_node@GOTPAGEOFF]
Lloh18:
	ldr	w0, [x8]
	bl	_signed_type_for
	mov	x21, x0
	ldr	x1, [sp, #16]
	ldr	x8, [x27]
	cmp	x1, x8
	b.ne	LBB0_38
; %bb.27:
	mov	x1, #0
	bl	_build_int_cst
	b	LBB0_39
LBB0_28:
	mov	x0, x21
	bl	_TREE_TYPE
	bl	_TYPE_OVERFLOW_UNDEFINED
	cbz	x0, LBB0_8
; %bb.29:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x26]
	cmp	x0, x8
	b.ne	LBB0_8
; %bb.30:
	mov	x0, x21
	bl	_TREE_OVERFLOW
	cbnz	w0, LBB0_8
; %bb.31:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	mov	x24, x0
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x23, x0
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x28]
Lloh19:
	adrp	x9, _MINUS_EXPR@GOTPAGE
Lloh20:
	ldr	x9, [x9, _MINUS_EXPR@GOTPAGEOFF]
Lloh21:
	ldr	w9, [x9]
	cmp	x0, x8
	csel	w25, w9, w8, eq
	mov	x0, x21
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x25
	mov	x2, x21
	mov	x3, x24
	bl	_fold_build2
	mov	x24, x0
	bl	_TREE_CODE
	mov	x25, x0
	mov	x0, x21
	bl	_TREE_CODE
	cmp	x25, x0
	b.ne	LBB0_8
; %bb.32:
	mov	x0, x24
	bl	_TREE_CODE
	ldr	x8, [x26]
	cmp	x0, x8
	b.ne	LBB0_34
; %bb.33:
	mov	x0, x24
	bl	_TREE_OVERFLOW
	cbnz	w0, LBB0_8
LBB0_34:
Lloh22:
	adrp	x8, _WARN_STRICT_OVERFLOW_COMPARISON@GOTPAGE
Lloh23:
	ldr	x8, [x8, _WARN_STRICT_OVERFLOW_COMPARISON@GOTPAGEOFF]
Lloh24:
	ldr	w1, [x8]
Lloh25:
	adrp	x0, l_.str@PAGE
Lloh26:
	add	x0, x0, l_.str@PAGEOFF
	bl	_fold_overflow_warning
	mov	x0, x20
	mov	x1, x19
	mov	x2, x23
	mov	x3, x24
	b	LBB0_3
LBB0_35:
	mov	x0, x23
	bl	_REAL_VALUE_MINUS_ZERO
	cbz	x0, LBB0_44
; %bb.36:
	mov	x0, x21
	bl	_TREE_TYPE
Lloh27:
	adrp	x8, _dconst0@GOTPAGE
Lloh28:
	ldr	x8, [x8, _dconst0@GOTPAGEOFF]
Lloh29:
	ldr	w1, [x8]
LBB0_37:
	bl	_build_real
	mov	x3, x0
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	bl	_fold_build2
	b	LBB0_141
LBB0_38:
	bl	_fold_convert
LBB0_39:
	str	x0, [sp, #16]
	ldr	x1, [sp]
	ldr	x8, [x27]
	mov	x0, x21
	cmp	x1, x8
	b.ne	LBB0_41
; %bb.40:
	mov	x1, #0
	bl	_build_int_cst
	b	LBB0_42
LBB0_41:
	bl	_fold_convert
LBB0_42:
	mov	x3, x0
	str	x0, [sp]
	ldr	x2, [sp, #16]
LBB0_43:
	mov	x0, x20
	mov	x1, x19
	bl	_fold_build2
	b	LBB0_141
LBB0_44:
	mov	x0, x23
	bl	_REAL_VALUE_ISNAN
	cbz	x0, LBB0_46
; %bb.45:
	mov	x0, x21
	bl	_TREE_TYPE
	bl	_TYPE_MODE
	bl	_HONOR_SNANS
	cbz	w0, LBB0_138
LBB0_46:
	mov	x0, x23
	bl	_REAL_VALUE_ISINF
	cbz	x0, LBB0_48
; %bb.47:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_inf_compare
	ldr	x8, [x27]
	cmp	x0, x8
	b.ne	LBB0_141
LBB0_48:
Lloh30:
	adrp	x25, _flag_unsafe_math_optimizations@GOTPAGE
Lloh31:
	ldr	x25, [x25, _flag_unsafe_math_optimizations@GOTPAGEOFF]
	ldr	x8, [x25]
	cbz	x8, LBB0_61
; %bb.49:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_55
; %bb.50:
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.eq	LBB0_52
; %bb.51:
	mov	x0, x22
	bl	_TREE_CODE
Lloh32:
	adrp	x8, _MINUS_EXPR@GOTPAGE
Lloh33:
	ldr	x8, [x8, _MINUS_EXPR@GOTPAGEOFF]
Lloh34:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_55
LBB0_52:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_55
; %bb.53:
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x28]
Lloh35:
	adrp	x9, _MINUS_EXPR@GOTPAGE
Lloh36:
	ldr	x9, [x9, _MINUS_EXPR@GOTPAGEOFF]
Lloh37:
	ldr	x9, [x9]
	cmp	x0, x8
	csel	x23, x9, x8, eq
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	mov	x2, x0
	mov	x0, x23
	mov	x1, x21
	mov	w3, #0
	bl	_const_binop
	cbz	x0, LBB0_55
; %bb.54:
	mov	x23, x0
	bl	_TREE_CONSTANT_OVERFLOW
	cbz	w0, LBB0_142
LBB0_55:
	ldr	x8, [x25]
	cbz	x8, LBB0_61
; %bb.56:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_61
; %bb.57:
	mov	x0, x22
	bl	_TREE_CODE
Lloh38:
	adrp	x23, _MINUS_EXPR@GOTPAGE
Lloh39:
	ldr	x23, [x23, _MINUS_EXPR@GOTPAGEOFF]
	ldr	x8, [x23]
	cmp	x0, x8
	b.ne	LBB0_61
; %bb.58:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_61
; %bb.59:
	ldr	x23, [x23]
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x1, x0
	mov	x0, x23
	mov	x2, x21
	mov	w3, #0
	bl	_const_binop
	cbz	x0, LBB0_61
; %bb.60:
	mov	x23, x0
	bl	_TREE_CONSTANT_OVERFLOW
	cbz	w0, LBB0_143
LBB0_61:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_66
; %bb.62:
	ldr	x8, [x25]
	cbz	x8, LBB0_66
; %bb.63:
Lloh40:
	adrp	x8, _flag_errno_math@GOTPAGE
Lloh41:
	ldr	x8, [x8, _flag_errno_math@GOTPAGEOFF]
Lloh42:
	ldr	w8, [x8]
	cbnz	w8, LBB0_66
; %bb.64:
	mov	x0, x22
	bl	_builtin_mathfn_code
Lloh43:
	adrp	x8, _END_BUILTINS@GOTPAGE
Lloh44:
	ldr	x8, [x8, _END_BUILTINS@GOTPAGEOFF]
Lloh45:
	ldr	w8, [x8]
	cmp	w0, w8
	b.eq	LBB0_66
; %bb.65:
	mov	x1, x20
	mov	x2, x19
	mov	x3, x22
	mov	x4, x21
	bl	_fold_mathfn_compare
	ldr	x8, [x27]
	cmp	x0, x8
	b.ne	LBB0_141
LBB0_66:
	mov	x0, x21
	bl	_TREE_CONSTANT
	cbz	x0, LBB0_78
; %bb.67:
	mov	x0, x22
	bl	_TREE_CODE
Lloh46:
	adrp	x23, _POSTINCREMENT_EXPR@GOTPAGE
Lloh47:
	ldr	x23, [x23, _POSTINCREMENT_EXPR@GOTPAGEOFF]
	ldr	x8, [x23]
	cmp	x0, x8
	b.eq	LBB0_69
; %bb.68:
	mov	x0, x22
	bl	_TREE_CODE
Lloh48:
	adrp	x8, _POSTDECREMENT_EXPR@GOTPAGE
Lloh49:
	ldr	x8, [x8, _POSTDECREMENT_EXPR@GOTPAGEOFF]
Lloh50:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_78
LBB0_69:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_POINTER_TYPE_P
	cbz	x0, LBB0_75
LBB0_70:
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x23]
Lloh51:
	adrp	x9, _MINUS_EXPR@GOTPAGE
Lloh52:
	ldr	x9, [x9, _MINUS_EXPR@GOTPAGEOFF]
	cmp	x0, x8
	csel	x8, x28, x9, eq
	ldr	w23, [x8]
Lloh53:
	adrp	x8, _PREINCREMENT_EXPR@GOTPAGE
Lloh54:
	ldr	x8, [x8, _PREINCREMENT_EXPR@GOTPAGEOFF]
Lloh55:
	adrp	x9, _PREDECREMENT_EXPR@GOTPAGE
Lloh56:
	ldr	x9, [x9, _PREDECREMENT_EXPR@GOTPAGEOFF]
	csel	x25, x8, x9, eq
	mov	x0, x22
	bl	_TREE_TYPE
	mov	x24, x0
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	mov	x3, x0
	mov	x0, x23
	mov	x1, x24
	mov	x2, x21
	bl	_fold_build2
	mov	x23, x0
	ldr	w24, [x25]
	mov	x0, x22
	bl	_TREE_TYPE
	mov	x25, x0
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x26, x0
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	mov	x3, x0
	mov	x0, x24
	mov	x1, x25
	mov	x2, x26
	bl	_build2
	mov	x22, x0
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh57:
	adrp	x8, _COMPONENT_REF@GOTPAGE
Lloh58:
	ldr	x8, [x8, _COMPONENT_REF@GOTPAGEOFF]
Lloh59:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_96
; %bb.71:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_DECL_BIT_FIELD
	cbz	x0, LBB0_96
; %bb.72:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_DECL_SIZE
	mov	w1, #1
	bl	_host_integerp
	cbz	x0, LBB0_96
; %bb.73:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_DECL_SIZE
	mov	w1, #1
	bl	_tree_low_cst
	mov	x24, x0
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	bl	_fold_build2
	mov	x21, x0
	bl	_TREE_CODE
Lloh60:
	adrp	x8, _INTEGER_CST@GOTPAGE
Lloh61:
	ldr	x8, [x8, _INTEGER_CST@GOTPAGEOFF]
Lloh62:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_95
; %bb.74:
	mov	x0, x19
	mov	x1, x21
	b	LBB0_140
LBB0_75:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_INTEGRAL_TYPE_P
	cbz	x0, LBB0_78
; %bb.76:
	cmp	w20, #133
	b.eq	LBB0_70
; %bb.77:
	cmp	w20, #128
	b.eq	LBB0_70
LBB0_78:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TREE_CODE
Lloh63:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh64:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh65:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_83
; %bb.79:
	mov	x0, x22
	bl	_TREE_CODE
Lloh66:
	adrp	x8, _NOP_EXPR@GOTPAGE
Lloh67:
	ldr	x8, [x8, _NOP_EXPR@GOTPAGEOFF]
Lloh68:
	ldr	x8, [x8]
	cmp	x0, x8
	b.eq	LBB0_81
; %bb.80:
	mov	x0, x22
	bl	_TREE_CODE
Lloh69:
	adrp	x8, _CONVERT_EXPR@GOTPAGE
Lloh70:
	ldr	x8, [x8, _CONVERT_EXPR@GOTPAGEOFF]
Lloh71:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_83
LBB0_81:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_widened_comparison
	cbnz	x0, LBB0_141
; %bb.82:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_sign_changed_comparison
	cbnz	x0, LBB0_141
LBB0_83:
	mov	x0, x21
	bl	_TREE_CODE
Lloh72:
	adrp	x28, _INTEGER_CST@GOTPAGE
Lloh73:
	ldr	x28, [x28, _INTEGER_CST@GOTPAGEOFF]
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_88
; %bb.84:
	mov	x0, x22
	bl	_TREE_CODE
Lloh74:
	adrp	x8, _MIN_EXPR@GOTPAGE
Lloh75:
	ldr	x8, [x8, _MIN_EXPR@GOTPAGEOFF]
Lloh76:
	ldr	x8, [x8]
	cmp	x0, x8
	b.eq	LBB0_86
; %bb.85:
	mov	x0, x22
	bl	_TREE_CODE
Lloh77:
	adrp	x8, _MAX_EXPR@GOTPAGE
Lloh78:
	ldr	x8, [x8, _MAX_EXPR@GOTPAGEOFF]
Lloh79:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_88
LBB0_86:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_88
; %bb.87:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_optimize_minmax_comparison
	cbnz	x0, LBB0_141
LBB0_88:
	mov	x0, x22
	mov	x1, x21
	mov	w2, #0
	bl	_operand_equal_p
	cbz	x0, LBB0_103
; %bb.89:
	sub	w8, w20, #128
	cmp	w8, #5
	b.hi	LBB0_98
; %bb.90:
Lloh80:
	adrp	x9, lJTI0_0@PAGE
Lloh81:
	add	x9, x9, lJTI0_0@PAGEOFF
	adr	x10, LBB0_91
	ldrb	w11, [x9, x8]
	add	x10, x10, x11, lsl #2
	br	x10
LBB0_91:
	mov	w0, #0
	b	LBB0_137
LBB0_92:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_FLOAT_TYPE_P
	cbz	x0, LBB0_136
; %bb.93:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_MODE
	bl	_HONOR_NANS
	cbz	w0, LBB0_136
; %bb.94:
	mov	w0, #133
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_build2
	b	LBB0_141
LBB0_95:
	ldr	x21, [x27]
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	sub	x1, x0, x24
	mov	x0, x21
	bl	_build_int_cst
	mov	x21, x0
	mov	x0, x22
	bl	_TREE_TYPE
	mov	x1, x21
	bl	_fold_convert
	mov	x21, x0
Lloh82:
	adrp	x8, _LSHIFT_EXPR@GOTPAGE
Lloh83:
	ldr	x8, [x8, _LSHIFT_EXPR@GOTPAGEOFF]
Lloh84:
	ldr	w24, [x8]
	mov	x0, x22
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x24
	mov	x2, x23
	mov	x3, x21
	bl	_fold_build2
	mov	x23, x0
Lloh85:
	adrp	x8, _RSHIFT_EXPR@GOTPAGE
Lloh86:
	ldr	x8, [x8, _RSHIFT_EXPR@GOTPAGEOFF]
Lloh87:
	ldr	w24, [x8]
	mov	x0, x22
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x24
	mov	x2, x23
	mov	x3, x21
	bl	_fold_build2
	mov	x23, x0
LBB0_96:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
LBB0_97:
	mov	x3, x23
	bl	_fold_build2
	b	LBB0_141
LBB0_98:
	bl	_gcc_unreachable
	b	LBB0_103
LBB0_99:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_FLOAT_TYPE_P
	cbz	x0, LBB0_91
; %bb.100:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_MODE
	bl	_HONOR_NANS
	cbnz	w0, LBB0_103
	b	LBB0_91
LBB0_101:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_FLOAT_TYPE_P
	cbz	x0, LBB0_136
; %bb.102:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_MODE
	bl	_HONOR_NANS
	cbz	w0, LBB0_136
LBB0_103:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_121
; %bb.104:
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.eq	LBB0_121
; %bb.105:
	stp	xzr, xzr, [sp, #16]
	str	wzr, [sp, #8]
	add	x1, sp, #24
	add	x2, sp, #16
	add	x3, sp, #8
	mov	x0, x22
	bl	_twoval_comparison_p
	cbz	x0, LBB0_121
; %bb.106:
	ldr	x0, [sp, #24]
	cbz	x0, LBB0_121
; %bb.107:
	ldr	x8, [sp, #16]
	cbz	x8, LBB0_121
; %bb.108:
	bl	_TREE_CONSTANT
	cbz	x0, LBB0_110
; %bb.109:
	ldr	x0, [sp, #16]
	bl	_TREE_CONSTANT
	cbnz	x0, LBB0_121
LBB0_110:
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	mov	x23, x0
	ldr	x0, [sp, #16]
	bl	_TREE_TYPE
	cmp	x23, x0
	b.ne	LBB0_121
; %bb.111:
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	bl	_INTEGRAL_TYPE_P
	cbz	x0, LBB0_121
; %bb.112:
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	bl	_TYPE_MAX_VALUE
	cbz	x0, LBB0_121
; %bb.113:
	ldr	x0, [sp, #16]
	bl	_TREE_TYPE
	bl	_TYPE_MAX_VALUE
	cbz	x0, LBB0_121
; %bb.114:
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	bl	_TYPE_MIN_VALUE
	mov	x23, x0
	ldr	x0, [sp, #16]
	bl	_TREE_TYPE
	bl	_TYPE_MAX_VALUE
	mov	x1, x0
	mov	x0, x23
	mov	w2, #0
	bl	_operand_equal_p
	cbnz	x0, LBB0_121
; %bb.115:
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	bl	_TYPE_MAX_VALUE
	mov	x25, x0
	ldr	x0, [sp, #24]
	bl	_TREE_TYPE
	bl	_TYPE_MIN_VALUE
	mov	x26, x0
	ldp	x3, x1, [sp, #16]
	mov	x0, x22
	mov	x2, x25
	mov	x4, x26
	bl	_eval_subst
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	bl	_fold_build2
	mov	x23, x0
	ldp	x3, x1, [sp, #16]
	mov	x0, x22
	mov	x2, x25
	mov	x4, x25
	bl	_eval_subst
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	bl	_fold_build2
	mov	x24, x0
	ldp	x3, x1, [sp, #16]
	mov	x0, x22
	mov	x2, x26
	mov	x4, x25
	bl	_eval_subst
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	mov	x3, x21
	bl	_fold_build2
	mov	x25, x0
	mov	x0, x23
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_121
; %bb.116:
	mov	x0, x24
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_121
; %bb.117:
	mov	x0, x25
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_121
; %bb.118:
	mov	x0, x23
	bl	_integer_onep
	mov	x21, x0
	mov	x0, x24
	bl	_integer_onep
	lsl	w8, w0, #1
	add	w21, w8, w21, lsl #2
	mov	x0, x25
	bl	_integer_onep
	add	w8, w21, w0
	cmp	w8, #7
	b.hi	LBB0_151
; %bb.119:
Lloh88:
	adrp	x9, lJTI0_1@PAGE
Lloh89:
	add	x9, x9, lJTI0_1@PAGEOFF
	adr	x10, LBB0_120
	ldrb	w11, [x9, x8]
	add	x10, x10, x11, lsl #2
	br	x10
LBB0_120:
Lloh90:
	adrp	x8, _integer_zero_node@GOTPAGE
Lloh91:
	ldr	x8, [x8, _integer_zero_node@GOTPAGEOFF]
	b	LBB0_139
LBB0_121:
	mov	x0, x22
	bl	_TREE_CODE
Lloh92:
	adrp	x23, _ADDR_EXPR@GOTPAGE
Lloh93:
	ldr	x23, [x23, _ADDR_EXPR@GOTPAGEOFF]
	ldr	x8, [x23]
	cmp	x0, x8
	b.ne	LBB0_127
; %bb.122:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh94:
	adrp	x24, _COMPONENT_REF@GOTPAGE
Lloh95:
	ldr	x24, [x24, _COMPONENT_REF@GOTPAGEOFF]
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_127
; %bb.123:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x23]
	cmp	x0, x8
	b.ne	LBB0_127
; %bb.124:
	mov	x0, x21
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
	ldr	x8, [x24]
	cmp	x0, x8
	b.ne	LBB0_127
; %bb.125:
	mov	x0, x22
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x23, x0
	mov	x0, x21
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x24, x0
	mov	x0, x23
	mov	w1, #1
	bl	_TREE_OPERAND
	mov	x25, x0
	mov	x0, x24
	mov	w1, #1
	bl	_TREE_OPERAND
	cmp	x25, x0
	b.ne	LBB0_127
; %bb.126:
	mov	x0, x23
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x21, x0
	mov	x0, x24
	mov	w1, #0
	bl	_TREE_OPERAND
	mov	x22, x0
	mov	x0, x21
	bl	_build_fold_addr_expr
	mov	x21, x0
	mov	x0, x22
	bl	_build_fold_addr_expr
	b	LBB0_19
LBB0_127:
	mov	x0, x22
	bl	_TREE_CODE
Lloh96:
	adrp	x8, _TRUNC_DIV_EXPR@GOTPAGE
Lloh97:
	ldr	x8, [x8, _TRUNC_DIV_EXPR@GOTPAGEOFF]
Lloh98:
	ldr	x8, [x8]
	cmp	x0, x8
	b.eq	LBB0_129
; %bb.128:
	mov	x0, x22
	bl	_TREE_CODE
Lloh99:
	adrp	x8, _EXACT_DIV_EXPR@GOTPAGE
Lloh100:
	ldr	x8, [x8, _EXACT_DIV_EXPR@GOTPAGEOFF]
Lloh101:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_135
LBB0_129:
	mov	x0, x21
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_135
; %bb.130:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x0, x8
	b.ne	LBB0_135
; %bb.131:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_integer_zerop
	cbnz	w0, LBB0_135
; %bb.132:
	mov	x0, x22
	mov	w1, #1
	bl	_TREE_OPERAND
	bl	_TREE_OVERFLOW
	cbnz	w0, LBB0_135
; %bb.133:
	mov	x0, x21
	bl	_TREE_OVERFLOW
	cbnz	w0, LBB0_135
; %bb.134:
	mov	x0, x20
	mov	x1, x19
	mov	x2, x22
	mov	x3, x21
	bl	_fold_div_compare
	ldr	x8, [x27]
	cmp	x0, x8
	b.ne	LBB0_141
LBB0_135:
	ldr	x0, [x27]
	b	LBB0_141
LBB0_136:
	mov	w0, #1
LBB0_137:
	mov	x1, x19
	bl	_constant_boolean_node
	b	LBB0_141
LBB0_138:
Lloh102:
	adrp	x8, _integer_one_node@GOTPAGE
Lloh103:
	ldr	x8, [x8, _integer_one_node@GOTPAGEOFF]
Lloh104:
	adrp	x9, _integer_zero_node@GOTPAGE
Lloh105:
	ldr	x9, [x9, _integer_zero_node@GOTPAGEOFF]
	cmp	w20, #128
	csel	x8, x8, x9, eq
LBB0_139:
	ldr	x1, [x8]
	mov	x0, x19
LBB0_140:
	mov	x2, x22
	bl	_omit_one_operand
LBB0_141:
	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
	add	sp, sp, #128
	ret
LBB0_142:
	mov	x0, x22
	mov	w1, #0
	b	LBB0_144
LBB0_143:
	mov	x0, x20
	bl	_swap_tree_comparison
	mov	x20, x0
	mov	x0, x22
	mov	w1, #1
LBB0_144:
	bl	_TREE_OPERAND
	mov	x2, x0
	mov	x0, x20
	mov	x1, x19
	b	LBB0_97
LBB0_145:
	mov	w20, #129
	b	LBB0_151
LBB0_146:
	mov	w20, #133
	b	LBB0_151
LBB0_147:
	mov	w20, #130
	b	LBB0_151
LBB0_148:
	mov	w20, #131
	b	LBB0_151
LBB0_149:
	mov	w20, #128
	b	LBB0_151
LBB0_150:
	mov	w20, #132
LBB0_151:
	ldr	w8, [sp, #8]
	ldp	x3, x2, [sp, #16]
	cbz	w8, LBB0_43
; %bb.152:
	mov	x0, x20
	mov	x1, x19
	bl	_build2
	bl	_save_expr
	b	LBB0_141
LBB0_153:
Lloh106:
	adrp	x8, _integer_one_node@GOTPAGE
Lloh107:
	ldr	x8, [x8, _integer_one_node@GOTPAGEOFF]
	b	LBB0_139
	.loh AdrpLdrGot	Lloh0, Lloh1
	.loh AdrpLdrGot	Lloh2, Lloh3
	.loh AdrpLdrGotLdr	Lloh4, Lloh5, Lloh6
	.loh AdrpLdrGot	Lloh7, Lloh8
	.loh AdrpLdrGotLdr	Lloh9, Lloh10, Lloh11
	.loh AdrpLdrGot	Lloh12, Lloh13
	.loh AdrpLdrGot	Lloh14, Lloh15
	.loh AdrpLdrGotLdr	Lloh16, Lloh17, Lloh18
	.loh AdrpLdrGotLdr	Lloh19, Lloh20, Lloh21
	.loh AdrpAdd	Lloh25, Lloh26
	.loh AdrpLdrGotLdr	Lloh22, Lloh23, Lloh24
	.loh AdrpLdrGotLdr	Lloh27, Lloh28, Lloh29
	.loh AdrpLdrGot	Lloh30, Lloh31
	.loh AdrpLdrGotLdr	Lloh32, Lloh33, Lloh34
	.loh AdrpLdrGotLdr	Lloh35, Lloh36, Lloh37
	.loh AdrpLdrGot	Lloh38, Lloh39
	.loh AdrpLdrGotLdr	Lloh40, Lloh41, Lloh42
	.loh AdrpLdrGotLdr	Lloh43, Lloh44, Lloh45
	.loh AdrpLdrGot	Lloh46, Lloh47
	.loh AdrpLdrGotLdr	Lloh48, Lloh49, Lloh50
	.loh AdrpLdrGotLdr	Lloh57, Lloh58, Lloh59
	.loh AdrpLdrGot	Lloh55, Lloh56
	.loh AdrpLdrGot	Lloh53, Lloh54
	.loh AdrpLdrGot	Lloh51, Lloh52
	.loh AdrpLdrGotLdr	Lloh60, Lloh61, Lloh62
	.loh AdrpLdrGotLdr	Lloh63, Lloh64, Lloh65
	.loh AdrpLdrGotLdr	Lloh66, Lloh67, Lloh68
	.loh AdrpLdrGotLdr	Lloh69, Lloh70, Lloh71
	.loh AdrpLdrGot	Lloh72, Lloh73
	.loh AdrpLdrGotLdr	Lloh74, Lloh75, Lloh76
	.loh AdrpLdrGotLdr	Lloh77, Lloh78, Lloh79
	.loh AdrpAdd	Lloh80, Lloh81
	.loh AdrpLdrGotLdr	Lloh85, Lloh86, Lloh87
	.loh AdrpLdrGotLdr	Lloh82, Lloh83, Lloh84
	.loh AdrpAdd	Lloh88, Lloh89
	.loh AdrpLdrGot	Lloh90, Lloh91
	.loh AdrpLdrGot	Lloh92, Lloh93
	.loh AdrpLdrGot	Lloh94, Lloh95
	.loh AdrpLdrGotLdr	Lloh96, Lloh97, Lloh98
	.loh AdrpLdrGotLdr	Lloh99, Lloh100, Lloh101
	.loh AdrpLdrGot	Lloh104, Lloh105
	.loh AdrpLdrGot	Lloh102, Lloh103
	.loh AdrpLdrGot	Lloh106, Lloh107
	.cfi_endproc
	.section	__TEXT,__const
lJTI0_0:
	.byte	(LBB0_99-LBB0_91)>>2
	.byte	(LBB0_91-LBB0_91)>>2
	.byte	(LBB0_92-LBB0_91)>>2
	.byte	(LBB0_91-LBB0_91)>>2
	.byte	(LBB0_92-LBB0_91)>>2
	.byte	(LBB0_101-LBB0_91)>>2
lJTI0_1:
	.byte	(LBB0_120-LBB0_120)>>2
	.byte	(LBB0_145-LBB0_120)>>2
	.byte	(LBB0_146-LBB0_120)>>2
	.byte	(LBB0_147-LBB0_120)>>2
	.byte	(LBB0_148-LBB0_120)>>2
	.byte	(LBB0_149-LBB0_120)>>2
	.byte	(LBB0_150-LBB0_120)>>2
	.byte	(LBB0_153-LBB0_120)>>2
                                        ; -- End function
	.comm	_NULL_TREE,8,3                  ; @NULL_TREE
	.comm	_PLUS_EXPR,8,3                  ; @PLUS_EXPR
	.comm	_MINUS_EXPR,8,3                 ; @MINUS_EXPR
	.comm	_INTEGER_CST,8,3                ; @INTEGER_CST
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C1 +- C2"

	.comm	_WARN_STRICT_OVERFLOW_COMPARISON,4,2 ; @WARN_STRICT_OVERFLOW_COMPARISON
	.comm	_flag_wrapv,4,2                 ; @flag_wrapv
	.comm	_size_type_node,4,2             ; @size_type_node
	.comm	_NEGATE_EXPR,8,3                ; @NEGATE_EXPR
	.comm	_REAL_CST,8,3                   ; @REAL_CST
	.comm	_dconst0,4,2                    ; @dconst0
	.comm	_integer_one_node,8,3           ; @integer_one_node
	.comm	_integer_zero_node,8,3          ; @integer_zero_node
	.comm	_flag_unsafe_math_optimizations,8,3 ; @flag_unsafe_math_optimizations
	.comm	_flag_errno_math,4,2            ; @flag_errno_math
	.comm	_END_BUILTINS,4,2               ; @END_BUILTINS
	.comm	_POSTINCREMENT_EXPR,8,3         ; @POSTINCREMENT_EXPR
	.comm	_POSTDECREMENT_EXPR,8,3         ; @POSTDECREMENT_EXPR
	.comm	_PREINCREMENT_EXPR,4,2          ; @PREINCREMENT_EXPR
	.comm	_PREDECREMENT_EXPR,4,2          ; @PREDECREMENT_EXPR
	.comm	_COMPONENT_REF,8,3              ; @COMPONENT_REF
	.comm	_LSHIFT_EXPR,4,2                ; @LSHIFT_EXPR
	.comm	_RSHIFT_EXPR,4,2                ; @RSHIFT_EXPR
	.comm	_INTEGER_TYPE,8,3               ; @INTEGER_TYPE
	.comm	_NOP_EXPR,8,3                   ; @NOP_EXPR
	.comm	_CONVERT_EXPR,8,3               ; @CONVERT_EXPR
	.comm	_MIN_EXPR,8,3                   ; @MIN_EXPR
	.comm	_MAX_EXPR,8,3                   ; @MAX_EXPR
	.comm	_ADDR_EXPR,8,3                  ; @ADDR_EXPR
	.comm	_TRUNC_DIV_EXPR,8,3             ; @TRUNC_DIV_EXPR
	.comm	_EXACT_DIV_EXPR,8,3             ; @EXACT_DIV_EXPR
	.no_dead_strip	_fold_comparison
.subsections_via_symbols
