	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_build_binary_op                ## -- Begin function build_binary_op
	.p2align	4, 0x90
_build_binary_op:                       ## @build_binary_op
	.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	$184, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	movq	%rdx, %r15
	movq	%rsi, %rbx
                                        ## kill: def $edi killed $edi def $rdi
	movq	%rdi, -64(%rbp)                 ## 8-byte Spill
	movq	%rdx, %r14
	movq	%rsi, %r12
	testl	%ecx, %ecx
	je	LBB0_2
## %bb.1:
	movq	%rbx, %rdi
	callq	_default_conversion
	movq	%rax, %r12
	movq	%r15, %rdi
	callq	_default_conversion
	movq	%rax, %r14
LBB0_2:
	movq	%r15, -168(%rbp)                ## 8-byte Spill
	movq	%rbx, -136(%rbp)                ## 8-byte Spill
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rbx
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r13
	movq	%rbx, -80(%rbp)                 ## 8-byte Spill
	movq	%rbx, %rdi
	callq	_TREE_CODE
	movl	%eax, %r15d
	movq	%r13, -96(%rbp)                 ## 8-byte Spill
	movq	%r13, %rdi
	callq	_TREE_CODE
	movl	%eax, %ebx
	movq	%r12, %rdi
	callq	_STRIP_TYPE_NOPS
	movq	%r14, %rdi
	callq	_STRIP_TYPE_NOPS
	movq	_ERROR_MARK@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%eax, %r15d
	je	LBB0_6
## %bb.3:
	cmpl	%eax, %ebx
	je	LBB0_6
## %bb.4:
	movl	%ebx, -44(%rbp)                 ## 4-byte Spill
	movq	%r14, -112(%rbp)                ## 8-byte Spill
	movl	%r15d, %r14d
	movq	_targetm@GOTPCREL(%rip), %rax
	movq	-64(%rbp), %r13                 ## 8-byte Reload
	movl	%r13d, %edi
	movq	-80(%rbp), %r15                 ## 8-byte Reload
	movq	%r15, %rsi
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	%rbx, %rdx
	callq	*(%rax)
	testq	%rax, %rax
	je	LBB0_8
## %bb.5:
	leaq	L_.str(%rip), %rsi
	movq	%rax, %rdi
	callq	_error
LBB0_6:
	movq	_error_mark_node@GOTPCREL(%rip), %rax
	movq	(%rax), %rax
LBB0_7:
	addq	$184, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_8:
	movq	_NULL_TREE@GOTPCREL(%rip), %rax
	movq	(%rax), %rcx
	leaq	L_.str.1(%rip), %r8
	movq	%r15, %rdi
	movq	%rbx, %rsi
	movl	$-3, %edx
	callq	_objc_compare_types
	leal	-128(%r13), %edx
	cmpl	$25, %edx
	ja	LBB0_115
## %bb.9:
	xorl	%r11d, %r11d
	movb	$1, %r9b
	leaq	LJTI0_0(%rip), %rcx
	movslq	(%rcx,%rdx,4), %rsi
	addq	%rcx, %rsi
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
                                        ## kill: def $r13d killed $r13d killed $r13
	movl	%r14d, %r15d
	jmpq	*%rsi
LBB0_10:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	movq	_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %esi
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	_REAL_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	_COMPLEX_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%edi, %r15d
	je	LBB0_47
## %bb.11:
	cmpl	%esi, %r15d
	je	LBB0_47
## %bb.12:
	cmpl	%edx, %r15d
	je	LBB0_47
## %bb.13:
	cmpl	%ecx, %r15d
	je	LBB0_47
## %bb.14:
	cmpl	%eax, %r15d
	je	LBB0_47
## %bb.15:
	xorl	%r9d, %r9d
	jmp	LBB0_87
LBB0_16:
	movq	%r12, -72(%rbp)                 ## 8-byte Spill
	movq	_skip_evaluation@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	jne	LBB0_19
## %bb.17:
	movq	%rbx, %rdi
	callq	_integer_zerop
	movb	$1, %r9b
	testl	%eax, %eax
	je	LBB0_19
## %bb.18:
	movq	_OPT_Wdiv_by_zero@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.2(%rip), %rsi
	xorl	%eax, %eax
	callq	_warning
	movb	$1, %r9b
LBB0_19:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %r13
	movl	(%r13), %esi
	movq	_REAL_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %edx
	movq	_COMPLEX_TYPE@GOTPCREL(%rip), %r12
	movl	(%r12), %eax
	movq	_VECTOR_TYPE@GOTPCREL(%rip), %r14
	movl	(%r14), %ecx
	cmpl	%esi, %r15d
	je	LBB0_23
## %bb.20:
	cmpl	%edx, %r15d
	je	LBB0_23
## %bb.21:
	cmpl	%eax, %r15d
	je	LBB0_23
## %bb.22:
	cmpl	%ecx, %r15d
	jne	LBB0_27
LBB0_23:
	movl	-44(%rbp), %edi                 ## 4-byte Reload
	cmpl	%esi, %edi
	je	LBB0_91
## %bb.24:
	cmpl	%edx, %edi
	je	LBB0_91
## %bb.25:
	cmpl	%eax, %edi
	je	LBB0_91
## %bb.26:
	cmpl	%ecx, %edi
	je	LBB0_91
LBB0_27:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
LBB0_28:
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
LBB0_29:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	jmp	LBB0_108
LBB0_30:
	movq	_integer_type_node@GOTPCREL(%rip), %rax
	movq	(%rax), %rdi
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %r14
	movl	(%r14), %ecx
	movq	_REAL_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%ecx, %r15d
	je	LBB0_32
## %bb.31:
	cmpl	%eax, %r15d
	jne	LBB0_34
LBB0_32:
	xorl	%r9d, %r9d
	movb	$1, %r10b
	movl	-44(%rbp), %edx                 ## 4-byte Reload
	cmpl	%ecx, %edx
	je	LBB0_137
## %bb.33:
	cmpl	%eax, %edx
	je	LBB0_137
LBB0_34:
	movq	%r12, -72(%rbp)                 ## 8-byte Spill
	movq	_POINTER_TYPE@GOTPCREL(%rip), %rbx
	movl	(%rbx), %eax
	cmpl	%eax, %r15d
	movq	%rdi, -56(%rbp)                 ## 8-byte Spill
	jne	LBB0_82
## %bb.35:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_82
## %bb.36:
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movq	%rbx, %rdi
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	movq	%r14, %rsi
	callq	_comp_target_types
	testl	%eax, %eax
	je	LBB0_139
## %bb.37:
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_common_pointer_type
	movq	%rax, -104(%rbp)                ## 8-byte Spill
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_COMPLETE_TYPE_P
	testl	%eax, %eax
	setne	%bl
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_COMPLETE_TYPE_P
	testl	%eax, %eax
	sete	%al
	xorb	%bl, %al
	je	LBB0_144
## %bb.38:
	movq	_pedantic@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	je	LBB0_41
## %bb.39:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_FUNCTION_TYPE@GOTPCREL(%rip), %rcx
	xorl	%r9d, %r9d
	cmpl	(%rcx), %eax
	jne	LBB0_42
## %bb.40:
	leaq	L_.str.14(%rip), %rdi
	callq	_pedwarn
LBB0_41:
	xorl	%r9d, %r9d
LBB0_42:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movl	%ebx, %r13d
	jmp	LBB0_43
LBB0_44:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%eax, %r15d
	jne	LBB0_86
## %bb.45:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_86
## %bb.46:
	xorl	%r9d, %r9d
	movl	$-1, %edx
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	jmp	LBB0_88
LBB0_47:
	movl	-44(%rbp), %ebx                 ## 4-byte Reload
	cmpl	%edi, %ebx
	movq	-64(%rbp), %r14                 ## 8-byte Reload
	je	LBB0_106
## %bb.48:
	cmpl	%esi, %ebx
	je	LBB0_106
## %bb.49:
	cmpl	%edx, %ebx
	je	LBB0_106
## %bb.50:
	cmpl	%ecx, %ebx
	je	LBB0_106
## %bb.51:
	cmpl	%eax, %ebx
	je	LBB0_106
## %bb.52:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
	jmp	LBB0_107
LBB0_53:
	movq	_skip_evaluation@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	movq	-112(%rbp), %r14                ## 8-byte Reload
	jne	LBB0_56
## %bb.54:
	movq	%r14, %rdi
	callq	_integer_zerop
	testl	%eax, %eax
	je	LBB0_56
## %bb.55:
	movq	_OPT_Wdiv_by_zero@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.2(%rip), %rsi
	xorl	%eax, %eax
	callq	_warning
LBB0_56:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	xorl	%r9d, %r9d
	cmpl	%eax, %r15d
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	jne	LBB0_138
## %bb.57:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_58
LBB0_138:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	jmp	LBB0_103
LBB0_61:
	movl	%eax, -84(%rbp)                 ## 4-byte Spill
	movq	%r12, -72(%rbp)                 ## 8-byte Spill
	movq	_REAL_TYPE@GOTPCREL(%rip), %rbx
	movl	(%rbx), %eax
	cmpl	%eax, %r15d
	je	LBB0_63
## %bb.62:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_64
LBB0_63:
	movq	_OPT_Wfloat_equal@GOTPCREL(%rip), %rax
	movl	(%rax), %edi
	leaq	L_.str.7(%rip), %rsi
	xorl	%eax, %eax
	callq	_warning
	movl	(%rbx), %eax
LBB0_64:
	movq	_integer_type_node@GOTPCREL(%rip), %rcx
	movq	(%rcx), %rdi
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %r12
	movl	(%r12), %edx
	movq	_COMPLEX_TYPE@GOTPCREL(%rip), %rcx
	movl	(%rcx), %ecx
	cmpl	%edx, %r15d
	je	LBB0_67
## %bb.65:
	cmpl	%eax, %r15d
	je	LBB0_67
## %bb.66:
	cmpl	%ecx, %r15d
	jne	LBB0_70
LBB0_67:
	xorl	%r9d, %r9d
	movb	$1, %r10b
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	cmpl	%edx, %esi
	je	LBB0_140
## %bb.68:
	cmpl	%eax, %esi
	je	LBB0_140
## %bb.69:
	cmpl	%ecx, %esi
	je	LBB0_140
LBB0_70:
	movq	_POINTER_TYPE@GOTPCREL(%rip), %rbx
	movl	(%rbx), %eax
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %r13
	movl	(%r13), %ecx
	cmpl	%eax, %r15d
	movq	%rdi, -56(%rbp)                 ## 8-byte Spill
	je	LBB0_72
## %bb.71:
	cmpl	%ecx, %r15d
	jne	LBB0_74
LBB0_72:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_145
## %bb.73:
	cmpl	%ecx, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_145
LBB0_74:
	cmpl	%eax, %r15d
	jne	LBB0_159
## %bb.75:
	movq	-168(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	je	LBB0_158
## %bb.76:
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	%r12, %rdi
	callq	_TREE_CODE
	movq	_ADDR_EXPR@GOTPCREL(%rip), %rcx
	xorl	%r9d, %r9d
	cmpl	(%rcx), %eax
	jne	LBB0_186
## %bb.77:
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_P
	testl	%eax, %eax
	movq	-64(%rbp), %r14                 ## 8-byte Reload
	je	LBB0_277
## %bb.78:
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_PARM_DECL@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	je	LBB0_276
## %bb.79:
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_LABEL_DECL@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	je	LBB0_276
## %bb.80:
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_WEAK
	testl	%eax, %eax
	je	LBB0_276
## %bb.81:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	movq	%r14, %rbx
	jmp	LBB0_167
LBB0_82:
	cmpl	%eax, %r15d
	jne	LBB0_151
## %bb.83:
	movq	-168(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	je	LBB0_150
## %bb.84:
	movq	_pedantic@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	_extra_warnings@GOTPCREL(%rip), %rcx
	xorl	%r9d, %r9d
	orl	(%rcx), %eax
	je	LBB0_173
## %bb.85:
	leaq	L_.str.15(%rip), %rdi
	jmp	LBB0_172
LBB0_86:
	movq	_VECTOR_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movl	%r15d, %ecx
	xorl	%eax, %ecx
	xorl	-44(%rbp), %eax                 ## 4-byte Folded Reload
	orl	%ecx, %eax
	sete	%r9b
LBB0_87:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
LBB0_88:
	xorl	%edi, %edi
LBB0_89:
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
LBB0_90:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	jmp	LBB0_108
LBB0_91:
	cmpl	%eax, %r15d
	je	LBB0_93
## %bb.92:
	movl	%r15d, %esi
	cmpl	%ecx, %r15d
	jne	LBB0_94
LBB0_93:
	movq	-72(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_CODE
	movb	$1, %r9b
	movl	%eax, %esi
	movl	(%r12), %eax
	movl	(%r14), %ecx
LBB0_94:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	movq	%rbx, %r14
	je	LBB0_96
## %bb.95:
	movl	-44(%rbp), %edx                 ## 4-byte Reload
	movl	%edx, %eax
	cmpl	%ecx, %edx
	jne	LBB0_97
LBB0_96:
	movq	%r14, %rdi
	movl	%esi, %ebx
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_CODE
	movl	%ebx, %esi
	movb	$1, %r9b
LBB0_97:
	movl	(%r13), %ecx
	cmpl	%ecx, %esi
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	jne	LBB0_183
## %bb.98:
	cmpl	%ecx, %eax
	jne	LBB0_183
LBB0_58:
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movb	$1, %r9b
	movb	$1, %cl
	testl	%eax, %eax
	jne	LBB0_102
## %bb.59:
	movq	%r14, %rdi
	callq	_TREE_CODE
	cltq
	movq	_INTEGER_CST@GOTPCREL(%rip), %rcx
	cmpq	%rax, (%rcx)
	jne	LBB0_60
## %bb.100:
	movq	%r14, %rdi
	callq	_integer_all_onesp
	testl	%eax, %eax
	sete	%cl
	jmp	LBB0_101
LBB0_106:
	movq	_integer_type_node@GOTPCREL(%rip), %rax
	movq	(%rax), %rbx
	movq	%r12, %rdi
	callq	_c_common_truthvalue_conversion
	movq	%rax, %r12
	movq	-112(%rbp), %rdi                ## 8-byte Reload
	callq	_c_common_truthvalue_conversion
	movq	%rbx, %r8
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	movl	$1, %ecx
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
LBB0_107:
	movl	%r14d, %r13d
	jmp	LBB0_108
LBB0_115:
	xorl	%eax, %eax
	callq	_gcc_unreachable
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
                                        ## kill: def $r13d killed $r13d killed $r13
	movl	%r14d, %r15d
	jmp	LBB0_108
LBB0_116:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	xorl	%r9d, %r9d
	movl	$135, %r13d
	cmpl	%eax, %r15d
	jne	LBB0_184
## %bb.117:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_184
## %bb.118:
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %rdi
	callq	_TREE_CODE
	cltq
	movq	_INTEGER_CST@GOTPCREL(%rip), %rcx
	cmpq	%rax, (%rcx)
	jne	LBB0_210
## %bb.119:
	movq	_skip_evaluation@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	movl	$0, %r14d
	jne	LBB0_268
## %bb.120:
	movq	%rbx, %rdi
	callq	_tree_int_cst_sgn
	testl	%eax, %eax
	js	LBB0_266
## %bb.121:
	movq	%rbx, %rdi
	callq	_integer_zerop
	testl	%eax, %eax
	sete	%r14b
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TYPE_PRECISION
	movq	%rbx, %rdi
	movl	%eax, %esi
	callq	_compare_tree_int
	testq	%rax, %rax
	js	LBB0_268
## %bb.122:
	leaq	L_.str.4(%rip), %rsi
	jmp	LBB0_267
LBB0_123:
	movq	_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %ecx
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%ecx, %r15d
	jne	LBB0_141
## %bb.124:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_141
## %bb.125:
	movl	$137, %edi
	movq	%r12, %rsi
	movq	-112(%rbp), %rdx                ## 8-byte Reload
	jmp	LBB0_182
LBB0_126:
	movq	%r12, %r14
	movq	_POINTER_TYPE@GOTPCREL(%rip), %r12
	movl	(%r12), %eax
	cmpl	%eax, %r15d
	jne	LBB0_157
## %bb.127:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	jne	LBB0_179
## %bb.128:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	-96(%rbp), %rsi                 ## 8-byte Reload
	callq	_comp_target_types
	testl	%eax, %eax
	je	LBB0_178
## %bb.129:
	movq	%r14, %rdi
	movq	%rbx, %rsi
	addq	$184, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_pointer_diff                   ## TAILCALL
LBB0_130:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	xorl	%r9d, %r9d
	movl	$142, %r13d
	cmpl	%eax, %r15d
	jne	LBB0_184
## %bb.131:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_184
## %bb.132:
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	movq	%rbx, %rdi
	callq	_TREE_CODE
	cltq
	movq	_INTEGER_CST@GOTPCREL(%rip), %rcx
	cmpq	%rax, (%rcx)
	jne	LBB0_273
## %bb.133:
	movq	_skip_evaluation@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	jne	LBB0_273
## %bb.134:
	movq	%rbx, %rdi
	callq	_tree_int_cst_sgn
	testl	%eax, %eax
	js	LBB0_271
## %bb.135:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TYPE_PRECISION
	movq	%rbx, %rdi
	movl	%eax, %esi
	callq	_compare_tree_int
	testq	%rax, %rax
	js	LBB0_273
## %bb.136:
	leaq	L_.str.6(%rip), %rsi
	jmp	LBB0_272
LBB0_137:
	xorl	%r11d, %r11d
	xorl	%edx, %edx
	jmp	LBB0_89
LBB0_183:
	movq	_RDIV_EXPR@GOTPCREL(%rip), %rax
	movl	(%rax), %r13d
LBB0_184:
	xorl	%r11d, %r11d
LBB0_185:
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
	jmp	LBB0_108
LBB0_139:
	movq	_ptr_type_node@GOTPCREL(%rip), %rax
	movq	(%rax), %rbx
	leaq	L_.str.10(%rip), %rdi
	callq	_pedwarn
	movq	%rbx, %r8
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	jmp	LBB0_174
LBB0_140:
	xorl	%r11d, %r11d
	xorl	%edx, %edx
	jmp	LBB0_28
LBB0_141:
	xorl	%r11d, %r11d
	movl	$137, %r13d
	cmpl	%ecx, -44(%rbp)                 ## 4-byte Folded Reload
	movq	-112(%rbp), %rsi                ## 8-byte Reload
	jne	LBB0_185
## %bb.142:
	cmpl	%eax, %r15d
	jne	LBB0_185
## %bb.143:
	movl	$137, %edi
	movq	%r12, %rdx
	jmp	LBB0_182
LBB0_144:
	leaq	L_.str.13(%rip), %rdi
	callq	_pedwarn
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
LBB0_43:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movq	-104(%rbp), %r8                 ## 8-byte Reload
	jmp	LBB0_108
LBB0_145:
	movl	%r15d, -148(%rbp)               ## 4-byte Spill
	movq	-80(%rbp), %r15                 ## 8-byte Reload
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r12
	movq	-96(%rbp), %rbx                 ## 8-byte Reload
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %r13
	movq	%r15, %rdi
	movq	%rbx, %rsi
	callq	_comp_target_types
	testl	%eax, %eax
	je	LBB0_195
## %bb.146:
	movq	%r15, %rdi
	movq	%rbx, %rsi
	callq	_common_pointer_type
	movq	%rax, %r8
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movl	-148(%rbp), %r15d               ## 4-byte Reload
	jmp	LBB0_147
LBB0_60:
	xorl	%ecx, %ecx
LBB0_101:
	movb	$1, %r9b
LBB0_102:
	movzbl	%cl, %edx
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
LBB0_103:
	xorl	%edi, %edi
LBB0_104:
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
LBB0_105:
	movl	%ebx, %r13d
	jmp	LBB0_108
LBB0_150:
	movl	(%rbx), %eax
LBB0_151:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_169
## %bb.152:
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	je	LBB0_168
## %bb.153:
	movq	_pedantic@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	je	LBB0_155
## %bb.154:
	leaq	L_.str.15(%rip), %rdi
	callq	_pedwarn
LBB0_155:
	xorl	%r9d, %r9d
	jmp	LBB0_156
LBB0_157:
	movq	-112(%rbp), %rbx                ## 8-byte Reload
	jmp	LBB0_179
LBB0_158:
	movl	(%rbx), %eax
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
LBB0_159:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_189
## %bb.160:
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	je	LBB0_188
## %bb.161:
	movq	-112(%rbp), %r14                ## 8-byte Reload
	movq	%r14, %rdi
	callq	_TREE_CODE
	movq	_ADDR_EXPR@GOTPCREL(%rip), %rcx
	xorl	%r9d, %r9d
	cmpl	(%rcx), %eax
	jne	LBB0_156
## %bb.162:
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_P
	testl	%eax, %eax
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	je	LBB0_334
## %bb.163:
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_PARM_DECL@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	movq	-96(%rbp), %r13                 ## 8-byte Reload
	je	LBB0_319
## %bb.164:
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_TREE_CODE
	movq	_LABEL_DECL@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	je	LBB0_319
## %bb.165:
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	movq	%rax, %rdi
	callq	_DECL_WEAK
	testl	%eax, %eax
	je	LBB0_319
## %bb.166:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	%r13, %r8
LBB0_167:
	movl	%ebx, %r13d
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%r9d, %r9d
	jmp	LBB0_108
LBB0_156:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-96(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_174
LBB0_168:
	movl	(%rbx), %eax
LBB0_169:
	movl	(%r14), %ecx
	cmpl	%eax, %r15d
	jne	LBB0_175
## %bb.170:
	cmpl	%ecx, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_175
## %bb.171:
	leaq	L_.str.12(%rip), %rdi
LBB0_172:
	callq	_pedwarn
	xorl	%r9d, %r9d
LBB0_173:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
LBB0_174:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_108
LBB0_175:
	xorl	%r9d, %r9d
	cmpl	%ecx, %r15d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	jne	LBB0_278
## %bb.176:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	movq	-96(%rbp), %r14                 ## 8-byte Reload
	jne	LBB0_280
## %bb.177:
	leaq	L_.str.12(%rip), %rdi
	callq	_pedwarn
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	%r14, %r8
	jmp	LBB0_281
LBB0_178:
	movl	(%r12), %eax
	movb	$1, %r9b
LBB0_179:
	xorl	%r11d, %r11d
	movl	$140, %r13d
	cmpl	%eax, %r15d
	jne	LBB0_187
## %bb.180:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rax
	movl	-44(%rbp), %ecx                 ## 4-byte Reload
	cmpl	(%rax), %ecx
	movq	%r14, %r12
	jne	LBB0_185
## %bb.181:
	movl	$140, %edi
	movq	%r12, %rsi
	movq	%rbx, %rdx
LBB0_182:
	addq	$184, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	jmp	_pointer_int_sum                ## TAILCALL
LBB0_186:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_279
LBB0_187:
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
	movq	%r14, %r12
	jmp	LBB0_108
LBB0_188:
	movl	(%rbx), %eax
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
LBB0_189:
	movl	(%r12), %ecx
	cmpl	%eax, %r15d
	jne	LBB0_192
## %bb.190:
	cmpl	%ecx, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_192
## %bb.191:
	leaq	L_.str.12(%rip), %rdi
	callq	_pedwarn
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_29
LBB0_192:
	cmpl	%ecx, %r15d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	jne	LBB0_207
## %bb.193:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_207
## %bb.194:
	leaq	L_.str.12(%rip), %rdi
	callq	_pedwarn
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-96(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_90
LBB0_195:
	movq	%r12, %rbx
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movl	-148(%rbp), %r15d               ## 4-byte Reload
	jne	LBB0_198
## %bb.196:
	movq	%rbx, %rdi
	callq	_VOID_TYPE_P
	testl	%eax, %eax
	jne	LBB0_205
## %bb.197:
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
LBB0_198:
	cmpl	%eax, %r15d
	jne	LBB0_200
## %bb.199:
	movq	%r13, %rdi
	callq	_VOID_TYPE_P
	testl	%eax, %eax
	jne	LBB0_205
LBB0_200:
	movq	%rbx, %rdi
	callq	_VOID_TYPE_P
	testl	%eax, %eax
	je	LBB0_335
## %bb.201:
	movq	_pedantic@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	je	LBB0_205
## %bb.202:
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	jne	LBB0_205
## %bb.203:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_FUNCTION_TYPE@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	jne	LBB0_205
## %bb.204:
	leaq	L_.str.8(%rip), %rdi
	callq	_pedwarn
	jmp	LBB0_205
LBB0_207:
	movl	(%r13), %eax
	cmpl	%eax, %r15d
	movq	-64(%rbp), %rbx                 ## 8-byte Reload
	movq	-96(%rbp), %r13                 ## 8-byte Reload
	jne	LBB0_341
## %bb.208:
	movq	-168(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	xorl	%r9d, %r9d
	testl	%eax, %eax
	je	LBB0_340
## %bb.209:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_281
LBB0_210:
	xorl	%r14d, %r14d
	jmp	LBB0_268
LBB0_266:
	leaq	L_.str.3(%rip), %rsi
	xorl	%r14d, %r14d
LBB0_267:
	xorl	%edi, %edi
	xorl	%eax, %eax
	callq	_warning
LBB0_268:
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAIN_VARIANT
	movq	_integer_type_node@GOTPCREL(%rip), %rcx
	movq	(%rcx), %rdi
	movl	$1, %ecx
	cmpq	%rdi, %rax
	jne	LBB0_270
## %bb.269:
	xorl	%r9d, %r9d
	xorl	%r10d, %r10d
	xorl	%edi, %edi
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	movq	%r14, %r11
	xorl	%edx, %edx
	jmp	LBB0_108
LBB0_270:
	movq	%rbx, %rsi
	callq	_convert
	movl	$1, %ecx
	movq	%rax, -112(%rbp)                ## 8-byte Spill
	xorl	%r9d, %r9d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	movq	%r14, %r11
	jmp	LBB0_108
LBB0_271:
	leaq	L_.str.5(%rip), %rsi
LBB0_272:
	xorl	%edi, %edi
	xorl	%eax, %eax
	callq	_warning
LBB0_273:
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAIN_VARIANT
	movq	_integer_type_node@GOTPCREL(%rip), %rcx
	movq	(%rcx), %rdi
	movl	$1, %ecx
	cmpq	%rdi, %rax
	je	LBB0_275
## %bb.274:
	movq	%rbx, %rsi
	callq	_convert
	movl	$1, %ecx
	movq	%rax, -112(%rbp)                ## 8-byte Spill
LBB0_275:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%edi, %edi
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	jmp	LBB0_108
LBB0_276:
	movq	_OPT_Waddress@GOTPCREL(%rip), %rax
	movl	(%rax), %ebx
	movq	%r12, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	leaq	L_.str.11(%rip), %rsi
	movl	%ebx, %edi
	movq	%rax, %rdx
	xorl	%eax, %eax
	callq	_warning
LBB0_277:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%ecx, %ecx
	movq	-80(%rbp), %r8                  ## 8-byte Reload
	movq	%r14, %rbx
	jmp	LBB0_320
LBB0_278:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
LBB0_279:
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_108
LBB0_280:
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
LBB0_281:
	movl	%ebx, %r13d
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	jmp	LBB0_108
LBB0_319:
	movq	_OPT_Waddress@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movl	%eax, -84(%rbp)                 ## 4-byte Spill
	movq	%r14, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	leaq	L_.str.11(%rip), %rsi
	movl	-84(%rbp), %edi                 ## 4-byte Reload
	movq	%rax, %rdx
	xorl	%eax, %eax
	callq	_warning
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%ecx, %ecx
	movq	%r13, %r8
LBB0_320:
	movl	%ebx, %r13d
LBB0_321:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%edx, %edx
LBB0_108:
	movq	_ERROR_MARK@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%eax, %r15d
	je	LBB0_6
## %bb.109:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_6
## %bb.110:
	movq	%rdx, -200(%rbp)                ## 8-byte Spill
	movl	%ecx, -84(%rbp)                 ## 4-byte Spill
	movl	%r13d, -124(%rbp)               ## 4-byte Spill
	movq	_VECTOR_TYPE@GOTPCREL(%rip), %r13
	movl	(%r13), %eax
	cmpl	%eax, %r15d
	jne	LBB0_212
## %bb.111:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	movq	-112(%rbp), %r14                ## 8-byte Reload
	jne	LBB0_213
## %bb.112:
	movq	%r11, -192(%rbp)                ## 8-byte Spill
	movq	%r10, -184(%rbp)                ## 8-byte Spill
	movq	%r9, -72(%rbp)                  ## 8-byte Spill
	movq	%r8, -104(%rbp)                 ## 8-byte Spill
	movl	%r15d, -148(%rbp)               ## 4-byte Spill
	movq	%rdi, -56(%rbp)                 ## 8-byte Spill
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movq	%rbx, %rdi
	callq	_TYPE_SIZE
	movl	%eax, %r14d
	movq	-96(%rbp), %r15                 ## 8-byte Reload
	movq	%r15, %rdi
	callq	_TYPE_SIZE
	movl	%r14d, %edi
	movl	%eax, %esi
	callq	_tree_int_cst_equal
	testl	%eax, %eax
	je	LBB0_211
## %bb.113:
	movq	%rbx, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rbx
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rbx, %rdi
	movq	-80(%rbp), %rbx                 ## 8-byte Reload
	movq	%rax, %rsi
	callq	_same_scalar_type_ignoring_signedness
	testl	%eax, %eax
	je	LBB0_211
## %bb.114:
	movl	(%r13), %eax
	movq	-112(%rbp), %r14                ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movl	-148(%rbp), %r15d               ## 4-byte Reload
	movq	-104(%rbp), %r8                 ## 8-byte Reload
	movq	-72(%rbp), %r9                  ## 8-byte Reload
	movq	-184(%rbp), %r10                ## 8-byte Reload
	movq	-192(%rbp), %r11                ## 8-byte Reload
	jmp	LBB0_213
LBB0_211:
	movq	-64(%rbp), %rdi                 ## 8-byte Reload
                                        ## kill: def $edi killed $edi killed $rdi
	movq	%rbx, %rsi
	movq	%r15, %rdx
	callq	_binary_op_error
	jmp	LBB0_6
LBB0_212:
	movq	-112(%rbp), %r14                ## 8-byte Reload
LBB0_213:
	movq	_INTEGER_TYPE@GOTPCREL(%rip), %rcx
	movl	(%rcx), %edx
	movq	_REAL_TYPE@GOTPCREL(%rip), %rcx
	movl	(%rcx), %ecx
	movq	_COMPLEX_TYPE@GOTPCREL(%rip), %rsi
	movl	(%rsi), %ebx
	cmpl	%edx, %r15d
	je	LBB0_217
## %bb.214:
	cmpl	%ecx, %r15d
	je	LBB0_217
## %bb.215:
	cmpl	%ebx, %r15d
	je	LBB0_217
## %bb.216:
	cmpl	%eax, %r15d
	jne	LBB0_221
LBB0_217:
	movl	-44(%rbp), %esi                 ## 4-byte Reload
	cmpl	%edx, %esi
	je	LBB0_226
## %bb.218:
	cmpl	%ecx, %esi
	je	LBB0_226
## %bb.219:
	cmpl	%ebx, %esi
	je	LBB0_226
## %bb.220:
	cmpl	%eax, %esi
	je	LBB0_226
LBB0_221:
	xorl	%eax, %eax
	movq	%r12, %r13
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movl	-84(%rbp), %ecx                 ## 4-byte Reload
LBB0_222:
	testq	%r8, %r8
	je	LBB0_333
## %bb.223:
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	testl	%ecx, %ecx
	je	LBB0_254
LBB0_224:
	movq	_NULL_TREE@GOTPCREL(%rip), %rax
	cmpq	(%rax), %rdi
	cmovneq	%rdi, %r8
	movq	_require_constant_value@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	je	LBB0_256
## %bb.225:
	movl	-124(%rbp), %edi                ## 4-byte Reload
	movq	%r8, %rsi
	movq	%r13, %rdx
	movq	%r14, %rcx
	callq	_fold_build2_initializer
	jmp	LBB0_257
LBB0_226:
	movq	-200(%rbp), %rcx                ## 8-byte Reload
	testl	%ecx, %ecx
	setne	%al
	orb	%al, %r9b
	orb	%r10b, %r9b
	cmpb	$1, %r9b
	movq	%rdi, -56(%rbp)                 ## 8-byte Spill
	jne	LBB0_228
## %bb.227:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	-96(%rbp), %rsi                 ## 8-byte Reload
	movq	%r14, -112(%rbp)                ## 8-byte Spill
	movq	%r10, %r14
	movq	%r11, %r13
	callq	_c_common_type
	movq	-200(%rbp), %rcx                ## 8-byte Reload
	movq	%r13, %r11
	movq	%r14, %r10
	movq	-112(%rbp), %r14                ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movq	%rax, %r8
LBB0_228:
	xorl	%eax, %eax
	testl	%ecx, %ecx
	movq	%r10, -184(%rbp)                ## 8-byte Spill
	je	LBB0_264
## %bb.229:
	cmpl	%ebx, %r15d
	movl	-84(%rbp), %ecx                 ## 4-byte Reload
	je	LBB0_265
## %bb.230:
	cmpl	%ebx, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_265
## %bb.231:
	movq	%r11, -192(%rbp)                ## 8-byte Spill
	movq	%r8, %rdi
	movq	%r12, %rsi
	movq	%r8, %rbx
	callq	_convert
	movq	%rax, %r13
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_convert
	movq	%rax, %r14
	leaq	-120(%rbp), %rsi
	movq	%r13, %rdi
	callq	_get_narrower
	movq	%rax, %r12
	leaq	-144(%rbp), %rsi
	movq	%r14, %rdi
	callq	_get_narrower
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movq	%rbx, %r15
	movq	%rbx, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, -96(%rbp)                 ## 4-byte Spill
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jne	LBB0_234
## %bb.232:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	cmpq	%r15, %rax
	je	LBB0_234
## %bb.233:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, -120(%rbp)
LBB0_234:
	movq	%r13, -72(%rbp)                 ## 8-byte Spill
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jne	LBB0_237
## %bb.235:
	movq	%r14, %rdi
	callq	_TREE_TYPE
	cmpq	%r15, %rax
	je	LBB0_237
## %bb.236:
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, -144(%rbp)
LBB0_237:
	cmpl	$-1, -200(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_239
## %bb.238:
	movl	-120(%rbp), %eax
	movl	%eax, -96(%rbp)                 ## 4-byte Spill
LBB0_239:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jge	LBB0_244
## %bb.240:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jne	LBB0_244
## %bb.241:
	movl	-120(%rbp), %r13d
	cmpl	-144(%rbp), %r13d
	jne	LBB0_244
## %bb.242:
	testl	%r13d, %r13d
	jne	LBB0_282
## %bb.243:
	cmpl	$0, -96(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_282
LBB0_244:
	movq	%r12, %rdi
	callq	_TREE_CODE
	cltq
	movq	_INTEGER_CST@GOTPCREL(%rip), %rbx
	cmpq	%rax, (%rbx)
	jne	LBB0_249
## %bb.245:
	cmpl	$0, -144(%rbp)
	jne	LBB0_247
## %bb.246:
	cmpl	$0, -96(%rbp)                   ## 4-byte Folded Reload
	jne	LBB0_249
LBB0_247:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movq	%r14, %r13
	movl	%eax, %r14d
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %r14d
	movq	%r13, %r14
	jge	LBB0_249
## %bb.248:
	movl	-144(%rbp), %r14d
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movl	%r14d, %edi
	movq	%r13, %r14
	movq	%rax, %rsi
	callq	_c_common_signed_or_unsigned_type
	movq	%rax, %r13
	movq	%r12, %rdi
	movq	%rax, %rsi
	callq	_int_fits_type_p
	testq	%rax, %rax
	jne	LBB0_283
LBB0_249:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_CODE
	cltq
	movq	%r15, %r13
	cmpq	%rax, (%rbx)
	jne	LBB0_283
## %bb.250:
	cmpl	$0, -120(%rbp)
	jne	LBB0_252
## %bb.251:
	movq	%r15, %r13
	cmpl	$0, -96(%rbp)                   ## 4-byte Folded Reload
	jne	LBB0_283
LBB0_252:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	%r15, %r13
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jge	LBB0_283
## %bb.253:
	movl	-120(%rbp), %ebx
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movl	%ebx, %edi
	movq	%rax, %rsi
	callq	_c_common_signed_or_unsigned_type
	movq	%rax, %r13
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	movq	%rax, %rsi
	callq	_int_fits_type_p
	testq	%rax, %rax
	cmoveq	%r15, %r13
	jmp	LBB0_283
LBB0_254:
	movq	%rdi, %r15
	movq	%r13, %rdi
	movq	%r8, %r12
	callq	_TREE_TYPE
	movq	%r12, %rdi
	cmpq	%r12, %rax
	jne	LBB0_259
## %bb.255:
	movq	%rdi, %rbx
	jmp	LBB0_260
LBB0_256:
	movl	-124(%rbp), %edi                ## 4-byte Reload
	movq	%r8, %rsi
	movq	%r13, %rdx
	movq	%r14, %rcx
	callq	_fold_build2
LBB0_257:
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	testq	%rdi, %rdi
	je	LBB0_7
## %bb.258:
	movq	%rax, %rsi
	callq	_convert
	jmp	LBB0_7
LBB0_259:
	movq	%r13, %rsi
	movq	%rdi, %rbx
	callq	_convert_and_check
	movq	%rax, %r13
LBB0_260:
	movq	%r14, %rdi
	callq	_TREE_TYPE
	cmpq	%rbx, %rax
	je	LBB0_262
## %bb.261:
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_convert_and_check
	movq	%rax, %r14
LBB0_262:
	movq	%r13, %rdi
	callq	_TREE_CODE
	movq	_ERROR_MARK@GOTPCREL(%rip), %rbx
	cmpl	(%rbx), %eax
	je	LBB0_6
## %bb.263:
	movq	%r14, %rdi
	callq	_TREE_CODE
	movq	%r12, %r8
	movq	%r15, %rdi
	cmpl	(%rbx), %eax
	je	LBB0_6
	jmp	LBB0_224
LBB0_265:
	movq	%r12, %r13
	jmp	LBB0_285
LBB0_264:
	movq	%r12, %r13
	jmp	LBB0_284
LBB0_282:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rbx
	movq	-80(%rbp), %rdi                 ## 8-byte Reload
	callq	_TREE_TYPE
	movq	%rbx, %rdi
	movq	%rax, %rsi
	callq	_common_type
	movl	%r13d, %edi
	movq	%rax, %rsi
	callq	_c_common_signed_or_unsigned_type
	movq	%rax, %r13
LBB0_283:
	movq	%r15, %rax
	movq	%r13, %r8
	movq	-72(%rbp), %r13                 ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movq	-184(%rbp), %r10                ## 8-byte Reload
	movq	-192(%rbp), %r11                ## 8-byte Reload
LBB0_284:
	movl	-84(%rbp), %ecx                 ## 4-byte Reload
LBB0_285:
	testb	%r11b, %r11b
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	je	LBB0_294
## %bb.286:
	movq	%r8, -104(%rbp)                 ## 8-byte Spill
	leaq	-120(%rbp), %rsi
	movq	%r13, %rdi
	callq	_get_narrower
	movq	%rax, %r12
	cmpq	%r13, %rax
	jne	LBB0_289
## %bb.287:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	cmpq	%rax, -104(%rbp)                ## 8-byte Folded Reload
	jne	LBB0_289
## %bb.288:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, -120(%rbp)
LBB0_289:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	-104(%rbp), %r15                ## 8-byte Reload
	movq	%r15, %rdi
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jge	LBB0_292
## %bb.290:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movq	%r14, %rdi
	movl	%eax, %esi
	callq	_compare_tree_int
	testq	%rax, %rax
	js	LBB0_313
## %bb.291:
	movq	-104(%rbp), %r15                ## 8-byte Reload
LBB0_292:
	movq	%r15, %rbx
	movl	-84(%rbp), %ecx                 ## 4-byte Reload
	movq	-64(%rbp), %r12                 ## 8-byte Reload
LBB0_293:
	movq	%r15, %rax
	movq	%rbx, %r8
	movq	-136(%rbp), %r15                ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movq	-184(%rbp), %r10                ## 8-byte Reload
	jmp	LBB0_295
LBB0_294:
	movq	-136(%rbp), %r15                ## 8-byte Reload
LBB0_295:
	testb	%r10b, %r10b
	je	LBB0_222
## %bb.296:
	movq	%rax, -80(%rbp)                 ## 8-byte Spill
	movq	%r13, -120(%rbp)
	movq	%r14, -144(%rbp)
	movq	%r8, -208(%rbp)
	movl	-124(%rbp), %eax                ## 4-byte Reload
	movl	%eax, -172(%rbp)
	leaq	-120(%rbp), %rdi
	leaq	-144(%rbp), %rsi
	leaq	-208(%rbp), %rdx
	leaq	-172(%rbp), %rcx
	movq	%r8, %rbx
	callq	_shorten_compare
	testq	%rax, %rax
	jne	LBB0_7
## %bb.297:
	movq	%rbx, -104(%rbp)                ## 8-byte Spill
	movq	-120(%rbp), %r13
	movq	-144(%rbp), %r14
	movl	-172(%rbp), %eax
	movl	%eax, -124(%rbp)                ## 4-byte Spill
	movq	_warn_sign_compare@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	je	LBB0_332
## %bb.298:
	movq	_skip_evaluation@GOTPCREL(%rip), %rax
	cmpq	$0, (%rax)
	jne	LBB0_332
## %bb.299:
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, -44(%rbp)                 ## 4-byte Spill
	testl	%eax, %eax
	movq	%r13, %rbx
	sete	-136(%rbp)                      ## 1-byte Folded Spill
	movq	-168(%rbp), %r12                ## 8-byte Reload
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_UNSIGNED
	movl	%eax, %r13d
	leaq	-156(%rbp), %rsi
	movq	%rbx, -72(%rbp)                 ## 8-byte Spill
	movq	%rbx, %rdi
	callq	_get_narrower
	movq	%rax, %rbx
	leaq	-152(%rbp), %rsi
	movq	%r14, %rdi
	callq	_get_narrower
	movq	%rax, -96(%rbp)                 ## 8-byte Spill
	movq	%r15, -120(%rbp)
	movq	%r12, -144(%rbp)
	movq	%r15, %rdi
	callq	_STRIP_TYPE_NOPS
	movq	-144(%rbp), %rdi
	callq	_STRIP_TYPE_NOPS
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TYPE_UNSIGNED
	testl	%r13d, %r13d
	setne	%cl
	testl	%eax, %eax
	je	LBB0_310
## %bb.300:
	xorb	%cl, -136(%rbp)                 ## 1-byte Folded Spill
	jne	LBB0_310
## %bb.301:
	cmpl	$0, -44(%rbp)                   ## 4-byte Folded Reload
	movq	-144(%rbp), %rdi
	movq	-120(%rbp), %rax
	movq	%rax, %r15
	cmoveq	%rdi, %r15
	cmoveq	%rax, %rdi
	leaq	-212(%rbp), %rsi
	callq	_tree_expr_nonnegative_warnv_p
	testq	%rax, %rax
	jne	LBB0_310
## %bb.302:
	movq	%r15, %rdi
	callq	_TREE_CODE
	cltq
	movq	_INTEGER_CST@GOTPCREL(%rip), %r12
	cmpq	%rax, (%r12)
	jne	LBB0_306
## %bb.303:
	cmpl	$149, -124(%rbp)                ## 4-byte Folded Reload
	je	LBB0_305
## %bb.304:
	cmpl	$138, -124(%rbp)                ## 4-byte Folded Reload
	jne	LBB0_306
LBB0_305:
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_c_common_signed_type
	movq	%r15, %rdi
	movq	%rax, %rsi
	callq	_int_fits_type_p
	testq	%rax, %rax
	jne	LBB0_310
LBB0_306:
	movq	%r15, %rdi
	callq	_TREE_CODE
	cltq
	cmpq	%rax, (%r12)
	jne	LBB0_309
## %bb.307:
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TREE_CODE
	cltq
	movq	_ENUMERAL_TYPE@GOTPCREL(%rip), %rcx
	cmpq	%rax, (%rcx)
	jne	LBB0_309
## %bb.308:
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_MAX_VALUE
	movq	%rax, %r15
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_c_common_signed_type
	movq	%r15, %rdi
	movq	%rax, %rsi
	callq	_int_fits_type_p
	testq	%rax, %rax
	jne	LBB0_310
LBB0_309:
	leaq	L_.str.16(%rip), %rsi
	xorl	%edi, %edi
	xorl	%eax, %eax
	callq	_warning
LBB0_310:
	movq	%r14, -112(%rbp)                ## 8-byte Spill
	movq	%rbx, %r15
	movq	%rbx, %rdi
	callq	_TREE_CODE
	cltq
	movq	_BIT_NOT_EXPR@GOTPCREL(%rip), %r14
	cmpq	%rax, (%r14)
	setne	%bl
	movq	-96(%rbp), %r13                 ## 8-byte Reload
	movq	%r13, %rdi
	callq	_TREE_CODE
	cltq
	cmpq	%rax, (%r14)
	sete	%al
	xorb	%bl, %al
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	jne	LBB0_331
## %bb.311:
	movq	%r15, %rdi
	callq	_TREE_CODE
	cltq
	cmpq	%rax, (%r14)
	jne	LBB0_322
## %bb.312:
	movq	%r15, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	leaq	-156(%rbp), %rsi
	movq	%rax, %rdi
	callq	_get_narrower
	movq	%rax, %r15
	jmp	LBB0_323
LBB0_313:
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TYPE_UNSIGNED
	movl	-120(%rbp), %ebx
	testl	%eax, %eax
	je	LBB0_316
## %bb.314:
	testl	%ebx, %ebx
	jne	LBB0_316
## %bb.315:
	movq	-104(%rbp), %r15                ## 8-byte Reload
	movq	%r15, %rbx
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movl	-84(%rbp), %ecx                 ## 4-byte Reload
	jmp	LBB0_293
LBB0_316:
	movq	%r12, %rdi
	callq	_TREE_TYPE
	movl	%ebx, %edi
	movq	%rax, %rsi
	callq	_c_common_signed_or_unsigned_type
	movq	%rax, %rbx
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movl	$1, %ecx
	cmpq	%rbx, %rax
	je	LBB0_318
## %bb.317:
	movq	%rbx, %rdi
	movq	%r13, %rsi
	callq	_convert
	movl	$1, %ecx
	movq	%rax, %r13
LBB0_318:
	movq	-64(%rbp), %r12                 ## 8-byte Reload
	movq	-104(%rbp), %r15                ## 8-byte Reload
	jmp	LBB0_293
LBB0_322:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_TREE_OPERAND
	leaq	-152(%rbp), %rsi
	movq	%rax, %rdi
	callq	_get_narrower
	movq	%rax, %r13
LBB0_323:
	movq	%r15, %rdi
	xorl	%esi, %esi
	callq	_host_integerp
	testq	%rax, %rax
	jne	LBB0_325
## %bb.324:
	movq	%r13, %rdi
	xorl	%esi, %esi
	callq	_host_integerp
	testq	%rax, %rax
	je	LBB0_344
LBB0_325:
	movq	%r15, %rdi
	xorl	%esi, %esi
	callq	_host_integerp
	movq	%r15, %rcx
	movq	%rax, %r15
	testq	%rax, %rax
	movl	-156(%rbp), %r14d
	movl	-152(%rbp), %ebx
	movq	%rcx, %rdi
	cmoveq	%r13, %rdi
	cmoveq	%rcx, %r13
	xorl	%esi, %esi
	callq	_tree_low_cst
	movl	%eax, -96(%rbp)                 ## 4-byte Spill
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %r13d
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TYPE_PRECISION
	cmpl	%eax, %r13d
	jge	LBB0_331
## %bb.326:
	testq	%r15, %r15
	cmovel	%r14d, %ebx
	movq	_HOST_BITS_PER_WIDE_INT@GOTPCREL(%rip), %rax
	cmpl	(%rax), %r13d
	jge	LBB0_331
## %bb.327:
	testl	%ebx, %ebx
	je	LBB0_331
## %bb.328:
	movl	-96(%rbp), %eax                 ## 4-byte Reload
	notl	%eax
	movl	%r13d, %ecx
	shrl	%cl, %eax
	testl	%eax, %eax
	je	LBB0_331
## %bb.329:
	leaq	L_.str.17(%rip), %rsi
LBB0_330:
	xorl	%edi, %edi
	xorl	%eax, %eax
	callq	_warning
	jmp	LBB0_331
LBB0_334:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%ecx, %ecx
	movq	-96(%rbp), %r8                  ## 8-byte Reload
	movq	-64(%rbp), %rax                 ## 8-byte Reload
	movl	%eax, %r13d
	jmp	LBB0_321
LBB0_335:
	movq	%r13, %rdi
	callq	_VOID_TYPE_P
	testl	%eax, %eax
	je	LBB0_349
## %bb.336:
	movq	_pedantic@GOTPCREL(%rip), %rax
	cmpl	$0, (%rax)
	je	LBB0_205
## %bb.337:
	movq	-168(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	testl	%eax, %eax
	jne	LBB0_356
## %bb.338:
	movq	%rbx, %rdi
	callq	_TREE_CODE
	movq	_FUNCTION_TYPE@GOTPCREL(%rip), %rcx
	cmpl	(%rcx), %eax
	jne	LBB0_356
## %bb.339:
	leaq	L_.str.8(%rip), %rdi
	jmp	LBB0_355
LBB0_205:
	xorl	%r8d, %r8d
LBB0_206:
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
LBB0_147:
	movq	_NULL_TREE@GOTPCREL(%rip), %rax
	cmpq	(%rax), %r8
	jne	LBB0_149
## %bb.148:
	movq	_ptr_type_node@GOTPCREL(%rip), %rax
	movq	(%rax), %r8
LBB0_149:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	jmp	LBB0_90
LBB0_340:
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
LBB0_341:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	jne	LBB0_343
## %bb.342:
	movq	-136(%rbp), %rdi                ## 8-byte Reload
	callq	_null_pointer_constant_p
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	xorl	%r9d, %r9d
	testl	%eax, %eax
	movq	%r13, %r8
	cmoveq	%r9, %r8
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
	jmp	LBB0_105
LBB0_343:
	xorl	%r9d, %r9d
	xorl	%r11d, %r11d
	xorl	%r10d, %r10d
	xorl	%edx, %edx
	jmp	LBB0_104
LBB0_344:
	cmpl	$0, -156(%rbp)
	je	LBB0_331
## %bb.345:
	cmpl	$0, -152(%rbp)
	je	LBB0_331
## %bb.346:
	movq	%r15, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jge	LBB0_331
## %bb.347:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rdi
	callq	_TYPE_PRECISION
	movl	%eax, %ebx
	movq	-104(%rbp), %rdi                ## 8-byte Reload
	callq	_TYPE_PRECISION
	cmpl	%eax, %ebx
	jge	LBB0_331
## %bb.348:
	leaq	L_.str.18(%rip), %rsi
	jmp	LBB0_330
LBB0_331:
	movq	-112(%rbp), %r14                ## 8-byte Reload
	movq	-72(%rbp), %r13                 ## 8-byte Reload
LBB0_332:
	movq	-104(%rbp), %r8                 ## 8-byte Reload
	testq	%r8, %r8
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	jne	LBB0_224
LBB0_333:
	movq	%r13, %rdi
	callq	_TREE_TYPE
	movq	%rax, %rbx
	movq	%r14, %rdi
	callq	_TREE_TYPE
	movl	%r12d, %edi
	movq	%rbx, %rsi
	movq	%rax, %rdx
	callq	_binary_op_error
	jmp	LBB0_6
LBB0_349:
	cmpl	$0, -84(%rbp)                   ## 4-byte Folded Reload
	je	LBB0_351
## %bb.350:
	xorl	%r8d, %r8d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	jmp	LBB0_206
LBB0_351:
	movq	_BLOCK_POINTER_TYPE@GOTPCREL(%rip), %rax
	movl	(%rax), %eax
	cmpl	%eax, %r15d
	je	LBB0_354
## %bb.352:
	cmpl	%eax, -44(%rbp)                 ## 4-byte Folded Reload
	je	LBB0_354
## %bb.353:
	leaq	L_.str.10(%rip), %rdi
	jmp	LBB0_355
LBB0_354:
	leaq	L_.str.9(%rip), %rdi
LBB0_355:
	callq	_pedwarn
LBB0_356:
	xorl	%r8d, %r8d
	movq	-72(%rbp), %r12                 ## 8-byte Reload
	movq	-56(%rbp), %rdi                 ## 8-byte Reload
	movl	%r14d, %r15d
	jmp	LBB0_147
	.cfi_endproc
	.p2align	2, 0x90
	.data_region jt32
.set L0_0_set_10, LBB0_10-LJTI0_0
.set L0_0_set_53, LBB0_53-LJTI0_0
.set L0_0_set_16, LBB0_16-LJTI0_0
.set L0_0_set_116, LBB0_116-LJTI0_0
.set L0_0_set_123, LBB0_123-LJTI0_0
.set L0_0_set_61, LBB0_61-LJTI0_0
.set L0_0_set_108, LBB0_108-LJTI0_0
.set L0_0_set_126, LBB0_126-LJTI0_0
.set L0_0_set_30, LBB0_30-LJTI0_0
.set L0_0_set_130, LBB0_130-LJTI0_0
.set L0_0_set_44, LBB0_44-LJTI0_0
LJTI0_0:
	.long	L0_0_set_10
	.long	L0_0_set_10
	.long	L0_0_set_10
	.long	L0_0_set_10
	.long	L0_0_set_10
	.long	L0_0_set_53
	.long	L0_0_set_16
	.long	L0_0_set_116
	.long	L0_0_set_16
	.long	L0_0_set_123
	.long	L0_0_set_61
	.long	L0_0_set_108
	.long	L0_0_set_126
	.long	L0_0_set_30
	.long	L0_0_set_130
	.long	L0_0_set_30
	.long	L0_0_set_30
	.long	L0_0_set_30
	.long	L0_0_set_53
	.long	L0_0_set_16
	.long	L0_0_set_16
	.long	L0_0_set_61
	.long	L0_0_set_16
	.long	L0_0_set_44
	.long	L0_0_set_44
	.long	L0_0_set_44
	.end_data_region
                                        ## -- End function
	.comm	_ERROR_MARK,4,2                 ## @ERROR_MARK
	.comm	_error_mark_node,8,3            ## @error_mark_node
	.comm	_targetm,8,3                    ## @targetm
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.space	1

	.comm	_NULL_TREE,8,3                  ## @NULL_TREE
L_.str.1:                               ## @.str.1
	.asciz	"comparison"

	.comm	_POINTER_TYPE,4,2               ## @POINTER_TYPE
	.comm	_INTEGER_TYPE,4,2               ## @INTEGER_TYPE
	.comm	_skip_evaluation,8,3            ## @skip_evaluation
	.comm	_OPT_Wdiv_by_zero,4,2           ## @OPT_Wdiv_by_zero
L_.str.2:                               ## @.str.2
	.asciz	"division by zero"

	.comm	_REAL_TYPE,4,2                  ## @REAL_TYPE
	.comm	_COMPLEX_TYPE,4,2               ## @COMPLEX_TYPE
	.comm	_VECTOR_TYPE,4,2                ## @VECTOR_TYPE
	.comm	_RDIV_EXPR,4,2                  ## @RDIV_EXPR
	.comm	_INTEGER_CST,8,3                ## @INTEGER_CST
	.comm	_BLOCK_POINTER_TYPE,4,2         ## @BLOCK_POINTER_TYPE
	.comm	_integer_type_node,8,3          ## @integer_type_node
L_.str.3:                               ## @.str.3
	.asciz	"right shift count is negative"

L_.str.4:                               ## @.str.4
	.asciz	"right shift count >= width of type"

L_.str.5:                               ## @.str.5
	.asciz	"left shift count is negative"

L_.str.6:                               ## @.str.6
	.asciz	"left shift count >= width of type"

	.comm	_OPT_Wfloat_equal,4,2           ## @OPT_Wfloat_equal
L_.str.7:                               ## @.str.7
	.asciz	"comparing floating point with == or != is unsafe"

	.comm	_pedantic,4,2                   ## @pedantic
	.comm	_FUNCTION_TYPE,4,2              ## @FUNCTION_TYPE
L_.str.8:                               ## @.str.8
	.asciz	"ISO C forbids comparison of %<void *%> with function pointer"

L_.str.9:                               ## @.str.9
	.asciz	"comparison of distinct block types lacks a cast"

L_.str.10:                              ## @.str.10
	.asciz	"comparison of distinct pointer types lacks a cast"

	.comm	_ptr_type_node,8,3              ## @ptr_type_node
	.comm	_ADDR_EXPR,4,2                  ## @ADDR_EXPR
	.comm	_PARM_DECL,4,2                  ## @PARM_DECL
	.comm	_LABEL_DECL,4,2                 ## @LABEL_DECL
	.comm	_OPT_Waddress,4,2               ## @OPT_Waddress
L_.str.11:                              ## @.str.11
	.asciz	"the address of %qD will never be NULL"

L_.str.12:                              ## @.str.12
	.asciz	"comparison between pointer and integer"

L_.str.13:                              ## @.str.13
	.asciz	"comparison of complete and incomplete pointers"

L_.str.14:                              ## @.str.14
	.asciz	"ISO C forbids ordered comparisons of pointers to functions"

	.comm	_extra_warnings,4,2             ## @extra_warnings
L_.str.15:                              ## @.str.15
	.asciz	"ordered comparison of pointer with integer zero"

	.comm	_warn_sign_compare,8,3          ## @warn_sign_compare
	.comm	_ENUMERAL_TYPE,8,3              ## @ENUMERAL_TYPE
L_.str.16:                              ## @.str.16
	.asciz	"comparison between signed and unsigned"

	.comm	_BIT_NOT_EXPR,8,3               ## @BIT_NOT_EXPR
	.comm	_HOST_BITS_PER_WIDE_INT,4,2     ## @HOST_BITS_PER_WIDE_INT
L_.str.17:                              ## @.str.17
	.asciz	"comparison of promoted ~unsigned with constant"

L_.str.18:                              ## @.str.18
	.asciz	"comparison of promoted ~unsigned with unsigned"

	.comm	_require_constant_value,8,3     ## @require_constant_value
.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_build_binary_op                ; -- Begin function build_binary_op
	.p2align	2
_build_binary_op:                       ; @build_binary_op
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #208
	.cfi_def_cfa_offset 208
	stp	x28, x27, [sp, #112]            ; 16-byte Folded Spill
	stp	x26, x25, [sp, #128]            ; 16-byte Folded Spill
	stp	x24, x23, [sp, #144]            ; 16-byte Folded Spill
	stp	x22, x21, [sp, #160]            ; 16-byte Folded Spill
	stp	x20, x19, [sp, #176]            ; 16-byte Folded Spill
	stp	x29, x30, [sp, #192]            ; 16-byte Folded Spill
	add	x29, sp, #192
	.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	x23, x2
	mov	x22, x1
	mov	x21, x0
	mov	x19, x2
	mov	x20, x1
	cbz	w3, LBB0_2
; %bb.1:
	mov	x0, x22
	bl	_default_conversion
	mov	x20, x0
	mov	x0, x23
	bl	_default_conversion
	mov	x19, x0
LBB0_2:
	mov	x0, x20
	bl	_TREE_TYPE
	mov	x24, x0
	mov	x0, x19
	bl	_TREE_TYPE
	mov	x27, x0
	mov	x0, x24
	bl	_TREE_CODE
	mov	x25, x0
	mov	x0, x27
	bl	_TREE_CODE
	mov	x26, x0
	mov	x0, x20
	bl	_STRIP_TYPE_NOPS
	mov	x0, x19
	bl	_STRIP_TYPE_NOPS
Lloh0:
	adrp	x8, _ERROR_MARK@GOTPAGE
Lloh1:
	ldr	x8, [x8, _ERROR_MARK@GOTPAGEOFF]
Lloh2:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #4, ne
	b.eq	LBB0_309
; %bb.3:
Lloh3:
	adrp	x8, _targetm@GOTPAGE
Lloh4:
	ldr	x8, [x8, _targetm@GOTPAGEOFF]
Lloh5:
	ldr	x8, [x8]
	mov	x0, x21
	mov	x1, x24
	mov	x2, x27
	blr	x8
	cbz	x0, LBB0_5
; %bb.4:
Lloh6:
	adrp	x1, l_.str@PAGE
Lloh7:
	add	x1, x1, l_.str@PAGEOFF
	bl	_error
	b	LBB0_309
LBB0_5:
Lloh8:
	adrp	x8, _NULL_TREE@GOTPAGE
Lloh9:
	ldr	x8, [x8, _NULL_TREE@GOTPAGEOFF]
Lloh10:
	ldr	x3, [x8]
Lloh11:
	adrp	x4, l_.str.1@PAGE
Lloh12:
	add	x4, x4, l_.str.1@PAGEOFF
	mov	x0, x24
	mov	x1, x27
	mov	w2, #-3
	bl	_objc_compare_types
	sub	w8, w21, #128
	cmp	w8, #25
	b.hi	LBB0_73
; %bb.6:
	mov	x28, x0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
	mov	w17, #1
Lloh13:
	adrp	x9, lJTI0_0@PAGE
Lloh14:
	add	x9, x9, lJTI0_0@PAGEOFF
	adr	x10, LBB0_7
	ldrh	w11, [x9, x8, lsl #1]
	add	x10, x10, x11, lsl #2
	mov	x13, x21
	br	x10
LBB0_7:
Lloh15:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh16:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh17:
	ldr	w12, [x8]
Lloh18:
	adrp	x8, _POINTER_TYPE@GOTPAGE
Lloh19:
	ldr	x8, [x8, _POINTER_TYPE@GOTPAGEOFF]
Lloh20:
	ldr	w11, [x8]
Lloh21:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh22:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh23:
	ldr	w10, [x8]
Lloh24:
	adrp	x8, _REAL_TYPE@GOTPAGE
Lloh25:
	ldr	x8, [x8, _REAL_TYPE@GOTPAGEOFF]
Lloh26:
	ldr	w9, [x8]
Lloh27:
	adrp	x8, _COMPLEX_TYPE@GOTPAGE
Lloh28:
	ldr	x8, [x8, _COMPLEX_TYPE@GOTPAGEOFF]
Lloh29:
	ldr	w8, [x8]
	cmp	w25, w12
	ccmp	w25, w11, #4, ne
	ccmp	w25, w10, #4, ne
	ccmp	w25, w9, #4, ne
	ccmp	w25, w8, #4, ne
	b.ne	LBB0_74
; %bb.8:
	cmp	w26, w12
	b.eq	LBB0_13
; %bb.9:
	cmp	w26, w11
	b.eq	LBB0_13
; %bb.10:
	cmp	w26, w10
	b.eq	LBB0_13
; %bb.11:
	cmp	w26, w9
	b.eq	LBB0_13
; %bb.12:
	cmp	w26, w8
	b.ne	LBB0_74
LBB0_13:
Lloh30:
	adrp	x8, _integer_type_node@GOTPAGE
Lloh31:
	ldr	x8, [x8, _integer_type_node@GOTPAGEOFF]
Lloh32:
	ldr	x28, [x8]
	mov	x0, x20
	bl	_c_common_truthvalue_conversion
	mov	x20, x0
	mov	x0, x19
	bl	_c_common_truthvalue_conversion
	mov	x19, x0
	mov	x0, x28
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #1
	b	LBB0_76
LBB0_14:
Lloh33:
	adrp	x8, _skip_evaluation@GOTPAGE
Lloh34:
	ldr	x8, [x8, _skip_evaluation@GOTPAGEOFF]
Lloh35:
	ldr	x8, [x8]
	cbnz	x8, LBB0_17
; %bb.15:
	mov	x0, x19
	bl	_integer_zerop
	cbz	w0, LBB0_17
; %bb.16:
Lloh36:
	adrp	x8, _OPT_Wdiv_by_zero@GOTPAGE
Lloh37:
	ldr	x8, [x8, _OPT_Wdiv_by_zero@GOTPAGEOFF]
Lloh38:
	ldr	w0, [x8]
Lloh39:
	adrp	x1, l_.str.2@PAGE
Lloh40:
	add	x1, x1, l_.str.2@PAGEOFF
	bl	_warning
LBB0_17:
Lloh41:
	adrp	x12, _INTEGER_TYPE@GOTPAGE
Lloh42:
	ldr	x12, [x12, _INTEGER_TYPE@GOTPAGEOFF]
	ldr	w11, [x12]
Lloh43:
	adrp	x8, _REAL_TYPE@GOTPAGE
Lloh44:
	ldr	x8, [x8, _REAL_TYPE@GOTPAGEOFF]
Lloh45:
	adrp	x28, _COMPLEX_TYPE@GOTPAGE
Lloh46:
	ldr	x28, [x28, _COMPLEX_TYPE@GOTPAGEOFF]
Lloh47:
	ldr	w10, [x8]
	ldr	w9, [x28]
Lloh48:
	adrp	x8, _VECTOR_TYPE@GOTPAGE
Lloh49:
	ldr	x8, [x8, _VECTOR_TYPE@GOTPAGEOFF]
Lloh50:
	ldr	w8, [x8]
	cmp	w25, w11
	b.eq	LBB0_21
; %bb.18:
	cmp	w25, w10
	b.eq	LBB0_21
; %bb.19:
	cmp	w25, w9
	b.eq	LBB0_21
; %bb.20:
	cmp	w25, w8
	b.ne	LBB0_74
LBB0_21:
	cmp	w26, w11
	b.eq	LBB0_25
; %bb.22:
	cmp	w26, w10
	b.eq	LBB0_25
; %bb.23:
	cmp	w26, w9
	b.eq	LBB0_25
; %bb.24:
	cmp	w26, w8
	b.ne	LBB0_74
LBB0_25:
	cmp	w25, w9
	b.eq	LBB0_146
; %bb.26:
	cmp	w25, w8
	b.eq	LBB0_146
; %bb.27:
	mov	x10, x25
	b	LBB0_147
LBB0_28:
Lloh51:
	adrp	x8, _integer_type_node@GOTPAGE
Lloh52:
	ldr	x8, [x8, _integer_type_node@GOTPAGEOFF]
Lloh53:
	ldr	x12, [x8]
Lloh54:
	adrp	x28, _INTEGER_TYPE@GOTPAGE
Lloh55:
	ldr	x28, [x28, _INTEGER_TYPE@GOTPAGEOFF]
	ldr	w9, [x28]
Lloh56:
	adrp	x8, _REAL_TYPE@GOTPAGE
Lloh57:
	ldr	x8, [x8, _REAL_TYPE@GOTPAGEOFF]
Lloh58:
	ldr	w8, [x8]
	cmp	w25, w9
	ccmp	w25, w8, #4, ne
	b.ne	LBB0_31
; %bb.29:
	mov	x0, #0
	mov	w17, #0
	mov	w14, #1
	cmp	w26, w9
	b.eq	LBB0_72
; %bb.30:
	cmp	w26, w8
	b.eq	LBB0_72
LBB0_31:
	str	w21, [sp, #68]                  ; 4-byte Folded Spill
Lloh59:
	adrp	x21, _POINTER_TYPE@GOTPAGE
Lloh60:
	ldr	x21, [x21, _POINTER_TYPE@GOTPAGEOFF]
	ldr	w8, [x21]
	cmp	w25, w8
	b.ne	LBB0_67
; %bb.32:
	cmp	w26, w8
	b.ne	LBB0_67
; %bb.33:
	mov	x28, x12
	mov	x0, x24
	mov	x1, x27
	bl	_comp_target_types
	cbz	w0, LBB0_157
; %bb.34:
	mov	x0, x24
	mov	x1, x27
	bl	_common_pointer_type
	str	x0, [sp, #40]                   ; 8-byte Folded Spill
	mov	x0, x24
	bl	_TREE_TYPE
	bl	_COMPLETE_TYPE_P
	cmp	w0, #0
	cset	w21, ne
	mov	x0, x27
	bl	_TREE_TYPE
	bl	_COMPLETE_TYPE_P
	cmp	w0, #0
	cset	w8, eq
	eor	w8, w21, w8
	tbz	w8, #0, LBB0_169
; %bb.35:
Lloh61:
	adrp	x8, _pedantic@GOTPAGE
Lloh62:
	ldr	x8, [x8, _pedantic@GOTPAGEOFF]
Lloh63:
	ldr	w8, [x8]
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	cbz	w8, LBB0_38
; %bb.36:
	mov	x0, x24
	bl	_TREE_TYPE
	bl	_TREE_CODE
Lloh64:
	adrp	x8, _FUNCTION_TYPE@GOTPAGE
Lloh65:
	ldr	x8, [x8, _FUNCTION_TYPE@GOTPAGEOFF]
Lloh66:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_38
; %bb.37:
Lloh67:
	adrp	x0, l_.str.14@PAGE
Lloh68:
	add	x0, x0, l_.str.14@PAGEOFF
	bl	_pedwarn
LBB0_38:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	b	LBB0_170
LBB0_39:
Lloh69:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh70:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh71:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #0, eq
	b.eq	LBB0_71
; %bb.40:
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
Lloh72:
	adrp	x8, _VECTOR_TYPE@GOTPAGE
Lloh73:
	ldr	x8, [x8, _VECTOR_TYPE@GOTPAGEOFF]
Lloh74:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #0, eq
	cset	w17, eq
	b	LBB0_76
LBB0_41:
Lloh75:
	adrp	x8, _skip_evaluation@GOTPAGE
Lloh76:
	ldr	x8, [x8, _skip_evaluation@GOTPAGEOFF]
Lloh77:
	ldr	x8, [x8]
	cbnz	x8, LBB0_44
; %bb.42:
	mov	x0, x19
	bl	_integer_zerop
	cbz	w0, LBB0_44
; %bb.43:
Lloh78:
	adrp	x8, _OPT_Wdiv_by_zero@GOTPAGE
Lloh79:
	ldr	x8, [x8, _OPT_Wdiv_by_zero@GOTPAGEOFF]
Lloh80:
	ldr	w0, [x8]
Lloh81:
	adrp	x1, l_.str.2@PAGE
Lloh82:
	add	x1, x1, l_.str.2@PAGEOFF
	bl	_warning
LBB0_44:
	mov	x12, #0
	mov	w17, #0
Lloh83:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh84:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh85:
	ldr	w8, [x8]
	cmp	w25, w8
	b.ne	LBB0_46
; %bb.45:
	cmp	w26, w8
	b.eq	LBB0_152
LBB0_46:
	mov	x15, x17
	mov	x14, x17
	mov	x1, x17
	mov	x16, x17
	mov	x0, x12
	b	LBB0_76
LBB0_47:
	str	w21, [sp, #68]                  ; 4-byte Folded Spill
Lloh86:
	adrp	x21, _REAL_TYPE@GOTPAGE
Lloh87:
	ldr	x21, [x21, _REAL_TYPE@GOTPAGEOFF]
	ldr	w8, [x21]
	cmp	w25, w8
	ccmp	w26, w8, #4, ne
	b.ne	LBB0_49
; %bb.48:
Lloh88:
	adrp	x8, _OPT_Wfloat_equal@GOTPAGE
Lloh89:
	ldr	x8, [x8, _OPT_Wfloat_equal@GOTPAGEOFF]
Lloh90:
	ldr	w0, [x8]
Lloh91:
	adrp	x1, l_.str.7@PAGE
Lloh92:
	add	x1, x1, l_.str.7@PAGEOFF
	bl	_warning
	ldr	w8, [x21]
LBB0_49:
Lloh93:
	adrp	x9, _integer_type_node@GOTPAGE
Lloh94:
	ldr	x9, [x9, _integer_type_node@GOTPAGEOFF]
Lloh95:
	adrp	x11, _INTEGER_TYPE@GOTPAGE
Lloh96:
	ldr	x11, [x11, _INTEGER_TYPE@GOTPAGEOFF]
Lloh97:
	ldr	x12, [x9]
	ldr	w10, [x11]
Lloh98:
	adrp	x9, _COMPLEX_TYPE@GOTPAGE
Lloh99:
	ldr	x9, [x9, _COMPLEX_TYPE@GOTPAGEOFF]
Lloh100:
	ldr	w9, [x9]
	cmp	w25, w10
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b.eq	LBB0_52
; %bb.50:
	cmp	w25, w8
	b.eq	LBB0_52
; %bb.51:
	cmp	w25, w9
	b.ne	LBB0_55
LBB0_52:
	mov	x0, #0
	mov	w17, #0
	mov	w14, #1
	cmp	w26, w10
	b.eq	LBB0_72
; %bb.53:
	cmp	w26, w8
	b.eq	LBB0_72
; %bb.54:
	cmp	w26, w9
	b.eq	LBB0_72
LBB0_55:
Lloh101:
	adrp	x10, _POINTER_TYPE@GOTPAGE
Lloh102:
	ldr	x10, [x10, _POINTER_TYPE@GOTPAGEOFF]
	ldr	w8, [x10]
Lloh103:
	adrp	x9, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh104:
	ldr	x9, [x9, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh105:
	ldr	w9, [x9]
	cmp	w25, w8
	str	x12, [sp, #32]                  ; 8-byte Folded Spill
	b.eq	LBB0_57
; %bb.56:
	cmp	w25, w9
	b.ne	LBB0_59
LBB0_57:
	cmp	w26, w8
	b.eq	LBB0_171
; %bb.58:
	cmp	w26, w9
	b.eq	LBB0_171
LBB0_59:
	cmp	w25, w8
	b.ne	LBB0_182
; %bb.60:
	mov	x28, x10
	mov	x0, x23
	bl	_null_pointer_constant_p
	cbz	w0, LBB0_181
; %bb.61:
	mov	x0, x20
	bl	_TREE_CODE
Lloh106:
	adrp	x8, _ADDR_EXPR@GOTPAGE
Lloh107:
	ldr	x8, [x8, _ADDR_EXPR@GOTPAGEOFF]
Lloh108:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_233
; %bb.62:
	mov	x0, x20
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_DECL_P
	cbz	w0, LBB0_233
; %bb.63:
	mov	x0, x20
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh109:
	adrp	x8, _PARM_DECL@GOTPAGE
Lloh110:
	ldr	x8, [x8, _PARM_DECL@GOTPAGEOFF]
Lloh111:
	ldr	w8, [x8]
	cmp	w0, w8
	b.eq	LBB0_66
; %bb.64:
	mov	x0, x20
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh112:
	adrp	x8, _LABEL_DECL@GOTPAGE
Lloh113:
	ldr	x8, [x8, _LABEL_DECL@GOTPAGEOFF]
Lloh114:
	ldr	w8, [x8]
	cmp	w0, w8
	b.eq	LBB0_66
; %bb.65:
	mov	x0, x20
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_DECL_WEAK
	cbnz	w0, LBB0_233
LBB0_66:
Lloh115:
	adrp	x8, _OPT_Waddress@GOTPAGE
Lloh116:
	ldr	x8, [x8, _OPT_Waddress@GOTPAGEOFF]
Lloh117:
	ldr	w28, [x8]
	mov	x0, x20
	mov	w1, #0
	bl	_TREE_OPERAND
	str	x0, [sp]
Lloh118:
	adrp	x1, l_.str.11@PAGE
Lloh119:
	add	x1, x1, l_.str.11@PAGEOFF
	mov	x0, x28
	bl	_warning
	b	LBB0_233
LBB0_67:
	cmp	w25, w8
	str	x12, [sp, #32]                  ; 8-byte Folded Spill
	b.ne	LBB0_176
; %bb.68:
	mov	x0, x23
	bl	_null_pointer_constant_p
	cbz	w0, LBB0_175
; %bb.69:
Lloh120:
	adrp	x8, _pedantic@GOTPAGE
Lloh121:
	ldr	x8, [x8, _pedantic@GOTPAGEOFF]
Lloh122:
	ldr	w8, [x8]
Lloh123:
	adrp	x9, _extra_warnings@GOTPAGE
Lloh124:
	ldr	x9, [x9, _extra_warnings@GOTPAGEOFF]
Lloh125:
	ldr	w9, [x9]
	orr	w8, w8, w9
	cbz	w8, LBB0_195
; %bb.70:
Lloh126:
	adrp	x0, l_.str.15@PAGE
Lloh127:
	add	x0, x0, l_.str.15@PAGEOFF
	b	LBB0_194
LBB0_71:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
	mov	w1, #-1
	b	LBB0_76
LBB0_72:
	mov	x15, x17
	mov	x1, x17
	mov	x16, x17
	b	LBB0_76
LBB0_73:
	bl	_gcc_unreachable
LBB0_74:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
LBB0_75:
	mov	w16, #0
	mov	x0, #0
LBB0_76:
	mov	x13, x21
LBB0_77:
Lloh128:
	adrp	x8, _ERROR_MARK@GOTPAGE
Lloh129:
	ldr	x8, [x8, _ERROR_MARK@GOTPAGEOFF]
Lloh130:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #4, ne
	b.eq	LBB0_309
; %bb.78:
	str	w21, [sp, #68]                  ; 4-byte Folded Spill
Lloh131:
	adrp	x21, _VECTOR_TYPE@GOTPAGE
Lloh132:
	ldr	x21, [x21, _VECTOR_TYPE@GOTPAGEOFF]
	ldr	w8, [x21]
	cmp	w25, w8
	b.ne	LBB0_83
; %bb.79:
	cmp	w26, w8
	b.ne	LBB0_83
; %bb.80:
	stp	w1, w16, [sp, #16]              ; 8-byte Folded Spill
	stp	w17, w15, [sp, #8]              ; 8-byte Folded Spill
	str	w14, [sp, #48]                  ; 4-byte Folded Spill
	str	w13, [sp, #56]                  ; 4-byte Folded Spill
	str	x0, [sp, #40]                   ; 8-byte Folded Spill
	str	x22, [sp, #24]                  ; 8-byte Folded Spill
	mov	x22, x23
	mov	x23, x12
	mov	x0, x24
	bl	_TYPE_SIZE
	mov	x28, x0
	mov	x0, x27
	bl	_TYPE_SIZE
	mov	x1, x0
	mov	x0, x28
	bl	_tree_int_cst_equal
	cbz	w0, LBB0_98
; %bb.81:
	mov	x0, x24
	bl	_TREE_TYPE
	mov	x28, x0
	mov	x0, x27
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x28
	bl	_same_scalar_type_ignoring_signedness
	cbz	w0, LBB0_98
; %bb.82:
	ldr	w8, [x21]
	mov	x12, x23
	mov	x23, x22
	ldr	x22, [sp, #24]                  ; 8-byte Folded Reload
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	ldr	w13, [sp, #56]                  ; 4-byte Folded Reload
	ldr	w14, [sp, #48]                  ; 4-byte Folded Reload
	ldp	w17, w15, [sp, #8]              ; 8-byte Folded Reload
	ldp	w1, w16, [sp, #16]              ; 8-byte Folded Reload
LBB0_83:
Lloh133:
	adrp	x9, _INTEGER_TYPE@GOTPAGE
Lloh134:
	ldr	x9, [x9, _INTEGER_TYPE@GOTPAGEOFF]
Lloh135:
	adrp	x11, _REAL_TYPE@GOTPAGE
Lloh136:
	ldr	x11, [x11, _REAL_TYPE@GOTPAGEOFF]
Lloh137:
	ldr	w10, [x9]
Lloh138:
	ldr	w9, [x11]
Lloh139:
	adrp	x11, _COMPLEX_TYPE@GOTPAGE
Lloh140:
	ldr	x11, [x11, _COMPLEX_TYPE@GOTPAGEOFF]
Lloh141:
	ldr	w28, [x11]
	cmp	w25, w10
	b.eq	LBB0_88
; %bb.84:
	cmp	w25, w9
	b.eq	LBB0_88
; %bb.85:
	cmp	w25, w28
	b.eq	LBB0_88
; %bb.86:
	cmp	w25, w8
	b.eq	LBB0_88
; %bb.87:
	mov	x24, #0
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b	LBB0_93
LBB0_88:
	cmp	w26, w10
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b.eq	LBB0_99
; %bb.89:
	cmp	w26, w9
	b.eq	LBB0_99
; %bb.90:
	cmp	w26, w28
	b.eq	LBB0_99
; %bb.91:
	cmp	w26, w8
	b.eq	LBB0_99
; %bb.92:
	mov	x24, #0
LBB0_93:
Lloh142:
	adrp	x26, _ERROR_MARK@GOTPAGE
Lloh143:
	ldr	x26, [x26, _ERROR_MARK@GOTPAGEOFF]
LBB0_94:
	cbz	x0, LBB0_307
; %bb.95:
	cbz	w16, LBB0_125
LBB0_96:
Lloh144:
	adrp	x8, _NULL_TREE@GOTPAGE
Lloh145:
	ldr	x8, [x8, _NULL_TREE@GOTPAGEOFF]
Lloh146:
	ldr	x8, [x8]
	cmp	x12, x8
	csel	x1, x0, x12, eq
Lloh147:
	adrp	x8, _require_constant_value@GOTPAGE
Lloh148:
	ldr	x8, [x8, _require_constant_value@GOTPAGEOFF]
Lloh149:
	ldr	x8, [x8]
	cbz	x8, LBB0_131
; %bb.97:
	mov	x0, x13
	mov	x2, x20
	mov	x3, x19
	bl	_fold_build2_initializer
	b	LBB0_132
LBB0_98:
	ldr	w0, [sp, #68]                   ; 4-byte Folded Reload
	mov	x1, x24
	mov	x2, x27
	b	LBB0_308
LBB0_99:
	cmp	w1, #0
	cset	w8, ne
	orr	w8, w17, w8
	orr	w8, w14, w8
	cmp	w8, #1
	b.ne	LBB0_101
; %bb.100:
	mov	x0, x24
	str	w1, [sp, #16]                   ; 4-byte Folded Spill
	mov	x1, x27
	str	x22, [sp, #24]                  ; 8-byte Folded Spill
	str	x23, [sp, #40]                  ; 8-byte Folded Spill
	mov	x23, x12
	mov	x27, x13
	mov	x21, x14
	mov	x24, x15
	mov	x22, x16
	bl	_c_common_type
	ldr	w1, [sp, #16]                   ; 4-byte Folded Reload
	mov	x16, x22
	mov	x15, x24
	mov	x14, x21
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	mov	x13, x27
	mov	x12, x23
	ldr	x23, [sp, #40]                  ; 8-byte Folded Reload
	ldr	x22, [sp, #24]                  ; 8-byte Folded Reload
LBB0_101:
	mov	x24, #0
	str	x12, [sp, #32]                  ; 8-byte Folded Spill
	str	w13, [sp, #56]                  ; 4-byte Folded Spill
	str	w14, [sp, #48]                  ; 4-byte Folded Spill
	cbz	w1, LBB0_134
; %bb.102:
	cmp	w25, w28
	b.eq	LBB0_134
; %bb.103:
	cmp	w26, w28
	b.eq	LBB0_134
; %bb.104:
	mov	x28, x1
	str	w16, [sp, #20]                  ; 4-byte Folded Spill
	mov	x21, x15
	mov	x26, x0
	mov	x1, x20
	bl	_convert
	mov	x20, x0
	mov	x0, x26
	mov	x1, x19
	bl	_convert
	mov	x19, x0
	sub	x1, x29, #88
	mov	x0, x20
	bl	_get_narrower
	mov	x25, x0
	add	x1, sp, #96
	mov	x0, x19
	bl	_get_narrower
	str	x0, [sp, #40]                   ; 8-byte Folded Spill
	mov	x24, x26
	mov	x0, x26
	bl	_TYPE_UNSIGNED
	mov	x26, x0
	mov	x0, x20
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x27, x0
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	cmp	w27, w0
	b.ne	LBB0_107
; %bb.105:
	mov	x0, x20
	bl	_TREE_TYPE
	cmp	x0, x24
	b.eq	LBB0_107
; %bb.106:
	mov	x0, x20
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	stur	w0, [x29, #-88]
LBB0_107:
	mov	x0, x19
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x27, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	cmp	w27, w0
	b.ne	LBB0_110
; %bb.108:
	mov	x0, x19
	bl	_TREE_TYPE
	cmp	x0, x24
	b.eq	LBB0_110
; %bb.109:
	mov	x0, x19
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	str	w0, [sp, #96]
LBB0_110:
	ldur	w8, [x29, #-88]
	cmn	w28, #1
	csel	w27, w8, w26, eq
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x26, x0
	mov	x0, x24
	bl	_TYPE_PRECISION
	cmp	w26, w0
	b.ge	LBB0_115
; %bb.111:
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x26, x0
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	cmp	w26, w0
	b.ne	LBB0_115
; %bb.112:
	ldur	w26, [x29, #-88]
	ldr	w8, [sp, #96]
	cmp	w26, w8
	b.ne	LBB0_115
; %bb.113:
	cbnz	w26, LBB0_245
; %bb.114:
	cbz	w27, LBB0_245
LBB0_115:
	mov	x0, x25
	bl	_TREE_CODE
Lloh150:
	adrp	x28, _INTEGER_CST@GOTPAGE
Lloh151:
	ldr	x28, [x28, _INTEGER_CST@GOTPAGEOFF]
	ldr	x8, [x28]
	cmp	x8, w0, sxtw
	b.ne	LBB0_120
; %bb.116:
	ldr	w8, [sp, #96]
	cbnz	w8, LBB0_118
; %bb.117:
	cbnz	w27, LBB0_120
LBB0_118:
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x26, x0
	mov	x0, x24
	bl	_TYPE_PRECISION
	cmp	w26, w0
	b.ge	LBB0_120
; %bb.119:
	ldr	w26, [sp, #96]
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x26
	bl	_c_common_signed_or_unsigned_type
	mov	x26, x0
	mov	x0, x25
	mov	x1, x26
	bl	_int_fits_type_p
	cbnz	x0, LBB0_246
LBB0_120:
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_CODE
	ldr	x8, [x28]
	cmp	x8, w0, sxtw
	mov	x26, x24
	b.ne	LBB0_246
; %bb.121:
	ldur	w8, [x29, #-88]
	cbnz	w8, LBB0_123
; %bb.122:
	mov	x26, x24
	cbnz	w27, LBB0_246
LBB0_123:
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x27, x0
	mov	x26, x24
	mov	x0, x24
	bl	_TYPE_PRECISION
	cmp	w27, w0
	b.ge	LBB0_246
; %bb.124:
	ldur	w26, [x29, #-88]
	mov	x0, x25
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x26
	bl	_c_common_signed_or_unsigned_type
	mov	x25, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	mov	x1, x25
	bl	_int_fits_type_p
	cmp	x0, #0
	csel	x26, x24, x25, eq
	b	LBB0_246
LBB0_125:
	mov	x25, x13
	mov	x21, x12
	mov	x23, x0
	mov	x0, x20
	bl	_TREE_TYPE
	cmp	x0, x23
	mov	x22, x23
	b.eq	LBB0_127
; %bb.126:
	mov	x0, x22
	mov	x1, x20
	bl	_convert_and_check
	mov	x20, x0
LBB0_127:
	mov	x0, x19
	bl	_TREE_TYPE
	cmp	x0, x22
	b.eq	LBB0_129
; %bb.128:
	mov	x0, x22
	mov	x1, x19
	bl	_convert_and_check
	mov	x19, x0
LBB0_129:
	mov	x0, x20
	bl	_TREE_CODE
	ldr	w8, [x26]
	cmp	w0, w8
	b.eq	LBB0_309
; %bb.130:
	mov	x0, x19
	bl	_TREE_CODE
	mov	x13, x25
	mov	x12, x21
	ldr	w8, [x26]
	cmp	w0, w8
	mov	x0, x23
	b.eq	LBB0_309
	b	LBB0_96
LBB0_131:
	mov	x0, x13
	mov	x2, x20
	mov	x3, x19
	bl	_fold_build2
LBB0_132:
	mov	x1, x0
	cbz	x24, LBB0_310
; %bb.133:
	mov	x0, x24
	bl	_convert
	b	LBB0_261
LBB0_134:
Lloh152:
	adrp	x26, _ERROR_MARK@GOTPAGE
Lloh153:
	ldr	x26, [x26, _ERROR_MARK@GOTPAGEOFF]
	b	LBB0_247
LBB0_135:
Lloh154:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh155:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh156:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #0, eq
	b.eq	LBB0_158
; %bb.136:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
	mov	w13, #135
	b	LBB0_77
LBB0_137:
Lloh157:
	adrp	x8, _POINTER_TYPE@GOTPAGE
Lloh158:
	ldr	x8, [x8, _POINTER_TYPE@GOTPAGEOFF]
Lloh159:
	ldr	w9, [x8]
Lloh160:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh161:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh162:
	ldr	w8, [x8]
	cmp	w25, w9
	ccmp	w26, w8, #0, eq
	b.eq	LBB0_163
; %bb.138:
	mov	x12, #0
	mov	w15, #0
	mov	w13, #137
	mov	w17, #1
	cmp	w26, w9
	b.ne	LBB0_210
; %bb.139:
	cmp	w25, w8
	b.ne	LBB0_210
; %bb.140:
	mov	w0, #137
	mov	x1, x19
	mov	x2, x20
	b	LBB0_206
LBB0_141:
	mov	x28, x21
Lloh163:
	adrp	x21, _POINTER_TYPE@GOTPAGE
Lloh164:
	ldr	x21, [x21, _POINTER_TYPE@GOTPAGEOFF]
	ldr	w8, [x21]
	cmp	w25, w8
	ccmp	w26, w8, #0, eq
	b.ne	LBB0_202
; %bb.142:
	mov	x0, x24
	mov	x1, x27
	bl	_comp_target_types
	cbz	w0, LBB0_201
; %bb.143:
	mov	x0, x20
	mov	x1, x19
	ldp	x29, x30, [sp, #192]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #176]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #160]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #144]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #128]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #112]            ; 16-byte Folded Reload
	add	sp, sp, #208
	b	_pointer_diff
LBB0_144:
Lloh165:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh166:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh167:
	ldr	w8, [x8]
	cmp	w25, w8
	ccmp	w26, w8, #0, eq
	b.eq	LBB0_164
; %bb.145:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
	mov	w13, #142
	b	LBB0_77
LBB0_146:
	mov	x0, x20
	bl	_TREE_TYPE
	bl	_TREE_TYPE
	bl	_TREE_CODE
Lloh168:
	adrp	x12, _INTEGER_TYPE@GOTPAGE
Lloh169:
	ldr	x12, [x12, _INTEGER_TYPE@GOTPAGEOFF]
	mov	x10, x0
	ldr	w9, [x28]
Lloh170:
	adrp	x8, _VECTOR_TYPE@GOTPAGE
Lloh171:
	ldr	x8, [x8, _VECTOR_TYPE@GOTPAGEOFF]
Lloh172:
	ldr	w8, [x8]
LBB0_147:
	cmp	w26, w9
	b.eq	LBB0_149
; %bb.148:
	mov	x0, x26
	cmp	w26, w8
	b.ne	LBB0_150
LBB0_149:
	mov	x0, x19
	mov	x28, x10
	bl	_TREE_TYPE
	bl	_TREE_TYPE
	bl	_TREE_CODE
	mov	x10, x28
Lloh173:
	adrp	x12, _INTEGER_TYPE@GOTPAGE
Lloh174:
	ldr	x12, [x12, _INTEGER_TYPE@GOTPAGEOFF]
LBB0_150:
	ldr	w8, [x12]
	cmp	w10, w8
	b.ne	LBB0_154
; %bb.151:
	cmp	w0, w8
	b.ne	LBB0_154
LBB0_152:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	cbz	w0, LBB0_155
; %bb.153:
	mov	w1, #1
	b	LBB0_174
LBB0_154:
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
Lloh175:
	adrp	x8, _RDIV_EXPR@GOTPAGE
Lloh176:
	ldr	x8, [x8, _RDIV_EXPR@GOTPAGEOFF]
Lloh177:
	ldr	w13, [x8]
	mov	w17, #1
	b	LBB0_77
LBB0_155:
	mov	x0, x19
	bl	_TREE_CODE
Lloh178:
	adrp	x8, _INTEGER_CST@GOTPAGE
Lloh179:
	ldr	x8, [x8, _INTEGER_CST@GOTPAGEOFF]
Lloh180:
	ldr	x8, [x8]
	cmp	x8, w0, sxtw
	b.ne	LBB0_173
; %bb.156:
	mov	x0, x19
	bl	_integer_all_onesp
	cmp	w0, #0
	cset	w1, eq
	b	LBB0_174
LBB0_157:
Lloh181:
	adrp	x8, _ptr_type_node@GOTPAGE
Lloh182:
	ldr	x8, [x8, _ptr_type_node@GOTPAGEOFF]
Lloh183:
	ldr	x21, [x8]
Lloh184:
	adrp	x0, l_.str.10@PAGE
Lloh185:
	add	x0, x0, l_.str.10@PAGEOFF
	bl	_pedwarn
	mov	x0, x21
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	mov	x13, x21
	mov	x12, x28
	b	LBB0_77
LBB0_158:
	mov	x0, x19
	bl	_TREE_CODE
	mov	w28, #0
Lloh186:
	adrp	x8, _INTEGER_CST@GOTPAGE
Lloh187:
	ldr	x8, [x8, _INTEGER_CST@GOTPAGEOFF]
Lloh188:
	ldr	x8, [x8]
	cmp	x8, w0, sxtw
	b.ne	LBB0_237
; %bb.159:
Lloh189:
	adrp	x8, _skip_evaluation@GOTPAGE
Lloh190:
	ldr	x8, [x8, _skip_evaluation@GOTPAGEOFF]
Lloh191:
	ldr	x8, [x8]
	cbnz	x8, LBB0_237
; %bb.160:
	mov	x0, x19
	bl	_tree_int_cst_sgn
	tbnz	w0, #31, LBB0_235
; %bb.161:
	mov	x0, x19
	bl	_integer_zerop
	cmp	w0, #0
	cset	w28, eq
	mov	x0, x24
	bl	_TYPE_PRECISION
	mov	x1, x0
	mov	x0, x19
	bl	_compare_tree_int
	tbnz	x0, #63, LBB0_237
; %bb.162:
Lloh192:
	adrp	x1, l_.str.4@PAGE
Lloh193:
	add	x1, x1, l_.str.4@PAGEOFF
	b	LBB0_236
LBB0_163:
	mov	w0, #137
	b	LBB0_205
LBB0_164:
	mov	x0, x19
	bl	_TREE_CODE
Lloh194:
	adrp	x8, _INTEGER_CST@GOTPAGE
Lloh195:
	ldr	x8, [x8, _INTEGER_CST@GOTPAGEOFF]
Lloh196:
	ldr	x8, [x8]
	cmp	x8, w0, sxtw
	b.ne	LBB0_242
; %bb.165:
Lloh197:
	adrp	x8, _skip_evaluation@GOTPAGE
Lloh198:
	ldr	x8, [x8, _skip_evaluation@GOTPAGEOFF]
Lloh199:
	ldr	x8, [x8]
	cbnz	x8, LBB0_242
; %bb.166:
	mov	x0, x19
	bl	_tree_int_cst_sgn
	tbnz	w0, #31, LBB0_240
; %bb.167:
	mov	x0, x24
	bl	_TYPE_PRECISION
	mov	x1, x0
	mov	x0, x19
	bl	_compare_tree_int
	tbnz	x0, #63, LBB0_242
; %bb.168:
Lloh200:
	adrp	x1, l_.str.6@PAGE
Lloh201:
	add	x1, x1, l_.str.6@PAGEOFF
	b	LBB0_241
LBB0_169:
Lloh202:
	adrp	x0, l_.str.13@PAGE
Lloh203:
	add	x0, x0, l_.str.13@PAGEOFF
	bl	_pedwarn
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
LBB0_170:
	mov	x13, x21
	mov	x12, x28
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	b	LBB0_77
LBB0_171:
	mov	x0, x24
	bl	_TREE_TYPE
	str	x0, [sp, #56]                   ; 8-byte Folded Spill
	mov	x0, x27
	bl	_TREE_TYPE
	str	x0, [sp, #48]                   ; 8-byte Folded Spill
	mov	x0, x24
	mov	x1, x27
	bl	_comp_target_types
	cbz	w0, LBB0_218
; %bb.172:
	mov	x0, x24
	mov	x1, x27
	bl	_common_pointer_type
	b	LBB0_229
LBB0_173:
	mov	w1, #0
LBB0_174:
	mov	w15, #0
	mov	w14, #0
	mov	x12, #0
	mov	w16, #0
	mov	x0, #0
	mov	w17, #1
	b	LBB0_76
LBB0_175:
	ldr	w8, [x21]
LBB0_176:
	cmp	w26, w8
	b.ne	LBB0_191
; %bb.177:
	mov	x0, x22
	bl	_null_pointer_constant_p
	cbz	w0, LBB0_190
; %bb.178:
Lloh204:
	adrp	x8, _pedantic@GOTPAGE
Lloh205:
	ldr	x8, [x8, _pedantic@GOTPAGEOFF]
Lloh206:
	ldr	w8, [x8]
	cbz	w8, LBB0_180
; %bb.179:
Lloh207:
	adrp	x0, l_.str.15@PAGE
Lloh208:
	add	x0, x0, l_.str.15@PAGEOFF
	bl	_pedwarn
LBB0_180:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x27
	b	LBB0_196
LBB0_181:
	mov	x10, x28
	ldr	w8, [x28]
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
Lloh209:
	adrp	x11, _INTEGER_TYPE@GOTPAGE
Lloh210:
	ldr	x11, [x11, _INTEGER_TYPE@GOTPAGEOFF]
LBB0_182:
	cmp	w26, w8
	b.ne	LBB0_212
; %bb.183:
	mov	x28, x10
	mov	x0, x22
	bl	_null_pointer_constant_p
	cbz	w0, LBB0_211
; %bb.184:
	mov	x0, x19
	bl	_TREE_CODE
Lloh211:
	adrp	x8, _ADDR_EXPR@GOTPAGE
Lloh212:
	ldr	x8, [x8, _ADDR_EXPR@GOTPAGEOFF]
Lloh213:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_200
; %bb.185:
	mov	x0, x19
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_DECL_P
	cbz	w0, LBB0_200
; %bb.186:
	mov	x0, x19
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh214:
	adrp	x8, _PARM_DECL@GOTPAGE
Lloh215:
	ldr	x8, [x8, _PARM_DECL@GOTPAGEOFF]
Lloh216:
	ldr	w8, [x8]
	cmp	w0, w8
	b.eq	LBB0_189
; %bb.187:
	mov	x0, x19
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_TREE_CODE
Lloh217:
	adrp	x8, _LABEL_DECL@GOTPAGE
Lloh218:
	ldr	x8, [x8, _LABEL_DECL@GOTPAGEOFF]
Lloh219:
	ldr	w8, [x8]
	cmp	w0, w8
	b.eq	LBB0_189
; %bb.188:
	mov	x0, x19
	mov	w1, #0
	bl	_TREE_OPERAND
	bl	_DECL_WEAK
	cbnz	w0, LBB0_200
LBB0_189:
Lloh220:
	adrp	x8, _OPT_Waddress@GOTPAGE
Lloh221:
	ldr	x8, [x8, _OPT_Waddress@GOTPAGEOFF]
Lloh222:
	ldr	w28, [x8]
	mov	x0, x19
	mov	w1, #0
	bl	_TREE_OPERAND
	str	x0, [sp]
Lloh223:
	adrp	x1, l_.str.11@PAGE
Lloh224:
	add	x1, x1, l_.str.11@PAGEOFF
	mov	x0, x28
	bl	_warning
	b	LBB0_200
LBB0_190:
	ldr	w8, [x21]
LBB0_191:
	ldr	w9, [x28]
	cmp	w25, w8
	b.ne	LBB0_197
; %bb.192:
	cmp	w26, w9
	b.ne	LBB0_197
; %bb.193:
Lloh225:
	adrp	x0, l_.str.12@PAGE
Lloh226:
	add	x0, x0, l_.str.12@PAGEOFF
LBB0_194:
	bl	_pedwarn
LBB0_195:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x24
LBB0_196:
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b	LBB0_234
LBB0_197:
	mov	x0, #0
	mov	w17, #0
	cmp	w25, w9
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b.ne	LBB0_207
; %bb.198:
	cmp	w26, w8
	b.ne	LBB0_207
; %bb.199:
Lloh227:
	adrp	x0, l_.str.12@PAGE
Lloh228:
	add	x0, x0, l_.str.12@PAGEOFF
	bl	_pedwarn
LBB0_200:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x27
	b	LBB0_234
LBB0_201:
	ldr	w8, [x21]
LBB0_202:
	mov	x12, #0
	mov	w15, #0
	mov	w13, #140
	mov	w17, #1
	cmp	w25, w8
	b.ne	LBB0_208
; %bb.203:
Lloh229:
	adrp	x8, _INTEGER_TYPE@GOTPAGE
Lloh230:
	ldr	x8, [x8, _INTEGER_TYPE@GOTPAGEOFF]
Lloh231:
	ldr	w8, [x8]
	cmp	w26, w8
	b.ne	LBB0_209
; %bb.204:
	mov	w0, #140
LBB0_205:
	mov	x1, x20
	mov	x2, x19
LBB0_206:
	ldp	x29, x30, [sp, #192]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #176]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #160]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #144]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #128]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #112]            ; 16-byte Folded Reload
	add	sp, sp, #208
	b	_pointer_int_sum
LBB0_207:
	mov	x15, x17
	mov	x14, x17
	mov	x1, x17
	mov	x16, x17
	b	LBB0_234
LBB0_208:
	mov	x14, x15
	mov	x1, x15
	mov	x16, x15
	mov	x0, x12
	mov	x21, x28
	b	LBB0_77
LBB0_209:
	mov	x21, x28
LBB0_210:
	mov	x14, x15
	mov	x1, x15
	mov	x16, x15
	mov	x0, x12
	b	LBB0_77
LBB0_211:
	ldr	w8, [x28]
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
Lloh232:
	adrp	x11, _INTEGER_TYPE@GOTPAGE
Lloh233:
	ldr	x11, [x11, _INTEGER_TYPE@GOTPAGEOFF]
LBB0_212:
	ldr	w9, [x11]
	cmp	w25, w8
	b.ne	LBB0_215
; %bb.213:
	cmp	w26, w9
	b.ne	LBB0_215
; %bb.214:
Lloh234:
	adrp	x0, l_.str.12@PAGE
Lloh235:
	add	x0, x0, l_.str.12@PAGEOFF
	bl	_pedwarn
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x24
	b	LBB0_76
LBB0_215:
	cmp	w25, w9
	b.ne	LBB0_231
; %bb.216:
	cmp	w26, w8
	b.ne	LBB0_231
; %bb.217:
Lloh236:
	adrp	x0, l_.str.12@PAGE
Lloh237:
	add	x0, x0, l_.str.12@PAGEOFF
	bl	_pedwarn
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x27
	b	LBB0_76
LBB0_218:
Lloh238:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh239:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh240:
	ldr	w8, [x8]
	cmp	w26, w8
	b.ne	LBB0_221
; %bb.219:
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	bl	_VOID_TYPE_P
	cbnz	w0, LBB0_228
; %bb.220:
Lloh241:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh242:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh243:
	ldr	w8, [x8]
LBB0_221:
	cmp	w25, w8
	b.ne	LBB0_223
; %bb.222:
	ldr	x0, [sp, #48]                   ; 8-byte Folded Reload
	bl	_VOID_TYPE_P
	cbnz	w0, LBB0_228
LBB0_223:
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	bl	_VOID_TYPE_P
	cbz	w0, LBB0_290
; %bb.224:
Lloh244:
	adrp	x8, _pedantic@GOTPAGE
Lloh245:
	ldr	x8, [x8, _pedantic@GOTPAGEOFF]
Lloh246:
	ldr	w8, [x8]
	cbz	w8, LBB0_228
; %bb.225:
	mov	x0, x22
	bl	_null_pointer_constant_p
	cbnz	w0, LBB0_228
; %bb.226:
	ldr	x0, [sp, #48]                   ; 8-byte Folded Reload
	bl	_TREE_CODE
Lloh247:
	adrp	x8, _FUNCTION_TYPE@GOTPAGE
Lloh248:
	ldr	x8, [x8, _FUNCTION_TYPE@GOTPAGEOFF]
Lloh249:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_228
; %bb.227:
Lloh250:
	adrp	x0, l_.str.8@PAGE
Lloh251:
	add	x0, x0, l_.str.8@PAGEOFF
	bl	_pedwarn
LBB0_228:
	mov	x0, #0
LBB0_229:
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
LBB0_230:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
Lloh252:
	adrp	x8, _NULL_TREE@GOTPAGE
Lloh253:
	ldr	x8, [x8, _NULL_TREE@GOTPAGEOFF]
Lloh254:
	ldr	x8, [x8]
Lloh255:
	adrp	x9, _ptr_type_node@GOTPAGE
Lloh256:
	ldr	x9, [x9, _ptr_type_node@GOTPAGEOFF]
Lloh257:
	ldr	x9, [x9]
	cmp	x0, x8
	csel	x0, x9, x0, eq
	b	LBB0_76
LBB0_231:
Lloh258:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh259:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh260:
	ldr	w8, [x8]
	cmp	w25, w8
	b.ne	LBB0_297
; %bb.232:
	mov	x0, x23
	bl	_null_pointer_constant_p
	cbz	w0, LBB0_296
LBB0_233:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	mov	x0, x24
LBB0_234:
	mov	x13, x21
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	b	LBB0_77
LBB0_235:
	mov	w28, #0
Lloh261:
	adrp	x1, l_.str.3@PAGE
Lloh262:
	add	x1, x1, l_.str.3@PAGEOFF
LBB0_236:
	mov	w0, #0
	bl	_warning
LBB0_237:
	mov	x0, x19
	bl	_TREE_TYPE
	bl	_TYPE_MAIN_VARIANT
	mov	x8, x0
Lloh263:
	adrp	x9, _integer_type_node@GOTPAGE
Lloh264:
	ldr	x9, [x9, _integer_type_node@GOTPAGEOFF]
Lloh265:
	ldr	x0, [x9]
	cmp	x8, x0
	b.eq	LBB0_239
; %bb.238:
	mov	x1, x19
	bl	_convert
	mov	x19, x0
LBB0_239:
	mov	w17, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w13, #135
	mov	w16, #1
	mov	x0, x24
	mov	x15, x28
	b	LBB0_77
LBB0_240:
Lloh266:
	adrp	x1, l_.str.5@PAGE
Lloh267:
	add	x1, x1, l_.str.5@PAGEOFF
LBB0_241:
	mov	w0, #0
	bl	_warning
LBB0_242:
	mov	x0, x19
	bl	_TREE_TYPE
	bl	_TYPE_MAIN_VARIANT
	mov	x8, x0
Lloh268:
	adrp	x9, _integer_type_node@GOTPAGE
Lloh269:
	ldr	x9, [x9, _integer_type_node@GOTPAGEOFF]
Lloh270:
	ldr	x0, [x9]
	cmp	x8, x0
	b.eq	LBB0_244
; %bb.243:
	mov	x1, x19
	bl	_convert
	mov	x19, x0
LBB0_244:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	x12, #0
	mov	w13, #142
	mov	w16, #1
	mov	x0, x24
	b	LBB0_77
LBB0_245:
	mov	x0, x25
	bl	_TREE_TYPE
	mov	x25, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x25
	bl	_common_type
	mov	x1, x0
	mov	x0, x26
	bl	_c_common_signed_or_unsigned_type
	mov	x26, x0
LBB0_246:
	mov	x0, x26
Lloh271:
	adrp	x26, _ERROR_MARK@GOTPAGE
Lloh272:
	ldr	x26, [x26, _ERROR_MARK@GOTPAGEOFF]
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	ldr	w13, [sp, #56]                  ; 4-byte Folded Reload
	ldr	w14, [sp, #48]                  ; 4-byte Folded Reload
	mov	x15, x21
	ldr	w16, [sp, #20]                  ; 4-byte Folded Reload
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
LBB0_247:
	cbz	w15, LBB0_259
; %bb.248:
	mov	x21, x16
	mov	x27, x0
	sub	x1, x29, #88
	mov	x0, x20
	bl	_get_narrower
	mov	x24, x0
	cmp	x0, x20
	b.ne	LBB0_251
; %bb.249:
	mov	x0, x20
	bl	_TREE_TYPE
	cmp	x27, x0
	b.ne	LBB0_251
; %bb.250:
	mov	x0, x20
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	stur	w0, [x29, #-88]
LBB0_251:
	mov	x0, x24
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x25, x0
	mov	x28, x27
	mov	x0, x27
	bl	_TYPE_PRECISION
	cmp	w25, w0
	b.ge	LBB0_256
; %bb.252:
	mov	x0, x24
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x1, x0
	mov	x0, x19
	bl	_compare_tree_int
	tbz	x0, #63, LBB0_255
; %bb.253:
	mov	x0, x27
	bl	_TYPE_UNSIGNED
	ldur	w25, [x29, #-88]
	cbz	w0, LBB0_278
; %bb.254:
	cbnz	w25, LBB0_278
LBB0_255:
	mov	x24, x27
	mov	x25, x27
	b	LBB0_257
LBB0_256:
	mov	x25, x28
	mov	x24, x28
LBB0_257:
	mov	x16, x21
LBB0_258:
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	mov	x0, x25
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	ldr	w13, [sp, #56]                  ; 4-byte Folded Reload
	ldr	w14, [sp, #48]                  ; 4-byte Folded Reload
LBB0_259:
	cbz	w14, LBB0_94
; %bb.260:
	stur	x20, [x29, #-88]
	stp	x0, x19, [sp, #88]
	str	w13, [sp, #84]
	mov	x19, x0
	sub	x0, x29, #88
	add	x1, sp, #96
	add	x2, sp, #88
	add	x3, sp, #84
	bl	_shorten_compare
	cbz	x0, LBB0_262
LBB0_261:
	mov	x1, x0
	b	LBB0_310
LBB0_262:
	str	x19, [sp, #40]                  ; 8-byte Folded Spill
	ldur	x20, [x29, #-88]
	ldr	x19, [sp, #96]
	ldr	w13, [sp, #84]
Lloh273:
	adrp	x8, _warn_sign_compare@GOTPAGE
Lloh274:
	ldr	x8, [x8, _warn_sign_compare@GOTPAGEOFF]
Lloh275:
	ldr	x8, [x8]
	cbz	x8, LBB0_306
; %bb.263:
Lloh276:
	adrp	x8, _skip_evaluation@GOTPAGE
Lloh277:
	ldr	x8, [x8, _skip_evaluation@GOTPAGEOFF]
Lloh278:
	ldr	x8, [x8]
	cbnz	x8, LBB0_306
; %bb.264:
	str	w13, [sp, #56]                  ; 4-byte Folded Spill
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	mov	x27, x0
	cmp	w0, #0
	cset	w21, eq
	mov	x0, x23
	bl	_TREE_TYPE
	bl	_TYPE_UNSIGNED
	mov	x28, x0
	add	x1, sp, #80
	mov	x0, x20
	bl	_get_narrower
	mov	x26, x0
	add	x1, sp, #76
	mov	x0, x19
	bl	_get_narrower
	mov	x25, x0
	stur	x22, [x29, #-88]
	str	x23, [sp, #96]
	mov	x0, x22
	bl	_STRIP_TYPE_NOPS
	ldr	x0, [sp, #96]
	bl	_STRIP_TYPE_NOPS
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TYPE_UNSIGNED
	cmp	w28, #0
	cset	w8, ne
	cbz	w0, LBB0_275
; %bb.265:
	eor	w8, w21, w8
	tbnz	w8, #0, LBB0_275
; %bb.266:
	ldr	x8, [sp, #96]
	ldur	x9, [x29, #-88]
	cmp	w27, #0
	csel	x22, x8, x9, eq
	csel	x0, x9, x8, eq
	add	x1, sp, #72
	bl	_tree_expr_nonnegative_warnv_p
	cbnz	x0, LBB0_275
; %bb.267:
	mov	x0, x22
	bl	_TREE_CODE
Lloh279:
	adrp	x21, _INTEGER_CST@GOTPAGE
Lloh280:
	ldr	x21, [x21, _INTEGER_CST@GOTPAGEOFF]
	ldr	x8, [x21]
	cmp	x8, w0, sxtw
	b.ne	LBB0_271
; %bb.268:
	ldr	w8, [sp, #56]                   ; 4-byte Folded Reload
	cmp	w8, #149
	b.eq	LBB0_270
; %bb.269:
	ldr	w8, [sp, #56]                   ; 4-byte Folded Reload
	cmp	w8, #138
	b.ne	LBB0_271
LBB0_270:
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_c_common_signed_type
	mov	x1, x0
	mov	x0, x22
	bl	_int_fits_type_p
	cbnz	x0, LBB0_275
LBB0_271:
	mov	x0, x22
	bl	_TREE_CODE
	ldr	x8, [x21]
	cmp	x8, w0, sxtw
	b.ne	LBB0_274
; %bb.272:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TREE_CODE
Lloh281:
	adrp	x8, _ENUMERAL_TYPE@GOTPAGE
Lloh282:
	ldr	x8, [x8, _ENUMERAL_TYPE@GOTPAGEOFF]
Lloh283:
	ldr	x8, [x8]
	cmp	x8, w0, sxtw
	b.ne	LBB0_274
; %bb.273:
	mov	x0, x22
	bl	_TREE_TYPE
	bl	_TYPE_MAX_VALUE
	mov	x22, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_c_common_signed_type
	mov	x1, x0
	mov	x0, x22
	bl	_int_fits_type_p
	cbnz	x0, LBB0_275
LBB0_274:
Lloh284:
	adrp	x1, l_.str.16@PAGE
Lloh285:
	add	x1, x1, l_.str.16@PAGEOFF
	mov	w0, #0
	bl	_warning
LBB0_275:
	mov	x0, x26
	bl	_TREE_CODE
Lloh286:
	adrp	x21, _BIT_NOT_EXPR@GOTPAGE
Lloh287:
	ldr	x21, [x21, _BIT_NOT_EXPR@GOTPAGEOFF]
	ldr	x8, [x21]
	cmp	x8, w0, sxtw
	cset	w22, ne
	mov	x0, x25
	bl	_TREE_CODE
	ldr	x8, [x21]
	cmp	x8, w0, sxtw
	cset	w8, eq
	eor	w8, w22, w8
	tbnz	w8, #0, LBB0_305
; %bb.276:
	mov	x0, x26
	bl	_TREE_CODE
	ldr	x8, [x21]
	cmp	x8, w0, sxtw
	b.ne	LBB0_281
; %bb.277:
	mov	x0, x26
	mov	w1, #0
	bl	_TREE_OPERAND
	add	x1, sp, #80
	bl	_get_narrower
	mov	x26, x0
	b	LBB0_282
LBB0_278:
	mov	x0, x24
	bl	_TREE_TYPE
	mov	x1, x0
	mov	x0, x25
	bl	_c_common_signed_or_unsigned_type
	mov	x25, x0
	mov	x0, x20
	bl	_TREE_TYPE
	cmp	x0, x25
	b.eq	LBB0_280
; %bb.279:
	mov	x0, x25
	mov	x1, x20
	bl	_convert
	mov	x20, x0
LBB0_280:
	mov	w16, #1
	mov	x24, x27
	b	LBB0_258
LBB0_281:
	mov	x0, x25
	mov	w1, #0
	bl	_TREE_OPERAND
	add	x1, sp, #76
	bl	_get_narrower
	mov	x25, x0
LBB0_282:
	mov	x0, x26
	mov	w1, #0
	bl	_host_integerp
	cbnz	x0, LBB0_284
; %bb.283:
	mov	x0, x25
	mov	w1, #0
	bl	_host_integerp
	cbz	x0, LBB0_300
LBB0_284:
	mov	x0, x26
	mov	w1, #0
	bl	_host_integerp
	mov	x22, x0
	ldp	w27, w21, [sp, #76]
	cmp	x0, #0
	csel	x0, x25, x26, eq
	csel	x25, x26, x25, eq
	mov	w1, #0
	bl	_tree_low_cst
	mov	x23, x0
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x25, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TYPE_PRECISION
	cmp	w25, w0
	b.ge	LBB0_305
; %bb.285:
	cmp	x22, #0
	csel	w8, w21, w27, eq
Lloh288:
	adrp	x9, _HOST_BITS_PER_WIDE_INT@GOTPAGE
Lloh289:
	ldr	x9, [x9, _HOST_BITS_PER_WIDE_INT@GOTPAGEOFF]
Lloh290:
	ldr	w9, [x9]
	cmp	w25, w9
	b.ge	LBB0_305
; %bb.286:
	cbz	w8, LBB0_305
; %bb.287:
	mvn	w8, w23
	lsr	w8, w8, w25
	cbz	w8, LBB0_305
; %bb.288:
Lloh291:
	adrp	x1, l_.str.17@PAGE
Lloh292:
	add	x1, x1, l_.str.17@PAGEOFF
LBB0_289:
	mov	w0, #0
	bl	_warning
	b	LBB0_305
LBB0_290:
	ldr	x0, [sp, #48]                   ; 8-byte Folded Reload
	bl	_VOID_TYPE_P
	cbz	w0, LBB0_311
; %bb.291:
	mov	x28, x22
Lloh293:
	adrp	x8, _pedantic@GOTPAGE
Lloh294:
	ldr	x8, [x8, _pedantic@GOTPAGEOFF]
Lloh295:
	ldr	w8, [x8]
	cbz	w8, LBB0_315
; %bb.292:
	mov	x22, x23
	mov	x0, x23
	bl	_null_pointer_constant_p
	cbnz	w0, LBB0_295
; %bb.293:
	ldr	x0, [sp, #56]                   ; 8-byte Folded Reload
	bl	_TREE_CODE
Lloh296:
	adrp	x8, _FUNCTION_TYPE@GOTPAGE
Lloh297:
	ldr	x8, [x8, _FUNCTION_TYPE@GOTPAGEOFF]
Lloh298:
	ldr	w8, [x8]
	cmp	w0, w8
	b.ne	LBB0_295
; %bb.294:
Lloh299:
	adrp	x0, l_.str.8@PAGE
Lloh300:
	add	x0, x0, l_.str.8@PAGEOFF
	bl	_pedwarn
LBB0_295:
	mov	x0, #0
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	mov	x23, x22
	b	LBB0_316
LBB0_296:
Lloh301:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh302:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh303:
	ldr	w8, [x8]
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
LBB0_297:
	cmp	w26, w8
	b.ne	LBB0_299
; %bb.298:
	mov	x0, x22
	bl	_null_pointer_constant_p
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	mov	w16, #0
	cmp	w0, #0
	csel	x0, xzr, x27, eq
	b	LBB0_76
LBB0_299:
	mov	w17, #0
	mov	w15, #0
	mov	w14, #0
	mov	w1, #0
	b	LBB0_75
LBB0_300:
	ldr	w8, [sp, #80]
	cbz	w8, LBB0_305
; %bb.301:
	ldr	w8, [sp, #76]
	cbz	w8, LBB0_305
; %bb.302:
	mov	x0, x26
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x22, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TYPE_PRECISION
	cmp	w22, w0
	b.ge	LBB0_305
; %bb.303:
	mov	x0, x25
	bl	_TREE_TYPE
	bl	_TYPE_PRECISION
	mov	x22, x0
	ldr	x0, [sp, #40]                   ; 8-byte Folded Reload
	bl	_TYPE_PRECISION
	cmp	w22, w0
	b.ge	LBB0_305
; %bb.304:
Lloh304:
	adrp	x1, l_.str.18@PAGE
Lloh305:
	add	x1, x1, l_.str.18@PAGEOFF
	b	LBB0_289
LBB0_305:
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	ldr	w13, [sp, #56]                  ; 4-byte Folded Reload
LBB0_306:
	ldp	x12, x0, [sp, #32]              ; 16-byte Folded Reload
	cbnz	x0, LBB0_96
LBB0_307:
	mov	x0, x20
	bl	_TREE_TYPE
	mov	x20, x0
	mov	x0, x19
	bl	_TREE_TYPE
	mov	x2, x0
	mov	x0, x21
	mov	x1, x20
LBB0_308:
	bl	_binary_op_error
LBB0_309:
Lloh306:
	adrp	x8, _error_mark_node@GOTPAGE
Lloh307:
	ldr	x8, [x8, _error_mark_node@GOTPAGEOFF]
Lloh308:
	ldr	x1, [x8]
LBB0_310:
	mov	x0, x1
	ldp	x29, x30, [sp, #192]            ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #176]            ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #160]            ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #144]            ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #128]            ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #112]            ; 16-byte Folded Reload
	add	sp, sp, #208
	ret
LBB0_311:
	cbnz	w28, LBB0_319
; %bb.312:
Lloh309:
	adrp	x8, _BLOCK_POINTER_TYPE@GOTPAGE
Lloh310:
	ldr	x8, [x8, _BLOCK_POINTER_TYPE@GOTPAGEOFF]
Lloh311:
	ldr	w8, [x8]
	cmp	w25, w8
	b.eq	LBB0_317
; %bb.313:
	cmp	w26, w8
	b.eq	LBB0_317
; %bb.314:
Lloh312:
	adrp	x0, l_.str.10@PAGE
Lloh313:
	add	x0, x0, l_.str.10@PAGEOFF
	b	LBB0_318
LBB0_315:
	mov	x0, #0
	ldr	x12, [sp, #32]                  ; 8-byte Folded Reload
LBB0_316:
	mov	x22, x28
	b	LBB0_230
LBB0_317:
Lloh314:
	adrp	x0, l_.str.9@PAGE
Lloh315:
	add	x0, x0, l_.str.9@PAGEOFF
LBB0_318:
	bl	_pedwarn
LBB0_319:
	mov	x0, #0
	ldr	w21, [sp, #68]                  ; 4-byte Folded Reload
	b	LBB0_229
	.loh AdrpLdrGotLdr	Lloh0, Lloh1, Lloh2
	.loh AdrpLdrGotLdr	Lloh3, Lloh4, Lloh5
	.loh AdrpAdd	Lloh6, Lloh7
	.loh AdrpAdd	Lloh11, Lloh12
	.loh AdrpLdrGotLdr	Lloh8, Lloh9, Lloh10
	.loh AdrpAdd	Lloh13, Lloh14
	.loh AdrpLdrGotLdr	Lloh27, Lloh28, Lloh29
	.loh AdrpLdrGotLdr	Lloh24, Lloh25, Lloh26
	.loh AdrpLdrGotLdr	Lloh21, Lloh22, Lloh23
	.loh AdrpLdrGotLdr	Lloh18, Lloh19, Lloh20
	.loh AdrpLdrGotLdr	Lloh15, Lloh16, Lloh17
	.loh AdrpLdrGotLdr	Lloh30, Lloh31, Lloh32
	.loh AdrpLdrGotLdr	Lloh33, Lloh34, Lloh35
	.loh AdrpAdd	Lloh39, Lloh40
	.loh AdrpLdrGotLdr	Lloh36, Lloh37, Lloh38
	.loh AdrpLdrGotLdr	Lloh48, Lloh49, Lloh50
	.loh AdrpLdrGot	Lloh45, Lloh46
	.loh AdrpLdrGotLdr	Lloh43, Lloh44, Lloh47
	.loh AdrpLdrGot	Lloh41, Lloh42
	.loh AdrpLdrGotLdr	Lloh56, Lloh57, Lloh58
	.loh AdrpLdrGot	Lloh54, Lloh55
	.loh AdrpLdrGotLdr	Lloh51, Lloh52, Lloh53
	.loh AdrpLdrGot	Lloh59, Lloh60
	.loh AdrpLdrGotLdr	Lloh61, Lloh62, Lloh63
	.loh AdrpLdrGotLdr	Lloh64, Lloh65, Lloh66
	.loh AdrpAdd	Lloh67, Lloh68
	.loh AdrpLdrGotLdr	Lloh69, Lloh70, Lloh71
	.loh AdrpLdrGotLdr	Lloh72, Lloh73, Lloh74
	.loh AdrpLdrGotLdr	Lloh75, Lloh76, Lloh77
	.loh AdrpAdd	Lloh81, Lloh82
	.loh AdrpLdrGotLdr	Lloh78, Lloh79, Lloh80
	.loh AdrpLdrGotLdr	Lloh83, Lloh84, Lloh85
	.loh AdrpLdrGot	Lloh86, Lloh87
	.loh AdrpAdd	Lloh91, Lloh92
	.loh AdrpLdrGotLdr	Lloh88, Lloh89, Lloh90
	.loh AdrpLdrGotLdr	Lloh98, Lloh99, Lloh100
	.loh AdrpLdrGot	Lloh95, Lloh96
	.loh AdrpLdrGotLdr	Lloh93, Lloh94, Lloh97
	.loh AdrpLdrGotLdr	Lloh103, Lloh104, Lloh105
	.loh AdrpLdrGot	Lloh101, Lloh102
	.loh AdrpLdrGotLdr	Lloh106, Lloh107, Lloh108
	.loh AdrpLdrGotLdr	Lloh109, Lloh110, Lloh111
	.loh AdrpLdrGotLdr	Lloh112, Lloh113, Lloh114
	.loh AdrpAdd	Lloh118, Lloh119
	.loh AdrpLdrGotLdr	Lloh115, Lloh116, Lloh117
	.loh AdrpLdrGotLdr	Lloh123, Lloh124, Lloh125
	.loh AdrpLdrGotLdr	Lloh120, Lloh121, Lloh122
	.loh AdrpAdd	Lloh126, Lloh127
	.loh AdrpLdrGotLdr	Lloh128, Lloh129, Lloh130
	.loh AdrpLdrGot	Lloh131, Lloh132
	.loh AdrpLdrGotLdr	Lloh139, Lloh140, Lloh141
	.loh AdrpLdrGotLdr	Lloh135, Lloh136, Lloh138
	.loh AdrpLdrGotLdr	Lloh133, Lloh134, Lloh137
	.loh AdrpLdrGot	Lloh142, Lloh143
	.loh AdrpLdrGotLdr	Lloh147, Lloh148, Lloh149
	.loh AdrpLdrGotLdr	Lloh144, Lloh145, Lloh146
	.loh AdrpLdrGot	Lloh150, Lloh151
	.loh AdrpLdrGot	Lloh152, Lloh153
	.loh AdrpLdrGotLdr	Lloh154, Lloh155, Lloh156
	.loh AdrpLdrGotLdr	Lloh160, Lloh161, Lloh162
	.loh AdrpLdrGotLdr	Lloh157, Lloh158, Lloh159
	.loh AdrpLdrGot	Lloh163, Lloh164
	.loh AdrpLdrGotLdr	Lloh165, Lloh166, Lloh167
	.loh AdrpLdrGotLdr	Lloh170, Lloh171, Lloh172
	.loh AdrpLdrGot	Lloh168, Lloh169
	.loh AdrpLdrGot	Lloh173, Lloh174
	.loh AdrpLdrGotLdr	Lloh175, Lloh176, Lloh177
	.loh AdrpLdrGotLdr	Lloh178, Lloh179, Lloh180
	.loh AdrpAdd	Lloh184, Lloh185
	.loh AdrpLdrGotLdr	Lloh181, Lloh182, Lloh183
	.loh AdrpLdrGotLdr	Lloh186, Lloh187, Lloh188
	.loh AdrpLdrGotLdr	Lloh189, Lloh190, Lloh191
	.loh AdrpAdd	Lloh192, Lloh193
	.loh AdrpLdrGotLdr	Lloh194, Lloh195, Lloh196
	.loh AdrpLdrGotLdr	Lloh197, Lloh198, Lloh199
	.loh AdrpAdd	Lloh200, Lloh201
	.loh AdrpAdd	Lloh202, Lloh203
	.loh AdrpLdrGotLdr	Lloh204, Lloh205, Lloh206
	.loh AdrpAdd	Lloh207, Lloh208
	.loh AdrpLdrGot	Lloh209, Lloh210
	.loh AdrpLdrGotLdr	Lloh211, Lloh212, Lloh213
	.loh AdrpLdrGotLdr	Lloh214, Lloh215, Lloh216
	.loh AdrpLdrGotLdr	Lloh217, Lloh218, Lloh219
	.loh AdrpAdd	Lloh223, Lloh224
	.loh AdrpLdrGotLdr	Lloh220, Lloh221, Lloh222
	.loh AdrpAdd	Lloh225, Lloh226
	.loh AdrpAdd	Lloh227, Lloh228
	.loh AdrpLdrGotLdr	Lloh229, Lloh230, Lloh231
	.loh AdrpLdrGot	Lloh232, Lloh233
	.loh AdrpAdd	Lloh234, Lloh235
	.loh AdrpAdd	Lloh236, Lloh237
	.loh AdrpLdrGotLdr	Lloh238, Lloh239, Lloh240
	.loh AdrpLdrGotLdr	Lloh241, Lloh242, Lloh243
	.loh AdrpLdrGotLdr	Lloh244, Lloh245, Lloh246
	.loh AdrpLdrGotLdr	Lloh247, Lloh248, Lloh249
	.loh AdrpAdd	Lloh250, Lloh251
	.loh AdrpLdrGotLdr	Lloh255, Lloh256, Lloh257
	.loh AdrpLdrGotLdr	Lloh252, Lloh253, Lloh254
	.loh AdrpLdrGotLdr	Lloh258, Lloh259, Lloh260
	.loh AdrpAdd	Lloh261, Lloh262
	.loh AdrpLdrGotLdr	Lloh263, Lloh264, Lloh265
	.loh AdrpAdd	Lloh266, Lloh267
	.loh AdrpLdrGotLdr	Lloh268, Lloh269, Lloh270
	.loh AdrpLdrGot	Lloh271, Lloh272
	.loh AdrpLdrGotLdr	Lloh273, Lloh274, Lloh275
	.loh AdrpLdrGotLdr	Lloh276, Lloh277, Lloh278
	.loh AdrpLdrGot	Lloh279, Lloh280
	.loh AdrpLdrGotLdr	Lloh281, Lloh282, Lloh283
	.loh AdrpAdd	Lloh284, Lloh285
	.loh AdrpLdrGot	Lloh286, Lloh287
	.loh AdrpLdrGotLdr	Lloh288, Lloh289, Lloh290
	.loh AdrpAdd	Lloh291, Lloh292
	.loh AdrpLdrGotLdr	Lloh293, Lloh294, Lloh295
	.loh AdrpLdrGotLdr	Lloh296, Lloh297, Lloh298
	.loh AdrpAdd	Lloh299, Lloh300
	.loh AdrpLdrGotLdr	Lloh301, Lloh302, Lloh303
	.loh AdrpAdd	Lloh304, Lloh305
	.loh AdrpLdrGotLdr	Lloh306, Lloh307, Lloh308
	.loh AdrpLdrGotLdr	Lloh309, Lloh310, Lloh311
	.loh AdrpAdd	Lloh312, Lloh313
	.loh AdrpAdd	Lloh314, Lloh315
	.cfi_endproc
	.section	__TEXT,__const
	.p2align	1
lJTI0_0:
	.short	(LBB0_7-LBB0_7)>>2
	.short	(LBB0_7-LBB0_7)>>2
	.short	(LBB0_7-LBB0_7)>>2
	.short	(LBB0_7-LBB0_7)>>2
	.short	(LBB0_7-LBB0_7)>>2
	.short	(LBB0_41-LBB0_7)>>2
	.short	(LBB0_14-LBB0_7)>>2
	.short	(LBB0_135-LBB0_7)>>2
	.short	(LBB0_14-LBB0_7)>>2
	.short	(LBB0_137-LBB0_7)>>2
	.short	(LBB0_47-LBB0_7)>>2
	.short	(LBB0_77-LBB0_7)>>2
	.short	(LBB0_141-LBB0_7)>>2
	.short	(LBB0_28-LBB0_7)>>2
	.short	(LBB0_144-LBB0_7)>>2
	.short	(LBB0_28-LBB0_7)>>2
	.short	(LBB0_28-LBB0_7)>>2
	.short	(LBB0_28-LBB0_7)>>2
	.short	(LBB0_41-LBB0_7)>>2
	.short	(LBB0_14-LBB0_7)>>2
	.short	(LBB0_14-LBB0_7)>>2
	.short	(LBB0_47-LBB0_7)>>2
	.short	(LBB0_14-LBB0_7)>>2
	.short	(LBB0_39-LBB0_7)>>2
	.short	(LBB0_39-LBB0_7)>>2
	.short	(LBB0_39-LBB0_7)>>2
                                        ; -- End function
	.comm	_ERROR_MARK,4,2                 ; @ERROR_MARK
	.comm	_error_mark_node,8,3            ; @error_mark_node
	.comm	_targetm,8,3                    ; @targetm
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.space	1

	.comm	_NULL_TREE,8,3                  ; @NULL_TREE
l_.str.1:                               ; @.str.1
	.asciz	"comparison"

	.comm	_POINTER_TYPE,4,2               ; @POINTER_TYPE
	.comm	_INTEGER_TYPE,4,2               ; @INTEGER_TYPE
	.comm	_skip_evaluation,8,3            ; @skip_evaluation
	.comm	_OPT_Wdiv_by_zero,4,2           ; @OPT_Wdiv_by_zero
l_.str.2:                               ; @.str.2
	.asciz	"division by zero"

	.comm	_REAL_TYPE,4,2                  ; @REAL_TYPE
	.comm	_COMPLEX_TYPE,4,2               ; @COMPLEX_TYPE
	.comm	_VECTOR_TYPE,4,2                ; @VECTOR_TYPE
	.comm	_RDIV_EXPR,4,2                  ; @RDIV_EXPR
	.comm	_INTEGER_CST,8,3                ; @INTEGER_CST
	.comm	_BLOCK_POINTER_TYPE,4,2         ; @BLOCK_POINTER_TYPE
	.comm	_integer_type_node,8,3          ; @integer_type_node
l_.str.3:                               ; @.str.3
	.asciz	"right shift count is negative"

l_.str.4:                               ; @.str.4
	.asciz	"right shift count >= width of type"

l_.str.5:                               ; @.str.5
	.asciz	"left shift count is negative"

l_.str.6:                               ; @.str.6
	.asciz	"left shift count >= width of type"

	.comm	_OPT_Wfloat_equal,4,2           ; @OPT_Wfloat_equal
l_.str.7:                               ; @.str.7
	.asciz	"comparing floating point with == or != is unsafe"

	.comm	_pedantic,4,2                   ; @pedantic
	.comm	_FUNCTION_TYPE,4,2              ; @FUNCTION_TYPE
l_.str.8:                               ; @.str.8
	.asciz	"ISO C forbids comparison of %<void *%> with function pointer"

l_.str.9:                               ; @.str.9
	.asciz	"comparison of distinct block types lacks a cast"

l_.str.10:                              ; @.str.10
	.asciz	"comparison of distinct pointer types lacks a cast"

	.comm	_ptr_type_node,8,3              ; @ptr_type_node
	.comm	_ADDR_EXPR,4,2                  ; @ADDR_EXPR
	.comm	_PARM_DECL,4,2                  ; @PARM_DECL
	.comm	_LABEL_DECL,4,2                 ; @LABEL_DECL
	.comm	_OPT_Waddress,4,2               ; @OPT_Waddress
l_.str.11:                              ; @.str.11
	.asciz	"the address of %qD will never be NULL"

l_.str.12:                              ; @.str.12
	.asciz	"comparison between pointer and integer"

l_.str.13:                              ; @.str.13
	.asciz	"comparison of complete and incomplete pointers"

l_.str.14:                              ; @.str.14
	.asciz	"ISO C forbids ordered comparisons of pointers to functions"

	.comm	_extra_warnings,4,2             ; @extra_warnings
l_.str.15:                              ; @.str.15
	.asciz	"ordered comparison of pointer with integer zero"

	.comm	_warn_sign_compare,8,3          ; @warn_sign_compare
	.comm	_ENUMERAL_TYPE,8,3              ; @ENUMERAL_TYPE
l_.str.16:                              ; @.str.16
	.asciz	"comparison between signed and unsigned"

	.comm	_BIT_NOT_EXPR,8,3               ; @BIT_NOT_EXPR
	.comm	_HOST_BITS_PER_WIDE_INT,4,2     ; @HOST_BITS_PER_WIDE_INT
l_.str.17:                              ; @.str.17
	.asciz	"comparison of promoted ~unsigned with constant"

l_.str.18:                              ; @.str.18
	.asciz	"comparison of promoted ~unsigned with unsigned"

	.comm	_require_constant_value,8,3     ; @require_constant_value
.subsections_via_symbols
