	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_main                           ## -- Begin function main
	.p2align	4, 0x90
_main:                                  ## @main
	.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	$24, %rsp
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	leaq	L_.str(%rip), %rax
	movq	_progname@GOTPCREL(%rip), %rcx
	movq	%rax, (%rcx)
	callq	_init_md_reader_args
	movq	_SUCCESS_EXIT_CODE@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_27
## %bb.1:
	leaq	L_.str.1(%rip), %rdi
	callq	_puts
	leaq	L_.str.2(%rip), %rdi
	callq	_puts
	leaq	L_.str.3(%rip), %rdi
	callq	_puts
	leaq	L_.str.4(%rip), %rdi
	callq	_puts
	leaq	L_.str.5(%rip), %rdi
	callq	_puts
	leaq	L_.str.6(%rip), %rdi
	callq	_puts
	leaq	-52(%rbp), %rdi
	leaq	-48(%rbp), %rsi
	callq	_read_md_rtx
	testq	%rax, %rax
	je	LBB0_23
## %bb.2:
	movq	%rax, %rbx
	xorl	%r14d, %r14d
	xorl	%r12d, %r12d
	xorl	%r13d, %r13d
	xorl	%r15d, %r15d
	jmp	LBB0_5
	.p2align	4, 0x90
LBB0_3:                                 ##   in Loop: Header=BB0_5 Depth=1
	movq	%rbx, %rdi
	callq	_gen_attr
LBB0_4:                                 ##   in Loop: Header=BB0_5 Depth=1
	leaq	-52(%rbp), %rdi
	leaq	-48(%rbp), %rsi
	callq	_read_md_rtx
	movq	%rax, %rbx
	testq	%rax, %rax
	je	LBB0_20
LBB0_5:                                 ## =>This Loop Header: Depth=1
                                        ##     Child Loop BB0_12 Depth 2
	movq	%rbx, %rdi
	callq	_GET_CODE
	movq	_DEFINE_ATTR@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	je	LBB0_3
## %bb.6:                               ##   in Loop: Header=BB0_5 Depth=1
	movq	%rbx, %rdi
	callq	_GET_CODE
	movq	_DEFINE_DELAY@GOTPCREL(%rip), %rcx
	cmpq	(%rcx), %rax
	jne	LBB0_18
## %bb.7:                               ##   in Loop: Header=BB0_5 Depth=1
	testl	%r15d, %r15d
	jne	LBB0_9
## %bb.8:                               ##   in Loop: Header=BB0_5 Depth=1
	leaq	L_str.206(%rip), %rdi
	callq	_puts
	leaq	L_str.207(%rip), %rdi
	callq	_puts
	leaq	L_str.208(%rip), %rdi
	callq	_puts
	leaq	L_str.209(%rip), %rdi
	callq	_puts
LBB0_9:                                 ##   in Loop: Header=BB0_5 Depth=1
	movl	$1, %r15d
	movq	%rbx, %rdi
	movl	$1, %esi
	callq	_XVECLEN
	testl	%eax, %eax
	jle	LBB0_4
## %bb.10:                              ##   in Loop: Header=BB0_5 Depth=1
	movl	%r14d, -44(%rbp)                ## 4-byte Spill
	xorl	%r14d, %r14d
	jmp	LBB0_12
	.p2align	4, 0x90
LBB0_11:                                ##   in Loop: Header=BB0_12 Depth=2
	addl	$3, %r14d
	movl	$1, %r15d
	movq	%rbx, %rdi
	movl	$1, %esi
	callq	_XVECLEN
	cmpl	%eax, %r14d
	jge	LBB0_19
LBB0_12:                                ##   Parent Loop BB0_5 Depth=1
                                        ## =>  This Inner Loop Header: Depth=2
	leal	1(%r14), %edx
	movq	%rbx, %rdi
	movl	$1, %esi
	callq	_XVECEXP
	testq	%rax, %rax
	je	LBB0_15
## %bb.13:                              ##   in Loop: Header=BB0_12 Depth=2
	testl	%r13d, %r13d
	jne	LBB0_15
## %bb.14:                              ##   in Loop: Header=BB0_12 Depth=2
	leaq	L_str.210(%rip), %rdi
	callq	_puts
	leaq	L_str.211(%rip), %rdi
	callq	_puts
	movl	$1, %r13d
LBB0_15:                                ##   in Loop: Header=BB0_12 Depth=2
	leal	2(%r14), %edx
	movq	%rbx, %rdi
	movl	$1, %esi
	callq	_XVECEXP
	testq	%rax, %rax
	je	LBB0_11
## %bb.16:                              ##   in Loop: Header=BB0_12 Depth=2
	testl	%r12d, %r12d
	jne	LBB0_11
## %bb.17:                              ##   in Loop: Header=BB0_12 Depth=2
	leaq	L_str.212(%rip), %rdi
	callq	_puts
	leaq	L_str.213(%rip), %rdi
	callq	_puts
	movl	$1, %r12d
	jmp	LBB0_11
	.p2align	4, 0x90
LBB0_18:                                ##   in Loop: Header=BB0_5 Depth=1
	movq	%rbx, %rdi
	callq	_GET_CODE
	xorl	%ecx, %ecx
	movq	_DEFINE_INSN_RESERVATION@GOTPCREL(%rip), %rdx
	cmpq	(%rdx), %rax
	sete	%cl
	addl	%ecx, %r14d
	jmp	LBB0_4
LBB0_19:                                ##   in Loop: Header=BB0_5 Depth=1
	movl	-44(%rbp), %r14d                ## 4-byte Reload
	jmp	LBB0_4
LBB0_20:
	testl	%r14d, %r14d
	jle	LBB0_23
## %bb.21:
	leaq	L_str.115(%rip), %rdi
	callq	_puts
	leaq	L_.str.16(%rip), %rdi
	callq	_printf
	leaq	L_str.116(%rip), %rdi
	callq	_puts
	leaq	L_str.117(%rip), %rdi
	callq	_puts
	leaq	L_str.194(%rip), %rbx
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.119(%rip), %rdi
	callq	_puts
	leaq	L_str.120(%rip), %rdi
	callq	_puts
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.122(%rip), %rdi
	callq	_puts
	leaq	L_str.123(%rip), %rdi
	callq	_puts
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.125(%rip), %rdi
	callq	_puts
	leaq	L_str.126(%rip), %rdi
	callq	_puts
	leaq	L_str.127(%rip), %rdi
	callq	_puts
	leaq	L_str.128(%rip), %rdi
	callq	_puts
	leaq	L_str.129(%rip), %rdi
	callq	_puts
	leaq	L_str.130(%rip), %rdi
	callq	_puts
	leaq	L_str.131(%rip), %rdi
	callq	_puts
	leaq	L_str.132(%rip), %rdi
	callq	_puts
	leaq	L_str.133(%rip), %rdi
	callq	_puts
	leaq	L_str.134(%rip), %rdi
	callq	_puts
	leaq	L_str.135(%rip), %rdi
	callq	_puts
	leaq	L_str.136(%rip), %rdi
	callq	_puts
	leaq	L_str.137(%rip), %rdi
	callq	_puts
	leaq	L_str.138(%rip), %rdi
	callq	_puts
	leaq	L_str.139(%rip), %rdi
	callq	_puts
	leaq	L_str.140(%rip), %rdi
	callq	_puts
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.142(%rip), %rdi
	callq	_puts
	leaq	L_str.143(%rip), %rdi
	callq	_puts
	leaq	L_str.144(%rip), %rdi
	callq	_puts
	leaq	L_str.145(%rip), %rdi
	callq	_puts
	leaq	L_str.146(%rip), %rdi
	callq	_puts
	leaq	L_str.147(%rip), %rdi
	callq	_puts
	leaq	L_str.148(%rip), %rdi
	callq	_puts
	leaq	L_str.149(%rip), %rdi
	callq	_puts
	leaq	L_str.150(%rip), %rdi
	callq	_puts
	leaq	L_str.151(%rip), %rdi
	callq	_puts
	leaq	L_str.152(%rip), %rdi
	callq	_puts
	leaq	L_str.153(%rip), %rdi
	callq	_puts
	leaq	L_str.154(%rip), %rdi
	callq	_puts
	leaq	L_str.155(%rip), %rdi
	callq	_puts
	leaq	L_str.156(%rip), %rdi
	callq	_puts
	leaq	L_str.157(%rip), %rdi
	callq	_puts
	leaq	L_str.158(%rip), %rdi
	callq	_puts
	leaq	L_str.159(%rip), %rdi
	callq	_puts
	leaq	L_str.160(%rip), %rdi
	callq	_puts
	leaq	L_str.161(%rip), %rdi
	callq	_puts
	leaq	L_str.162(%rip), %rdi
	callq	_puts
	leaq	L_str.163(%rip), %rdi
	callq	_puts
	leaq	L_str.164(%rip), %rdi
	callq	_puts
	leaq	L_str.165(%rip), %rdi
	callq	_puts
	leaq	L_str.166(%rip), %rdi
	callq	_puts
	leaq	L_str.167(%rip), %rdi
	callq	_puts
	leaq	L_str.168(%rip), %rdi
	callq	_puts
	leaq	L_str.169(%rip), %rdi
	callq	_puts
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.171(%rip), %rdi
	callq	_puts
	leaq	L_str.172(%rip), %rdi
	callq	_puts
	leaq	L_str.173(%rip), %rdi
	callq	_puts
	leaq	L_str.174(%rip), %rdi
	callq	_puts
	leaq	L_str.175(%rip), %rdi
	callq	_puts
	leaq	L_str.176(%rip), %rdi
	callq	_puts
	leaq	L_str.177(%rip), %rdi
	callq	_puts
	leaq	L_str.178(%rip), %rdi
	callq	_puts
	leaq	L_str.179(%rip), %rdi
	callq	_puts
	leaq	L_str.180(%rip), %rdi
	callq	_puts
	leaq	L_str.181(%rip), %rdi
	callq	_puts
	leaq	L_str.182(%rip), %rdi
	callq	_puts
	leaq	L_str.183(%rip), %rdi
	callq	_puts
	leaq	L_str.184(%rip), %rdi
	callq	_puts
	leaq	L_str.185(%rip), %rdi
	callq	_puts
	leaq	L_str.186(%rip), %rdi
	callq	_puts
	leaq	L_str.187(%rip), %rdi
	callq	_puts
	leaq	L_str.188(%rip), %rdi
	callq	_puts
	leaq	L_str.189(%rip), %rdi
	callq	_puts
	leaq	L_str.190(%rip), %rdi
	callq	_puts
	leaq	L_str.191(%rip), %rdi
	callq	_puts
	leaq	L_str.192(%rip), %rdi
	callq	_puts
	leaq	L_str.193(%rip), %rdi
	callq	_puts
	movq	%rbx, %rdi
	callq	_puts
	leaq	L_str.195(%rip), %rdi
	callq	_puts
	leaq	L_str.196(%rip), %rdi
	callq	_puts
	leaq	L_str.197(%rip), %rdi
	callq	_puts
	leaq	L_str.198(%rip), %rdi
	callq	_puts
	leaq	L_str.199(%rip), %rdi
	callq	_puts
	leaq	L_str.200(%rip), %rdi
	callq	_puts
	leaq	L_str.201(%rip), %rdi
	callq	_puts
	leaq	L_str.202(%rip), %rdi
	callq	_puts
	leaq	L_str.203(%rip), %rdi
	callq	_puts
	leaq	L_str.204(%rip), %rdi
	callq	_puts
	leaq	L_str.205(%rip), %rdi
	jmp	LBB0_24
LBB0_23:
	leaq	L_str.146(%rip), %rdi
LBB0_24:
	callq	_puts
	leaq	L_str.109(%rip), %rdi
	callq	_puts
	leaq	L_str.110(%rip), %rdi
	callq	_puts
	leaq	L_str.111(%rip), %rdi
	callq	_puts
	leaq	L_str.112(%rip), %rdi
	callq	_puts
	leaq	L_str.113(%rip), %rdi
	callq	_puts
	leaq	L_str.114(%rip), %rdi
	callq	_puts
	leaq	L_.str.108(%rip), %rdi
	callq	_puts
	movq	_stdout@GOTPCREL(%rip), %rbx
	movl	(%rbx), %edi
	callq	_ferror
	testq	%rax, %rax
	jne	LBB0_27
## %bb.25:
	movl	(%rbx), %edi
	callq	_fflush
	testq	%rax, %rax
	jne	LBB0_27
## %bb.26:
	movl	(%rbx), %edi
	callq	_fclose
	testq	%rax, %rax
	je	LBB0_29
LBB0_27:
	movq	_FATAL_EXIT_CODE@GOTPCREL(%rip), %rax
LBB0_28:
	movl	(%rax), %eax
	addq	$24, %rsp
	popq	%rbx
	popq	%r12
	popq	%r13
	popq	%r14
	popq	%r15
	popq	%rbp
	retq
LBB0_29:
	movq	_SUCCESS_EXIT_CODE@GOTPCREL(%rip), %rax
	jmp	LBB0_28
	.cfi_endproc
                                        ## -- End function
	.section	__TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
	.asciz	"genattr"

	.comm	_progname,8,3                   ## @progname
	.comm	_SUCCESS_EXIT_CODE,8,3          ## @SUCCESS_EXIT_CODE
	.comm	_FATAL_EXIT_CODE,4,2            ## @FATAL_EXIT_CODE
L_.str.1:                               ## @.str.1
	.asciz	"/* Generated automatically by the program `genattr'"

L_.str.2:                               ## @.str.2
	.asciz	"   from the machine description file `md'.  */\n"

L_.str.3:                               ## @.str.3
	.asciz	"#ifndef GCC_INSN_ATTR_H"

L_.str.4:                               ## @.str.4
	.asciz	"#define GCC_INSN_ATTR_H\n"

L_.str.5:                               ## @.str.5
	.asciz	"#define HAVE_ATTR_alternative"

L_.str.6:                               ## @.str.6
	.asciz	"#define get_attr_alternative(insn) which_alternative"

	.comm	_DEFINE_ATTR,8,3                ## @DEFINE_ATTR
	.comm	_DEFINE_DELAY,8,3               ## @DEFINE_DELAY
	.comm	_DEFINE_INSN_RESERVATION,8,3    ## @DEFINE_INSN_RESERVATION
L_.str.16:                              ## @.str.16
	.asciz	"\n/* DFA based pipeline interface.  */"

L_.str.108:                             ## @.str.108
	.asciz	"\n#endif /* GCC_INSN_ATTR_H */"

	.comm	_stdout,4,2                     ## @stdout
L_str.109:                              ## @str.109
	.asciz	"\n#define ATTR_FLAG_forward\t0x1"

L_str.110:                              ## @str.110
	.asciz	"#define ATTR_FLAG_backward\t0x2"

L_str.111:                              ## @str.111
	.asciz	"#define ATTR_FLAG_likely\t0x4"

L_str.112:                              ## @str.112
	.asciz	"#define ATTR_FLAG_very_likely\t0x8"

L_str.113:                              ## @str.113
	.asciz	"#define ATTR_FLAG_unlikely\t0x10"

L_str.114:                              ## @str.114
	.asciz	"#define ATTR_FLAG_very_unlikely\t0x20"

L_str.115:                              ## @str.115
	.asciz	"\n#define INSN_SCHEDULING"

L_str.116:                              ## @str.116
	.asciz	"\n#ifndef AUTOMATON_ALTS"

L_str.117:                              ## @str.117
	.asciz	"#define AUTOMATON_ALTS 0"

L_str.119:                              ## @str.119
	.asciz	"\n#ifndef AUTOMATON_STATE_ALTS"

L_str.120:                              ## @str.120
	.asciz	"#define AUTOMATON_STATE_ALTS 0"

L_str.122:                              ## @str.122
	.asciz	"#ifndef CPU_UNITS_QUERY"

L_str.123:                              ## @str.123
	.asciz	"#define CPU_UNITS_QUERY 0"

L_str.125:                              ## @str.125
	.asciz	"/* Internal insn code number used by automata.  */"

L_str.126:                              ## @str.126
	.asciz	"extern int internal_dfa_insn_code (rtx);\n"

L_str.127:                              ## @str.127
	.asciz	"/* Insn latency time defined in define_insn_reservation. */"

L_str.128:                              ## @str.128
	.asciz	"extern int insn_default_latency (rtx);\n"

L_str.129:                              ## @str.129
	.asciz	"/* Return nonzero if there is a bypass for given insn"

L_str.130:                              ## @str.130
	.asciz	"   which is a data producer.  */"

L_str.131:                              ## @str.131
	.asciz	"extern int bypass_p (rtx);\n"

L_str.132:                              ## @str.132
	.asciz	"/* Insn latency time on data consumed by the 2nd insn."

L_str.133:                              ## @str.133
	.asciz	"   Use the function if bypass_p returns nonzero for"

L_str.134:                              ## @str.134
	.asciz	"   the 1st insn. */"

L_str.135:                              ## @str.135
	.asciz	"extern int insn_latency (rtx, rtx);\n"

L_str.136:                              ## @str.136
	.asciz	"\n#if AUTOMATON_ALTS"

L_str.137:                              ## @str.137
	.asciz	"/* The following function returns number of alternative"

L_str.138:                              ## @str.138
	.asciz	"   reservations of given insn.  It may be used for better"

L_str.139:                              ## @str.139
	.asciz	"   insns scheduling heuristics. */"

L_str.140:                              ## @str.140
	.asciz	"extern int insn_alts (rtx);\n"

L_str.142:                              ## @str.142
	.asciz	"/* Maximal possible number of insns waiting results being"

L_str.143:                              ## @str.143
	.asciz	"   produced by insns whose execution is not finished. */"

L_str.144:                              ## @str.144
	.asciz	"extern const int max_insn_queue_index;\n"

L_str.145:                              ## @str.145
	.asciz	"/* Pointer to data describing current state of DFA.  */"

L_str.146:                              ## @str.146
	.asciz	"typedef void *state_t;\n"

L_str.147:                              ## @str.147
	.asciz	"/* Size of the data in bytes.  */"

L_str.148:                              ## @str.148
	.asciz	"extern int state_size (void);\n"

L_str.149:                              ## @str.149
	.asciz	"/* Initiate given DFA state, i.e. Set up the state"

L_str.150:                              ## @str.150
	.asciz	"   as all functional units were not reserved.  */"

L_str.151:                              ## @str.151
	.asciz	"extern void state_reset (state_t);"

L_str.152:                              ## @str.152
	.asciz	"/* The following function returns negative value if given"

L_str.153:                              ## @str.153
	.asciz	"   insn can be issued in processor state described by given"

L_str.154:                              ## @str.154
	.asciz	"   DFA state.  In this case, the DFA state is changed to"

L_str.155:                              ## @str.155
	.asciz	"   reflect the current and future reservations by given"

L_str.156:                              ## @str.156
	.asciz	"   insn.  Otherwise the function returns minimal time"

L_str.157:                              ## @str.157
	.asciz	"   delay to issue the insn.  This delay may be zero"

L_str.158:                              ## @str.158
	.asciz	"   for superscalar or VLIW processors.  If the second"

L_str.159:                              ## @str.159
	.asciz	"   parameter is NULL the function changes given DFA state"

L_str.160:                              ## @str.160
	.asciz	"   as new processor cycle started.  */"

L_str.161:                              ## @str.161
	.asciz	"extern int state_transition (state_t, rtx);"

L_str.162:                              ## @str.162
	.asciz	"\n#if AUTOMATON_STATE_ALTS"

L_str.163:                              ## @str.163
	.asciz	"/* The following function returns number of possible"

L_str.164:                              ## @str.164
	.asciz	"   alternative reservations of given insn in given"

L_str.165:                              ## @str.165
	.asciz	"   DFA state.  It may be used for better insns scheduling"

L_str.166:                              ## @str.166
	.asciz	"   heuristics.  By default the function is defined if"

L_str.167:                              ## @str.167
	.asciz	"   macro AUTOMATON_STATE_ALTS is defined because its"

L_str.168:                              ## @str.168
	.asciz	"   implementation may require much memory.  */"

L_str.169:                              ## @str.169
	.asciz	"extern int state_alts (state_t, rtx);"

L_str.171:                              ## @str.171
	.asciz	"extern int min_issue_delay (state_t, rtx);"

L_str.172:                              ## @str.172
	.asciz	"/* The following function returns nonzero if no one insn"

L_str.173:                              ## @str.173
	.asciz	"   can be issued in current DFA state. */"

L_str.174:                              ## @str.174
	.asciz	"extern int state_dead_lock_p (state_t);"

L_str.175:                              ## @str.175
	.asciz	"/* The function returns minimal delay of issue of the 2nd"

L_str.176:                              ## @str.176
	.asciz	"   insn after issuing the 1st insn in given DFA state."

L_str.177:                              ## @str.177
	.asciz	"   The 1st insn should be issued in given state (i.e."

L_str.178:                              ## @str.178
	.asciz	"    state_transition should return negative value for"

L_str.179:                              ## @str.179
	.asciz	"    the insn and the state).  Data dependencies between"

L_str.180:                              ## @str.180
	.asciz	"    the insns are ignored by the function.  */"

L_str.181:                              ## @str.181
	.asciz	"extern int min_insn_conflict_delay (state_t, rtx, rtx);"

L_str.182:                              ## @str.182
	.asciz	"/* The following function outputs reservations for given"

L_str.183:                              ## @str.183
	.asciz	"   insn as they are described in the corresponding"

L_str.184:                              ## @str.184
	.asciz	"   define_insn_reservation.  */"

L_str.185:                              ## @str.185
	.asciz	"extern void print_reservation (FILE *, rtx);"

L_str.186:                              ## @str.186
	.asciz	"\n#if CPU_UNITS_QUERY"

L_str.187:                              ## @str.187
	.asciz	"/* The following function returns code of functional unit"

L_str.188:                              ## @str.188
	.asciz	"   with given name (see define_cpu_unit). */"

L_str.189:                              ## @str.189
	.asciz	"extern int get_cpu_unit_code (const char *);"

L_str.190:                              ## @str.190
	.asciz	"/* The following function returns nonzero if functional"

L_str.191:                              ## @str.191
	.asciz	"   unit with given code is currently reserved in given"

L_str.192:                              ## @str.192
	.asciz	"   DFA state.  */"

L_str.193:                              ## @str.193
	.asciz	"extern int cpu_unit_reservation_p (state_t, int);"

L_str.194:                              ## @str.194
	.asciz	"#endif\n"

L_str.195:                              ## @str.195
	.asciz	"/* Clean insn code cache.  It should be called if there"

L_str.196:                              ## @str.196
	.asciz	"   is a chance that condition value in a"

L_str.197:                              ## @str.197
	.asciz	"   define_insn_reservation will be changed after"

L_str.198:                              ## @str.198
	.asciz	"   last call of dfa_start.  */"

L_str.199:                              ## @str.199
	.asciz	"extern void dfa_clean_insn_cache (void);\n"

L_str.200:                              ## @str.200
	.asciz	"extern void dfa_clear_single_insn_cache (rtx);\n"

L_str.201:                              ## @str.201
	.asciz	"/* Initiate and finish work with DFA.  They should be"

L_str.202:                              ## @str.202
	.asciz	"   called as the first and the last interface"

L_str.203:                              ## @str.203
	.asciz	"   functions.  */"

L_str.204:                              ## @str.204
	.asciz	"extern void dfa_start (void);"

L_str.205:                              ## @str.205
	.asciz	"extern void dfa_finish (void);"

L_str.206:                              ## @str.206
	.asciz	"#define DELAY_SLOTS"

L_str.207:                              ## @str.207
	.asciz	"extern int num_delay_slots (rtx);"

L_str.208:                              ## @str.208
	.asciz	"extern int eligible_for_delay (rtx, int, rtx, int);\n"

L_str.209:                              ## @str.209
	.asciz	"extern int const_num_delay_slots (rtx);\n"

L_str.210:                              ## @str.210
	.asciz	"#define ANNUL_IFTRUE_SLOTS"

L_str.211:                              ## @str.211
	.asciz	"extern int eligible_for_annul_true (rtx, int, rtx, int);"

L_str.212:                              ## @str.212
	.asciz	"#define ANNUL_IFFALSE_SLOTS"

L_str.213:                              ## @str.213
	.asciz	"extern int eligible_for_annul_false (rtx, int, rtx, int);"

.subsections_via_symbols

	.section	__TEXT,__text,regular,pure_instructions
	.build_version macos, 13, 0	sdk_version 13, 3
	.globl	_main                           ; -- Begin function main
	.p2align	2
_main:                                  ; @main
	.cfi_startproc
; %bb.0:
	sub	sp, sp, #112
	.cfi_def_cfa_offset 112
	stp	x28, x27, [sp, #16]             ; 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             ; 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             ; 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             ; 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             ; 16-byte Folded Spill
	stp	x29, x30, [sp, #96]             ; 16-byte Folded Spill
	add	x29, sp, #96
	.cfi_def_cfa w29, 16
	.cfi_offset w30, -8
	.cfi_offset w29, -16
	.cfi_offset w19, -24
	.cfi_offset w20, -32
	.cfi_offset w21, -40
	.cfi_offset w22, -48
	.cfi_offset w23, -56
	.cfi_offset w24, -64
	.cfi_offset w25, -72
	.cfi_offset w26, -80
	.cfi_offset w27, -88
	.cfi_offset w28, -96
Lloh0:
	adrp	x8, _progname@GOTPAGE
Lloh1:
	ldr	x8, [x8, _progname@GOTPAGEOFF]
Lloh2:
	adrp	x9, l_.str@PAGE
Lloh3:
	add	x9, x9, l_.str@PAGEOFF
Lloh4:
	str	x9, [x8]
	bl	_init_md_reader_args
Lloh5:
	adrp	x8, _SUCCESS_EXIT_CODE@GOTPAGE
Lloh6:
	ldr	x8, [x8, _SUCCESS_EXIT_CODE@GOTPAGEOFF]
Lloh7:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_26
; %bb.1:
Lloh8:
	adrp	x0, l_.str.1@PAGE
Lloh9:
	add	x0, x0, l_.str.1@PAGEOFF
	bl	_puts
Lloh10:
	adrp	x0, l_.str.2@PAGE
Lloh11:
	add	x0, x0, l_.str.2@PAGEOFF
	bl	_puts
Lloh12:
	adrp	x0, l_.str.3@PAGE
Lloh13:
	add	x0, x0, l_.str.3@PAGEOFF
	bl	_puts
Lloh14:
	adrp	x0, l_.str.4@PAGE
Lloh15:
	add	x0, x0, l_.str.4@PAGEOFF
	bl	_puts
Lloh16:
	adrp	x0, l_.str.5@PAGE
Lloh17:
	add	x0, x0, l_.str.5@PAGEOFF
	bl	_puts
Lloh18:
	adrp	x0, l_.str.6@PAGE
Lloh19:
	add	x0, x0, l_.str.6@PAGEOFF
	bl	_puts
	add	x0, sp, #12
	add	x1, sp, #8
	bl	_read_md_rtx
	cbz	x0, LBB0_22
; %bb.2:
	mov	x27, x0
	mov	w28, #0
	mov	w21, #0
	mov	w22, #0
	mov	w20, #0
Lloh20:
	adrp	x19, _DEFINE_ATTR@GOTPAGE
Lloh21:
	ldr	x19, [x19, _DEFINE_ATTR@GOTPAGEOFF]
Lloh22:
	adrp	x23, l_str.212@PAGE
Lloh23:
	add	x23, x23, l_str.212@PAGEOFF
Lloh24:
	adrp	x24, l_str.213@PAGE
Lloh25:
	add	x24, x24, l_str.213@PAGEOFF
Lloh26:
	adrp	x25, l_str.210@PAGE
Lloh27:
	add	x25, x25, l_str.210@PAGEOFF
Lloh28:
	adrp	x26, l_str.211@PAGE
Lloh29:
	add	x26, x26, l_str.211@PAGEOFF
	b	LBB0_5
LBB0_3:                                 ;   in Loop: Header=BB0_5 Depth=1
	mov	x0, x27
	bl	_gen_attr
LBB0_4:                                 ;   in Loop: Header=BB0_5 Depth=1
	add	x0, sp, #12
	add	x1, sp, #8
	bl	_read_md_rtx
	mov	x27, x0
	cbz	x0, LBB0_20
LBB0_5:                                 ; =>This Loop Header: Depth=1
                                        ;     Child Loop BB0_12 Depth 2
	mov	x0, x27
	bl	_GET_CODE
	ldr	x8, [x19]
	cmp	x0, x8
	b.eq	LBB0_3
; %bb.6:                                ;   in Loop: Header=BB0_5 Depth=1
	mov	x0, x27
	bl	_GET_CODE
Lloh30:
	adrp	x8, _DEFINE_DELAY@GOTPAGE
Lloh31:
	ldr	x8, [x8, _DEFINE_DELAY@GOTPAGEOFF]
Lloh32:
	ldr	x8, [x8]
	cmp	x0, x8
	b.ne	LBB0_18
; %bb.7:                                ;   in Loop: Header=BB0_5 Depth=1
	cbnz	w20, LBB0_9
; %bb.8:                                ;   in Loop: Header=BB0_5 Depth=1
Lloh33:
	adrp	x0, l_str.206@PAGE
Lloh34:
	add	x0, x0, l_str.206@PAGEOFF
	bl	_puts
Lloh35:
	adrp	x0, l_str.207@PAGE
Lloh36:
	add	x0, x0, l_str.207@PAGEOFF
	bl	_puts
Lloh37:
	adrp	x0, l_str.208@PAGE
Lloh38:
	add	x0, x0, l_str.208@PAGEOFF
	bl	_puts
Lloh39:
	adrp	x0, l_str.209@PAGE
Lloh40:
	add	x0, x0, l_str.209@PAGEOFF
	bl	_puts
LBB0_9:                                 ;   in Loop: Header=BB0_5 Depth=1
	mov	w20, #1
	mov	x0, x27
	mov	w1, #1
	bl	_XVECLEN
	cmp	w0, #1
	b.lt	LBB0_4
; %bb.10:                               ;   in Loop: Header=BB0_5 Depth=1
	str	w28, [sp, #4]                   ; 4-byte Folded Spill
	mov	x28, x19
	mov	w19, #0
	b	LBB0_12
LBB0_11:                                ;   in Loop: Header=BB0_12 Depth=2
	add	w19, w19, #3
	mov	w20, #1
	mov	x0, x27
	mov	w1, #1
	bl	_XVECLEN
	cmp	w19, w0
	b.ge	LBB0_19
LBB0_12:                                ;   Parent Loop BB0_5 Depth=1
                                        ; =>  This Inner Loop Header: Depth=2
	add	w2, w19, #1
	mov	x0, x27
	mov	w1, #1
	bl	_XVECEXP
	cbz	x0, LBB0_15
; %bb.13:                               ;   in Loop: Header=BB0_12 Depth=2
	cbnz	w22, LBB0_15
; %bb.14:                               ;   in Loop: Header=BB0_12 Depth=2
	mov	x0, x25
	bl	_puts
	mov	x0, x26
	bl	_puts
	mov	w22, #1
LBB0_15:                                ;   in Loop: Header=BB0_12 Depth=2
	add	w2, w19, #2
	mov	x0, x27
	mov	w1, #1
	bl	_XVECEXP
	cbz	x0, LBB0_11
; %bb.16:                               ;   in Loop: Header=BB0_12 Depth=2
	cbnz	w21, LBB0_11
; %bb.17:                               ;   in Loop: Header=BB0_12 Depth=2
	mov	x0, x23
	bl	_puts
	mov	x0, x24
	bl	_puts
	mov	w21, #1
	b	LBB0_11
LBB0_18:                                ;   in Loop: Header=BB0_5 Depth=1
	mov	x0, x27
	bl	_GET_CODE
Lloh41:
	adrp	x8, _DEFINE_INSN_RESERVATION@GOTPAGE
Lloh42:
	ldr	x8, [x8, _DEFINE_INSN_RESERVATION@GOTPAGEOFF]
Lloh43:
	ldr	x8, [x8]
	cmp	x0, x8
	cinc	w28, w28, eq
	b	LBB0_4
LBB0_19:                                ;   in Loop: Header=BB0_5 Depth=1
	mov	x19, x28
	ldr	w28, [sp, #4]                   ; 4-byte Folded Reload
	b	LBB0_4
LBB0_20:
	cmp	w28, #1
	b.lt	LBB0_22
; %bb.21:
Lloh44:
	adrp	x0, l_str.115@PAGE
Lloh45:
	add	x0, x0, l_str.115@PAGEOFF
	bl	_puts
Lloh46:
	adrp	x0, l_.str.16@PAGE
Lloh47:
	add	x0, x0, l_.str.16@PAGEOFF
	bl	_printf
Lloh48:
	adrp	x0, l_str.116@PAGE
Lloh49:
	add	x0, x0, l_str.116@PAGEOFF
	bl	_puts
Lloh50:
	adrp	x0, l_str.117@PAGE
Lloh51:
	add	x0, x0, l_str.117@PAGEOFF
	bl	_puts
Lloh52:
	adrp	x19, l_str.194@PAGE
Lloh53:
	add	x19, x19, l_str.194@PAGEOFF
	mov	x0, x19
	bl	_puts
Lloh54:
	adrp	x0, l_str.119@PAGE
Lloh55:
	add	x0, x0, l_str.119@PAGEOFF
	bl	_puts
Lloh56:
	adrp	x0, l_str.120@PAGE
Lloh57:
	add	x0, x0, l_str.120@PAGEOFF
	bl	_puts
	mov	x0, x19
	bl	_puts
Lloh58:
	adrp	x0, l_str.122@PAGE
Lloh59:
	add	x0, x0, l_str.122@PAGEOFF
	bl	_puts
Lloh60:
	adrp	x0, l_str.123@PAGE
Lloh61:
	add	x0, x0, l_str.123@PAGEOFF
	bl	_puts
	mov	x0, x19
	bl	_puts
Lloh62:
	adrp	x0, l_str.125@PAGE
Lloh63:
	add	x0, x0, l_str.125@PAGEOFF
	bl	_puts
Lloh64:
	adrp	x0, l_str.126@PAGE
Lloh65:
	add	x0, x0, l_str.126@PAGEOFF
	bl	_puts
Lloh66:
	adrp	x0, l_str.127@PAGE
Lloh67:
	add	x0, x0, l_str.127@PAGEOFF
	bl	_puts
Lloh68:
	adrp	x0, l_str.128@PAGE
Lloh69:
	add	x0, x0, l_str.128@PAGEOFF
	bl	_puts
Lloh70:
	adrp	x0, l_str.129@PAGE
Lloh71:
	add	x0, x0, l_str.129@PAGEOFF
	bl	_puts
Lloh72:
	adrp	x0, l_str.130@PAGE
Lloh73:
	add	x0, x0, l_str.130@PAGEOFF
	bl	_puts
Lloh74:
	adrp	x0, l_str.131@PAGE
Lloh75:
	add	x0, x0, l_str.131@PAGEOFF
	bl	_puts
Lloh76:
	adrp	x0, l_str.132@PAGE
Lloh77:
	add	x0, x0, l_str.132@PAGEOFF
	bl	_puts
Lloh78:
	adrp	x0, l_str.133@PAGE
Lloh79:
	add	x0, x0, l_str.133@PAGEOFF
	bl	_puts
Lloh80:
	adrp	x0, l_str.134@PAGE
Lloh81:
	add	x0, x0, l_str.134@PAGEOFF
	bl	_puts
Lloh82:
	adrp	x0, l_str.135@PAGE
Lloh83:
	add	x0, x0, l_str.135@PAGEOFF
	bl	_puts
Lloh84:
	adrp	x0, l_str.136@PAGE
Lloh85:
	add	x0, x0, l_str.136@PAGEOFF
	bl	_puts
Lloh86:
	adrp	x0, l_str.137@PAGE
Lloh87:
	add	x0, x0, l_str.137@PAGEOFF
	bl	_puts
Lloh88:
	adrp	x0, l_str.138@PAGE
Lloh89:
	add	x0, x0, l_str.138@PAGEOFF
	bl	_puts
Lloh90:
	adrp	x0, l_str.139@PAGE
Lloh91:
	add	x0, x0, l_str.139@PAGEOFF
	bl	_puts
Lloh92:
	adrp	x0, l_str.140@PAGE
Lloh93:
	add	x0, x0, l_str.140@PAGEOFF
	bl	_puts
	mov	x0, x19
	bl	_puts
Lloh94:
	adrp	x0, l_str.142@PAGE
Lloh95:
	add	x0, x0, l_str.142@PAGEOFF
	bl	_puts
Lloh96:
	adrp	x0, l_str.143@PAGE
Lloh97:
	add	x0, x0, l_str.143@PAGEOFF
	bl	_puts
Lloh98:
	adrp	x0, l_str.144@PAGE
Lloh99:
	add	x0, x0, l_str.144@PAGEOFF
	bl	_puts
Lloh100:
	adrp	x0, l_str.145@PAGE
Lloh101:
	add	x0, x0, l_str.145@PAGEOFF
	bl	_puts
Lloh102:
	adrp	x0, l_str.146@PAGE
Lloh103:
	add	x0, x0, l_str.146@PAGEOFF
	bl	_puts
Lloh104:
	adrp	x0, l_str.147@PAGE
Lloh105:
	add	x0, x0, l_str.147@PAGEOFF
	bl	_puts
Lloh106:
	adrp	x0, l_str.148@PAGE
Lloh107:
	add	x0, x0, l_str.148@PAGEOFF
	bl	_puts
Lloh108:
	adrp	x0, l_str.149@PAGE
Lloh109:
	add	x0, x0, l_str.149@PAGEOFF
	bl	_puts
Lloh110:
	adrp	x0, l_str.150@PAGE
Lloh111:
	add	x0, x0, l_str.150@PAGEOFF
	bl	_puts
Lloh112:
	adrp	x0, l_str.151@PAGE
Lloh113:
	add	x0, x0, l_str.151@PAGEOFF
	bl	_puts
Lloh114:
	adrp	x0, l_str.152@PAGE
Lloh115:
	add	x0, x0, l_str.152@PAGEOFF
	bl	_puts
Lloh116:
	adrp	x0, l_str.153@PAGE
Lloh117:
	add	x0, x0, l_str.153@PAGEOFF
	bl	_puts
Lloh118:
	adrp	x0, l_str.154@PAGE
Lloh119:
	add	x0, x0, l_str.154@PAGEOFF
	bl	_puts
Lloh120:
	adrp	x0, l_str.155@PAGE
Lloh121:
	add	x0, x0, l_str.155@PAGEOFF
	bl	_puts
Lloh122:
	adrp	x0, l_str.156@PAGE
Lloh123:
	add	x0, x0, l_str.156@PAGEOFF
	bl	_puts
Lloh124:
	adrp	x0, l_str.157@PAGE
Lloh125:
	add	x0, x0, l_str.157@PAGEOFF
	bl	_puts
Lloh126:
	adrp	x0, l_str.158@PAGE
Lloh127:
	add	x0, x0, l_str.158@PAGEOFF
	bl	_puts
Lloh128:
	adrp	x0, l_str.159@PAGE
Lloh129:
	add	x0, x0, l_str.159@PAGEOFF
	bl	_puts
Lloh130:
	adrp	x0, l_str.160@PAGE
Lloh131:
	add	x0, x0, l_str.160@PAGEOFF
	bl	_puts
Lloh132:
	adrp	x0, l_str.161@PAGE
Lloh133:
	add	x0, x0, l_str.161@PAGEOFF
	bl	_puts
Lloh134:
	adrp	x0, l_str.162@PAGE
Lloh135:
	add	x0, x0, l_str.162@PAGEOFF
	bl	_puts
Lloh136:
	adrp	x0, l_str.163@PAGE
Lloh137:
	add	x0, x0, l_str.163@PAGEOFF
	bl	_puts
Lloh138:
	adrp	x0, l_str.164@PAGE
Lloh139:
	add	x0, x0, l_str.164@PAGEOFF
	bl	_puts
Lloh140:
	adrp	x0, l_str.165@PAGE
Lloh141:
	add	x0, x0, l_str.165@PAGEOFF
	bl	_puts
Lloh142:
	adrp	x0, l_str.166@PAGE
Lloh143:
	add	x0, x0, l_str.166@PAGEOFF
	bl	_puts
Lloh144:
	adrp	x0, l_str.167@PAGE
Lloh145:
	add	x0, x0, l_str.167@PAGEOFF
	bl	_puts
Lloh146:
	adrp	x0, l_str.168@PAGE
Lloh147:
	add	x0, x0, l_str.168@PAGEOFF
	bl	_puts
Lloh148:
	adrp	x0, l_str.169@PAGE
Lloh149:
	add	x0, x0, l_str.169@PAGEOFF
	bl	_puts
	mov	x0, x19
	bl	_puts
Lloh150:
	adrp	x0, l_str.171@PAGE
Lloh151:
	add	x0, x0, l_str.171@PAGEOFF
	bl	_puts
Lloh152:
	adrp	x0, l_str.172@PAGE
Lloh153:
	add	x0, x0, l_str.172@PAGEOFF
	bl	_puts
Lloh154:
	adrp	x0, l_str.173@PAGE
Lloh155:
	add	x0, x0, l_str.173@PAGEOFF
	bl	_puts
Lloh156:
	adrp	x0, l_str.174@PAGE
Lloh157:
	add	x0, x0, l_str.174@PAGEOFF
	bl	_puts
Lloh158:
	adrp	x0, l_str.175@PAGE
Lloh159:
	add	x0, x0, l_str.175@PAGEOFF
	bl	_puts
Lloh160:
	adrp	x0, l_str.176@PAGE
Lloh161:
	add	x0, x0, l_str.176@PAGEOFF
	bl	_puts
Lloh162:
	adrp	x0, l_str.177@PAGE
Lloh163:
	add	x0, x0, l_str.177@PAGEOFF
	bl	_puts
Lloh164:
	adrp	x0, l_str.178@PAGE
Lloh165:
	add	x0, x0, l_str.178@PAGEOFF
	bl	_puts
Lloh166:
	adrp	x0, l_str.179@PAGE
Lloh167:
	add	x0, x0, l_str.179@PAGEOFF
	bl	_puts
Lloh168:
	adrp	x0, l_str.180@PAGE
Lloh169:
	add	x0, x0, l_str.180@PAGEOFF
	bl	_puts
Lloh170:
	adrp	x0, l_str.181@PAGE
Lloh171:
	add	x0, x0, l_str.181@PAGEOFF
	bl	_puts
Lloh172:
	adrp	x0, l_str.182@PAGE
Lloh173:
	add	x0, x0, l_str.182@PAGEOFF
	bl	_puts
Lloh174:
	adrp	x0, l_str.183@PAGE
Lloh175:
	add	x0, x0, l_str.183@PAGEOFF
	bl	_puts
Lloh176:
	adrp	x0, l_str.184@PAGE
Lloh177:
	add	x0, x0, l_str.184@PAGEOFF
	bl	_puts
Lloh178:
	adrp	x0, l_str.185@PAGE
Lloh179:
	add	x0, x0, l_str.185@PAGEOFF
	bl	_puts
Lloh180:
	adrp	x0, l_str.186@PAGE
Lloh181:
	add	x0, x0, l_str.186@PAGEOFF
	bl	_puts
Lloh182:
	adrp	x0, l_str.187@PAGE
Lloh183:
	add	x0, x0, l_str.187@PAGEOFF
	bl	_puts
Lloh184:
	adrp	x0, l_str.188@PAGE
Lloh185:
	add	x0, x0, l_str.188@PAGEOFF
	bl	_puts
Lloh186:
	adrp	x0, l_str.189@PAGE
Lloh187:
	add	x0, x0, l_str.189@PAGEOFF
	bl	_puts
Lloh188:
	adrp	x0, l_str.190@PAGE
Lloh189:
	add	x0, x0, l_str.190@PAGEOFF
	bl	_puts
Lloh190:
	adrp	x0, l_str.191@PAGE
Lloh191:
	add	x0, x0, l_str.191@PAGEOFF
	bl	_puts
Lloh192:
	adrp	x0, l_str.192@PAGE
Lloh193:
	add	x0, x0, l_str.192@PAGEOFF
	bl	_puts
Lloh194:
	adrp	x0, l_str.193@PAGE
Lloh195:
	add	x0, x0, l_str.193@PAGEOFF
	bl	_puts
	mov	x0, x19
	bl	_puts
Lloh196:
	adrp	x0, l_str.195@PAGE
Lloh197:
	add	x0, x0, l_str.195@PAGEOFF
	bl	_puts
Lloh198:
	adrp	x0, l_str.196@PAGE
Lloh199:
	add	x0, x0, l_str.196@PAGEOFF
	bl	_puts
Lloh200:
	adrp	x0, l_str.197@PAGE
Lloh201:
	add	x0, x0, l_str.197@PAGEOFF
	bl	_puts
Lloh202:
	adrp	x0, l_str.198@PAGE
Lloh203:
	add	x0, x0, l_str.198@PAGEOFF
	bl	_puts
Lloh204:
	adrp	x0, l_str.199@PAGE
Lloh205:
	add	x0, x0, l_str.199@PAGEOFF
	bl	_puts
Lloh206:
	adrp	x0, l_str.200@PAGE
Lloh207:
	add	x0, x0, l_str.200@PAGEOFF
	bl	_puts
Lloh208:
	adrp	x0, l_str.201@PAGE
Lloh209:
	add	x0, x0, l_str.201@PAGEOFF
	bl	_puts
Lloh210:
	adrp	x0, l_str.202@PAGE
Lloh211:
	add	x0, x0, l_str.202@PAGEOFF
	bl	_puts
Lloh212:
	adrp	x0, l_str.203@PAGE
Lloh213:
	add	x0, x0, l_str.203@PAGEOFF
	bl	_puts
Lloh214:
	adrp	x0, l_str.204@PAGE
Lloh215:
	add	x0, x0, l_str.204@PAGEOFF
	bl	_puts
Lloh216:
	adrp	x0, l_str.205@PAGE
Lloh217:
	add	x0, x0, l_str.205@PAGEOFF
	b	LBB0_23
LBB0_22:
Lloh218:
	adrp	x0, l_str.146@PAGE
Lloh219:
	add	x0, x0, l_str.146@PAGEOFF
LBB0_23:
	bl	_puts
Lloh220:
	adrp	x0, l_str.109@PAGE
Lloh221:
	add	x0, x0, l_str.109@PAGEOFF
	bl	_puts
Lloh222:
	adrp	x0, l_str.110@PAGE
Lloh223:
	add	x0, x0, l_str.110@PAGEOFF
	bl	_puts
Lloh224:
	adrp	x0, l_str.111@PAGE
Lloh225:
	add	x0, x0, l_str.111@PAGEOFF
	bl	_puts
Lloh226:
	adrp	x0, l_str.112@PAGE
Lloh227:
	add	x0, x0, l_str.112@PAGEOFF
	bl	_puts
Lloh228:
	adrp	x0, l_str.113@PAGE
Lloh229:
	add	x0, x0, l_str.113@PAGEOFF
	bl	_puts
Lloh230:
	adrp	x0, l_str.114@PAGE
Lloh231:
	add	x0, x0, l_str.114@PAGEOFF
	bl	_puts
Lloh232:
	adrp	x0, l_.str.108@PAGE
Lloh233:
	add	x0, x0, l_.str.108@PAGEOFF
	bl	_puts
Lloh234:
	adrp	x19, _stdout@GOTPAGE
Lloh235:
	ldr	x19, [x19, _stdout@GOTPAGEOFF]
	ldr	w0, [x19]
	bl	_ferror
	cbnz	x0, LBB0_26
; %bb.24:
	ldr	w0, [x19]
	bl	_fflush
	cbnz	x0, LBB0_26
; %bb.25:
	ldr	w0, [x19]
	bl	_fclose
	cbz	x0, LBB0_28
LBB0_26:
Lloh236:
	adrp	x8, _FATAL_EXIT_CODE@GOTPAGE
Lloh237:
	ldr	x8, [x8, _FATAL_EXIT_CODE@GOTPAGEOFF]
LBB0_27:
	ldr	w0, [x8]
	ldp	x29, x30, [sp, #96]             ; 16-byte Folded Reload
	ldp	x20, x19, [sp, #80]             ; 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             ; 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             ; 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             ; 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             ; 16-byte Folded Reload
	add	sp, sp, #112
	ret
LBB0_28:
Lloh238:
	adrp	x8, _SUCCESS_EXIT_CODE@GOTPAGE
Lloh239:
	ldr	x8, [x8, _SUCCESS_EXIT_CODE@GOTPAGEOFF]
	b	LBB0_27
	.loh AdrpLdrGotLdr	Lloh5, Lloh6, Lloh7
	.loh AdrpAdd	Lloh2, Lloh3
	.loh AdrpLdrGotStr	Lloh0, Lloh1, Lloh4
	.loh AdrpAdd	Lloh18, Lloh19
	.loh AdrpAdd	Lloh16, Lloh17
	.loh AdrpAdd	Lloh14, Lloh15
	.loh AdrpAdd	Lloh12, Lloh13
	.loh AdrpAdd	Lloh10, Lloh11
	.loh AdrpAdd	Lloh8, Lloh9
	.loh AdrpAdd	Lloh28, Lloh29
	.loh AdrpAdd	Lloh26, Lloh27
	.loh AdrpAdd	Lloh24, Lloh25
	.loh AdrpAdd	Lloh22, Lloh23
	.loh AdrpLdrGot	Lloh20, Lloh21
	.loh AdrpLdrGotLdr	Lloh30, Lloh31, Lloh32
	.loh AdrpAdd	Lloh39, Lloh40
	.loh AdrpAdd	Lloh37, Lloh38
	.loh AdrpAdd	Lloh35, Lloh36
	.loh AdrpAdd	Lloh33, Lloh34
	.loh AdrpLdrGotLdr	Lloh41, Lloh42, Lloh43
	.loh AdrpAdd	Lloh216, Lloh217
	.loh AdrpAdd	Lloh214, Lloh215
	.loh AdrpAdd	Lloh212, Lloh213
	.loh AdrpAdd	Lloh210, Lloh211
	.loh AdrpAdd	Lloh208, Lloh209
	.loh AdrpAdd	Lloh206, Lloh207
	.loh AdrpAdd	Lloh204, Lloh205
	.loh AdrpAdd	Lloh202, Lloh203
	.loh AdrpAdd	Lloh200, Lloh201
	.loh AdrpAdd	Lloh198, Lloh199
	.loh AdrpAdd	Lloh196, Lloh197
	.loh AdrpAdd	Lloh194, Lloh195
	.loh AdrpAdd	Lloh192, Lloh193
	.loh AdrpAdd	Lloh190, Lloh191
	.loh AdrpAdd	Lloh188, Lloh189
	.loh AdrpAdd	Lloh186, Lloh187
	.loh AdrpAdd	Lloh184, Lloh185
	.loh AdrpAdd	Lloh182, Lloh183
	.loh AdrpAdd	Lloh180, Lloh181
	.loh AdrpAdd	Lloh178, Lloh179
	.loh AdrpAdd	Lloh176, Lloh177
	.loh AdrpAdd	Lloh174, Lloh175
	.loh AdrpAdd	Lloh172, Lloh173
	.loh AdrpAdd	Lloh170, Lloh171
	.loh AdrpAdd	Lloh168, Lloh169
	.loh AdrpAdd	Lloh166, Lloh167
	.loh AdrpAdd	Lloh164, Lloh165
	.loh AdrpAdd	Lloh162, Lloh163
	.loh AdrpAdd	Lloh160, Lloh161
	.loh AdrpAdd	Lloh158, Lloh159
	.loh AdrpAdd	Lloh156, Lloh157
	.loh AdrpAdd	Lloh154, Lloh155
	.loh AdrpAdd	Lloh152, Lloh153
	.loh AdrpAdd	Lloh150, Lloh151
	.loh AdrpAdd	Lloh148, Lloh149
	.loh AdrpAdd	Lloh146, Lloh147
	.loh AdrpAdd	Lloh144, Lloh145
	.loh AdrpAdd	Lloh142, Lloh143
	.loh AdrpAdd	Lloh140, Lloh141
	.loh AdrpAdd	Lloh138, Lloh139
	.loh AdrpAdd	Lloh136, Lloh137
	.loh AdrpAdd	Lloh134, Lloh135
	.loh AdrpAdd	Lloh132, Lloh133
	.loh AdrpAdd	Lloh130, Lloh131
	.loh AdrpAdd	Lloh128, Lloh129
	.loh AdrpAdd	Lloh126, Lloh127
	.loh AdrpAdd	Lloh124, Lloh125
	.loh AdrpAdd	Lloh122, Lloh123
	.loh AdrpAdd	Lloh120, Lloh121
	.loh AdrpAdd	Lloh118, Lloh119
	.loh AdrpAdd	Lloh116, Lloh117
	.loh AdrpAdd	Lloh114, Lloh115
	.loh AdrpAdd	Lloh112, Lloh113
	.loh AdrpAdd	Lloh110, Lloh111
	.loh AdrpAdd	Lloh108, Lloh109
	.loh AdrpAdd	Lloh106, Lloh107
	.loh AdrpAdd	Lloh104, Lloh105
	.loh AdrpAdd	Lloh102, Lloh103
	.loh AdrpAdd	Lloh100, Lloh101
	.loh AdrpAdd	Lloh98, Lloh99
	.loh AdrpAdd	Lloh96, Lloh97
	.loh AdrpAdd	Lloh94, Lloh95
	.loh AdrpAdd	Lloh92, Lloh93
	.loh AdrpAdd	Lloh90, Lloh91
	.loh AdrpAdd	Lloh88, Lloh89
	.loh AdrpAdd	Lloh86, Lloh87
	.loh AdrpAdd	Lloh84, Lloh85
	.loh AdrpAdd	Lloh82, Lloh83
	.loh AdrpAdd	Lloh80, Lloh81
	.loh AdrpAdd	Lloh78, Lloh79
	.loh AdrpAdd	Lloh76, Lloh77
	.loh AdrpAdd	Lloh74, Lloh75
	.loh AdrpAdd	Lloh72, Lloh73
	.loh AdrpAdd	Lloh70, Lloh71
	.loh AdrpAdd	Lloh68, Lloh69
	.loh AdrpAdd	Lloh66, Lloh67
	.loh AdrpAdd	Lloh64, Lloh65
	.loh AdrpAdd	Lloh62, Lloh63
	.loh AdrpAdd	Lloh60, Lloh61
	.loh AdrpAdd	Lloh58, Lloh59
	.loh AdrpAdd	Lloh56, Lloh57
	.loh AdrpAdd	Lloh54, Lloh55
	.loh AdrpAdd	Lloh52, Lloh53
	.loh AdrpAdd	Lloh50, Lloh51
	.loh AdrpAdd	Lloh48, Lloh49
	.loh AdrpAdd	Lloh46, Lloh47
	.loh AdrpAdd	Lloh44, Lloh45
	.loh AdrpAdd	Lloh218, Lloh219
	.loh AdrpLdrGot	Lloh234, Lloh235
	.loh AdrpAdd	Lloh232, Lloh233
	.loh AdrpAdd	Lloh230, Lloh231
	.loh AdrpAdd	Lloh228, Lloh229
	.loh AdrpAdd	Lloh226, Lloh227
	.loh AdrpAdd	Lloh224, Lloh225
	.loh AdrpAdd	Lloh222, Lloh223
	.loh AdrpAdd	Lloh220, Lloh221
	.loh AdrpLdrGot	Lloh236, Lloh237
	.loh AdrpLdrGot	Lloh238, Lloh239
	.cfi_endproc
                                        ; -- End function
	.section	__TEXT,__cstring,cstring_literals
l_.str:                                 ; @.str
	.asciz	"genattr"

	.comm	_progname,8,3                   ; @progname
	.comm	_SUCCESS_EXIT_CODE,8,3          ; @SUCCESS_EXIT_CODE
	.comm	_FATAL_EXIT_CODE,4,2            ; @FATAL_EXIT_CODE
l_.str.1:                               ; @.str.1
	.asciz	"/* Generated automatically by the program `genattr'"

l_.str.2:                               ; @.str.2
	.asciz	"   from the machine description file `md'.  */\n"

l_.str.3:                               ; @.str.3
	.asciz	"#ifndef GCC_INSN_ATTR_H"

l_.str.4:                               ; @.str.4
	.asciz	"#define GCC_INSN_ATTR_H\n"

l_.str.5:                               ; @.str.5
	.asciz	"#define HAVE_ATTR_alternative"

l_.str.6:                               ; @.str.6
	.asciz	"#define get_attr_alternative(insn) which_alternative"

	.comm	_DEFINE_ATTR,8,3                ; @DEFINE_ATTR
	.comm	_DEFINE_DELAY,8,3               ; @DEFINE_DELAY
	.comm	_DEFINE_INSN_RESERVATION,8,3    ; @DEFINE_INSN_RESERVATION
l_.str.16:                              ; @.str.16
	.asciz	"\n/* DFA based pipeline interface.  */"

l_.str.108:                             ; @.str.108
	.asciz	"\n#endif /* GCC_INSN_ATTR_H */"

	.comm	_stdout,4,2                     ; @stdout
l_str.109:                              ; @str.109
	.asciz	"\n#define ATTR_FLAG_forward\t0x1"

l_str.110:                              ; @str.110
	.asciz	"#define ATTR_FLAG_backward\t0x2"

l_str.111:                              ; @str.111
	.asciz	"#define ATTR_FLAG_likely\t0x4"

l_str.112:                              ; @str.112
	.asciz	"#define ATTR_FLAG_very_likely\t0x8"

l_str.113:                              ; @str.113
	.asciz	"#define ATTR_FLAG_unlikely\t0x10"

l_str.114:                              ; @str.114
	.asciz	"#define ATTR_FLAG_very_unlikely\t0x20"

l_str.115:                              ; @str.115
	.asciz	"\n#define INSN_SCHEDULING"

l_str.116:                              ; @str.116
	.asciz	"\n#ifndef AUTOMATON_ALTS"

l_str.117:                              ; @str.117
	.asciz	"#define AUTOMATON_ALTS 0"

l_str.119:                              ; @str.119
	.asciz	"\n#ifndef AUTOMATON_STATE_ALTS"

l_str.120:                              ; @str.120
	.asciz	"#define AUTOMATON_STATE_ALTS 0"

l_str.122:                              ; @str.122
	.asciz	"#ifndef CPU_UNITS_QUERY"

l_str.123:                              ; @str.123
	.asciz	"#define CPU_UNITS_QUERY 0"

l_str.125:                              ; @str.125
	.asciz	"/* Internal insn code number used by automata.  */"

l_str.126:                              ; @str.126
	.asciz	"extern int internal_dfa_insn_code (rtx);\n"

l_str.127:                              ; @str.127
	.asciz	"/* Insn latency time defined in define_insn_reservation. */"

l_str.128:                              ; @str.128
	.asciz	"extern int insn_default_latency (rtx);\n"

l_str.129:                              ; @str.129
	.asciz	"/* Return nonzero if there is a bypass for given insn"

l_str.130:                              ; @str.130
	.asciz	"   which is a data producer.  */"

l_str.131:                              ; @str.131
	.asciz	"extern int bypass_p (rtx);\n"

l_str.132:                              ; @str.132
	.asciz	"/* Insn latency time on data consumed by the 2nd insn."

l_str.133:                              ; @str.133
	.asciz	"   Use the function if bypass_p returns nonzero for"

l_str.134:                              ; @str.134
	.asciz	"   the 1st insn. */"

l_str.135:                              ; @str.135
	.asciz	"extern int insn_latency (rtx, rtx);\n"

l_str.136:                              ; @str.136
	.asciz	"\n#if AUTOMATON_ALTS"

l_str.137:                              ; @str.137
	.asciz	"/* The following function returns number of alternative"

l_str.138:                              ; @str.138
	.asciz	"   reservations of given insn.  It may be used for better"

l_str.139:                              ; @str.139
	.asciz	"   insns scheduling heuristics. */"

l_str.140:                              ; @str.140
	.asciz	"extern int insn_alts (rtx);\n"

l_str.142:                              ; @str.142
	.asciz	"/* Maximal possible number of insns waiting results being"

l_str.143:                              ; @str.143
	.asciz	"   produced by insns whose execution is not finished. */"

l_str.144:                              ; @str.144
	.asciz	"extern const int max_insn_queue_index;\n"

l_str.145:                              ; @str.145
	.asciz	"/* Pointer to data describing current state of DFA.  */"

l_str.146:                              ; @str.146
	.asciz	"typedef void *state_t;\n"

l_str.147:                              ; @str.147
	.asciz	"/* Size of the data in bytes.  */"

l_str.148:                              ; @str.148
	.asciz	"extern int state_size (void);\n"

l_str.149:                              ; @str.149
	.asciz	"/* Initiate given DFA state, i.e. Set up the state"

l_str.150:                              ; @str.150
	.asciz	"   as all functional units were not reserved.  */"

l_str.151:                              ; @str.151
	.asciz	"extern void state_reset (state_t);"

l_str.152:                              ; @str.152
	.asciz	"/* The following function returns negative value if given"

l_str.153:                              ; @str.153
	.asciz	"   insn can be issued in processor state described by given"

l_str.154:                              ; @str.154
	.asciz	"   DFA state.  In this case, the DFA state is changed to"

l_str.155:                              ; @str.155
	.asciz	"   reflect the current and future reservations by given"

l_str.156:                              ; @str.156
	.asciz	"   insn.  Otherwise the function returns minimal time"

l_str.157:                              ; @str.157
	.asciz	"   delay to issue the insn.  This delay may be zero"

l_str.158:                              ; @str.158
	.asciz	"   for superscalar or VLIW processors.  If the second"

l_str.159:                              ; @str.159
	.asciz	"   parameter is NULL the function changes given DFA state"

l_str.160:                              ; @str.160
	.asciz	"   as new processor cycle started.  */"

l_str.161:                              ; @str.161
	.asciz	"extern int state_transition (state_t, rtx);"

l_str.162:                              ; @str.162
	.asciz	"\n#if AUTOMATON_STATE_ALTS"

l_str.163:                              ; @str.163
	.asciz	"/* The following function returns number of possible"

l_str.164:                              ; @str.164
	.asciz	"   alternative reservations of given insn in given"

l_str.165:                              ; @str.165
	.asciz	"   DFA state.  It may be used for better insns scheduling"

l_str.166:                              ; @str.166
	.asciz	"   heuristics.  By default the function is defined if"

l_str.167:                              ; @str.167
	.asciz	"   macro AUTOMATON_STATE_ALTS is defined because its"

l_str.168:                              ; @str.168
	.asciz	"   implementation may require much memory.  */"

l_str.169:                              ; @str.169
	.asciz	"extern int state_alts (state_t, rtx);"

l_str.171:                              ; @str.171
	.asciz	"extern int min_issue_delay (state_t, rtx);"

l_str.172:                              ; @str.172
	.asciz	"/* The following function returns nonzero if no one insn"

l_str.173:                              ; @str.173
	.asciz	"   can be issued in current DFA state. */"

l_str.174:                              ; @str.174
	.asciz	"extern int state_dead_lock_p (state_t);"

l_str.175:                              ; @str.175
	.asciz	"/* The function returns minimal delay of issue of the 2nd"

l_str.176:                              ; @str.176
	.asciz	"   insn after issuing the 1st insn in given DFA state."

l_str.177:                              ; @str.177
	.asciz	"   The 1st insn should be issued in given state (i.e."

l_str.178:                              ; @str.178
	.asciz	"    state_transition should return negative value for"

l_str.179:                              ; @str.179
	.asciz	"    the insn and the state).  Data dependencies between"

l_str.180:                              ; @str.180
	.asciz	"    the insns are ignored by the function.  */"

l_str.181:                              ; @str.181
	.asciz	"extern int min_insn_conflict_delay (state_t, rtx, rtx);"

l_str.182:                              ; @str.182
	.asciz	"/* The following function outputs reservations for given"

l_str.183:                              ; @str.183
	.asciz	"   insn as they are described in the corresponding"

l_str.184:                              ; @str.184
	.asciz	"   define_insn_reservation.  */"

l_str.185:                              ; @str.185
	.asciz	"extern void print_reservation (FILE *, rtx);"

l_str.186:                              ; @str.186
	.asciz	"\n#if CPU_UNITS_QUERY"

l_str.187:                              ; @str.187
	.asciz	"/* The following function returns code of functional unit"

l_str.188:                              ; @str.188
	.asciz	"   with given name (see define_cpu_unit). */"

l_str.189:                              ; @str.189
	.asciz	"extern int get_cpu_unit_code (const char *);"

l_str.190:                              ; @str.190
	.asciz	"/* The following function returns nonzero if functional"

l_str.191:                              ; @str.191
	.asciz	"   unit with given code is currently reserved in given"

l_str.192:                              ; @str.192
	.asciz	"   DFA state.  */"

l_str.193:                              ; @str.193
	.asciz	"extern int cpu_unit_reservation_p (state_t, int);"

l_str.194:                              ; @str.194
	.asciz	"#endif\n"

l_str.195:                              ; @str.195
	.asciz	"/* Clean insn code cache.  It should be called if there"

l_str.196:                              ; @str.196
	.asciz	"   is a chance that condition value in a"

l_str.197:                              ; @str.197
	.asciz	"   define_insn_reservation will be changed after"

l_str.198:                              ; @str.198
	.asciz	"   last call of dfa_start.  */"

l_str.199:                              ; @str.199
	.asciz	"extern void dfa_clean_insn_cache (void);\n"

l_str.200:                              ; @str.200
	.asciz	"extern void dfa_clear_single_insn_cache (rtx);\n"

l_str.201:                              ; @str.201
	.asciz	"/* Initiate and finish work with DFA.  They should be"

l_str.202:                              ; @str.202
	.asciz	"   called as the first and the last interface"

l_str.203:                              ; @str.203
	.asciz	"   functions.  */"

l_str.204:                              ; @str.204
	.asciz	"extern void dfa_start (void);"

l_str.205:                              ; @str.205
	.asciz	"extern void dfa_finish (void);"

l_str.206:                              ; @str.206
	.asciz	"#define DELAY_SLOTS"

l_str.207:                              ; @str.207
	.asciz	"extern int num_delay_slots (rtx);"

l_str.208:                              ; @str.208
	.asciz	"extern int eligible_for_delay (rtx, int, rtx, int);\n"

l_str.209:                              ; @str.209
	.asciz	"extern int const_num_delay_slots (rtx);\n"

l_str.210:                              ; @str.210
	.asciz	"#define ANNUL_IFTRUE_SLOTS"

l_str.211:                              ; @str.211
	.asciz	"extern int eligible_for_annul_true (rtx, int, rtx, int);"

l_str.212:                              ; @str.212
	.asciz	"#define ANNUL_IFFALSE_SLOTS"

l_str.213:                              ; @str.213
	.asciz	"extern int eligible_for_annul_false (rtx, int, rtx, int);"

.subsections_via_symbols
