Opcodes.inc source code [llvm_projects/build/tools/clang/lib/AST/Opcodes.inc]

1	#ifdef GET_OPCODE_NAMES
2	OP_Activate,
3	#endif
4	#ifdef GET_INTERPFN_LIST
5	&Interp_Activate,
6	#endif
7	#ifdef GET_INTERPFN_DISPATCHERS
8	PRESERVE_NONE
9	static bool Interp_Activate(InterpState &S) {
10	Activate(S);
11	#if USE_TAILCALLS
12	MUSTTAIL return InterpNext(S);
13	#else
14	return true;
15	#endif
16	}
17	#endif
18	#ifdef GET_DISASM
19	case OP_Activate:
20	Text.Op = PrintName("Activate");
21	break;
22	#endif
23	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24	bool emitActivate(SourceInfo);
25	#endif
26	#ifdef GET_LINK_IMPL
27	bool ByteCodeEmitter::emitActivate(SourceInfo L) {
28	return emitOp<>(OP_Activate, L);
29	}
30	#endif
31	#ifdef GET_EVAL_IMPL
32	bool EvalEmitter::emitActivate(SourceInfo L) {
33	if (!isActive()) return true;
34	CurrentSource = L;
35	return Activate(S);
36	}
37	#endif
38	#ifdef GET_OPCODE_NAMES
39	OP_ActivateThisField,
40	#endif
41	#ifdef GET_INTERPFN_LIST
42	&Interp_ActivateThisField,
43	#endif
44	#ifdef GET_INTERPFN_DISPATCHERS
45	PRESERVE_NONE
46	static bool Interp_ActivateThisField(InterpState &S) {
47	{
48	const auto V0 = ReadArg<uint32_t>(S, S.PC);
49	if (!ActivateThisField(S, V0)) return false;
50	}
51	#if USE_TAILCALLS
52	MUSTTAIL return InterpNext(S);
53	#else
54	return true;
55	#endif
56	}
57	#endif
58	#ifdef GET_DISASM
59	case OP_ActivateThisField:
60	Text.Op = PrintName("ActivateThisField");
61	Text.Args.push_back(printArg<uint32_t>(P, PC));
62	break;
63	#endif
64	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
65	bool emitActivateThisField( uint32_t , SourceInfo);
66	#endif
67	#ifdef GET_LINK_IMPL
68	bool ByteCodeEmitter::emitActivateThisField( uint32_t A0, SourceInfo L) {
69	return emitOp<uint32_t>(OP_ActivateThisField, A0, L);
70	}
71	#endif
72	#ifdef GET_EVAL_IMPL
73	bool EvalEmitter::emitActivateThisField( uint32_t A0, SourceInfo L) {
74	if (!isActive()) return true;
75	CurrentSource = L;
76	return ActivateThisField(S, A0);
77	}
78	#endif
79	#ifdef GET_OPCODE_NAMES
80	OP_AddSint8,
81	OP_AddUint8,
82	OP_AddSint16,
83	OP_AddUint16,
84	OP_AddSint32,
85	OP_AddUint32,
86	OP_AddSint64,
87	OP_AddUint64,
88	OP_AddIntAP,
89	OP_AddIntAPS,
90	OP_AddBool,
91	OP_AddFixedPoint,
92	#endif
93	#ifdef GET_INTERPFN_LIST
94	&Interp_AddSint8,
95	&Interp_AddUint8,
96	&Interp_AddSint16,
97	&Interp_AddUint16,
98	&Interp_AddSint32,
99	&Interp_AddUint32,
100	&Interp_AddSint64,
101	&Interp_AddUint64,
102	&Interp_AddIntAP,
103	&Interp_AddIntAPS,
104	&Interp_AddBool,
105	&Interp_AddFixedPoint,
106	#endif
107	#ifdef GET_INTERPFN_DISPATCHERS
108	PRESERVE_NONE
109	static bool Interp_AddSint8(InterpState &S) {
110	if (!Add<PT_Sint8>(S, S.PC)) return false;
111	#if USE_TAILCALLS
112	MUSTTAIL return InterpNext(S);
113	#else
114	return true;
115	#endif
116	}
117	PRESERVE_NONE
118	static bool Interp_AddUint8(InterpState &S) {
119	if (!Add<PT_Uint8>(S, S.PC)) return false;
120	#if USE_TAILCALLS
121	MUSTTAIL return InterpNext(S);
122	#else
123	return true;
124	#endif
125	}
126	PRESERVE_NONE
127	static bool Interp_AddSint16(InterpState &S) {
128	if (!Add<PT_Sint16>(S, S.PC)) return false;
129	#if USE_TAILCALLS
130	MUSTTAIL return InterpNext(S);
131	#else
132	return true;
133	#endif
134	}
135	PRESERVE_NONE
136	static bool Interp_AddUint16(InterpState &S) {
137	if (!Add<PT_Uint16>(S, S.PC)) return false;
138	#if USE_TAILCALLS
139	MUSTTAIL return InterpNext(S);
140	#else
141	return true;
142	#endif
143	}
144	PRESERVE_NONE
145	static bool Interp_AddSint32(InterpState &S) {
146	if (!Add<PT_Sint32>(S, S.PC)) return false;
147	#if USE_TAILCALLS
148	MUSTTAIL return InterpNext(S);
149	#else
150	return true;
151	#endif
152	}
153	PRESERVE_NONE
154	static bool Interp_AddUint32(InterpState &S) {
155	if (!Add<PT_Uint32>(S, S.PC)) return false;
156	#if USE_TAILCALLS
157	MUSTTAIL return InterpNext(S);
158	#else
159	return true;
160	#endif
161	}
162	PRESERVE_NONE
163	static bool Interp_AddSint64(InterpState &S) {
164	if (!Add<PT_Sint64>(S, S.PC)) return false;
165	#if USE_TAILCALLS
166	MUSTTAIL return InterpNext(S);
167	#else
168	return true;
169	#endif
170	}
171	PRESERVE_NONE
172	static bool Interp_AddUint64(InterpState &S) {
173	if (!Add<PT_Uint64>(S, S.PC)) return false;
174	#if USE_TAILCALLS
175	MUSTTAIL return InterpNext(S);
176	#else
177	return true;
178	#endif
179	}
180	PRESERVE_NONE
181	static bool Interp_AddIntAP(InterpState &S) {
182	if (!Add<PT_IntAP>(S, S.PC)) return false;
183	#if USE_TAILCALLS
184	MUSTTAIL return InterpNext(S);
185	#else
186	return true;
187	#endif
188	}
189	PRESERVE_NONE
190	static bool Interp_AddIntAPS(InterpState &S) {
191	if (!Add<PT_IntAPS>(S, S.PC)) return false;
192	#if USE_TAILCALLS
193	MUSTTAIL return InterpNext(S);
194	#else
195	return true;
196	#endif
197	}
198	PRESERVE_NONE
199	static bool Interp_AddBool(InterpState &S) {
200	if (!Add<PT_Bool>(S, S.PC)) return false;
201	#if USE_TAILCALLS
202	MUSTTAIL return InterpNext(S);
203	#else
204	return true;
205	#endif
206	}
207	PRESERVE_NONE
208	static bool Interp_AddFixedPoint(InterpState &S) {
209	if (!Add<PT_FixedPoint>(S, S.PC)) return false;
210	#if USE_TAILCALLS
211	MUSTTAIL return InterpNext(S);
212	#else
213	return true;
214	#endif
215	}
216	#endif
217	#ifdef GET_DISASM
218	case OP_AddSint8:
219	Text.Op = PrintName("AddSint8");
220	break;
221	case OP_AddUint8:
222	Text.Op = PrintName("AddUint8");
223	break;
224	case OP_AddSint16:
225	Text.Op = PrintName("AddSint16");
226	break;
227	case OP_AddUint16:
228	Text.Op = PrintName("AddUint16");
229	break;
230	case OP_AddSint32:
231	Text.Op = PrintName("AddSint32");
232	break;
233	case OP_AddUint32:
234	Text.Op = PrintName("AddUint32");
235	break;
236	case OP_AddSint64:
237	Text.Op = PrintName("AddSint64");
238	break;
239	case OP_AddUint64:
240	Text.Op = PrintName("AddUint64");
241	break;
242	case OP_AddIntAP:
243	Text.Op = PrintName("AddIntAP");
244	break;
245	case OP_AddIntAPS:
246	Text.Op = PrintName("AddIntAPS");
247	break;
248	case OP_AddBool:
249	Text.Op = PrintName("AddBool");
250	break;
251	case OP_AddFixedPoint:
252	Text.Op = PrintName("AddFixedPoint");
253	break;
254	#endif
255	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
256	bool emitAddSint8(SourceInfo);
257	bool emitAddUint8(SourceInfo);
258	bool emitAddSint16(SourceInfo);
259	bool emitAddUint16(SourceInfo);
260	bool emitAddSint32(SourceInfo);
261	bool emitAddUint32(SourceInfo);
262	bool emitAddSint64(SourceInfo);
263	bool emitAddUint64(SourceInfo);
264	bool emitAddIntAP(SourceInfo);
265	bool emitAddIntAPS(SourceInfo);
266	bool emitAddBool(SourceInfo);
267	bool emitAddFixedPoint(SourceInfo);
268	#endif
269	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
270	[[nodiscard]] bool emitAdd(PrimType, SourceInfo I);
271	#endif
272	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
273	bool
274	#if defined(GET_EVAL_IMPL)
275	EvalEmitter
276	#else
277	ByteCodeEmitter
278	#endif
279	::emitAdd(PrimType T0, SourceInfo I) {
280	switch (T0) {
281	case PT_Sint8:
282	return emitAddSint8(I);
283	case PT_Uint8:
284	return emitAddUint8(I);
285	case PT_Sint16:
286	return emitAddSint16(I);
287	case PT_Uint16:
288	return emitAddUint16(I);
289	case PT_Sint32:
290	return emitAddSint32(I);
291	case PT_Uint32:
292	return emitAddUint32(I);
293	case PT_Sint64:
294	return emitAddSint64(I);
295	case PT_Uint64:
296	return emitAddUint64(I);
297	case PT_IntAP:
298	return emitAddIntAP(I);
299	case PT_IntAPS:
300	return emitAddIntAPS(I);
301	case PT_Bool:
302	return emitAddBool(I);
303	case PT_FixedPoint:
304	return emitAddFixedPoint(I);
305	default: llvm_unreachable("invalid type: emitAdd");
306	}
307	llvm_unreachable("invalid enum value");
308	}
309	#endif
310	#ifdef GET_LINK_IMPL
311	bool ByteCodeEmitter::emitAddSint8(SourceInfo L) {
312	return emitOp<>(OP_AddSint8, L);
313	}
314	bool ByteCodeEmitter::emitAddUint8(SourceInfo L) {
315	return emitOp<>(OP_AddUint8, L);
316	}
317	bool ByteCodeEmitter::emitAddSint16(SourceInfo L) {
318	return emitOp<>(OP_AddSint16, L);
319	}
320	bool ByteCodeEmitter::emitAddUint16(SourceInfo L) {
321	return emitOp<>(OP_AddUint16, L);
322	}
323	bool ByteCodeEmitter::emitAddSint32(SourceInfo L) {
324	return emitOp<>(OP_AddSint32, L);
325	}
326	bool ByteCodeEmitter::emitAddUint32(SourceInfo L) {
327	return emitOp<>(OP_AddUint32, L);
328	}
329	bool ByteCodeEmitter::emitAddSint64(SourceInfo L) {
330	return emitOp<>(OP_AddSint64, L);
331	}
332	bool ByteCodeEmitter::emitAddUint64(SourceInfo L) {
333	return emitOp<>(OP_AddUint64, L);
334	}
335	bool ByteCodeEmitter::emitAddIntAP(SourceInfo L) {
336	return emitOp<>(OP_AddIntAP, L);
337	}
338	bool ByteCodeEmitter::emitAddIntAPS(SourceInfo L) {
339	return emitOp<>(OP_AddIntAPS, L);
340	}
341	bool ByteCodeEmitter::emitAddBool(SourceInfo L) {
342	return emitOp<>(OP_AddBool, L);
343	}
344	bool ByteCodeEmitter::emitAddFixedPoint(SourceInfo L) {
345	return emitOp<>(OP_AddFixedPoint, L);
346	}
347	#endif
348	#ifdef GET_EVAL_IMPL
349	bool EvalEmitter::emitAddSint8(SourceInfo L) {
350	if (!isActive()) return true;
351	CurrentSource = L;
352	return Add<PT_Sint8>(S, CodePtr());
353	}
354	bool EvalEmitter::emitAddUint8(SourceInfo L) {
355	if (!isActive()) return true;
356	CurrentSource = L;
357	return Add<PT_Uint8>(S, CodePtr());
358	}
359	bool EvalEmitter::emitAddSint16(SourceInfo L) {
360	if (!isActive()) return true;
361	CurrentSource = L;
362	return Add<PT_Sint16>(S, CodePtr());
363	}
364	bool EvalEmitter::emitAddUint16(SourceInfo L) {
365	if (!isActive()) return true;
366	CurrentSource = L;
367	return Add<PT_Uint16>(S, CodePtr());
368	}
369	bool EvalEmitter::emitAddSint32(SourceInfo L) {
370	if (!isActive()) return true;
371	CurrentSource = L;
372	return Add<PT_Sint32>(S, CodePtr());
373	}
374	bool EvalEmitter::emitAddUint32(SourceInfo L) {
375	if (!isActive()) return true;
376	CurrentSource = L;
377	return Add<PT_Uint32>(S, CodePtr());
378	}
379	bool EvalEmitter::emitAddSint64(SourceInfo L) {
380	if (!isActive()) return true;
381	CurrentSource = L;
382	return Add<PT_Sint64>(S, CodePtr());
383	}
384	bool EvalEmitter::emitAddUint64(SourceInfo L) {
385	if (!isActive()) return true;
386	CurrentSource = L;
387	return Add<PT_Uint64>(S, CodePtr());
388	}
389	bool EvalEmitter::emitAddIntAP(SourceInfo L) {
390	if (!isActive()) return true;
391	CurrentSource = L;
392	return Add<PT_IntAP>(S, CodePtr());
393	}
394	bool EvalEmitter::emitAddIntAPS(SourceInfo L) {
395	if (!isActive()) return true;
396	CurrentSource = L;
397	return Add<PT_IntAPS>(S, CodePtr());
398	}
399	bool EvalEmitter::emitAddBool(SourceInfo L) {
400	if (!isActive()) return true;
401	CurrentSource = L;
402	return Add<PT_Bool>(S, CodePtr());
403	}
404	bool EvalEmitter::emitAddFixedPoint(SourceInfo L) {
405	if (!isActive()) return true;
406	CurrentSource = L;
407	return Add<PT_FixedPoint>(S, CodePtr());
408	}
409	#endif
410	#ifdef GET_OPCODE_NAMES
411	OP_AddOffsetSint8,
412	OP_AddOffsetUint8,
413	OP_AddOffsetSint16,
414	OP_AddOffsetUint16,
415	OP_AddOffsetSint32,
416	OP_AddOffsetUint32,
417	OP_AddOffsetSint64,
418	OP_AddOffsetUint64,
419	OP_AddOffsetIntAP,
420	OP_AddOffsetIntAPS,
421	OP_AddOffsetBool,
422	#endif
423	#ifdef GET_INTERPFN_LIST
424	&Interp_AddOffsetSint8,
425	&Interp_AddOffsetUint8,
426	&Interp_AddOffsetSint16,
427	&Interp_AddOffsetUint16,
428	&Interp_AddOffsetSint32,
429	&Interp_AddOffsetUint32,
430	&Interp_AddOffsetSint64,
431	&Interp_AddOffsetUint64,
432	&Interp_AddOffsetIntAP,
433	&Interp_AddOffsetIntAPS,
434	&Interp_AddOffsetBool,
435	#endif
436	#ifdef GET_INTERPFN_DISPATCHERS
437	PRESERVE_NONE
438	static bool Interp_AddOffsetSint8(InterpState &S) {
439	if (!AddOffset<PT_Sint8>(S, S.PC)) return false;
440	#if USE_TAILCALLS
441	MUSTTAIL return InterpNext(S);
442	#else
443	return true;
444	#endif
445	}
446	PRESERVE_NONE
447	static bool Interp_AddOffsetUint8(InterpState &S) {
448	if (!AddOffset<PT_Uint8>(S, S.PC)) return false;
449	#if USE_TAILCALLS
450	MUSTTAIL return InterpNext(S);
451	#else
452	return true;
453	#endif
454	}
455	PRESERVE_NONE
456	static bool Interp_AddOffsetSint16(InterpState &S) {
457	if (!AddOffset<PT_Sint16>(S, S.PC)) return false;
458	#if USE_TAILCALLS
459	MUSTTAIL return InterpNext(S);
460	#else
461	return true;
462	#endif
463	}
464	PRESERVE_NONE
465	static bool Interp_AddOffsetUint16(InterpState &S) {
466	if (!AddOffset<PT_Uint16>(S, S.PC)) return false;
467	#if USE_TAILCALLS
468	MUSTTAIL return InterpNext(S);
469	#else
470	return true;
471	#endif
472	}
473	PRESERVE_NONE
474	static bool Interp_AddOffsetSint32(InterpState &S) {
475	if (!AddOffset<PT_Sint32>(S, S.PC)) return false;
476	#if USE_TAILCALLS
477	MUSTTAIL return InterpNext(S);
478	#else
479	return true;
480	#endif
481	}
482	PRESERVE_NONE
483	static bool Interp_AddOffsetUint32(InterpState &S) {
484	if (!AddOffset<PT_Uint32>(S, S.PC)) return false;
485	#if USE_TAILCALLS
486	MUSTTAIL return InterpNext(S);
487	#else
488	return true;
489	#endif
490	}
491	PRESERVE_NONE
492	static bool Interp_AddOffsetSint64(InterpState &S) {
493	if (!AddOffset<PT_Sint64>(S, S.PC)) return false;
494	#if USE_TAILCALLS
495	MUSTTAIL return InterpNext(S);
496	#else
497	return true;
498	#endif
499	}
500	PRESERVE_NONE
501	static bool Interp_AddOffsetUint64(InterpState &S) {
502	if (!AddOffset<PT_Uint64>(S, S.PC)) return false;
503	#if USE_TAILCALLS
504	MUSTTAIL return InterpNext(S);
505	#else
506	return true;
507	#endif
508	}
509	PRESERVE_NONE
510	static bool Interp_AddOffsetIntAP(InterpState &S) {
511	if (!AddOffset<PT_IntAP>(S, S.PC)) return false;
512	#if USE_TAILCALLS
513	MUSTTAIL return InterpNext(S);
514	#else
515	return true;
516	#endif
517	}
518	PRESERVE_NONE
519	static bool Interp_AddOffsetIntAPS(InterpState &S) {
520	if (!AddOffset<PT_IntAPS>(S, S.PC)) return false;
521	#if USE_TAILCALLS
522	MUSTTAIL return InterpNext(S);
523	#else
524	return true;
525	#endif
526	}
527	PRESERVE_NONE
528	static bool Interp_AddOffsetBool(InterpState &S) {
529	if (!AddOffset<PT_Bool>(S, S.PC)) return false;
530	#if USE_TAILCALLS
531	MUSTTAIL return InterpNext(S);
532	#else
533	return true;
534	#endif
535	}
536	#endif
537	#ifdef GET_DISASM
538	case OP_AddOffsetSint8:
539	Text.Op = PrintName("AddOffsetSint8");
540	break;
541	case OP_AddOffsetUint8:
542	Text.Op = PrintName("AddOffsetUint8");
543	break;
544	case OP_AddOffsetSint16:
545	Text.Op = PrintName("AddOffsetSint16");
546	break;
547	case OP_AddOffsetUint16:
548	Text.Op = PrintName("AddOffsetUint16");
549	break;
550	case OP_AddOffsetSint32:
551	Text.Op = PrintName("AddOffsetSint32");
552	break;
553	case OP_AddOffsetUint32:
554	Text.Op = PrintName("AddOffsetUint32");
555	break;
556	case OP_AddOffsetSint64:
557	Text.Op = PrintName("AddOffsetSint64");
558	break;
559	case OP_AddOffsetUint64:
560	Text.Op = PrintName("AddOffsetUint64");
561	break;
562	case OP_AddOffsetIntAP:
563	Text.Op = PrintName("AddOffsetIntAP");
564	break;
565	case OP_AddOffsetIntAPS:
566	Text.Op = PrintName("AddOffsetIntAPS");
567	break;
568	case OP_AddOffsetBool:
569	Text.Op = PrintName("AddOffsetBool");
570	break;
571	#endif
572	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
573	bool emitAddOffsetSint8(SourceInfo);
574	bool emitAddOffsetUint8(SourceInfo);
575	bool emitAddOffsetSint16(SourceInfo);
576	bool emitAddOffsetUint16(SourceInfo);
577	bool emitAddOffsetSint32(SourceInfo);
578	bool emitAddOffsetUint32(SourceInfo);
579	bool emitAddOffsetSint64(SourceInfo);
580	bool emitAddOffsetUint64(SourceInfo);
581	bool emitAddOffsetIntAP(SourceInfo);
582	bool emitAddOffsetIntAPS(SourceInfo);
583	bool emitAddOffsetBool(SourceInfo);
584	#endif
585	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
586	[[nodiscard]] bool emitAddOffset(PrimType, SourceInfo I);
587	#endif
588	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
589	bool
590	#if defined(GET_EVAL_IMPL)
591	EvalEmitter
592	#else
593	ByteCodeEmitter
594	#endif
595	::emitAddOffset(PrimType T0, SourceInfo I) {
596	switch (T0) {
597	case PT_Sint8:
598	return emitAddOffsetSint8(I);
599	case PT_Uint8:
600	return emitAddOffsetUint8(I);
601	case PT_Sint16:
602	return emitAddOffsetSint16(I);
603	case PT_Uint16:
604	return emitAddOffsetUint16(I);
605	case PT_Sint32:
606	return emitAddOffsetSint32(I);
607	case PT_Uint32:
608	return emitAddOffsetUint32(I);
609	case PT_Sint64:
610	return emitAddOffsetSint64(I);
611	case PT_Uint64:
612	return emitAddOffsetUint64(I);
613	case PT_IntAP:
614	return emitAddOffsetIntAP(I);
615	case PT_IntAPS:
616	return emitAddOffsetIntAPS(I);
617	case PT_Bool:
618	return emitAddOffsetBool(I);
619	default: llvm_unreachable("invalid type: emitAddOffset");
620	}
621	llvm_unreachable("invalid enum value");
622	}
623	#endif
624	#ifdef GET_LINK_IMPL
625	bool ByteCodeEmitter::emitAddOffsetSint8(SourceInfo L) {
626	return emitOp<>(OP_AddOffsetSint8, L);
627	}
628	bool ByteCodeEmitter::emitAddOffsetUint8(SourceInfo L) {
629	return emitOp<>(OP_AddOffsetUint8, L);
630	}
631	bool ByteCodeEmitter::emitAddOffsetSint16(SourceInfo L) {
632	return emitOp<>(OP_AddOffsetSint16, L);
633	}
634	bool ByteCodeEmitter::emitAddOffsetUint16(SourceInfo L) {
635	return emitOp<>(OP_AddOffsetUint16, L);
636	}
637	bool ByteCodeEmitter::emitAddOffsetSint32(SourceInfo L) {
638	return emitOp<>(OP_AddOffsetSint32, L);
639	}
640	bool ByteCodeEmitter::emitAddOffsetUint32(SourceInfo L) {
641	return emitOp<>(OP_AddOffsetUint32, L);
642	}
643	bool ByteCodeEmitter::emitAddOffsetSint64(SourceInfo L) {
644	return emitOp<>(OP_AddOffsetSint64, L);
645	}
646	bool ByteCodeEmitter::emitAddOffsetUint64(SourceInfo L) {
647	return emitOp<>(OP_AddOffsetUint64, L);
648	}
649	bool ByteCodeEmitter::emitAddOffsetIntAP(SourceInfo L) {
650	return emitOp<>(OP_AddOffsetIntAP, L);
651	}
652	bool ByteCodeEmitter::emitAddOffsetIntAPS(SourceInfo L) {
653	return emitOp<>(OP_AddOffsetIntAPS, L);
654	}
655	bool ByteCodeEmitter::emitAddOffsetBool(SourceInfo L) {
656	return emitOp<>(OP_AddOffsetBool, L);
657	}
658	#endif
659	#ifdef GET_EVAL_IMPL
660	bool EvalEmitter::emitAddOffsetSint8(SourceInfo L) {
661	if (!isActive()) return true;
662	CurrentSource = L;
663	return AddOffset<PT_Sint8>(S, CodePtr());
664	}
665	bool EvalEmitter::emitAddOffsetUint8(SourceInfo L) {
666	if (!isActive()) return true;
667	CurrentSource = L;
668	return AddOffset<PT_Uint8>(S, CodePtr());
669	}
670	bool EvalEmitter::emitAddOffsetSint16(SourceInfo L) {
671	if (!isActive()) return true;
672	CurrentSource = L;
673	return AddOffset<PT_Sint16>(S, CodePtr());
674	}
675	bool EvalEmitter::emitAddOffsetUint16(SourceInfo L) {
676	if (!isActive()) return true;
677	CurrentSource = L;
678	return AddOffset<PT_Uint16>(S, CodePtr());
679	}
680	bool EvalEmitter::emitAddOffsetSint32(SourceInfo L) {
681	if (!isActive()) return true;
682	CurrentSource = L;
683	return AddOffset<PT_Sint32>(S, CodePtr());
684	}
685	bool EvalEmitter::emitAddOffsetUint32(SourceInfo L) {
686	if (!isActive()) return true;
687	CurrentSource = L;
688	return AddOffset<PT_Uint32>(S, CodePtr());
689	}
690	bool EvalEmitter::emitAddOffsetSint64(SourceInfo L) {
691	if (!isActive()) return true;
692	CurrentSource = L;
693	return AddOffset<PT_Sint64>(S, CodePtr());
694	}
695	bool EvalEmitter::emitAddOffsetUint64(SourceInfo L) {
696	if (!isActive()) return true;
697	CurrentSource = L;
698	return AddOffset<PT_Uint64>(S, CodePtr());
699	}
700	bool EvalEmitter::emitAddOffsetIntAP(SourceInfo L) {
701	if (!isActive()) return true;
702	CurrentSource = L;
703	return AddOffset<PT_IntAP>(S, CodePtr());
704	}
705	bool EvalEmitter::emitAddOffsetIntAPS(SourceInfo L) {
706	if (!isActive()) return true;
707	CurrentSource = L;
708	return AddOffset<PT_IntAPS>(S, CodePtr());
709	}
710	bool EvalEmitter::emitAddOffsetBool(SourceInfo L) {
711	if (!isActive()) return true;
712	CurrentSource = L;
713	return AddOffset<PT_Bool>(S, CodePtr());
714	}
715	#endif
716	#ifdef GET_OPCODE_NAMES
717	OP_Addf,
718	#endif
719	#ifdef GET_INTERPFN_LIST
720	&Interp_Addf,
721	#endif
722	#ifdef GET_INTERPFN_DISPATCHERS
723	PRESERVE_NONE
724	static bool Interp_Addf(InterpState &S) {
725	{
726	CodePtr OpPC = S.PC;
727	const auto V0 = ReadArg<uint32_t>(S, S.PC);
728	if (!Addf(S, OpPC, V0)) return false;
729	}
730	#if USE_TAILCALLS
731	MUSTTAIL return InterpNext(S);
732	#else
733	return true;
734	#endif
735	}
736	#endif
737	#ifdef GET_DISASM
738	case OP_Addf:
739	Text.Op = PrintName("Addf");
740	Text.Args.push_back(printArg<uint32_t>(P, PC));
741	break;
742	#endif
743	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
744	bool emitAddf( uint32_t , SourceInfo);
745	#endif
746	#ifdef GET_LINK_IMPL
747	bool ByteCodeEmitter::emitAddf( uint32_t A0, SourceInfo L) {
748	return emitOp<uint32_t>(OP_Addf, A0, L);
749	}
750	#endif
751	#ifdef GET_EVAL_IMPL
752	bool EvalEmitter::emitAddf( uint32_t A0, SourceInfo L) {
753	if (!isActive()) return true;
754	CurrentSource = L;
755	return Addf(S, CodePtr(), A0);
756	}
757	#endif
758	#ifdef GET_OPCODE_NAMES
759	OP_Alloc,
760	#endif
761	#ifdef GET_INTERPFN_LIST
762	&Interp_Alloc,
763	#endif
764	#ifdef GET_INTERPFN_DISPATCHERS
765	PRESERVE_NONE
766	static bool Interp_Alloc(InterpState &S) {
767	{
768	CodePtr OpPC = S.PC;
769	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
770	if (!Alloc(S, OpPC, V0)) return false;
771	}
772	#if USE_TAILCALLS
773	MUSTTAIL return InterpNext(S);
774	#else
775	return true;
776	#endif
777	}
778	#endif
779	#ifdef GET_DISASM
780	case OP_Alloc:
781	Text.Op = PrintName("Alloc");
782	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
783	break;
784	#endif
785	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
786	bool emitAlloc( const Descriptor * , SourceInfo);
787	#endif
788	#ifdef GET_LINK_IMPL
789	bool ByteCodeEmitter::emitAlloc( const Descriptor * A0, SourceInfo L) {
790	return emitOp<const Descriptor *>(OP_Alloc, A0, L);
791	}
792	#endif
793	#ifdef GET_EVAL_IMPL
794	bool EvalEmitter::emitAlloc( const Descriptor * A0, SourceInfo L) {
795	if (!isActive()) return true;
796	CurrentSource = L;
797	return Alloc(S, CodePtr(), A0);
798	}
799	#endif
800	#ifdef GET_OPCODE_NAMES
801	OP_AllocCNSint8,
802	OP_AllocCNUint8,
803	OP_AllocCNSint16,
804	OP_AllocCNUint16,
805	OP_AllocCNSint32,
806	OP_AllocCNUint32,
807	OP_AllocCNSint64,
808	OP_AllocCNUint64,
809	OP_AllocCNIntAP,
810	OP_AllocCNIntAPS,
811	OP_AllocCNBool,
812	#endif
813	#ifdef GET_INTERPFN_LIST
814	&Interp_AllocCNSint8,
815	&Interp_AllocCNUint8,
816	&Interp_AllocCNSint16,
817	&Interp_AllocCNUint16,
818	&Interp_AllocCNSint32,
819	&Interp_AllocCNUint32,
820	&Interp_AllocCNSint64,
821	&Interp_AllocCNUint64,
822	&Interp_AllocCNIntAP,
823	&Interp_AllocCNIntAPS,
824	&Interp_AllocCNBool,
825	#endif
826	#ifdef GET_INTERPFN_DISPATCHERS
827	PRESERVE_NONE
828	static bool Interp_AllocCNSint8(InterpState &S) {
829	{
830	CodePtr OpPC = S.PC;
831	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
832	const auto V1 = ReadArg<bool>(S, S.PC);
833	if (!AllocCN<PT_Sint8>(S, OpPC, V0, V1)) return false;
834	}
835	#if USE_TAILCALLS
836	MUSTTAIL return InterpNext(S);
837	#else
838	return true;
839	#endif
840	}
841	PRESERVE_NONE
842	static bool Interp_AllocCNUint8(InterpState &S) {
843	{
844	CodePtr OpPC = S.PC;
845	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
846	const auto V1 = ReadArg<bool>(S, S.PC);
847	if (!AllocCN<PT_Uint8>(S, OpPC, V0, V1)) return false;
848	}
849	#if USE_TAILCALLS
850	MUSTTAIL return InterpNext(S);
851	#else
852	return true;
853	#endif
854	}
855	PRESERVE_NONE
856	static bool Interp_AllocCNSint16(InterpState &S) {
857	{
858	CodePtr OpPC = S.PC;
859	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
860	const auto V1 = ReadArg<bool>(S, S.PC);
861	if (!AllocCN<PT_Sint16>(S, OpPC, V0, V1)) return false;
862	}
863	#if USE_TAILCALLS
864	MUSTTAIL return InterpNext(S);
865	#else
866	return true;
867	#endif
868	}
869	PRESERVE_NONE
870	static bool Interp_AllocCNUint16(InterpState &S) {
871	{
872	CodePtr OpPC = S.PC;
873	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
874	const auto V1 = ReadArg<bool>(S, S.PC);
875	if (!AllocCN<PT_Uint16>(S, OpPC, V0, V1)) return false;
876	}
877	#if USE_TAILCALLS
878	MUSTTAIL return InterpNext(S);
879	#else
880	return true;
881	#endif
882	}
883	PRESERVE_NONE
884	static bool Interp_AllocCNSint32(InterpState &S) {
885	{
886	CodePtr OpPC = S.PC;
887	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
888	const auto V1 = ReadArg<bool>(S, S.PC);
889	if (!AllocCN<PT_Sint32>(S, OpPC, V0, V1)) return false;
890	}
891	#if USE_TAILCALLS
892	MUSTTAIL return InterpNext(S);
893	#else
894	return true;
895	#endif
896	}
897	PRESERVE_NONE
898	static bool Interp_AllocCNUint32(InterpState &S) {
899	{
900	CodePtr OpPC = S.PC;
901	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
902	const auto V1 = ReadArg<bool>(S, S.PC);
903	if (!AllocCN<PT_Uint32>(S, OpPC, V0, V1)) return false;
904	}
905	#if USE_TAILCALLS
906	MUSTTAIL return InterpNext(S);
907	#else
908	return true;
909	#endif
910	}
911	PRESERVE_NONE
912	static bool Interp_AllocCNSint64(InterpState &S) {
913	{
914	CodePtr OpPC = S.PC;
915	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
916	const auto V1 = ReadArg<bool>(S, S.PC);
917	if (!AllocCN<PT_Sint64>(S, OpPC, V0, V1)) return false;
918	}
919	#if USE_TAILCALLS
920	MUSTTAIL return InterpNext(S);
921	#else
922	return true;
923	#endif
924	}
925	PRESERVE_NONE
926	static bool Interp_AllocCNUint64(InterpState &S) {
927	{
928	CodePtr OpPC = S.PC;
929	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
930	const auto V1 = ReadArg<bool>(S, S.PC);
931	if (!AllocCN<PT_Uint64>(S, OpPC, V0, V1)) return false;
932	}
933	#if USE_TAILCALLS
934	MUSTTAIL return InterpNext(S);
935	#else
936	return true;
937	#endif
938	}
939	PRESERVE_NONE
940	static bool Interp_AllocCNIntAP(InterpState &S) {
941	{
942	CodePtr OpPC = S.PC;
943	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
944	const auto V1 = ReadArg<bool>(S, S.PC);
945	if (!AllocCN<PT_IntAP>(S, OpPC, V0, V1)) return false;
946	}
947	#if USE_TAILCALLS
948	MUSTTAIL return InterpNext(S);
949	#else
950	return true;
951	#endif
952	}
953	PRESERVE_NONE
954	static bool Interp_AllocCNIntAPS(InterpState &S) {
955	{
956	CodePtr OpPC = S.PC;
957	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
958	const auto V1 = ReadArg<bool>(S, S.PC);
959	if (!AllocCN<PT_IntAPS>(S, OpPC, V0, V1)) return false;
960	}
961	#if USE_TAILCALLS
962	MUSTTAIL return InterpNext(S);
963	#else
964	return true;
965	#endif
966	}
967	PRESERVE_NONE
968	static bool Interp_AllocCNBool(InterpState &S) {
969	{
970	CodePtr OpPC = S.PC;
971	const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
972	const auto V1 = ReadArg<bool>(S, S.PC);
973	if (!AllocCN<PT_Bool>(S, OpPC, V0, V1)) return false;
974	}
975	#if USE_TAILCALLS
976	MUSTTAIL return InterpNext(S);
977	#else
978	return true;
979	#endif
980	}
981	#endif
982	#ifdef GET_DISASM
983	case OP_AllocCNSint8:
984	Text.Op = PrintName("AllocCNSint8");
985	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
986	Text.Args.push_back(printArg<bool>(P, PC));
987	break;
988	case OP_AllocCNUint8:
989	Text.Op = PrintName("AllocCNUint8");
990	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
991	Text.Args.push_back(printArg<bool>(P, PC));
992	break;
993	case OP_AllocCNSint16:
994	Text.Op = PrintName("AllocCNSint16");
995	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
996	Text.Args.push_back(printArg<bool>(P, PC));
997	break;
998	case OP_AllocCNUint16:
999	Text.Op = PrintName("AllocCNUint16");
1000	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1001	Text.Args.push_back(printArg<bool>(P, PC));
1002	break;
1003	case OP_AllocCNSint32:
1004	Text.Op = PrintName("AllocCNSint32");
1005	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1006	Text.Args.push_back(printArg<bool>(P, PC));
1007	break;
1008	case OP_AllocCNUint32:
1009	Text.Op = PrintName("AllocCNUint32");
1010	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1011	Text.Args.push_back(printArg<bool>(P, PC));
1012	break;
1013	case OP_AllocCNSint64:
1014	Text.Op = PrintName("AllocCNSint64");
1015	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1016	Text.Args.push_back(printArg<bool>(P, PC));
1017	break;
1018	case OP_AllocCNUint64:
1019	Text.Op = PrintName("AllocCNUint64");
1020	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1021	Text.Args.push_back(printArg<bool>(P, PC));
1022	break;
1023	case OP_AllocCNIntAP:
1024	Text.Op = PrintName("AllocCNIntAP");
1025	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1026	Text.Args.push_back(printArg<bool>(P, PC));
1027	break;
1028	case OP_AllocCNIntAPS:
1029	Text.Op = PrintName("AllocCNIntAPS");
1030	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1031	Text.Args.push_back(printArg<bool>(P, PC));
1032	break;
1033	case OP_AllocCNBool:
1034	Text.Op = PrintName("AllocCNBool");
1035	Text.Args.push_back(printArg<const Descriptor *>(P, PC));
1036	Text.Args.push_back(printArg<bool>(P, PC));
1037	break;
1038	#endif
1039	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1040	bool emitAllocCNSint8( const Descriptor * , bool , SourceInfo);
1041	bool emitAllocCNUint8( const Descriptor * , bool , SourceInfo);
1042	bool emitAllocCNSint16( const Descriptor * , bool , SourceInfo);
1043	bool emitAllocCNUint16( const Descriptor * , bool , SourceInfo);
1044	bool emitAllocCNSint32( const Descriptor * , bool , SourceInfo);
1045	bool emitAllocCNUint32( const Descriptor * , bool , SourceInfo);
1046	bool emitAllocCNSint64( const Descriptor * , bool , SourceInfo);
1047	bool emitAllocCNUint64( const Descriptor * , bool , SourceInfo);
1048	bool emitAllocCNIntAP( const Descriptor * , bool , SourceInfo);
1049	bool emitAllocCNIntAPS( const Descriptor * , bool , SourceInfo);
1050	bool emitAllocCNBool( const Descriptor * , bool , SourceInfo);
1051	#endif
1052	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1053	[[nodiscard]] bool emitAllocCN(PrimType, const Descriptor , bool*, SourceInfo I);
1054	#endif
1055	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
1056	bool
1057	#if defined(GET_EVAL_IMPL)
1058	EvalEmitter
1059	#else
1060	ByteCodeEmitter
1061	#endif
1062	::emitAllocCN(PrimType T0, const Descriptor * A0, bool A1, SourceInfo I) {
1063	switch (T0) {
1064	case PT_Sint8:
1065	return emitAllocCNSint8(A0, A1, I);
1066	case PT_Uint8:
1067	return emitAllocCNUint8(A0, A1, I);
1068	case PT_Sint16:
1069	return emitAllocCNSint16(A0, A1, I);
1070	case PT_Uint16:
1071	return emitAllocCNUint16(A0, A1, I);
1072	case PT_Sint32:
1073	return emitAllocCNSint32(A0, A1, I);
1074	case PT_Uint32:
1075	return emitAllocCNUint32(A0, A1, I);
1076	case PT_Sint64:
1077	return emitAllocCNSint64(A0, A1, I);
1078	case PT_Uint64:
1079	return emitAllocCNUint64(A0, A1, I);
1080	case PT_IntAP:
1081	return emitAllocCNIntAP(A0, A1, I);
1082	case PT_IntAPS:
1083	return emitAllocCNIntAPS(A0, A1, I);
1084	case PT_Bool:
1085	return emitAllocCNBool(A0, A1, I);
1086	default: llvm_unreachable("invalid type: emitAllocCN");
1087	}
1088	llvm_unreachable("invalid enum value");
1089	}
1090	#endif
1091	#ifdef GET_LINK_IMPL
1092	bool ByteCodeEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, SourceInfo L) {
1093	return emitOp<const Descriptor , bool*>(OP_AllocCNSint8, A0, A1, L);
1094	}
1095	bool ByteCodeEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, SourceInfo L) {
1096	return emitOp<const Descriptor , bool*>(OP_AllocCNUint8, A0, A1, L);
1097	}
1098	bool ByteCodeEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, SourceInfo L) {
1099	return emitOp<const Descriptor , bool*>(OP_AllocCNSint16, A0, A1, L);
1100	}
1101	bool ByteCodeEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, SourceInfo L) {
1102	return emitOp<const Descriptor , bool*>(OP_AllocCNUint16, A0, A1, L);
1103	}
1104	bool ByteCodeEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, SourceInfo L) {
1105	return emitOp<const Descriptor , bool*>(OP_AllocCNSint32, A0, A1, L);
1106	}
1107	bool ByteCodeEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, SourceInfo L) {
1108	return emitOp<const Descriptor , bool*>(OP_AllocCNUint32, A0, A1, L);
1109	}
1110	bool ByteCodeEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, SourceInfo L) {
1111	return emitOp<const Descriptor , bool*>(OP_AllocCNSint64, A0, A1, L);
1112	}
1113	bool ByteCodeEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, SourceInfo L) {
1114	return emitOp<const Descriptor , bool*>(OP_AllocCNUint64, A0, A1, L);
1115	}
1116	bool ByteCodeEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, SourceInfo L) {
1117	return emitOp<const Descriptor , bool*>(OP_AllocCNIntAP, A0, A1, L);
1118	}
1119	bool ByteCodeEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, SourceInfo L) {
1120	return emitOp<const Descriptor , bool*>(OP_AllocCNIntAPS, A0, A1, L);
1121	}
1122	bool ByteCodeEmitter::emitAllocCNBool( const Descriptor * A0, bool A1, SourceInfo L) {
1123	return emitOp<const Descriptor , bool*>(OP_AllocCNBool, A0, A1, L);
1124	}
1125	#endif
1126	#ifdef GET_EVAL_IMPL
1127	bool EvalEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, SourceInfo L) {
1128	if (!isActive()) return true;
1129	CurrentSource = L;
1130	return AllocCN<PT_Sint8>(S, CodePtr(), A0, A1);
1131	}
1132	bool EvalEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, SourceInfo L) {
1133	if (!isActive()) return true;
1134	CurrentSource = L;
1135	return AllocCN<PT_Uint8>(S, CodePtr(), A0, A1);
1136	}
1137	bool EvalEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, SourceInfo L) {
1138	if (!isActive()) return true;
1139	CurrentSource = L;
1140	return AllocCN<PT_Sint16>(S, CodePtr(), A0, A1);
1141	}
1142	bool EvalEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, SourceInfo L) {
1143	if (!isActive()) return true;
1144	CurrentSource = L;
1145	return AllocCN<PT_Uint16>(S, CodePtr(), A0, A1);
1146	}
1147	bool EvalEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, SourceInfo L) {
1148	if (!isActive()) return true;
1149	CurrentSource = L;
1150	return AllocCN<PT_Sint32>(S, CodePtr(), A0, A1);
1151	}
1152	bool EvalEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, SourceInfo L) {
1153	if (!isActive()) return true;
1154	CurrentSource = L;
1155	return AllocCN<PT_Uint32>(S, CodePtr(), A0, A1);
1156	}
1157	bool EvalEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, SourceInfo L) {
1158	if (!isActive()) return true;
1159	CurrentSource = L;
1160	return AllocCN<PT_Sint64>(S, CodePtr(), A0, A1);
1161	}
1162	bool EvalEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, SourceInfo L) {
1163	if (!isActive()) return true;
1164	CurrentSource = L;
1165	return AllocCN<PT_Uint64>(S, CodePtr(), A0, A1);
1166	}
1167	bool EvalEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, SourceInfo L) {
1168	if (!isActive()) return true;
1169	CurrentSource = L;
1170	return AllocCN<PT_IntAP>(S, CodePtr(), A0, A1);
1171	}
1172	bool EvalEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, SourceInfo L) {
1173	if (!isActive()) return true;
1174	CurrentSource = L;
1175	return AllocCN<PT_IntAPS>(S, CodePtr(), A0, A1);
1176	}
1177	bool EvalEmitter::emitAllocCNBool( const Descriptor * A0, bool A1, SourceInfo L) {
1178	if (!isActive()) return true;
1179	CurrentSource = L;
1180	return AllocCN<PT_Bool>(S, CodePtr(), A0, A1);
1181	}
1182	#endif
1183	#ifdef GET_OPCODE_NAMES
1184	OP_AllocNSint8,
1185	OP_AllocNUint8,
1186	OP_AllocNSint16,
1187	OP_AllocNUint16,
1188	OP_AllocNSint32,
1189	OP_AllocNUint32,
1190	OP_AllocNSint64,
1191	OP_AllocNUint64,
1192	OP_AllocNIntAP,
1193	OP_AllocNIntAPS,
1194	OP_AllocNBool,
1195	#endif
1196	#ifdef GET_INTERPFN_LIST
1197	&Interp_AllocNSint8,
1198	&Interp_AllocNUint8,
1199	&Interp_AllocNSint16,
1200	&Interp_AllocNUint16,
1201	&Interp_AllocNSint32,
1202	&Interp_AllocNUint32,
1203	&Interp_AllocNSint64,
1204	&Interp_AllocNUint64,
1205	&Interp_AllocNIntAP,
1206	&Interp_AllocNIntAPS,
1207	&Interp_AllocNBool,
1208	#endif
1209	#ifdef GET_INTERPFN_DISPATCHERS
1210	PRESERVE_NONE
1211	static bool Interp_AllocNSint8(InterpState &S) {
1212	{
1213	CodePtr OpPC = S.PC;
1214	const auto V0 = ReadArg<PrimType>(S, S.PC);
1215	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1216	const auto V2 = ReadArg<bool>(S, S.PC);
1217	if (!AllocN<PT_Sint8>(S, OpPC, V0, V1, V2)) return false;
1218	}
1219	#if USE_TAILCALLS
1220	MUSTTAIL return InterpNext(S);
1221	#else
1222	return true;
1223	#endif
1224	}
1225	PRESERVE_NONE
1226	static bool Interp_AllocNUint8(InterpState &S) {
1227	{
1228	CodePtr OpPC = S.PC;
1229	const auto V0 = ReadArg<PrimType>(S, S.PC);
1230	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1231	const auto V2 = ReadArg<bool>(S, S.PC);
1232	if (!AllocN<PT_Uint8>(S, OpPC, V0, V1, V2)) return false;
1233	}
1234	#if USE_TAILCALLS
1235	MUSTTAIL return InterpNext(S);
1236	#else
1237	return true;
1238	#endif
1239	}
1240	PRESERVE_NONE
1241	static bool Interp_AllocNSint16(InterpState &S) {
1242	{
1243	CodePtr OpPC = S.PC;
1244	const auto V0 = ReadArg<PrimType>(S, S.PC);
1245	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1246	const auto V2 = ReadArg<bool>(S, S.PC);
1247	if (!AllocN<PT_Sint16>(S, OpPC, V0, V1, V2)) return false;
1248	}
1249	#if USE_TAILCALLS
1250	MUSTTAIL return InterpNext(S);
1251	#else
1252	return true;
1253	#endif
1254	}
1255	PRESERVE_NONE
1256	static bool Interp_AllocNUint16(InterpState &S) {
1257	{
1258	CodePtr OpPC = S.PC;
1259	const auto V0 = ReadArg<PrimType>(S, S.PC);
1260	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1261	const auto V2 = ReadArg<bool>(S, S.PC);
1262	if (!AllocN<PT_Uint16>(S, OpPC, V0, V1, V2)) return false;
1263	}
1264	#if USE_TAILCALLS
1265	MUSTTAIL return InterpNext(S);
1266	#else
1267	return true;
1268	#endif
1269	}
1270	PRESERVE_NONE
1271	static bool Interp_AllocNSint32(InterpState &S) {
1272	{
1273	CodePtr OpPC = S.PC;
1274	const auto V0 = ReadArg<PrimType>(S, S.PC);
1275	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1276	const auto V2 = ReadArg<bool>(S, S.PC);
1277	if (!AllocN<PT_Sint32>(S, OpPC, V0, V1, V2)) return false;
1278	}
1279	#if USE_TAILCALLS
1280	MUSTTAIL return InterpNext(S);
1281	#else
1282	return true;
1283	#endif
1284	}
1285	PRESERVE_NONE
1286	static bool Interp_AllocNUint32(InterpState &S) {
1287	{
1288	CodePtr OpPC = S.PC;
1289	const auto V0 = ReadArg<PrimType>(S, S.PC);
1290	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1291	const auto V2 = ReadArg<bool>(S, S.PC);
1292	if (!AllocN<PT_Uint32>(S, OpPC, V0, V1, V2)) return false;
1293	}
1294	#if USE_TAILCALLS
1295	MUSTTAIL return InterpNext(S);
1296	#else
1297	return true;
1298	#endif
1299	}
1300	PRESERVE_NONE
1301	static bool Interp_AllocNSint64(InterpState &S) {
1302	{
1303	CodePtr OpPC = S.PC;
1304	const auto V0 = ReadArg<PrimType>(S, S.PC);
1305	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1306	const auto V2 = ReadArg<bool>(S, S.PC);
1307	if (!AllocN<PT_Sint64>(S, OpPC, V0, V1, V2)) return false;
1308	}
1309	#if USE_TAILCALLS
1310	MUSTTAIL return InterpNext(S);
1311	#else
1312	return true;
1313	#endif
1314	}
1315	PRESERVE_NONE
1316	static bool Interp_AllocNUint64(InterpState &S) {
1317	{
1318	CodePtr OpPC = S.PC;
1319	const auto V0 = ReadArg<PrimType>(S, S.PC);
1320	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1321	const auto V2 = ReadArg<bool>(S, S.PC);
1322	if (!AllocN<PT_Uint64>(S, OpPC, V0, V1, V2)) return false;
1323	}
1324	#if USE_TAILCALLS
1325	MUSTTAIL return InterpNext(S);
1326	#else
1327	return true;
1328	#endif
1329	}
1330	PRESERVE_NONE
1331	static bool Interp_AllocNIntAP(InterpState &S) {
1332	{
1333	CodePtr OpPC = S.PC;
1334	const auto V0 = ReadArg<PrimType>(S, S.PC);
1335	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1336	const auto V2 = ReadArg<bool>(S, S.PC);
1337	if (!AllocN<PT_IntAP>(S, OpPC, V0, V1, V2)) return false;
1338	}
1339	#if USE_TAILCALLS
1340	MUSTTAIL return InterpNext(S);
1341	#else
1342	return true;
1343	#endif
1344	}
1345	PRESERVE_NONE
1346	static bool Interp_AllocNIntAPS(InterpState &S) {
1347	{
1348	CodePtr OpPC = S.PC;
1349	const auto V0 = ReadArg<PrimType>(S, S.PC);
1350	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1351	const auto V2 = ReadArg<bool>(S, S.PC);
1352	if (!AllocN<PT_IntAPS>(S, OpPC, V0, V1, V2)) return false;
1353	}
1354	#if USE_TAILCALLS
1355	MUSTTAIL return InterpNext(S);
1356	#else
1357	return true;
1358	#endif
1359	}
1360	PRESERVE_NONE
1361	static bool Interp_AllocNBool(InterpState &S) {
1362	{
1363	CodePtr OpPC = S.PC;
1364	const auto V0 = ReadArg<PrimType>(S, S.PC);
1365	const auto V1 = ReadArg<const Expr *>(S, S.PC);
1366	const auto V2 = ReadArg<bool>(S, S.PC);
1367	if (!AllocN<PT_Bool>(S, OpPC, V0, V1, V2)) return false;
1368	}
1369	#if USE_TAILCALLS
1370	MUSTTAIL return InterpNext(S);
1371	#else
1372	return true;
1373	#endif
1374	}
1375	#endif
1376	#ifdef GET_DISASM
1377	case OP_AllocNSint8:
1378	Text.Op = PrintName("AllocNSint8");
1379	Text.Args.push_back(printArg<PrimType>(P, PC));
1380	Text.Args.push_back(printArg<const Expr *>(P, PC));
1381	Text.Args.push_back(printArg<bool>(P, PC));
1382	break;
1383	case OP_AllocNUint8:
1384	Text.Op = PrintName("AllocNUint8");
1385	Text.Args.push_back(printArg<PrimType>(P, PC));
1386	Text.Args.push_back(printArg<const Expr *>(P, PC));
1387	Text.Args.push_back(printArg<bool>(P, PC));
1388	break;
1389	case OP_AllocNSint16:
1390	Text.Op = PrintName("AllocNSint16");
1391	Text.Args.push_back(printArg<PrimType>(P, PC));
1392	Text.Args.push_back(printArg<const Expr *>(P, PC));
1393	Text.Args.push_back(printArg<bool>(P, PC));
1394	break;
1395	case OP_AllocNUint16:
1396	Text.Op = PrintName("AllocNUint16");
1397	Text.Args.push_back(printArg<PrimType>(P, PC));
1398	Text.Args.push_back(printArg<const Expr *>(P, PC));
1399	Text.Args.push_back(printArg<bool>(P, PC));
1400	break;
1401	case OP_AllocNSint32:
1402	Text.Op = PrintName("AllocNSint32");
1403	Text.Args.push_back(printArg<PrimType>(P, PC));
1404	Text.Args.push_back(printArg<const Expr *>(P, PC));
1405	Text.Args.push_back(printArg<bool>(P, PC));
1406	break;
1407	case OP_AllocNUint32:
1408	Text.Op = PrintName("AllocNUint32");
1409	Text.Args.push_back(printArg<PrimType>(P, PC));
1410	Text.Args.push_back(printArg<const Expr *>(P, PC));
1411	Text.Args.push_back(printArg<bool>(P, PC));
1412	break;
1413	case OP_AllocNSint64:
1414	Text.Op = PrintName("AllocNSint64");
1415	Text.Args.push_back(printArg<PrimType>(P, PC));
1416	Text.Args.push_back(printArg<const Expr *>(P, PC));
1417	Text.Args.push_back(printArg<bool>(P, PC));
1418	break;
1419	case OP_AllocNUint64:
1420	Text.Op = PrintName("AllocNUint64");
1421	Text.Args.push_back(printArg<PrimType>(P, PC));
1422	Text.Args.push_back(printArg<const Expr *>(P, PC));
1423	Text.Args.push_back(printArg<bool>(P, PC));
1424	break;
1425	case OP_AllocNIntAP:
1426	Text.Op = PrintName("AllocNIntAP");
1427	Text.Args.push_back(printArg<PrimType>(P, PC));
1428	Text.Args.push_back(printArg<const Expr *>(P, PC));
1429	Text.Args.push_back(printArg<bool>(P, PC));
1430	break;
1431	case OP_AllocNIntAPS:
1432	Text.Op = PrintName("AllocNIntAPS");
1433	Text.Args.push_back(printArg<PrimType>(P, PC));
1434	Text.Args.push_back(printArg<const Expr *>(P, PC));
1435	Text.Args.push_back(printArg<bool>(P, PC));
1436	break;
1437	case OP_AllocNBool:
1438	Text.Op = PrintName("AllocNBool");
1439	Text.Args.push_back(printArg<PrimType>(P, PC));
1440	Text.Args.push_back(printArg<const Expr *>(P, PC));
1441	Text.Args.push_back(printArg<bool>(P, PC));
1442	break;
1443	#endif
1444	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1445	bool emitAllocNSint8( PrimType , const Expr * , bool , SourceInfo);
1446	bool emitAllocNUint8( PrimType , const Expr * , bool , SourceInfo);
1447	bool emitAllocNSint16( PrimType , const Expr * , bool , SourceInfo);
1448	bool emitAllocNUint16( PrimType , const Expr * , bool , SourceInfo);
1449	bool emitAllocNSint32( PrimType , const Expr * , bool , SourceInfo);
1450	bool emitAllocNUint32( PrimType , const Expr * , bool , SourceInfo);
1451	bool emitAllocNSint64( PrimType , const Expr * , bool , SourceInfo);
1452	bool emitAllocNUint64( PrimType , const Expr * , bool , SourceInfo);
1453	bool emitAllocNIntAP( PrimType , const Expr * , bool , SourceInfo);
1454	bool emitAllocNIntAPS( PrimType , const Expr * , bool , SourceInfo);
1455	bool emitAllocNBool( PrimType , const Expr * , bool , SourceInfo);
1456	#endif
1457	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1458	[[nodiscard]] bool emitAllocN(PrimType, PrimType, const Expr , bool*, SourceInfo I);
1459	#endif
1460	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
1461	bool
1462	#if defined(GET_EVAL_IMPL)
1463	EvalEmitter
1464	#else
1465	ByteCodeEmitter
1466	#endif
1467	::emitAllocN(PrimType T0, PrimType A0, const Expr * A1, bool A2, SourceInfo I) {
1468	switch (T0) {
1469	case PT_Sint8:
1470	return emitAllocNSint8(A0, A1, A2, I);
1471	case PT_Uint8:
1472	return emitAllocNUint8(A0, A1, A2, I);
1473	case PT_Sint16:
1474	return emitAllocNSint16(A0, A1, A2, I);
1475	case PT_Uint16:
1476	return emitAllocNUint16(A0, A1, A2, I);
1477	case PT_Sint32:
1478	return emitAllocNSint32(A0, A1, A2, I);
1479	case PT_Uint32:
1480	return emitAllocNUint32(A0, A1, A2, I);
1481	case PT_Sint64:
1482	return emitAllocNSint64(A0, A1, A2, I);
1483	case PT_Uint64:
1484	return emitAllocNUint64(A0, A1, A2, I);
1485	case PT_IntAP:
1486	return emitAllocNIntAP(A0, A1, A2, I);
1487	case PT_IntAPS:
1488	return emitAllocNIntAPS(A0, A1, A2, I);
1489	case PT_Bool:
1490	return emitAllocNBool(A0, A1, A2, I);
1491	default: llvm_unreachable("invalid type: emitAllocN");
1492	}
1493	llvm_unreachable("invalid enum value");
1494	}
1495	#endif
1496	#ifdef GET_LINK_IMPL
1497	bool ByteCodeEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1498	return emitOp<PrimType, const Expr , bool*>(OP_AllocNSint8, A0, A1, A2, L);
1499	}
1500	bool ByteCodeEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1501	return emitOp<PrimType, const Expr , bool*>(OP_AllocNUint8, A0, A1, A2, L);
1502	}
1503	bool ByteCodeEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1504	return emitOp<PrimType, const Expr , bool*>(OP_AllocNSint16, A0, A1, A2, L);
1505	}
1506	bool ByteCodeEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1507	return emitOp<PrimType, const Expr , bool*>(OP_AllocNUint16, A0, A1, A2, L);
1508	}
1509	bool ByteCodeEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1510	return emitOp<PrimType, const Expr , bool*>(OP_AllocNSint32, A0, A1, A2, L);
1511	}
1512	bool ByteCodeEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1513	return emitOp<PrimType, const Expr , bool*>(OP_AllocNUint32, A0, A1, A2, L);
1514	}
1515	bool ByteCodeEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1516	return emitOp<PrimType, const Expr , bool*>(OP_AllocNSint64, A0, A1, A2, L);
1517	}
1518	bool ByteCodeEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1519	return emitOp<PrimType, const Expr , bool*>(OP_AllocNUint64, A0, A1, A2, L);
1520	}
1521	bool ByteCodeEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1522	return emitOp<PrimType, const Expr , bool*>(OP_AllocNIntAP, A0, A1, A2, L);
1523	}
1524	bool ByteCodeEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1525	return emitOp<PrimType, const Expr , bool*>(OP_AllocNIntAPS, A0, A1, A2, L);
1526	}
1527	bool ByteCodeEmitter::emitAllocNBool( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1528	return emitOp<PrimType, const Expr , bool*>(OP_AllocNBool, A0, A1, A2, L);
1529	}
1530	#endif
1531	#ifdef GET_EVAL_IMPL
1532	bool EvalEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1533	if (!isActive()) return true;
1534	CurrentSource = L;
1535	return AllocN<PT_Sint8>(S, CodePtr(), A0, A1, A2);
1536	}
1537	bool EvalEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1538	if (!isActive()) return true;
1539	CurrentSource = L;
1540	return AllocN<PT_Uint8>(S, CodePtr(), A0, A1, A2);
1541	}
1542	bool EvalEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1543	if (!isActive()) return true;
1544	CurrentSource = L;
1545	return AllocN<PT_Sint16>(S, CodePtr(), A0, A1, A2);
1546	}
1547	bool EvalEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1548	if (!isActive()) return true;
1549	CurrentSource = L;
1550	return AllocN<PT_Uint16>(S, CodePtr(), A0, A1, A2);
1551	}
1552	bool EvalEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1553	if (!isActive()) return true;
1554	CurrentSource = L;
1555	return AllocN<PT_Sint32>(S, CodePtr(), A0, A1, A2);
1556	}
1557	bool EvalEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1558	if (!isActive()) return true;
1559	CurrentSource = L;
1560	return AllocN<PT_Uint32>(S, CodePtr(), A0, A1, A2);
1561	}
1562	bool EvalEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1563	if (!isActive()) return true;
1564	CurrentSource = L;
1565	return AllocN<PT_Sint64>(S, CodePtr(), A0, A1, A2);
1566	}
1567	bool EvalEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1568	if (!isActive()) return true;
1569	CurrentSource = L;
1570	return AllocN<PT_Uint64>(S, CodePtr(), A0, A1, A2);
1571	}
1572	bool EvalEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1573	if (!isActive()) return true;
1574	CurrentSource = L;
1575	return AllocN<PT_IntAP>(S, CodePtr(), A0, A1, A2);
1576	}
1577	bool EvalEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1578	if (!isActive()) return true;
1579	CurrentSource = L;
1580	return AllocN<PT_IntAPS>(S, CodePtr(), A0, A1, A2);
1581	}
1582	bool EvalEmitter::emitAllocNBool( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1583	if (!isActive()) return true;
1584	CurrentSource = L;
1585	return AllocN<PT_Bool>(S, CodePtr(), A0, A1, A2);
1586	}
1587	#endif
1588	#ifdef GET_OPCODE_NAMES
1589	OP_ArrayDecay,
1590	#endif
1591	#ifdef GET_INTERPFN_LIST
1592	&Interp_ArrayDecay,
1593	#endif
1594	#ifdef GET_INTERPFN_DISPATCHERS
1595	PRESERVE_NONE
1596	static bool Interp_ArrayDecay(InterpState &S) {
1597	if (!ArrayDecay(S, S.PC)) return false;
1598	#if USE_TAILCALLS
1599	MUSTTAIL return InterpNext(S);
1600	#else
1601	return true;
1602	#endif
1603	}
1604	#endif
1605	#ifdef GET_DISASM
1606	case OP_ArrayDecay:
1607	Text.Op = PrintName("ArrayDecay");
1608	break;
1609	#endif
1610	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1611	bool emitArrayDecay(SourceInfo);
1612	#endif
1613	#ifdef GET_LINK_IMPL
1614	bool ByteCodeEmitter::emitArrayDecay(SourceInfo L) {
1615	return emitOp<>(OP_ArrayDecay, L);
1616	}
1617	#endif
1618	#ifdef GET_EVAL_IMPL
1619	bool EvalEmitter::emitArrayDecay(SourceInfo L) {
1620	if (!isActive()) return true;
1621	CurrentSource = L;
1622	return ArrayDecay(S, CodePtr());
1623	}
1624	#endif
1625	#ifdef GET_OPCODE_NAMES
1626	OP_ArrayElemSint8,
1627	OP_ArrayElemUint8,
1628	OP_ArrayElemSint16,
1629	OP_ArrayElemUint16,
1630	OP_ArrayElemSint32,
1631	OP_ArrayElemUint32,
1632	OP_ArrayElemSint64,
1633	OP_ArrayElemUint64,
1634	OP_ArrayElemIntAP,
1635	OP_ArrayElemIntAPS,
1636	OP_ArrayElemBool,
1637	OP_ArrayElemFixedPoint,
1638	OP_ArrayElemPtr,
1639	OP_ArrayElemMemberPtr,
1640	OP_ArrayElemFloat,
1641	#endif
1642	#ifdef GET_INTERPFN_LIST
1643	&Interp_ArrayElemSint8,
1644	&Interp_ArrayElemUint8,
1645	&Interp_ArrayElemSint16,
1646	&Interp_ArrayElemUint16,
1647	&Interp_ArrayElemSint32,
1648	&Interp_ArrayElemUint32,
1649	&Interp_ArrayElemSint64,
1650	&Interp_ArrayElemUint64,
1651	&Interp_ArrayElemIntAP,
1652	&Interp_ArrayElemIntAPS,
1653	&Interp_ArrayElemBool,
1654	&Interp_ArrayElemFixedPoint,
1655	&Interp_ArrayElemPtr,
1656	&Interp_ArrayElemMemberPtr,
1657	&Interp_ArrayElemFloat,
1658	#endif
1659	#ifdef GET_INTERPFN_DISPATCHERS
1660	PRESERVE_NONE
1661	static bool Interp_ArrayElemSint8(InterpState &S) {
1662	{
1663	CodePtr OpPC = S.PC;
1664	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1665	if (!ArrayElem<PT_Sint8>(S, OpPC, V0)) return false;
1666	}
1667	#if USE_TAILCALLS
1668	MUSTTAIL return InterpNext(S);
1669	#else
1670	return true;
1671	#endif
1672	}
1673	PRESERVE_NONE
1674	static bool Interp_ArrayElemUint8(InterpState &S) {
1675	{
1676	CodePtr OpPC = S.PC;
1677	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1678	if (!ArrayElem<PT_Uint8>(S, OpPC, V0)) return false;
1679	}
1680	#if USE_TAILCALLS
1681	MUSTTAIL return InterpNext(S);
1682	#else
1683	return true;
1684	#endif
1685	}
1686	PRESERVE_NONE
1687	static bool Interp_ArrayElemSint16(InterpState &S) {
1688	{
1689	CodePtr OpPC = S.PC;
1690	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1691	if (!ArrayElem<PT_Sint16>(S, OpPC, V0)) return false;
1692	}
1693	#if USE_TAILCALLS
1694	MUSTTAIL return InterpNext(S);
1695	#else
1696	return true;
1697	#endif
1698	}
1699	PRESERVE_NONE
1700	static bool Interp_ArrayElemUint16(InterpState &S) {
1701	{
1702	CodePtr OpPC = S.PC;
1703	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1704	if (!ArrayElem<PT_Uint16>(S, OpPC, V0)) return false;
1705	}
1706	#if USE_TAILCALLS
1707	MUSTTAIL return InterpNext(S);
1708	#else
1709	return true;
1710	#endif
1711	}
1712	PRESERVE_NONE
1713	static bool Interp_ArrayElemSint32(InterpState &S) {
1714	{
1715	CodePtr OpPC = S.PC;
1716	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1717	if (!ArrayElem<PT_Sint32>(S, OpPC, V0)) return false;
1718	}
1719	#if USE_TAILCALLS
1720	MUSTTAIL return InterpNext(S);
1721	#else
1722	return true;
1723	#endif
1724	}
1725	PRESERVE_NONE
1726	static bool Interp_ArrayElemUint32(InterpState &S) {
1727	{
1728	CodePtr OpPC = S.PC;
1729	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1730	if (!ArrayElem<PT_Uint32>(S, OpPC, V0)) return false;
1731	}
1732	#if USE_TAILCALLS
1733	MUSTTAIL return InterpNext(S);
1734	#else
1735	return true;
1736	#endif
1737	}
1738	PRESERVE_NONE
1739	static bool Interp_ArrayElemSint64(InterpState &S) {
1740	{
1741	CodePtr OpPC = S.PC;
1742	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1743	if (!ArrayElem<PT_Sint64>(S, OpPC, V0)) return false;
1744	}
1745	#if USE_TAILCALLS
1746	MUSTTAIL return InterpNext(S);
1747	#else
1748	return true;
1749	#endif
1750	}
1751	PRESERVE_NONE
1752	static bool Interp_ArrayElemUint64(InterpState &S) {
1753	{
1754	CodePtr OpPC = S.PC;
1755	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1756	if (!ArrayElem<PT_Uint64>(S, OpPC, V0)) return false;
1757	}
1758	#if USE_TAILCALLS
1759	MUSTTAIL return InterpNext(S);
1760	#else
1761	return true;
1762	#endif
1763	}
1764	PRESERVE_NONE
1765	static bool Interp_ArrayElemIntAP(InterpState &S) {
1766	{
1767	CodePtr OpPC = S.PC;
1768	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1769	if (!ArrayElem<PT_IntAP>(S, OpPC, V0)) return false;
1770	}
1771	#if USE_TAILCALLS
1772	MUSTTAIL return InterpNext(S);
1773	#else
1774	return true;
1775	#endif
1776	}
1777	PRESERVE_NONE
1778	static bool Interp_ArrayElemIntAPS(InterpState &S) {
1779	{
1780	CodePtr OpPC = S.PC;
1781	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1782	if (!ArrayElem<PT_IntAPS>(S, OpPC, V0)) return false;
1783	}
1784	#if USE_TAILCALLS
1785	MUSTTAIL return InterpNext(S);
1786	#else
1787	return true;
1788	#endif
1789	}
1790	PRESERVE_NONE
1791	static bool Interp_ArrayElemBool(InterpState &S) {
1792	{
1793	CodePtr OpPC = S.PC;
1794	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1795	if (!ArrayElem<PT_Bool>(S, OpPC, V0)) return false;
1796	}
1797	#if USE_TAILCALLS
1798	MUSTTAIL return InterpNext(S);
1799	#else
1800	return true;
1801	#endif
1802	}
1803	PRESERVE_NONE
1804	static bool Interp_ArrayElemFixedPoint(InterpState &S) {
1805	{
1806	CodePtr OpPC = S.PC;
1807	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1808	if (!ArrayElem<PT_FixedPoint>(S, OpPC, V0)) return false;
1809	}
1810	#if USE_TAILCALLS
1811	MUSTTAIL return InterpNext(S);
1812	#else
1813	return true;
1814	#endif
1815	}
1816	PRESERVE_NONE
1817	static bool Interp_ArrayElemPtr(InterpState &S) {
1818	{
1819	CodePtr OpPC = S.PC;
1820	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1821	if (!ArrayElem<PT_Ptr>(S, OpPC, V0)) return false;
1822	}
1823	#if USE_TAILCALLS
1824	MUSTTAIL return InterpNext(S);
1825	#else
1826	return true;
1827	#endif
1828	}
1829	PRESERVE_NONE
1830	static bool Interp_ArrayElemMemberPtr(InterpState &S) {
1831	{
1832	CodePtr OpPC = S.PC;
1833	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1834	if (!ArrayElem<PT_MemberPtr>(S, OpPC, V0)) return false;
1835	}
1836	#if USE_TAILCALLS
1837	MUSTTAIL return InterpNext(S);
1838	#else
1839	return true;
1840	#endif
1841	}
1842	PRESERVE_NONE
1843	static bool Interp_ArrayElemFloat(InterpState &S) {
1844	{
1845	CodePtr OpPC = S.PC;
1846	const auto V0 = ReadArg<uint32_t>(S, S.PC);
1847	if (!ArrayElem<PT_Float>(S, OpPC, V0)) return false;
1848	}
1849	#if USE_TAILCALLS
1850	MUSTTAIL return InterpNext(S);
1851	#else
1852	return true;
1853	#endif
1854	}
1855	#endif
1856	#ifdef GET_DISASM
1857	case OP_ArrayElemSint8:
1858	Text.Op = PrintName("ArrayElemSint8");
1859	Text.Args.push_back(printArg<uint32_t>(P, PC));
1860	break;
1861	case OP_ArrayElemUint8:
1862	Text.Op = PrintName("ArrayElemUint8");
1863	Text.Args.push_back(printArg<uint32_t>(P, PC));
1864	break;
1865	case OP_ArrayElemSint16:
1866	Text.Op = PrintName("ArrayElemSint16");
1867	Text.Args.push_back(printArg<uint32_t>(P, PC));
1868	break;
1869	case OP_ArrayElemUint16:
1870	Text.Op = PrintName("ArrayElemUint16");
1871	Text.Args.push_back(printArg<uint32_t>(P, PC));
1872	break;
1873	case OP_ArrayElemSint32:
1874	Text.Op = PrintName("ArrayElemSint32");
1875	Text.Args.push_back(printArg<uint32_t>(P, PC));
1876	break;
1877	case OP_ArrayElemUint32:
1878	Text.Op = PrintName("ArrayElemUint32");
1879	Text.Args.push_back(printArg<uint32_t>(P, PC));
1880	break;
1881	case OP_ArrayElemSint64:
1882	Text.Op = PrintName("ArrayElemSint64");
1883	Text.Args.push_back(printArg<uint32_t>(P, PC));
1884	break;
1885	case OP_ArrayElemUint64:
1886	Text.Op = PrintName("ArrayElemUint64");
1887	Text.Args.push_back(printArg<uint32_t>(P, PC));
1888	break;
1889	case OP_ArrayElemIntAP:
1890	Text.Op = PrintName("ArrayElemIntAP");
1891	Text.Args.push_back(printArg<uint32_t>(P, PC));
1892	break;
1893	case OP_ArrayElemIntAPS:
1894	Text.Op = PrintName("ArrayElemIntAPS");
1895	Text.Args.push_back(printArg<uint32_t>(P, PC));
1896	break;
1897	case OP_ArrayElemBool:
1898	Text.Op = PrintName("ArrayElemBool");
1899	Text.Args.push_back(printArg<uint32_t>(P, PC));
1900	break;
1901	case OP_ArrayElemFixedPoint:
1902	Text.Op = PrintName("ArrayElemFixedPoint");
1903	Text.Args.push_back(printArg<uint32_t>(P, PC));
1904	break;
1905	case OP_ArrayElemPtr:
1906	Text.Op = PrintName("ArrayElemPtr");
1907	Text.Args.push_back(printArg<uint32_t>(P, PC));
1908	break;
1909	case OP_ArrayElemMemberPtr:
1910	Text.Op = PrintName("ArrayElemMemberPtr");
1911	Text.Args.push_back(printArg<uint32_t>(P, PC));
1912	break;
1913	case OP_ArrayElemFloat:
1914	Text.Op = PrintName("ArrayElemFloat");
1915	Text.Args.push_back(printArg<uint32_t>(P, PC));
1916	break;
1917	#endif
1918	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1919	bool emitArrayElemSint8( uint32_t , SourceInfo);
1920	bool emitArrayElemUint8( uint32_t , SourceInfo);
1921	bool emitArrayElemSint16( uint32_t , SourceInfo);
1922	bool emitArrayElemUint16( uint32_t , SourceInfo);
1923	bool emitArrayElemSint32( uint32_t , SourceInfo);
1924	bool emitArrayElemUint32( uint32_t , SourceInfo);
1925	bool emitArrayElemSint64( uint32_t , SourceInfo);
1926	bool emitArrayElemUint64( uint32_t , SourceInfo);
1927	bool emitArrayElemIntAP( uint32_t , SourceInfo);
1928	bool emitArrayElemIntAPS( uint32_t , SourceInfo);
1929	bool emitArrayElemBool( uint32_t , SourceInfo);
1930	bool emitArrayElemFixedPoint( uint32_t , SourceInfo);
1931	bool emitArrayElemPtr( uint32_t , SourceInfo);
1932	bool emitArrayElemMemberPtr( uint32_t , SourceInfo);
1933	bool emitArrayElemFloat( uint32_t , SourceInfo);
1934	#endif
1935	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
1936	[[nodiscard]] bool emitArrayElem(PrimType, uint32_t, SourceInfo I);
1937	#endif
1938	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
1939	bool
1940	#if defined(GET_EVAL_IMPL)
1941	EvalEmitter
1942	#else
1943	ByteCodeEmitter
1944	#endif
1945	::emitArrayElem(PrimType T0, uint32_t A0, SourceInfo I) {
1946	switch (T0) {
1947	case PT_Sint8:
1948	return emitArrayElemSint8(A0, I);
1949	case PT_Uint8:
1950	return emitArrayElemUint8(A0, I);
1951	case PT_Sint16:
1952	return emitArrayElemSint16(A0, I);
1953	case PT_Uint16:
1954	return emitArrayElemUint16(A0, I);
1955	case PT_Sint32:
1956	return emitArrayElemSint32(A0, I);
1957	case PT_Uint32:
1958	return emitArrayElemUint32(A0, I);
1959	case PT_Sint64:
1960	return emitArrayElemSint64(A0, I);
1961	case PT_Uint64:
1962	return emitArrayElemUint64(A0, I);
1963	case PT_IntAP:
1964	return emitArrayElemIntAP(A0, I);
1965	case PT_IntAPS:
1966	return emitArrayElemIntAPS(A0, I);
1967	case PT_Bool:
1968	return emitArrayElemBool(A0, I);
1969	case PT_FixedPoint:
1970	return emitArrayElemFixedPoint(A0, I);
1971	case PT_Ptr:
1972	return emitArrayElemPtr(A0, I);
1973	case PT_MemberPtr:
1974	return emitArrayElemMemberPtr(A0, I);
1975	case PT_Float:
1976	return emitArrayElemFloat(A0, I);
1977	}
1978	llvm_unreachable("invalid enum value");
1979	}
1980	#endif
1981	#ifdef GET_LINK_IMPL
1982	bool ByteCodeEmitter::emitArrayElemSint8( uint32_t A0, SourceInfo L) {
1983	return emitOp<uint32_t>(OP_ArrayElemSint8, A0, L);
1984	}
1985	bool ByteCodeEmitter::emitArrayElemUint8( uint32_t A0, SourceInfo L) {
1986	return emitOp<uint32_t>(OP_ArrayElemUint8, A0, L);
1987	}
1988	bool ByteCodeEmitter::emitArrayElemSint16( uint32_t A0, SourceInfo L) {
1989	return emitOp<uint32_t>(OP_ArrayElemSint16, A0, L);
1990	}
1991	bool ByteCodeEmitter::emitArrayElemUint16( uint32_t A0, SourceInfo L) {
1992	return emitOp<uint32_t>(OP_ArrayElemUint16, A0, L);
1993	}
1994	bool ByteCodeEmitter::emitArrayElemSint32( uint32_t A0, SourceInfo L) {
1995	return emitOp<uint32_t>(OP_ArrayElemSint32, A0, L);
1996	}
1997	bool ByteCodeEmitter::emitArrayElemUint32( uint32_t A0, SourceInfo L) {
1998	return emitOp<uint32_t>(OP_ArrayElemUint32, A0, L);
1999	}
2000	bool ByteCodeEmitter::emitArrayElemSint64( uint32_t A0, SourceInfo L) {
2001	return emitOp<uint32_t>(OP_ArrayElemSint64, A0, L);
2002	}
2003	bool ByteCodeEmitter::emitArrayElemUint64( uint32_t A0, SourceInfo L) {
2004	return emitOp<uint32_t>(OP_ArrayElemUint64, A0, L);
2005	}
2006	bool ByteCodeEmitter::emitArrayElemIntAP( uint32_t A0, SourceInfo L) {
2007	return emitOp<uint32_t>(OP_ArrayElemIntAP, A0, L);
2008	}
2009	bool ByteCodeEmitter::emitArrayElemIntAPS( uint32_t A0, SourceInfo L) {
2010	return emitOp<uint32_t>(OP_ArrayElemIntAPS, A0, L);
2011	}
2012	bool ByteCodeEmitter::emitArrayElemBool( uint32_t A0, SourceInfo L) {
2013	return emitOp<uint32_t>(OP_ArrayElemBool, A0, L);
2014	}
2015	bool ByteCodeEmitter::emitArrayElemFixedPoint( uint32_t A0, SourceInfo L) {
2016	return emitOp<uint32_t>(OP_ArrayElemFixedPoint, A0, L);
2017	}
2018	bool ByteCodeEmitter::emitArrayElemPtr( uint32_t A0, SourceInfo L) {
2019	return emitOp<uint32_t>(OP_ArrayElemPtr, A0, L);
2020	}
2021	bool ByteCodeEmitter::emitArrayElemMemberPtr( uint32_t A0, SourceInfo L) {
2022	return emitOp<uint32_t>(OP_ArrayElemMemberPtr, A0, L);
2023	}
2024	bool ByteCodeEmitter::emitArrayElemFloat( uint32_t A0, SourceInfo L) {
2025	return emitOp<uint32_t>(OP_ArrayElemFloat, A0, L);
2026	}
2027	#endif
2028	#ifdef GET_EVAL_IMPL
2029	bool EvalEmitter::emitArrayElemSint8( uint32_t A0, SourceInfo L) {
2030	if (!isActive()) return true;
2031	CurrentSource = L;
2032	return ArrayElem<PT_Sint8>(S, CodePtr(), A0);
2033	}
2034	bool EvalEmitter::emitArrayElemUint8( uint32_t A0, SourceInfo L) {
2035	if (!isActive()) return true;
2036	CurrentSource = L;
2037	return ArrayElem<PT_Uint8>(S, CodePtr(), A0);
2038	}
2039	bool EvalEmitter::emitArrayElemSint16( uint32_t A0, SourceInfo L) {
2040	if (!isActive()) return true;
2041	CurrentSource = L;
2042	return ArrayElem<PT_Sint16>(S, CodePtr(), A0);
2043	}
2044	bool EvalEmitter::emitArrayElemUint16( uint32_t A0, SourceInfo L) {
2045	if (!isActive()) return true;
2046	CurrentSource = L;
2047	return ArrayElem<PT_Uint16>(S, CodePtr(), A0);
2048	}
2049	bool EvalEmitter::emitArrayElemSint32( uint32_t A0, SourceInfo L) {
2050	if (!isActive()) return true;
2051	CurrentSource = L;
2052	return ArrayElem<PT_Sint32>(S, CodePtr(), A0);
2053	}
2054	bool EvalEmitter::emitArrayElemUint32( uint32_t A0, SourceInfo L) {
2055	if (!isActive()) return true;
2056	CurrentSource = L;
2057	return ArrayElem<PT_Uint32>(S, CodePtr(), A0);
2058	}
2059	bool EvalEmitter::emitArrayElemSint64( uint32_t A0, SourceInfo L) {
2060	if (!isActive()) return true;
2061	CurrentSource = L;
2062	return ArrayElem<PT_Sint64>(S, CodePtr(), A0);
2063	}
2064	bool EvalEmitter::emitArrayElemUint64( uint32_t A0, SourceInfo L) {
2065	if (!isActive()) return true;
2066	CurrentSource = L;
2067	return ArrayElem<PT_Uint64>(S, CodePtr(), A0);
2068	}
2069	bool EvalEmitter::emitArrayElemIntAP( uint32_t A0, SourceInfo L) {
2070	if (!isActive()) return true;
2071	CurrentSource = L;
2072	return ArrayElem<PT_IntAP>(S, CodePtr(), A0);
2073	}
2074	bool EvalEmitter::emitArrayElemIntAPS( uint32_t A0, SourceInfo L) {
2075	if (!isActive()) return true;
2076	CurrentSource = L;
2077	return ArrayElem<PT_IntAPS>(S, CodePtr(), A0);
2078	}
2079	bool EvalEmitter::emitArrayElemBool( uint32_t A0, SourceInfo L) {
2080	if (!isActive()) return true;
2081	CurrentSource = L;
2082	return ArrayElem<PT_Bool>(S, CodePtr(), A0);
2083	}
2084	bool EvalEmitter::emitArrayElemFixedPoint( uint32_t A0, SourceInfo L) {
2085	if (!isActive()) return true;
2086	CurrentSource = L;
2087	return ArrayElem<PT_FixedPoint>(S, CodePtr(), A0);
2088	}
2089	bool EvalEmitter::emitArrayElemPtr( uint32_t A0, SourceInfo L) {
2090	if (!isActive()) return true;
2091	CurrentSource = L;
2092	return ArrayElem<PT_Ptr>(S, CodePtr(), A0);
2093	}
2094	bool EvalEmitter::emitArrayElemMemberPtr( uint32_t A0, SourceInfo L) {
2095	if (!isActive()) return true;
2096	CurrentSource = L;
2097	return ArrayElem<PT_MemberPtr>(S, CodePtr(), A0);
2098	}
2099	bool EvalEmitter::emitArrayElemFloat( uint32_t A0, SourceInfo L) {
2100	if (!isActive()) return true;
2101	CurrentSource = L;
2102	return ArrayElem<PT_Float>(S, CodePtr(), A0);
2103	}
2104	#endif
2105	#ifdef GET_OPCODE_NAMES
2106	OP_ArrayElemPopSint8,
2107	OP_ArrayElemPopUint8,
2108	OP_ArrayElemPopSint16,
2109	OP_ArrayElemPopUint16,
2110	OP_ArrayElemPopSint32,
2111	OP_ArrayElemPopUint32,
2112	OP_ArrayElemPopSint64,
2113	OP_ArrayElemPopUint64,
2114	OP_ArrayElemPopIntAP,
2115	OP_ArrayElemPopIntAPS,
2116	OP_ArrayElemPopBool,
2117	OP_ArrayElemPopFixedPoint,
2118	OP_ArrayElemPopPtr,
2119	OP_ArrayElemPopMemberPtr,
2120	OP_ArrayElemPopFloat,
2121	#endif
2122	#ifdef GET_INTERPFN_LIST
2123	&Interp_ArrayElemPopSint8,
2124	&Interp_ArrayElemPopUint8,
2125	&Interp_ArrayElemPopSint16,
2126	&Interp_ArrayElemPopUint16,
2127	&Interp_ArrayElemPopSint32,
2128	&Interp_ArrayElemPopUint32,
2129	&Interp_ArrayElemPopSint64,
2130	&Interp_ArrayElemPopUint64,
2131	&Interp_ArrayElemPopIntAP,
2132	&Interp_ArrayElemPopIntAPS,
2133	&Interp_ArrayElemPopBool,
2134	&Interp_ArrayElemPopFixedPoint,
2135	&Interp_ArrayElemPopPtr,
2136	&Interp_ArrayElemPopMemberPtr,
2137	&Interp_ArrayElemPopFloat,
2138	#endif
2139	#ifdef GET_INTERPFN_DISPATCHERS
2140	PRESERVE_NONE
2141	static bool Interp_ArrayElemPopSint8(InterpState &S) {
2142	{
2143	CodePtr OpPC = S.PC;
2144	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2145	if (!ArrayElemPop<PT_Sint8>(S, OpPC, V0)) return false;
2146	}
2147	#if USE_TAILCALLS
2148	MUSTTAIL return InterpNext(S);
2149	#else
2150	return true;
2151	#endif
2152	}
2153	PRESERVE_NONE
2154	static bool Interp_ArrayElemPopUint8(InterpState &S) {
2155	{
2156	CodePtr OpPC = S.PC;
2157	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2158	if (!ArrayElemPop<PT_Uint8>(S, OpPC, V0)) return false;
2159	}
2160	#if USE_TAILCALLS
2161	MUSTTAIL return InterpNext(S);
2162	#else
2163	return true;
2164	#endif
2165	}
2166	PRESERVE_NONE
2167	static bool Interp_ArrayElemPopSint16(InterpState &S) {
2168	{
2169	CodePtr OpPC = S.PC;
2170	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2171	if (!ArrayElemPop<PT_Sint16>(S, OpPC, V0)) return false;
2172	}
2173	#if USE_TAILCALLS
2174	MUSTTAIL return InterpNext(S);
2175	#else
2176	return true;
2177	#endif
2178	}
2179	PRESERVE_NONE
2180	static bool Interp_ArrayElemPopUint16(InterpState &S) {
2181	{
2182	CodePtr OpPC = S.PC;
2183	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2184	if (!ArrayElemPop<PT_Uint16>(S, OpPC, V0)) return false;
2185	}
2186	#if USE_TAILCALLS
2187	MUSTTAIL return InterpNext(S);
2188	#else
2189	return true;
2190	#endif
2191	}
2192	PRESERVE_NONE
2193	static bool Interp_ArrayElemPopSint32(InterpState &S) {
2194	{
2195	CodePtr OpPC = S.PC;
2196	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2197	if (!ArrayElemPop<PT_Sint32>(S, OpPC, V0)) return false;
2198	}
2199	#if USE_TAILCALLS
2200	MUSTTAIL return InterpNext(S);
2201	#else
2202	return true;
2203	#endif
2204	}
2205	PRESERVE_NONE
2206	static bool Interp_ArrayElemPopUint32(InterpState &S) {
2207	{
2208	CodePtr OpPC = S.PC;
2209	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2210	if (!ArrayElemPop<PT_Uint32>(S, OpPC, V0)) return false;
2211	}
2212	#if USE_TAILCALLS
2213	MUSTTAIL return InterpNext(S);
2214	#else
2215	return true;
2216	#endif
2217	}
2218	PRESERVE_NONE
2219	static bool Interp_ArrayElemPopSint64(InterpState &S) {
2220	{
2221	CodePtr OpPC = S.PC;
2222	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2223	if (!ArrayElemPop<PT_Sint64>(S, OpPC, V0)) return false;
2224	}
2225	#if USE_TAILCALLS
2226	MUSTTAIL return InterpNext(S);
2227	#else
2228	return true;
2229	#endif
2230	}
2231	PRESERVE_NONE
2232	static bool Interp_ArrayElemPopUint64(InterpState &S) {
2233	{
2234	CodePtr OpPC = S.PC;
2235	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2236	if (!ArrayElemPop<PT_Uint64>(S, OpPC, V0)) return false;
2237	}
2238	#if USE_TAILCALLS
2239	MUSTTAIL return InterpNext(S);
2240	#else
2241	return true;
2242	#endif
2243	}
2244	PRESERVE_NONE
2245	static bool Interp_ArrayElemPopIntAP(InterpState &S) {
2246	{
2247	CodePtr OpPC = S.PC;
2248	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2249	if (!ArrayElemPop<PT_IntAP>(S, OpPC, V0)) return false;
2250	}
2251	#if USE_TAILCALLS
2252	MUSTTAIL return InterpNext(S);
2253	#else
2254	return true;
2255	#endif
2256	}
2257	PRESERVE_NONE
2258	static bool Interp_ArrayElemPopIntAPS(InterpState &S) {
2259	{
2260	CodePtr OpPC = S.PC;
2261	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2262	if (!ArrayElemPop<PT_IntAPS>(S, OpPC, V0)) return false;
2263	}
2264	#if USE_TAILCALLS
2265	MUSTTAIL return InterpNext(S);
2266	#else
2267	return true;
2268	#endif
2269	}
2270	PRESERVE_NONE
2271	static bool Interp_ArrayElemPopBool(InterpState &S) {
2272	{
2273	CodePtr OpPC = S.PC;
2274	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2275	if (!ArrayElemPop<PT_Bool>(S, OpPC, V0)) return false;
2276	}
2277	#if USE_TAILCALLS
2278	MUSTTAIL return InterpNext(S);
2279	#else
2280	return true;
2281	#endif
2282	}
2283	PRESERVE_NONE
2284	static bool Interp_ArrayElemPopFixedPoint(InterpState &S) {
2285	{
2286	CodePtr OpPC = S.PC;
2287	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2288	if (!ArrayElemPop<PT_FixedPoint>(S, OpPC, V0)) return false;
2289	}
2290	#if USE_TAILCALLS
2291	MUSTTAIL return InterpNext(S);
2292	#else
2293	return true;
2294	#endif
2295	}
2296	PRESERVE_NONE
2297	static bool Interp_ArrayElemPopPtr(InterpState &S) {
2298	{
2299	CodePtr OpPC = S.PC;
2300	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2301	if (!ArrayElemPop<PT_Ptr>(S, OpPC, V0)) return false;
2302	}
2303	#if USE_TAILCALLS
2304	MUSTTAIL return InterpNext(S);
2305	#else
2306	return true;
2307	#endif
2308	}
2309	PRESERVE_NONE
2310	static bool Interp_ArrayElemPopMemberPtr(InterpState &S) {
2311	{
2312	CodePtr OpPC = S.PC;
2313	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2314	if (!ArrayElemPop<PT_MemberPtr>(S, OpPC, V0)) return false;
2315	}
2316	#if USE_TAILCALLS
2317	MUSTTAIL return InterpNext(S);
2318	#else
2319	return true;
2320	#endif
2321	}
2322	PRESERVE_NONE
2323	static bool Interp_ArrayElemPopFloat(InterpState &S) {
2324	{
2325	CodePtr OpPC = S.PC;
2326	const auto V0 = ReadArg<uint32_t>(S, S.PC);
2327	if (!ArrayElemPop<PT_Float>(S, OpPC, V0)) return false;
2328	}
2329	#if USE_TAILCALLS
2330	MUSTTAIL return InterpNext(S);
2331	#else
2332	return true;
2333	#endif
2334	}
2335	#endif
2336	#ifdef GET_DISASM
2337	case OP_ArrayElemPopSint8:
2338	Text.Op = PrintName("ArrayElemPopSint8");
2339	Text.Args.push_back(printArg<uint32_t>(P, PC));
2340	break;
2341	case OP_ArrayElemPopUint8:
2342	Text.Op = PrintName("ArrayElemPopUint8");
2343	Text.Args.push_back(printArg<uint32_t>(P, PC));
2344	break;
2345	case OP_ArrayElemPopSint16:
2346	Text.Op = PrintName("ArrayElemPopSint16");
2347	Text.Args.push_back(printArg<uint32_t>(P, PC));
2348	break;
2349	case OP_ArrayElemPopUint16:
2350	Text.Op = PrintName("ArrayElemPopUint16");
2351	Text.Args.push_back(printArg<uint32_t>(P, PC));
2352	break;
2353	case OP_ArrayElemPopSint32:
2354	Text.Op = PrintName("ArrayElemPopSint32");
2355	Text.Args.push_back(printArg<uint32_t>(P, PC));
2356	break;
2357	case OP_ArrayElemPopUint32:
2358	Text.Op = PrintName("ArrayElemPopUint32");
2359	Text.Args.push_back(printArg<uint32_t>(P, PC));
2360	break;
2361	case OP_ArrayElemPopSint64:
2362	Text.Op = PrintName("ArrayElemPopSint64");
2363	Text.Args.push_back(printArg<uint32_t>(P, PC));
2364	break;
2365	case OP_ArrayElemPopUint64:
2366	Text.Op = PrintName("ArrayElemPopUint64");
2367	Text.Args.push_back(printArg<uint32_t>(P, PC));
2368	break;
2369	case OP_ArrayElemPopIntAP:
2370	Text.Op = PrintName("ArrayElemPopIntAP");
2371	Text.Args.push_back(printArg<uint32_t>(P, PC));
2372	break;
2373	case OP_ArrayElemPopIntAPS:
2374	Text.Op = PrintName("ArrayElemPopIntAPS");
2375	Text.Args.push_back(printArg<uint32_t>(P, PC));
2376	break;
2377	case OP_ArrayElemPopBool:
2378	Text.Op = PrintName("ArrayElemPopBool");
2379	Text.Args.push_back(printArg<uint32_t>(P, PC));
2380	break;
2381	case OP_ArrayElemPopFixedPoint:
2382	Text.Op = PrintName("ArrayElemPopFixedPoint");
2383	Text.Args.push_back(printArg<uint32_t>(P, PC));
2384	break;
2385	case OP_ArrayElemPopPtr:
2386	Text.Op = PrintName("ArrayElemPopPtr");
2387	Text.Args.push_back(printArg<uint32_t>(P, PC));
2388	break;
2389	case OP_ArrayElemPopMemberPtr:
2390	Text.Op = PrintName("ArrayElemPopMemberPtr");
2391	Text.Args.push_back(printArg<uint32_t>(P, PC));
2392	break;
2393	case OP_ArrayElemPopFloat:
2394	Text.Op = PrintName("ArrayElemPopFloat");
2395	Text.Args.push_back(printArg<uint32_t>(P, PC));
2396	break;
2397	#endif
2398	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
2399	bool emitArrayElemPopSint8( uint32_t , SourceInfo);
2400	bool emitArrayElemPopUint8( uint32_t , SourceInfo);
2401	bool emitArrayElemPopSint16( uint32_t , SourceInfo);
2402	bool emitArrayElemPopUint16( uint32_t , SourceInfo);
2403	bool emitArrayElemPopSint32( uint32_t , SourceInfo);
2404	bool emitArrayElemPopUint32( uint32_t , SourceInfo);
2405	bool emitArrayElemPopSint64( uint32_t , SourceInfo);
2406	bool emitArrayElemPopUint64( uint32_t , SourceInfo);
2407	bool emitArrayElemPopIntAP( uint32_t , SourceInfo);
2408	bool emitArrayElemPopIntAPS( uint32_t , SourceInfo);
2409	bool emitArrayElemPopBool( uint32_t , SourceInfo);
2410	bool emitArrayElemPopFixedPoint( uint32_t , SourceInfo);
2411	bool emitArrayElemPopPtr( uint32_t , SourceInfo);
2412	bool emitArrayElemPopMemberPtr( uint32_t , SourceInfo);
2413	bool emitArrayElemPopFloat( uint32_t , SourceInfo);
2414	#endif
2415	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
2416	[[nodiscard]] bool emitArrayElemPop(PrimType, uint32_t, SourceInfo I);
2417	#endif
2418	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
2419	bool
2420	#if defined(GET_EVAL_IMPL)
2421	EvalEmitter
2422	#else
2423	ByteCodeEmitter
2424	#endif
2425	::emitArrayElemPop(PrimType T0, uint32_t A0, SourceInfo I) {
2426	switch (T0) {
2427	case PT_Sint8:
2428	return emitArrayElemPopSint8(A0, I);
2429	case PT_Uint8:
2430	return emitArrayElemPopUint8(A0, I);
2431	case PT_Sint16:
2432	return emitArrayElemPopSint16(A0, I);
2433	case PT_Uint16:
2434	return emitArrayElemPopUint16(A0, I);
2435	case PT_Sint32:
2436	return emitArrayElemPopSint32(A0, I);
2437	case PT_Uint32:
2438	return emitArrayElemPopUint32(A0, I);
2439	case PT_Sint64:
2440	return emitArrayElemPopSint64(A0, I);
2441	case PT_Uint64:
2442	return emitArrayElemPopUint64(A0, I);
2443	case PT_IntAP:
2444	return emitArrayElemPopIntAP(A0, I);
2445	case PT_IntAPS:
2446	return emitArrayElemPopIntAPS(A0, I);
2447	case PT_Bool:
2448	return emitArrayElemPopBool(A0, I);
2449	case PT_FixedPoint:
2450	return emitArrayElemPopFixedPoint(A0, I);
2451	case PT_Ptr:
2452	return emitArrayElemPopPtr(A0, I);
2453	case PT_MemberPtr:
2454	return emitArrayElemPopMemberPtr(A0, I);
2455	case PT_Float:
2456	return emitArrayElemPopFloat(A0, I);
2457	}
2458	llvm_unreachable("invalid enum value");
2459	}
2460	#endif
2461	#ifdef GET_LINK_IMPL
2462	bool ByteCodeEmitter::emitArrayElemPopSint8( uint32_t A0, SourceInfo L) {
2463	return emitOp<uint32_t>(OP_ArrayElemPopSint8, A0, L);
2464	}
2465	bool ByteCodeEmitter::emitArrayElemPopUint8( uint32_t A0, SourceInfo L) {
2466	return emitOp<uint32_t>(OP_ArrayElemPopUint8, A0, L);
2467	}
2468	bool ByteCodeEmitter::emitArrayElemPopSint16( uint32_t A0, SourceInfo L) {
2469	return emitOp<uint32_t>(OP_ArrayElemPopSint16, A0, L);
2470	}
2471	bool ByteCodeEmitter::emitArrayElemPopUint16( uint32_t A0, SourceInfo L) {
2472	return emitOp<uint32_t>(OP_ArrayElemPopUint16, A0, L);
2473	}
2474	bool ByteCodeEmitter::emitArrayElemPopSint32( uint32_t A0, SourceInfo L) {
2475	return emitOp<uint32_t>(OP_ArrayElemPopSint32, A0, L);
2476	}
2477	bool ByteCodeEmitter::emitArrayElemPopUint32( uint32_t A0, SourceInfo L) {
2478	return emitOp<uint32_t>(OP_ArrayElemPopUint32, A0, L);
2479	}
2480	bool ByteCodeEmitter::emitArrayElemPopSint64( uint32_t A0, SourceInfo L) {
2481	return emitOp<uint32_t>(OP_ArrayElemPopSint64, A0, L);
2482	}
2483	bool ByteCodeEmitter::emitArrayElemPopUint64( uint32_t A0, SourceInfo L) {
2484	return emitOp<uint32_t>(OP_ArrayElemPopUint64, A0, L);
2485	}
2486	bool ByteCodeEmitter::emitArrayElemPopIntAP( uint32_t A0, SourceInfo L) {
2487	return emitOp<uint32_t>(OP_ArrayElemPopIntAP, A0, L);
2488	}
2489	bool ByteCodeEmitter::emitArrayElemPopIntAPS( uint32_t A0, SourceInfo L) {
2490	return emitOp<uint32_t>(OP_ArrayElemPopIntAPS, A0, L);
2491	}
2492	bool ByteCodeEmitter::emitArrayElemPopBool( uint32_t A0, SourceInfo L) {
2493	return emitOp<uint32_t>(OP_ArrayElemPopBool, A0, L);
2494	}
2495	bool ByteCodeEmitter::emitArrayElemPopFixedPoint( uint32_t A0, SourceInfo L) {
2496	return emitOp<uint32_t>(OP_ArrayElemPopFixedPoint, A0, L);
2497	}
2498	bool ByteCodeEmitter::emitArrayElemPopPtr( uint32_t A0, SourceInfo L) {
2499	return emitOp<uint32_t>(OP_ArrayElemPopPtr, A0, L);
2500	}
2501	bool ByteCodeEmitter::emitArrayElemPopMemberPtr( uint32_t A0, SourceInfo L) {
2502	return emitOp<uint32_t>(OP_ArrayElemPopMemberPtr, A0, L);
2503	}
2504	bool ByteCodeEmitter::emitArrayElemPopFloat( uint32_t A0, SourceInfo L) {
2505	return emitOp<uint32_t>(OP_ArrayElemPopFloat, A0, L);
2506	}
2507	#endif
2508	#ifdef GET_EVAL_IMPL
2509	bool EvalEmitter::emitArrayElemPopSint8( uint32_t A0, SourceInfo L) {
2510	if (!isActive()) return true;
2511	CurrentSource = L;
2512	return ArrayElemPop<PT_Sint8>(S, CodePtr(), A0);
2513	}
2514	bool EvalEmitter::emitArrayElemPopUint8( uint32_t A0, SourceInfo L) {
2515	if (!isActive()) return true;
2516	CurrentSource = L;
2517	return ArrayElemPop<PT_Uint8>(S, CodePtr(), A0);
2518	}
2519	bool EvalEmitter::emitArrayElemPopSint16( uint32_t A0, SourceInfo L) {
2520	if (!isActive()) return true;
2521	CurrentSource = L;
2522	return ArrayElemPop<PT_Sint16>(S, CodePtr(), A0);
2523	}
2524	bool EvalEmitter::emitArrayElemPopUint16( uint32_t A0, SourceInfo L) {
2525	if (!isActive()) return true;
2526	CurrentSource = L;
2527	return ArrayElemPop<PT_Uint16>(S, CodePtr(), A0);
2528	}
2529	bool EvalEmitter::emitArrayElemPopSint32( uint32_t A0, SourceInfo L) {
2530	if (!isActive()) return true;
2531	CurrentSource = L;
2532	return ArrayElemPop<PT_Sint32>(S, CodePtr(), A0);
2533	}
2534	bool EvalEmitter::emitArrayElemPopUint32( uint32_t A0, SourceInfo L) {
2535	if (!isActive()) return true;
2536	CurrentSource = L;
2537	return ArrayElemPop<PT_Uint32>(S, CodePtr(), A0);
2538	}
2539	bool EvalEmitter::emitArrayElemPopSint64( uint32_t A0, SourceInfo L) {
2540	if (!isActive()) return true;
2541	CurrentSource = L;
2542	return ArrayElemPop<PT_Sint64>(S, CodePtr(), A0);
2543	}
2544	bool EvalEmitter::emitArrayElemPopUint64( uint32_t A0, SourceInfo L) {
2545	if (!isActive()) return true;
2546	CurrentSource = L;
2547	return ArrayElemPop<PT_Uint64>(S, CodePtr(), A0);
2548	}
2549	bool EvalEmitter::emitArrayElemPopIntAP( uint32_t A0, SourceInfo L) {
2550	if (!isActive()) return true;
2551	CurrentSource = L;
2552	return ArrayElemPop<PT_IntAP>(S, CodePtr(), A0);
2553	}
2554	bool EvalEmitter::emitArrayElemPopIntAPS( uint32_t A0, SourceInfo L) {
2555	if (!isActive()) return true;
2556	CurrentSource = L;
2557	return ArrayElemPop<PT_IntAPS>(S, CodePtr(), A0);
2558	}
2559	bool EvalEmitter::emitArrayElemPopBool( uint32_t A0, SourceInfo L) {
2560	if (!isActive()) return true;
2561	CurrentSource = L;
2562	return ArrayElemPop<PT_Bool>(S, CodePtr(), A0);
2563	}
2564	bool EvalEmitter::emitArrayElemPopFixedPoint( uint32_t A0, SourceInfo L) {
2565	if (!isActive()) return true;
2566	CurrentSource = L;
2567	return ArrayElemPop<PT_FixedPoint>(S, CodePtr(), A0);
2568	}
2569	bool EvalEmitter::emitArrayElemPopPtr( uint32_t A0, SourceInfo L) {
2570	if (!isActive()) return true;
2571	CurrentSource = L;
2572	return ArrayElemPop<PT_Ptr>(S, CodePtr(), A0);
2573	}
2574	bool EvalEmitter::emitArrayElemPopMemberPtr( uint32_t A0, SourceInfo L) {
2575	if (!isActive()) return true;
2576	CurrentSource = L;
2577	return ArrayElemPop<PT_MemberPtr>(S, CodePtr(), A0);
2578	}
2579	bool EvalEmitter::emitArrayElemPopFloat( uint32_t A0, SourceInfo L) {
2580	if (!isActive()) return true;
2581	CurrentSource = L;
2582	return ArrayElemPop<PT_Float>(S, CodePtr(), A0);
2583	}
2584	#endif
2585	#ifdef GET_OPCODE_NAMES
2586	OP_ArrayElemPtrSint8,
2587	OP_ArrayElemPtrUint8,
2588	OP_ArrayElemPtrSint16,
2589	OP_ArrayElemPtrUint16,
2590	OP_ArrayElemPtrSint32,
2591	OP_ArrayElemPtrUint32,
2592	OP_ArrayElemPtrSint64,
2593	OP_ArrayElemPtrUint64,
2594	OP_ArrayElemPtrIntAP,
2595	OP_ArrayElemPtrIntAPS,
2596	OP_ArrayElemPtrBool,
2597	#endif
2598	#ifdef GET_INTERPFN_LIST
2599	&Interp_ArrayElemPtrSint8,
2600	&Interp_ArrayElemPtrUint8,
2601	&Interp_ArrayElemPtrSint16,
2602	&Interp_ArrayElemPtrUint16,
2603	&Interp_ArrayElemPtrSint32,
2604	&Interp_ArrayElemPtrUint32,
2605	&Interp_ArrayElemPtrSint64,
2606	&Interp_ArrayElemPtrUint64,
2607	&Interp_ArrayElemPtrIntAP,
2608	&Interp_ArrayElemPtrIntAPS,
2609	&Interp_ArrayElemPtrBool,
2610	#endif
2611	#ifdef GET_INTERPFN_DISPATCHERS
2612	PRESERVE_NONE
2613	static bool Interp_ArrayElemPtrSint8(InterpState &S) {
2614	if (!ArrayElemPtr<PT_Sint8>(S, S.PC)) return false;
2615	#if USE_TAILCALLS
2616	MUSTTAIL return InterpNext(S);
2617	#else
2618	return true;
2619	#endif
2620	}
2621	PRESERVE_NONE
2622	static bool Interp_ArrayElemPtrUint8(InterpState &S) {
2623	if (!ArrayElemPtr<PT_Uint8>(S, S.PC)) return false;
2624	#if USE_TAILCALLS
2625	MUSTTAIL return InterpNext(S);
2626	#else
2627	return true;
2628	#endif
2629	}
2630	PRESERVE_NONE
2631	static bool Interp_ArrayElemPtrSint16(InterpState &S) {
2632	if (!ArrayElemPtr<PT_Sint16>(S, S.PC)) return false;
2633	#if USE_TAILCALLS
2634	MUSTTAIL return InterpNext(S);
2635	#else
2636	return true;
2637	#endif
2638	}
2639	PRESERVE_NONE
2640	static bool Interp_ArrayElemPtrUint16(InterpState &S) {
2641	if (!ArrayElemPtr<PT_Uint16>(S, S.PC)) return false;
2642	#if USE_TAILCALLS
2643	MUSTTAIL return InterpNext(S);
2644	#else
2645	return true;
2646	#endif
2647	}
2648	PRESERVE_NONE
2649	static bool Interp_ArrayElemPtrSint32(InterpState &S) {
2650	if (!ArrayElemPtr<PT_Sint32>(S, S.PC)) return false;
2651	#if USE_TAILCALLS
2652	MUSTTAIL return InterpNext(S);
2653	#else
2654	return true;
2655	#endif
2656	}
2657	PRESERVE_NONE
2658	static bool Interp_ArrayElemPtrUint32(InterpState &S) {
2659	if (!ArrayElemPtr<PT_Uint32>(S, S.PC)) return false;
2660	#if USE_TAILCALLS
2661	MUSTTAIL return InterpNext(S);
2662	#else
2663	return true;
2664	#endif
2665	}
2666	PRESERVE_NONE
2667	static bool Interp_ArrayElemPtrSint64(InterpState &S) {
2668	if (!ArrayElemPtr<PT_Sint64>(S, S.PC)) return false;
2669	#if USE_TAILCALLS
2670	MUSTTAIL return InterpNext(S);
2671	#else
2672	return true;
2673	#endif
2674	}
2675	PRESERVE_NONE
2676	static bool Interp_ArrayElemPtrUint64(InterpState &S) {
2677	if (!ArrayElemPtr<PT_Uint64>(S, S.PC)) return false;
2678	#if USE_TAILCALLS
2679	MUSTTAIL return InterpNext(S);
2680	#else
2681	return true;
2682	#endif
2683	}
2684	PRESERVE_NONE
2685	static bool Interp_ArrayElemPtrIntAP(InterpState &S) {
2686	if (!ArrayElemPtr<PT_IntAP>(S, S.PC)) return false;
2687	#if USE_TAILCALLS
2688	MUSTTAIL return InterpNext(S);
2689	#else
2690	return true;
2691	#endif
2692	}
2693	PRESERVE_NONE
2694	static bool Interp_ArrayElemPtrIntAPS(InterpState &S) {
2695	if (!ArrayElemPtr<PT_IntAPS>(S, S.PC)) return false;
2696	#if USE_TAILCALLS
2697	MUSTTAIL return InterpNext(S);
2698	#else
2699	return true;
2700	#endif
2701	}
2702	PRESERVE_NONE
2703	static bool Interp_ArrayElemPtrBool(InterpState &S) {
2704	if (!ArrayElemPtr<PT_Bool>(S, S.PC)) return false;
2705	#if USE_TAILCALLS
2706	MUSTTAIL return InterpNext(S);
2707	#else
2708	return true;
2709	#endif
2710	}
2711	#endif
2712	#ifdef GET_DISASM
2713	case OP_ArrayElemPtrSint8:
2714	Text.Op = PrintName("ArrayElemPtrSint8");
2715	break;
2716	case OP_ArrayElemPtrUint8:
2717	Text.Op = PrintName("ArrayElemPtrUint8");
2718	break;
2719	case OP_ArrayElemPtrSint16:
2720	Text.Op = PrintName("ArrayElemPtrSint16");
2721	break;
2722	case OP_ArrayElemPtrUint16:
2723	Text.Op = PrintName("ArrayElemPtrUint16");
2724	break;
2725	case OP_ArrayElemPtrSint32:
2726	Text.Op = PrintName("ArrayElemPtrSint32");
2727	break;
2728	case OP_ArrayElemPtrUint32:
2729	Text.Op = PrintName("ArrayElemPtrUint32");
2730	break;
2731	case OP_ArrayElemPtrSint64:
2732	Text.Op = PrintName("ArrayElemPtrSint64");
2733	break;
2734	case OP_ArrayElemPtrUint64:
2735	Text.Op = PrintName("ArrayElemPtrUint64");
2736	break;
2737	case OP_ArrayElemPtrIntAP:
2738	Text.Op = PrintName("ArrayElemPtrIntAP");
2739	break;
2740	case OP_ArrayElemPtrIntAPS:
2741	Text.Op = PrintName("ArrayElemPtrIntAPS");
2742	break;
2743	case OP_ArrayElemPtrBool:
2744	Text.Op = PrintName("ArrayElemPtrBool");
2745	break;
2746	#endif
2747	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
2748	bool emitArrayElemPtrSint8(SourceInfo);
2749	bool emitArrayElemPtrUint8(SourceInfo);
2750	bool emitArrayElemPtrSint16(SourceInfo);
2751	bool emitArrayElemPtrUint16(SourceInfo);
2752	bool emitArrayElemPtrSint32(SourceInfo);
2753	bool emitArrayElemPtrUint32(SourceInfo);
2754	bool emitArrayElemPtrSint64(SourceInfo);
2755	bool emitArrayElemPtrUint64(SourceInfo);
2756	bool emitArrayElemPtrIntAP(SourceInfo);
2757	bool emitArrayElemPtrIntAPS(SourceInfo);
2758	bool emitArrayElemPtrBool(SourceInfo);
2759	#endif
2760	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
2761	[[nodiscard]] bool emitArrayElemPtr(PrimType, SourceInfo I);
2762	#endif
2763	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
2764	bool
2765	#if defined(GET_EVAL_IMPL)
2766	EvalEmitter
2767	#else
2768	ByteCodeEmitter
2769	#endif
2770	::emitArrayElemPtr(PrimType T0, SourceInfo I) {
2771	switch (T0) {
2772	case PT_Sint8:
2773	return emitArrayElemPtrSint8(I);
2774	case PT_Uint8:
2775	return emitArrayElemPtrUint8(I);
2776	case PT_Sint16:
2777	return emitArrayElemPtrSint16(I);
2778	case PT_Uint16:
2779	return emitArrayElemPtrUint16(I);
2780	case PT_Sint32:
2781	return emitArrayElemPtrSint32(I);
2782	case PT_Uint32:
2783	return emitArrayElemPtrUint32(I);
2784	case PT_Sint64:
2785	return emitArrayElemPtrSint64(I);
2786	case PT_Uint64:
2787	return emitArrayElemPtrUint64(I);
2788	case PT_IntAP:
2789	return emitArrayElemPtrIntAP(I);
2790	case PT_IntAPS:
2791	return emitArrayElemPtrIntAPS(I);
2792	case PT_Bool:
2793	return emitArrayElemPtrBool(I);
2794	default: llvm_unreachable("invalid type: emitArrayElemPtr");
2795	}
2796	llvm_unreachable("invalid enum value");
2797	}
2798	#endif
2799	#ifdef GET_LINK_IMPL
2800	bool ByteCodeEmitter::emitArrayElemPtrSint8(SourceInfo L) {
2801	return emitOp<>(OP_ArrayElemPtrSint8, L);
2802	}
2803	bool ByteCodeEmitter::emitArrayElemPtrUint8(SourceInfo L) {
2804	return emitOp<>(OP_ArrayElemPtrUint8, L);
2805	}
2806	bool ByteCodeEmitter::emitArrayElemPtrSint16(SourceInfo L) {
2807	return emitOp<>(OP_ArrayElemPtrSint16, L);
2808	}
2809	bool ByteCodeEmitter::emitArrayElemPtrUint16(SourceInfo L) {
2810	return emitOp<>(OP_ArrayElemPtrUint16, L);
2811	}
2812	bool ByteCodeEmitter::emitArrayElemPtrSint32(SourceInfo L) {
2813	return emitOp<>(OP_ArrayElemPtrSint32, L);
2814	}
2815	bool ByteCodeEmitter::emitArrayElemPtrUint32(SourceInfo L) {
2816	return emitOp<>(OP_ArrayElemPtrUint32, L);
2817	}
2818	bool ByteCodeEmitter::emitArrayElemPtrSint64(SourceInfo L) {
2819	return emitOp<>(OP_ArrayElemPtrSint64, L);
2820	}
2821	bool ByteCodeEmitter::emitArrayElemPtrUint64(SourceInfo L) {
2822	return emitOp<>(OP_ArrayElemPtrUint64, L);
2823	}
2824	bool ByteCodeEmitter::emitArrayElemPtrIntAP(SourceInfo L) {
2825	return emitOp<>(OP_ArrayElemPtrIntAP, L);
2826	}
2827	bool ByteCodeEmitter::emitArrayElemPtrIntAPS(SourceInfo L) {
2828	return emitOp<>(OP_ArrayElemPtrIntAPS, L);
2829	}
2830	bool ByteCodeEmitter::emitArrayElemPtrBool(SourceInfo L) {
2831	return emitOp<>(OP_ArrayElemPtrBool, L);
2832	}
2833	#endif
2834	#ifdef GET_EVAL_IMPL
2835	bool EvalEmitter::emitArrayElemPtrSint8(SourceInfo L) {
2836	if (!isActive()) return true;
2837	CurrentSource = L;
2838	return ArrayElemPtr<PT_Sint8>(S, CodePtr());
2839	}
2840	bool EvalEmitter::emitArrayElemPtrUint8(SourceInfo L) {
2841	if (!isActive()) return true;
2842	CurrentSource = L;
2843	return ArrayElemPtr<PT_Uint8>(S, CodePtr());
2844	}
2845	bool EvalEmitter::emitArrayElemPtrSint16(SourceInfo L) {
2846	if (!isActive()) return true;
2847	CurrentSource = L;
2848	return ArrayElemPtr<PT_Sint16>(S, CodePtr());
2849	}
2850	bool EvalEmitter::emitArrayElemPtrUint16(SourceInfo L) {
2851	if (!isActive()) return true;
2852	CurrentSource = L;
2853	return ArrayElemPtr<PT_Uint16>(S, CodePtr());
2854	}
2855	bool EvalEmitter::emitArrayElemPtrSint32(SourceInfo L) {
2856	if (!isActive()) return true;
2857	CurrentSource = L;
2858	return ArrayElemPtr<PT_Sint32>(S, CodePtr());
2859	}
2860	bool EvalEmitter::emitArrayElemPtrUint32(SourceInfo L) {
2861	if (!isActive()) return true;
2862	CurrentSource = L;
2863	return ArrayElemPtr<PT_Uint32>(S, CodePtr());
2864	}
2865	bool EvalEmitter::emitArrayElemPtrSint64(SourceInfo L) {
2866	if (!isActive()) return true;
2867	CurrentSource = L;
2868	return ArrayElemPtr<PT_Sint64>(S, CodePtr());
2869	}
2870	bool EvalEmitter::emitArrayElemPtrUint64(SourceInfo L) {
2871	if (!isActive()) return true;
2872	CurrentSource = L;
2873	return ArrayElemPtr<PT_Uint64>(S, CodePtr());
2874	}
2875	bool EvalEmitter::emitArrayElemPtrIntAP(SourceInfo L) {
2876	if (!isActive()) return true;
2877	CurrentSource = L;
2878	return ArrayElemPtr<PT_IntAP>(S, CodePtr());
2879	}
2880	bool EvalEmitter::emitArrayElemPtrIntAPS(SourceInfo L) {
2881	if (!isActive()) return true;
2882	CurrentSource = L;
2883	return ArrayElemPtr<PT_IntAPS>(S, CodePtr());
2884	}
2885	bool EvalEmitter::emitArrayElemPtrBool(SourceInfo L) {
2886	if (!isActive()) return true;
2887	CurrentSource = L;
2888	return ArrayElemPtr<PT_Bool>(S, CodePtr());
2889	}
2890	#endif
2891	#ifdef GET_OPCODE_NAMES
2892	OP_ArrayElemPtrPopSint8,
2893	OP_ArrayElemPtrPopUint8,
2894	OP_ArrayElemPtrPopSint16,
2895	OP_ArrayElemPtrPopUint16,
2896	OP_ArrayElemPtrPopSint32,
2897	OP_ArrayElemPtrPopUint32,
2898	OP_ArrayElemPtrPopSint64,
2899	OP_ArrayElemPtrPopUint64,
2900	OP_ArrayElemPtrPopIntAP,
2901	OP_ArrayElemPtrPopIntAPS,
2902	OP_ArrayElemPtrPopBool,
2903	#endif
2904	#ifdef GET_INTERPFN_LIST
2905	&Interp_ArrayElemPtrPopSint8,
2906	&Interp_ArrayElemPtrPopUint8,
2907	&Interp_ArrayElemPtrPopSint16,
2908	&Interp_ArrayElemPtrPopUint16,
2909	&Interp_ArrayElemPtrPopSint32,
2910	&Interp_ArrayElemPtrPopUint32,
2911	&Interp_ArrayElemPtrPopSint64,
2912	&Interp_ArrayElemPtrPopUint64,
2913	&Interp_ArrayElemPtrPopIntAP,
2914	&Interp_ArrayElemPtrPopIntAPS,
2915	&Interp_ArrayElemPtrPopBool,
2916	#endif
2917	#ifdef GET_INTERPFN_DISPATCHERS
2918	PRESERVE_NONE
2919	static bool Interp_ArrayElemPtrPopSint8(InterpState &S) {
2920	if (!ArrayElemPtrPop<PT_Sint8>(S, S.PC)) return false;
2921	#if USE_TAILCALLS
2922	MUSTTAIL return InterpNext(S);
2923	#else
2924	return true;
2925	#endif
2926	}
2927	PRESERVE_NONE
2928	static bool Interp_ArrayElemPtrPopUint8(InterpState &S) {
2929	if (!ArrayElemPtrPop<PT_Uint8>(S, S.PC)) return false;
2930	#if USE_TAILCALLS
2931	MUSTTAIL return InterpNext(S);
2932	#else
2933	return true;
2934	#endif
2935	}
2936	PRESERVE_NONE
2937	static bool Interp_ArrayElemPtrPopSint16(InterpState &S) {
2938	if (!ArrayElemPtrPop<PT_Sint16>(S, S.PC)) return false;
2939	#if USE_TAILCALLS
2940	MUSTTAIL return InterpNext(S);
2941	#else
2942	return true;
2943	#endif
2944	}
2945	PRESERVE_NONE
2946	static bool Interp_ArrayElemPtrPopUint16(InterpState &S) {
2947	if (!ArrayElemPtrPop<PT_Uint16>(S, S.PC)) return false;
2948	#if USE_TAILCALLS
2949	MUSTTAIL return InterpNext(S);
2950	#else
2951	return true;
2952	#endif
2953	}
2954	PRESERVE_NONE
2955	static bool Interp_ArrayElemPtrPopSint32(InterpState &S) {
2956	if (!ArrayElemPtrPop<PT_Sint32>(S, S.PC)) return false;
2957	#if USE_TAILCALLS
2958	MUSTTAIL return InterpNext(S);
2959	#else
2960	return true;
2961	#endif
2962	}
2963	PRESERVE_NONE
2964	static bool Interp_ArrayElemPtrPopUint32(InterpState &S) {
2965	if (!ArrayElemPtrPop<PT_Uint32>(S, S.PC)) return false;
2966	#if USE_TAILCALLS
2967	MUSTTAIL return InterpNext(S);
2968	#else
2969	return true;
2970	#endif
2971	}
2972	PRESERVE_NONE
2973	static bool Interp_ArrayElemPtrPopSint64(InterpState &S) {
2974	if (!ArrayElemPtrPop<PT_Sint64>(S, S.PC)) return false;
2975	#if USE_TAILCALLS
2976	MUSTTAIL return InterpNext(S);
2977	#else
2978	return true;
2979	#endif
2980	}
2981	PRESERVE_NONE
2982	static bool Interp_ArrayElemPtrPopUint64(InterpState &S) {
2983	if (!ArrayElemPtrPop<PT_Uint64>(S, S.PC)) return false;
2984	#if USE_TAILCALLS
2985	MUSTTAIL return InterpNext(S);
2986	#else
2987	return true;
2988	#endif
2989	}
2990	PRESERVE_NONE
2991	static bool Interp_ArrayElemPtrPopIntAP(InterpState &S) {
2992	if (!ArrayElemPtrPop<PT_IntAP>(S, S.PC)) return false;
2993	#if USE_TAILCALLS
2994	MUSTTAIL return InterpNext(S);
2995	#else
2996	return true;
2997	#endif
2998	}
2999	PRESERVE_NONE
3000	static bool Interp_ArrayElemPtrPopIntAPS(InterpState &S) {
3001	if (!ArrayElemPtrPop<PT_IntAPS>(S, S.PC)) return false;
3002	#if USE_TAILCALLS
3003	MUSTTAIL return InterpNext(S);
3004	#else
3005	return true;
3006	#endif
3007	}
3008	PRESERVE_NONE
3009	static bool Interp_ArrayElemPtrPopBool(InterpState &S) {
3010	if (!ArrayElemPtrPop<PT_Bool>(S, S.PC)) return false;
3011	#if USE_TAILCALLS
3012	MUSTTAIL return InterpNext(S);
3013	#else
3014	return true;
3015	#endif
3016	}
3017	#endif
3018	#ifdef GET_DISASM
3019	case OP_ArrayElemPtrPopSint8:
3020	Text.Op = PrintName("ArrayElemPtrPopSint8");
3021	break;
3022	case OP_ArrayElemPtrPopUint8:
3023	Text.Op = PrintName("ArrayElemPtrPopUint8");
3024	break;
3025	case OP_ArrayElemPtrPopSint16:
3026	Text.Op = PrintName("ArrayElemPtrPopSint16");
3027	break;
3028	case OP_ArrayElemPtrPopUint16:
3029	Text.Op = PrintName("ArrayElemPtrPopUint16");
3030	break;
3031	case OP_ArrayElemPtrPopSint32:
3032	Text.Op = PrintName("ArrayElemPtrPopSint32");
3033	break;
3034	case OP_ArrayElemPtrPopUint32:
3035	Text.Op = PrintName("ArrayElemPtrPopUint32");
3036	break;
3037	case OP_ArrayElemPtrPopSint64:
3038	Text.Op = PrintName("ArrayElemPtrPopSint64");
3039	break;
3040	case OP_ArrayElemPtrPopUint64:
3041	Text.Op = PrintName("ArrayElemPtrPopUint64");
3042	break;
3043	case OP_ArrayElemPtrPopIntAP:
3044	Text.Op = PrintName("ArrayElemPtrPopIntAP");
3045	break;
3046	case OP_ArrayElemPtrPopIntAPS:
3047	Text.Op = PrintName("ArrayElemPtrPopIntAPS");
3048	break;
3049	case OP_ArrayElemPtrPopBool:
3050	Text.Op = PrintName("ArrayElemPtrPopBool");
3051	break;
3052	#endif
3053	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3054	bool emitArrayElemPtrPopSint8(SourceInfo);
3055	bool emitArrayElemPtrPopUint8(SourceInfo);
3056	bool emitArrayElemPtrPopSint16(SourceInfo);
3057	bool emitArrayElemPtrPopUint16(SourceInfo);
3058	bool emitArrayElemPtrPopSint32(SourceInfo);
3059	bool emitArrayElemPtrPopUint32(SourceInfo);
3060	bool emitArrayElemPtrPopSint64(SourceInfo);
3061	bool emitArrayElemPtrPopUint64(SourceInfo);
3062	bool emitArrayElemPtrPopIntAP(SourceInfo);
3063	bool emitArrayElemPtrPopIntAPS(SourceInfo);
3064	bool emitArrayElemPtrPopBool(SourceInfo);
3065	#endif
3066	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3067	[[nodiscard]] bool emitArrayElemPtrPop(PrimType, SourceInfo I);
3068	#endif
3069	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
3070	bool
3071	#if defined(GET_EVAL_IMPL)
3072	EvalEmitter
3073	#else
3074	ByteCodeEmitter
3075	#endif
3076	::emitArrayElemPtrPop(PrimType T0, SourceInfo I) {
3077	switch (T0) {
3078	case PT_Sint8:
3079	return emitArrayElemPtrPopSint8(I);
3080	case PT_Uint8:
3081	return emitArrayElemPtrPopUint8(I);
3082	case PT_Sint16:
3083	return emitArrayElemPtrPopSint16(I);
3084	case PT_Uint16:
3085	return emitArrayElemPtrPopUint16(I);
3086	case PT_Sint32:
3087	return emitArrayElemPtrPopSint32(I);
3088	case PT_Uint32:
3089	return emitArrayElemPtrPopUint32(I);
3090	case PT_Sint64:
3091	return emitArrayElemPtrPopSint64(I);
3092	case PT_Uint64:
3093	return emitArrayElemPtrPopUint64(I);
3094	case PT_IntAP:
3095	return emitArrayElemPtrPopIntAP(I);
3096	case PT_IntAPS:
3097	return emitArrayElemPtrPopIntAPS(I);
3098	case PT_Bool:
3099	return emitArrayElemPtrPopBool(I);
3100	default: llvm_unreachable("invalid type: emitArrayElemPtrPop");
3101	}
3102	llvm_unreachable("invalid enum value");
3103	}
3104	#endif
3105	#ifdef GET_LINK_IMPL
3106	bool ByteCodeEmitter::emitArrayElemPtrPopSint8(SourceInfo L) {
3107	return emitOp<>(OP_ArrayElemPtrPopSint8, L);
3108	}
3109	bool ByteCodeEmitter::emitArrayElemPtrPopUint8(SourceInfo L) {
3110	return emitOp<>(OP_ArrayElemPtrPopUint8, L);
3111	}
3112	bool ByteCodeEmitter::emitArrayElemPtrPopSint16(SourceInfo L) {
3113	return emitOp<>(OP_ArrayElemPtrPopSint16, L);
3114	}
3115	bool ByteCodeEmitter::emitArrayElemPtrPopUint16(SourceInfo L) {
3116	return emitOp<>(OP_ArrayElemPtrPopUint16, L);
3117	}
3118	bool ByteCodeEmitter::emitArrayElemPtrPopSint32(SourceInfo L) {
3119	return emitOp<>(OP_ArrayElemPtrPopSint32, L);
3120	}
3121	bool ByteCodeEmitter::emitArrayElemPtrPopUint32(SourceInfo L) {
3122	return emitOp<>(OP_ArrayElemPtrPopUint32, L);
3123	}
3124	bool ByteCodeEmitter::emitArrayElemPtrPopSint64(SourceInfo L) {
3125	return emitOp<>(OP_ArrayElemPtrPopSint64, L);
3126	}
3127	bool ByteCodeEmitter::emitArrayElemPtrPopUint64(SourceInfo L) {
3128	return emitOp<>(OP_ArrayElemPtrPopUint64, L);
3129	}
3130	bool ByteCodeEmitter::emitArrayElemPtrPopIntAP(SourceInfo L) {
3131	return emitOp<>(OP_ArrayElemPtrPopIntAP, L);
3132	}
3133	bool ByteCodeEmitter::emitArrayElemPtrPopIntAPS(SourceInfo L) {
3134	return emitOp<>(OP_ArrayElemPtrPopIntAPS, L);
3135	}
3136	bool ByteCodeEmitter::emitArrayElemPtrPopBool(SourceInfo L) {
3137	return emitOp<>(OP_ArrayElemPtrPopBool, L);
3138	}
3139	#endif
3140	#ifdef GET_EVAL_IMPL
3141	bool EvalEmitter::emitArrayElemPtrPopSint8(SourceInfo L) {
3142	if (!isActive()) return true;
3143	CurrentSource = L;
3144	return ArrayElemPtrPop<PT_Sint8>(S, CodePtr());
3145	}
3146	bool EvalEmitter::emitArrayElemPtrPopUint8(SourceInfo L) {
3147	if (!isActive()) return true;
3148	CurrentSource = L;
3149	return ArrayElemPtrPop<PT_Uint8>(S, CodePtr());
3150	}
3151	bool EvalEmitter::emitArrayElemPtrPopSint16(SourceInfo L) {
3152	if (!isActive()) return true;
3153	CurrentSource = L;
3154	return ArrayElemPtrPop<PT_Sint16>(S, CodePtr());
3155	}
3156	bool EvalEmitter::emitArrayElemPtrPopUint16(SourceInfo L) {
3157	if (!isActive()) return true;
3158	CurrentSource = L;
3159	return ArrayElemPtrPop<PT_Uint16>(S, CodePtr());
3160	}
3161	bool EvalEmitter::emitArrayElemPtrPopSint32(SourceInfo L) {
3162	if (!isActive()) return true;
3163	CurrentSource = L;
3164	return ArrayElemPtrPop<PT_Sint32>(S, CodePtr());
3165	}
3166	bool EvalEmitter::emitArrayElemPtrPopUint32(SourceInfo L) {
3167	if (!isActive()) return true;
3168	CurrentSource = L;
3169	return ArrayElemPtrPop<PT_Uint32>(S, CodePtr());
3170	}
3171	bool EvalEmitter::emitArrayElemPtrPopSint64(SourceInfo L) {
3172	if (!isActive()) return true;
3173	CurrentSource = L;
3174	return ArrayElemPtrPop<PT_Sint64>(S, CodePtr());
3175	}
3176	bool EvalEmitter::emitArrayElemPtrPopUint64(SourceInfo L) {
3177	if (!isActive()) return true;
3178	CurrentSource = L;
3179	return ArrayElemPtrPop<PT_Uint64>(S, CodePtr());
3180	}
3181	bool EvalEmitter::emitArrayElemPtrPopIntAP(SourceInfo L) {
3182	if (!isActive()) return true;
3183	CurrentSource = L;
3184	return ArrayElemPtrPop<PT_IntAP>(S, CodePtr());
3185	}
3186	bool EvalEmitter::emitArrayElemPtrPopIntAPS(SourceInfo L) {
3187	if (!isActive()) return true;
3188	CurrentSource = L;
3189	return ArrayElemPtrPop<PT_IntAPS>(S, CodePtr());
3190	}
3191	bool EvalEmitter::emitArrayElemPtrPopBool(SourceInfo L) {
3192	if (!isActive()) return true;
3193	CurrentSource = L;
3194	return ArrayElemPtrPop<PT_Bool>(S, CodePtr());
3195	}
3196	#endif
3197	#ifdef GET_OPCODE_NAMES
3198	OP_Assume,
3199	#endif
3200	#ifdef GET_INTERPFN_LIST
3201	&Interp_Assume,
3202	#endif
3203	#ifdef GET_INTERPFN_DISPATCHERS
3204	PRESERVE_NONE
3205	static bool Interp_Assume(InterpState &S) {
3206	if (!Assume(S, S.PC)) return false;
3207	#if USE_TAILCALLS
3208	MUSTTAIL return InterpNext(S);
3209	#else
3210	return true;
3211	#endif
3212	}
3213	#endif
3214	#ifdef GET_DISASM
3215	case OP_Assume:
3216	Text.Op = PrintName("Assume");
3217	break;
3218	#endif
3219	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3220	bool emitAssume(SourceInfo);
3221	#endif
3222	#ifdef GET_LINK_IMPL
3223	bool ByteCodeEmitter::emitAssume(SourceInfo L) {
3224	return emitOp<>(OP_Assume, L);
3225	}
3226	#endif
3227	#ifdef GET_EVAL_IMPL
3228	bool EvalEmitter::emitAssume(SourceInfo L) {
3229	if (!isActive()) return true;
3230	CurrentSource = L;
3231	return Assume(S, CodePtr());
3232	}
3233	#endif
3234	#ifdef GET_OPCODE_NAMES
3235	OP_BCP,
3236	#endif
3237	#ifdef GET_INTERPFN_LIST
3238	&Interp_BCP,
3239	#endif
3240	#ifdef GET_INTERPFN_DISPATCHERS
3241	PRESERVE_NONE
3242	static bool Interp_BCP(InterpState &S) {
3243	{
3244	CodePtr OpPC = S.PC;
3245	const auto V0 = ReadArg<int32_t>(S, S.PC);
3246	const auto V1 = ReadArg<PrimType>(S, S.PC);
3247	if (!BCP(S, OpPC, V0, V1)) return false;
3248	}
3249	#if USE_TAILCALLS
3250	MUSTTAIL return InterpNext(S);
3251	#else
3252	return true;
3253	#endif
3254	}
3255	#endif
3256	#ifdef GET_DISASM
3257	case OP_BCP:
3258	Text.Op = PrintName("BCP");
3259	Text.Args.push_back(printArg<int32_t>(P, PC));
3260	Text.Args.push_back(printArg<PrimType>(P, PC));
3261	break;
3262	#endif
3263	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3264	bool emitBCP( int32_t , PrimType , SourceInfo);
3265	#endif
3266	#ifdef GET_LINK_IMPL
3267	bool ByteCodeEmitter::emitBCP( int32_t A0, PrimType A1, SourceInfo L) {
3268	return emitOp<int32_t, PrimType>(OP_BCP, A0, A1, L);
3269	}
3270	#endif
3271	#ifdef GET_OPCODE_NAMES
3272	OP_BitAndSint8,
3273	OP_BitAndUint8,
3274	OP_BitAndSint16,
3275	OP_BitAndUint16,
3276	OP_BitAndSint32,
3277	OP_BitAndUint32,
3278	OP_BitAndSint64,
3279	OP_BitAndUint64,
3280	OP_BitAndIntAP,
3281	OP_BitAndIntAPS,
3282	OP_BitAndFixedPoint,
3283	#endif
3284	#ifdef GET_INTERPFN_LIST
3285	&Interp_BitAndSint8,
3286	&Interp_BitAndUint8,
3287	&Interp_BitAndSint16,
3288	&Interp_BitAndUint16,
3289	&Interp_BitAndSint32,
3290	&Interp_BitAndUint32,
3291	&Interp_BitAndSint64,
3292	&Interp_BitAndUint64,
3293	&Interp_BitAndIntAP,
3294	&Interp_BitAndIntAPS,
3295	&Interp_BitAndFixedPoint,
3296	#endif
3297	#ifdef GET_INTERPFN_DISPATCHERS
3298	PRESERVE_NONE
3299	static bool Interp_BitAndSint8(InterpState &S) {
3300	if (!BitAnd<PT_Sint8>(S)) return false;
3301	#if USE_TAILCALLS
3302	MUSTTAIL return InterpNext(S);
3303	#else
3304	return true;
3305	#endif
3306	}
3307	PRESERVE_NONE
3308	static bool Interp_BitAndUint8(InterpState &S) {
3309	if (!BitAnd<PT_Uint8>(S)) return false;
3310	#if USE_TAILCALLS
3311	MUSTTAIL return InterpNext(S);
3312	#else
3313	return true;
3314	#endif
3315	}
3316	PRESERVE_NONE
3317	static bool Interp_BitAndSint16(InterpState &S) {
3318	if (!BitAnd<PT_Sint16>(S)) return false;
3319	#if USE_TAILCALLS
3320	MUSTTAIL return InterpNext(S);
3321	#else
3322	return true;
3323	#endif
3324	}
3325	PRESERVE_NONE
3326	static bool Interp_BitAndUint16(InterpState &S) {
3327	if (!BitAnd<PT_Uint16>(S)) return false;
3328	#if USE_TAILCALLS
3329	MUSTTAIL return InterpNext(S);
3330	#else
3331	return true;
3332	#endif
3333	}
3334	PRESERVE_NONE
3335	static bool Interp_BitAndSint32(InterpState &S) {
3336	if (!BitAnd<PT_Sint32>(S)) return false;
3337	#if USE_TAILCALLS
3338	MUSTTAIL return InterpNext(S);
3339	#else
3340	return true;
3341	#endif
3342	}
3343	PRESERVE_NONE
3344	static bool Interp_BitAndUint32(InterpState &S) {
3345	if (!BitAnd<PT_Uint32>(S)) return false;
3346	#if USE_TAILCALLS
3347	MUSTTAIL return InterpNext(S);
3348	#else
3349	return true;
3350	#endif
3351	}
3352	PRESERVE_NONE
3353	static bool Interp_BitAndSint64(InterpState &S) {
3354	if (!BitAnd<PT_Sint64>(S)) return false;
3355	#if USE_TAILCALLS
3356	MUSTTAIL return InterpNext(S);
3357	#else
3358	return true;
3359	#endif
3360	}
3361	PRESERVE_NONE
3362	static bool Interp_BitAndUint64(InterpState &S) {
3363	if (!BitAnd<PT_Uint64>(S)) return false;
3364	#if USE_TAILCALLS
3365	MUSTTAIL return InterpNext(S);
3366	#else
3367	return true;
3368	#endif
3369	}
3370	PRESERVE_NONE
3371	static bool Interp_BitAndIntAP(InterpState &S) {
3372	if (!BitAnd<PT_IntAP>(S)) return false;
3373	#if USE_TAILCALLS
3374	MUSTTAIL return InterpNext(S);
3375	#else
3376	return true;
3377	#endif
3378	}
3379	PRESERVE_NONE
3380	static bool Interp_BitAndIntAPS(InterpState &S) {
3381	if (!BitAnd<PT_IntAPS>(S)) return false;
3382	#if USE_TAILCALLS
3383	MUSTTAIL return InterpNext(S);
3384	#else
3385	return true;
3386	#endif
3387	}
3388	PRESERVE_NONE
3389	static bool Interp_BitAndFixedPoint(InterpState &S) {
3390	if (!BitAnd<PT_FixedPoint>(S)) return false;
3391	#if USE_TAILCALLS
3392	MUSTTAIL return InterpNext(S);
3393	#else
3394	return true;
3395	#endif
3396	}
3397	#endif
3398	#ifdef GET_DISASM
3399	case OP_BitAndSint8:
3400	Text.Op = PrintName("BitAndSint8");
3401	break;
3402	case OP_BitAndUint8:
3403	Text.Op = PrintName("BitAndUint8");
3404	break;
3405	case OP_BitAndSint16:
3406	Text.Op = PrintName("BitAndSint16");
3407	break;
3408	case OP_BitAndUint16:
3409	Text.Op = PrintName("BitAndUint16");
3410	break;
3411	case OP_BitAndSint32:
3412	Text.Op = PrintName("BitAndSint32");
3413	break;
3414	case OP_BitAndUint32:
3415	Text.Op = PrintName("BitAndUint32");
3416	break;
3417	case OP_BitAndSint64:
3418	Text.Op = PrintName("BitAndSint64");
3419	break;
3420	case OP_BitAndUint64:
3421	Text.Op = PrintName("BitAndUint64");
3422	break;
3423	case OP_BitAndIntAP:
3424	Text.Op = PrintName("BitAndIntAP");
3425	break;
3426	case OP_BitAndIntAPS:
3427	Text.Op = PrintName("BitAndIntAPS");
3428	break;
3429	case OP_BitAndFixedPoint:
3430	Text.Op = PrintName("BitAndFixedPoint");
3431	break;
3432	#endif
3433	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3434	bool emitBitAndSint8(SourceInfo);
3435	bool emitBitAndUint8(SourceInfo);
3436	bool emitBitAndSint16(SourceInfo);
3437	bool emitBitAndUint16(SourceInfo);
3438	bool emitBitAndSint32(SourceInfo);
3439	bool emitBitAndUint32(SourceInfo);
3440	bool emitBitAndSint64(SourceInfo);
3441	bool emitBitAndUint64(SourceInfo);
3442	bool emitBitAndIntAP(SourceInfo);
3443	bool emitBitAndIntAPS(SourceInfo);
3444	bool emitBitAndFixedPoint(SourceInfo);
3445	#endif
3446	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3447	[[nodiscard]] bool emitBitAnd(PrimType, SourceInfo I);
3448	#endif
3449	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
3450	bool
3451	#if defined(GET_EVAL_IMPL)
3452	EvalEmitter
3453	#else
3454	ByteCodeEmitter
3455	#endif
3456	::emitBitAnd(PrimType T0, SourceInfo I) {
3457	switch (T0) {
3458	case PT_Sint8:
3459	return emitBitAndSint8(I);
3460	case PT_Uint8:
3461	return emitBitAndUint8(I);
3462	case PT_Sint16:
3463	return emitBitAndSint16(I);
3464	case PT_Uint16:
3465	return emitBitAndUint16(I);
3466	case PT_Sint32:
3467	return emitBitAndSint32(I);
3468	case PT_Uint32:
3469	return emitBitAndUint32(I);
3470	case PT_Sint64:
3471	return emitBitAndSint64(I);
3472	case PT_Uint64:
3473	return emitBitAndUint64(I);
3474	case PT_IntAP:
3475	return emitBitAndIntAP(I);
3476	case PT_IntAPS:
3477	return emitBitAndIntAPS(I);
3478	case PT_FixedPoint:
3479	return emitBitAndFixedPoint(I);
3480	default: llvm_unreachable("invalid type: emitBitAnd");
3481	}
3482	llvm_unreachable("invalid enum value");
3483	}
3484	#endif
3485	#ifdef GET_LINK_IMPL
3486	bool ByteCodeEmitter::emitBitAndSint8(SourceInfo L) {
3487	return emitOp<>(OP_BitAndSint8, L);
3488	}
3489	bool ByteCodeEmitter::emitBitAndUint8(SourceInfo L) {
3490	return emitOp<>(OP_BitAndUint8, L);
3491	}
3492	bool ByteCodeEmitter::emitBitAndSint16(SourceInfo L) {
3493	return emitOp<>(OP_BitAndSint16, L);
3494	}
3495	bool ByteCodeEmitter::emitBitAndUint16(SourceInfo L) {
3496	return emitOp<>(OP_BitAndUint16, L);
3497	}
3498	bool ByteCodeEmitter::emitBitAndSint32(SourceInfo L) {
3499	return emitOp<>(OP_BitAndSint32, L);
3500	}
3501	bool ByteCodeEmitter::emitBitAndUint32(SourceInfo L) {
3502	return emitOp<>(OP_BitAndUint32, L);
3503	}
3504	bool ByteCodeEmitter::emitBitAndSint64(SourceInfo L) {
3505	return emitOp<>(OP_BitAndSint64, L);
3506	}
3507	bool ByteCodeEmitter::emitBitAndUint64(SourceInfo L) {
3508	return emitOp<>(OP_BitAndUint64, L);
3509	}
3510	bool ByteCodeEmitter::emitBitAndIntAP(SourceInfo L) {
3511	return emitOp<>(OP_BitAndIntAP, L);
3512	}
3513	bool ByteCodeEmitter::emitBitAndIntAPS(SourceInfo L) {
3514	return emitOp<>(OP_BitAndIntAPS, L);
3515	}
3516	bool ByteCodeEmitter::emitBitAndFixedPoint(SourceInfo L) {
3517	return emitOp<>(OP_BitAndFixedPoint, L);
3518	}
3519	#endif
3520	#ifdef GET_EVAL_IMPL
3521	bool EvalEmitter::emitBitAndSint8(SourceInfo L) {
3522	if (!isActive()) return true;
3523	CurrentSource = L;
3524	return BitAnd<PT_Sint8>(S);
3525	}
3526	bool EvalEmitter::emitBitAndUint8(SourceInfo L) {
3527	if (!isActive()) return true;
3528	CurrentSource = L;
3529	return BitAnd<PT_Uint8>(S);
3530	}
3531	bool EvalEmitter::emitBitAndSint16(SourceInfo L) {
3532	if (!isActive()) return true;
3533	CurrentSource = L;
3534	return BitAnd<PT_Sint16>(S);
3535	}
3536	bool EvalEmitter::emitBitAndUint16(SourceInfo L) {
3537	if (!isActive()) return true;
3538	CurrentSource = L;
3539	return BitAnd<PT_Uint16>(S);
3540	}
3541	bool EvalEmitter::emitBitAndSint32(SourceInfo L) {
3542	if (!isActive()) return true;
3543	CurrentSource = L;
3544	return BitAnd<PT_Sint32>(S);
3545	}
3546	bool EvalEmitter::emitBitAndUint32(SourceInfo L) {
3547	if (!isActive()) return true;
3548	CurrentSource = L;
3549	return BitAnd<PT_Uint32>(S);
3550	}
3551	bool EvalEmitter::emitBitAndSint64(SourceInfo L) {
3552	if (!isActive()) return true;
3553	CurrentSource = L;
3554	return BitAnd<PT_Sint64>(S);
3555	}
3556	bool EvalEmitter::emitBitAndUint64(SourceInfo L) {
3557	if (!isActive()) return true;
3558	CurrentSource = L;
3559	return BitAnd<PT_Uint64>(S);
3560	}
3561	bool EvalEmitter::emitBitAndIntAP(SourceInfo L) {
3562	if (!isActive()) return true;
3563	CurrentSource = L;
3564	return BitAnd<PT_IntAP>(S);
3565	}
3566	bool EvalEmitter::emitBitAndIntAPS(SourceInfo L) {
3567	if (!isActive()) return true;
3568	CurrentSource = L;
3569	return BitAnd<PT_IntAPS>(S);
3570	}
3571	bool EvalEmitter::emitBitAndFixedPoint(SourceInfo L) {
3572	if (!isActive()) return true;
3573	CurrentSource = L;
3574	return BitAnd<PT_FixedPoint>(S);
3575	}
3576	#endif
3577	#ifdef GET_OPCODE_NAMES
3578	OP_BitCast,
3579	#endif
3580	#ifdef GET_INTERPFN_LIST
3581	&Interp_BitCast,
3582	#endif
3583	#ifdef GET_INTERPFN_DISPATCHERS
3584	PRESERVE_NONE
3585	static bool Interp_BitCast(InterpState &S) {
3586	if (!BitCast(S, S.PC)) return false;
3587	#if USE_TAILCALLS
3588	MUSTTAIL return InterpNext(S);
3589	#else
3590	return true;
3591	#endif
3592	}
3593	#endif
3594	#ifdef GET_DISASM
3595	case OP_BitCast:
3596	Text.Op = PrintName("BitCast");
3597	break;
3598	#endif
3599	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3600	bool emitBitCast(SourceInfo);
3601	#endif
3602	#ifdef GET_LINK_IMPL
3603	bool ByteCodeEmitter::emitBitCast(SourceInfo L) {
3604	return emitOp<>(OP_BitCast, L);
3605	}
3606	#endif
3607	#ifdef GET_EVAL_IMPL
3608	bool EvalEmitter::emitBitCast(SourceInfo L) {
3609	if (!isActive()) return true;
3610	CurrentSource = L;
3611	return BitCast(S, CodePtr());
3612	}
3613	#endif
3614	#ifdef GET_OPCODE_NAMES
3615	OP_BitCastPrimUint8,
3616	OP_BitCastPrimSint8,
3617	OP_BitCastPrimUint16,
3618	OP_BitCastPrimSint16,
3619	OP_BitCastPrimUint32,
3620	OP_BitCastPrimSint32,
3621	OP_BitCastPrimUint64,
3622	OP_BitCastPrimSint64,
3623	OP_BitCastPrimIntAP,
3624	OP_BitCastPrimIntAPS,
3625	OP_BitCastPrimBool,
3626	OP_BitCastPrimFloat,
3627	OP_BitCastPrimPtr,
3628	OP_BitCastPrimMemberPtr,
3629	#endif
3630	#ifdef GET_INTERPFN_LIST
3631	&Interp_BitCastPrimUint8,
3632	&Interp_BitCastPrimSint8,
3633	&Interp_BitCastPrimUint16,
3634	&Interp_BitCastPrimSint16,
3635	&Interp_BitCastPrimUint32,
3636	&Interp_BitCastPrimSint32,
3637	&Interp_BitCastPrimUint64,
3638	&Interp_BitCastPrimSint64,
3639	&Interp_BitCastPrimIntAP,
3640	&Interp_BitCastPrimIntAPS,
3641	&Interp_BitCastPrimBool,
3642	&Interp_BitCastPrimFloat,
3643	&Interp_BitCastPrimPtr,
3644	&Interp_BitCastPrimMemberPtr,
3645	#endif
3646	#ifdef GET_INTERPFN_DISPATCHERS
3647	PRESERVE_NONE
3648	static bool Interp_BitCastPrimUint8(InterpState &S) {
3649	{
3650	CodePtr OpPC = S.PC;
3651	const auto V0 = ReadArg<bool>(S, S.PC);
3652	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3653	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3654	const auto V3 = ReadArg<const Type *>(S, S.PC);
3655	if (!BitCastPrim<PT_Uint8>(S, OpPC, V0, V1, V2, V3)) return false;
3656	}
3657	#if USE_TAILCALLS
3658	MUSTTAIL return InterpNext(S);
3659	#else
3660	return true;
3661	#endif
3662	}
3663	PRESERVE_NONE
3664	static bool Interp_BitCastPrimSint8(InterpState &S) {
3665	{
3666	CodePtr OpPC = S.PC;
3667	const auto V0 = ReadArg<bool>(S, S.PC);
3668	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3669	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3670	const auto V3 = ReadArg<const Type *>(S, S.PC);
3671	if (!BitCastPrim<PT_Sint8>(S, OpPC, V0, V1, V2, V3)) return false;
3672	}
3673	#if USE_TAILCALLS
3674	MUSTTAIL return InterpNext(S);
3675	#else
3676	return true;
3677	#endif
3678	}
3679	PRESERVE_NONE
3680	static bool Interp_BitCastPrimUint16(InterpState &S) {
3681	{
3682	CodePtr OpPC = S.PC;
3683	const auto V0 = ReadArg<bool>(S, S.PC);
3684	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3685	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3686	const auto V3 = ReadArg<const Type *>(S, S.PC);
3687	if (!BitCastPrim<PT_Uint16>(S, OpPC, V0, V1, V2, V3)) return false;
3688	}
3689	#if USE_TAILCALLS
3690	MUSTTAIL return InterpNext(S);
3691	#else
3692	return true;
3693	#endif
3694	}
3695	PRESERVE_NONE
3696	static bool Interp_BitCastPrimSint16(InterpState &S) {
3697	{
3698	CodePtr OpPC = S.PC;
3699	const auto V0 = ReadArg<bool>(S, S.PC);
3700	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3701	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3702	const auto V3 = ReadArg<const Type *>(S, S.PC);
3703	if (!BitCastPrim<PT_Sint16>(S, OpPC, V0, V1, V2, V3)) return false;
3704	}
3705	#if USE_TAILCALLS
3706	MUSTTAIL return InterpNext(S);
3707	#else
3708	return true;
3709	#endif
3710	}
3711	PRESERVE_NONE
3712	static bool Interp_BitCastPrimUint32(InterpState &S) {
3713	{
3714	CodePtr OpPC = S.PC;
3715	const auto V0 = ReadArg<bool>(S, S.PC);
3716	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3717	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3718	const auto V3 = ReadArg<const Type *>(S, S.PC);
3719	if (!BitCastPrim<PT_Uint32>(S, OpPC, V0, V1, V2, V3)) return false;
3720	}
3721	#if USE_TAILCALLS
3722	MUSTTAIL return InterpNext(S);
3723	#else
3724	return true;
3725	#endif
3726	}
3727	PRESERVE_NONE
3728	static bool Interp_BitCastPrimSint32(InterpState &S) {
3729	{
3730	CodePtr OpPC = S.PC;
3731	const auto V0 = ReadArg<bool>(S, S.PC);
3732	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3733	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3734	const auto V3 = ReadArg<const Type *>(S, S.PC);
3735	if (!BitCastPrim<PT_Sint32>(S, OpPC, V0, V1, V2, V3)) return false;
3736	}
3737	#if USE_TAILCALLS
3738	MUSTTAIL return InterpNext(S);
3739	#else
3740	return true;
3741	#endif
3742	}
3743	PRESERVE_NONE
3744	static bool Interp_BitCastPrimUint64(InterpState &S) {
3745	{
3746	CodePtr OpPC = S.PC;
3747	const auto V0 = ReadArg<bool>(S, S.PC);
3748	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3749	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3750	const auto V3 = ReadArg<const Type *>(S, S.PC);
3751	if (!BitCastPrim<PT_Uint64>(S, OpPC, V0, V1, V2, V3)) return false;
3752	}
3753	#if USE_TAILCALLS
3754	MUSTTAIL return InterpNext(S);
3755	#else
3756	return true;
3757	#endif
3758	}
3759	PRESERVE_NONE
3760	static bool Interp_BitCastPrimSint64(InterpState &S) {
3761	{
3762	CodePtr OpPC = S.PC;
3763	const auto V0 = ReadArg<bool>(S, S.PC);
3764	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3765	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3766	const auto V3 = ReadArg<const Type *>(S, S.PC);
3767	if (!BitCastPrim<PT_Sint64>(S, OpPC, V0, V1, V2, V3)) return false;
3768	}
3769	#if USE_TAILCALLS
3770	MUSTTAIL return InterpNext(S);
3771	#else
3772	return true;
3773	#endif
3774	}
3775	PRESERVE_NONE
3776	static bool Interp_BitCastPrimIntAP(InterpState &S) {
3777	{
3778	CodePtr OpPC = S.PC;
3779	const auto V0 = ReadArg<bool>(S, S.PC);
3780	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3781	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3782	const auto V3 = ReadArg<const Type *>(S, S.PC);
3783	if (!BitCastPrim<PT_IntAP>(S, OpPC, V0, V1, V2, V3)) return false;
3784	}
3785	#if USE_TAILCALLS
3786	MUSTTAIL return InterpNext(S);
3787	#else
3788	return true;
3789	#endif
3790	}
3791	PRESERVE_NONE
3792	static bool Interp_BitCastPrimIntAPS(InterpState &S) {
3793	{
3794	CodePtr OpPC = S.PC;
3795	const auto V0 = ReadArg<bool>(S, S.PC);
3796	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3797	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3798	const auto V3 = ReadArg<const Type *>(S, S.PC);
3799	if (!BitCastPrim<PT_IntAPS>(S, OpPC, V0, V1, V2, V3)) return false;
3800	}
3801	#if USE_TAILCALLS
3802	MUSTTAIL return InterpNext(S);
3803	#else
3804	return true;
3805	#endif
3806	}
3807	PRESERVE_NONE
3808	static bool Interp_BitCastPrimBool(InterpState &S) {
3809	{
3810	CodePtr OpPC = S.PC;
3811	const auto V0 = ReadArg<bool>(S, S.PC);
3812	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3813	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3814	const auto V3 = ReadArg<const Type *>(S, S.PC);
3815	if (!BitCastPrim<PT_Bool>(S, OpPC, V0, V1, V2, V3)) return false;
3816	}
3817	#if USE_TAILCALLS
3818	MUSTTAIL return InterpNext(S);
3819	#else
3820	return true;
3821	#endif
3822	}
3823	PRESERVE_NONE
3824	static bool Interp_BitCastPrimFloat(InterpState &S) {
3825	{
3826	CodePtr OpPC = S.PC;
3827	const auto V0 = ReadArg<bool>(S, S.PC);
3828	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3829	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3830	const auto V3 = ReadArg<const Type *>(S, S.PC);
3831	if (!BitCastPrim<PT_Float>(S, OpPC, V0, V1, V2, V3)) return false;
3832	}
3833	#if USE_TAILCALLS
3834	MUSTTAIL return InterpNext(S);
3835	#else
3836	return true;
3837	#endif
3838	}
3839	PRESERVE_NONE
3840	static bool Interp_BitCastPrimPtr(InterpState &S) {
3841	{
3842	CodePtr OpPC = S.PC;
3843	const auto V0 = ReadArg<bool>(S, S.PC);
3844	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3845	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3846	const auto V3 = ReadArg<const Type *>(S, S.PC);
3847	if (!BitCastPrim<PT_Ptr>(S, OpPC, V0, V1, V2, V3)) return false;
3848	}
3849	#if USE_TAILCALLS
3850	MUSTTAIL return InterpNext(S);
3851	#else
3852	return true;
3853	#endif
3854	}
3855	PRESERVE_NONE
3856	static bool Interp_BitCastPrimMemberPtr(InterpState &S) {
3857	{
3858	CodePtr OpPC = S.PC;
3859	const auto V0 = ReadArg<bool>(S, S.PC);
3860	const auto V1 = ReadArg<uint32_t>(S, S.PC);
3861	const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3862	const auto V3 = ReadArg<const Type *>(S, S.PC);
3863	if (!BitCastPrim<PT_MemberPtr>(S, OpPC, V0, V1, V2, V3)) return false;
3864	}
3865	#if USE_TAILCALLS
3866	MUSTTAIL return InterpNext(S);
3867	#else
3868	return true;
3869	#endif
3870	}
3871	#endif
3872	#ifdef GET_DISASM
3873	case OP_BitCastPrimUint8:
3874	Text.Op = PrintName("BitCastPrimUint8");
3875	Text.Args.push_back(printArg<bool>(P, PC));
3876	Text.Args.push_back(printArg<uint32_t>(P, PC));
3877	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3878	Text.Args.push_back(printArg<const Type *>(P, PC));
3879	break;
3880	case OP_BitCastPrimSint8:
3881	Text.Op = PrintName("BitCastPrimSint8");
3882	Text.Args.push_back(printArg<bool>(P, PC));
3883	Text.Args.push_back(printArg<uint32_t>(P, PC));
3884	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3885	Text.Args.push_back(printArg<const Type *>(P, PC));
3886	break;
3887	case OP_BitCastPrimUint16:
3888	Text.Op = PrintName("BitCastPrimUint16");
3889	Text.Args.push_back(printArg<bool>(P, PC));
3890	Text.Args.push_back(printArg<uint32_t>(P, PC));
3891	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3892	Text.Args.push_back(printArg<const Type *>(P, PC));
3893	break;
3894	case OP_BitCastPrimSint16:
3895	Text.Op = PrintName("BitCastPrimSint16");
3896	Text.Args.push_back(printArg<bool>(P, PC));
3897	Text.Args.push_back(printArg<uint32_t>(P, PC));
3898	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3899	Text.Args.push_back(printArg<const Type *>(P, PC));
3900	break;
3901	case OP_BitCastPrimUint32:
3902	Text.Op = PrintName("BitCastPrimUint32");
3903	Text.Args.push_back(printArg<bool>(P, PC));
3904	Text.Args.push_back(printArg<uint32_t>(P, PC));
3905	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3906	Text.Args.push_back(printArg<const Type *>(P, PC));
3907	break;
3908	case OP_BitCastPrimSint32:
3909	Text.Op = PrintName("BitCastPrimSint32");
3910	Text.Args.push_back(printArg<bool>(P, PC));
3911	Text.Args.push_back(printArg<uint32_t>(P, PC));
3912	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3913	Text.Args.push_back(printArg<const Type *>(P, PC));
3914	break;
3915	case OP_BitCastPrimUint64:
3916	Text.Op = PrintName("BitCastPrimUint64");
3917	Text.Args.push_back(printArg<bool>(P, PC));
3918	Text.Args.push_back(printArg<uint32_t>(P, PC));
3919	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3920	Text.Args.push_back(printArg<const Type *>(P, PC));
3921	break;
3922	case OP_BitCastPrimSint64:
3923	Text.Op = PrintName("BitCastPrimSint64");
3924	Text.Args.push_back(printArg<bool>(P, PC));
3925	Text.Args.push_back(printArg<uint32_t>(P, PC));
3926	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3927	Text.Args.push_back(printArg<const Type *>(P, PC));
3928	break;
3929	case OP_BitCastPrimIntAP:
3930	Text.Op = PrintName("BitCastPrimIntAP");
3931	Text.Args.push_back(printArg<bool>(P, PC));
3932	Text.Args.push_back(printArg<uint32_t>(P, PC));
3933	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3934	Text.Args.push_back(printArg<const Type *>(P, PC));
3935	break;
3936	case OP_BitCastPrimIntAPS:
3937	Text.Op = PrintName("BitCastPrimIntAPS");
3938	Text.Args.push_back(printArg<bool>(P, PC));
3939	Text.Args.push_back(printArg<uint32_t>(P, PC));
3940	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3941	Text.Args.push_back(printArg<const Type *>(P, PC));
3942	break;
3943	case OP_BitCastPrimBool:
3944	Text.Op = PrintName("BitCastPrimBool");
3945	Text.Args.push_back(printArg<bool>(P, PC));
3946	Text.Args.push_back(printArg<uint32_t>(P, PC));
3947	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3948	Text.Args.push_back(printArg<const Type *>(P, PC));
3949	break;
3950	case OP_BitCastPrimFloat:
3951	Text.Op = PrintName("BitCastPrimFloat");
3952	Text.Args.push_back(printArg<bool>(P, PC));
3953	Text.Args.push_back(printArg<uint32_t>(P, PC));
3954	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3955	Text.Args.push_back(printArg<const Type *>(P, PC));
3956	break;
3957	case OP_BitCastPrimPtr:
3958	Text.Op = PrintName("BitCastPrimPtr");
3959	Text.Args.push_back(printArg<bool>(P, PC));
3960	Text.Args.push_back(printArg<uint32_t>(P, PC));
3961	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3962	Text.Args.push_back(printArg<const Type *>(P, PC));
3963	break;
3964	case OP_BitCastPrimMemberPtr:
3965	Text.Op = PrintName("BitCastPrimMemberPtr");
3966	Text.Args.push_back(printArg<bool>(P, PC));
3967	Text.Args.push_back(printArg<uint32_t>(P, PC));
3968	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
3969	Text.Args.push_back(printArg<const Type *>(P, PC));
3970	break;
3971	#endif
3972	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3973	bool emitBitCastPrimUint8( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3974	bool emitBitCastPrimSint8( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3975	bool emitBitCastPrimUint16( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3976	bool emitBitCastPrimSint16( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3977	bool emitBitCastPrimUint32( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3978	bool emitBitCastPrimSint32( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3979	bool emitBitCastPrimUint64( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3980	bool emitBitCastPrimSint64( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3981	bool emitBitCastPrimIntAP( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3982	bool emitBitCastPrimIntAPS( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3983	bool emitBitCastPrimBool( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3984	bool emitBitCastPrimFloat( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3985	bool emitBitCastPrimPtr( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3986	bool emitBitCastPrimMemberPtr( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
3987	#endif
3988	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
3989	[[nodiscard]] bool emitBitCastPrim(PrimType, bool, uint32_t, const llvm::fltSemantics , const* Type *, SourceInfo I);
3990	#endif
3991	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
3992	bool
3993	#if defined(GET_EVAL_IMPL)
3994	EvalEmitter
3995	#else
3996	ByteCodeEmitter
3997	#endif
3998	::emitBitCastPrim(PrimType T0, bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo I) {
3999	switch (T0) {
4000	case PT_Uint8:
4001	return emitBitCastPrimUint8(A0, A1, A2, A3, I);
4002	case PT_Sint8:
4003	return emitBitCastPrimSint8(A0, A1, A2, A3, I);
4004	case PT_Uint16:
4005	return emitBitCastPrimUint16(A0, A1, A2, A3, I);
4006	case PT_Sint16:
4007	return emitBitCastPrimSint16(A0, A1, A2, A3, I);
4008	case PT_Uint32:
4009	return emitBitCastPrimUint32(A0, A1, A2, A3, I);
4010	case PT_Sint32:
4011	return emitBitCastPrimSint32(A0, A1, A2, A3, I);
4012	case PT_Uint64:
4013	return emitBitCastPrimUint64(A0, A1, A2, A3, I);
4014	case PT_Sint64:
4015	return emitBitCastPrimSint64(A0, A1, A2, A3, I);
4016	case PT_IntAP:
4017	return emitBitCastPrimIntAP(A0, A1, A2, A3, I);
4018	case PT_IntAPS:
4019	return emitBitCastPrimIntAPS(A0, A1, A2, A3, I);
4020	case PT_Bool:
4021	return emitBitCastPrimBool(A0, A1, A2, A3, I);
4022	case PT_Float:
4023	return emitBitCastPrimFloat(A0, A1, A2, A3, I);
4024	case PT_Ptr:
4025	return emitBitCastPrimPtr(A0, A1, A2, A3, I);
4026	case PT_MemberPtr:
4027	return emitBitCastPrimMemberPtr(A0, A1, A2, A3, I);
4028	default: llvm_unreachable("invalid type: emitBitCastPrim");
4029	}
4030	llvm_unreachable("invalid enum value");
4031	}
4032	#endif
4033	#ifdef GET_LINK_IMPL
4034	bool ByteCodeEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4035	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimUint8, A0, A1, A2, A3, L);
4036	}
4037	bool ByteCodeEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4038	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimSint8, A0, A1, A2, A3, L);
4039	}
4040	bool ByteCodeEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4041	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimUint16, A0, A1, A2, A3, L);
4042	}
4043	bool ByteCodeEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4044	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimSint16, A0, A1, A2, A3, L);
4045	}
4046	bool ByteCodeEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4047	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimUint32, A0, A1, A2, A3, L);
4048	}
4049	bool ByteCodeEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4050	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimSint32, A0, A1, A2, A3, L);
4051	}
4052	bool ByteCodeEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4053	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimUint64, A0, A1, A2, A3, L);
4054	}
4055	bool ByteCodeEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4056	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimSint64, A0, A1, A2, A3, L);
4057	}
4058	bool ByteCodeEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4059	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimIntAP, A0, A1, A2, A3, L);
4060	}
4061	bool ByteCodeEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4062	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimIntAPS, A0, A1, A2, A3, L);
4063	}
4064	bool ByteCodeEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4065	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimBool, A0, A1, A2, A3, L);
4066	}
4067	bool ByteCodeEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4068	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimFloat, A0, A1, A2, A3, L);
4069	}
4070	bool ByteCodeEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4071	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimPtr, A0, A1, A2, A3, L);
4072	}
4073	bool ByteCodeEmitter::emitBitCastPrimMemberPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4074	return emitOp<bool, uint32_t, const llvm::fltSemantics , const* Type *>(OP_BitCastPrimMemberPtr, A0, A1, A2, A3, L);
4075	}
4076	#endif
4077	#ifdef GET_EVAL_IMPL
4078	bool EvalEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4079	if (!isActive()) return true;
4080	CurrentSource = L;
4081	return BitCastPrim<PT_Uint8>(S, CodePtr(), A0, A1, A2, A3);
4082	}
4083	bool EvalEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4084	if (!isActive()) return true;
4085	CurrentSource = L;
4086	return BitCastPrim<PT_Sint8>(S, CodePtr(), A0, A1, A2, A3);
4087	}
4088	bool EvalEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4089	if (!isActive()) return true;
4090	CurrentSource = L;
4091	return BitCastPrim<PT_Uint16>(S, CodePtr(), A0, A1, A2, A3);
4092	}
4093	bool EvalEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4094	if (!isActive()) return true;
4095	CurrentSource = L;
4096	return BitCastPrim<PT_Sint16>(S, CodePtr(), A0, A1, A2, A3);
4097	}
4098	bool EvalEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4099	if (!isActive()) return true;
4100	CurrentSource = L;
4101	return BitCastPrim<PT_Uint32>(S, CodePtr(), A0, A1, A2, A3);
4102	}
4103	bool EvalEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4104	if (!isActive()) return true;
4105	CurrentSource = L;
4106	return BitCastPrim<PT_Sint32>(S, CodePtr(), A0, A1, A2, A3);
4107	}
4108	bool EvalEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4109	if (!isActive()) return true;
4110	CurrentSource = L;
4111	return BitCastPrim<PT_Uint64>(S, CodePtr(), A0, A1, A2, A3);
4112	}
4113	bool EvalEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4114	if (!isActive()) return true;
4115	CurrentSource = L;
4116	return BitCastPrim<PT_Sint64>(S, CodePtr(), A0, A1, A2, A3);
4117	}
4118	bool EvalEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4119	if (!isActive()) return true;
4120	CurrentSource = L;
4121	return BitCastPrim<PT_IntAP>(S, CodePtr(), A0, A1, A2, A3);
4122	}
4123	bool EvalEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4124	if (!isActive()) return true;
4125	CurrentSource = L;
4126	return BitCastPrim<PT_IntAPS>(S, CodePtr(), A0, A1, A2, A3);
4127	}
4128	bool EvalEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4129	if (!isActive()) return true;
4130	CurrentSource = L;
4131	return BitCastPrim<PT_Bool>(S, CodePtr(), A0, A1, A2, A3);
4132	}
4133	bool EvalEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4134	if (!isActive()) return true;
4135	CurrentSource = L;
4136	return BitCastPrim<PT_Float>(S, CodePtr(), A0, A1, A2, A3);
4137	}
4138	bool EvalEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4139	if (!isActive()) return true;
4140	CurrentSource = L;
4141	return BitCastPrim<PT_Ptr>(S, CodePtr(), A0, A1, A2, A3);
4142	}
4143	bool EvalEmitter::emitBitCastPrimMemberPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4144	if (!isActive()) return true;
4145	CurrentSource = L;
4146	return BitCastPrim<PT_MemberPtr>(S, CodePtr(), A0, A1, A2, A3);
4147	}
4148	#endif
4149	#ifdef GET_OPCODE_NAMES
4150	OP_BitOrSint8,
4151	OP_BitOrUint8,
4152	OP_BitOrSint16,
4153	OP_BitOrUint16,
4154	OP_BitOrSint32,
4155	OP_BitOrUint32,
4156	OP_BitOrSint64,
4157	OP_BitOrUint64,
4158	OP_BitOrIntAP,
4159	OP_BitOrIntAPS,
4160	OP_BitOrFixedPoint,
4161	#endif
4162	#ifdef GET_INTERPFN_LIST
4163	&Interp_BitOrSint8,
4164	&Interp_BitOrUint8,
4165	&Interp_BitOrSint16,
4166	&Interp_BitOrUint16,
4167	&Interp_BitOrSint32,
4168	&Interp_BitOrUint32,
4169	&Interp_BitOrSint64,
4170	&Interp_BitOrUint64,
4171	&Interp_BitOrIntAP,
4172	&Interp_BitOrIntAPS,
4173	&Interp_BitOrFixedPoint,
4174	#endif
4175	#ifdef GET_INTERPFN_DISPATCHERS
4176	PRESERVE_NONE
4177	static bool Interp_BitOrSint8(InterpState &S) {
4178	if (!BitOr<PT_Sint8>(S)) return false;
4179	#if USE_TAILCALLS
4180	MUSTTAIL return InterpNext(S);
4181	#else
4182	return true;
4183	#endif
4184	}
4185	PRESERVE_NONE
4186	static bool Interp_BitOrUint8(InterpState &S) {
4187	if (!BitOr<PT_Uint8>(S)) return false;
4188	#if USE_TAILCALLS
4189	MUSTTAIL return InterpNext(S);
4190	#else
4191	return true;
4192	#endif
4193	}
4194	PRESERVE_NONE
4195	static bool Interp_BitOrSint16(InterpState &S) {
4196	if (!BitOr<PT_Sint16>(S)) return false;
4197	#if USE_TAILCALLS
4198	MUSTTAIL return InterpNext(S);
4199	#else
4200	return true;
4201	#endif
4202	}
4203	PRESERVE_NONE
4204	static bool Interp_BitOrUint16(InterpState &S) {
4205	if (!BitOr<PT_Uint16>(S)) return false;
4206	#if USE_TAILCALLS
4207	MUSTTAIL return InterpNext(S);
4208	#else
4209	return true;
4210	#endif
4211	}
4212	PRESERVE_NONE
4213	static bool Interp_BitOrSint32(InterpState &S) {
4214	if (!BitOr<PT_Sint32>(S)) return false;
4215	#if USE_TAILCALLS
4216	MUSTTAIL return InterpNext(S);
4217	#else
4218	return true;
4219	#endif
4220	}
4221	PRESERVE_NONE
4222	static bool Interp_BitOrUint32(InterpState &S) {
4223	if (!BitOr<PT_Uint32>(S)) return false;
4224	#if USE_TAILCALLS
4225	MUSTTAIL return InterpNext(S);
4226	#else
4227	return true;
4228	#endif
4229	}
4230	PRESERVE_NONE
4231	static bool Interp_BitOrSint64(InterpState &S) {
4232	if (!BitOr<PT_Sint64>(S)) return false;
4233	#if USE_TAILCALLS
4234	MUSTTAIL return InterpNext(S);
4235	#else
4236	return true;
4237	#endif
4238	}
4239	PRESERVE_NONE
4240	static bool Interp_BitOrUint64(InterpState &S) {
4241	if (!BitOr<PT_Uint64>(S)) return false;
4242	#if USE_TAILCALLS
4243	MUSTTAIL return InterpNext(S);
4244	#else
4245	return true;
4246	#endif
4247	}
4248	PRESERVE_NONE
4249	static bool Interp_BitOrIntAP(InterpState &S) {
4250	if (!BitOr<PT_IntAP>(S)) return false;
4251	#if USE_TAILCALLS
4252	MUSTTAIL return InterpNext(S);
4253	#else
4254	return true;
4255	#endif
4256	}
4257	PRESERVE_NONE
4258	static bool Interp_BitOrIntAPS(InterpState &S) {
4259	if (!BitOr<PT_IntAPS>(S)) return false;
4260	#if USE_TAILCALLS
4261	MUSTTAIL return InterpNext(S);
4262	#else
4263	return true;
4264	#endif
4265	}
4266	PRESERVE_NONE
4267	static bool Interp_BitOrFixedPoint(InterpState &S) {
4268	if (!BitOr<PT_FixedPoint>(S)) return false;
4269	#if USE_TAILCALLS
4270	MUSTTAIL return InterpNext(S);
4271	#else
4272	return true;
4273	#endif
4274	}
4275	#endif
4276	#ifdef GET_DISASM
4277	case OP_BitOrSint8:
4278	Text.Op = PrintName("BitOrSint8");
4279	break;
4280	case OP_BitOrUint8:
4281	Text.Op = PrintName("BitOrUint8");
4282	break;
4283	case OP_BitOrSint16:
4284	Text.Op = PrintName("BitOrSint16");
4285	break;
4286	case OP_BitOrUint16:
4287	Text.Op = PrintName("BitOrUint16");
4288	break;
4289	case OP_BitOrSint32:
4290	Text.Op = PrintName("BitOrSint32");
4291	break;
4292	case OP_BitOrUint32:
4293	Text.Op = PrintName("BitOrUint32");
4294	break;
4295	case OP_BitOrSint64:
4296	Text.Op = PrintName("BitOrSint64");
4297	break;
4298	case OP_BitOrUint64:
4299	Text.Op = PrintName("BitOrUint64");
4300	break;
4301	case OP_BitOrIntAP:
4302	Text.Op = PrintName("BitOrIntAP");
4303	break;
4304	case OP_BitOrIntAPS:
4305	Text.Op = PrintName("BitOrIntAPS");
4306	break;
4307	case OP_BitOrFixedPoint:
4308	Text.Op = PrintName("BitOrFixedPoint");
4309	break;
4310	#endif
4311	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
4312	bool emitBitOrSint8(SourceInfo);
4313	bool emitBitOrUint8(SourceInfo);
4314	bool emitBitOrSint16(SourceInfo);
4315	bool emitBitOrUint16(SourceInfo);
4316	bool emitBitOrSint32(SourceInfo);
4317	bool emitBitOrUint32(SourceInfo);
4318	bool emitBitOrSint64(SourceInfo);
4319	bool emitBitOrUint64(SourceInfo);
4320	bool emitBitOrIntAP(SourceInfo);
4321	bool emitBitOrIntAPS(SourceInfo);
4322	bool emitBitOrFixedPoint(SourceInfo);
4323	#endif
4324	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
4325	[[nodiscard]] bool emitBitOr(PrimType, SourceInfo I);
4326	#endif
4327	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
4328	bool
4329	#if defined(GET_EVAL_IMPL)
4330	EvalEmitter
4331	#else
4332	ByteCodeEmitter
4333	#endif
4334	::emitBitOr(PrimType T0, SourceInfo I) {
4335	switch (T0) {
4336	case PT_Sint8:
4337	return emitBitOrSint8(I);
4338	case PT_Uint8:
4339	return emitBitOrUint8(I);
4340	case PT_Sint16:
4341	return emitBitOrSint16(I);
4342	case PT_Uint16:
4343	return emitBitOrUint16(I);
4344	case PT_Sint32:
4345	return emitBitOrSint32(I);
4346	case PT_Uint32:
4347	return emitBitOrUint32(I);
4348	case PT_Sint64:
4349	return emitBitOrSint64(I);
4350	case PT_Uint64:
4351	return emitBitOrUint64(I);
4352	case PT_IntAP:
4353	return emitBitOrIntAP(I);
4354	case PT_IntAPS:
4355	return emitBitOrIntAPS(I);
4356	case PT_FixedPoint:
4357	return emitBitOrFixedPoint(I);
4358	default: llvm_unreachable("invalid type: emitBitOr");
4359	}
4360	llvm_unreachable("invalid enum value");
4361	}
4362	#endif
4363	#ifdef GET_LINK_IMPL
4364	bool ByteCodeEmitter::emitBitOrSint8(SourceInfo L) {
4365	return emitOp<>(OP_BitOrSint8, L);
4366	}
4367	bool ByteCodeEmitter::emitBitOrUint8(SourceInfo L) {
4368	return emitOp<>(OP_BitOrUint8, L);
4369	}
4370	bool ByteCodeEmitter::emitBitOrSint16(SourceInfo L) {
4371	return emitOp<>(OP_BitOrSint16, L);
4372	}
4373	bool ByteCodeEmitter::emitBitOrUint16(SourceInfo L) {
4374	return emitOp<>(OP_BitOrUint16, L);
4375	}
4376	bool ByteCodeEmitter::emitBitOrSint32(SourceInfo L) {
4377	return emitOp<>(OP_BitOrSint32, L);
4378	}
4379	bool ByteCodeEmitter::emitBitOrUint32(SourceInfo L) {
4380	return emitOp<>(OP_BitOrUint32, L);
4381	}
4382	bool ByteCodeEmitter::emitBitOrSint64(SourceInfo L) {
4383	return emitOp<>(OP_BitOrSint64, L);
4384	}
4385	bool ByteCodeEmitter::emitBitOrUint64(SourceInfo L) {
4386	return emitOp<>(OP_BitOrUint64, L);
4387	}
4388	bool ByteCodeEmitter::emitBitOrIntAP(SourceInfo L) {
4389	return emitOp<>(OP_BitOrIntAP, L);
4390	}
4391	bool ByteCodeEmitter::emitBitOrIntAPS(SourceInfo L) {
4392	return emitOp<>(OP_BitOrIntAPS, L);
4393	}
4394	bool ByteCodeEmitter::emitBitOrFixedPoint(SourceInfo L) {
4395	return emitOp<>(OP_BitOrFixedPoint, L);
4396	}
4397	#endif
4398	#ifdef GET_EVAL_IMPL
4399	bool EvalEmitter::emitBitOrSint8(SourceInfo L) {
4400	if (!isActive()) return true;
4401	CurrentSource = L;
4402	return BitOr<PT_Sint8>(S);
4403	}
4404	bool EvalEmitter::emitBitOrUint8(SourceInfo L) {
4405	if (!isActive()) return true;
4406	CurrentSource = L;
4407	return BitOr<PT_Uint8>(S);
4408	}
4409	bool EvalEmitter::emitBitOrSint16(SourceInfo L) {
4410	if (!isActive()) return true;
4411	CurrentSource = L;
4412	return BitOr<PT_Sint16>(S);
4413	}
4414	bool EvalEmitter::emitBitOrUint16(SourceInfo L) {
4415	if (!isActive()) return true;
4416	CurrentSource = L;
4417	return BitOr<PT_Uint16>(S);
4418	}
4419	bool EvalEmitter::emitBitOrSint32(SourceInfo L) {
4420	if (!isActive()) return true;
4421	CurrentSource = L;
4422	return BitOr<PT_Sint32>(S);
4423	}
4424	bool EvalEmitter::emitBitOrUint32(SourceInfo L) {
4425	if (!isActive()) return true;
4426	CurrentSource = L;
4427	return BitOr<PT_Uint32>(S);
4428	}
4429	bool EvalEmitter::emitBitOrSint64(SourceInfo L) {
4430	if (!isActive()) return true;
4431	CurrentSource = L;
4432	return BitOr<PT_Sint64>(S);
4433	}
4434	bool EvalEmitter::emitBitOrUint64(SourceInfo L) {
4435	if (!isActive()) return true;
4436	CurrentSource = L;
4437	return BitOr<PT_Uint64>(S);
4438	}
4439	bool EvalEmitter::emitBitOrIntAP(SourceInfo L) {
4440	if (!isActive()) return true;
4441	CurrentSource = L;
4442	return BitOr<PT_IntAP>(S);
4443	}
4444	bool EvalEmitter::emitBitOrIntAPS(SourceInfo L) {
4445	if (!isActive()) return true;
4446	CurrentSource = L;
4447	return BitOr<PT_IntAPS>(S);
4448	}
4449	bool EvalEmitter::emitBitOrFixedPoint(SourceInfo L) {
4450	if (!isActive()) return true;
4451	CurrentSource = L;
4452	return BitOr<PT_FixedPoint>(S);
4453	}
4454	#endif
4455	#ifdef GET_OPCODE_NAMES
4456	OP_BitXorSint8,
4457	OP_BitXorUint8,
4458	OP_BitXorSint16,
4459	OP_BitXorUint16,
4460	OP_BitXorSint32,
4461	OP_BitXorUint32,
4462	OP_BitXorSint64,
4463	OP_BitXorUint64,
4464	OP_BitXorIntAP,
4465	OP_BitXorIntAPS,
4466	OP_BitXorFixedPoint,
4467	#endif
4468	#ifdef GET_INTERPFN_LIST
4469	&Interp_BitXorSint8,
4470	&Interp_BitXorUint8,
4471	&Interp_BitXorSint16,
4472	&Interp_BitXorUint16,
4473	&Interp_BitXorSint32,
4474	&Interp_BitXorUint32,
4475	&Interp_BitXorSint64,
4476	&Interp_BitXorUint64,
4477	&Interp_BitXorIntAP,
4478	&Interp_BitXorIntAPS,
4479	&Interp_BitXorFixedPoint,
4480	#endif
4481	#ifdef GET_INTERPFN_DISPATCHERS
4482	PRESERVE_NONE
4483	static bool Interp_BitXorSint8(InterpState &S) {
4484	if (!BitXor<PT_Sint8>(S)) return false;
4485	#if USE_TAILCALLS
4486	MUSTTAIL return InterpNext(S);
4487	#else
4488	return true;
4489	#endif
4490	}
4491	PRESERVE_NONE
4492	static bool Interp_BitXorUint8(InterpState &S) {
4493	if (!BitXor<PT_Uint8>(S)) return false;
4494	#if USE_TAILCALLS
4495	MUSTTAIL return InterpNext(S);
4496	#else
4497	return true;
4498	#endif
4499	}
4500	PRESERVE_NONE
4501	static bool Interp_BitXorSint16(InterpState &S) {
4502	if (!BitXor<PT_Sint16>(S)) return false;
4503	#if USE_TAILCALLS
4504	MUSTTAIL return InterpNext(S);
4505	#else
4506	return true;
4507	#endif
4508	}
4509	PRESERVE_NONE
4510	static bool Interp_BitXorUint16(InterpState &S) {
4511	if (!BitXor<PT_Uint16>(S)) return false;
4512	#if USE_TAILCALLS
4513	MUSTTAIL return InterpNext(S);
4514	#else
4515	return true;
4516	#endif
4517	}
4518	PRESERVE_NONE
4519	static bool Interp_BitXorSint32(InterpState &S) {
4520	if (!BitXor<PT_Sint32>(S)) return false;
4521	#if USE_TAILCALLS
4522	MUSTTAIL return InterpNext(S);
4523	#else
4524	return true;
4525	#endif
4526	}
4527	PRESERVE_NONE
4528	static bool Interp_BitXorUint32(InterpState &S) {
4529	if (!BitXor<PT_Uint32>(S)) return false;
4530	#if USE_TAILCALLS
4531	MUSTTAIL return InterpNext(S);
4532	#else
4533	return true;
4534	#endif
4535	}
4536	PRESERVE_NONE
4537	static bool Interp_BitXorSint64(InterpState &S) {
4538	if (!BitXor<PT_Sint64>(S)) return false;
4539	#if USE_TAILCALLS
4540	MUSTTAIL return InterpNext(S);
4541	#else
4542	return true;
4543	#endif
4544	}
4545	PRESERVE_NONE
4546	static bool Interp_BitXorUint64(InterpState &S) {
4547	if (!BitXor<PT_Uint64>(S)) return false;
4548	#if USE_TAILCALLS
4549	MUSTTAIL return InterpNext(S);
4550	#else
4551	return true;
4552	#endif
4553	}
4554	PRESERVE_NONE
4555	static bool Interp_BitXorIntAP(InterpState &S) {
4556	if (!BitXor<PT_IntAP>(S)) return false;
4557	#if USE_TAILCALLS
4558	MUSTTAIL return InterpNext(S);
4559	#else
4560	return true;
4561	#endif
4562	}
4563	PRESERVE_NONE
4564	static bool Interp_BitXorIntAPS(InterpState &S) {
4565	if (!BitXor<PT_IntAPS>(S)) return false;
4566	#if USE_TAILCALLS
4567	MUSTTAIL return InterpNext(S);
4568	#else
4569	return true;
4570	#endif
4571	}
4572	PRESERVE_NONE
4573	static bool Interp_BitXorFixedPoint(InterpState &S) {
4574	if (!BitXor<PT_FixedPoint>(S)) return false;
4575	#if USE_TAILCALLS
4576	MUSTTAIL return InterpNext(S);
4577	#else
4578	return true;
4579	#endif
4580	}
4581	#endif
4582	#ifdef GET_DISASM
4583	case OP_BitXorSint8:
4584	Text.Op = PrintName("BitXorSint8");
4585	break;
4586	case OP_BitXorUint8:
4587	Text.Op = PrintName("BitXorUint8");
4588	break;
4589	case OP_BitXorSint16:
4590	Text.Op = PrintName("BitXorSint16");
4591	break;
4592	case OP_BitXorUint16:
4593	Text.Op = PrintName("BitXorUint16");
4594	break;
4595	case OP_BitXorSint32:
4596	Text.Op = PrintName("BitXorSint32");
4597	break;
4598	case OP_BitXorUint32:
4599	Text.Op = PrintName("BitXorUint32");
4600	break;
4601	case OP_BitXorSint64:
4602	Text.Op = PrintName("BitXorSint64");
4603	break;
4604	case OP_BitXorUint64:
4605	Text.Op = PrintName("BitXorUint64");
4606	break;
4607	case OP_BitXorIntAP:
4608	Text.Op = PrintName("BitXorIntAP");
4609	break;
4610	case OP_BitXorIntAPS:
4611	Text.Op = PrintName("BitXorIntAPS");
4612	break;
4613	case OP_BitXorFixedPoint:
4614	Text.Op = PrintName("BitXorFixedPoint");
4615	break;
4616	#endif
4617	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
4618	bool emitBitXorSint8(SourceInfo);
4619	bool emitBitXorUint8(SourceInfo);
4620	bool emitBitXorSint16(SourceInfo);
4621	bool emitBitXorUint16(SourceInfo);
4622	bool emitBitXorSint32(SourceInfo);
4623	bool emitBitXorUint32(SourceInfo);
4624	bool emitBitXorSint64(SourceInfo);
4625	bool emitBitXorUint64(SourceInfo);
4626	bool emitBitXorIntAP(SourceInfo);
4627	bool emitBitXorIntAPS(SourceInfo);
4628	bool emitBitXorFixedPoint(SourceInfo);
4629	#endif
4630	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
4631	[[nodiscard]] bool emitBitXor(PrimType, SourceInfo I);
4632	#endif
4633	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
4634	bool
4635	#if defined(GET_EVAL_IMPL)
4636	EvalEmitter
4637	#else
4638	ByteCodeEmitter
4639	#endif
4640	::emitBitXor(PrimType T0, SourceInfo I) {
4641	switch (T0) {
4642	case PT_Sint8:
4643	return emitBitXorSint8(I);
4644	case PT_Uint8:
4645	return emitBitXorUint8(I);
4646	case PT_Sint16:
4647	return emitBitXorSint16(I);
4648	case PT_Uint16:
4649	return emitBitXorUint16(I);
4650	case PT_Sint32:
4651	return emitBitXorSint32(I);
4652	case PT_Uint32:
4653	return emitBitXorUint32(I);
4654	case PT_Sint64:
4655	return emitBitXorSint64(I);
4656	case PT_Uint64:
4657	return emitBitXorUint64(I);
4658	case PT_IntAP:
4659	return emitBitXorIntAP(I);
4660	case PT_IntAPS:
4661	return emitBitXorIntAPS(I);
4662	case PT_FixedPoint:
4663	return emitBitXorFixedPoint(I);
4664	default: llvm_unreachable("invalid type: emitBitXor");
4665	}
4666	llvm_unreachable("invalid enum value");
4667	}
4668	#endif
4669	#ifdef GET_LINK_IMPL
4670	bool ByteCodeEmitter::emitBitXorSint8(SourceInfo L) {
4671	return emitOp<>(OP_BitXorSint8, L);
4672	}
4673	bool ByteCodeEmitter::emitBitXorUint8(SourceInfo L) {
4674	return emitOp<>(OP_BitXorUint8, L);
4675	}
4676	bool ByteCodeEmitter::emitBitXorSint16(SourceInfo L) {
4677	return emitOp<>(OP_BitXorSint16, L);
4678	}
4679	bool ByteCodeEmitter::emitBitXorUint16(SourceInfo L) {
4680	return emitOp<>(OP_BitXorUint16, L);
4681	}
4682	bool ByteCodeEmitter::emitBitXorSint32(SourceInfo L) {
4683	return emitOp<>(OP_BitXorSint32, L);
4684	}
4685	bool ByteCodeEmitter::emitBitXorUint32(SourceInfo L) {
4686	return emitOp<>(OP_BitXorUint32, L);
4687	}
4688	bool ByteCodeEmitter::emitBitXorSint64(SourceInfo L) {
4689	return emitOp<>(OP_BitXorSint64, L);
4690	}
4691	bool ByteCodeEmitter::emitBitXorUint64(SourceInfo L) {
4692	return emitOp<>(OP_BitXorUint64, L);
4693	}
4694	bool ByteCodeEmitter::emitBitXorIntAP(SourceInfo L) {
4695	return emitOp<>(OP_BitXorIntAP, L);
4696	}
4697	bool ByteCodeEmitter::emitBitXorIntAPS(SourceInfo L) {
4698	return emitOp<>(OP_BitXorIntAPS, L);
4699	}
4700	bool ByteCodeEmitter::emitBitXorFixedPoint(SourceInfo L) {
4701	return emitOp<>(OP_BitXorFixedPoint, L);
4702	}
4703	#endif
4704	#ifdef GET_EVAL_IMPL
4705	bool EvalEmitter::emitBitXorSint8(SourceInfo L) {
4706	if (!isActive()) return true;
4707	CurrentSource = L;
4708	return BitXor<PT_Sint8>(S);
4709	}
4710	bool EvalEmitter::emitBitXorUint8(SourceInfo L) {
4711	if (!isActive()) return true;
4712	CurrentSource = L;
4713	return BitXor<PT_Uint8>(S);
4714	}
4715	bool EvalEmitter::emitBitXorSint16(SourceInfo L) {
4716	if (!isActive()) return true;
4717	CurrentSource = L;
4718	return BitXor<PT_Sint16>(S);
4719	}
4720	bool EvalEmitter::emitBitXorUint16(SourceInfo L) {
4721	if (!isActive()) return true;
4722	CurrentSource = L;
4723	return BitXor<PT_Uint16>(S);
4724	}
4725	bool EvalEmitter::emitBitXorSint32(SourceInfo L) {
4726	if (!isActive()) return true;
4727	CurrentSource = L;
4728	return BitXor<PT_Sint32>(S);
4729	}
4730	bool EvalEmitter::emitBitXorUint32(SourceInfo L) {
4731	if (!isActive()) return true;
4732	CurrentSource = L;
4733	return BitXor<PT_Uint32>(S);
4734	}
4735	bool EvalEmitter::emitBitXorSint64(SourceInfo L) {
4736	if (!isActive()) return true;
4737	CurrentSource = L;
4738	return BitXor<PT_Sint64>(S);
4739	}
4740	bool EvalEmitter::emitBitXorUint64(SourceInfo L) {
4741	if (!isActive()) return true;
4742	CurrentSource = L;
4743	return BitXor<PT_Uint64>(S);
4744	}
4745	bool EvalEmitter::emitBitXorIntAP(SourceInfo L) {
4746	if (!isActive()) return true;
4747	CurrentSource = L;
4748	return BitXor<PT_IntAP>(S);
4749	}
4750	bool EvalEmitter::emitBitXorIntAPS(SourceInfo L) {
4751	if (!isActive()) return true;
4752	CurrentSource = L;
4753	return BitXor<PT_IntAPS>(S);
4754	}
4755	bool EvalEmitter::emitBitXorFixedPoint(SourceInfo L) {
4756	if (!isActive()) return true;
4757	CurrentSource = L;
4758	return BitXor<PT_FixedPoint>(S);
4759	}
4760	#endif
4761	#ifdef GET_OPCODE_NAMES
4762	OP_CMP3Sint8,
4763	OP_CMP3Uint8,
4764	OP_CMP3Sint16,
4765	OP_CMP3Uint16,
4766	OP_CMP3Sint32,
4767	OP_CMP3Uint32,
4768	OP_CMP3Sint64,
4769	OP_CMP3Uint64,
4770	OP_CMP3IntAP,
4771	OP_CMP3IntAPS,
4772	OP_CMP3Bool,
4773	OP_CMP3FixedPoint,
4774	OP_CMP3Ptr,
4775	OP_CMP3Float,
4776	#endif
4777	#ifdef GET_INTERPFN_LIST
4778	&Interp_CMP3Sint8,
4779	&Interp_CMP3Uint8,
4780	&Interp_CMP3Sint16,
4781	&Interp_CMP3Uint16,
4782	&Interp_CMP3Sint32,
4783	&Interp_CMP3Uint32,
4784	&Interp_CMP3Sint64,
4785	&Interp_CMP3Uint64,
4786	&Interp_CMP3IntAP,
4787	&Interp_CMP3IntAPS,
4788	&Interp_CMP3Bool,
4789	&Interp_CMP3FixedPoint,
4790	&Interp_CMP3Ptr,
4791	&Interp_CMP3Float,
4792	#endif
4793	#ifdef GET_INTERPFN_DISPATCHERS
4794	PRESERVE_NONE
4795	static bool Interp_CMP3Sint8(InterpState &S) {
4796	{
4797	CodePtr OpPC = S.PC;
4798	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4799	if (!CMP3<PT_Sint8>(S, OpPC, V0)) return false;
4800	}
4801	#if USE_TAILCALLS
4802	MUSTTAIL return InterpNext(S);
4803	#else
4804	return true;
4805	#endif
4806	}
4807	PRESERVE_NONE
4808	static bool Interp_CMP3Uint8(InterpState &S) {
4809	{
4810	CodePtr OpPC = S.PC;
4811	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4812	if (!CMP3<PT_Uint8>(S, OpPC, V0)) return false;
4813	}
4814	#if USE_TAILCALLS
4815	MUSTTAIL return InterpNext(S);
4816	#else
4817	return true;
4818	#endif
4819	}
4820	PRESERVE_NONE
4821	static bool Interp_CMP3Sint16(InterpState &S) {
4822	{
4823	CodePtr OpPC = S.PC;
4824	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4825	if (!CMP3<PT_Sint16>(S, OpPC, V0)) return false;
4826	}
4827	#if USE_TAILCALLS
4828	MUSTTAIL return InterpNext(S);
4829	#else
4830	return true;
4831	#endif
4832	}
4833	PRESERVE_NONE
4834	static bool Interp_CMP3Uint16(InterpState &S) {
4835	{
4836	CodePtr OpPC = S.PC;
4837	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4838	if (!CMP3<PT_Uint16>(S, OpPC, V0)) return false;
4839	}
4840	#if USE_TAILCALLS
4841	MUSTTAIL return InterpNext(S);
4842	#else
4843	return true;
4844	#endif
4845	}
4846	PRESERVE_NONE
4847	static bool Interp_CMP3Sint32(InterpState &S) {
4848	{
4849	CodePtr OpPC = S.PC;
4850	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4851	if (!CMP3<PT_Sint32>(S, OpPC, V0)) return false;
4852	}
4853	#if USE_TAILCALLS
4854	MUSTTAIL return InterpNext(S);
4855	#else
4856	return true;
4857	#endif
4858	}
4859	PRESERVE_NONE
4860	static bool Interp_CMP3Uint32(InterpState &S) {
4861	{
4862	CodePtr OpPC = S.PC;
4863	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4864	if (!CMP3<PT_Uint32>(S, OpPC, V0)) return false;
4865	}
4866	#if USE_TAILCALLS
4867	MUSTTAIL return InterpNext(S);
4868	#else
4869	return true;
4870	#endif
4871	}
4872	PRESERVE_NONE
4873	static bool Interp_CMP3Sint64(InterpState &S) {
4874	{
4875	CodePtr OpPC = S.PC;
4876	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4877	if (!CMP3<PT_Sint64>(S, OpPC, V0)) return false;
4878	}
4879	#if USE_TAILCALLS
4880	MUSTTAIL return InterpNext(S);
4881	#else
4882	return true;
4883	#endif
4884	}
4885	PRESERVE_NONE
4886	static bool Interp_CMP3Uint64(InterpState &S) {
4887	{
4888	CodePtr OpPC = S.PC;
4889	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4890	if (!CMP3<PT_Uint64>(S, OpPC, V0)) return false;
4891	}
4892	#if USE_TAILCALLS
4893	MUSTTAIL return InterpNext(S);
4894	#else
4895	return true;
4896	#endif
4897	}
4898	PRESERVE_NONE
4899	static bool Interp_CMP3IntAP(InterpState &S) {
4900	{
4901	CodePtr OpPC = S.PC;
4902	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4903	if (!CMP3<PT_IntAP>(S, OpPC, V0)) return false;
4904	}
4905	#if USE_TAILCALLS
4906	MUSTTAIL return InterpNext(S);
4907	#else
4908	return true;
4909	#endif
4910	}
4911	PRESERVE_NONE
4912	static bool Interp_CMP3IntAPS(InterpState &S) {
4913	{
4914	CodePtr OpPC = S.PC;
4915	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4916	if (!CMP3<PT_IntAPS>(S, OpPC, V0)) return false;
4917	}
4918	#if USE_TAILCALLS
4919	MUSTTAIL return InterpNext(S);
4920	#else
4921	return true;
4922	#endif
4923	}
4924	PRESERVE_NONE
4925	static bool Interp_CMP3Bool(InterpState &S) {
4926	{
4927	CodePtr OpPC = S.PC;
4928	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4929	if (!CMP3<PT_Bool>(S, OpPC, V0)) return false;
4930	}
4931	#if USE_TAILCALLS
4932	MUSTTAIL return InterpNext(S);
4933	#else
4934	return true;
4935	#endif
4936	}
4937	PRESERVE_NONE
4938	static bool Interp_CMP3FixedPoint(InterpState &S) {
4939	{
4940	CodePtr OpPC = S.PC;
4941	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4942	if (!CMP3<PT_FixedPoint>(S, OpPC, V0)) return false;
4943	}
4944	#if USE_TAILCALLS
4945	MUSTTAIL return InterpNext(S);
4946	#else
4947	return true;
4948	#endif
4949	}
4950	PRESERVE_NONE
4951	static bool Interp_CMP3Ptr(InterpState &S) {
4952	{
4953	CodePtr OpPC = S.PC;
4954	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4955	if (!CMP3<PT_Ptr>(S, OpPC, V0)) return false;
4956	}
4957	#if USE_TAILCALLS
4958	MUSTTAIL return InterpNext(S);
4959	#else
4960	return true;
4961	#endif
4962	}
4963	PRESERVE_NONE
4964	static bool Interp_CMP3Float(InterpState &S) {
4965	{
4966	CodePtr OpPC = S.PC;
4967	const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4968	if (!CMP3<PT_Float>(S, OpPC, V0)) return false;
4969	}
4970	#if USE_TAILCALLS
4971	MUSTTAIL return InterpNext(S);
4972	#else
4973	return true;
4974	#endif
4975	}
4976	#endif
4977	#ifdef GET_DISASM
4978	case OP_CMP3Sint8:
4979	Text.Op = PrintName("CMP3Sint8");
4980	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
4981	break;
4982	case OP_CMP3Uint8:
4983	Text.Op = PrintName("CMP3Uint8");
4984	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
4985	break;
4986	case OP_CMP3Sint16:
4987	Text.Op = PrintName("CMP3Sint16");
4988	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
4989	break;
4990	case OP_CMP3Uint16:
4991	Text.Op = PrintName("CMP3Uint16");
4992	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
4993	break;
4994	case OP_CMP3Sint32:
4995	Text.Op = PrintName("CMP3Sint32");
4996	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
4997	break;
4998	case OP_CMP3Uint32:
4999	Text.Op = PrintName("CMP3Uint32");
5000	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5001	break;
5002	case OP_CMP3Sint64:
5003	Text.Op = PrintName("CMP3Sint64");
5004	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5005	break;
5006	case OP_CMP3Uint64:
5007	Text.Op = PrintName("CMP3Uint64");
5008	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5009	break;
5010	case OP_CMP3IntAP:
5011	Text.Op = PrintName("CMP3IntAP");
5012	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5013	break;
5014	case OP_CMP3IntAPS:
5015	Text.Op = PrintName("CMP3IntAPS");
5016	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5017	break;
5018	case OP_CMP3Bool:
5019	Text.Op = PrintName("CMP3Bool");
5020	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5021	break;
5022	case OP_CMP3FixedPoint:
5023	Text.Op = PrintName("CMP3FixedPoint");
5024	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5025	break;
5026	case OP_CMP3Ptr:
5027	Text.Op = PrintName("CMP3Ptr");
5028	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5029	break;
5030	case OP_CMP3Float:
5031	Text.Op = PrintName("CMP3Float");
5032	Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(P, PC));
5033	break;
5034	#endif
5035	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5036	bool emitCMP3Sint8( const ComparisonCategoryInfo * , SourceInfo);
5037	bool emitCMP3Uint8( const ComparisonCategoryInfo * , SourceInfo);
5038	bool emitCMP3Sint16( const ComparisonCategoryInfo * , SourceInfo);
5039	bool emitCMP3Uint16( const ComparisonCategoryInfo * , SourceInfo);
5040	bool emitCMP3Sint32( const ComparisonCategoryInfo * , SourceInfo);
5041	bool emitCMP3Uint32( const ComparisonCategoryInfo * , SourceInfo);
5042	bool emitCMP3Sint64( const ComparisonCategoryInfo * , SourceInfo);
5043	bool emitCMP3Uint64( const ComparisonCategoryInfo * , SourceInfo);
5044	bool emitCMP3IntAP( const ComparisonCategoryInfo * , SourceInfo);
5045	bool emitCMP3IntAPS( const ComparisonCategoryInfo * , SourceInfo);
5046	bool emitCMP3Bool( const ComparisonCategoryInfo * , SourceInfo);
5047	bool emitCMP3FixedPoint( const ComparisonCategoryInfo * , SourceInfo);
5048	bool emitCMP3Ptr( const ComparisonCategoryInfo * , SourceInfo);
5049	bool emitCMP3Float( const ComparisonCategoryInfo * , SourceInfo);
5050	#endif
5051	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5052	[[nodiscard]] bool emitCMP3(PrimType, const ComparisonCategoryInfo *, SourceInfo I);
5053	#endif
5054	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
5055	bool
5056	#if defined(GET_EVAL_IMPL)
5057	EvalEmitter
5058	#else
5059	ByteCodeEmitter
5060	#endif
5061	::emitCMP3(PrimType T0, const ComparisonCategoryInfo * A0, SourceInfo I) {
5062	switch (T0) {
5063	case PT_Sint8:
5064	return emitCMP3Sint8(A0, I);
5065	case PT_Uint8:
5066	return emitCMP3Uint8(A0, I);
5067	case PT_Sint16:
5068	return emitCMP3Sint16(A0, I);
5069	case PT_Uint16:
5070	return emitCMP3Uint16(A0, I);
5071	case PT_Sint32:
5072	return emitCMP3Sint32(A0, I);
5073	case PT_Uint32:
5074	return emitCMP3Uint32(A0, I);
5075	case PT_Sint64:
5076	return emitCMP3Sint64(A0, I);
5077	case PT_Uint64:
5078	return emitCMP3Uint64(A0, I);
5079	case PT_IntAP:
5080	return emitCMP3IntAP(A0, I);
5081	case PT_IntAPS:
5082	return emitCMP3IntAPS(A0, I);
5083	case PT_Bool:
5084	return emitCMP3Bool(A0, I);
5085	case PT_FixedPoint:
5086	return emitCMP3FixedPoint(A0, I);
5087	case PT_Ptr:
5088	return emitCMP3Ptr(A0, I);
5089	case PT_Float:
5090	return emitCMP3Float(A0, I);
5091	default: llvm_unreachable("invalid type: emitCMP3");
5092	}
5093	llvm_unreachable("invalid enum value");
5094	}
5095	#endif
5096	#ifdef GET_LINK_IMPL
5097	bool ByteCodeEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5098	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint8, A0, L);
5099	}
5100	bool ByteCodeEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5101	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint8, A0, L);
5102	}
5103	bool ByteCodeEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5104	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint16, A0, L);
5105	}
5106	bool ByteCodeEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5107	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint16, A0, L);
5108	}
5109	bool ByteCodeEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5110	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint32, A0, L);
5111	}
5112	bool ByteCodeEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5113	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint32, A0, L);
5114	}
5115	bool ByteCodeEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5116	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint64, A0, L);
5117	}
5118	bool ByteCodeEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5119	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint64, A0, L);
5120	}
5121	bool ByteCodeEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, SourceInfo L) {
5122	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAP, A0, L);
5123	}
5124	bool ByteCodeEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, SourceInfo L) {
5125	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAPS, A0, L);
5126	}
5127	bool ByteCodeEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, SourceInfo L) {
5128	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Bool, A0, L);
5129	}
5130	bool ByteCodeEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, SourceInfo L) {
5131	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3FixedPoint, A0, L);
5132	}
5133	bool ByteCodeEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, SourceInfo L) {
5134	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Ptr, A0, L);
5135	}
5136	bool ByteCodeEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, SourceInfo L) {
5137	return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Float, A0, L);
5138	}
5139	#endif
5140	#ifdef GET_EVAL_IMPL
5141	bool EvalEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5142	if (!isActive()) return true;
5143	CurrentSource = L;
5144	return CMP3<PT_Sint8>(S, CodePtr(), A0);
5145	}
5146	bool EvalEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5147	if (!isActive()) return true;
5148	CurrentSource = L;
5149	return CMP3<PT_Uint8>(S, CodePtr(), A0);
5150	}
5151	bool EvalEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5152	if (!isActive()) return true;
5153	CurrentSource = L;
5154	return CMP3<PT_Sint16>(S, CodePtr(), A0);
5155	}
5156	bool EvalEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5157	if (!isActive()) return true;
5158	CurrentSource = L;
5159	return CMP3<PT_Uint16>(S, CodePtr(), A0);
5160	}
5161	bool EvalEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5162	if (!isActive()) return true;
5163	CurrentSource = L;
5164	return CMP3<PT_Sint32>(S, CodePtr(), A0);
5165	}
5166	bool EvalEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5167	if (!isActive()) return true;
5168	CurrentSource = L;
5169	return CMP3<PT_Uint32>(S, CodePtr(), A0);
5170	}
5171	bool EvalEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5172	if (!isActive()) return true;
5173	CurrentSource = L;
5174	return CMP3<PT_Sint64>(S, CodePtr(), A0);
5175	}
5176	bool EvalEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5177	if (!isActive()) return true;
5178	CurrentSource = L;
5179	return CMP3<PT_Uint64>(S, CodePtr(), A0);
5180	}
5181	bool EvalEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, SourceInfo L) {
5182	if (!isActive()) return true;
5183	CurrentSource = L;
5184	return CMP3<PT_IntAP>(S, CodePtr(), A0);
5185	}
5186	bool EvalEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, SourceInfo L) {
5187	if (!isActive()) return true;
5188	CurrentSource = L;
5189	return CMP3<PT_IntAPS>(S, CodePtr(), A0);
5190	}
5191	bool EvalEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, SourceInfo L) {
5192	if (!isActive()) return true;
5193	CurrentSource = L;
5194	return CMP3<PT_Bool>(S, CodePtr(), A0);
5195	}
5196	bool EvalEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, SourceInfo L) {
5197	if (!isActive()) return true;
5198	CurrentSource = L;
5199	return CMP3<PT_FixedPoint>(S, CodePtr(), A0);
5200	}
5201	bool EvalEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, SourceInfo L) {
5202	if (!isActive()) return true;
5203	CurrentSource = L;
5204	return CMP3<PT_Ptr>(S, CodePtr(), A0);
5205	}
5206	bool EvalEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, SourceInfo L) {
5207	if (!isActive()) return true;
5208	CurrentSource = L;
5209	return CMP3<PT_Float>(S, CodePtr(), A0);
5210	}
5211	#endif
5212	#ifdef GET_OPCODE_NAMES
5213	OP_Call,
5214	#endif
5215	#ifdef GET_INTERPFN_LIST
5216	&Interp_Call,
5217	#endif
5218	#ifdef GET_INTERPFN_DISPATCHERS
5219	PRESERVE_NONE
5220	static bool Interp_Call(InterpState &S) {
5221	{
5222	CodePtr OpPC = S.PC;
5223	const auto V0 = ReadArg<const Function *>(S, S.PC);
5224	const auto V1 = ReadArg<uint32_t>(S, S.PC);
5225	if (!Call(S, OpPC, V0, V1)) return false;
5226	}
5227	#if USE_TAILCALLS
5228	MUSTTAIL return InterpNext(S);
5229	#else
5230	return true;
5231	#endif
5232	}
5233	#endif
5234	#ifdef GET_DISASM
5235	case OP_Call:
5236	Text.Op = PrintName("Call");
5237	Text.Args.push_back(printArg<const Function *>(P, PC));
5238	Text.Args.push_back(printArg<uint32_t>(P, PC));
5239	break;
5240	#endif
5241	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5242	bool emitCall( const Function * , uint32_t , SourceInfo);
5243	#endif
5244	#ifdef GET_LINK_IMPL
5245	bool ByteCodeEmitter::emitCall( const Function * A0, uint32_t A1, SourceInfo L) {
5246	return emitOp<const Function *, uint32_t>(OP_Call, A0, A1, L);
5247	}
5248	#endif
5249	#ifdef GET_EVAL_IMPL
5250	bool EvalEmitter::emitCall( const Function * A0, uint32_t A1, SourceInfo L) {
5251	if (!isActive()) return true;
5252	CurrentSource = L;
5253	return Call(S, CodePtr(), A0, A1);
5254	}
5255	#endif
5256	#ifdef GET_OPCODE_NAMES
5257	OP_CallBI,
5258	#endif
5259	#ifdef GET_INTERPFN_LIST
5260	&Interp_CallBI,
5261	#endif
5262	#ifdef GET_INTERPFN_DISPATCHERS
5263	PRESERVE_NONE
5264	static bool Interp_CallBI(InterpState &S) {
5265	{
5266	CodePtr OpPC = S.PC;
5267	const auto V0 = ReadArg<const CallExpr *>(S, S.PC);
5268	const auto V1 = ReadArg<uint32_t>(S, S.PC);
5269	if (!CallBI(S, OpPC, V0, V1)) return false;
5270	}
5271	#if USE_TAILCALLS
5272	MUSTTAIL return InterpNext(S);
5273	#else
5274	return true;
5275	#endif
5276	}
5277	#endif
5278	#ifdef GET_DISASM
5279	case OP_CallBI:
5280	Text.Op = PrintName("CallBI");
5281	Text.Args.push_back(printArg<const CallExpr *>(P, PC));
5282	Text.Args.push_back(printArg<uint32_t>(P, PC));
5283	break;
5284	#endif
5285	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5286	bool emitCallBI( const CallExpr * , uint32_t , SourceInfo);
5287	#endif
5288	#ifdef GET_LINK_IMPL
5289	bool ByteCodeEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, SourceInfo L) {
5290	return emitOp<const CallExpr *, uint32_t>(OP_CallBI, A0, A1, L);
5291	}
5292	#endif
5293	#ifdef GET_EVAL_IMPL
5294	bool EvalEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, SourceInfo L) {
5295	if (!isActive()) return true;
5296	CurrentSource = L;
5297	return CallBI(S, CodePtr(), A0, A1);
5298	}
5299	#endif
5300	#ifdef GET_OPCODE_NAMES
5301	OP_CallPtr,
5302	#endif
5303	#ifdef GET_INTERPFN_LIST
5304	&Interp_CallPtr,
5305	#endif
5306	#ifdef GET_INTERPFN_DISPATCHERS
5307	PRESERVE_NONE
5308	static bool Interp_CallPtr(InterpState &S) {
5309	{
5310	CodePtr OpPC = S.PC;
5311	const auto V0 = ReadArg<uint32_t>(S, S.PC);
5312	const auto V1 = ReadArg<const CallExpr *>(S, S.PC);
5313	if (!CallPtr(S, OpPC, V0, V1)) return false;
5314	}
5315	#if USE_TAILCALLS
5316	MUSTTAIL return InterpNext(S);
5317	#else
5318	return true;
5319	#endif
5320	}
5321	#endif
5322	#ifdef GET_DISASM
5323	case OP_CallPtr:
5324	Text.Op = PrintName("CallPtr");
5325	Text.Args.push_back(printArg<uint32_t>(P, PC));
5326	Text.Args.push_back(printArg<const CallExpr *>(P, PC));
5327	break;
5328	#endif
5329	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5330	bool emitCallPtr( uint32_t , const CallExpr * , SourceInfo);
5331	#endif
5332	#ifdef GET_LINK_IMPL
5333	bool ByteCodeEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, SourceInfo L) {
5334	return emitOp<uint32_t, const CallExpr *>(OP_CallPtr, A0, A1, L);
5335	}
5336	#endif
5337	#ifdef GET_EVAL_IMPL
5338	bool EvalEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, SourceInfo L) {
5339	if (!isActive()) return true;
5340	CurrentSource = L;
5341	return CallPtr(S, CodePtr(), A0, A1);
5342	}
5343	#endif
5344	#ifdef GET_OPCODE_NAMES
5345	OP_CallVar,
5346	#endif
5347	#ifdef GET_INTERPFN_LIST
5348	&Interp_CallVar,
5349	#endif
5350	#ifdef GET_INTERPFN_DISPATCHERS
5351	PRESERVE_NONE
5352	static bool Interp_CallVar(InterpState &S) {
5353	{
5354	CodePtr OpPC = S.PC;
5355	const auto V0 = ReadArg<const Function *>(S, S.PC);
5356	const auto V1 = ReadArg<uint32_t>(S, S.PC);
5357	if (!CallVar(S, OpPC, V0, V1)) return false;
5358	}
5359	#if USE_TAILCALLS
5360	MUSTTAIL return InterpNext(S);
5361	#else
5362	return true;
5363	#endif
5364	}
5365	#endif
5366	#ifdef GET_DISASM
5367	case OP_CallVar:
5368	Text.Op = PrintName("CallVar");
5369	Text.Args.push_back(printArg<const Function *>(P, PC));
5370	Text.Args.push_back(printArg<uint32_t>(P, PC));
5371	break;
5372	#endif
5373	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5374	bool emitCallVar( const Function * , uint32_t , SourceInfo);
5375	#endif
5376	#ifdef GET_LINK_IMPL
5377	bool ByteCodeEmitter::emitCallVar( const Function * A0, uint32_t A1, SourceInfo L) {
5378	return emitOp<const Function *, uint32_t>(OP_CallVar, A0, A1, L);
5379	}
5380	#endif
5381	#ifdef GET_EVAL_IMPL
5382	bool EvalEmitter::emitCallVar( const Function * A0, uint32_t A1, SourceInfo L) {
5383	if (!isActive()) return true;
5384	CurrentSource = L;
5385	return CallVar(S, CodePtr(), A0, A1);
5386	}
5387	#endif
5388	#ifdef GET_OPCODE_NAMES
5389	OP_CallVirt,
5390	#endif
5391	#ifdef GET_INTERPFN_LIST
5392	&Interp_CallVirt,
5393	#endif
5394	#ifdef GET_INTERPFN_DISPATCHERS
5395	PRESERVE_NONE
5396	static bool Interp_CallVirt(InterpState &S) {
5397	{
5398	CodePtr OpPC = S.PC;
5399	const auto V0 = ReadArg<const Function *>(S, S.PC);
5400	const auto V1 = ReadArg<uint32_t>(S, S.PC);
5401	if (!CallVirt(S, OpPC, V0, V1)) return false;
5402	}
5403	#if USE_TAILCALLS
5404	MUSTTAIL return InterpNext(S);
5405	#else
5406	return true;
5407	#endif
5408	}
5409	#endif
5410	#ifdef GET_DISASM
5411	case OP_CallVirt:
5412	Text.Op = PrintName("CallVirt");
5413	Text.Args.push_back(printArg<const Function *>(P, PC));
5414	Text.Args.push_back(printArg<uint32_t>(P, PC));
5415	break;
5416	#endif
5417	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
5418	bool emitCallVirt( const Function * , uint32_t , SourceInfo);
5419	#endif
5420	#ifdef GET_LINK_IMPL
5421	bool ByteCodeEmitter::emitCallVirt( const Function * A0, uint32_t A1, SourceInfo L) {
5422	return emitOp<const Function *, uint32_t>(OP_CallVirt, A0, A1, L);
5423	}
5424	#endif
5425	#ifdef GET_EVAL_IMPL
5426	bool EvalEmitter::emitCallVirt( const Function * A0, uint32_t A1, SourceInfo L) {
5427	if (!isActive()) return true;
5428	CurrentSource = L;
5429	return CallVirt(S, CodePtr(), A0, A1);
5430	}
5431	#endif
5432	#ifdef GET_OPCODE_NAMES
5433	OP_CastUint8Uint8,
5434	OP_CastUint8Sint8,
5435	OP_CastUint8Uint16,
5436	OP_CastUint8Sint16,
5437	OP_CastUint8Uint32,
5438	OP_CastUint8Sint32,
5439	OP_CastUint8Uint64,
5440	OP_CastUint8Sint64,
5441	OP_CastUint8Bool,
5442	OP_CastSint8Uint8,
5443	OP_CastSint8Sint8,
5444	OP_CastSint8Uint16,
5445	OP_CastSint8Sint16,
5446	OP_CastSint8Uint32,
5447	OP_CastSint8Sint32,
5448	OP_CastSint8Uint64,
5449	OP_CastSint8Sint64,
5450	OP_CastSint8Bool,
5451	OP_CastUint16Uint8,
5452	OP_CastUint16Sint8,
5453	OP_CastUint16Uint16,
5454	OP_CastUint16Sint16,
5455	OP_CastUint16Uint32,
5456	OP_CastUint16Sint32,
5457	OP_CastUint16Uint64,
5458	OP_CastUint16Sint64,
5459	OP_CastUint16Bool,
5460	OP_CastSint16Uint8,
5461	OP_CastSint16Sint8,
5462	OP_CastSint16Uint16,
5463	OP_CastSint16Sint16,
5464	OP_CastSint16Uint32,
5465	OP_CastSint16Sint32,
5466	OP_CastSint16Uint64,
5467	OP_CastSint16Sint64,
5468	OP_CastSint16Bool,
5469	OP_CastUint32Uint8,
5470	OP_CastUint32Sint8,
5471	OP_CastUint32Uint16,
5472	OP_CastUint32Sint16,
5473	OP_CastUint32Uint32,
5474	OP_CastUint32Sint32,
5475	OP_CastUint32Uint64,
5476	OP_CastUint32Sint64,
5477	OP_CastUint32Bool,
5478	OP_CastSint32Uint8,
5479	OP_CastSint32Sint8,
5480	OP_CastSint32Uint16,
5481	OP_CastSint32Sint16,
5482	OP_CastSint32Uint32,
5483	OP_CastSint32Sint32,
5484	OP_CastSint32Uint64,
5485	OP_CastSint32Sint64,
5486	OP_CastSint32Bool,
5487	OP_CastUint64Uint8,
5488	OP_CastUint64Sint8,
5489	OP_CastUint64Uint16,
5490	OP_CastUint64Sint16,
5491	OP_CastUint64Uint32,
5492	OP_CastUint64Sint32,
5493	OP_CastUint64Uint64,
5494	OP_CastUint64Sint64,
5495	OP_CastUint64Bool,
5496	OP_CastSint64Uint8,
5497	OP_CastSint64Sint8,
5498	OP_CastSint64Uint16,
5499	OP_CastSint64Sint16,
5500	OP_CastSint64Uint32,
5501	OP_CastSint64Sint32,
5502	OP_CastSint64Uint64,
5503	OP_CastSint64Sint64,
5504	OP_CastSint64Bool,
5505	OP_CastBoolUint8,
5506	OP_CastBoolSint8,
5507	OP_CastBoolUint16,
5508	OP_CastBoolSint16,
5509	OP_CastBoolUint32,
5510	OP_CastBoolSint32,
5511	OP_CastBoolUint64,
5512	OP_CastBoolSint64,
5513	OP_CastBoolBool,
5514	OP_CastIntAPUint8,
5515	OP_CastIntAPSint8,
5516	OP_CastIntAPUint16,
5517	OP_CastIntAPSint16,
5518	OP_CastIntAPUint32,
5519	OP_CastIntAPSint32,
5520	OP_CastIntAPUint64,
5521	OP_CastIntAPSint64,
5522	OP_CastIntAPBool,
5523	OP_CastIntAPSUint8,
5524	OP_CastIntAPSSint8,
5525	OP_CastIntAPSUint16,
5526	OP_CastIntAPSSint16,
5527	OP_CastIntAPSUint32,
5528	OP_CastIntAPSSint32,
5529	OP_CastIntAPSUint64,
5530	OP_CastIntAPSSint64,
5531	OP_CastIntAPSBool,
5532	OP_CastFixedPointUint8,
5533	OP_CastFixedPointSint8,
5534	OP_CastFixedPointUint16,
5535	OP_CastFixedPointSint16,
5536	OP_CastFixedPointUint32,
5537	OP_CastFixedPointSint32,
5538	OP_CastFixedPointUint64,
5539	OP_CastFixedPointSint64,
5540	OP_CastFixedPointBool,
5541	#endif
5542	#ifdef GET_INTERPFN_LIST
5543	&Interp_CastUint8Uint8,
5544	&Interp_CastUint8Sint8,
5545	&Interp_CastUint8Uint16,
5546	&Interp_CastUint8Sint16,
5547	&Interp_CastUint8Uint32,
5548	&Interp_CastUint8Sint32,
5549	&Interp_CastUint8Uint64,
5550	&Interp_CastUint8Sint64,
5551	&Interp_CastUint8Bool,
5552	&Interp_CastSint8Uint8,
5553	&Interp_CastSint8Sint8,
5554	&Interp_CastSint8Uint16,
5555	&Interp_CastSint8Sint16,
5556	&Interp_CastSint8Uint32,
5557	&Interp_CastSint8Sint32,
5558	&Interp_CastSint8Uint64,
5559	&Interp_CastSint8Sint64,
5560	&Interp_CastSint8Bool,
5561	&Interp_CastUint16Uint8,
5562	&Interp_CastUint16Sint8,
5563	&Interp_CastUint16Uint16,
5564	&Interp_CastUint16Sint16,
5565	&Interp_CastUint16Uint32,
5566	&Interp_CastUint16Sint32,
5567	&Interp_CastUint16Uint64,
5568	&Interp_CastUint16Sint64,
5569	&Interp_CastUint16Bool,
5570	&Interp_CastSint16Uint8,
5571	&Interp_CastSint16Sint8,
5572	&Interp_CastSint16Uint16,
5573	&Interp_CastSint16Sint16,
5574	&Interp_CastSint16Uint32,
5575	&Interp_CastSint16Sint32,
5576	&Interp_CastSint16Uint64,
5577	&Interp_CastSint16Sint64,
5578	&Interp_CastSint16Bool,
5579	&Interp_CastUint32Uint8,
5580	&Interp_CastUint32Sint8,
5581	&Interp_CastUint32Uint16,
5582	&Interp_CastUint32Sint16,
5583	&Interp_CastUint32Uint32,
5584	&Interp_CastUint32Sint32,
5585	&Interp_CastUint32Uint64,
5586	&Interp_CastUint32Sint64,
5587	&Interp_CastUint32Bool,
5588	&Interp_CastSint32Uint8,
5589	&Interp_CastSint32Sint8,
5590	&Interp_CastSint32Uint16,
5591	&Interp_CastSint32Sint16,
5592	&Interp_CastSint32Uint32,
5593	&Interp_CastSint32Sint32,
5594	&Interp_CastSint32Uint64,
5595	&Interp_CastSint32Sint64,
5596	&Interp_CastSint32Bool,
5597	&Interp_CastUint64Uint8,
5598	&Interp_CastUint64Sint8,
5599	&Interp_CastUint64Uint16,
5600	&Interp_CastUint64Sint16,
5601	&Interp_CastUint64Uint32,
5602	&Interp_CastUint64Sint32,
5603	&Interp_CastUint64Uint64,
5604	&Interp_CastUint64Sint64,
5605	&Interp_CastUint64Bool,
5606	&Interp_CastSint64Uint8,
5607	&Interp_CastSint64Sint8,
5608	&Interp_CastSint64Uint16,
5609	&Interp_CastSint64Sint16,
5610	&Interp_CastSint64Uint32,
5611	&Interp_CastSint64Sint32,
5612	&Interp_CastSint64Uint64,
5613	&Interp_CastSint64Sint64,
5614	&Interp_CastSint64Bool,
5615	&Interp_CastBoolUint8,
5616	&Interp_CastBoolSint8,
5617	&Interp_CastBoolUint16,
5618	&Interp_CastBoolSint16,
5619	&Interp_CastBoolUint32,
5620	&Interp_CastBoolSint32,
5621	&Interp_CastBoolUint64,
5622	&Interp_CastBoolSint64,
5623	&Interp_CastBoolBool,
5624	&Interp_CastIntAPUint8,
5625	&Interp_CastIntAPSint8,
5626	&Interp_CastIntAPUint16,
5627	&Interp_CastIntAPSint16,
5628	&Interp_CastIntAPUint32,
5629	&Interp_CastIntAPSint32,
5630	&Interp_CastIntAPUint64,
5631	&Interp_CastIntAPSint64,
5632	&Interp_CastIntAPBool,
5633	&Interp_CastIntAPSUint8,
5634	&Interp_CastIntAPSSint8,
5635	&Interp_CastIntAPSUint16,
5636	&Interp_CastIntAPSSint16,
5637	&Interp_CastIntAPSUint32,
5638	&Interp_CastIntAPSSint32,
5639	&Interp_CastIntAPSUint64,
5640	&Interp_CastIntAPSSint64,
5641	&Interp_CastIntAPSBool,
5642	&Interp_CastFixedPointUint8,
5643	&Interp_CastFixedPointSint8,
5644	&Interp_CastFixedPointUint16,
5645	&Interp_CastFixedPointSint16,
5646	&Interp_CastFixedPointUint32,
5647	&Interp_CastFixedPointSint32,
5648	&Interp_CastFixedPointUint64,
5649	&Interp_CastFixedPointSint64,
5650	&Interp_CastFixedPointBool,
5651	#endif
5652	#ifdef GET_INTERPFN_DISPATCHERS
5653	PRESERVE_NONE
5654	static bool Interp_CastUint8Uint8(InterpState &S) {
5655	if (!Cast<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
5656	#if USE_TAILCALLS
5657	MUSTTAIL return InterpNext(S);
5658	#else
5659	return true;
5660	#endif
5661	}
5662	PRESERVE_NONE
5663	static bool Interp_CastUint8Sint8(InterpState &S) {
5664	if (!Cast<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
5665	#if USE_TAILCALLS
5666	MUSTTAIL return InterpNext(S);
5667	#else
5668	return true;
5669	#endif
5670	}
5671	PRESERVE_NONE
5672	static bool Interp_CastUint8Uint16(InterpState &S) {
5673	if (!Cast<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
5674	#if USE_TAILCALLS
5675	MUSTTAIL return InterpNext(S);
5676	#else
5677	return true;
5678	#endif
5679	}
5680	PRESERVE_NONE
5681	static bool Interp_CastUint8Sint16(InterpState &S) {
5682	if (!Cast<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
5683	#if USE_TAILCALLS
5684	MUSTTAIL return InterpNext(S);
5685	#else
5686	return true;
5687	#endif
5688	}
5689	PRESERVE_NONE
5690	static bool Interp_CastUint8Uint32(InterpState &S) {
5691	if (!Cast<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
5692	#if USE_TAILCALLS
5693	MUSTTAIL return InterpNext(S);
5694	#else
5695	return true;
5696	#endif
5697	}
5698	PRESERVE_NONE
5699	static bool Interp_CastUint8Sint32(InterpState &S) {
5700	if (!Cast<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
5701	#if USE_TAILCALLS
5702	MUSTTAIL return InterpNext(S);
5703	#else
5704	return true;
5705	#endif
5706	}
5707	PRESERVE_NONE
5708	static bool Interp_CastUint8Uint64(InterpState &S) {
5709	if (!Cast<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
5710	#if USE_TAILCALLS
5711	MUSTTAIL return InterpNext(S);
5712	#else
5713	return true;
5714	#endif
5715	}
5716	PRESERVE_NONE
5717	static bool Interp_CastUint8Sint64(InterpState &S) {
5718	if (!Cast<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
5719	#if USE_TAILCALLS
5720	MUSTTAIL return InterpNext(S);
5721	#else
5722	return true;
5723	#endif
5724	}
5725	PRESERVE_NONE
5726	static bool Interp_CastUint8Bool(InterpState &S) {
5727	if (!Cast<PT_Uint8, PT_Bool>(S, S.PC)) return false;
5728	#if USE_TAILCALLS
5729	MUSTTAIL return InterpNext(S);
5730	#else
5731	return true;
5732	#endif
5733	}
5734	PRESERVE_NONE
5735	static bool Interp_CastSint8Uint8(InterpState &S) {
5736	if (!Cast<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
5737	#if USE_TAILCALLS
5738	MUSTTAIL return InterpNext(S);
5739	#else
5740	return true;
5741	#endif
5742	}
5743	PRESERVE_NONE
5744	static bool Interp_CastSint8Sint8(InterpState &S) {
5745	if (!Cast<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
5746	#if USE_TAILCALLS
5747	MUSTTAIL return InterpNext(S);
5748	#else
5749	return true;
5750	#endif
5751	}
5752	PRESERVE_NONE
5753	static bool Interp_CastSint8Uint16(InterpState &S) {
5754	if (!Cast<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
5755	#if USE_TAILCALLS
5756	MUSTTAIL return InterpNext(S);
5757	#else
5758	return true;
5759	#endif
5760	}
5761	PRESERVE_NONE
5762	static bool Interp_CastSint8Sint16(InterpState &S) {
5763	if (!Cast<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
5764	#if USE_TAILCALLS
5765	MUSTTAIL return InterpNext(S);
5766	#else
5767	return true;
5768	#endif
5769	}
5770	PRESERVE_NONE
5771	static bool Interp_CastSint8Uint32(InterpState &S) {
5772	if (!Cast<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
5773	#if USE_TAILCALLS
5774	MUSTTAIL return InterpNext(S);
5775	#else
5776	return true;
5777	#endif
5778	}
5779	PRESERVE_NONE
5780	static bool Interp_CastSint8Sint32(InterpState &S) {
5781	if (!Cast<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
5782	#if USE_TAILCALLS
5783	MUSTTAIL return InterpNext(S);
5784	#else
5785	return true;
5786	#endif
5787	}
5788	PRESERVE_NONE
5789	static bool Interp_CastSint8Uint64(InterpState &S) {
5790	if (!Cast<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
5791	#if USE_TAILCALLS
5792	MUSTTAIL return InterpNext(S);
5793	#else
5794	return true;
5795	#endif
5796	}
5797	PRESERVE_NONE
5798	static bool Interp_CastSint8Sint64(InterpState &S) {
5799	if (!Cast<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
5800	#if USE_TAILCALLS
5801	MUSTTAIL return InterpNext(S);
5802	#else
5803	return true;
5804	#endif
5805	}
5806	PRESERVE_NONE
5807	static bool Interp_CastSint8Bool(InterpState &S) {
5808	if (!Cast<PT_Sint8, PT_Bool>(S, S.PC)) return false;
5809	#if USE_TAILCALLS
5810	MUSTTAIL return InterpNext(S);
5811	#else
5812	return true;
5813	#endif
5814	}
5815	PRESERVE_NONE
5816	static bool Interp_CastUint16Uint8(InterpState &S) {
5817	if (!Cast<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
5818	#if USE_TAILCALLS
5819	MUSTTAIL return InterpNext(S);
5820	#else
5821	return true;
5822	#endif
5823	}
5824	PRESERVE_NONE
5825	static bool Interp_CastUint16Sint8(InterpState &S) {
5826	if (!Cast<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
5827	#if USE_TAILCALLS
5828	MUSTTAIL return InterpNext(S);
5829	#else
5830	return true;
5831	#endif
5832	}
5833	PRESERVE_NONE
5834	static bool Interp_CastUint16Uint16(InterpState &S) {
5835	if (!Cast<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
5836	#if USE_TAILCALLS
5837	MUSTTAIL return InterpNext(S);
5838	#else
5839	return true;
5840	#endif
5841	}
5842	PRESERVE_NONE
5843	static bool Interp_CastUint16Sint16(InterpState &S) {
5844	if (!Cast<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
5845	#if USE_TAILCALLS
5846	MUSTTAIL return InterpNext(S);
5847	#else
5848	return true;
5849	#endif
5850	}
5851	PRESERVE_NONE
5852	static bool Interp_CastUint16Uint32(InterpState &S) {
5853	if (!Cast<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
5854	#if USE_TAILCALLS
5855	MUSTTAIL return InterpNext(S);
5856	#else
5857	return true;
5858	#endif
5859	}
5860	PRESERVE_NONE
5861	static bool Interp_CastUint16Sint32(InterpState &S) {
5862	if (!Cast<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
5863	#if USE_TAILCALLS
5864	MUSTTAIL return InterpNext(S);
5865	#else
5866	return true;
5867	#endif
5868	}
5869	PRESERVE_NONE
5870	static bool Interp_CastUint16Uint64(InterpState &S) {
5871	if (!Cast<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
5872	#if USE_TAILCALLS
5873	MUSTTAIL return InterpNext(S);
5874	#else
5875	return true;
5876	#endif
5877	}
5878	PRESERVE_NONE
5879	static bool Interp_CastUint16Sint64(InterpState &S) {
5880	if (!Cast<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
5881	#if USE_TAILCALLS
5882	MUSTTAIL return InterpNext(S);
5883	#else
5884	return true;
5885	#endif
5886	}
5887	PRESERVE_NONE
5888	static bool Interp_CastUint16Bool(InterpState &S) {
5889	if (!Cast<PT_Uint16, PT_Bool>(S, S.PC)) return false;
5890	#if USE_TAILCALLS
5891	MUSTTAIL return InterpNext(S);
5892	#else
5893	return true;
5894	#endif
5895	}
5896	PRESERVE_NONE
5897	static bool Interp_CastSint16Uint8(InterpState &S) {
5898	if (!Cast<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
5899	#if USE_TAILCALLS
5900	MUSTTAIL return InterpNext(S);
5901	#else
5902	return true;
5903	#endif
5904	}
5905	PRESERVE_NONE
5906	static bool Interp_CastSint16Sint8(InterpState &S) {
5907	if (!Cast<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
5908	#if USE_TAILCALLS
5909	MUSTTAIL return InterpNext(S);
5910	#else
5911	return true;
5912	#endif
5913	}
5914	PRESERVE_NONE
5915	static bool Interp_CastSint16Uint16(InterpState &S) {
5916	if (!Cast<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
5917	#if USE_TAILCALLS
5918	MUSTTAIL return InterpNext(S);
5919	#else
5920	return true;
5921	#endif
5922	}
5923	PRESERVE_NONE
5924	static bool Interp_CastSint16Sint16(InterpState &S) {
5925	if (!Cast<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
5926	#if USE_TAILCALLS
5927	MUSTTAIL return InterpNext(S);
5928	#else
5929	return true;
5930	#endif
5931	}
5932	PRESERVE_NONE
5933	static bool Interp_CastSint16Uint32(InterpState &S) {
5934	if (!Cast<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
5935	#if USE_TAILCALLS
5936	MUSTTAIL return InterpNext(S);
5937	#else
5938	return true;
5939	#endif
5940	}
5941	PRESERVE_NONE
5942	static bool Interp_CastSint16Sint32(InterpState &S) {
5943	if (!Cast<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
5944	#if USE_TAILCALLS
5945	MUSTTAIL return InterpNext(S);
5946	#else
5947	return true;
5948	#endif
5949	}
5950	PRESERVE_NONE
5951	static bool Interp_CastSint16Uint64(InterpState &S) {
5952	if (!Cast<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
5953	#if USE_TAILCALLS
5954	MUSTTAIL return InterpNext(S);
5955	#else
5956	return true;
5957	#endif
5958	}
5959	PRESERVE_NONE
5960	static bool Interp_CastSint16Sint64(InterpState &S) {
5961	if (!Cast<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
5962	#if USE_TAILCALLS
5963	MUSTTAIL return InterpNext(S);
5964	#else
5965	return true;
5966	#endif
5967	}
5968	PRESERVE_NONE
5969	static bool Interp_CastSint16Bool(InterpState &S) {
5970	if (!Cast<PT_Sint16, PT_Bool>(S, S.PC)) return false;
5971	#if USE_TAILCALLS
5972	MUSTTAIL return InterpNext(S);
5973	#else
5974	return true;
5975	#endif
5976	}
5977	PRESERVE_NONE
5978	static bool Interp_CastUint32Uint8(InterpState &S) {
5979	if (!Cast<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
5980	#if USE_TAILCALLS
5981	MUSTTAIL return InterpNext(S);
5982	#else
5983	return true;
5984	#endif
5985	}
5986	PRESERVE_NONE
5987	static bool Interp_CastUint32Sint8(InterpState &S) {
5988	if (!Cast<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
5989	#if USE_TAILCALLS
5990	MUSTTAIL return InterpNext(S);
5991	#else
5992	return true;
5993	#endif
5994	}
5995	PRESERVE_NONE
5996	static bool Interp_CastUint32Uint16(InterpState &S) {
5997	if (!Cast<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
5998	#if USE_TAILCALLS
5999	MUSTTAIL return InterpNext(S);
6000	#else
6001	return true;
6002	#endif
6003	}
6004	PRESERVE_NONE
6005	static bool Interp_CastUint32Sint16(InterpState &S) {
6006	if (!Cast<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
6007	#if USE_TAILCALLS
6008	MUSTTAIL return InterpNext(S);
6009	#else
6010	return true;
6011	#endif
6012	}
6013	PRESERVE_NONE
6014	static bool Interp_CastUint32Uint32(InterpState &S) {
6015	if (!Cast<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
6016	#if USE_TAILCALLS
6017	MUSTTAIL return InterpNext(S);
6018	#else
6019	return true;
6020	#endif
6021	}
6022	PRESERVE_NONE
6023	static bool Interp_CastUint32Sint32(InterpState &S) {
6024	if (!Cast<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
6025	#if USE_TAILCALLS
6026	MUSTTAIL return InterpNext(S);
6027	#else
6028	return true;
6029	#endif
6030	}
6031	PRESERVE_NONE
6032	static bool Interp_CastUint32Uint64(InterpState &S) {
6033	if (!Cast<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
6034	#if USE_TAILCALLS
6035	MUSTTAIL return InterpNext(S);
6036	#else
6037	return true;
6038	#endif
6039	}
6040	PRESERVE_NONE
6041	static bool Interp_CastUint32Sint64(InterpState &S) {
6042	if (!Cast<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
6043	#if USE_TAILCALLS
6044	MUSTTAIL return InterpNext(S);
6045	#else
6046	return true;
6047	#endif
6048	}
6049	PRESERVE_NONE
6050	static bool Interp_CastUint32Bool(InterpState &S) {
6051	if (!Cast<PT_Uint32, PT_Bool>(S, S.PC)) return false;
6052	#if USE_TAILCALLS
6053	MUSTTAIL return InterpNext(S);
6054	#else
6055	return true;
6056	#endif
6057	}
6058	PRESERVE_NONE
6059	static bool Interp_CastSint32Uint8(InterpState &S) {
6060	if (!Cast<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
6061	#if USE_TAILCALLS
6062	MUSTTAIL return InterpNext(S);
6063	#else
6064	return true;
6065	#endif
6066	}
6067	PRESERVE_NONE
6068	static bool Interp_CastSint32Sint8(InterpState &S) {
6069	if (!Cast<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
6070	#if USE_TAILCALLS
6071	MUSTTAIL return InterpNext(S);
6072	#else
6073	return true;
6074	#endif
6075	}
6076	PRESERVE_NONE
6077	static bool Interp_CastSint32Uint16(InterpState &S) {
6078	if (!Cast<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
6079	#if USE_TAILCALLS
6080	MUSTTAIL return InterpNext(S);
6081	#else
6082	return true;
6083	#endif
6084	}
6085	PRESERVE_NONE
6086	static bool Interp_CastSint32Sint16(InterpState &S) {
6087	if (!Cast<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
6088	#if USE_TAILCALLS
6089	MUSTTAIL return InterpNext(S);
6090	#else
6091	return true;
6092	#endif
6093	}
6094	PRESERVE_NONE
6095	static bool Interp_CastSint32Uint32(InterpState &S) {
6096	if (!Cast<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
6097	#if USE_TAILCALLS
6098	MUSTTAIL return InterpNext(S);
6099	#else
6100	return true;
6101	#endif
6102	}
6103	PRESERVE_NONE
6104	static bool Interp_CastSint32Sint32(InterpState &S) {
6105	if (!Cast<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
6106	#if USE_TAILCALLS
6107	MUSTTAIL return InterpNext(S);
6108	#else
6109	return true;
6110	#endif
6111	}
6112	PRESERVE_NONE
6113	static bool Interp_CastSint32Uint64(InterpState &S) {
6114	if (!Cast<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
6115	#if USE_TAILCALLS
6116	MUSTTAIL return InterpNext(S);
6117	#else
6118	return true;
6119	#endif
6120	}
6121	PRESERVE_NONE
6122	static bool Interp_CastSint32Sint64(InterpState &S) {
6123	if (!Cast<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
6124	#if USE_TAILCALLS
6125	MUSTTAIL return InterpNext(S);
6126	#else
6127	return true;
6128	#endif
6129	}
6130	PRESERVE_NONE
6131	static bool Interp_CastSint32Bool(InterpState &S) {
6132	if (!Cast<PT_Sint32, PT_Bool>(S, S.PC)) return false;
6133	#if USE_TAILCALLS
6134	MUSTTAIL return InterpNext(S);
6135	#else
6136	return true;
6137	#endif
6138	}
6139	PRESERVE_NONE
6140	static bool Interp_CastUint64Uint8(InterpState &S) {
6141	if (!Cast<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
6142	#if USE_TAILCALLS
6143	MUSTTAIL return InterpNext(S);
6144	#else
6145	return true;
6146	#endif
6147	}
6148	PRESERVE_NONE
6149	static bool Interp_CastUint64Sint8(InterpState &S) {
6150	if (!Cast<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
6151	#if USE_TAILCALLS
6152	MUSTTAIL return InterpNext(S);
6153	#else
6154	return true;
6155	#endif
6156	}
6157	PRESERVE_NONE
6158	static bool Interp_CastUint64Uint16(InterpState &S) {
6159	if (!Cast<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
6160	#if USE_TAILCALLS
6161	MUSTTAIL return InterpNext(S);
6162	#else
6163	return true;
6164	#endif
6165	}
6166	PRESERVE_NONE
6167	static bool Interp_CastUint64Sint16(InterpState &S) {
6168	if (!Cast<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
6169	#if USE_TAILCALLS
6170	MUSTTAIL return InterpNext(S);
6171	#else
6172	return true;
6173	#endif
6174	}
6175	PRESERVE_NONE
6176	static bool Interp_CastUint64Uint32(InterpState &S) {
6177	if (!Cast<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
6178	#if USE_TAILCALLS
6179	MUSTTAIL return InterpNext(S);
6180	#else
6181	return true;
6182	#endif
6183	}
6184	PRESERVE_NONE
6185	static bool Interp_CastUint64Sint32(InterpState &S) {
6186	if (!Cast<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
6187	#if USE_TAILCALLS
6188	MUSTTAIL return InterpNext(S);
6189	#else
6190	return true;
6191	#endif
6192	}
6193	PRESERVE_NONE
6194	static bool Interp_CastUint64Uint64(InterpState &S) {
6195	if (!Cast<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
6196	#if USE_TAILCALLS
6197	MUSTTAIL return InterpNext(S);
6198	#else
6199	return true;
6200	#endif
6201	}
6202	PRESERVE_NONE
6203	static bool Interp_CastUint64Sint64(InterpState &S) {
6204	if (!Cast<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
6205	#if USE_TAILCALLS
6206	MUSTTAIL return InterpNext(S);
6207	#else
6208	return true;
6209	#endif
6210	}
6211	PRESERVE_NONE
6212	static bool Interp_CastUint64Bool(InterpState &S) {
6213	if (!Cast<PT_Uint64, PT_Bool>(S, S.PC)) return false;
6214	#if USE_TAILCALLS
6215	MUSTTAIL return InterpNext(S);
6216	#else
6217	return true;
6218	#endif
6219	}
6220	PRESERVE_NONE
6221	static bool Interp_CastSint64Uint8(InterpState &S) {
6222	if (!Cast<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
6223	#if USE_TAILCALLS
6224	MUSTTAIL return InterpNext(S);
6225	#else
6226	return true;
6227	#endif
6228	}
6229	PRESERVE_NONE
6230	static bool Interp_CastSint64Sint8(InterpState &S) {
6231	if (!Cast<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
6232	#if USE_TAILCALLS
6233	MUSTTAIL return InterpNext(S);
6234	#else
6235	return true;
6236	#endif
6237	}
6238	PRESERVE_NONE
6239	static bool Interp_CastSint64Uint16(InterpState &S) {
6240	if (!Cast<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
6241	#if USE_TAILCALLS
6242	MUSTTAIL return InterpNext(S);
6243	#else
6244	return true;
6245	#endif
6246	}
6247	PRESERVE_NONE
6248	static bool Interp_CastSint64Sint16(InterpState &S) {
6249	if (!Cast<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
6250	#if USE_TAILCALLS
6251	MUSTTAIL return InterpNext(S);
6252	#else
6253	return true;
6254	#endif
6255	}
6256	PRESERVE_NONE
6257	static bool Interp_CastSint64Uint32(InterpState &S) {
6258	if (!Cast<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
6259	#if USE_TAILCALLS
6260	MUSTTAIL return InterpNext(S);
6261	#else
6262	return true;
6263	#endif
6264	}
6265	PRESERVE_NONE
6266	static bool Interp_CastSint64Sint32(InterpState &S) {
6267	if (!Cast<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
6268	#if USE_TAILCALLS
6269	MUSTTAIL return InterpNext(S);
6270	#else
6271	return true;
6272	#endif
6273	}
6274	PRESERVE_NONE
6275	static bool Interp_CastSint64Uint64(InterpState &S) {
6276	if (!Cast<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
6277	#if USE_TAILCALLS
6278	MUSTTAIL return InterpNext(S);
6279	#else
6280	return true;
6281	#endif
6282	}
6283	PRESERVE_NONE
6284	static bool Interp_CastSint64Sint64(InterpState &S) {
6285	if (!Cast<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
6286	#if USE_TAILCALLS
6287	MUSTTAIL return InterpNext(S);
6288	#else
6289	return true;
6290	#endif
6291	}
6292	PRESERVE_NONE
6293	static bool Interp_CastSint64Bool(InterpState &S) {
6294	if (!Cast<PT_Sint64, PT_Bool>(S, S.PC)) return false;
6295	#if USE_TAILCALLS
6296	MUSTTAIL return InterpNext(S);
6297	#else
6298	return true;
6299	#endif
6300	}
6301	PRESERVE_NONE
6302	static bool Interp_CastBoolUint8(InterpState &S) {
6303	if (!Cast<PT_Bool, PT_Uint8>(S, S.PC)) return false;
6304	#if USE_TAILCALLS
6305	MUSTTAIL return InterpNext(S);
6306	#else
6307	return true;
6308	#endif
6309	}
6310	PRESERVE_NONE
6311	static bool Interp_CastBoolSint8(InterpState &S) {
6312	if (!Cast<PT_Bool, PT_Sint8>(S, S.PC)) return false;
6313	#if USE_TAILCALLS
6314	MUSTTAIL return InterpNext(S);
6315	#else
6316	return true;
6317	#endif
6318	}
6319	PRESERVE_NONE
6320	static bool Interp_CastBoolUint16(InterpState &S) {
6321	if (!Cast<PT_Bool, PT_Uint16>(S, S.PC)) return false;
6322	#if USE_TAILCALLS
6323	MUSTTAIL return InterpNext(S);
6324	#else
6325	return true;
6326	#endif
6327	}
6328	PRESERVE_NONE
6329	static bool Interp_CastBoolSint16(InterpState &S) {
6330	if (!Cast<PT_Bool, PT_Sint16>(S, S.PC)) return false;
6331	#if USE_TAILCALLS
6332	MUSTTAIL return InterpNext(S);
6333	#else
6334	return true;
6335	#endif
6336	}
6337	PRESERVE_NONE
6338	static bool Interp_CastBoolUint32(InterpState &S) {
6339	if (!Cast<PT_Bool, PT_Uint32>(S, S.PC)) return false;
6340	#if USE_TAILCALLS
6341	MUSTTAIL return InterpNext(S);
6342	#else
6343	return true;
6344	#endif
6345	}
6346	PRESERVE_NONE
6347	static bool Interp_CastBoolSint32(InterpState &S) {
6348	if (!Cast<PT_Bool, PT_Sint32>(S, S.PC)) return false;
6349	#if USE_TAILCALLS
6350	MUSTTAIL return InterpNext(S);
6351	#else
6352	return true;
6353	#endif
6354	}
6355	PRESERVE_NONE
6356	static bool Interp_CastBoolUint64(InterpState &S) {
6357	if (!Cast<PT_Bool, PT_Uint64>(S, S.PC)) return false;
6358	#if USE_TAILCALLS
6359	MUSTTAIL return InterpNext(S);
6360	#else
6361	return true;
6362	#endif
6363	}
6364	PRESERVE_NONE
6365	static bool Interp_CastBoolSint64(InterpState &S) {
6366	if (!Cast<PT_Bool, PT_Sint64>(S, S.PC)) return false;
6367	#if USE_TAILCALLS
6368	MUSTTAIL return InterpNext(S);
6369	#else
6370	return true;
6371	#endif
6372	}
6373	PRESERVE_NONE
6374	static bool Interp_CastBoolBool(InterpState &S) {
6375	if (!Cast<PT_Bool, PT_Bool>(S, S.PC)) return false;
6376	#if USE_TAILCALLS
6377	MUSTTAIL return InterpNext(S);
6378	#else
6379	return true;
6380	#endif
6381	}
6382	PRESERVE_NONE
6383	static bool Interp_CastIntAPUint8(InterpState &S) {
6384	if (!Cast<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
6385	#if USE_TAILCALLS
6386	MUSTTAIL return InterpNext(S);
6387	#else
6388	return true;
6389	#endif
6390	}
6391	PRESERVE_NONE
6392	static bool Interp_CastIntAPSint8(InterpState &S) {
6393	if (!Cast<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
6394	#if USE_TAILCALLS
6395	MUSTTAIL return InterpNext(S);
6396	#else
6397	return true;
6398	#endif
6399	}
6400	PRESERVE_NONE
6401	static bool Interp_CastIntAPUint16(InterpState &S) {
6402	if (!Cast<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
6403	#if USE_TAILCALLS
6404	MUSTTAIL return InterpNext(S);
6405	#else
6406	return true;
6407	#endif
6408	}
6409	PRESERVE_NONE
6410	static bool Interp_CastIntAPSint16(InterpState &S) {
6411	if (!Cast<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
6412	#if USE_TAILCALLS
6413	MUSTTAIL return InterpNext(S);
6414	#else
6415	return true;
6416	#endif
6417	}
6418	PRESERVE_NONE
6419	static bool Interp_CastIntAPUint32(InterpState &S) {
6420	if (!Cast<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
6421	#if USE_TAILCALLS
6422	MUSTTAIL return InterpNext(S);
6423	#else
6424	return true;
6425	#endif
6426	}
6427	PRESERVE_NONE
6428	static bool Interp_CastIntAPSint32(InterpState &S) {
6429	if (!Cast<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
6430	#if USE_TAILCALLS
6431	MUSTTAIL return InterpNext(S);
6432	#else
6433	return true;
6434	#endif
6435	}
6436	PRESERVE_NONE
6437	static bool Interp_CastIntAPUint64(InterpState &S) {
6438	if (!Cast<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
6439	#if USE_TAILCALLS
6440	MUSTTAIL return InterpNext(S);
6441	#else
6442	return true;
6443	#endif
6444	}
6445	PRESERVE_NONE
6446	static bool Interp_CastIntAPSint64(InterpState &S) {
6447	if (!Cast<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
6448	#if USE_TAILCALLS
6449	MUSTTAIL return InterpNext(S);
6450	#else
6451	return true;
6452	#endif
6453	}
6454	PRESERVE_NONE
6455	static bool Interp_CastIntAPBool(InterpState &S) {
6456	if (!Cast<PT_IntAP, PT_Bool>(S, S.PC)) return false;
6457	#if USE_TAILCALLS
6458	MUSTTAIL return InterpNext(S);
6459	#else
6460	return true;
6461	#endif
6462	}
6463	PRESERVE_NONE
6464	static bool Interp_CastIntAPSUint8(InterpState &S) {
6465	if (!Cast<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
6466	#if USE_TAILCALLS
6467	MUSTTAIL return InterpNext(S);
6468	#else
6469	return true;
6470	#endif
6471	}
6472	PRESERVE_NONE
6473	static bool Interp_CastIntAPSSint8(InterpState &S) {
6474	if (!Cast<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
6475	#if USE_TAILCALLS
6476	MUSTTAIL return InterpNext(S);
6477	#else
6478	return true;
6479	#endif
6480	}
6481	PRESERVE_NONE
6482	static bool Interp_CastIntAPSUint16(InterpState &S) {
6483	if (!Cast<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
6484	#if USE_TAILCALLS
6485	MUSTTAIL return InterpNext(S);
6486	#else
6487	return true;
6488	#endif
6489	}
6490	PRESERVE_NONE
6491	static bool Interp_CastIntAPSSint16(InterpState &S) {
6492	if (!Cast<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
6493	#if USE_TAILCALLS
6494	MUSTTAIL return InterpNext(S);
6495	#else
6496	return true;
6497	#endif
6498	}
6499	PRESERVE_NONE
6500	static bool Interp_CastIntAPSUint32(InterpState &S) {
6501	if (!Cast<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
6502	#if USE_TAILCALLS
6503	MUSTTAIL return InterpNext(S);
6504	#else
6505	return true;
6506	#endif
6507	}
6508	PRESERVE_NONE
6509	static bool Interp_CastIntAPSSint32(InterpState &S) {
6510	if (!Cast<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
6511	#if USE_TAILCALLS
6512	MUSTTAIL return InterpNext(S);
6513	#else
6514	return true;
6515	#endif
6516	}
6517	PRESERVE_NONE
6518	static bool Interp_CastIntAPSUint64(InterpState &S) {
6519	if (!Cast<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
6520	#if USE_TAILCALLS
6521	MUSTTAIL return InterpNext(S);
6522	#else
6523	return true;
6524	#endif
6525	}
6526	PRESERVE_NONE
6527	static bool Interp_CastIntAPSSint64(InterpState &S) {
6528	if (!Cast<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
6529	#if USE_TAILCALLS
6530	MUSTTAIL return InterpNext(S);
6531	#else
6532	return true;
6533	#endif
6534	}
6535	PRESERVE_NONE
6536	static bool Interp_CastIntAPSBool(InterpState &S) {
6537	if (!Cast<PT_IntAPS, PT_Bool>(S, S.PC)) return false;
6538	#if USE_TAILCALLS
6539	MUSTTAIL return InterpNext(S);
6540	#else
6541	return true;
6542	#endif
6543	}
6544	PRESERVE_NONE
6545	static bool Interp_CastFixedPointUint8(InterpState &S) {
6546	if (!Cast<PT_FixedPoint, PT_Uint8>(S, S.PC)) return false;
6547	#if USE_TAILCALLS
6548	MUSTTAIL return InterpNext(S);
6549	#else
6550	return true;
6551	#endif
6552	}
6553	PRESERVE_NONE
6554	static bool Interp_CastFixedPointSint8(InterpState &S) {
6555	if (!Cast<PT_FixedPoint, PT_Sint8>(S, S.PC)) return false;
6556	#if USE_TAILCALLS
6557	MUSTTAIL return InterpNext(S);
6558	#else
6559	return true;
6560	#endif
6561	}
6562	PRESERVE_NONE
6563	static bool Interp_CastFixedPointUint16(InterpState &S) {
6564	if (!Cast<PT_FixedPoint, PT_Uint16>(S, S.PC)) return false;
6565	#if USE_TAILCALLS
6566	MUSTTAIL return InterpNext(S);
6567	#else
6568	return true;
6569	#endif
6570	}
6571	PRESERVE_NONE
6572	static bool Interp_CastFixedPointSint16(InterpState &S) {
6573	if (!Cast<PT_FixedPoint, PT_Sint16>(S, S.PC)) return false;
6574	#if USE_TAILCALLS
6575	MUSTTAIL return InterpNext(S);
6576	#else
6577	return true;
6578	#endif
6579	}
6580	PRESERVE_NONE
6581	static bool Interp_CastFixedPointUint32(InterpState &S) {
6582	if (!Cast<PT_FixedPoint, PT_Uint32>(S, S.PC)) return false;
6583	#if USE_TAILCALLS
6584	MUSTTAIL return InterpNext(S);
6585	#else
6586	return true;
6587	#endif
6588	}
6589	PRESERVE_NONE
6590	static bool Interp_CastFixedPointSint32(InterpState &S) {
6591	if (!Cast<PT_FixedPoint, PT_Sint32>(S, S.PC)) return false;
6592	#if USE_TAILCALLS
6593	MUSTTAIL return InterpNext(S);
6594	#else
6595	return true;
6596	#endif
6597	}
6598	PRESERVE_NONE
6599	static bool Interp_CastFixedPointUint64(InterpState &S) {
6600	if (!Cast<PT_FixedPoint, PT_Uint64>(S, S.PC)) return false;
6601	#if USE_TAILCALLS
6602	MUSTTAIL return InterpNext(S);
6603	#else
6604	return true;
6605	#endif
6606	}
6607	PRESERVE_NONE
6608	static bool Interp_CastFixedPointSint64(InterpState &S) {
6609	if (!Cast<PT_FixedPoint, PT_Sint64>(S, S.PC)) return false;
6610	#if USE_TAILCALLS
6611	MUSTTAIL return InterpNext(S);
6612	#else
6613	return true;
6614	#endif
6615	}
6616	PRESERVE_NONE
6617	static bool Interp_CastFixedPointBool(InterpState &S) {
6618	if (!Cast<PT_FixedPoint, PT_Bool>(S, S.PC)) return false;
6619	#if USE_TAILCALLS
6620	MUSTTAIL return InterpNext(S);
6621	#else
6622	return true;
6623	#endif
6624	}
6625	#endif
6626	#ifdef GET_DISASM
6627	case OP_CastUint8Uint8:
6628	Text.Op = PrintName("CastUint8Uint8");
6629	break;
6630	case OP_CastUint8Sint8:
6631	Text.Op = PrintName("CastUint8Sint8");
6632	break;
6633	case OP_CastUint8Uint16:
6634	Text.Op = PrintName("CastUint8Uint16");
6635	break;
6636	case OP_CastUint8Sint16:
6637	Text.Op = PrintName("CastUint8Sint16");
6638	break;
6639	case OP_CastUint8Uint32:
6640	Text.Op = PrintName("CastUint8Uint32");
6641	break;
6642	case OP_CastUint8Sint32:
6643	Text.Op = PrintName("CastUint8Sint32");
6644	break;
6645	case OP_CastUint8Uint64:
6646	Text.Op = PrintName("CastUint8Uint64");
6647	break;
6648	case OP_CastUint8Sint64:
6649	Text.Op = PrintName("CastUint8Sint64");
6650	break;
6651	case OP_CastUint8Bool:
6652	Text.Op = PrintName("CastUint8Bool");
6653	break;
6654	case OP_CastSint8Uint8:
6655	Text.Op = PrintName("CastSint8Uint8");
6656	break;
6657	case OP_CastSint8Sint8:
6658	Text.Op = PrintName("CastSint8Sint8");
6659	break;
6660	case OP_CastSint8Uint16:
6661	Text.Op = PrintName("CastSint8Uint16");
6662	break;
6663	case OP_CastSint8Sint16:
6664	Text.Op = PrintName("CastSint8Sint16");
6665	break;
6666	case OP_CastSint8Uint32:
6667	Text.Op = PrintName("CastSint8Uint32");
6668	break;
6669	case OP_CastSint8Sint32:
6670	Text.Op = PrintName("CastSint8Sint32");
6671	break;
6672	case OP_CastSint8Uint64:
6673	Text.Op = PrintName("CastSint8Uint64");
6674	break;
6675	case OP_CastSint8Sint64:
6676	Text.Op = PrintName("CastSint8Sint64");
6677	break;
6678	case OP_CastSint8Bool:
6679	Text.Op = PrintName("CastSint8Bool");
6680	break;
6681	case OP_CastUint16Uint8:
6682	Text.Op = PrintName("CastUint16Uint8");
6683	break;
6684	case OP_CastUint16Sint8:
6685	Text.Op = PrintName("CastUint16Sint8");
6686	break;
6687	case OP_CastUint16Uint16:
6688	Text.Op = PrintName("CastUint16Uint16");
6689	break;
6690	case OP_CastUint16Sint16:
6691	Text.Op = PrintName("CastUint16Sint16");
6692	break;
6693	case OP_CastUint16Uint32:
6694	Text.Op = PrintName("CastUint16Uint32");
6695	break;
6696	case OP_CastUint16Sint32:
6697	Text.Op = PrintName("CastUint16Sint32");
6698	break;
6699	case OP_CastUint16Uint64:
6700	Text.Op = PrintName("CastUint16Uint64");
6701	break;
6702	case OP_CastUint16Sint64:
6703	Text.Op = PrintName("CastUint16Sint64");
6704	break;
6705	case OP_CastUint16Bool:
6706	Text.Op = PrintName("CastUint16Bool");
6707	break;
6708	case OP_CastSint16Uint8:
6709	Text.Op = PrintName("CastSint16Uint8");
6710	break;
6711	case OP_CastSint16Sint8:
6712	Text.Op = PrintName("CastSint16Sint8");
6713	break;
6714	case OP_CastSint16Uint16:
6715	Text.Op = PrintName("CastSint16Uint16");
6716	break;
6717	case OP_CastSint16Sint16:
6718	Text.Op = PrintName("CastSint16Sint16");
6719	break;
6720	case OP_CastSint16Uint32:
6721	Text.Op = PrintName("CastSint16Uint32");
6722	break;
6723	case OP_CastSint16Sint32:
6724	Text.Op = PrintName("CastSint16Sint32");
6725	break;
6726	case OP_CastSint16Uint64:
6727	Text.Op = PrintName("CastSint16Uint64");
6728	break;
6729	case OP_CastSint16Sint64:
6730	Text.Op = PrintName("CastSint16Sint64");
6731	break;
6732	case OP_CastSint16Bool:
6733	Text.Op = PrintName("CastSint16Bool");
6734	break;
6735	case OP_CastUint32Uint8:
6736	Text.Op = PrintName("CastUint32Uint8");
6737	break;
6738	case OP_CastUint32Sint8:
6739	Text.Op = PrintName("CastUint32Sint8");
6740	break;
6741	case OP_CastUint32Uint16:
6742	Text.Op = PrintName("CastUint32Uint16");
6743	break;
6744	case OP_CastUint32Sint16:
6745	Text.Op = PrintName("CastUint32Sint16");
6746	break;
6747	case OP_CastUint32Uint32:
6748	Text.Op = PrintName("CastUint32Uint32");
6749	break;
6750	case OP_CastUint32Sint32:
6751	Text.Op = PrintName("CastUint32Sint32");
6752	break;
6753	case OP_CastUint32Uint64:
6754	Text.Op = PrintName("CastUint32Uint64");
6755	break;
6756	case OP_CastUint32Sint64:
6757	Text.Op = PrintName("CastUint32Sint64");
6758	break;
6759	case OP_CastUint32Bool:
6760	Text.Op = PrintName("CastUint32Bool");
6761	break;
6762	case OP_CastSint32Uint8:
6763	Text.Op = PrintName("CastSint32Uint8");
6764	break;
6765	case OP_CastSint32Sint8:
6766	Text.Op = PrintName("CastSint32Sint8");
6767	break;
6768	case OP_CastSint32Uint16:
6769	Text.Op = PrintName("CastSint32Uint16");
6770	break;
6771	case OP_CastSint32Sint16:
6772	Text.Op = PrintName("CastSint32Sint16");
6773	break;
6774	case OP_CastSint32Uint32:
6775	Text.Op = PrintName("CastSint32Uint32");
6776	break;
6777	case OP_CastSint32Sint32:
6778	Text.Op = PrintName("CastSint32Sint32");
6779	break;
6780	case OP_CastSint32Uint64:
6781	Text.Op = PrintName("CastSint32Uint64");
6782	break;
6783	case OP_CastSint32Sint64:
6784	Text.Op = PrintName("CastSint32Sint64");
6785	break;
6786	case OP_CastSint32Bool:
6787	Text.Op = PrintName("CastSint32Bool");
6788	break;
6789	case OP_CastUint64Uint8:
6790	Text.Op = PrintName("CastUint64Uint8");
6791	break;
6792	case OP_CastUint64Sint8:
6793	Text.Op = PrintName("CastUint64Sint8");
6794	break;
6795	case OP_CastUint64Uint16:
6796	Text.Op = PrintName("CastUint64Uint16");
6797	break;
6798	case OP_CastUint64Sint16:
6799	Text.Op = PrintName("CastUint64Sint16");
6800	break;
6801	case OP_CastUint64Uint32:
6802	Text.Op = PrintName("CastUint64Uint32");
6803	break;
6804	case OP_CastUint64Sint32:
6805	Text.Op = PrintName("CastUint64Sint32");
6806	break;
6807	case OP_CastUint64Uint64:
6808	Text.Op = PrintName("CastUint64Uint64");
6809	break;
6810	case OP_CastUint64Sint64:
6811	Text.Op = PrintName("CastUint64Sint64");
6812	break;
6813	case OP_CastUint64Bool:
6814	Text.Op = PrintName("CastUint64Bool");
6815	break;
6816	case OP_CastSint64Uint8:
6817	Text.Op = PrintName("CastSint64Uint8");
6818	break;
6819	case OP_CastSint64Sint8:
6820	Text.Op = PrintName("CastSint64Sint8");
6821	break;
6822	case OP_CastSint64Uint16:
6823	Text.Op = PrintName("CastSint64Uint16");
6824	break;
6825	case OP_CastSint64Sint16:
6826	Text.Op = PrintName("CastSint64Sint16");
6827	break;
6828	case OP_CastSint64Uint32:
6829	Text.Op = PrintName("CastSint64Uint32");
6830	break;
6831	case OP_CastSint64Sint32:
6832	Text.Op = PrintName("CastSint64Sint32");
6833	break;
6834	case OP_CastSint64Uint64:
6835	Text.Op = PrintName("CastSint64Uint64");
6836	break;
6837	case OP_CastSint64Sint64:
6838	Text.Op = PrintName("CastSint64Sint64");
6839	break;
6840	case OP_CastSint64Bool:
6841	Text.Op = PrintName("CastSint64Bool");
6842	break;
6843	case OP_CastBoolUint8:
6844	Text.Op = PrintName("CastBoolUint8");
6845	break;
6846	case OP_CastBoolSint8:
6847	Text.Op = PrintName("CastBoolSint8");
6848	break;
6849	case OP_CastBoolUint16:
6850	Text.Op = PrintName("CastBoolUint16");
6851	break;
6852	case OP_CastBoolSint16:
6853	Text.Op = PrintName("CastBoolSint16");
6854	break;
6855	case OP_CastBoolUint32:
6856	Text.Op = PrintName("CastBoolUint32");
6857	break;
6858	case OP_CastBoolSint32:
6859	Text.Op = PrintName("CastBoolSint32");
6860	break;
6861	case OP_CastBoolUint64:
6862	Text.Op = PrintName("CastBoolUint64");
6863	break;
6864	case OP_CastBoolSint64:
6865	Text.Op = PrintName("CastBoolSint64");
6866	break;
6867	case OP_CastBoolBool:
6868	Text.Op = PrintName("CastBoolBool");
6869	break;
6870	case OP_CastIntAPUint8:
6871	Text.Op = PrintName("CastIntAPUint8");
6872	break;
6873	case OP_CastIntAPSint8:
6874	Text.Op = PrintName("CastIntAPSint8");
6875	break;
6876	case OP_CastIntAPUint16:
6877	Text.Op = PrintName("CastIntAPUint16");
6878	break;
6879	case OP_CastIntAPSint16:
6880	Text.Op = PrintName("CastIntAPSint16");
6881	break;
6882	case OP_CastIntAPUint32:
6883	Text.Op = PrintName("CastIntAPUint32");
6884	break;
6885	case OP_CastIntAPSint32:
6886	Text.Op = PrintName("CastIntAPSint32");
6887	break;
6888	case OP_CastIntAPUint64:
6889	Text.Op = PrintName("CastIntAPUint64");
6890	break;
6891	case OP_CastIntAPSint64:
6892	Text.Op = PrintName("CastIntAPSint64");
6893	break;
6894	case OP_CastIntAPBool:
6895	Text.Op = PrintName("CastIntAPBool");
6896	break;
6897	case OP_CastIntAPSUint8:
6898	Text.Op = PrintName("CastIntAPSUint8");
6899	break;
6900	case OP_CastIntAPSSint8:
6901	Text.Op = PrintName("CastIntAPSSint8");
6902	break;
6903	case OP_CastIntAPSUint16:
6904	Text.Op = PrintName("CastIntAPSUint16");
6905	break;
6906	case OP_CastIntAPSSint16:
6907	Text.Op = PrintName("CastIntAPSSint16");
6908	break;
6909	case OP_CastIntAPSUint32:
6910	Text.Op = PrintName("CastIntAPSUint32");
6911	break;
6912	case OP_CastIntAPSSint32:
6913	Text.Op = PrintName("CastIntAPSSint32");
6914	break;
6915	case OP_CastIntAPSUint64:
6916	Text.Op = PrintName("CastIntAPSUint64");
6917	break;
6918	case OP_CastIntAPSSint64:
6919	Text.Op = PrintName("CastIntAPSSint64");
6920	break;
6921	case OP_CastIntAPSBool:
6922	Text.Op = PrintName("CastIntAPSBool");
6923	break;
6924	case OP_CastFixedPointUint8:
6925	Text.Op = PrintName("CastFixedPointUint8");
6926	break;
6927	case OP_CastFixedPointSint8:
6928	Text.Op = PrintName("CastFixedPointSint8");
6929	break;
6930	case OP_CastFixedPointUint16:
6931	Text.Op = PrintName("CastFixedPointUint16");
6932	break;
6933	case OP_CastFixedPointSint16:
6934	Text.Op = PrintName("CastFixedPointSint16");
6935	break;
6936	case OP_CastFixedPointUint32:
6937	Text.Op = PrintName("CastFixedPointUint32");
6938	break;
6939	case OP_CastFixedPointSint32:
6940	Text.Op = PrintName("CastFixedPointSint32");
6941	break;
6942	case OP_CastFixedPointUint64:
6943	Text.Op = PrintName("CastFixedPointUint64");
6944	break;
6945	case OP_CastFixedPointSint64:
6946	Text.Op = PrintName("CastFixedPointSint64");
6947	break;
6948	case OP_CastFixedPointBool:
6949	Text.Op = PrintName("CastFixedPointBool");
6950	break;
6951	#endif
6952	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
6953	bool emitCastUint8Uint8(SourceInfo);
6954	bool emitCastUint8Sint8(SourceInfo);
6955	bool emitCastUint8Uint16(SourceInfo);
6956	bool emitCastUint8Sint16(SourceInfo);
6957	bool emitCastUint8Uint32(SourceInfo);
6958	bool emitCastUint8Sint32(SourceInfo);
6959	bool emitCastUint8Uint64(SourceInfo);
6960	bool emitCastUint8Sint64(SourceInfo);
6961	bool emitCastUint8Bool(SourceInfo);
6962	bool emitCastSint8Uint8(SourceInfo);
6963	bool emitCastSint8Sint8(SourceInfo);
6964	bool emitCastSint8Uint16(SourceInfo);
6965	bool emitCastSint8Sint16(SourceInfo);
6966	bool emitCastSint8Uint32(SourceInfo);
6967	bool emitCastSint8Sint32(SourceInfo);
6968	bool emitCastSint8Uint64(SourceInfo);
6969	bool emitCastSint8Sint64(SourceInfo);
6970	bool emitCastSint8Bool(SourceInfo);
6971	bool emitCastUint16Uint8(SourceInfo);
6972	bool emitCastUint16Sint8(SourceInfo);
6973	bool emitCastUint16Uint16(SourceInfo);
6974	bool emitCastUint16Sint16(SourceInfo);
6975	bool emitCastUint16Uint32(SourceInfo);
6976	bool emitCastUint16Sint32(SourceInfo);
6977	bool emitCastUint16Uint64(SourceInfo);
6978	bool emitCastUint16Sint64(SourceInfo);
6979	bool emitCastUint16Bool(SourceInfo);
6980	bool emitCastSint16Uint8(SourceInfo);
6981	bool emitCastSint16Sint8(SourceInfo);
6982	bool emitCastSint16Uint16(SourceInfo);
6983	bool emitCastSint16Sint16(SourceInfo);
6984	bool emitCastSint16Uint32(SourceInfo);
6985	bool emitCastSint16Sint32(SourceInfo);
6986	bool emitCastSint16Uint64(SourceInfo);
6987	bool emitCastSint16Sint64(SourceInfo);
6988	bool emitCastSint16Bool(SourceInfo);
6989	bool emitCastUint32Uint8(SourceInfo);
6990	bool emitCastUint32Sint8(SourceInfo);
6991	bool emitCastUint32Uint16(SourceInfo);
6992	bool emitCastUint32Sint16(SourceInfo);
6993	bool emitCastUint32Uint32(SourceInfo);
6994	bool emitCastUint32Sint32(SourceInfo);
6995	bool emitCastUint32Uint64(SourceInfo);
6996	bool emitCastUint32Sint64(SourceInfo);
6997	bool emitCastUint32Bool(SourceInfo);
6998	bool emitCastSint32Uint8(SourceInfo);
6999	bool emitCastSint32Sint8(SourceInfo);
7000	bool emitCastSint32Uint16(SourceInfo);
7001	bool emitCastSint32Sint16(SourceInfo);
7002	bool emitCastSint32Uint32(SourceInfo);
7003	bool emitCastSint32Sint32(SourceInfo);
7004	bool emitCastSint32Uint64(SourceInfo);
7005	bool emitCastSint32Sint64(SourceInfo);
7006	bool emitCastSint32Bool(SourceInfo);
7007	bool emitCastUint64Uint8(SourceInfo);
7008	bool emitCastUint64Sint8(SourceInfo);
7009	bool emitCastUint64Uint16(SourceInfo);
7010	bool emitCastUint64Sint16(SourceInfo);
7011	bool emitCastUint64Uint32(SourceInfo);
7012	bool emitCastUint64Sint32(SourceInfo);
7013	bool emitCastUint64Uint64(SourceInfo);
7014	bool emitCastUint64Sint64(SourceInfo);
7015	bool emitCastUint64Bool(SourceInfo);
7016	bool emitCastSint64Uint8(SourceInfo);
7017	bool emitCastSint64Sint8(SourceInfo);
7018	bool emitCastSint64Uint16(SourceInfo);
7019	bool emitCastSint64Sint16(SourceInfo);
7020	bool emitCastSint64Uint32(SourceInfo);
7021	bool emitCastSint64Sint32(SourceInfo);
7022	bool emitCastSint64Uint64(SourceInfo);
7023	bool emitCastSint64Sint64(SourceInfo);
7024	bool emitCastSint64Bool(SourceInfo);
7025	bool emitCastBoolUint8(SourceInfo);
7026	bool emitCastBoolSint8(SourceInfo);
7027	bool emitCastBoolUint16(SourceInfo);
7028	bool emitCastBoolSint16(SourceInfo);
7029	bool emitCastBoolUint32(SourceInfo);
7030	bool emitCastBoolSint32(SourceInfo);
7031	bool emitCastBoolUint64(SourceInfo);
7032	bool emitCastBoolSint64(SourceInfo);
7033	bool emitCastBoolBool(SourceInfo);
7034	bool emitCastIntAPUint8(SourceInfo);
7035	bool emitCastIntAPSint8(SourceInfo);
7036	bool emitCastIntAPUint16(SourceInfo);
7037	bool emitCastIntAPSint16(SourceInfo);
7038	bool emitCastIntAPUint32(SourceInfo);
7039	bool emitCastIntAPSint32(SourceInfo);
7040	bool emitCastIntAPUint64(SourceInfo);
7041	bool emitCastIntAPSint64(SourceInfo);
7042	bool emitCastIntAPBool(SourceInfo);
7043	bool emitCastIntAPSUint8(SourceInfo);
7044	bool emitCastIntAPSSint8(SourceInfo);
7045	bool emitCastIntAPSUint16(SourceInfo);
7046	bool emitCastIntAPSSint16(SourceInfo);
7047	bool emitCastIntAPSUint32(SourceInfo);
7048	bool emitCastIntAPSSint32(SourceInfo);
7049	bool emitCastIntAPSUint64(SourceInfo);
7050	bool emitCastIntAPSSint64(SourceInfo);
7051	bool emitCastIntAPSBool(SourceInfo);
7052	bool emitCastFixedPointUint8(SourceInfo);
7053	bool emitCastFixedPointSint8(SourceInfo);
7054	bool emitCastFixedPointUint16(SourceInfo);
7055	bool emitCastFixedPointSint16(SourceInfo);
7056	bool emitCastFixedPointUint32(SourceInfo);
7057	bool emitCastFixedPointSint32(SourceInfo);
7058	bool emitCastFixedPointUint64(SourceInfo);
7059	bool emitCastFixedPointSint64(SourceInfo);
7060	bool emitCastFixedPointBool(SourceInfo);
7061	#endif
7062	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
7063	[[nodiscard]] bool emitCast(PrimType, PrimType, SourceInfo I);
7064	#endif
7065	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
7066	bool
7067	#if defined(GET_EVAL_IMPL)
7068	EvalEmitter
7069	#else
7070	ByteCodeEmitter
7071	#endif
7072	::emitCast(PrimType T0, PrimType T1, SourceInfo I) {
7073	switch (T0) {
7074	case PT_Uint8:
7075	switch (T1) {
7076	case PT_Uint8:
7077	return emitCastUint8Uint8(I);
7078	case PT_Sint8:
7079	return emitCastUint8Sint8(I);
7080	case PT_Uint16:
7081	return emitCastUint8Uint16(I);
7082	case PT_Sint16:
7083	return emitCastUint8Sint16(I);
7084	case PT_Uint32:
7085	return emitCastUint8Uint32(I);
7086	case PT_Sint32:
7087	return emitCastUint8Sint32(I);
7088	case PT_Uint64:
7089	return emitCastUint8Uint64(I);
7090	case PT_Sint64:
7091	return emitCastUint8Sint64(I);
7092	case PT_Bool:
7093	return emitCastUint8Bool(I);
7094	default: llvm_unreachable("invalid type: emitCast");
7095	}
7096	llvm_unreachable("invalid enum value");
7097	case PT_Sint8:
7098	switch (T1) {
7099	case PT_Uint8:
7100	return emitCastSint8Uint8(I);
7101	case PT_Sint8:
7102	return emitCastSint8Sint8(I);
7103	case PT_Uint16:
7104	return emitCastSint8Uint16(I);
7105	case PT_Sint16:
7106	return emitCastSint8Sint16(I);
7107	case PT_Uint32:
7108	return emitCastSint8Uint32(I);
7109	case PT_Sint32:
7110	return emitCastSint8Sint32(I);
7111	case PT_Uint64:
7112	return emitCastSint8Uint64(I);
7113	case PT_Sint64:
7114	return emitCastSint8Sint64(I);
7115	case PT_Bool:
7116	return emitCastSint8Bool(I);
7117	default: llvm_unreachable("invalid type: emitCast");
7118	}
7119	llvm_unreachable("invalid enum value");
7120	case PT_Uint16:
7121	switch (T1) {
7122	case PT_Uint8:
7123	return emitCastUint16Uint8(I);
7124	case PT_Sint8:
7125	return emitCastUint16Sint8(I);
7126	case PT_Uint16:
7127	return emitCastUint16Uint16(I);
7128	case PT_Sint16:
7129	return emitCastUint16Sint16(I);
7130	case PT_Uint32:
7131	return emitCastUint16Uint32(I);
7132	case PT_Sint32:
7133	return emitCastUint16Sint32(I);
7134	case PT_Uint64:
7135	return emitCastUint16Uint64(I);
7136	case PT_Sint64:
7137	return emitCastUint16Sint64(I);
7138	case PT_Bool:
7139	return emitCastUint16Bool(I);
7140	default: llvm_unreachable("invalid type: emitCast");
7141	}
7142	llvm_unreachable("invalid enum value");
7143	case PT_Sint16:
7144	switch (T1) {
7145	case PT_Uint8:
7146	return emitCastSint16Uint8(I);
7147	case PT_Sint8:
7148	return emitCastSint16Sint8(I);
7149	case PT_Uint16:
7150	return emitCastSint16Uint16(I);
7151	case PT_Sint16:
7152	return emitCastSint16Sint16(I);
7153	case PT_Uint32:
7154	return emitCastSint16Uint32(I);
7155	case PT_Sint32:
7156	return emitCastSint16Sint32(I);
7157	case PT_Uint64:
7158	return emitCastSint16Uint64(I);
7159	case PT_Sint64:
7160	return emitCastSint16Sint64(I);
7161	case PT_Bool:
7162	return emitCastSint16Bool(I);
7163	default: llvm_unreachable("invalid type: emitCast");
7164	}
7165	llvm_unreachable("invalid enum value");
7166	case PT_Uint32:
7167	switch (T1) {
7168	case PT_Uint8:
7169	return emitCastUint32Uint8(I);
7170	case PT_Sint8:
7171	return emitCastUint32Sint8(I);
7172	case PT_Uint16:
7173	return emitCastUint32Uint16(I);
7174	case PT_Sint16:
7175	return emitCastUint32Sint16(I);
7176	case PT_Uint32:
7177	return emitCastUint32Uint32(I);
7178	case PT_Sint32:
7179	return emitCastUint32Sint32(I);
7180	case PT_Uint64:
7181	return emitCastUint32Uint64(I);
7182	case PT_Sint64:
7183	return emitCastUint32Sint64(I);
7184	case PT_Bool:
7185	return emitCastUint32Bool(I);
7186	default: llvm_unreachable("invalid type: emitCast");
7187	}
7188	llvm_unreachable("invalid enum value");
7189	case PT_Sint32:
7190	switch (T1) {
7191	case PT_Uint8:
7192	return emitCastSint32Uint8(I);
7193	case PT_Sint8:
7194	return emitCastSint32Sint8(I);
7195	case PT_Uint16:
7196	return emitCastSint32Uint16(I);
7197	case PT_Sint16:
7198	return emitCastSint32Sint16(I);
7199	case PT_Uint32:
7200	return emitCastSint32Uint32(I);
7201	case PT_Sint32:
7202	return emitCastSint32Sint32(I);
7203	case PT_Uint64:
7204	return emitCastSint32Uint64(I);
7205	case PT_Sint64:
7206	return emitCastSint32Sint64(I);
7207	case PT_Bool:
7208	return emitCastSint32Bool(I);
7209	default: llvm_unreachable("invalid type: emitCast");
7210	}
7211	llvm_unreachable("invalid enum value");
7212	case PT_Uint64:
7213	switch (T1) {
7214	case PT_Uint8:
7215	return emitCastUint64Uint8(I);
7216	case PT_Sint8:
7217	return emitCastUint64Sint8(I);
7218	case PT_Uint16:
7219	return emitCastUint64Uint16(I);
7220	case PT_Sint16:
7221	return emitCastUint64Sint16(I);
7222	case PT_Uint32:
7223	return emitCastUint64Uint32(I);
7224	case PT_Sint32:
7225	return emitCastUint64Sint32(I);
7226	case PT_Uint64:
7227	return emitCastUint64Uint64(I);
7228	case PT_Sint64:
7229	return emitCastUint64Sint64(I);
7230	case PT_Bool:
7231	return emitCastUint64Bool(I);
7232	default: llvm_unreachable("invalid type: emitCast");
7233	}
7234	llvm_unreachable("invalid enum value");
7235	case PT_Sint64:
7236	switch (T1) {
7237	case PT_Uint8:
7238	return emitCastSint64Uint8(I);
7239	case PT_Sint8:
7240	return emitCastSint64Sint8(I);
7241	case PT_Uint16:
7242	return emitCastSint64Uint16(I);
7243	case PT_Sint16:
7244	return emitCastSint64Sint16(I);
7245	case PT_Uint32:
7246	return emitCastSint64Uint32(I);
7247	case PT_Sint32:
7248	return emitCastSint64Sint32(I);
7249	case PT_Uint64:
7250	return emitCastSint64Uint64(I);
7251	case PT_Sint64:
7252	return emitCastSint64Sint64(I);
7253	case PT_Bool:
7254	return emitCastSint64Bool(I);
7255	default: llvm_unreachable("invalid type: emitCast");
7256	}
7257	llvm_unreachable("invalid enum value");
7258	case PT_Bool:
7259	switch (T1) {
7260	case PT_Uint8:
7261	return emitCastBoolUint8(I);
7262	case PT_Sint8:
7263	return emitCastBoolSint8(I);
7264	case PT_Uint16:
7265	return emitCastBoolUint16(I);
7266	case PT_Sint16:
7267	return emitCastBoolSint16(I);
7268	case PT_Uint32:
7269	return emitCastBoolUint32(I);
7270	case PT_Sint32:
7271	return emitCastBoolSint32(I);
7272	case PT_Uint64:
7273	return emitCastBoolUint64(I);
7274	case PT_Sint64:
7275	return emitCastBoolSint64(I);
7276	case PT_Bool:
7277	return emitCastBoolBool(I);
7278	default: llvm_unreachable("invalid type: emitCast");
7279	}
7280	llvm_unreachable("invalid enum value");
7281	case PT_IntAP:
7282	switch (T1) {
7283	case PT_Uint8:
7284	return emitCastIntAPUint8(I);
7285	case PT_Sint8:
7286	return emitCastIntAPSint8(I);
7287	case PT_Uint16:
7288	return emitCastIntAPUint16(I);
7289	case PT_Sint16:
7290	return emitCastIntAPSint16(I);
7291	case PT_Uint32:
7292	return emitCastIntAPUint32(I);
7293	case PT_Sint32:
7294	return emitCastIntAPSint32(I);
7295	case PT_Uint64:
7296	return emitCastIntAPUint64(I);
7297	case PT_Sint64:
7298	return emitCastIntAPSint64(I);
7299	case PT_Bool:
7300	return emitCastIntAPBool(I);
7301	default: llvm_unreachable("invalid type: emitCast");
7302	}
7303	llvm_unreachable("invalid enum value");
7304	case PT_IntAPS:
7305	switch (T1) {
7306	case PT_Uint8:
7307	return emitCastIntAPSUint8(I);
7308	case PT_Sint8:
7309	return emitCastIntAPSSint8(I);
7310	case PT_Uint16:
7311	return emitCastIntAPSUint16(I);
7312	case PT_Sint16:
7313	return emitCastIntAPSSint16(I);
7314	case PT_Uint32:
7315	return emitCastIntAPSUint32(I);
7316	case PT_Sint32:
7317	return emitCastIntAPSSint32(I);
7318	case PT_Uint64:
7319	return emitCastIntAPSUint64(I);
7320	case PT_Sint64:
7321	return emitCastIntAPSSint64(I);
7322	case PT_Bool:
7323	return emitCastIntAPSBool(I);
7324	default: llvm_unreachable("invalid type: emitCast");
7325	}
7326	llvm_unreachable("invalid enum value");
7327	case PT_FixedPoint:
7328	switch (T1) {
7329	case PT_Uint8:
7330	return emitCastFixedPointUint8(I);
7331	case PT_Sint8:
7332	return emitCastFixedPointSint8(I);
7333	case PT_Uint16:
7334	return emitCastFixedPointUint16(I);
7335	case PT_Sint16:
7336	return emitCastFixedPointSint16(I);
7337	case PT_Uint32:
7338	return emitCastFixedPointUint32(I);
7339	case PT_Sint32:
7340	return emitCastFixedPointSint32(I);
7341	case PT_Uint64:
7342	return emitCastFixedPointUint64(I);
7343	case PT_Sint64:
7344	return emitCastFixedPointSint64(I);
7345	case PT_Bool:
7346	return emitCastFixedPointBool(I);
7347	default: llvm_unreachable("invalid type: emitCast");
7348	}
7349	llvm_unreachable("invalid enum value");
7350	default: llvm_unreachable("invalid type: emitCast");
7351	}
7352	llvm_unreachable("invalid enum value");
7353	}
7354	#endif
7355	#ifdef GET_LINK_IMPL
7356	bool ByteCodeEmitter::emitCastUint8Uint8(SourceInfo L) {
7357	return emitOp<>(OP_CastUint8Uint8, L);
7358	}
7359	bool ByteCodeEmitter::emitCastUint8Sint8(SourceInfo L) {
7360	return emitOp<>(OP_CastUint8Sint8, L);
7361	}
7362	bool ByteCodeEmitter::emitCastUint8Uint16(SourceInfo L) {
7363	return emitOp<>(OP_CastUint8Uint16, L);
7364	}
7365	bool ByteCodeEmitter::emitCastUint8Sint16(SourceInfo L) {
7366	return emitOp<>(OP_CastUint8Sint16, L);
7367	}
7368	bool ByteCodeEmitter::emitCastUint8Uint32(SourceInfo L) {
7369	return emitOp<>(OP_CastUint8Uint32, L);
7370	}
7371	bool ByteCodeEmitter::emitCastUint8Sint32(SourceInfo L) {
7372	return emitOp<>(OP_CastUint8Sint32, L);
7373	}
7374	bool ByteCodeEmitter::emitCastUint8Uint64(SourceInfo L) {
7375	return emitOp<>(OP_CastUint8Uint64, L);
7376	}
7377	bool ByteCodeEmitter::emitCastUint8Sint64(SourceInfo L) {
7378	return emitOp<>(OP_CastUint8Sint64, L);
7379	}
7380	bool ByteCodeEmitter::emitCastUint8Bool(SourceInfo L) {
7381	return emitOp<>(OP_CastUint8Bool, L);
7382	}
7383	bool ByteCodeEmitter::emitCastSint8Uint8(SourceInfo L) {
7384	return emitOp<>(OP_CastSint8Uint8, L);
7385	}
7386	bool ByteCodeEmitter::emitCastSint8Sint8(SourceInfo L) {
7387	return emitOp<>(OP_CastSint8Sint8, L);
7388	}
7389	bool ByteCodeEmitter::emitCastSint8Uint16(SourceInfo L) {
7390	return emitOp<>(OP_CastSint8Uint16, L);
7391	}
7392	bool ByteCodeEmitter::emitCastSint8Sint16(SourceInfo L) {
7393	return emitOp<>(OP_CastSint8Sint16, L);
7394	}
7395	bool ByteCodeEmitter::emitCastSint8Uint32(SourceInfo L) {
7396	return emitOp<>(OP_CastSint8Uint32, L);
7397	}
7398	bool ByteCodeEmitter::emitCastSint8Sint32(SourceInfo L) {
7399	return emitOp<>(OP_CastSint8Sint32, L);
7400	}
7401	bool ByteCodeEmitter::emitCastSint8Uint64(SourceInfo L) {
7402	return emitOp<>(OP_CastSint8Uint64, L);
7403	}
7404	bool ByteCodeEmitter::emitCastSint8Sint64(SourceInfo L) {
7405	return emitOp<>(OP_CastSint8Sint64, L);
7406	}
7407	bool ByteCodeEmitter::emitCastSint8Bool(SourceInfo L) {
7408	return emitOp<>(OP_CastSint8Bool, L);
7409	}
7410	bool ByteCodeEmitter::emitCastUint16Uint8(SourceInfo L) {
7411	return emitOp<>(OP_CastUint16Uint8, L);
7412	}
7413	bool ByteCodeEmitter::emitCastUint16Sint8(SourceInfo L) {
7414	return emitOp<>(OP_CastUint16Sint8, L);
7415	}
7416	bool ByteCodeEmitter::emitCastUint16Uint16(SourceInfo L) {
7417	return emitOp<>(OP_CastUint16Uint16, L);
7418	}
7419	bool ByteCodeEmitter::emitCastUint16Sint16(SourceInfo L) {
7420	return emitOp<>(OP_CastUint16Sint16, L);
7421	}
7422	bool ByteCodeEmitter::emitCastUint16Uint32(SourceInfo L) {
7423	return emitOp<>(OP_CastUint16Uint32, L);
7424	}
7425	bool ByteCodeEmitter::emitCastUint16Sint32(SourceInfo L) {
7426	return emitOp<>(OP_CastUint16Sint32, L);
7427	}
7428	bool ByteCodeEmitter::emitCastUint16Uint64(SourceInfo L) {
7429	return emitOp<>(OP_CastUint16Uint64, L);
7430	}
7431	bool ByteCodeEmitter::emitCastUint16Sint64(SourceInfo L) {
7432	return emitOp<>(OP_CastUint16Sint64, L);
7433	}
7434	bool ByteCodeEmitter::emitCastUint16Bool(SourceInfo L) {
7435	return emitOp<>(OP_CastUint16Bool, L);
7436	}
7437	bool ByteCodeEmitter::emitCastSint16Uint8(SourceInfo L) {
7438	return emitOp<>(OP_CastSint16Uint8, L);
7439	}
7440	bool ByteCodeEmitter::emitCastSint16Sint8(SourceInfo L) {
7441	return emitOp<>(OP_CastSint16Sint8, L);
7442	}
7443	bool ByteCodeEmitter::emitCastSint16Uint16(SourceInfo L) {
7444	return emitOp<>(OP_CastSint16Uint16, L);
7445	}
7446	bool ByteCodeEmitter::emitCastSint16Sint16(SourceInfo L) {
7447	return emitOp<>(OP_CastSint16Sint16, L);
7448	}
7449	bool ByteCodeEmitter::emitCastSint16Uint32(SourceInfo L) {
7450	return emitOp<>(OP_CastSint16Uint32, L);
7451	}
7452	bool ByteCodeEmitter::emitCastSint16Sint32(SourceInfo L) {
7453	return emitOp<>(OP_CastSint16Sint32, L);
7454	}
7455	bool ByteCodeEmitter::emitCastSint16Uint64(SourceInfo L) {
7456	return emitOp<>(OP_CastSint16Uint64, L);
7457	}
7458	bool ByteCodeEmitter::emitCastSint16Sint64(SourceInfo L) {
7459	return emitOp<>(OP_CastSint16Sint64, L);
7460	}
7461	bool ByteCodeEmitter::emitCastSint16Bool(SourceInfo L) {
7462	return emitOp<>(OP_CastSint16Bool, L);
7463	}
7464	bool ByteCodeEmitter::emitCastUint32Uint8(SourceInfo L) {
7465	return emitOp<>(OP_CastUint32Uint8, L);
7466	}
7467	bool ByteCodeEmitter::emitCastUint32Sint8(SourceInfo L) {
7468	return emitOp<>(OP_CastUint32Sint8, L);
7469	}
7470	bool ByteCodeEmitter::emitCastUint32Uint16(SourceInfo L) {
7471	return emitOp<>(OP_CastUint32Uint16, L);
7472	}
7473	bool ByteCodeEmitter::emitCastUint32Sint16(SourceInfo L) {
7474	return emitOp<>(OP_CastUint32Sint16, L);
7475	}
7476	bool ByteCodeEmitter::emitCastUint32Uint32(SourceInfo L) {
7477	return emitOp<>(OP_CastUint32Uint32, L);
7478	}
7479	bool ByteCodeEmitter::emitCastUint32Sint32(SourceInfo L) {
7480	return emitOp<>(OP_CastUint32Sint32, L);
7481	}
7482	bool ByteCodeEmitter::emitCastUint32Uint64(SourceInfo L) {
7483	return emitOp<>(OP_CastUint32Uint64, L);
7484	}
7485	bool ByteCodeEmitter::emitCastUint32Sint64(SourceInfo L) {
7486	return emitOp<>(OP_CastUint32Sint64, L);
7487	}
7488	bool ByteCodeEmitter::emitCastUint32Bool(SourceInfo L) {
7489	return emitOp<>(OP_CastUint32Bool, L);
7490	}
7491	bool ByteCodeEmitter::emitCastSint32Uint8(SourceInfo L) {
7492	return emitOp<>(OP_CastSint32Uint8, L);
7493	}
7494	bool ByteCodeEmitter::emitCastSint32Sint8(SourceInfo L) {
7495	return emitOp<>(OP_CastSint32Sint8, L);
7496	}
7497	bool ByteCodeEmitter::emitCastSint32Uint16(SourceInfo L) {
7498	return emitOp<>(OP_CastSint32Uint16, L);
7499	}
7500	bool ByteCodeEmitter::emitCastSint32Sint16(SourceInfo L) {
7501	return emitOp<>(OP_CastSint32Sint16, L);
7502	}
7503	bool ByteCodeEmitter::emitCastSint32Uint32(SourceInfo L) {
7504	return emitOp<>(OP_CastSint32Uint32, L);
7505	}
7506	bool ByteCodeEmitter::emitCastSint32Sint32(SourceInfo L) {
7507	return emitOp<>(OP_CastSint32Sint32, L);
7508	}
7509	bool ByteCodeEmitter::emitCastSint32Uint64(SourceInfo L) {
7510	return emitOp<>(OP_CastSint32Uint64, L);
7511	}
7512	bool ByteCodeEmitter::emitCastSint32Sint64(SourceInfo L) {
7513	return emitOp<>(OP_CastSint32Sint64, L);
7514	}
7515	bool ByteCodeEmitter::emitCastSint32Bool(SourceInfo L) {
7516	return emitOp<>(OP_CastSint32Bool, L);
7517	}
7518	bool ByteCodeEmitter::emitCastUint64Uint8(SourceInfo L) {
7519	return emitOp<>(OP_CastUint64Uint8, L);
7520	}
7521	bool ByteCodeEmitter::emitCastUint64Sint8(SourceInfo L) {
7522	return emitOp<>(OP_CastUint64Sint8, L);
7523	}
7524	bool ByteCodeEmitter::emitCastUint64Uint16(SourceInfo L) {
7525	return emitOp<>(OP_CastUint64Uint16, L);
7526	}
7527	bool ByteCodeEmitter::emitCastUint64Sint16(SourceInfo L) {
7528	return emitOp<>(OP_CastUint64Sint16, L);
7529	}
7530	bool ByteCodeEmitter::emitCastUint64Uint32(SourceInfo L) {
7531	return emitOp<>(OP_CastUint64Uint32, L);
7532	}
7533	bool ByteCodeEmitter::emitCastUint64Sint32(SourceInfo L) {
7534	return emitOp<>(OP_CastUint64Sint32, L);
7535	}
7536	bool ByteCodeEmitter::emitCastUint64Uint64(SourceInfo L) {
7537	return emitOp<>(OP_CastUint64Uint64, L);
7538	}
7539	bool ByteCodeEmitter::emitCastUint64Sint64(SourceInfo L) {
7540	return emitOp<>(OP_CastUint64Sint64, L);
7541	}
7542	bool ByteCodeEmitter::emitCastUint64Bool(SourceInfo L) {
7543	return emitOp<>(OP_CastUint64Bool, L);
7544	}
7545	bool ByteCodeEmitter::emitCastSint64Uint8(SourceInfo L) {
7546	return emitOp<>(OP_CastSint64Uint8, L);
7547	}
7548	bool ByteCodeEmitter::emitCastSint64Sint8(SourceInfo L) {
7549	return emitOp<>(OP_CastSint64Sint8, L);
7550	}
7551	bool ByteCodeEmitter::emitCastSint64Uint16(SourceInfo L) {
7552	return emitOp<>(OP_CastSint64Uint16, L);
7553	}
7554	bool ByteCodeEmitter::emitCastSint64Sint16(SourceInfo L) {
7555	return emitOp<>(OP_CastSint64Sint16, L);
7556	}
7557	bool ByteCodeEmitter::emitCastSint64Uint32(SourceInfo L) {
7558	return emitOp<>(OP_CastSint64Uint32, L);
7559	}
7560	bool ByteCodeEmitter::emitCastSint64Sint32(SourceInfo L) {
7561	return emitOp<>(OP_CastSint64Sint32, L);
7562	}
7563	bool ByteCodeEmitter::emitCastSint64Uint64(SourceInfo L) {
7564	return emitOp<>(OP_CastSint64Uint64, L);
7565	}
7566	bool ByteCodeEmitter::emitCastSint64Sint64(SourceInfo L) {
7567	return emitOp<>(OP_CastSint64Sint64, L);
7568	}
7569	bool ByteCodeEmitter::emitCastSint64Bool(SourceInfo L) {
7570	return emitOp<>(OP_CastSint64Bool, L);
7571	}
7572	bool ByteCodeEmitter::emitCastBoolUint8(SourceInfo L) {
7573	return emitOp<>(OP_CastBoolUint8, L);
7574	}
7575	bool ByteCodeEmitter::emitCastBoolSint8(SourceInfo L) {
7576	return emitOp<>(OP_CastBoolSint8, L);
7577	}
7578	bool ByteCodeEmitter::emitCastBoolUint16(SourceInfo L) {
7579	return emitOp<>(OP_CastBoolUint16, L);
7580	}
7581	bool ByteCodeEmitter::emitCastBoolSint16(SourceInfo L) {
7582	return emitOp<>(OP_CastBoolSint16, L);
7583	}
7584	bool ByteCodeEmitter::emitCastBoolUint32(SourceInfo L) {
7585	return emitOp<>(OP_CastBoolUint32, L);
7586	}
7587	bool ByteCodeEmitter::emitCastBoolSint32(SourceInfo L) {
7588	return emitOp<>(OP_CastBoolSint32, L);
7589	}
7590	bool ByteCodeEmitter::emitCastBoolUint64(SourceInfo L) {
7591	return emitOp<>(OP_CastBoolUint64, L);
7592	}
7593	bool ByteCodeEmitter::emitCastBoolSint64(SourceInfo L) {
7594	return emitOp<>(OP_CastBoolSint64, L);
7595	}
7596	bool ByteCodeEmitter::emitCastBoolBool(SourceInfo L) {
7597	return emitOp<>(OP_CastBoolBool, L);
7598	}
7599	bool ByteCodeEmitter::emitCastIntAPUint8(SourceInfo L) {
7600	return emitOp<>(OP_CastIntAPUint8, L);
7601	}
7602	bool ByteCodeEmitter::emitCastIntAPSint8(SourceInfo L) {
7603	return emitOp<>(OP_CastIntAPSint8, L);
7604	}
7605	bool ByteCodeEmitter::emitCastIntAPUint16(SourceInfo L) {
7606	return emitOp<>(OP_CastIntAPUint16, L);
7607	}
7608	bool ByteCodeEmitter::emitCastIntAPSint16(SourceInfo L) {
7609	return emitOp<>(OP_CastIntAPSint16, L);
7610	}
7611	bool ByteCodeEmitter::emitCastIntAPUint32(SourceInfo L) {
7612	return emitOp<>(OP_CastIntAPUint32, L);
7613	}
7614	bool ByteCodeEmitter::emitCastIntAPSint32(SourceInfo L) {
7615	return emitOp<>(OP_CastIntAPSint32, L);
7616	}
7617	bool ByteCodeEmitter::emitCastIntAPUint64(SourceInfo L) {
7618	return emitOp<>(OP_CastIntAPUint64, L);
7619	}
7620	bool ByteCodeEmitter::emitCastIntAPSint64(SourceInfo L) {
7621	return emitOp<>(OP_CastIntAPSint64, L);
7622	}
7623	bool ByteCodeEmitter::emitCastIntAPBool(SourceInfo L) {
7624	return emitOp<>(OP_CastIntAPBool, L);
7625	}
7626	bool ByteCodeEmitter::emitCastIntAPSUint8(SourceInfo L) {
7627	return emitOp<>(OP_CastIntAPSUint8, L);
7628	}
7629	bool ByteCodeEmitter::emitCastIntAPSSint8(SourceInfo L) {
7630	return emitOp<>(OP_CastIntAPSSint8, L);
7631	}
7632	bool ByteCodeEmitter::emitCastIntAPSUint16(SourceInfo L) {
7633	return emitOp<>(OP_CastIntAPSUint16, L);
7634	}
7635	bool ByteCodeEmitter::emitCastIntAPSSint16(SourceInfo L) {
7636	return emitOp<>(OP_CastIntAPSSint16, L);
7637	}
7638	bool ByteCodeEmitter::emitCastIntAPSUint32(SourceInfo L) {
7639	return emitOp<>(OP_CastIntAPSUint32, L);
7640	}
7641	bool ByteCodeEmitter::emitCastIntAPSSint32(SourceInfo L) {
7642	return emitOp<>(OP_CastIntAPSSint32, L);
7643	}
7644	bool ByteCodeEmitter::emitCastIntAPSUint64(SourceInfo L) {
7645	return emitOp<>(OP_CastIntAPSUint64, L);
7646	}
7647	bool ByteCodeEmitter::emitCastIntAPSSint64(SourceInfo L) {
7648	return emitOp<>(OP_CastIntAPSSint64, L);
7649	}
7650	bool ByteCodeEmitter::emitCastIntAPSBool(SourceInfo L) {
7651	return emitOp<>(OP_CastIntAPSBool, L);
7652	}
7653	bool ByteCodeEmitter::emitCastFixedPointUint8(SourceInfo L) {
7654	return emitOp<>(OP_CastFixedPointUint8, L);
7655	}
7656	bool ByteCodeEmitter::emitCastFixedPointSint8(SourceInfo L) {
7657	return emitOp<>(OP_CastFixedPointSint8, L);
7658	}
7659	bool ByteCodeEmitter::emitCastFixedPointUint16(SourceInfo L) {
7660	return emitOp<>(OP_CastFixedPointUint16, L);
7661	}
7662	bool ByteCodeEmitter::emitCastFixedPointSint16(SourceInfo L) {
7663	return emitOp<>(OP_CastFixedPointSint16, L);
7664	}
7665	bool ByteCodeEmitter::emitCastFixedPointUint32(SourceInfo L) {
7666	return emitOp<>(OP_CastFixedPointUint32, L);
7667	}
7668	bool ByteCodeEmitter::emitCastFixedPointSint32(SourceInfo L) {
7669	return emitOp<>(OP_CastFixedPointSint32, L);
7670	}
7671	bool ByteCodeEmitter::emitCastFixedPointUint64(SourceInfo L) {
7672	return emitOp<>(OP_CastFixedPointUint64, L);
7673	}
7674	bool ByteCodeEmitter::emitCastFixedPointSint64(SourceInfo L) {
7675	return emitOp<>(OP_CastFixedPointSint64, L);
7676	}
7677	bool ByteCodeEmitter::emitCastFixedPointBool(SourceInfo L) {
7678	return emitOp<>(OP_CastFixedPointBool, L);
7679	}
7680	#endif
7681	#ifdef GET_EVAL_IMPL
7682	bool EvalEmitter::emitCastUint8Uint8(SourceInfo L) {
7683	if (!isActive()) return true;
7684	CurrentSource = L;
7685	return Cast<PT_Uint8, PT_Uint8>(S, CodePtr());
7686	}
7687	bool EvalEmitter::emitCastUint8Sint8(SourceInfo L) {
7688	if (!isActive()) return true;
7689	CurrentSource = L;
7690	return Cast<PT_Uint8, PT_Sint8>(S, CodePtr());
7691	}
7692	bool EvalEmitter::emitCastUint8Uint16(SourceInfo L) {
7693	if (!isActive()) return true;
7694	CurrentSource = L;
7695	return Cast<PT_Uint8, PT_Uint16>(S, CodePtr());
7696	}
7697	bool EvalEmitter::emitCastUint8Sint16(SourceInfo L) {
7698	if (!isActive()) return true;
7699	CurrentSource = L;
7700	return Cast<PT_Uint8, PT_Sint16>(S, CodePtr());
7701	}
7702	bool EvalEmitter::emitCastUint8Uint32(SourceInfo L) {
7703	if (!isActive()) return true;
7704	CurrentSource = L;
7705	return Cast<PT_Uint8, PT_Uint32>(S, CodePtr());
7706	}
7707	bool EvalEmitter::emitCastUint8Sint32(SourceInfo L) {
7708	if (!isActive()) return true;
7709	CurrentSource = L;
7710	return Cast<PT_Uint8, PT_Sint32>(S, CodePtr());
7711	}
7712	bool EvalEmitter::emitCastUint8Uint64(SourceInfo L) {
7713	if (!isActive()) return true;
7714	CurrentSource = L;
7715	return Cast<PT_Uint8, PT_Uint64>(S, CodePtr());
7716	}
7717	bool EvalEmitter::emitCastUint8Sint64(SourceInfo L) {
7718	if (!isActive()) return true;
7719	CurrentSource = L;
7720	return Cast<PT_Uint8, PT_Sint64>(S, CodePtr());
7721	}
7722	bool EvalEmitter::emitCastUint8Bool(SourceInfo L) {
7723	if (!isActive()) return true;
7724	CurrentSource = L;
7725	return Cast<PT_Uint8, PT_Bool>(S, CodePtr());
7726	}
7727	bool EvalEmitter::emitCastSint8Uint8(SourceInfo L) {
7728	if (!isActive()) return true;
7729	CurrentSource = L;
7730	return Cast<PT_Sint8, PT_Uint8>(S, CodePtr());
7731	}
7732	bool EvalEmitter::emitCastSint8Sint8(SourceInfo L) {
7733	if (!isActive()) return true;
7734	CurrentSource = L;
7735	return Cast<PT_Sint8, PT_Sint8>(S, CodePtr());
7736	}
7737	bool EvalEmitter::emitCastSint8Uint16(SourceInfo L) {
7738	if (!isActive()) return true;
7739	CurrentSource = L;
7740	return Cast<PT_Sint8, PT_Uint16>(S, CodePtr());
7741	}
7742	bool EvalEmitter::emitCastSint8Sint16(SourceInfo L) {
7743	if (!isActive()) return true;
7744	CurrentSource = L;
7745	return Cast<PT_Sint8, PT_Sint16>(S, CodePtr());
7746	}
7747	bool EvalEmitter::emitCastSint8Uint32(SourceInfo L) {
7748	if (!isActive()) return true;
7749	CurrentSource = L;
7750	return Cast<PT_Sint8, PT_Uint32>(S, CodePtr());
7751	}
7752	bool EvalEmitter::emitCastSint8Sint32(SourceInfo L) {
7753	if (!isActive()) return true;
7754	CurrentSource = L;
7755	return Cast<PT_Sint8, PT_Sint32>(S, CodePtr());
7756	}
7757	bool EvalEmitter::emitCastSint8Uint64(SourceInfo L) {
7758	if (!isActive()) return true;
7759	CurrentSource = L;
7760	return Cast<PT_Sint8, PT_Uint64>(S, CodePtr());
7761	}
7762	bool EvalEmitter::emitCastSint8Sint64(SourceInfo L) {
7763	if (!isActive()) return true;
7764	CurrentSource = L;
7765	return Cast<PT_Sint8, PT_Sint64>(S, CodePtr());
7766	}
7767	bool EvalEmitter::emitCastSint8Bool(SourceInfo L) {
7768	if (!isActive()) return true;
7769	CurrentSource = L;
7770	return Cast<PT_Sint8, PT_Bool>(S, CodePtr());
7771	}
7772	bool EvalEmitter::emitCastUint16Uint8(SourceInfo L) {
7773	if (!isActive()) return true;
7774	CurrentSource = L;
7775	return Cast<PT_Uint16, PT_Uint8>(S, CodePtr());
7776	}
7777	bool EvalEmitter::emitCastUint16Sint8(SourceInfo L) {
7778	if (!isActive()) return true;
7779	CurrentSource = L;
7780	return Cast<PT_Uint16, PT_Sint8>(S, CodePtr());
7781	}
7782	bool EvalEmitter::emitCastUint16Uint16(SourceInfo L) {
7783	if (!isActive()) return true;
7784	CurrentSource = L;
7785	return Cast<PT_Uint16, PT_Uint16>(S, CodePtr());
7786	}
7787	bool EvalEmitter::emitCastUint16Sint16(SourceInfo L) {
7788	if (!isActive()) return true;
7789	CurrentSource = L;
7790	return Cast<PT_Uint16, PT_Sint16>(S, CodePtr());
7791	}
7792	bool EvalEmitter::emitCastUint16Uint32(SourceInfo L) {
7793	if (!isActive()) return true;
7794	CurrentSource = L;
7795	return Cast<PT_Uint16, PT_Uint32>(S, CodePtr());
7796	}
7797	bool EvalEmitter::emitCastUint16Sint32(SourceInfo L) {
7798	if (!isActive()) return true;
7799	CurrentSource = L;
7800	return Cast<PT_Uint16, PT_Sint32>(S, CodePtr());
7801	}
7802	bool EvalEmitter::emitCastUint16Uint64(SourceInfo L) {
7803	if (!isActive()) return true;
7804	CurrentSource = L;
7805	return Cast<PT_Uint16, PT_Uint64>(S, CodePtr());
7806	}
7807	bool EvalEmitter::emitCastUint16Sint64(SourceInfo L) {
7808	if (!isActive()) return true;
7809	CurrentSource = L;
7810	return Cast<PT_Uint16, PT_Sint64>(S, CodePtr());
7811	}
7812	bool EvalEmitter::emitCastUint16Bool(SourceInfo L) {
7813	if (!isActive()) return true;
7814	CurrentSource = L;
7815	return Cast<PT_Uint16, PT_Bool>(S, CodePtr());
7816	}
7817	bool EvalEmitter::emitCastSint16Uint8(SourceInfo L) {
7818	if (!isActive()) return true;
7819	CurrentSource = L;
7820	return Cast<PT_Sint16, PT_Uint8>(S, CodePtr());
7821	}
7822	bool EvalEmitter::emitCastSint16Sint8(SourceInfo L) {
7823	if (!isActive()) return true;
7824	CurrentSource = L;
7825	return Cast<PT_Sint16, PT_Sint8>(S, CodePtr());
7826	}
7827	bool EvalEmitter::emitCastSint16Uint16(SourceInfo L) {
7828	if (!isActive()) return true;
7829	CurrentSource = L;
7830	return Cast<PT_Sint16, PT_Uint16>(S, CodePtr());
7831	}
7832	bool EvalEmitter::emitCastSint16Sint16(SourceInfo L) {
7833	if (!isActive()) return true;
7834	CurrentSource = L;
7835	return Cast<PT_Sint16, PT_Sint16>(S, CodePtr());
7836	}
7837	bool EvalEmitter::emitCastSint16Uint32(SourceInfo L) {
7838	if (!isActive()) return true;
7839	CurrentSource = L;
7840	return Cast<PT_Sint16, PT_Uint32>(S, CodePtr());
7841	}
7842	bool EvalEmitter::emitCastSint16Sint32(SourceInfo L) {
7843	if (!isActive()) return true;
7844	CurrentSource = L;
7845	return Cast<PT_Sint16, PT_Sint32>(S, CodePtr());
7846	}
7847	bool EvalEmitter::emitCastSint16Uint64(SourceInfo L) {
7848	if (!isActive()) return true;
7849	CurrentSource = L;
7850	return Cast<PT_Sint16, PT_Uint64>(S, CodePtr());
7851	}
7852	bool EvalEmitter::emitCastSint16Sint64(SourceInfo L) {
7853	if (!isActive()) return true;
7854	CurrentSource = L;
7855	return Cast<PT_Sint16, PT_Sint64>(S, CodePtr());
7856	}
7857	bool EvalEmitter::emitCastSint16Bool(SourceInfo L) {
7858	if (!isActive()) return true;
7859	CurrentSource = L;
7860	return Cast<PT_Sint16, PT_Bool>(S, CodePtr());
7861	}
7862	bool EvalEmitter::emitCastUint32Uint8(SourceInfo L) {
7863	if (!isActive()) return true;
7864	CurrentSource = L;
7865	return Cast<PT_Uint32, PT_Uint8>(S, CodePtr());
7866	}
7867	bool EvalEmitter::emitCastUint32Sint8(SourceInfo L) {
7868	if (!isActive()) return true;
7869	CurrentSource = L;
7870	return Cast<PT_Uint32, PT_Sint8>(S, CodePtr());
7871	}
7872	bool EvalEmitter::emitCastUint32Uint16(SourceInfo L) {
7873	if (!isActive()) return true;
7874	CurrentSource = L;
7875	return Cast<PT_Uint32, PT_Uint16>(S, CodePtr());
7876	}
7877	bool EvalEmitter::emitCastUint32Sint16(SourceInfo L) {
7878	if (!isActive()) return true;
7879	CurrentSource = L;
7880	return Cast<PT_Uint32, PT_Sint16>(S, CodePtr());
7881	}
7882	bool EvalEmitter::emitCastUint32Uint32(SourceInfo L) {
7883	if (!isActive()) return true;
7884	CurrentSource = L;
7885	return Cast<PT_Uint32, PT_Uint32>(S, CodePtr());
7886	}
7887	bool EvalEmitter::emitCastUint32Sint32(SourceInfo L) {
7888	if (!isActive()) return true;
7889	CurrentSource = L;
7890	return Cast<PT_Uint32, PT_Sint32>(S, CodePtr());
7891	}
7892	bool EvalEmitter::emitCastUint32Uint64(SourceInfo L) {
7893	if (!isActive()) return true;
7894	CurrentSource = L;
7895	return Cast<PT_Uint32, PT_Uint64>(S, CodePtr());
7896	}
7897	bool EvalEmitter::emitCastUint32Sint64(SourceInfo L) {
7898	if (!isActive()) return true;
7899	CurrentSource = L;
7900	return Cast<PT_Uint32, PT_Sint64>(S, CodePtr());
7901	}
7902	bool EvalEmitter::emitCastUint32Bool(SourceInfo L) {
7903	if (!isActive()) return true;
7904	CurrentSource = L;
7905	return Cast<PT_Uint32, PT_Bool>(S, CodePtr());
7906	}
7907	bool EvalEmitter::emitCastSint32Uint8(SourceInfo L) {
7908	if (!isActive()) return true;
7909	CurrentSource = L;
7910	return Cast<PT_Sint32, PT_Uint8>(S, CodePtr());
7911	}
7912	bool EvalEmitter::emitCastSint32Sint8(SourceInfo L) {
7913	if (!isActive()) return true;
7914	CurrentSource = L;
7915	return Cast<PT_Sint32, PT_Sint8>(S, CodePtr());
7916	}
7917	bool EvalEmitter::emitCastSint32Uint16(SourceInfo L) {
7918	if (!isActive()) return true;
7919	CurrentSource = L;
7920	return Cast<PT_Sint32, PT_Uint16>(S, CodePtr());
7921	}
7922	bool EvalEmitter::emitCastSint32Sint16(SourceInfo L) {
7923	if (!isActive()) return true;
7924	CurrentSource = L;
7925	return Cast<PT_Sint32, PT_Sint16>(S, CodePtr());
7926	}
7927	bool EvalEmitter::emitCastSint32Uint32(SourceInfo L) {
7928	if (!isActive()) return true;
7929	CurrentSource = L;
7930	return Cast<PT_Sint32, PT_Uint32>(S, CodePtr());
7931	}
7932	bool EvalEmitter::emitCastSint32Sint32(SourceInfo L) {
7933	if (!isActive()) return true;
7934	CurrentSource = L;
7935	return Cast<PT_Sint32, PT_Sint32>(S, CodePtr());
7936	}
7937	bool EvalEmitter::emitCastSint32Uint64(SourceInfo L) {
7938	if (!isActive()) return true;
7939	CurrentSource = L;
7940	return Cast<PT_Sint32, PT_Uint64>(S, CodePtr());
7941	}
7942	bool EvalEmitter::emitCastSint32Sint64(SourceInfo L) {
7943	if (!isActive()) return true;
7944	CurrentSource = L;
7945	return Cast<PT_Sint32, PT_Sint64>(S, CodePtr());
7946	}
7947	bool EvalEmitter::emitCastSint32Bool(SourceInfo L) {
7948	if (!isActive()) return true;
7949	CurrentSource = L;
7950	return Cast<PT_Sint32, PT_Bool>(S, CodePtr());
7951	}
7952	bool EvalEmitter::emitCastUint64Uint8(SourceInfo L) {
7953	if (!isActive()) return true;
7954	CurrentSource = L;
7955	return Cast<PT_Uint64, PT_Uint8>(S, CodePtr());
7956	}
7957	bool EvalEmitter::emitCastUint64Sint8(SourceInfo L) {
7958	if (!isActive()) return true;
7959	CurrentSource = L;
7960	return Cast<PT_Uint64, PT_Sint8>(S, CodePtr());
7961	}
7962	bool EvalEmitter::emitCastUint64Uint16(SourceInfo L) {
7963	if (!isActive()) return true;
7964	CurrentSource = L;
7965	return Cast<PT_Uint64, PT_Uint16>(S, CodePtr());
7966	}
7967	bool EvalEmitter::emitCastUint64Sint16(SourceInfo L) {
7968	if (!isActive()) return true;
7969	CurrentSource = L;
7970	return Cast<PT_Uint64, PT_Sint16>(S, CodePtr());
7971	}
7972	bool EvalEmitter::emitCastUint64Uint32(SourceInfo L) {
7973	if (!isActive()) return true;
7974	CurrentSource = L;
7975	return Cast<PT_Uint64, PT_Uint32>(S, CodePtr());
7976	}
7977	bool EvalEmitter::emitCastUint64Sint32(SourceInfo L) {
7978	if (!isActive()) return true;
7979	CurrentSource = L;
7980	return Cast<PT_Uint64, PT_Sint32>(S, CodePtr());
7981	}
7982	bool EvalEmitter::emitCastUint64Uint64(SourceInfo L) {
7983	if (!isActive()) return true;
7984	CurrentSource = L;
7985	return Cast<PT_Uint64, PT_Uint64>(S, CodePtr());
7986	}
7987	bool EvalEmitter::emitCastUint64Sint64(SourceInfo L) {
7988	if (!isActive()) return true;
7989	CurrentSource = L;
7990	return Cast<PT_Uint64, PT_Sint64>(S, CodePtr());
7991	}
7992	bool EvalEmitter::emitCastUint64Bool(SourceInfo L) {
7993	if (!isActive()) return true;
7994	CurrentSource = L;
7995	return Cast<PT_Uint64, PT_Bool>(S, CodePtr());
7996	}
7997	bool EvalEmitter::emitCastSint64Uint8(SourceInfo L) {
7998	if (!isActive()) return true;
7999	CurrentSource = L;
8000	return Cast<PT_Sint64, PT_Uint8>(S, CodePtr());
8001	}
8002	bool EvalEmitter::emitCastSint64Sint8(SourceInfo L) {
8003	if (!isActive()) return true;
8004	CurrentSource = L;
8005	return Cast<PT_Sint64, PT_Sint8>(S, CodePtr());
8006	}
8007	bool EvalEmitter::emitCastSint64Uint16(SourceInfo L) {
8008	if (!isActive()) return true;
8009	CurrentSource = L;
8010	return Cast<PT_Sint64, PT_Uint16>(S, CodePtr());
8011	}
8012	bool EvalEmitter::emitCastSint64Sint16(SourceInfo L) {
8013	if (!isActive()) return true;
8014	CurrentSource = L;
8015	return Cast<PT_Sint64, PT_Sint16>(S, CodePtr());
8016	}
8017	bool EvalEmitter::emitCastSint64Uint32(SourceInfo L) {
8018	if (!isActive()) return true;
8019	CurrentSource = L;
8020	return Cast<PT_Sint64, PT_Uint32>(S, CodePtr());
8021	}
8022	bool EvalEmitter::emitCastSint64Sint32(SourceInfo L) {
8023	if (!isActive()) return true;
8024	CurrentSource = L;
8025	return Cast<PT_Sint64, PT_Sint32>(S, CodePtr());
8026	}
8027	bool EvalEmitter::emitCastSint64Uint64(SourceInfo L) {
8028	if (!isActive()) return true;
8029	CurrentSource = L;
8030	return Cast<PT_Sint64, PT_Uint64>(S, CodePtr());
8031	}
8032	bool EvalEmitter::emitCastSint64Sint64(SourceInfo L) {
8033	if (!isActive()) return true;
8034	CurrentSource = L;
8035	return Cast<PT_Sint64, PT_Sint64>(S, CodePtr());
8036	}
8037	bool EvalEmitter::emitCastSint64Bool(SourceInfo L) {
8038	if (!isActive()) return true;
8039	CurrentSource = L;
8040	return Cast<PT_Sint64, PT_Bool>(S, CodePtr());
8041	}
8042	bool EvalEmitter::emitCastBoolUint8(SourceInfo L) {
8043	if (!isActive()) return true;
8044	CurrentSource = L;
8045	return Cast<PT_Bool, PT_Uint8>(S, CodePtr());
8046	}
8047	bool EvalEmitter::emitCastBoolSint8(SourceInfo L) {
8048	if (!isActive()) return true;
8049	CurrentSource = L;
8050	return Cast<PT_Bool, PT_Sint8>(S, CodePtr());
8051	}
8052	bool EvalEmitter::emitCastBoolUint16(SourceInfo L) {
8053	if (!isActive()) return true;
8054	CurrentSource = L;
8055	return Cast<PT_Bool, PT_Uint16>(S, CodePtr());
8056	}
8057	bool EvalEmitter::emitCastBoolSint16(SourceInfo L) {
8058	if (!isActive()) return true;
8059	CurrentSource = L;
8060	return Cast<PT_Bool, PT_Sint16>(S, CodePtr());
8061	}
8062	bool EvalEmitter::emitCastBoolUint32(SourceInfo L) {
8063	if (!isActive()) return true;
8064	CurrentSource = L;
8065	return Cast<PT_Bool, PT_Uint32>(S, CodePtr());
8066	}
8067	bool EvalEmitter::emitCastBoolSint32(SourceInfo L) {
8068	if (!isActive()) return true;
8069	CurrentSource = L;
8070	return Cast<PT_Bool, PT_Sint32>(S, CodePtr());
8071	}
8072	bool EvalEmitter::emitCastBoolUint64(SourceInfo L) {
8073	if (!isActive()) return true;
8074	CurrentSource = L;
8075	return Cast<PT_Bool, PT_Uint64>(S, CodePtr());
8076	}
8077	bool EvalEmitter::emitCastBoolSint64(SourceInfo L) {
8078	if (!isActive()) return true;
8079	CurrentSource = L;
8080	return Cast<PT_Bool, PT_Sint64>(S, CodePtr());
8081	}
8082	bool EvalEmitter::emitCastBoolBool(SourceInfo L) {
8083	if (!isActive()) return true;
8084	CurrentSource = L;
8085	return Cast<PT_Bool, PT_Bool>(S, CodePtr());
8086	}
8087	bool EvalEmitter::emitCastIntAPUint8(SourceInfo L) {
8088	if (!isActive()) return true;
8089	CurrentSource = L;
8090	return Cast<PT_IntAP, PT_Uint8>(S, CodePtr());
8091	}
8092	bool EvalEmitter::emitCastIntAPSint8(SourceInfo L) {
8093	if (!isActive()) return true;
8094	CurrentSource = L;
8095	return Cast<PT_IntAP, PT_Sint8>(S, CodePtr());
8096	}
8097	bool EvalEmitter::emitCastIntAPUint16(SourceInfo L) {
8098	if (!isActive()) return true;
8099	CurrentSource = L;
8100	return Cast<PT_IntAP, PT_Uint16>(S, CodePtr());
8101	}
8102	bool EvalEmitter::emitCastIntAPSint16(SourceInfo L) {
8103	if (!isActive()) return true;
8104	CurrentSource = L;
8105	return Cast<PT_IntAP, PT_Sint16>(S, CodePtr());
8106	}
8107	bool EvalEmitter::emitCastIntAPUint32(SourceInfo L) {
8108	if (!isActive()) return true;
8109	CurrentSource = L;
8110	return Cast<PT_IntAP, PT_Uint32>(S, CodePtr());
8111	}
8112	bool EvalEmitter::emitCastIntAPSint32(SourceInfo L) {
8113	if (!isActive()) return true;
8114	CurrentSource = L;
8115	return Cast<PT_IntAP, PT_Sint32>(S, CodePtr());
8116	}
8117	bool EvalEmitter::emitCastIntAPUint64(SourceInfo L) {
8118	if (!isActive()) return true;
8119	CurrentSource = L;
8120	return Cast<PT_IntAP, PT_Uint64>(S, CodePtr());
8121	}
8122	bool EvalEmitter::emitCastIntAPSint64(SourceInfo L) {
8123	if (!isActive()) return true;
8124	CurrentSource = L;
8125	return Cast<PT_IntAP, PT_Sint64>(S, CodePtr());
8126	}
8127	bool EvalEmitter::emitCastIntAPBool(SourceInfo L) {
8128	if (!isActive()) return true;
8129	CurrentSource = L;
8130	return Cast<PT_IntAP, PT_Bool>(S, CodePtr());
8131	}
8132	bool EvalEmitter::emitCastIntAPSUint8(SourceInfo L) {
8133	if (!isActive()) return true;
8134	CurrentSource = L;
8135	return Cast<PT_IntAPS, PT_Uint8>(S, CodePtr());
8136	}
8137	bool EvalEmitter::emitCastIntAPSSint8(SourceInfo L) {
8138	if (!isActive()) return true;
8139	CurrentSource = L;
8140	return Cast<PT_IntAPS, PT_Sint8>(S, CodePtr());
8141	}
8142	bool EvalEmitter::emitCastIntAPSUint16(SourceInfo L) {
8143	if (!isActive()) return true;
8144	CurrentSource = L;
8145	return Cast<PT_IntAPS, PT_Uint16>(S, CodePtr());
8146	}
8147	bool EvalEmitter::emitCastIntAPSSint16(SourceInfo L) {
8148	if (!isActive()) return true;
8149	CurrentSource = L;
8150	return Cast<PT_IntAPS, PT_Sint16>(S, CodePtr());
8151	}
8152	bool EvalEmitter::emitCastIntAPSUint32(SourceInfo L) {
8153	if (!isActive()) return true;
8154	CurrentSource = L;
8155	return Cast<PT_IntAPS, PT_Uint32>(S, CodePtr());
8156	}
8157	bool EvalEmitter::emitCastIntAPSSint32(SourceInfo L) {
8158	if (!isActive()) return true;
8159	CurrentSource = L;
8160	return Cast<PT_IntAPS, PT_Sint32>(S, CodePtr());
8161	}
8162	bool EvalEmitter::emitCastIntAPSUint64(SourceInfo L) {
8163	if (!isActive()) return true;
8164	CurrentSource = L;
8165	return Cast<PT_IntAPS, PT_Uint64>(S, CodePtr());
8166	}
8167	bool EvalEmitter::emitCastIntAPSSint64(SourceInfo L) {
8168	if (!isActive()) return true;
8169	CurrentSource = L;
8170	return Cast<PT_IntAPS, PT_Sint64>(S, CodePtr());
8171	}
8172	bool EvalEmitter::emitCastIntAPSBool(SourceInfo L) {
8173	if (!isActive()) return true;
8174	CurrentSource = L;
8175	return Cast<PT_IntAPS, PT_Bool>(S, CodePtr());
8176	}
8177	bool EvalEmitter::emitCastFixedPointUint8(SourceInfo L) {
8178	if (!isActive()) return true;
8179	CurrentSource = L;
8180	return Cast<PT_FixedPoint, PT_Uint8>(S, CodePtr());
8181	}
8182	bool EvalEmitter::emitCastFixedPointSint8(SourceInfo L) {
8183	if (!isActive()) return true;
8184	CurrentSource = L;
8185	return Cast<PT_FixedPoint, PT_Sint8>(S, CodePtr());
8186	}
8187	bool EvalEmitter::emitCastFixedPointUint16(SourceInfo L) {
8188	if (!isActive()) return true;
8189	CurrentSource = L;
8190	return Cast<PT_FixedPoint, PT_Uint16>(S, CodePtr());
8191	}
8192	bool EvalEmitter::emitCastFixedPointSint16(SourceInfo L) {
8193	if (!isActive()) return true;
8194	CurrentSource = L;
8195	return Cast<PT_FixedPoint, PT_Sint16>(S, CodePtr());
8196	}
8197	bool EvalEmitter::emitCastFixedPointUint32(SourceInfo L) {
8198	if (!isActive()) return true;
8199	CurrentSource = L;
8200	return Cast<PT_FixedPoint, PT_Uint32>(S, CodePtr());
8201	}
8202	bool EvalEmitter::emitCastFixedPointSint32(SourceInfo L) {
8203	if (!isActive()) return true;
8204	CurrentSource = L;
8205	return Cast<PT_FixedPoint, PT_Sint32>(S, CodePtr());
8206	}
8207	bool EvalEmitter::emitCastFixedPointUint64(SourceInfo L) {
8208	if (!isActive()) return true;
8209	CurrentSource = L;
8210	return Cast<PT_FixedPoint, PT_Uint64>(S, CodePtr());
8211	}
8212	bool EvalEmitter::emitCastFixedPointSint64(SourceInfo L) {
8213	if (!isActive()) return true;
8214	CurrentSource = L;
8215	return Cast<PT_FixedPoint, PT_Sint64>(S, CodePtr());
8216	}
8217	bool EvalEmitter::emitCastFixedPointBool(SourceInfo L) {
8218	if (!isActive()) return true;
8219	CurrentSource = L;
8220	return Cast<PT_FixedPoint, PT_Bool>(S, CodePtr());
8221	}
8222	#endif
8223	#ifdef GET_OPCODE_NAMES
8224	OP_CastAPSint8,
8225	OP_CastAPUint8,
8226	OP_CastAPSint16,
8227	OP_CastAPUint16,
8228	OP_CastAPSint32,
8229	OP_CastAPUint32,
8230	OP_CastAPSint64,
8231	OP_CastAPUint64,
8232	OP_CastAPIntAP,
8233	OP_CastAPIntAPS,
8234	OP_CastAPBool,
8235	OP_CastAPFixedPoint,
8236	#endif
8237	#ifdef GET_INTERPFN_LIST
8238	&Interp_CastAPSint8,
8239	&Interp_CastAPUint8,
8240	&Interp_CastAPSint16,
8241	&Interp_CastAPUint16,
8242	&Interp_CastAPSint32,
8243	&Interp_CastAPUint32,
8244	&Interp_CastAPSint64,
8245	&Interp_CastAPUint64,
8246	&Interp_CastAPIntAP,
8247	&Interp_CastAPIntAPS,
8248	&Interp_CastAPBool,
8249	&Interp_CastAPFixedPoint,
8250	#endif
8251	#ifdef GET_INTERPFN_DISPATCHERS
8252	PRESERVE_NONE
8253	static bool Interp_CastAPSint8(InterpState &S) {
8254	{
8255	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8256	if (!CastAP<PT_Sint8>(S, V0)) return false;
8257	}
8258	#if USE_TAILCALLS
8259	MUSTTAIL return InterpNext(S);
8260	#else
8261	return true;
8262	#endif
8263	}
8264	PRESERVE_NONE
8265	static bool Interp_CastAPUint8(InterpState &S) {
8266	{
8267	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8268	if (!CastAP<PT_Uint8>(S, V0)) return false;
8269	}
8270	#if USE_TAILCALLS
8271	MUSTTAIL return InterpNext(S);
8272	#else
8273	return true;
8274	#endif
8275	}
8276	PRESERVE_NONE
8277	static bool Interp_CastAPSint16(InterpState &S) {
8278	{
8279	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8280	if (!CastAP<PT_Sint16>(S, V0)) return false;
8281	}
8282	#if USE_TAILCALLS
8283	MUSTTAIL return InterpNext(S);
8284	#else
8285	return true;
8286	#endif
8287	}
8288	PRESERVE_NONE
8289	static bool Interp_CastAPUint16(InterpState &S) {
8290	{
8291	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8292	if (!CastAP<PT_Uint16>(S, V0)) return false;
8293	}
8294	#if USE_TAILCALLS
8295	MUSTTAIL return InterpNext(S);
8296	#else
8297	return true;
8298	#endif
8299	}
8300	PRESERVE_NONE
8301	static bool Interp_CastAPSint32(InterpState &S) {
8302	{
8303	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8304	if (!CastAP<PT_Sint32>(S, V0)) return false;
8305	}
8306	#if USE_TAILCALLS
8307	MUSTTAIL return InterpNext(S);
8308	#else
8309	return true;
8310	#endif
8311	}
8312	PRESERVE_NONE
8313	static bool Interp_CastAPUint32(InterpState &S) {
8314	{
8315	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8316	if (!CastAP<PT_Uint32>(S, V0)) return false;
8317	}
8318	#if USE_TAILCALLS
8319	MUSTTAIL return InterpNext(S);
8320	#else
8321	return true;
8322	#endif
8323	}
8324	PRESERVE_NONE
8325	static bool Interp_CastAPSint64(InterpState &S) {
8326	{
8327	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8328	if (!CastAP<PT_Sint64>(S, V0)) return false;
8329	}
8330	#if USE_TAILCALLS
8331	MUSTTAIL return InterpNext(S);
8332	#else
8333	return true;
8334	#endif
8335	}
8336	PRESERVE_NONE
8337	static bool Interp_CastAPUint64(InterpState &S) {
8338	{
8339	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8340	if (!CastAP<PT_Uint64>(S, V0)) return false;
8341	}
8342	#if USE_TAILCALLS
8343	MUSTTAIL return InterpNext(S);
8344	#else
8345	return true;
8346	#endif
8347	}
8348	PRESERVE_NONE
8349	static bool Interp_CastAPIntAP(InterpState &S) {
8350	{
8351	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8352	if (!CastAP<PT_IntAP>(S, V0)) return false;
8353	}
8354	#if USE_TAILCALLS
8355	MUSTTAIL return InterpNext(S);
8356	#else
8357	return true;
8358	#endif
8359	}
8360	PRESERVE_NONE
8361	static bool Interp_CastAPIntAPS(InterpState &S) {
8362	{
8363	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8364	if (!CastAP<PT_IntAPS>(S, V0)) return false;
8365	}
8366	#if USE_TAILCALLS
8367	MUSTTAIL return InterpNext(S);
8368	#else
8369	return true;
8370	#endif
8371	}
8372	PRESERVE_NONE
8373	static bool Interp_CastAPBool(InterpState &S) {
8374	{
8375	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8376	if (!CastAP<PT_Bool>(S, V0)) return false;
8377	}
8378	#if USE_TAILCALLS
8379	MUSTTAIL return InterpNext(S);
8380	#else
8381	return true;
8382	#endif
8383	}
8384	PRESERVE_NONE
8385	static bool Interp_CastAPFixedPoint(InterpState &S) {
8386	{
8387	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8388	if (!CastAP<PT_FixedPoint>(S, V0)) return false;
8389	}
8390	#if USE_TAILCALLS
8391	MUSTTAIL return InterpNext(S);
8392	#else
8393	return true;
8394	#endif
8395	}
8396	#endif
8397	#ifdef GET_DISASM
8398	case OP_CastAPSint8:
8399	Text.Op = PrintName("CastAPSint8");
8400	Text.Args.push_back(printArg<uint32_t>(P, PC));
8401	break;
8402	case OP_CastAPUint8:
8403	Text.Op = PrintName("CastAPUint8");
8404	Text.Args.push_back(printArg<uint32_t>(P, PC));
8405	break;
8406	case OP_CastAPSint16:
8407	Text.Op = PrintName("CastAPSint16");
8408	Text.Args.push_back(printArg<uint32_t>(P, PC));
8409	break;
8410	case OP_CastAPUint16:
8411	Text.Op = PrintName("CastAPUint16");
8412	Text.Args.push_back(printArg<uint32_t>(P, PC));
8413	break;
8414	case OP_CastAPSint32:
8415	Text.Op = PrintName("CastAPSint32");
8416	Text.Args.push_back(printArg<uint32_t>(P, PC));
8417	break;
8418	case OP_CastAPUint32:
8419	Text.Op = PrintName("CastAPUint32");
8420	Text.Args.push_back(printArg<uint32_t>(P, PC));
8421	break;
8422	case OP_CastAPSint64:
8423	Text.Op = PrintName("CastAPSint64");
8424	Text.Args.push_back(printArg<uint32_t>(P, PC));
8425	break;
8426	case OP_CastAPUint64:
8427	Text.Op = PrintName("CastAPUint64");
8428	Text.Args.push_back(printArg<uint32_t>(P, PC));
8429	break;
8430	case OP_CastAPIntAP:
8431	Text.Op = PrintName("CastAPIntAP");
8432	Text.Args.push_back(printArg<uint32_t>(P, PC));
8433	break;
8434	case OP_CastAPIntAPS:
8435	Text.Op = PrintName("CastAPIntAPS");
8436	Text.Args.push_back(printArg<uint32_t>(P, PC));
8437	break;
8438	case OP_CastAPBool:
8439	Text.Op = PrintName("CastAPBool");
8440	Text.Args.push_back(printArg<uint32_t>(P, PC));
8441	break;
8442	case OP_CastAPFixedPoint:
8443	Text.Op = PrintName("CastAPFixedPoint");
8444	Text.Args.push_back(printArg<uint32_t>(P, PC));
8445	break;
8446	#endif
8447	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
8448	bool emitCastAPSint8( uint32_t , SourceInfo);
8449	bool emitCastAPUint8( uint32_t , SourceInfo);
8450	bool emitCastAPSint16( uint32_t , SourceInfo);
8451	bool emitCastAPUint16( uint32_t , SourceInfo);
8452	bool emitCastAPSint32( uint32_t , SourceInfo);
8453	bool emitCastAPUint32( uint32_t , SourceInfo);
8454	bool emitCastAPSint64( uint32_t , SourceInfo);
8455	bool emitCastAPUint64( uint32_t , SourceInfo);
8456	bool emitCastAPIntAP( uint32_t , SourceInfo);
8457	bool emitCastAPIntAPS( uint32_t , SourceInfo);
8458	bool emitCastAPBool( uint32_t , SourceInfo);
8459	bool emitCastAPFixedPoint( uint32_t , SourceInfo);
8460	#endif
8461	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
8462	[[nodiscard]] bool emitCastAP(PrimType, uint32_t, SourceInfo I);
8463	#endif
8464	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
8465	bool
8466	#if defined(GET_EVAL_IMPL)
8467	EvalEmitter
8468	#else
8469	ByteCodeEmitter
8470	#endif
8471	::emitCastAP(PrimType T0, uint32_t A0, SourceInfo I) {
8472	switch (T0) {
8473	case PT_Sint8:
8474	return emitCastAPSint8(A0, I);
8475	case PT_Uint8:
8476	return emitCastAPUint8(A0, I);
8477	case PT_Sint16:
8478	return emitCastAPSint16(A0, I);
8479	case PT_Uint16:
8480	return emitCastAPUint16(A0, I);
8481	case PT_Sint32:
8482	return emitCastAPSint32(A0, I);
8483	case PT_Uint32:
8484	return emitCastAPUint32(A0, I);
8485	case PT_Sint64:
8486	return emitCastAPSint64(A0, I);
8487	case PT_Uint64:
8488	return emitCastAPUint64(A0, I);
8489	case PT_IntAP:
8490	return emitCastAPIntAP(A0, I);
8491	case PT_IntAPS:
8492	return emitCastAPIntAPS(A0, I);
8493	case PT_Bool:
8494	return emitCastAPBool(A0, I);
8495	case PT_FixedPoint:
8496	return emitCastAPFixedPoint(A0, I);
8497	default: llvm_unreachable("invalid type: emitCastAP");
8498	}
8499	llvm_unreachable("invalid enum value");
8500	}
8501	#endif
8502	#ifdef GET_LINK_IMPL
8503	bool ByteCodeEmitter::emitCastAPSint8( uint32_t A0, SourceInfo L) {
8504	return emitOp<uint32_t>(OP_CastAPSint8, A0, L);
8505	}
8506	bool ByteCodeEmitter::emitCastAPUint8( uint32_t A0, SourceInfo L) {
8507	return emitOp<uint32_t>(OP_CastAPUint8, A0, L);
8508	}
8509	bool ByteCodeEmitter::emitCastAPSint16( uint32_t A0, SourceInfo L) {
8510	return emitOp<uint32_t>(OP_CastAPSint16, A0, L);
8511	}
8512	bool ByteCodeEmitter::emitCastAPUint16( uint32_t A0, SourceInfo L) {
8513	return emitOp<uint32_t>(OP_CastAPUint16, A0, L);
8514	}
8515	bool ByteCodeEmitter::emitCastAPSint32( uint32_t A0, SourceInfo L) {
8516	return emitOp<uint32_t>(OP_CastAPSint32, A0, L);
8517	}
8518	bool ByteCodeEmitter::emitCastAPUint32( uint32_t A0, SourceInfo L) {
8519	return emitOp<uint32_t>(OP_CastAPUint32, A0, L);
8520	}
8521	bool ByteCodeEmitter::emitCastAPSint64( uint32_t A0, SourceInfo L) {
8522	return emitOp<uint32_t>(OP_CastAPSint64, A0, L);
8523	}
8524	bool ByteCodeEmitter::emitCastAPUint64( uint32_t A0, SourceInfo L) {
8525	return emitOp<uint32_t>(OP_CastAPUint64, A0, L);
8526	}
8527	bool ByteCodeEmitter::emitCastAPIntAP( uint32_t A0, SourceInfo L) {
8528	return emitOp<uint32_t>(OP_CastAPIntAP, A0, L);
8529	}
8530	bool ByteCodeEmitter::emitCastAPIntAPS( uint32_t A0, SourceInfo L) {
8531	return emitOp<uint32_t>(OP_CastAPIntAPS, A0, L);
8532	}
8533	bool ByteCodeEmitter::emitCastAPBool( uint32_t A0, SourceInfo L) {
8534	return emitOp<uint32_t>(OP_CastAPBool, A0, L);
8535	}
8536	bool ByteCodeEmitter::emitCastAPFixedPoint( uint32_t A0, SourceInfo L) {
8537	return emitOp<uint32_t>(OP_CastAPFixedPoint, A0, L);
8538	}
8539	#endif
8540	#ifdef GET_EVAL_IMPL
8541	bool EvalEmitter::emitCastAPSint8( uint32_t A0, SourceInfo L) {
8542	if (!isActive()) return true;
8543	CurrentSource = L;
8544	return CastAP<PT_Sint8>(S, A0);
8545	}
8546	bool EvalEmitter::emitCastAPUint8( uint32_t A0, SourceInfo L) {
8547	if (!isActive()) return true;
8548	CurrentSource = L;
8549	return CastAP<PT_Uint8>(S, A0);
8550	}
8551	bool EvalEmitter::emitCastAPSint16( uint32_t A0, SourceInfo L) {
8552	if (!isActive()) return true;
8553	CurrentSource = L;
8554	return CastAP<PT_Sint16>(S, A0);
8555	}
8556	bool EvalEmitter::emitCastAPUint16( uint32_t A0, SourceInfo L) {
8557	if (!isActive()) return true;
8558	CurrentSource = L;
8559	return CastAP<PT_Uint16>(S, A0);
8560	}
8561	bool EvalEmitter::emitCastAPSint32( uint32_t A0, SourceInfo L) {
8562	if (!isActive()) return true;
8563	CurrentSource = L;
8564	return CastAP<PT_Sint32>(S, A0);
8565	}
8566	bool EvalEmitter::emitCastAPUint32( uint32_t A0, SourceInfo L) {
8567	if (!isActive()) return true;
8568	CurrentSource = L;
8569	return CastAP<PT_Uint32>(S, A0);
8570	}
8571	bool EvalEmitter::emitCastAPSint64( uint32_t A0, SourceInfo L) {
8572	if (!isActive()) return true;
8573	CurrentSource = L;
8574	return CastAP<PT_Sint64>(S, A0);
8575	}
8576	bool EvalEmitter::emitCastAPUint64( uint32_t A0, SourceInfo L) {
8577	if (!isActive()) return true;
8578	CurrentSource = L;
8579	return CastAP<PT_Uint64>(S, A0);
8580	}
8581	bool EvalEmitter::emitCastAPIntAP( uint32_t A0, SourceInfo L) {
8582	if (!isActive()) return true;
8583	CurrentSource = L;
8584	return CastAP<PT_IntAP>(S, A0);
8585	}
8586	bool EvalEmitter::emitCastAPIntAPS( uint32_t A0, SourceInfo L) {
8587	if (!isActive()) return true;
8588	CurrentSource = L;
8589	return CastAP<PT_IntAPS>(S, A0);
8590	}
8591	bool EvalEmitter::emitCastAPBool( uint32_t A0, SourceInfo L) {
8592	if (!isActive()) return true;
8593	CurrentSource = L;
8594	return CastAP<PT_Bool>(S, A0);
8595	}
8596	bool EvalEmitter::emitCastAPFixedPoint( uint32_t A0, SourceInfo L) {
8597	if (!isActive()) return true;
8598	CurrentSource = L;
8599	return CastAP<PT_FixedPoint>(S, A0);
8600	}
8601	#endif
8602	#ifdef GET_OPCODE_NAMES
8603	OP_CastAPSSint8,
8604	OP_CastAPSUint8,
8605	OP_CastAPSSint16,
8606	OP_CastAPSUint16,
8607	OP_CastAPSSint32,
8608	OP_CastAPSUint32,
8609	OP_CastAPSSint64,
8610	OP_CastAPSUint64,
8611	OP_CastAPSIntAP,
8612	OP_CastAPSIntAPS,
8613	OP_CastAPSBool,
8614	OP_CastAPSFixedPoint,
8615	#endif
8616	#ifdef GET_INTERPFN_LIST
8617	&Interp_CastAPSSint8,
8618	&Interp_CastAPSUint8,
8619	&Interp_CastAPSSint16,
8620	&Interp_CastAPSUint16,
8621	&Interp_CastAPSSint32,
8622	&Interp_CastAPSUint32,
8623	&Interp_CastAPSSint64,
8624	&Interp_CastAPSUint64,
8625	&Interp_CastAPSIntAP,
8626	&Interp_CastAPSIntAPS,
8627	&Interp_CastAPSBool,
8628	&Interp_CastAPSFixedPoint,
8629	#endif
8630	#ifdef GET_INTERPFN_DISPATCHERS
8631	PRESERVE_NONE
8632	static bool Interp_CastAPSSint8(InterpState &S) {
8633	{
8634	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8635	if (!CastAPS<PT_Sint8>(S, V0)) return false;
8636	}
8637	#if USE_TAILCALLS
8638	MUSTTAIL return InterpNext(S);
8639	#else
8640	return true;
8641	#endif
8642	}
8643	PRESERVE_NONE
8644	static bool Interp_CastAPSUint8(InterpState &S) {
8645	{
8646	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8647	if (!CastAPS<PT_Uint8>(S, V0)) return false;
8648	}
8649	#if USE_TAILCALLS
8650	MUSTTAIL return InterpNext(S);
8651	#else
8652	return true;
8653	#endif
8654	}
8655	PRESERVE_NONE
8656	static bool Interp_CastAPSSint16(InterpState &S) {
8657	{
8658	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8659	if (!CastAPS<PT_Sint16>(S, V0)) return false;
8660	}
8661	#if USE_TAILCALLS
8662	MUSTTAIL return InterpNext(S);
8663	#else
8664	return true;
8665	#endif
8666	}
8667	PRESERVE_NONE
8668	static bool Interp_CastAPSUint16(InterpState &S) {
8669	{
8670	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8671	if (!CastAPS<PT_Uint16>(S, V0)) return false;
8672	}
8673	#if USE_TAILCALLS
8674	MUSTTAIL return InterpNext(S);
8675	#else
8676	return true;
8677	#endif
8678	}
8679	PRESERVE_NONE
8680	static bool Interp_CastAPSSint32(InterpState &S) {
8681	{
8682	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8683	if (!CastAPS<PT_Sint32>(S, V0)) return false;
8684	}
8685	#if USE_TAILCALLS
8686	MUSTTAIL return InterpNext(S);
8687	#else
8688	return true;
8689	#endif
8690	}
8691	PRESERVE_NONE
8692	static bool Interp_CastAPSUint32(InterpState &S) {
8693	{
8694	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8695	if (!CastAPS<PT_Uint32>(S, V0)) return false;
8696	}
8697	#if USE_TAILCALLS
8698	MUSTTAIL return InterpNext(S);
8699	#else
8700	return true;
8701	#endif
8702	}
8703	PRESERVE_NONE
8704	static bool Interp_CastAPSSint64(InterpState &S) {
8705	{
8706	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8707	if (!CastAPS<PT_Sint64>(S, V0)) return false;
8708	}
8709	#if USE_TAILCALLS
8710	MUSTTAIL return InterpNext(S);
8711	#else
8712	return true;
8713	#endif
8714	}
8715	PRESERVE_NONE
8716	static bool Interp_CastAPSUint64(InterpState &S) {
8717	{
8718	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8719	if (!CastAPS<PT_Uint64>(S, V0)) return false;
8720	}
8721	#if USE_TAILCALLS
8722	MUSTTAIL return InterpNext(S);
8723	#else
8724	return true;
8725	#endif
8726	}
8727	PRESERVE_NONE
8728	static bool Interp_CastAPSIntAP(InterpState &S) {
8729	{
8730	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8731	if (!CastAPS<PT_IntAP>(S, V0)) return false;
8732	}
8733	#if USE_TAILCALLS
8734	MUSTTAIL return InterpNext(S);
8735	#else
8736	return true;
8737	#endif
8738	}
8739	PRESERVE_NONE
8740	static bool Interp_CastAPSIntAPS(InterpState &S) {
8741	{
8742	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8743	if (!CastAPS<PT_IntAPS>(S, V0)) return false;
8744	}
8745	#if USE_TAILCALLS
8746	MUSTTAIL return InterpNext(S);
8747	#else
8748	return true;
8749	#endif
8750	}
8751	PRESERVE_NONE
8752	static bool Interp_CastAPSBool(InterpState &S) {
8753	{
8754	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8755	if (!CastAPS<PT_Bool>(S, V0)) return false;
8756	}
8757	#if USE_TAILCALLS
8758	MUSTTAIL return InterpNext(S);
8759	#else
8760	return true;
8761	#endif
8762	}
8763	PRESERVE_NONE
8764	static bool Interp_CastAPSFixedPoint(InterpState &S) {
8765	{
8766	const auto V0 = ReadArg<uint32_t>(S, S.PC);
8767	if (!CastAPS<PT_FixedPoint>(S, V0)) return false;
8768	}
8769	#if USE_TAILCALLS
8770	MUSTTAIL return InterpNext(S);
8771	#else
8772	return true;
8773	#endif
8774	}
8775	#endif
8776	#ifdef GET_DISASM
8777	case OP_CastAPSSint8:
8778	Text.Op = PrintName("CastAPSSint8");
8779	Text.Args.push_back(printArg<uint32_t>(P, PC));
8780	break;
8781	case OP_CastAPSUint8:
8782	Text.Op = PrintName("CastAPSUint8");
8783	Text.Args.push_back(printArg<uint32_t>(P, PC));
8784	break;
8785	case OP_CastAPSSint16:
8786	Text.Op = PrintName("CastAPSSint16");
8787	Text.Args.push_back(printArg<uint32_t>(P, PC));
8788	break;
8789	case OP_CastAPSUint16:
8790	Text.Op = PrintName("CastAPSUint16");
8791	Text.Args.push_back(printArg<uint32_t>(P, PC));
8792	break;
8793	case OP_CastAPSSint32:
8794	Text.Op = PrintName("CastAPSSint32");
8795	Text.Args.push_back(printArg<uint32_t>(P, PC));
8796	break;
8797	case OP_CastAPSUint32:
8798	Text.Op = PrintName("CastAPSUint32");
8799	Text.Args.push_back(printArg<uint32_t>(P, PC));
8800	break;
8801	case OP_CastAPSSint64:
8802	Text.Op = PrintName("CastAPSSint64");
8803	Text.Args.push_back(printArg<uint32_t>(P, PC));
8804	break;
8805	case OP_CastAPSUint64:
8806	Text.Op = PrintName("CastAPSUint64");
8807	Text.Args.push_back(printArg<uint32_t>(P, PC));
8808	break;
8809	case OP_CastAPSIntAP:
8810	Text.Op = PrintName("CastAPSIntAP");
8811	Text.Args.push_back(printArg<uint32_t>(P, PC));
8812	break;
8813	case OP_CastAPSIntAPS:
8814	Text.Op = PrintName("CastAPSIntAPS");
8815	Text.Args.push_back(printArg<uint32_t>(P, PC));
8816	break;
8817	case OP_CastAPSBool:
8818	Text.Op = PrintName("CastAPSBool");
8819	Text.Args.push_back(printArg<uint32_t>(P, PC));
8820	break;
8821	case OP_CastAPSFixedPoint:
8822	Text.Op = PrintName("CastAPSFixedPoint");
8823	Text.Args.push_back(printArg<uint32_t>(P, PC));
8824	break;
8825	#endif
8826	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
8827	bool emitCastAPSSint8( uint32_t , SourceInfo);
8828	bool emitCastAPSUint8( uint32_t , SourceInfo);
8829	bool emitCastAPSSint16( uint32_t , SourceInfo);
8830	bool emitCastAPSUint16( uint32_t , SourceInfo);
8831	bool emitCastAPSSint32( uint32_t , SourceInfo);
8832	bool emitCastAPSUint32( uint32_t , SourceInfo);
8833	bool emitCastAPSSint64( uint32_t , SourceInfo);
8834	bool emitCastAPSUint64( uint32_t , SourceInfo);
8835	bool emitCastAPSIntAP( uint32_t , SourceInfo);
8836	bool emitCastAPSIntAPS( uint32_t , SourceInfo);
8837	bool emitCastAPSBool( uint32_t , SourceInfo);
8838	bool emitCastAPSFixedPoint( uint32_t , SourceInfo);
8839	#endif
8840	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
8841	[[nodiscard]] bool emitCastAPS(PrimType, uint32_t, SourceInfo I);
8842	#endif
8843	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
8844	bool
8845	#if defined(GET_EVAL_IMPL)
8846	EvalEmitter
8847	#else
8848	ByteCodeEmitter
8849	#endif
8850	::emitCastAPS(PrimType T0, uint32_t A0, SourceInfo I) {
8851	switch (T0) {
8852	case PT_Sint8:
8853	return emitCastAPSSint8(A0, I);
8854	case PT_Uint8:
8855	return emitCastAPSUint8(A0, I);
8856	case PT_Sint16:
8857	return emitCastAPSSint16(A0, I);
8858	case PT_Uint16:
8859	return emitCastAPSUint16(A0, I);
8860	case PT_Sint32:
8861	return emitCastAPSSint32(A0, I);
8862	case PT_Uint32:
8863	return emitCastAPSUint32(A0, I);
8864	case PT_Sint64:
8865	return emitCastAPSSint64(A0, I);
8866	case PT_Uint64:
8867	return emitCastAPSUint64(A0, I);
8868	case PT_IntAP:
8869	return emitCastAPSIntAP(A0, I);
8870	case PT_IntAPS:
8871	return emitCastAPSIntAPS(A0, I);
8872	case PT_Bool:
8873	return emitCastAPSBool(A0, I);
8874	case PT_FixedPoint:
8875	return emitCastAPSFixedPoint(A0, I);
8876	default: llvm_unreachable("invalid type: emitCastAPS");
8877	}
8878	llvm_unreachable("invalid enum value");
8879	}
8880	#endif
8881	#ifdef GET_LINK_IMPL
8882	bool ByteCodeEmitter::emitCastAPSSint8( uint32_t A0, SourceInfo L) {
8883	return emitOp<uint32_t>(OP_CastAPSSint8, A0, L);
8884	}
8885	bool ByteCodeEmitter::emitCastAPSUint8( uint32_t A0, SourceInfo L) {
8886	return emitOp<uint32_t>(OP_CastAPSUint8, A0, L);
8887	}
8888	bool ByteCodeEmitter::emitCastAPSSint16( uint32_t A0, SourceInfo L) {
8889	return emitOp<uint32_t>(OP_CastAPSSint16, A0, L);
8890	}
8891	bool ByteCodeEmitter::emitCastAPSUint16( uint32_t A0, SourceInfo L) {
8892	return emitOp<uint32_t>(OP_CastAPSUint16, A0, L);
8893	}
8894	bool ByteCodeEmitter::emitCastAPSSint32( uint32_t A0, SourceInfo L) {
8895	return emitOp<uint32_t>(OP_CastAPSSint32, A0, L);
8896	}
8897	bool ByteCodeEmitter::emitCastAPSUint32( uint32_t A0, SourceInfo L) {
8898	return emitOp<uint32_t>(OP_CastAPSUint32, A0, L);
8899	}
8900	bool ByteCodeEmitter::emitCastAPSSint64( uint32_t A0, SourceInfo L) {
8901	return emitOp<uint32_t>(OP_CastAPSSint64, A0, L);
8902	}
8903	bool ByteCodeEmitter::emitCastAPSUint64( uint32_t A0, SourceInfo L) {
8904	return emitOp<uint32_t>(OP_CastAPSUint64, A0, L);
8905	}
8906	bool ByteCodeEmitter::emitCastAPSIntAP( uint32_t A0, SourceInfo L) {
8907	return emitOp<uint32_t>(OP_CastAPSIntAP, A0, L);
8908	}
8909	bool ByteCodeEmitter::emitCastAPSIntAPS( uint32_t A0, SourceInfo L) {
8910	return emitOp<uint32_t>(OP_CastAPSIntAPS, A0, L);
8911	}
8912	bool ByteCodeEmitter::emitCastAPSBool( uint32_t A0, SourceInfo L) {
8913	return emitOp<uint32_t>(OP_CastAPSBool, A0, L);
8914	}
8915	bool ByteCodeEmitter::emitCastAPSFixedPoint( uint32_t A0, SourceInfo L) {
8916	return emitOp<uint32_t>(OP_CastAPSFixedPoint, A0, L);
8917	}
8918	#endif
8919	#ifdef GET_EVAL_IMPL
8920	bool EvalEmitter::emitCastAPSSint8( uint32_t A0, SourceInfo L) {
8921	if (!isActive()) return true;
8922	CurrentSource = L;
8923	return CastAPS<PT_Sint8>(S, A0);
8924	}
8925	bool EvalEmitter::emitCastAPSUint8( uint32_t A0, SourceInfo L) {
8926	if (!isActive()) return true;
8927	CurrentSource = L;
8928	return CastAPS<PT_Uint8>(S, A0);
8929	}
8930	bool EvalEmitter::emitCastAPSSint16( uint32_t A0, SourceInfo L) {
8931	if (!isActive()) return true;
8932	CurrentSource = L;
8933	return CastAPS<PT_Sint16>(S, A0);
8934	}
8935	bool EvalEmitter::emitCastAPSUint16( uint32_t A0, SourceInfo L) {
8936	if (!isActive()) return true;
8937	CurrentSource = L;
8938	return CastAPS<PT_Uint16>(S, A0);
8939	}
8940	bool EvalEmitter::emitCastAPSSint32( uint32_t A0, SourceInfo L) {
8941	if (!isActive()) return true;
8942	CurrentSource = L;
8943	return CastAPS<PT_Sint32>(S, A0);
8944	}
8945	bool EvalEmitter::emitCastAPSUint32( uint32_t A0, SourceInfo L) {
8946	if (!isActive()) return true;
8947	CurrentSource = L;
8948	return CastAPS<PT_Uint32>(S, A0);
8949	}
8950	bool EvalEmitter::emitCastAPSSint64( uint32_t A0, SourceInfo L) {
8951	if (!isActive()) return true;
8952	CurrentSource = L;
8953	return CastAPS<PT_Sint64>(S, A0);
8954	}
8955	bool EvalEmitter::emitCastAPSUint64( uint32_t A0, SourceInfo L) {
8956	if (!isActive()) return true;
8957	CurrentSource = L;
8958	return CastAPS<PT_Uint64>(S, A0);
8959	}
8960	bool EvalEmitter::emitCastAPSIntAP( uint32_t A0, SourceInfo L) {
8961	if (!isActive()) return true;
8962	CurrentSource = L;
8963	return CastAPS<PT_IntAP>(S, A0);
8964	}
8965	bool EvalEmitter::emitCastAPSIntAPS( uint32_t A0, SourceInfo L) {
8966	if (!isActive()) return true;
8967	CurrentSource = L;
8968	return CastAPS<PT_IntAPS>(S, A0);
8969	}
8970	bool EvalEmitter::emitCastAPSBool( uint32_t A0, SourceInfo L) {
8971	if (!isActive()) return true;
8972	CurrentSource = L;
8973	return CastAPS<PT_Bool>(S, A0);
8974	}
8975	bool EvalEmitter::emitCastAPSFixedPoint( uint32_t A0, SourceInfo L) {
8976	if (!isActive()) return true;
8977	CurrentSource = L;
8978	return CastAPS<PT_FixedPoint>(S, A0);
8979	}
8980	#endif
8981	#ifdef GET_OPCODE_NAMES
8982	OP_CastFP,
8983	#endif
8984	#ifdef GET_INTERPFN_LIST
8985	&Interp_CastFP,
8986	#endif
8987	#ifdef GET_INTERPFN_DISPATCHERS
8988	PRESERVE_NONE
8989	static bool Interp_CastFP(InterpState &S) {
8990	{
8991	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
8992	const auto V1 = ReadArg<llvm::RoundingMode>(S, S.PC);
8993	if (!CastFP(S, V0, V1)) return false;
8994	}
8995	#if USE_TAILCALLS
8996	MUSTTAIL return InterpNext(S);
8997	#else
8998	return true;
8999	#endif
9000	}
9001	#endif
9002	#ifdef GET_DISASM
9003	case OP_CastFP:
9004	Text.Op = PrintName("CastFP");
9005	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
9006	Text.Args.push_back(printArg<llvm::RoundingMode>(P, PC));
9007	break;
9008	#endif
9009	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9010	bool emitCastFP( const llvm::fltSemantics * , llvm::RoundingMode , SourceInfo);
9011	#endif
9012	#ifdef GET_LINK_IMPL
9013	bool ByteCodeEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, SourceInfo L) {
9014	return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastFP, A0, A1, L);
9015	}
9016	#endif
9017	#ifdef GET_EVAL_IMPL
9018	bool EvalEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, SourceInfo L) {
9019	if (!isActive()) return true;
9020	CurrentSource = L;
9021	return CastFP(S, A0, A1);
9022	}
9023	#endif
9024	#ifdef GET_OPCODE_NAMES
9025	OP_CastFixedPoint,
9026	#endif
9027	#ifdef GET_INTERPFN_LIST
9028	&Interp_CastFixedPoint,
9029	#endif
9030	#ifdef GET_INTERPFN_DISPATCHERS
9031	PRESERVE_NONE
9032	static bool Interp_CastFixedPoint(InterpState &S) {
9033	{
9034	CodePtr OpPC = S.PC;
9035	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9036	if (!CastFixedPoint(S, OpPC, V0)) return false;
9037	}
9038	#if USE_TAILCALLS
9039	MUSTTAIL return InterpNext(S);
9040	#else
9041	return true;
9042	#endif
9043	}
9044	#endif
9045	#ifdef GET_DISASM
9046	case OP_CastFixedPoint:
9047	Text.Op = PrintName("CastFixedPoint");
9048	Text.Args.push_back(printArg<uint32_t>(P, PC));
9049	break;
9050	#endif
9051	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9052	bool emitCastFixedPoint( uint32_t , SourceInfo);
9053	#endif
9054	#ifdef GET_LINK_IMPL
9055	bool ByteCodeEmitter::emitCastFixedPoint( uint32_t A0, SourceInfo L) {
9056	return emitOp<uint32_t>(OP_CastFixedPoint, A0, L);
9057	}
9058	#endif
9059	#ifdef GET_EVAL_IMPL
9060	bool EvalEmitter::emitCastFixedPoint( uint32_t A0, SourceInfo L) {
9061	if (!isActive()) return true;
9062	CurrentSource = L;
9063	return CastFixedPoint(S, CodePtr(), A0);
9064	}
9065	#endif
9066	#ifdef GET_OPCODE_NAMES
9067	OP_CastFixedPointFloating,
9068	#endif
9069	#ifdef GET_INTERPFN_LIST
9070	&Interp_CastFixedPointFloating,
9071	#endif
9072	#ifdef GET_INTERPFN_DISPATCHERS
9073	PRESERVE_NONE
9074	static bool Interp_CastFixedPointFloating(InterpState &S) {
9075	{
9076	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
9077	if (!CastFixedPointFloating(S, V0)) return false;
9078	}
9079	#if USE_TAILCALLS
9080	MUSTTAIL return InterpNext(S);
9081	#else
9082	return true;
9083	#endif
9084	}
9085	#endif
9086	#ifdef GET_DISASM
9087	case OP_CastFixedPointFloating:
9088	Text.Op = PrintName("CastFixedPointFloating");
9089	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
9090	break;
9091	#endif
9092	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9093	bool emitCastFixedPointFloating( const llvm::fltSemantics * , SourceInfo);
9094	#endif
9095	#ifdef GET_LINK_IMPL
9096	bool ByteCodeEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, SourceInfo L) {
9097	return emitOp<const llvm::fltSemantics *>(OP_CastFixedPointFloating, A0, L);
9098	}
9099	#endif
9100	#ifdef GET_EVAL_IMPL
9101	bool EvalEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, SourceInfo L) {
9102	if (!isActive()) return true;
9103	CurrentSource = L;
9104	return CastFixedPointFloating(S, A0);
9105	}
9106	#endif
9107	#ifdef GET_OPCODE_NAMES
9108	OP_CastFixedPointIntegralSint8,
9109	OP_CastFixedPointIntegralUint8,
9110	OP_CastFixedPointIntegralSint16,
9111	OP_CastFixedPointIntegralUint16,
9112	OP_CastFixedPointIntegralSint32,
9113	OP_CastFixedPointIntegralUint32,
9114	OP_CastFixedPointIntegralSint64,
9115	OP_CastFixedPointIntegralUint64,
9116	#endif
9117	#ifdef GET_INTERPFN_LIST
9118	&Interp_CastFixedPointIntegralSint8,
9119	&Interp_CastFixedPointIntegralUint8,
9120	&Interp_CastFixedPointIntegralSint16,
9121	&Interp_CastFixedPointIntegralUint16,
9122	&Interp_CastFixedPointIntegralSint32,
9123	&Interp_CastFixedPointIntegralUint32,
9124	&Interp_CastFixedPointIntegralSint64,
9125	&Interp_CastFixedPointIntegralUint64,
9126	#endif
9127	#ifdef GET_INTERPFN_DISPATCHERS
9128	PRESERVE_NONE
9129	static bool Interp_CastFixedPointIntegralSint8(InterpState &S) {
9130	if (!CastFixedPointIntegral<PT_Sint8>(S, S.PC)) return false;
9131	#if USE_TAILCALLS
9132	MUSTTAIL return InterpNext(S);
9133	#else
9134	return true;
9135	#endif
9136	}
9137	PRESERVE_NONE
9138	static bool Interp_CastFixedPointIntegralUint8(InterpState &S) {
9139	if (!CastFixedPointIntegral<PT_Uint8>(S, S.PC)) return false;
9140	#if USE_TAILCALLS
9141	MUSTTAIL return InterpNext(S);
9142	#else
9143	return true;
9144	#endif
9145	}
9146	PRESERVE_NONE
9147	static bool Interp_CastFixedPointIntegralSint16(InterpState &S) {
9148	if (!CastFixedPointIntegral<PT_Sint16>(S, S.PC)) return false;
9149	#if USE_TAILCALLS
9150	MUSTTAIL return InterpNext(S);
9151	#else
9152	return true;
9153	#endif
9154	}
9155	PRESERVE_NONE
9156	static bool Interp_CastFixedPointIntegralUint16(InterpState &S) {
9157	if (!CastFixedPointIntegral<PT_Uint16>(S, S.PC)) return false;
9158	#if USE_TAILCALLS
9159	MUSTTAIL return InterpNext(S);
9160	#else
9161	return true;
9162	#endif
9163	}
9164	PRESERVE_NONE
9165	static bool Interp_CastFixedPointIntegralSint32(InterpState &S) {
9166	if (!CastFixedPointIntegral<PT_Sint32>(S, S.PC)) return false;
9167	#if USE_TAILCALLS
9168	MUSTTAIL return InterpNext(S);
9169	#else
9170	return true;
9171	#endif
9172	}
9173	PRESERVE_NONE
9174	static bool Interp_CastFixedPointIntegralUint32(InterpState &S) {
9175	if (!CastFixedPointIntegral<PT_Uint32>(S, S.PC)) return false;
9176	#if USE_TAILCALLS
9177	MUSTTAIL return InterpNext(S);
9178	#else
9179	return true;
9180	#endif
9181	}
9182	PRESERVE_NONE
9183	static bool Interp_CastFixedPointIntegralSint64(InterpState &S) {
9184	if (!CastFixedPointIntegral<PT_Sint64>(S, S.PC)) return false;
9185	#if USE_TAILCALLS
9186	MUSTTAIL return InterpNext(S);
9187	#else
9188	return true;
9189	#endif
9190	}
9191	PRESERVE_NONE
9192	static bool Interp_CastFixedPointIntegralUint64(InterpState &S) {
9193	if (!CastFixedPointIntegral<PT_Uint64>(S, S.PC)) return false;
9194	#if USE_TAILCALLS
9195	MUSTTAIL return InterpNext(S);
9196	#else
9197	return true;
9198	#endif
9199	}
9200	#endif
9201	#ifdef GET_DISASM
9202	case OP_CastFixedPointIntegralSint8:
9203	Text.Op = PrintName("CastFixedPointIntegralSint8");
9204	break;
9205	case OP_CastFixedPointIntegralUint8:
9206	Text.Op = PrintName("CastFixedPointIntegralUint8");
9207	break;
9208	case OP_CastFixedPointIntegralSint16:
9209	Text.Op = PrintName("CastFixedPointIntegralSint16");
9210	break;
9211	case OP_CastFixedPointIntegralUint16:
9212	Text.Op = PrintName("CastFixedPointIntegralUint16");
9213	break;
9214	case OP_CastFixedPointIntegralSint32:
9215	Text.Op = PrintName("CastFixedPointIntegralSint32");
9216	break;
9217	case OP_CastFixedPointIntegralUint32:
9218	Text.Op = PrintName("CastFixedPointIntegralUint32");
9219	break;
9220	case OP_CastFixedPointIntegralSint64:
9221	Text.Op = PrintName("CastFixedPointIntegralSint64");
9222	break;
9223	case OP_CastFixedPointIntegralUint64:
9224	Text.Op = PrintName("CastFixedPointIntegralUint64");
9225	break;
9226	#endif
9227	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9228	bool emitCastFixedPointIntegralSint8(SourceInfo);
9229	bool emitCastFixedPointIntegralUint8(SourceInfo);
9230	bool emitCastFixedPointIntegralSint16(SourceInfo);
9231	bool emitCastFixedPointIntegralUint16(SourceInfo);
9232	bool emitCastFixedPointIntegralSint32(SourceInfo);
9233	bool emitCastFixedPointIntegralUint32(SourceInfo);
9234	bool emitCastFixedPointIntegralSint64(SourceInfo);
9235	bool emitCastFixedPointIntegralUint64(SourceInfo);
9236	#endif
9237	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9238	[[nodiscard]] bool emitCastFixedPointIntegral(PrimType, SourceInfo I);
9239	#endif
9240	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
9241	bool
9242	#if defined(GET_EVAL_IMPL)
9243	EvalEmitter
9244	#else
9245	ByteCodeEmitter
9246	#endif
9247	::emitCastFixedPointIntegral(PrimType T0, SourceInfo I) {
9248	switch (T0) {
9249	case PT_Sint8:
9250	return emitCastFixedPointIntegralSint8(I);
9251	case PT_Uint8:
9252	return emitCastFixedPointIntegralUint8(I);
9253	case PT_Sint16:
9254	return emitCastFixedPointIntegralSint16(I);
9255	case PT_Uint16:
9256	return emitCastFixedPointIntegralUint16(I);
9257	case PT_Sint32:
9258	return emitCastFixedPointIntegralSint32(I);
9259	case PT_Uint32:
9260	return emitCastFixedPointIntegralUint32(I);
9261	case PT_Sint64:
9262	return emitCastFixedPointIntegralSint64(I);
9263	case PT_Uint64:
9264	return emitCastFixedPointIntegralUint64(I);
9265	default: llvm_unreachable("invalid type: emitCastFixedPointIntegral");
9266	}
9267	llvm_unreachable("invalid enum value");
9268	}
9269	#endif
9270	#ifdef GET_LINK_IMPL
9271	bool ByteCodeEmitter::emitCastFixedPointIntegralSint8(SourceInfo L) {
9272	return emitOp<>(OP_CastFixedPointIntegralSint8, L);
9273	}
9274	bool ByteCodeEmitter::emitCastFixedPointIntegralUint8(SourceInfo L) {
9275	return emitOp<>(OP_CastFixedPointIntegralUint8, L);
9276	}
9277	bool ByteCodeEmitter::emitCastFixedPointIntegralSint16(SourceInfo L) {
9278	return emitOp<>(OP_CastFixedPointIntegralSint16, L);
9279	}
9280	bool ByteCodeEmitter::emitCastFixedPointIntegralUint16(SourceInfo L) {
9281	return emitOp<>(OP_CastFixedPointIntegralUint16, L);
9282	}
9283	bool ByteCodeEmitter::emitCastFixedPointIntegralSint32(SourceInfo L) {
9284	return emitOp<>(OP_CastFixedPointIntegralSint32, L);
9285	}
9286	bool ByteCodeEmitter::emitCastFixedPointIntegralUint32(SourceInfo L) {
9287	return emitOp<>(OP_CastFixedPointIntegralUint32, L);
9288	}
9289	bool ByteCodeEmitter::emitCastFixedPointIntegralSint64(SourceInfo L) {
9290	return emitOp<>(OP_CastFixedPointIntegralSint64, L);
9291	}
9292	bool ByteCodeEmitter::emitCastFixedPointIntegralUint64(SourceInfo L) {
9293	return emitOp<>(OP_CastFixedPointIntegralUint64, L);
9294	}
9295	#endif
9296	#ifdef GET_EVAL_IMPL
9297	bool EvalEmitter::emitCastFixedPointIntegralSint8(SourceInfo L) {
9298	if (!isActive()) return true;
9299	CurrentSource = L;
9300	return CastFixedPointIntegral<PT_Sint8>(S, CodePtr());
9301	}
9302	bool EvalEmitter::emitCastFixedPointIntegralUint8(SourceInfo L) {
9303	if (!isActive()) return true;
9304	CurrentSource = L;
9305	return CastFixedPointIntegral<PT_Uint8>(S, CodePtr());
9306	}
9307	bool EvalEmitter::emitCastFixedPointIntegralSint16(SourceInfo L) {
9308	if (!isActive()) return true;
9309	CurrentSource = L;
9310	return CastFixedPointIntegral<PT_Sint16>(S, CodePtr());
9311	}
9312	bool EvalEmitter::emitCastFixedPointIntegralUint16(SourceInfo L) {
9313	if (!isActive()) return true;
9314	CurrentSource = L;
9315	return CastFixedPointIntegral<PT_Uint16>(S, CodePtr());
9316	}
9317	bool EvalEmitter::emitCastFixedPointIntegralSint32(SourceInfo L) {
9318	if (!isActive()) return true;
9319	CurrentSource = L;
9320	return CastFixedPointIntegral<PT_Sint32>(S, CodePtr());
9321	}
9322	bool EvalEmitter::emitCastFixedPointIntegralUint32(SourceInfo L) {
9323	if (!isActive()) return true;
9324	CurrentSource = L;
9325	return CastFixedPointIntegral<PT_Uint32>(S, CodePtr());
9326	}
9327	bool EvalEmitter::emitCastFixedPointIntegralSint64(SourceInfo L) {
9328	if (!isActive()) return true;
9329	CurrentSource = L;
9330	return CastFixedPointIntegral<PT_Sint64>(S, CodePtr());
9331	}
9332	bool EvalEmitter::emitCastFixedPointIntegralUint64(SourceInfo L) {
9333	if (!isActive()) return true;
9334	CurrentSource = L;
9335	return CastFixedPointIntegral<PT_Uint64>(S, CodePtr());
9336	}
9337	#endif
9338	#ifdef GET_OPCODE_NAMES
9339	OP_CastFloatingFixedPoint,
9340	#endif
9341	#ifdef GET_INTERPFN_LIST
9342	&Interp_CastFloatingFixedPoint,
9343	#endif
9344	#ifdef GET_INTERPFN_DISPATCHERS
9345	PRESERVE_NONE
9346	static bool Interp_CastFloatingFixedPoint(InterpState &S) {
9347	{
9348	CodePtr OpPC = S.PC;
9349	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9350	if (!CastFloatingFixedPoint(S, OpPC, V0)) return false;
9351	}
9352	#if USE_TAILCALLS
9353	MUSTTAIL return InterpNext(S);
9354	#else
9355	return true;
9356	#endif
9357	}
9358	#endif
9359	#ifdef GET_DISASM
9360	case OP_CastFloatingFixedPoint:
9361	Text.Op = PrintName("CastFloatingFixedPoint");
9362	Text.Args.push_back(printArg<uint32_t>(P, PC));
9363	break;
9364	#endif
9365	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9366	bool emitCastFloatingFixedPoint( uint32_t , SourceInfo);
9367	#endif
9368	#ifdef GET_LINK_IMPL
9369	bool ByteCodeEmitter::emitCastFloatingFixedPoint( uint32_t A0, SourceInfo L) {
9370	return emitOp<uint32_t>(OP_CastFloatingFixedPoint, A0, L);
9371	}
9372	#endif
9373	#ifdef GET_EVAL_IMPL
9374	bool EvalEmitter::emitCastFloatingFixedPoint( uint32_t A0, SourceInfo L) {
9375	if (!isActive()) return true;
9376	CurrentSource = L;
9377	return CastFloatingFixedPoint(S, CodePtr(), A0);
9378	}
9379	#endif
9380	#ifdef GET_OPCODE_NAMES
9381	OP_CastFloatingIntegralSint8,
9382	OP_CastFloatingIntegralUint8,
9383	OP_CastFloatingIntegralSint16,
9384	OP_CastFloatingIntegralUint16,
9385	OP_CastFloatingIntegralSint32,
9386	OP_CastFloatingIntegralUint32,
9387	OP_CastFloatingIntegralSint64,
9388	OP_CastFloatingIntegralUint64,
9389	OP_CastFloatingIntegralBool,
9390	#endif
9391	#ifdef GET_INTERPFN_LIST
9392	&Interp_CastFloatingIntegralSint8,
9393	&Interp_CastFloatingIntegralUint8,
9394	&Interp_CastFloatingIntegralSint16,
9395	&Interp_CastFloatingIntegralUint16,
9396	&Interp_CastFloatingIntegralSint32,
9397	&Interp_CastFloatingIntegralUint32,
9398	&Interp_CastFloatingIntegralSint64,
9399	&Interp_CastFloatingIntegralUint64,
9400	&Interp_CastFloatingIntegralBool,
9401	#endif
9402	#ifdef GET_INTERPFN_DISPATCHERS
9403	PRESERVE_NONE
9404	static bool Interp_CastFloatingIntegralSint8(InterpState &S) {
9405	{
9406	CodePtr OpPC = S.PC;
9407	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9408	if (!CastFloatingIntegral<PT_Sint8>(S, OpPC, V0)) return false;
9409	}
9410	#if USE_TAILCALLS
9411	MUSTTAIL return InterpNext(S);
9412	#else
9413	return true;
9414	#endif
9415	}
9416	PRESERVE_NONE
9417	static bool Interp_CastFloatingIntegralUint8(InterpState &S) {
9418	{
9419	CodePtr OpPC = S.PC;
9420	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9421	if (!CastFloatingIntegral<PT_Uint8>(S, OpPC, V0)) return false;
9422	}
9423	#if USE_TAILCALLS
9424	MUSTTAIL return InterpNext(S);
9425	#else
9426	return true;
9427	#endif
9428	}
9429	PRESERVE_NONE
9430	static bool Interp_CastFloatingIntegralSint16(InterpState &S) {
9431	{
9432	CodePtr OpPC = S.PC;
9433	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9434	if (!CastFloatingIntegral<PT_Sint16>(S, OpPC, V0)) return false;
9435	}
9436	#if USE_TAILCALLS
9437	MUSTTAIL return InterpNext(S);
9438	#else
9439	return true;
9440	#endif
9441	}
9442	PRESERVE_NONE
9443	static bool Interp_CastFloatingIntegralUint16(InterpState &S) {
9444	{
9445	CodePtr OpPC = S.PC;
9446	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9447	if (!CastFloatingIntegral<PT_Uint16>(S, OpPC, V0)) return false;
9448	}
9449	#if USE_TAILCALLS
9450	MUSTTAIL return InterpNext(S);
9451	#else
9452	return true;
9453	#endif
9454	}
9455	PRESERVE_NONE
9456	static bool Interp_CastFloatingIntegralSint32(InterpState &S) {
9457	{
9458	CodePtr OpPC = S.PC;
9459	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9460	if (!CastFloatingIntegral<PT_Sint32>(S, OpPC, V0)) return false;
9461	}
9462	#if USE_TAILCALLS
9463	MUSTTAIL return InterpNext(S);
9464	#else
9465	return true;
9466	#endif
9467	}
9468	PRESERVE_NONE
9469	static bool Interp_CastFloatingIntegralUint32(InterpState &S) {
9470	{
9471	CodePtr OpPC = S.PC;
9472	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9473	if (!CastFloatingIntegral<PT_Uint32>(S, OpPC, V0)) return false;
9474	}
9475	#if USE_TAILCALLS
9476	MUSTTAIL return InterpNext(S);
9477	#else
9478	return true;
9479	#endif
9480	}
9481	PRESERVE_NONE
9482	static bool Interp_CastFloatingIntegralSint64(InterpState &S) {
9483	{
9484	CodePtr OpPC = S.PC;
9485	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9486	if (!CastFloatingIntegral<PT_Sint64>(S, OpPC, V0)) return false;
9487	}
9488	#if USE_TAILCALLS
9489	MUSTTAIL return InterpNext(S);
9490	#else
9491	return true;
9492	#endif
9493	}
9494	PRESERVE_NONE
9495	static bool Interp_CastFloatingIntegralUint64(InterpState &S) {
9496	{
9497	CodePtr OpPC = S.PC;
9498	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9499	if (!CastFloatingIntegral<PT_Uint64>(S, OpPC, V0)) return false;
9500	}
9501	#if USE_TAILCALLS
9502	MUSTTAIL return InterpNext(S);
9503	#else
9504	return true;
9505	#endif
9506	}
9507	PRESERVE_NONE
9508	static bool Interp_CastFloatingIntegralBool(InterpState &S) {
9509	{
9510	CodePtr OpPC = S.PC;
9511	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9512	if (!CastFloatingIntegral<PT_Bool>(S, OpPC, V0)) return false;
9513	}
9514	#if USE_TAILCALLS
9515	MUSTTAIL return InterpNext(S);
9516	#else
9517	return true;
9518	#endif
9519	}
9520	#endif
9521	#ifdef GET_DISASM
9522	case OP_CastFloatingIntegralSint8:
9523	Text.Op = PrintName("CastFloatingIntegralSint8");
9524	Text.Args.push_back(printArg<uint32_t>(P, PC));
9525	break;
9526	case OP_CastFloatingIntegralUint8:
9527	Text.Op = PrintName("CastFloatingIntegralUint8");
9528	Text.Args.push_back(printArg<uint32_t>(P, PC));
9529	break;
9530	case OP_CastFloatingIntegralSint16:
9531	Text.Op = PrintName("CastFloatingIntegralSint16");
9532	Text.Args.push_back(printArg<uint32_t>(P, PC));
9533	break;
9534	case OP_CastFloatingIntegralUint16:
9535	Text.Op = PrintName("CastFloatingIntegralUint16");
9536	Text.Args.push_back(printArg<uint32_t>(P, PC));
9537	break;
9538	case OP_CastFloatingIntegralSint32:
9539	Text.Op = PrintName("CastFloatingIntegralSint32");
9540	Text.Args.push_back(printArg<uint32_t>(P, PC));
9541	break;
9542	case OP_CastFloatingIntegralUint32:
9543	Text.Op = PrintName("CastFloatingIntegralUint32");
9544	Text.Args.push_back(printArg<uint32_t>(P, PC));
9545	break;
9546	case OP_CastFloatingIntegralSint64:
9547	Text.Op = PrintName("CastFloatingIntegralSint64");
9548	Text.Args.push_back(printArg<uint32_t>(P, PC));
9549	break;
9550	case OP_CastFloatingIntegralUint64:
9551	Text.Op = PrintName("CastFloatingIntegralUint64");
9552	Text.Args.push_back(printArg<uint32_t>(P, PC));
9553	break;
9554	case OP_CastFloatingIntegralBool:
9555	Text.Op = PrintName("CastFloatingIntegralBool");
9556	Text.Args.push_back(printArg<uint32_t>(P, PC));
9557	break;
9558	#endif
9559	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9560	bool emitCastFloatingIntegralSint8( uint32_t , SourceInfo);
9561	bool emitCastFloatingIntegralUint8( uint32_t , SourceInfo);
9562	bool emitCastFloatingIntegralSint16( uint32_t , SourceInfo);
9563	bool emitCastFloatingIntegralUint16( uint32_t , SourceInfo);
9564	bool emitCastFloatingIntegralSint32( uint32_t , SourceInfo);
9565	bool emitCastFloatingIntegralUint32( uint32_t , SourceInfo);
9566	bool emitCastFloatingIntegralSint64( uint32_t , SourceInfo);
9567	bool emitCastFloatingIntegralUint64( uint32_t , SourceInfo);
9568	bool emitCastFloatingIntegralBool( uint32_t , SourceInfo);
9569	#endif
9570	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9571	[[nodiscard]] bool emitCastFloatingIntegral(PrimType, uint32_t, SourceInfo I);
9572	#endif
9573	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
9574	bool
9575	#if defined(GET_EVAL_IMPL)
9576	EvalEmitter
9577	#else
9578	ByteCodeEmitter
9579	#endif
9580	::emitCastFloatingIntegral(PrimType T0, uint32_t A0, SourceInfo I) {
9581	switch (T0) {
9582	case PT_Sint8:
9583	return emitCastFloatingIntegralSint8(A0, I);
9584	case PT_Uint8:
9585	return emitCastFloatingIntegralUint8(A0, I);
9586	case PT_Sint16:
9587	return emitCastFloatingIntegralSint16(A0, I);
9588	case PT_Uint16:
9589	return emitCastFloatingIntegralUint16(A0, I);
9590	case PT_Sint32:
9591	return emitCastFloatingIntegralSint32(A0, I);
9592	case PT_Uint32:
9593	return emitCastFloatingIntegralUint32(A0, I);
9594	case PT_Sint64:
9595	return emitCastFloatingIntegralSint64(A0, I);
9596	case PT_Uint64:
9597	return emitCastFloatingIntegralUint64(A0, I);
9598	case PT_Bool:
9599	return emitCastFloatingIntegralBool(A0, I);
9600	default: llvm_unreachable("invalid type: emitCastFloatingIntegral");
9601	}
9602	llvm_unreachable("invalid enum value");
9603	}
9604	#endif
9605	#ifdef GET_LINK_IMPL
9606	bool ByteCodeEmitter::emitCastFloatingIntegralSint8( uint32_t A0, SourceInfo L) {
9607	return emitOp<uint32_t>(OP_CastFloatingIntegralSint8, A0, L);
9608	}
9609	bool ByteCodeEmitter::emitCastFloatingIntegralUint8( uint32_t A0, SourceInfo L) {
9610	return emitOp<uint32_t>(OP_CastFloatingIntegralUint8, A0, L);
9611	}
9612	bool ByteCodeEmitter::emitCastFloatingIntegralSint16( uint32_t A0, SourceInfo L) {
9613	return emitOp<uint32_t>(OP_CastFloatingIntegralSint16, A0, L);
9614	}
9615	bool ByteCodeEmitter::emitCastFloatingIntegralUint16( uint32_t A0, SourceInfo L) {
9616	return emitOp<uint32_t>(OP_CastFloatingIntegralUint16, A0, L);
9617	}
9618	bool ByteCodeEmitter::emitCastFloatingIntegralSint32( uint32_t A0, SourceInfo L) {
9619	return emitOp<uint32_t>(OP_CastFloatingIntegralSint32, A0, L);
9620	}
9621	bool ByteCodeEmitter::emitCastFloatingIntegralUint32( uint32_t A0, SourceInfo L) {
9622	return emitOp<uint32_t>(OP_CastFloatingIntegralUint32, A0, L);
9623	}
9624	bool ByteCodeEmitter::emitCastFloatingIntegralSint64( uint32_t A0, SourceInfo L) {
9625	return emitOp<uint32_t>(OP_CastFloatingIntegralSint64, A0, L);
9626	}
9627	bool ByteCodeEmitter::emitCastFloatingIntegralUint64( uint32_t A0, SourceInfo L) {
9628	return emitOp<uint32_t>(OP_CastFloatingIntegralUint64, A0, L);
9629	}
9630	bool ByteCodeEmitter::emitCastFloatingIntegralBool( uint32_t A0, SourceInfo L) {
9631	return emitOp<uint32_t>(OP_CastFloatingIntegralBool, A0, L);
9632	}
9633	#endif
9634	#ifdef GET_EVAL_IMPL
9635	bool EvalEmitter::emitCastFloatingIntegralSint8( uint32_t A0, SourceInfo L) {
9636	if (!isActive()) return true;
9637	CurrentSource = L;
9638	return CastFloatingIntegral<PT_Sint8>(S, CodePtr(), A0);
9639	}
9640	bool EvalEmitter::emitCastFloatingIntegralUint8( uint32_t A0, SourceInfo L) {
9641	if (!isActive()) return true;
9642	CurrentSource = L;
9643	return CastFloatingIntegral<PT_Uint8>(S, CodePtr(), A0);
9644	}
9645	bool EvalEmitter::emitCastFloatingIntegralSint16( uint32_t A0, SourceInfo L) {
9646	if (!isActive()) return true;
9647	CurrentSource = L;
9648	return CastFloatingIntegral<PT_Sint16>(S, CodePtr(), A0);
9649	}
9650	bool EvalEmitter::emitCastFloatingIntegralUint16( uint32_t A0, SourceInfo L) {
9651	if (!isActive()) return true;
9652	CurrentSource = L;
9653	return CastFloatingIntegral<PT_Uint16>(S, CodePtr(), A0);
9654	}
9655	bool EvalEmitter::emitCastFloatingIntegralSint32( uint32_t A0, SourceInfo L) {
9656	if (!isActive()) return true;
9657	CurrentSource = L;
9658	return CastFloatingIntegral<PT_Sint32>(S, CodePtr(), A0);
9659	}
9660	bool EvalEmitter::emitCastFloatingIntegralUint32( uint32_t A0, SourceInfo L) {
9661	if (!isActive()) return true;
9662	CurrentSource = L;
9663	return CastFloatingIntegral<PT_Uint32>(S, CodePtr(), A0);
9664	}
9665	bool EvalEmitter::emitCastFloatingIntegralSint64( uint32_t A0, SourceInfo L) {
9666	if (!isActive()) return true;
9667	CurrentSource = L;
9668	return CastFloatingIntegral<PT_Sint64>(S, CodePtr(), A0);
9669	}
9670	bool EvalEmitter::emitCastFloatingIntegralUint64( uint32_t A0, SourceInfo L) {
9671	if (!isActive()) return true;
9672	CurrentSource = L;
9673	return CastFloatingIntegral<PT_Uint64>(S, CodePtr(), A0);
9674	}
9675	bool EvalEmitter::emitCastFloatingIntegralBool( uint32_t A0, SourceInfo L) {
9676	if (!isActive()) return true;
9677	CurrentSource = L;
9678	return CastFloatingIntegral<PT_Bool>(S, CodePtr(), A0);
9679	}
9680	#endif
9681	#ifdef GET_OPCODE_NAMES
9682	OP_CastFloatingIntegralAP,
9683	#endif
9684	#ifdef GET_INTERPFN_LIST
9685	&Interp_CastFloatingIntegralAP,
9686	#endif
9687	#ifdef GET_INTERPFN_DISPATCHERS
9688	PRESERVE_NONE
9689	static bool Interp_CastFloatingIntegralAP(InterpState &S) {
9690	{
9691	CodePtr OpPC = S.PC;
9692	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9693	const auto V1 = ReadArg<uint32_t>(S, S.PC);
9694	if (!CastFloatingIntegralAP(S, OpPC, V0, V1)) return false;
9695	}
9696	#if USE_TAILCALLS
9697	MUSTTAIL return InterpNext(S);
9698	#else
9699	return true;
9700	#endif
9701	}
9702	#endif
9703	#ifdef GET_DISASM
9704	case OP_CastFloatingIntegralAP:
9705	Text.Op = PrintName("CastFloatingIntegralAP");
9706	Text.Args.push_back(printArg<uint32_t>(P, PC));
9707	Text.Args.push_back(printArg<uint32_t>(P, PC));
9708	break;
9709	#endif
9710	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9711	bool emitCastFloatingIntegralAP( uint32_t , uint32_t , SourceInfo);
9712	#endif
9713	#ifdef GET_LINK_IMPL
9714	bool ByteCodeEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, SourceInfo L) {
9715	return emitOp<uint32_t, uint32_t>(OP_CastFloatingIntegralAP, A0, A1, L);
9716	}
9717	#endif
9718	#ifdef GET_EVAL_IMPL
9719	bool EvalEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, SourceInfo L) {
9720	if (!isActive()) return true;
9721	CurrentSource = L;
9722	return CastFloatingIntegralAP(S, CodePtr(), A0, A1);
9723	}
9724	#endif
9725	#ifdef GET_OPCODE_NAMES
9726	OP_CastFloatingIntegralAPS,
9727	#endif
9728	#ifdef GET_INTERPFN_LIST
9729	&Interp_CastFloatingIntegralAPS,
9730	#endif
9731	#ifdef GET_INTERPFN_DISPATCHERS
9732	PRESERVE_NONE
9733	static bool Interp_CastFloatingIntegralAPS(InterpState &S) {
9734	{
9735	CodePtr OpPC = S.PC;
9736	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9737	const auto V1 = ReadArg<uint32_t>(S, S.PC);
9738	if (!CastFloatingIntegralAPS(S, OpPC, V0, V1)) return false;
9739	}
9740	#if USE_TAILCALLS
9741	MUSTTAIL return InterpNext(S);
9742	#else
9743	return true;
9744	#endif
9745	}
9746	#endif
9747	#ifdef GET_DISASM
9748	case OP_CastFloatingIntegralAPS:
9749	Text.Op = PrintName("CastFloatingIntegralAPS");
9750	Text.Args.push_back(printArg<uint32_t>(P, PC));
9751	Text.Args.push_back(printArg<uint32_t>(P, PC));
9752	break;
9753	#endif
9754	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9755	bool emitCastFloatingIntegralAPS( uint32_t , uint32_t , SourceInfo);
9756	#endif
9757	#ifdef GET_LINK_IMPL
9758	bool ByteCodeEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
9759	return emitOp<uint32_t, uint32_t>(OP_CastFloatingIntegralAPS, A0, A1, L);
9760	}
9761	#endif
9762	#ifdef GET_EVAL_IMPL
9763	bool EvalEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
9764	if (!isActive()) return true;
9765	CurrentSource = L;
9766	return CastFloatingIntegralAPS(S, CodePtr(), A0, A1);
9767	}
9768	#endif
9769	#ifdef GET_OPCODE_NAMES
9770	OP_CastIntegralFixedPointSint8,
9771	OP_CastIntegralFixedPointUint8,
9772	OP_CastIntegralFixedPointSint16,
9773	OP_CastIntegralFixedPointUint16,
9774	OP_CastIntegralFixedPointSint32,
9775	OP_CastIntegralFixedPointUint32,
9776	OP_CastIntegralFixedPointSint64,
9777	OP_CastIntegralFixedPointUint64,
9778	OP_CastIntegralFixedPointIntAP,
9779	OP_CastIntegralFixedPointIntAPS,
9780	OP_CastIntegralFixedPointBool,
9781	#endif
9782	#ifdef GET_INTERPFN_LIST
9783	&Interp_CastIntegralFixedPointSint8,
9784	&Interp_CastIntegralFixedPointUint8,
9785	&Interp_CastIntegralFixedPointSint16,
9786	&Interp_CastIntegralFixedPointUint16,
9787	&Interp_CastIntegralFixedPointSint32,
9788	&Interp_CastIntegralFixedPointUint32,
9789	&Interp_CastIntegralFixedPointSint64,
9790	&Interp_CastIntegralFixedPointUint64,
9791	&Interp_CastIntegralFixedPointIntAP,
9792	&Interp_CastIntegralFixedPointIntAPS,
9793	&Interp_CastIntegralFixedPointBool,
9794	#endif
9795	#ifdef GET_INTERPFN_DISPATCHERS
9796	PRESERVE_NONE
9797	static bool Interp_CastIntegralFixedPointSint8(InterpState &S) {
9798	{
9799	CodePtr OpPC = S.PC;
9800	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9801	if (!CastIntegralFixedPoint<PT_Sint8>(S, OpPC, V0)) return false;
9802	}
9803	#if USE_TAILCALLS
9804	MUSTTAIL return InterpNext(S);
9805	#else
9806	return true;
9807	#endif
9808	}
9809	PRESERVE_NONE
9810	static bool Interp_CastIntegralFixedPointUint8(InterpState &S) {
9811	{
9812	CodePtr OpPC = S.PC;
9813	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9814	if (!CastIntegralFixedPoint<PT_Uint8>(S, OpPC, V0)) return false;
9815	}
9816	#if USE_TAILCALLS
9817	MUSTTAIL return InterpNext(S);
9818	#else
9819	return true;
9820	#endif
9821	}
9822	PRESERVE_NONE
9823	static bool Interp_CastIntegralFixedPointSint16(InterpState &S) {
9824	{
9825	CodePtr OpPC = S.PC;
9826	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9827	if (!CastIntegralFixedPoint<PT_Sint16>(S, OpPC, V0)) return false;
9828	}
9829	#if USE_TAILCALLS
9830	MUSTTAIL return InterpNext(S);
9831	#else
9832	return true;
9833	#endif
9834	}
9835	PRESERVE_NONE
9836	static bool Interp_CastIntegralFixedPointUint16(InterpState &S) {
9837	{
9838	CodePtr OpPC = S.PC;
9839	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9840	if (!CastIntegralFixedPoint<PT_Uint16>(S, OpPC, V0)) return false;
9841	}
9842	#if USE_TAILCALLS
9843	MUSTTAIL return InterpNext(S);
9844	#else
9845	return true;
9846	#endif
9847	}
9848	PRESERVE_NONE
9849	static bool Interp_CastIntegralFixedPointSint32(InterpState &S) {
9850	{
9851	CodePtr OpPC = S.PC;
9852	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9853	if (!CastIntegralFixedPoint<PT_Sint32>(S, OpPC, V0)) return false;
9854	}
9855	#if USE_TAILCALLS
9856	MUSTTAIL return InterpNext(S);
9857	#else
9858	return true;
9859	#endif
9860	}
9861	PRESERVE_NONE
9862	static bool Interp_CastIntegralFixedPointUint32(InterpState &S) {
9863	{
9864	CodePtr OpPC = S.PC;
9865	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9866	if (!CastIntegralFixedPoint<PT_Uint32>(S, OpPC, V0)) return false;
9867	}
9868	#if USE_TAILCALLS
9869	MUSTTAIL return InterpNext(S);
9870	#else
9871	return true;
9872	#endif
9873	}
9874	PRESERVE_NONE
9875	static bool Interp_CastIntegralFixedPointSint64(InterpState &S) {
9876	{
9877	CodePtr OpPC = S.PC;
9878	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9879	if (!CastIntegralFixedPoint<PT_Sint64>(S, OpPC, V0)) return false;
9880	}
9881	#if USE_TAILCALLS
9882	MUSTTAIL return InterpNext(S);
9883	#else
9884	return true;
9885	#endif
9886	}
9887	PRESERVE_NONE
9888	static bool Interp_CastIntegralFixedPointUint64(InterpState &S) {
9889	{
9890	CodePtr OpPC = S.PC;
9891	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9892	if (!CastIntegralFixedPoint<PT_Uint64>(S, OpPC, V0)) return false;
9893	}
9894	#if USE_TAILCALLS
9895	MUSTTAIL return InterpNext(S);
9896	#else
9897	return true;
9898	#endif
9899	}
9900	PRESERVE_NONE
9901	static bool Interp_CastIntegralFixedPointIntAP(InterpState &S) {
9902	{
9903	CodePtr OpPC = S.PC;
9904	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9905	if (!CastIntegralFixedPoint<PT_IntAP>(S, OpPC, V0)) return false;
9906	}
9907	#if USE_TAILCALLS
9908	MUSTTAIL return InterpNext(S);
9909	#else
9910	return true;
9911	#endif
9912	}
9913	PRESERVE_NONE
9914	static bool Interp_CastIntegralFixedPointIntAPS(InterpState &S) {
9915	{
9916	CodePtr OpPC = S.PC;
9917	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9918	if (!CastIntegralFixedPoint<PT_IntAPS>(S, OpPC, V0)) return false;
9919	}
9920	#if USE_TAILCALLS
9921	MUSTTAIL return InterpNext(S);
9922	#else
9923	return true;
9924	#endif
9925	}
9926	PRESERVE_NONE
9927	static bool Interp_CastIntegralFixedPointBool(InterpState &S) {
9928	{
9929	CodePtr OpPC = S.PC;
9930	const auto V0 = ReadArg<uint32_t>(S, S.PC);
9931	if (!CastIntegralFixedPoint<PT_Bool>(S, OpPC, V0)) return false;
9932	}
9933	#if USE_TAILCALLS
9934	MUSTTAIL return InterpNext(S);
9935	#else
9936	return true;
9937	#endif
9938	}
9939	#endif
9940	#ifdef GET_DISASM
9941	case OP_CastIntegralFixedPointSint8:
9942	Text.Op = PrintName("CastIntegralFixedPointSint8");
9943	Text.Args.push_back(printArg<uint32_t>(P, PC));
9944	break;
9945	case OP_CastIntegralFixedPointUint8:
9946	Text.Op = PrintName("CastIntegralFixedPointUint8");
9947	Text.Args.push_back(printArg<uint32_t>(P, PC));
9948	break;
9949	case OP_CastIntegralFixedPointSint16:
9950	Text.Op = PrintName("CastIntegralFixedPointSint16");
9951	Text.Args.push_back(printArg<uint32_t>(P, PC));
9952	break;
9953	case OP_CastIntegralFixedPointUint16:
9954	Text.Op = PrintName("CastIntegralFixedPointUint16");
9955	Text.Args.push_back(printArg<uint32_t>(P, PC));
9956	break;
9957	case OP_CastIntegralFixedPointSint32:
9958	Text.Op = PrintName("CastIntegralFixedPointSint32");
9959	Text.Args.push_back(printArg<uint32_t>(P, PC));
9960	break;
9961	case OP_CastIntegralFixedPointUint32:
9962	Text.Op = PrintName("CastIntegralFixedPointUint32");
9963	Text.Args.push_back(printArg<uint32_t>(P, PC));
9964	break;
9965	case OP_CastIntegralFixedPointSint64:
9966	Text.Op = PrintName("CastIntegralFixedPointSint64");
9967	Text.Args.push_back(printArg<uint32_t>(P, PC));
9968	break;
9969	case OP_CastIntegralFixedPointUint64:
9970	Text.Op = PrintName("CastIntegralFixedPointUint64");
9971	Text.Args.push_back(printArg<uint32_t>(P, PC));
9972	break;
9973	case OP_CastIntegralFixedPointIntAP:
9974	Text.Op = PrintName("CastIntegralFixedPointIntAP");
9975	Text.Args.push_back(printArg<uint32_t>(P, PC));
9976	break;
9977	case OP_CastIntegralFixedPointIntAPS:
9978	Text.Op = PrintName("CastIntegralFixedPointIntAPS");
9979	Text.Args.push_back(printArg<uint32_t>(P, PC));
9980	break;
9981	case OP_CastIntegralFixedPointBool:
9982	Text.Op = PrintName("CastIntegralFixedPointBool");
9983	Text.Args.push_back(printArg<uint32_t>(P, PC));
9984	break;
9985	#endif
9986	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
9987	bool emitCastIntegralFixedPointSint8( uint32_t , SourceInfo);
9988	bool emitCastIntegralFixedPointUint8( uint32_t , SourceInfo);
9989	bool emitCastIntegralFixedPointSint16( uint32_t , SourceInfo);
9990	bool emitCastIntegralFixedPointUint16( uint32_t , SourceInfo);
9991	bool emitCastIntegralFixedPointSint32( uint32_t , SourceInfo);
9992	bool emitCastIntegralFixedPointUint32( uint32_t , SourceInfo);
9993	bool emitCastIntegralFixedPointSint64( uint32_t , SourceInfo);
9994	bool emitCastIntegralFixedPointUint64( uint32_t , SourceInfo);
9995	bool emitCastIntegralFixedPointIntAP( uint32_t , SourceInfo);
9996	bool emitCastIntegralFixedPointIntAPS( uint32_t , SourceInfo);
9997	bool emitCastIntegralFixedPointBool( uint32_t , SourceInfo);
9998	#endif
9999	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10000	[[nodiscard]] bool emitCastIntegralFixedPoint(PrimType, uint32_t, SourceInfo I);
10001	#endif
10002	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
10003	bool
10004	#if defined(GET_EVAL_IMPL)
10005	EvalEmitter
10006	#else
10007	ByteCodeEmitter
10008	#endif
10009	::emitCastIntegralFixedPoint(PrimType T0, uint32_t A0, SourceInfo I) {
10010	switch (T0) {
10011	case PT_Sint8:
10012	return emitCastIntegralFixedPointSint8(A0, I);
10013	case PT_Uint8:
10014	return emitCastIntegralFixedPointUint8(A0, I);
10015	case PT_Sint16:
10016	return emitCastIntegralFixedPointSint16(A0, I);
10017	case PT_Uint16:
10018	return emitCastIntegralFixedPointUint16(A0, I);
10019	case PT_Sint32:
10020	return emitCastIntegralFixedPointSint32(A0, I);
10021	case PT_Uint32:
10022	return emitCastIntegralFixedPointUint32(A0, I);
10023	case PT_Sint64:
10024	return emitCastIntegralFixedPointSint64(A0, I);
10025	case PT_Uint64:
10026	return emitCastIntegralFixedPointUint64(A0, I);
10027	case PT_IntAP:
10028	return emitCastIntegralFixedPointIntAP(A0, I);
10029	case PT_IntAPS:
10030	return emitCastIntegralFixedPointIntAPS(A0, I);
10031	case PT_Bool:
10032	return emitCastIntegralFixedPointBool(A0, I);
10033	default: llvm_unreachable("invalid type: emitCastIntegralFixedPoint");
10034	}
10035	llvm_unreachable("invalid enum value");
10036	}
10037	#endif
10038	#ifdef GET_LINK_IMPL
10039	bool ByteCodeEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, SourceInfo L) {
10040	return emitOp<uint32_t>(OP_CastIntegralFixedPointSint8, A0, L);
10041	}
10042	bool ByteCodeEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, SourceInfo L) {
10043	return emitOp<uint32_t>(OP_CastIntegralFixedPointUint8, A0, L);
10044	}
10045	bool ByteCodeEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, SourceInfo L) {
10046	return emitOp<uint32_t>(OP_CastIntegralFixedPointSint16, A0, L);
10047	}
10048	bool ByteCodeEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, SourceInfo L) {
10049	return emitOp<uint32_t>(OP_CastIntegralFixedPointUint16, A0, L);
10050	}
10051	bool ByteCodeEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, SourceInfo L) {
10052	return emitOp<uint32_t>(OP_CastIntegralFixedPointSint32, A0, L);
10053	}
10054	bool ByteCodeEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, SourceInfo L) {
10055	return emitOp<uint32_t>(OP_CastIntegralFixedPointUint32, A0, L);
10056	}
10057	bool ByteCodeEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, SourceInfo L) {
10058	return emitOp<uint32_t>(OP_CastIntegralFixedPointSint64, A0, L);
10059	}
10060	bool ByteCodeEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, SourceInfo L) {
10061	return emitOp<uint32_t>(OP_CastIntegralFixedPointUint64, A0, L);
10062	}
10063	bool ByteCodeEmitter::emitCastIntegralFixedPointIntAP( uint32_t A0, SourceInfo L) {
10064	return emitOp<uint32_t>(OP_CastIntegralFixedPointIntAP, A0, L);
10065	}
10066	bool ByteCodeEmitter::emitCastIntegralFixedPointIntAPS( uint32_t A0, SourceInfo L) {
10067	return emitOp<uint32_t>(OP_CastIntegralFixedPointIntAPS, A0, L);
10068	}
10069	bool ByteCodeEmitter::emitCastIntegralFixedPointBool( uint32_t A0, SourceInfo L) {
10070	return emitOp<uint32_t>(OP_CastIntegralFixedPointBool, A0, L);
10071	}
10072	#endif
10073	#ifdef GET_EVAL_IMPL
10074	bool EvalEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, SourceInfo L) {
10075	if (!isActive()) return true;
10076	CurrentSource = L;
10077	return CastIntegralFixedPoint<PT_Sint8>(S, CodePtr(), A0);
10078	}
10079	bool EvalEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, SourceInfo L) {
10080	if (!isActive()) return true;
10081	CurrentSource = L;
10082	return CastIntegralFixedPoint<PT_Uint8>(S, CodePtr(), A0);
10083	}
10084	bool EvalEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, SourceInfo L) {
10085	if (!isActive()) return true;
10086	CurrentSource = L;
10087	return CastIntegralFixedPoint<PT_Sint16>(S, CodePtr(), A0);
10088	}
10089	bool EvalEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, SourceInfo L) {
10090	if (!isActive()) return true;
10091	CurrentSource = L;
10092	return CastIntegralFixedPoint<PT_Uint16>(S, CodePtr(), A0);
10093	}
10094	bool EvalEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, SourceInfo L) {
10095	if (!isActive()) return true;
10096	CurrentSource = L;
10097	return CastIntegralFixedPoint<PT_Sint32>(S, CodePtr(), A0);
10098	}
10099	bool EvalEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, SourceInfo L) {
10100	if (!isActive()) return true;
10101	CurrentSource = L;
10102	return CastIntegralFixedPoint<PT_Uint32>(S, CodePtr(), A0);
10103	}
10104	bool EvalEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, SourceInfo L) {
10105	if (!isActive()) return true;
10106	CurrentSource = L;
10107	return CastIntegralFixedPoint<PT_Sint64>(S, CodePtr(), A0);
10108	}
10109	bool EvalEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, SourceInfo L) {
10110	if (!isActive()) return true;
10111	CurrentSource = L;
10112	return CastIntegralFixedPoint<PT_Uint64>(S, CodePtr(), A0);
10113	}
10114	bool EvalEmitter::emitCastIntegralFixedPointIntAP( uint32_t A0, SourceInfo L) {
10115	if (!isActive()) return true;
10116	CurrentSource = L;
10117	return CastIntegralFixedPoint<PT_IntAP>(S, CodePtr(), A0);
10118	}
10119	bool EvalEmitter::emitCastIntegralFixedPointIntAPS( uint32_t A0, SourceInfo L) {
10120	if (!isActive()) return true;
10121	CurrentSource = L;
10122	return CastIntegralFixedPoint<PT_IntAPS>(S, CodePtr(), A0);
10123	}
10124	bool EvalEmitter::emitCastIntegralFixedPointBool( uint32_t A0, SourceInfo L) {
10125	if (!isActive()) return true;
10126	CurrentSource = L;
10127	return CastIntegralFixedPoint<PT_Bool>(S, CodePtr(), A0);
10128	}
10129	#endif
10130	#ifdef GET_OPCODE_NAMES
10131	OP_CastIntegralFloatingSint8,
10132	OP_CastIntegralFloatingUint8,
10133	OP_CastIntegralFloatingSint16,
10134	OP_CastIntegralFloatingUint16,
10135	OP_CastIntegralFloatingSint32,
10136	OP_CastIntegralFloatingUint32,
10137	OP_CastIntegralFloatingSint64,
10138	OP_CastIntegralFloatingUint64,
10139	OP_CastIntegralFloatingIntAP,
10140	OP_CastIntegralFloatingIntAPS,
10141	OP_CastIntegralFloatingBool,
10142	OP_CastIntegralFloatingFixedPoint,
10143	#endif
10144	#ifdef GET_INTERPFN_LIST
10145	&Interp_CastIntegralFloatingSint8,
10146	&Interp_CastIntegralFloatingUint8,
10147	&Interp_CastIntegralFloatingSint16,
10148	&Interp_CastIntegralFloatingUint16,
10149	&Interp_CastIntegralFloatingSint32,
10150	&Interp_CastIntegralFloatingUint32,
10151	&Interp_CastIntegralFloatingSint64,
10152	&Interp_CastIntegralFloatingUint64,
10153	&Interp_CastIntegralFloatingIntAP,
10154	&Interp_CastIntegralFloatingIntAPS,
10155	&Interp_CastIntegralFloatingBool,
10156	&Interp_CastIntegralFloatingFixedPoint,
10157	#endif
10158	#ifdef GET_INTERPFN_DISPATCHERS
10159	PRESERVE_NONE
10160	static bool Interp_CastIntegralFloatingSint8(InterpState &S) {
10161	{
10162	CodePtr OpPC = S.PC;
10163	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10164	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10165	if (!CastIntegralFloating<PT_Sint8>(S, OpPC, V0, V1)) return false;
10166	}
10167	#if USE_TAILCALLS
10168	MUSTTAIL return InterpNext(S);
10169	#else
10170	return true;
10171	#endif
10172	}
10173	PRESERVE_NONE
10174	static bool Interp_CastIntegralFloatingUint8(InterpState &S) {
10175	{
10176	CodePtr OpPC = S.PC;
10177	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10178	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10179	if (!CastIntegralFloating<PT_Uint8>(S, OpPC, V0, V1)) return false;
10180	}
10181	#if USE_TAILCALLS
10182	MUSTTAIL return InterpNext(S);
10183	#else
10184	return true;
10185	#endif
10186	}
10187	PRESERVE_NONE
10188	static bool Interp_CastIntegralFloatingSint16(InterpState &S) {
10189	{
10190	CodePtr OpPC = S.PC;
10191	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10192	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10193	if (!CastIntegralFloating<PT_Sint16>(S, OpPC, V0, V1)) return false;
10194	}
10195	#if USE_TAILCALLS
10196	MUSTTAIL return InterpNext(S);
10197	#else
10198	return true;
10199	#endif
10200	}
10201	PRESERVE_NONE
10202	static bool Interp_CastIntegralFloatingUint16(InterpState &S) {
10203	{
10204	CodePtr OpPC = S.PC;
10205	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10206	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10207	if (!CastIntegralFloating<PT_Uint16>(S, OpPC, V0, V1)) return false;
10208	}
10209	#if USE_TAILCALLS
10210	MUSTTAIL return InterpNext(S);
10211	#else
10212	return true;
10213	#endif
10214	}
10215	PRESERVE_NONE
10216	static bool Interp_CastIntegralFloatingSint32(InterpState &S) {
10217	{
10218	CodePtr OpPC = S.PC;
10219	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10220	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10221	if (!CastIntegralFloating<PT_Sint32>(S, OpPC, V0, V1)) return false;
10222	}
10223	#if USE_TAILCALLS
10224	MUSTTAIL return InterpNext(S);
10225	#else
10226	return true;
10227	#endif
10228	}
10229	PRESERVE_NONE
10230	static bool Interp_CastIntegralFloatingUint32(InterpState &S) {
10231	{
10232	CodePtr OpPC = S.PC;
10233	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10234	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10235	if (!CastIntegralFloating<PT_Uint32>(S, OpPC, V0, V1)) return false;
10236	}
10237	#if USE_TAILCALLS
10238	MUSTTAIL return InterpNext(S);
10239	#else
10240	return true;
10241	#endif
10242	}
10243	PRESERVE_NONE
10244	static bool Interp_CastIntegralFloatingSint64(InterpState &S) {
10245	{
10246	CodePtr OpPC = S.PC;
10247	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10248	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10249	if (!CastIntegralFloating<PT_Sint64>(S, OpPC, V0, V1)) return false;
10250	}
10251	#if USE_TAILCALLS
10252	MUSTTAIL return InterpNext(S);
10253	#else
10254	return true;
10255	#endif
10256	}
10257	PRESERVE_NONE
10258	static bool Interp_CastIntegralFloatingUint64(InterpState &S) {
10259	{
10260	CodePtr OpPC = S.PC;
10261	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10262	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10263	if (!CastIntegralFloating<PT_Uint64>(S, OpPC, V0, V1)) return false;
10264	}
10265	#if USE_TAILCALLS
10266	MUSTTAIL return InterpNext(S);
10267	#else
10268	return true;
10269	#endif
10270	}
10271	PRESERVE_NONE
10272	static bool Interp_CastIntegralFloatingIntAP(InterpState &S) {
10273	{
10274	CodePtr OpPC = S.PC;
10275	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10276	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10277	if (!CastIntegralFloating<PT_IntAP>(S, OpPC, V0, V1)) return false;
10278	}
10279	#if USE_TAILCALLS
10280	MUSTTAIL return InterpNext(S);
10281	#else
10282	return true;
10283	#endif
10284	}
10285	PRESERVE_NONE
10286	static bool Interp_CastIntegralFloatingIntAPS(InterpState &S) {
10287	{
10288	CodePtr OpPC = S.PC;
10289	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10290	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10291	if (!CastIntegralFloating<PT_IntAPS>(S, OpPC, V0, V1)) return false;
10292	}
10293	#if USE_TAILCALLS
10294	MUSTTAIL return InterpNext(S);
10295	#else
10296	return true;
10297	#endif
10298	}
10299	PRESERVE_NONE
10300	static bool Interp_CastIntegralFloatingBool(InterpState &S) {
10301	{
10302	CodePtr OpPC = S.PC;
10303	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10304	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10305	if (!CastIntegralFloating<PT_Bool>(S, OpPC, V0, V1)) return false;
10306	}
10307	#if USE_TAILCALLS
10308	MUSTTAIL return InterpNext(S);
10309	#else
10310	return true;
10311	#endif
10312	}
10313	PRESERVE_NONE
10314	static bool Interp_CastIntegralFloatingFixedPoint(InterpState &S) {
10315	{
10316	CodePtr OpPC = S.PC;
10317	const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10318	const auto V1 = ReadArg<uint32_t>(S, S.PC);
10319	if (!CastIntegralFloating<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
10320	}
10321	#if USE_TAILCALLS
10322	MUSTTAIL return InterpNext(S);
10323	#else
10324	return true;
10325	#endif
10326	}
10327	#endif
10328	#ifdef GET_DISASM
10329	case OP_CastIntegralFloatingSint8:
10330	Text.Op = PrintName("CastIntegralFloatingSint8");
10331	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10332	Text.Args.push_back(printArg<uint32_t>(P, PC));
10333	break;
10334	case OP_CastIntegralFloatingUint8:
10335	Text.Op = PrintName("CastIntegralFloatingUint8");
10336	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10337	Text.Args.push_back(printArg<uint32_t>(P, PC));
10338	break;
10339	case OP_CastIntegralFloatingSint16:
10340	Text.Op = PrintName("CastIntegralFloatingSint16");
10341	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10342	Text.Args.push_back(printArg<uint32_t>(P, PC));
10343	break;
10344	case OP_CastIntegralFloatingUint16:
10345	Text.Op = PrintName("CastIntegralFloatingUint16");
10346	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10347	Text.Args.push_back(printArg<uint32_t>(P, PC));
10348	break;
10349	case OP_CastIntegralFloatingSint32:
10350	Text.Op = PrintName("CastIntegralFloatingSint32");
10351	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10352	Text.Args.push_back(printArg<uint32_t>(P, PC));
10353	break;
10354	case OP_CastIntegralFloatingUint32:
10355	Text.Op = PrintName("CastIntegralFloatingUint32");
10356	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10357	Text.Args.push_back(printArg<uint32_t>(P, PC));
10358	break;
10359	case OP_CastIntegralFloatingSint64:
10360	Text.Op = PrintName("CastIntegralFloatingSint64");
10361	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10362	Text.Args.push_back(printArg<uint32_t>(P, PC));
10363	break;
10364	case OP_CastIntegralFloatingUint64:
10365	Text.Op = PrintName("CastIntegralFloatingUint64");
10366	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10367	Text.Args.push_back(printArg<uint32_t>(P, PC));
10368	break;
10369	case OP_CastIntegralFloatingIntAP:
10370	Text.Op = PrintName("CastIntegralFloatingIntAP");
10371	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10372	Text.Args.push_back(printArg<uint32_t>(P, PC));
10373	break;
10374	case OP_CastIntegralFloatingIntAPS:
10375	Text.Op = PrintName("CastIntegralFloatingIntAPS");
10376	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10377	Text.Args.push_back(printArg<uint32_t>(P, PC));
10378	break;
10379	case OP_CastIntegralFloatingBool:
10380	Text.Op = PrintName("CastIntegralFloatingBool");
10381	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10382	Text.Args.push_back(printArg<uint32_t>(P, PC));
10383	break;
10384	case OP_CastIntegralFloatingFixedPoint:
10385	Text.Op = PrintName("CastIntegralFloatingFixedPoint");
10386	Text.Args.push_back(printArg<const llvm::fltSemantics *>(P, PC));
10387	Text.Args.push_back(printArg<uint32_t>(P, PC));
10388	break;
10389	#endif
10390	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10391	bool emitCastIntegralFloatingSint8( const llvm::fltSemantics * , uint32_t , SourceInfo);
10392	bool emitCastIntegralFloatingUint8( const llvm::fltSemantics * , uint32_t , SourceInfo);
10393	bool emitCastIntegralFloatingSint16( const llvm::fltSemantics * , uint32_t , SourceInfo);
10394	bool emitCastIntegralFloatingUint16( const llvm::fltSemantics * , uint32_t , SourceInfo);
10395	bool emitCastIntegralFloatingSint32( const llvm::fltSemantics * , uint32_t , SourceInfo);
10396	bool emitCastIntegralFloatingUint32( const llvm::fltSemantics * , uint32_t , SourceInfo);
10397	bool emitCastIntegralFloatingSint64( const llvm::fltSemantics * , uint32_t , SourceInfo);
10398	bool emitCastIntegralFloatingUint64( const llvm::fltSemantics * , uint32_t , SourceInfo);
10399	bool emitCastIntegralFloatingIntAP( const llvm::fltSemantics * , uint32_t , SourceInfo);
10400	bool emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * , uint32_t , SourceInfo);
10401	bool emitCastIntegralFloatingBool( const llvm::fltSemantics * , uint32_t , SourceInfo);
10402	bool emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * , uint32_t , SourceInfo);
10403	#endif
10404	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10405	[[nodiscard]] bool emitCastIntegralFloating(PrimType, const llvm::fltSemantics *, uint32_t, SourceInfo I);
10406	#endif
10407	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
10408	bool
10409	#if defined(GET_EVAL_IMPL)
10410	EvalEmitter
10411	#else
10412	ByteCodeEmitter
10413	#endif
10414	::emitCastIntegralFloating(PrimType T0, const llvm::fltSemantics * A0, uint32_t A1, SourceInfo I) {
10415	switch (T0) {
10416	case PT_Sint8:
10417	return emitCastIntegralFloatingSint8(A0, A1, I);
10418	case PT_Uint8:
10419	return emitCastIntegralFloatingUint8(A0, A1, I);
10420	case PT_Sint16:
10421	return emitCastIntegralFloatingSint16(A0, A1, I);
10422	case PT_Uint16:
10423	return emitCastIntegralFloatingUint16(A0, A1, I);
10424	case PT_Sint32:
10425	return emitCastIntegralFloatingSint32(A0, A1, I);
10426	case PT_Uint32:
10427	return emitCastIntegralFloatingUint32(A0, A1, I);
10428	case PT_Sint64:
10429	return emitCastIntegralFloatingSint64(A0, A1, I);
10430	case PT_Uint64:
10431	return emitCastIntegralFloatingUint64(A0, A1, I);
10432	case PT_IntAP:
10433	return emitCastIntegralFloatingIntAP(A0, A1, I);
10434	case PT_IntAPS:
10435	return emitCastIntegralFloatingIntAPS(A0, A1, I);
10436	case PT_Bool:
10437	return emitCastIntegralFloatingBool(A0, A1, I);
10438	case PT_FixedPoint:
10439	return emitCastIntegralFloatingFixedPoint(A0, A1, I);
10440	default: llvm_unreachable("invalid type: emitCastIntegralFloating");
10441	}
10442	llvm_unreachable("invalid enum value");
10443	}
10444	#endif
10445	#ifdef GET_LINK_IMPL
10446	bool ByteCodeEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10447	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint8, A0, A1, L);
10448	}
10449	bool ByteCodeEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10450	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint8, A0, A1, L);
10451	}
10452	bool ByteCodeEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10453	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint16, A0, A1, L);
10454	}
10455	bool ByteCodeEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10456	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint16, A0, A1, L);
10457	}
10458	bool ByteCodeEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10459	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint32, A0, A1, L);
10460	}
10461	bool ByteCodeEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10462	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint32, A0, A1, L);
10463	}
10464	bool ByteCodeEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10465	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint64, A0, A1, L);
10466	}
10467	bool ByteCodeEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10468	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint64, A0, A1, L);
10469	}
10470	bool ByteCodeEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10471	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingIntAP, A0, A1, L);
10472	}
10473	bool ByteCodeEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10474	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingIntAPS, A0, A1, L);
10475	}
10476	bool ByteCodeEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10477	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingBool, A0, A1, L);
10478	}
10479	bool ByteCodeEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10480	return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingFixedPoint, A0, A1, L);
10481	}
10482	#endif
10483	#ifdef GET_EVAL_IMPL
10484	bool EvalEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10485	if (!isActive()) return true;
10486	CurrentSource = L;
10487	return CastIntegralFloating<PT_Sint8>(S, CodePtr(), A0, A1);
10488	}
10489	bool EvalEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10490	if (!isActive()) return true;
10491	CurrentSource = L;
10492	return CastIntegralFloating<PT_Uint8>(S, CodePtr(), A0, A1);
10493	}
10494	bool EvalEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10495	if (!isActive()) return true;
10496	CurrentSource = L;
10497	return CastIntegralFloating<PT_Sint16>(S, CodePtr(), A0, A1);
10498	}
10499	bool EvalEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10500	if (!isActive()) return true;
10501	CurrentSource = L;
10502	return CastIntegralFloating<PT_Uint16>(S, CodePtr(), A0, A1);
10503	}
10504	bool EvalEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10505	if (!isActive()) return true;
10506	CurrentSource = L;
10507	return CastIntegralFloating<PT_Sint32>(S, CodePtr(), A0, A1);
10508	}
10509	bool EvalEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10510	if (!isActive()) return true;
10511	CurrentSource = L;
10512	return CastIntegralFloating<PT_Uint32>(S, CodePtr(), A0, A1);
10513	}
10514	bool EvalEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10515	if (!isActive()) return true;
10516	CurrentSource = L;
10517	return CastIntegralFloating<PT_Sint64>(S, CodePtr(), A0, A1);
10518	}
10519	bool EvalEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10520	if (!isActive()) return true;
10521	CurrentSource = L;
10522	return CastIntegralFloating<PT_Uint64>(S, CodePtr(), A0, A1);
10523	}
10524	bool EvalEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10525	if (!isActive()) return true;
10526	CurrentSource = L;
10527	return CastIntegralFloating<PT_IntAP>(S, CodePtr(), A0, A1);
10528	}
10529	bool EvalEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10530	if (!isActive()) return true;
10531	CurrentSource = L;
10532	return CastIntegralFloating<PT_IntAPS>(S, CodePtr(), A0, A1);
10533	}
10534	bool EvalEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10535	if (!isActive()) return true;
10536	CurrentSource = L;
10537	return CastIntegralFloating<PT_Bool>(S, CodePtr(), A0, A1);
10538	}
10539	bool EvalEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10540	if (!isActive()) return true;
10541	CurrentSource = L;
10542	return CastIntegralFloating<PT_FixedPoint>(S, CodePtr(), A0, A1);
10543	}
10544	#endif
10545	#ifdef GET_OPCODE_NAMES
10546	OP_CastMemberPtrBasePop,
10547	#endif
10548	#ifdef GET_INTERPFN_LIST
10549	&Interp_CastMemberPtrBasePop,
10550	#endif
10551	#ifdef GET_INTERPFN_DISPATCHERS
10552	PRESERVE_NONE
10553	static bool Interp_CastMemberPtrBasePop(InterpState &S) {
10554	{
10555	const auto V0 = ReadArg<int32_t>(S, S.PC);
10556	const auto V1 = ReadArg<const RecordDecl *>(S, S.PC);
10557	if (!CastMemberPtrBasePop(S, V0, V1)) return false;
10558	}
10559	#if USE_TAILCALLS
10560	MUSTTAIL return InterpNext(S);
10561	#else
10562	return true;
10563	#endif
10564	}
10565	#endif
10566	#ifdef GET_DISASM
10567	case OP_CastMemberPtrBasePop:
10568	Text.Op = PrintName("CastMemberPtrBasePop");
10569	Text.Args.push_back(printArg<int32_t>(P, PC));
10570	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
10571	break;
10572	#endif
10573	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10574	bool emitCastMemberPtrBasePop( int32_t , const RecordDecl * , SourceInfo);
10575	#endif
10576	#ifdef GET_LINK_IMPL
10577	bool ByteCodeEmitter::emitCastMemberPtrBasePop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10578	return emitOp<int32_t, const RecordDecl *>(OP_CastMemberPtrBasePop, A0, A1, L);
10579	}
10580	#endif
10581	#ifdef GET_EVAL_IMPL
10582	bool EvalEmitter::emitCastMemberPtrBasePop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10583	if (!isActive()) return true;
10584	CurrentSource = L;
10585	return CastMemberPtrBasePop(S, A0, A1);
10586	}
10587	#endif
10588	#ifdef GET_OPCODE_NAMES
10589	OP_CastMemberPtrDerivedPop,
10590	#endif
10591	#ifdef GET_INTERPFN_LIST
10592	&Interp_CastMemberPtrDerivedPop,
10593	#endif
10594	#ifdef GET_INTERPFN_DISPATCHERS
10595	PRESERVE_NONE
10596	static bool Interp_CastMemberPtrDerivedPop(InterpState &S) {
10597	{
10598	const auto V0 = ReadArg<int32_t>(S, S.PC);
10599	const auto V1 = ReadArg<const RecordDecl *>(S, S.PC);
10600	if (!CastMemberPtrDerivedPop(S, V0, V1)) return false;
10601	}
10602	#if USE_TAILCALLS
10603	MUSTTAIL return InterpNext(S);
10604	#else
10605	return true;
10606	#endif
10607	}
10608	#endif
10609	#ifdef GET_DISASM
10610	case OP_CastMemberPtrDerivedPop:
10611	Text.Op = PrintName("CastMemberPtrDerivedPop");
10612	Text.Args.push_back(printArg<int32_t>(P, PC));
10613	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
10614	break;
10615	#endif
10616	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10617	bool emitCastMemberPtrDerivedPop( int32_t , const RecordDecl * , SourceInfo);
10618	#endif
10619	#ifdef GET_LINK_IMPL
10620	bool ByteCodeEmitter::emitCastMemberPtrDerivedPop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10621	return emitOp<int32_t, const RecordDecl *>(OP_CastMemberPtrDerivedPop, A0, A1, L);
10622	}
10623	#endif
10624	#ifdef GET_EVAL_IMPL
10625	bool EvalEmitter::emitCastMemberPtrDerivedPop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10626	if (!isActive()) return true;
10627	CurrentSource = L;
10628	return CastMemberPtrDerivedPop(S, A0, A1);
10629	}
10630	#endif
10631	#ifdef GET_OPCODE_NAMES
10632	OP_CastMemberPtrPtr,
10633	#endif
10634	#ifdef GET_INTERPFN_LIST
10635	&Interp_CastMemberPtrPtr,
10636	#endif
10637	#ifdef GET_INTERPFN_DISPATCHERS
10638	PRESERVE_NONE
10639	static bool Interp_CastMemberPtrPtr(InterpState &S) {
10640	if (!CastMemberPtrPtr(S, S.PC)) return false;
10641	#if USE_TAILCALLS
10642	MUSTTAIL return InterpNext(S);
10643	#else
10644	return true;
10645	#endif
10646	}
10647	#endif
10648	#ifdef GET_DISASM
10649	case OP_CastMemberPtrPtr:
10650	Text.Op = PrintName("CastMemberPtrPtr");
10651	break;
10652	#endif
10653	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10654	bool emitCastMemberPtrPtr(SourceInfo);
10655	#endif
10656	#ifdef GET_LINK_IMPL
10657	bool ByteCodeEmitter::emitCastMemberPtrPtr(SourceInfo L) {
10658	return emitOp<>(OP_CastMemberPtrPtr, L);
10659	}
10660	#endif
10661	#ifdef GET_EVAL_IMPL
10662	bool EvalEmitter::emitCastMemberPtrPtr(SourceInfo L) {
10663	if (!isActive()) return true;
10664	CurrentSource = L;
10665	return CastMemberPtrPtr(S, CodePtr());
10666	}
10667	#endif
10668	#ifdef GET_OPCODE_NAMES
10669	OP_CastNoOverflowIntAP,
10670	OP_CastNoOverflowIntAPS,
10671	#endif
10672	#ifdef GET_INTERPFN_LIST
10673	&Interp_CastNoOverflowIntAP,
10674	&Interp_CastNoOverflowIntAPS,
10675	#endif
10676	#ifdef GET_INTERPFN_DISPATCHERS
10677	PRESERVE_NONE
10678	static bool Interp_CastNoOverflowIntAP(InterpState &S) {
10679	if (!CastNoOverflow<PT_IntAP>(S, S.PC)) return false;
10680	#if USE_TAILCALLS
10681	MUSTTAIL return InterpNext(S);
10682	#else
10683	return true;
10684	#endif
10685	}
10686	PRESERVE_NONE
10687	static bool Interp_CastNoOverflowIntAPS(InterpState &S) {
10688	if (!CastNoOverflow<PT_IntAPS>(S, S.PC)) return false;
10689	#if USE_TAILCALLS
10690	MUSTTAIL return InterpNext(S);
10691	#else
10692	return true;
10693	#endif
10694	}
10695	#endif
10696	#ifdef GET_DISASM
10697	case OP_CastNoOverflowIntAP:
10698	Text.Op = PrintName("CastNoOverflowIntAP");
10699	break;
10700	case OP_CastNoOverflowIntAPS:
10701	Text.Op = PrintName("CastNoOverflowIntAPS");
10702	break;
10703	#endif
10704	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10705	bool emitCastNoOverflowIntAP(SourceInfo);
10706	bool emitCastNoOverflowIntAPS(SourceInfo);
10707	#endif
10708	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10709	[[nodiscard]] bool emitCastNoOverflow(PrimType, SourceInfo I);
10710	#endif
10711	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
10712	bool
10713	#if defined(GET_EVAL_IMPL)
10714	EvalEmitter
10715	#else
10716	ByteCodeEmitter
10717	#endif
10718	::emitCastNoOverflow(PrimType T0, SourceInfo I) {
10719	switch (T0) {
10720	case PT_IntAP:
10721	return emitCastNoOverflowIntAP(I);
10722	case PT_IntAPS:
10723	return emitCastNoOverflowIntAPS(I);
10724	default: llvm_unreachable("invalid type: emitCastNoOverflow");
10725	}
10726	llvm_unreachable("invalid enum value");
10727	}
10728	#endif
10729	#ifdef GET_LINK_IMPL
10730	bool ByteCodeEmitter::emitCastNoOverflowIntAP(SourceInfo L) {
10731	return emitOp<>(OP_CastNoOverflowIntAP, L);
10732	}
10733	bool ByteCodeEmitter::emitCastNoOverflowIntAPS(SourceInfo L) {
10734	return emitOp<>(OP_CastNoOverflowIntAPS, L);
10735	}
10736	#endif
10737	#ifdef GET_EVAL_IMPL
10738	bool EvalEmitter::emitCastNoOverflowIntAP(SourceInfo L) {
10739	if (!isActive()) return true;
10740	CurrentSource = L;
10741	return CastNoOverflow<PT_IntAP>(S, CodePtr());
10742	}
10743	bool EvalEmitter::emitCastNoOverflowIntAPS(SourceInfo L) {
10744	if (!isActive()) return true;
10745	CurrentSource = L;
10746	return CastNoOverflow<PT_IntAPS>(S, CodePtr());
10747	}
10748	#endif
10749	#ifdef GET_OPCODE_NAMES
10750	OP_CastPointerIntegralSint8,
10751	OP_CastPointerIntegralUint8,
10752	OP_CastPointerIntegralSint16,
10753	OP_CastPointerIntegralUint16,
10754	OP_CastPointerIntegralSint32,
10755	OP_CastPointerIntegralUint32,
10756	OP_CastPointerIntegralSint64,
10757	OP_CastPointerIntegralUint64,
10758	OP_CastPointerIntegralBool,
10759	#endif
10760	#ifdef GET_INTERPFN_LIST
10761	&Interp_CastPointerIntegralSint8,
10762	&Interp_CastPointerIntegralUint8,
10763	&Interp_CastPointerIntegralSint16,
10764	&Interp_CastPointerIntegralUint16,
10765	&Interp_CastPointerIntegralSint32,
10766	&Interp_CastPointerIntegralUint32,
10767	&Interp_CastPointerIntegralSint64,
10768	&Interp_CastPointerIntegralUint64,
10769	&Interp_CastPointerIntegralBool,
10770	#endif
10771	#ifdef GET_INTERPFN_DISPATCHERS
10772	PRESERVE_NONE
10773	static bool Interp_CastPointerIntegralSint8(InterpState &S) {
10774	if (!CastPointerIntegral<PT_Sint8>(S, S.PC)) return false;
10775	#if USE_TAILCALLS
10776	MUSTTAIL return InterpNext(S);
10777	#else
10778	return true;
10779	#endif
10780	}
10781	PRESERVE_NONE
10782	static bool Interp_CastPointerIntegralUint8(InterpState &S) {
10783	if (!CastPointerIntegral<PT_Uint8>(S, S.PC)) return false;
10784	#if USE_TAILCALLS
10785	MUSTTAIL return InterpNext(S);
10786	#else
10787	return true;
10788	#endif
10789	}
10790	PRESERVE_NONE
10791	static bool Interp_CastPointerIntegralSint16(InterpState &S) {
10792	if (!CastPointerIntegral<PT_Sint16>(S, S.PC)) return false;
10793	#if USE_TAILCALLS
10794	MUSTTAIL return InterpNext(S);
10795	#else
10796	return true;
10797	#endif
10798	}
10799	PRESERVE_NONE
10800	static bool Interp_CastPointerIntegralUint16(InterpState &S) {
10801	if (!CastPointerIntegral<PT_Uint16>(S, S.PC)) return false;
10802	#if USE_TAILCALLS
10803	MUSTTAIL return InterpNext(S);
10804	#else
10805	return true;
10806	#endif
10807	}
10808	PRESERVE_NONE
10809	static bool Interp_CastPointerIntegralSint32(InterpState &S) {
10810	if (!CastPointerIntegral<PT_Sint32>(S, S.PC)) return false;
10811	#if USE_TAILCALLS
10812	MUSTTAIL return InterpNext(S);
10813	#else
10814	return true;
10815	#endif
10816	}
10817	PRESERVE_NONE
10818	static bool Interp_CastPointerIntegralUint32(InterpState &S) {
10819	if (!CastPointerIntegral<PT_Uint32>(S, S.PC)) return false;
10820	#if USE_TAILCALLS
10821	MUSTTAIL return InterpNext(S);
10822	#else
10823	return true;
10824	#endif
10825	}
10826	PRESERVE_NONE
10827	static bool Interp_CastPointerIntegralSint64(InterpState &S) {
10828	if (!CastPointerIntegral<PT_Sint64>(S, S.PC)) return false;
10829	#if USE_TAILCALLS
10830	MUSTTAIL return InterpNext(S);
10831	#else
10832	return true;
10833	#endif
10834	}
10835	PRESERVE_NONE
10836	static bool Interp_CastPointerIntegralUint64(InterpState &S) {
10837	if (!CastPointerIntegral<PT_Uint64>(S, S.PC)) return false;
10838	#if USE_TAILCALLS
10839	MUSTTAIL return InterpNext(S);
10840	#else
10841	return true;
10842	#endif
10843	}
10844	PRESERVE_NONE
10845	static bool Interp_CastPointerIntegralBool(InterpState &S) {
10846	if (!CastPointerIntegral<PT_Bool>(S, S.PC)) return false;
10847	#if USE_TAILCALLS
10848	MUSTTAIL return InterpNext(S);
10849	#else
10850	return true;
10851	#endif
10852	}
10853	#endif
10854	#ifdef GET_DISASM
10855	case OP_CastPointerIntegralSint8:
10856	Text.Op = PrintName("CastPointerIntegralSint8");
10857	break;
10858	case OP_CastPointerIntegralUint8:
10859	Text.Op = PrintName("CastPointerIntegralUint8");
10860	break;
10861	case OP_CastPointerIntegralSint16:
10862	Text.Op = PrintName("CastPointerIntegralSint16");
10863	break;
10864	case OP_CastPointerIntegralUint16:
10865	Text.Op = PrintName("CastPointerIntegralUint16");
10866	break;
10867	case OP_CastPointerIntegralSint32:
10868	Text.Op = PrintName("CastPointerIntegralSint32");
10869	break;
10870	case OP_CastPointerIntegralUint32:
10871	Text.Op = PrintName("CastPointerIntegralUint32");
10872	break;
10873	case OP_CastPointerIntegralSint64:
10874	Text.Op = PrintName("CastPointerIntegralSint64");
10875	break;
10876	case OP_CastPointerIntegralUint64:
10877	Text.Op = PrintName("CastPointerIntegralUint64");
10878	break;
10879	case OP_CastPointerIntegralBool:
10880	Text.Op = PrintName("CastPointerIntegralBool");
10881	break;
10882	#endif
10883	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10884	bool emitCastPointerIntegralSint8(SourceInfo);
10885	bool emitCastPointerIntegralUint8(SourceInfo);
10886	bool emitCastPointerIntegralSint16(SourceInfo);
10887	bool emitCastPointerIntegralUint16(SourceInfo);
10888	bool emitCastPointerIntegralSint32(SourceInfo);
10889	bool emitCastPointerIntegralUint32(SourceInfo);
10890	bool emitCastPointerIntegralSint64(SourceInfo);
10891	bool emitCastPointerIntegralUint64(SourceInfo);
10892	bool emitCastPointerIntegralBool(SourceInfo);
10893	#endif
10894	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
10895	[[nodiscard]] bool emitCastPointerIntegral(PrimType, SourceInfo I);
10896	#endif
10897	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
10898	bool
10899	#if defined(GET_EVAL_IMPL)
10900	EvalEmitter
10901	#else
10902	ByteCodeEmitter
10903	#endif
10904	::emitCastPointerIntegral(PrimType T0, SourceInfo I) {
10905	switch (T0) {
10906	case PT_Sint8:
10907	return emitCastPointerIntegralSint8(I);
10908	case PT_Uint8:
10909	return emitCastPointerIntegralUint8(I);
10910	case PT_Sint16:
10911	return emitCastPointerIntegralSint16(I);
10912	case PT_Uint16:
10913	return emitCastPointerIntegralUint16(I);
10914	case PT_Sint32:
10915	return emitCastPointerIntegralSint32(I);
10916	case PT_Uint32:
10917	return emitCastPointerIntegralUint32(I);
10918	case PT_Sint64:
10919	return emitCastPointerIntegralSint64(I);
10920	case PT_Uint64:
10921	return emitCastPointerIntegralUint64(I);
10922	case PT_Bool:
10923	return emitCastPointerIntegralBool(I);
10924	default: llvm_unreachable("invalid type: emitCastPointerIntegral");
10925	}
10926	llvm_unreachable("invalid enum value");
10927	}
10928	#endif
10929	#ifdef GET_LINK_IMPL
10930	bool ByteCodeEmitter::emitCastPointerIntegralSint8(SourceInfo L) {
10931	return emitOp<>(OP_CastPointerIntegralSint8, L);
10932	}
10933	bool ByteCodeEmitter::emitCastPointerIntegralUint8(SourceInfo L) {
10934	return emitOp<>(OP_CastPointerIntegralUint8, L);
10935	}
10936	bool ByteCodeEmitter::emitCastPointerIntegralSint16(SourceInfo L) {
10937	return emitOp<>(OP_CastPointerIntegralSint16, L);
10938	}
10939	bool ByteCodeEmitter::emitCastPointerIntegralUint16(SourceInfo L) {
10940	return emitOp<>(OP_CastPointerIntegralUint16, L);
10941	}
10942	bool ByteCodeEmitter::emitCastPointerIntegralSint32(SourceInfo L) {
10943	return emitOp<>(OP_CastPointerIntegralSint32, L);
10944	}
10945	bool ByteCodeEmitter::emitCastPointerIntegralUint32(SourceInfo L) {
10946	return emitOp<>(OP_CastPointerIntegralUint32, L);
10947	}
10948	bool ByteCodeEmitter::emitCastPointerIntegralSint64(SourceInfo L) {
10949	return emitOp<>(OP_CastPointerIntegralSint64, L);
10950	}
10951	bool ByteCodeEmitter::emitCastPointerIntegralUint64(SourceInfo L) {
10952	return emitOp<>(OP_CastPointerIntegralUint64, L);
10953	}
10954	bool ByteCodeEmitter::emitCastPointerIntegralBool(SourceInfo L) {
10955	return emitOp<>(OP_CastPointerIntegralBool, L);
10956	}
10957	#endif
10958	#ifdef GET_EVAL_IMPL
10959	bool EvalEmitter::emitCastPointerIntegralSint8(SourceInfo L) {
10960	if (!isActive()) return true;
10961	CurrentSource = L;
10962	return CastPointerIntegral<PT_Sint8>(S, CodePtr());
10963	}
10964	bool EvalEmitter::emitCastPointerIntegralUint8(SourceInfo L) {
10965	if (!isActive()) return true;
10966	CurrentSource = L;
10967	return CastPointerIntegral<PT_Uint8>(S, CodePtr());
10968	}
10969	bool EvalEmitter::emitCastPointerIntegralSint16(SourceInfo L) {
10970	if (!isActive()) return true;
10971	CurrentSource = L;
10972	return CastPointerIntegral<PT_Sint16>(S, CodePtr());
10973	}
10974	bool EvalEmitter::emitCastPointerIntegralUint16(SourceInfo L) {
10975	if (!isActive()) return true;
10976	CurrentSource = L;
10977	return CastPointerIntegral<PT_Uint16>(S, CodePtr());
10978	}
10979	bool EvalEmitter::emitCastPointerIntegralSint32(SourceInfo L) {
10980	if (!isActive()) return true;
10981	CurrentSource = L;
10982	return CastPointerIntegral<PT_Sint32>(S, CodePtr());
10983	}
10984	bool EvalEmitter::emitCastPointerIntegralUint32(SourceInfo L) {
10985	if (!isActive()) return true;
10986	CurrentSource = L;
10987	return CastPointerIntegral<PT_Uint32>(S, CodePtr());
10988	}
10989	bool EvalEmitter::emitCastPointerIntegralSint64(SourceInfo L) {
10990	if (!isActive()) return true;
10991	CurrentSource = L;
10992	return CastPointerIntegral<PT_Sint64>(S, CodePtr());
10993	}
10994	bool EvalEmitter::emitCastPointerIntegralUint64(SourceInfo L) {
10995	if (!isActive()) return true;
10996	CurrentSource = L;
10997	return CastPointerIntegral<PT_Uint64>(S, CodePtr());
10998	}
10999	bool EvalEmitter::emitCastPointerIntegralBool(SourceInfo L) {
11000	if (!isActive()) return true;
11001	CurrentSource = L;
11002	return CastPointerIntegral<PT_Bool>(S, CodePtr());
11003	}
11004	#endif
11005	#ifdef GET_OPCODE_NAMES
11006	OP_CastPointerIntegralAP,
11007	#endif
11008	#ifdef GET_INTERPFN_LIST
11009	&Interp_CastPointerIntegralAP,
11010	#endif
11011	#ifdef GET_INTERPFN_DISPATCHERS
11012	PRESERVE_NONE
11013	static bool Interp_CastPointerIntegralAP(InterpState &S) {
11014	{
11015	CodePtr OpPC = S.PC;
11016	const auto V0 = ReadArg<uint32_t>(S, S.PC);
11017	if (!CastPointerIntegralAP(S, OpPC, V0)) return false;
11018	}
11019	#if USE_TAILCALLS
11020	MUSTTAIL return InterpNext(S);
11021	#else
11022	return true;
11023	#endif
11024	}
11025	#endif
11026	#ifdef GET_DISASM
11027	case OP_CastPointerIntegralAP:
11028	Text.Op = PrintName("CastPointerIntegralAP");
11029	Text.Args.push_back(printArg<uint32_t>(P, PC));
11030	break;
11031	#endif
11032	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11033	bool emitCastPointerIntegralAP( uint32_t , SourceInfo);
11034	#endif
11035	#ifdef GET_LINK_IMPL
11036	bool ByteCodeEmitter::emitCastPointerIntegralAP( uint32_t A0, SourceInfo L) {
11037	return emitOp<uint32_t>(OP_CastPointerIntegralAP, A0, L);
11038	}
11039	#endif
11040	#ifdef GET_EVAL_IMPL
11041	bool EvalEmitter::emitCastPointerIntegralAP( uint32_t A0, SourceInfo L) {
11042	if (!isActive()) return true;
11043	CurrentSource = L;
11044	return CastPointerIntegralAP(S, CodePtr(), A0);
11045	}
11046	#endif
11047	#ifdef GET_OPCODE_NAMES
11048	OP_CastPointerIntegralAPS,
11049	#endif
11050	#ifdef GET_INTERPFN_LIST
11051	&Interp_CastPointerIntegralAPS,
11052	#endif
11053	#ifdef GET_INTERPFN_DISPATCHERS
11054	PRESERVE_NONE
11055	static bool Interp_CastPointerIntegralAPS(InterpState &S) {
11056	{
11057	CodePtr OpPC = S.PC;
11058	const auto V0 = ReadArg<uint32_t>(S, S.PC);
11059	if (!CastPointerIntegralAPS(S, OpPC, V0)) return false;
11060	}
11061	#if USE_TAILCALLS
11062	MUSTTAIL return InterpNext(S);
11063	#else
11064	return true;
11065	#endif
11066	}
11067	#endif
11068	#ifdef GET_DISASM
11069	case OP_CastPointerIntegralAPS:
11070	Text.Op = PrintName("CastPointerIntegralAPS");
11071	Text.Args.push_back(printArg<uint32_t>(P, PC));
11072	break;
11073	#endif
11074	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11075	bool emitCastPointerIntegralAPS( uint32_t , SourceInfo);
11076	#endif
11077	#ifdef GET_LINK_IMPL
11078	bool ByteCodeEmitter::emitCastPointerIntegralAPS( uint32_t A0, SourceInfo L) {
11079	return emitOp<uint32_t>(OP_CastPointerIntegralAPS, A0, L);
11080	}
11081	#endif
11082	#ifdef GET_EVAL_IMPL
11083	bool EvalEmitter::emitCastPointerIntegralAPS( uint32_t A0, SourceInfo L) {
11084	if (!isActive()) return true;
11085	CurrentSource = L;
11086	return CastPointerIntegralAPS(S, CodePtr(), A0);
11087	}
11088	#endif
11089	#ifdef GET_OPCODE_NAMES
11090	OP_CheckAllocations,
11091	#endif
11092	#ifdef GET_INTERPFN_LIST
11093	&Interp_CheckAllocations,
11094	#endif
11095	#ifdef GET_INTERPFN_DISPATCHERS
11096	PRESERVE_NONE
11097	static bool Interp_CheckAllocations(InterpState &S) {
11098	if (!CheckAllocations(S)) return false;
11099	#if USE_TAILCALLS
11100	MUSTTAIL return InterpNext(S);
11101	#else
11102	return true;
11103	#endif
11104	}
11105	#endif
11106	#ifdef GET_DISASM
11107	case OP_CheckAllocations:
11108	Text.Op = PrintName("CheckAllocations");
11109	break;
11110	#endif
11111	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11112	bool emitCheckAllocations(SourceInfo);
11113	#endif
11114	#ifdef GET_LINK_IMPL
11115	bool ByteCodeEmitter::emitCheckAllocations(SourceInfo L) {
11116	return emitOp<>(OP_CheckAllocations, L);
11117	}
11118	#endif
11119	#ifdef GET_EVAL_IMPL
11120	bool EvalEmitter::emitCheckAllocations(SourceInfo L) {
11121	if (!isActive()) return true;
11122	CurrentSource = L;
11123	return CheckAllocations(S);
11124	}
11125	#endif
11126	#ifdef GET_OPCODE_NAMES
11127	OP_CheckArrayDestSize,
11128	#endif
11129	#ifdef GET_INTERPFN_LIST
11130	&Interp_CheckArrayDestSize,
11131	#endif
11132	#ifdef GET_INTERPFN_DISPATCHERS
11133	PRESERVE_NONE
11134	static bool Interp_CheckArrayDestSize(InterpState &S) {
11135	{
11136	CodePtr OpPC = S.PC;
11137	const auto V0 = ReadArg<uint64_t>(S, S.PC);
11138	if (!CheckArrayDestSize(S, OpPC, V0)) return false;
11139	}
11140	#if USE_TAILCALLS
11141	MUSTTAIL return InterpNext(S);
11142	#else
11143	return true;
11144	#endif
11145	}
11146	#endif
11147	#ifdef GET_DISASM
11148	case OP_CheckArrayDestSize:
11149	Text.Op = PrintName("CheckArrayDestSize");
11150	Text.Args.push_back(printArg<uint64_t>(P, PC));
11151	break;
11152	#endif
11153	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11154	bool emitCheckArrayDestSize( uint64_t , SourceInfo);
11155	#endif
11156	#ifdef GET_LINK_IMPL
11157	bool ByteCodeEmitter::emitCheckArrayDestSize( uint64_t A0, SourceInfo L) {
11158	return emitOp<uint64_t>(OP_CheckArrayDestSize, A0, L);
11159	}
11160	#endif
11161	#ifdef GET_EVAL_IMPL
11162	bool EvalEmitter::emitCheckArrayDestSize( uint64_t A0, SourceInfo L) {
11163	if (!isActive()) return true;
11164	CurrentSource = L;
11165	return CheckArrayDestSize(S, CodePtr(), A0);
11166	}
11167	#endif
11168	#ifdef GET_OPCODE_NAMES
11169	OP_CheckArraySize,
11170	#endif
11171	#ifdef GET_INTERPFN_LIST
11172	&Interp_CheckArraySize,
11173	#endif
11174	#ifdef GET_INTERPFN_DISPATCHERS
11175	PRESERVE_NONE
11176	static bool Interp_CheckArraySize(InterpState &S) {
11177	{
11178	CodePtr OpPC = S.PC;
11179	const auto V0 = ReadArg<uint64_t>(S, S.PC);
11180	if (!CheckArraySize(S, OpPC, V0)) return false;
11181	}
11182	#if USE_TAILCALLS
11183	MUSTTAIL return InterpNext(S);
11184	#else
11185	return true;
11186	#endif
11187	}
11188	#endif
11189	#ifdef GET_DISASM
11190	case OP_CheckArraySize:
11191	Text.Op = PrintName("CheckArraySize");
11192	Text.Args.push_back(printArg<uint64_t>(P, PC));
11193	break;
11194	#endif
11195	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11196	bool emitCheckArraySize( uint64_t , SourceInfo);
11197	#endif
11198	#ifdef GET_LINK_IMPL
11199	bool ByteCodeEmitter::emitCheckArraySize( uint64_t A0, SourceInfo L) {
11200	return emitOp<uint64_t>(OP_CheckArraySize, A0, L);
11201	}
11202	#endif
11203	#ifdef GET_EVAL_IMPL
11204	bool EvalEmitter::emitCheckArraySize( uint64_t A0, SourceInfo L) {
11205	if (!isActive()) return true;
11206	CurrentSource = L;
11207	return CheckArraySize(S, CodePtr(), A0);
11208	}
11209	#endif
11210	#ifdef GET_OPCODE_NAMES
11211	OP_CheckBitCast,
11212	#endif
11213	#ifdef GET_INTERPFN_LIST
11214	&Interp_CheckBitCast,
11215	#endif
11216	#ifdef GET_INTERPFN_DISPATCHERS
11217	PRESERVE_NONE
11218	static bool Interp_CheckBitCast(InterpState &S) {
11219	{
11220	CodePtr OpPC = S.PC;
11221	const auto V0 = ReadArg<const Type *>(S, S.PC);
11222	const auto V1 = ReadArg<bool>(S, S.PC);
11223	if (!CheckBitCast(S, OpPC, V0, V1)) return false;
11224	}
11225	#if USE_TAILCALLS
11226	MUSTTAIL return InterpNext(S);
11227	#else
11228	return true;
11229	#endif
11230	}
11231	#endif
11232	#ifdef GET_DISASM
11233	case OP_CheckBitCast:
11234	Text.Op = PrintName("CheckBitCast");
11235	Text.Args.push_back(printArg<const Type *>(P, PC));
11236	Text.Args.push_back(printArg<bool>(P, PC));
11237	break;
11238	#endif
11239	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11240	bool emitCheckBitCast( const Type * , bool , SourceInfo);
11241	#endif
11242	#ifdef GET_LINK_IMPL
11243	bool ByteCodeEmitter::emitCheckBitCast( const Type * A0, bool A1, SourceInfo L) {
11244	return emitOp<const Type , bool*>(OP_CheckBitCast, A0, A1, L);
11245	}
11246	#endif
11247	#ifdef GET_EVAL_IMPL
11248	bool EvalEmitter::emitCheckBitCast( const Type * A0, bool A1, SourceInfo L) {
11249	if (!isActive()) return true;
11250	CurrentSource = L;
11251	return CheckBitCast(S, CodePtr(), A0, A1);
11252	}
11253	#endif
11254	#ifdef GET_OPCODE_NAMES
11255	OP_CheckDecl,
11256	#endif
11257	#ifdef GET_INTERPFN_LIST
11258	&Interp_CheckDecl,
11259	#endif
11260	#ifdef GET_INTERPFN_DISPATCHERS
11261	PRESERVE_NONE
11262	static bool Interp_CheckDecl(InterpState &S) {
11263	{
11264	const auto V0 = ReadArg<const VarDecl*>(S, S.PC);
11265	if (!CheckDecl(S, V0)) return false;
11266	}
11267	#if USE_TAILCALLS
11268	MUSTTAIL return InterpNext(S);
11269	#else
11270	return true;
11271	#endif
11272	}
11273	#endif
11274	#ifdef GET_DISASM
11275	case OP_CheckDecl:
11276	Text.Op = PrintName("CheckDecl");
11277	Text.Args.push_back(printArg<const VarDecl*>(P, PC));
11278	break;
11279	#endif
11280	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11281	bool emitCheckDecl( const VarDecl* , SourceInfo);
11282	#endif
11283	#ifdef GET_LINK_IMPL
11284	bool ByteCodeEmitter::emitCheckDecl( const VarDecl* A0, SourceInfo L) {
11285	return emitOp<const VarDecl*>(OP_CheckDecl, A0, L);
11286	}
11287	#endif
11288	#ifdef GET_EVAL_IMPL
11289	bool EvalEmitter::emitCheckDecl( const VarDecl* A0, SourceInfo L) {
11290	if (!isActive()) return true;
11291	CurrentSource = L;
11292	return CheckDecl(S, A0);
11293	}
11294	#endif
11295	#ifdef GET_OPCODE_NAMES
11296	OP_CheckDestruction,
11297	#endif
11298	#ifdef GET_INTERPFN_LIST
11299	&Interp_CheckDestruction,
11300	#endif
11301	#ifdef GET_INTERPFN_DISPATCHERS
11302	PRESERVE_NONE
11303	static bool Interp_CheckDestruction(InterpState &S) {
11304	if (!CheckDestruction(S, S.PC)) return false;
11305	#if USE_TAILCALLS
11306	MUSTTAIL return InterpNext(S);
11307	#else
11308	return true;
11309	#endif
11310	}
11311	#endif
11312	#ifdef GET_DISASM
11313	case OP_CheckDestruction:
11314	Text.Op = PrintName("CheckDestruction");
11315	break;
11316	#endif
11317	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11318	bool emitCheckDestruction(SourceInfo);
11319	#endif
11320	#ifdef GET_LINK_IMPL
11321	bool ByteCodeEmitter::emitCheckDestruction(SourceInfo L) {
11322	return emitOp<>(OP_CheckDestruction, L);
11323	}
11324	#endif
11325	#ifdef GET_EVAL_IMPL
11326	bool EvalEmitter::emitCheckDestruction(SourceInfo L) {
11327	if (!isActive()) return true;
11328	CurrentSource = L;
11329	return CheckDestruction(S, CodePtr());
11330	}
11331	#endif
11332	#ifdef GET_OPCODE_NAMES
11333	OP_CheckEnumValueSint8,
11334	OP_CheckEnumValueUint8,
11335	OP_CheckEnumValueSint16,
11336	OP_CheckEnumValueUint16,
11337	OP_CheckEnumValueSint32,
11338	OP_CheckEnumValueUint32,
11339	OP_CheckEnumValueSint64,
11340	OP_CheckEnumValueUint64,
11341	OP_CheckEnumValueIntAP,
11342	OP_CheckEnumValueIntAPS,
11343	OP_CheckEnumValueBool,
11344	#endif
11345	#ifdef GET_INTERPFN_LIST
11346	&Interp_CheckEnumValueSint8,
11347	&Interp_CheckEnumValueUint8,
11348	&Interp_CheckEnumValueSint16,
11349	&Interp_CheckEnumValueUint16,
11350	&Interp_CheckEnumValueSint32,
11351	&Interp_CheckEnumValueUint32,
11352	&Interp_CheckEnumValueSint64,
11353	&Interp_CheckEnumValueUint64,
11354	&Interp_CheckEnumValueIntAP,
11355	&Interp_CheckEnumValueIntAPS,
11356	&Interp_CheckEnumValueBool,
11357	#endif
11358	#ifdef GET_INTERPFN_DISPATCHERS
11359	PRESERVE_NONE
11360	static bool Interp_CheckEnumValueSint8(InterpState &S) {
11361	{
11362	CodePtr OpPC = S.PC;
11363	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11364	CheckEnumValue<PT_Sint8>(S, OpPC, V0);
11365	}
11366	#if USE_TAILCALLS
11367	MUSTTAIL return InterpNext(S);
11368	#else
11369	return true;
11370	#endif
11371	}
11372	PRESERVE_NONE
11373	static bool Interp_CheckEnumValueUint8(InterpState &S) {
11374	{
11375	CodePtr OpPC = S.PC;
11376	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11377	CheckEnumValue<PT_Uint8>(S, OpPC, V0);
11378	}
11379	#if USE_TAILCALLS
11380	MUSTTAIL return InterpNext(S);
11381	#else
11382	return true;
11383	#endif
11384	}
11385	PRESERVE_NONE
11386	static bool Interp_CheckEnumValueSint16(InterpState &S) {
11387	{
11388	CodePtr OpPC = S.PC;
11389	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11390	CheckEnumValue<PT_Sint16>(S, OpPC, V0);
11391	}
11392	#if USE_TAILCALLS
11393	MUSTTAIL return InterpNext(S);
11394	#else
11395	return true;
11396	#endif
11397	}
11398	PRESERVE_NONE
11399	static bool Interp_CheckEnumValueUint16(InterpState &S) {
11400	{
11401	CodePtr OpPC = S.PC;
11402	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11403	CheckEnumValue<PT_Uint16>(S, OpPC, V0);
11404	}
11405	#if USE_TAILCALLS
11406	MUSTTAIL return InterpNext(S);
11407	#else
11408	return true;
11409	#endif
11410	}
11411	PRESERVE_NONE
11412	static bool Interp_CheckEnumValueSint32(InterpState &S) {
11413	{
11414	CodePtr OpPC = S.PC;
11415	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11416	CheckEnumValue<PT_Sint32>(S, OpPC, V0);
11417	}
11418	#if USE_TAILCALLS
11419	MUSTTAIL return InterpNext(S);
11420	#else
11421	return true;
11422	#endif
11423	}
11424	PRESERVE_NONE
11425	static bool Interp_CheckEnumValueUint32(InterpState &S) {
11426	{
11427	CodePtr OpPC = S.PC;
11428	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11429	CheckEnumValue<PT_Uint32>(S, OpPC, V0);
11430	}
11431	#if USE_TAILCALLS
11432	MUSTTAIL return InterpNext(S);
11433	#else
11434	return true;
11435	#endif
11436	}
11437	PRESERVE_NONE
11438	static bool Interp_CheckEnumValueSint64(InterpState &S) {
11439	{
11440	CodePtr OpPC = S.PC;
11441	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11442	CheckEnumValue<PT_Sint64>(S, OpPC, V0);
11443	}
11444	#if USE_TAILCALLS
11445	MUSTTAIL return InterpNext(S);
11446	#else
11447	return true;
11448	#endif
11449	}
11450	PRESERVE_NONE
11451	static bool Interp_CheckEnumValueUint64(InterpState &S) {
11452	{
11453	CodePtr OpPC = S.PC;
11454	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11455	CheckEnumValue<PT_Uint64>(S, OpPC, V0);
11456	}
11457	#if USE_TAILCALLS
11458	MUSTTAIL return InterpNext(S);
11459	#else
11460	return true;
11461	#endif
11462	}
11463	PRESERVE_NONE
11464	static bool Interp_CheckEnumValueIntAP(InterpState &S) {
11465	{
11466	CodePtr OpPC = S.PC;
11467	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11468	CheckEnumValue<PT_IntAP>(S, OpPC, V0);
11469	}
11470	#if USE_TAILCALLS
11471	MUSTTAIL return InterpNext(S);
11472	#else
11473	return true;
11474	#endif
11475	}
11476	PRESERVE_NONE
11477	static bool Interp_CheckEnumValueIntAPS(InterpState &S) {
11478	{
11479	CodePtr OpPC = S.PC;
11480	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11481	CheckEnumValue<PT_IntAPS>(S, OpPC, V0);
11482	}
11483	#if USE_TAILCALLS
11484	MUSTTAIL return InterpNext(S);
11485	#else
11486	return true;
11487	#endif
11488	}
11489	PRESERVE_NONE
11490	static bool Interp_CheckEnumValueBool(InterpState &S) {
11491	{
11492	CodePtr OpPC = S.PC;
11493	const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11494	CheckEnumValue<PT_Bool>(S, OpPC, V0);
11495	}
11496	#if USE_TAILCALLS
11497	MUSTTAIL return InterpNext(S);
11498	#else
11499	return true;
11500	#endif
11501	}
11502	#endif
11503	#ifdef GET_DISASM
11504	case OP_CheckEnumValueSint8:
11505	Text.Op = PrintName("CheckEnumValueSint8");
11506	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11507	break;
11508	case OP_CheckEnumValueUint8:
11509	Text.Op = PrintName("CheckEnumValueUint8");
11510	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11511	break;
11512	case OP_CheckEnumValueSint16:
11513	Text.Op = PrintName("CheckEnumValueSint16");
11514	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11515	break;
11516	case OP_CheckEnumValueUint16:
11517	Text.Op = PrintName("CheckEnumValueUint16");
11518	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11519	break;
11520	case OP_CheckEnumValueSint32:
11521	Text.Op = PrintName("CheckEnumValueSint32");
11522	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11523	break;
11524	case OP_CheckEnumValueUint32:
11525	Text.Op = PrintName("CheckEnumValueUint32");
11526	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11527	break;
11528	case OP_CheckEnumValueSint64:
11529	Text.Op = PrintName("CheckEnumValueSint64");
11530	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11531	break;
11532	case OP_CheckEnumValueUint64:
11533	Text.Op = PrintName("CheckEnumValueUint64");
11534	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11535	break;
11536	case OP_CheckEnumValueIntAP:
11537	Text.Op = PrintName("CheckEnumValueIntAP");
11538	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11539	break;
11540	case OP_CheckEnumValueIntAPS:
11541	Text.Op = PrintName("CheckEnumValueIntAPS");
11542	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11543	break;
11544	case OP_CheckEnumValueBool:
11545	Text.Op = PrintName("CheckEnumValueBool");
11546	Text.Args.push_back(printArg<const EnumDecl *>(P, PC));
11547	break;
11548	#endif
11549	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11550	bool emitCheckEnumValueSint8( const EnumDecl * , SourceInfo);
11551	bool emitCheckEnumValueUint8( const EnumDecl * , SourceInfo);
11552	bool emitCheckEnumValueSint16( const EnumDecl * , SourceInfo);
11553	bool emitCheckEnumValueUint16( const EnumDecl * , SourceInfo);
11554	bool emitCheckEnumValueSint32( const EnumDecl * , SourceInfo);
11555	bool emitCheckEnumValueUint32( const EnumDecl * , SourceInfo);
11556	bool emitCheckEnumValueSint64( const EnumDecl * , SourceInfo);
11557	bool emitCheckEnumValueUint64( const EnumDecl * , SourceInfo);
11558	bool emitCheckEnumValueIntAP( const EnumDecl * , SourceInfo);
11559	bool emitCheckEnumValueIntAPS( const EnumDecl * , SourceInfo);
11560	bool emitCheckEnumValueBool( const EnumDecl * , SourceInfo);
11561	#endif
11562	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11563	[[nodiscard]] bool emitCheckEnumValue(PrimType, const EnumDecl *, SourceInfo I);
11564	#endif
11565	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
11566	bool
11567	#if defined(GET_EVAL_IMPL)
11568	EvalEmitter
11569	#else
11570	ByteCodeEmitter
11571	#endif
11572	::emitCheckEnumValue(PrimType T0, const EnumDecl * A0, SourceInfo I) {
11573	switch (T0) {
11574	case PT_Sint8:
11575	return emitCheckEnumValueSint8(A0, I);
11576	case PT_Uint8:
11577	return emitCheckEnumValueUint8(A0, I);
11578	case PT_Sint16:
11579	return emitCheckEnumValueSint16(A0, I);
11580	case PT_Uint16:
11581	return emitCheckEnumValueUint16(A0, I);
11582	case PT_Sint32:
11583	return emitCheckEnumValueSint32(A0, I);
11584	case PT_Uint32:
11585	return emitCheckEnumValueUint32(A0, I);
11586	case PT_Sint64:
11587	return emitCheckEnumValueSint64(A0, I);
11588	case PT_Uint64:
11589	return emitCheckEnumValueUint64(A0, I);
11590	case PT_IntAP:
11591	return emitCheckEnumValueIntAP(A0, I);
11592	case PT_IntAPS:
11593	return emitCheckEnumValueIntAPS(A0, I);
11594	case PT_Bool:
11595	return emitCheckEnumValueBool(A0, I);
11596	default: llvm_unreachable("invalid type: emitCheckEnumValue");
11597	}
11598	llvm_unreachable("invalid enum value");
11599	}
11600	#endif
11601	#ifdef GET_LINK_IMPL
11602	bool ByteCodeEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, SourceInfo L) {
11603	return emitOp<const EnumDecl *>(OP_CheckEnumValueSint8, A0, L);
11604	}
11605	bool ByteCodeEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, SourceInfo L) {
11606	return emitOp<const EnumDecl *>(OP_CheckEnumValueUint8, A0, L);
11607	}
11608	bool ByteCodeEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, SourceInfo L) {
11609	return emitOp<const EnumDecl *>(OP_CheckEnumValueSint16, A0, L);
11610	}
11611	bool ByteCodeEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, SourceInfo L) {
11612	return emitOp<const EnumDecl *>(OP_CheckEnumValueUint16, A0, L);
11613	}
11614	bool ByteCodeEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, SourceInfo L) {
11615	return emitOp<const EnumDecl *>(OP_CheckEnumValueSint32, A0, L);
11616	}
11617	bool ByteCodeEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, SourceInfo L) {
11618	return emitOp<const EnumDecl *>(OP_CheckEnumValueUint32, A0, L);
11619	}
11620	bool ByteCodeEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, SourceInfo L) {
11621	return emitOp<const EnumDecl *>(OP_CheckEnumValueSint64, A0, L);
11622	}
11623	bool ByteCodeEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, SourceInfo L) {
11624	return emitOp<const EnumDecl *>(OP_CheckEnumValueUint64, A0, L);
11625	}
11626	bool ByteCodeEmitter::emitCheckEnumValueIntAP( const EnumDecl * A0, SourceInfo L) {
11627	return emitOp<const EnumDecl *>(OP_CheckEnumValueIntAP, A0, L);
11628	}
11629	bool ByteCodeEmitter::emitCheckEnumValueIntAPS( const EnumDecl * A0, SourceInfo L) {
11630	return emitOp<const EnumDecl *>(OP_CheckEnumValueIntAPS, A0, L);
11631	}
11632	bool ByteCodeEmitter::emitCheckEnumValueBool( const EnumDecl * A0, SourceInfo L) {
11633	return emitOp<const EnumDecl *>(OP_CheckEnumValueBool, A0, L);
11634	}
11635	#endif
11636	#ifdef GET_EVAL_IMPL
11637	bool EvalEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, SourceInfo L) {
11638	if (!isActive()) return true;
11639	CurrentSource = L;
11640	return CheckEnumValue<PT_Sint8>(S, CodePtr(), A0);
11641	}
11642	bool EvalEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, SourceInfo L) {
11643	if (!isActive()) return true;
11644	CurrentSource = L;
11645	return CheckEnumValue<PT_Uint8>(S, CodePtr(), A0);
11646	}
11647	bool EvalEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, SourceInfo L) {
11648	if (!isActive()) return true;
11649	CurrentSource = L;
11650	return CheckEnumValue<PT_Sint16>(S, CodePtr(), A0);
11651	}
11652	bool EvalEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, SourceInfo L) {
11653	if (!isActive()) return true;
11654	CurrentSource = L;
11655	return CheckEnumValue<PT_Uint16>(S, CodePtr(), A0);
11656	}
11657	bool EvalEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, SourceInfo L) {
11658	if (!isActive()) return true;
11659	CurrentSource = L;
11660	return CheckEnumValue<PT_Sint32>(S, CodePtr(), A0);
11661	}
11662	bool EvalEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, SourceInfo L) {
11663	if (!isActive()) return true;
11664	CurrentSource = L;
11665	return CheckEnumValue<PT_Uint32>(S, CodePtr(), A0);
11666	}
11667	bool EvalEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, SourceInfo L) {
11668	if (!isActive()) return true;
11669	CurrentSource = L;
11670	return CheckEnumValue<PT_Sint64>(S, CodePtr(), A0);
11671	}
11672	bool EvalEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, SourceInfo L) {
11673	if (!isActive()) return true;
11674	CurrentSource = L;
11675	return CheckEnumValue<PT_Uint64>(S, CodePtr(), A0);
11676	}
11677	bool EvalEmitter::emitCheckEnumValueIntAP( const EnumDecl * A0, SourceInfo L) {
11678	if (!isActive()) return true;
11679	CurrentSource = L;
11680	return CheckEnumValue<PT_IntAP>(S, CodePtr(), A0);
11681	}
11682	bool EvalEmitter::emitCheckEnumValueIntAPS( const EnumDecl * A0, SourceInfo L) {
11683	if (!isActive()) return true;
11684	CurrentSource = L;
11685	return CheckEnumValue<PT_IntAPS>(S, CodePtr(), A0);
11686	}
11687	bool EvalEmitter::emitCheckEnumValueBool( const EnumDecl * A0, SourceInfo L) {
11688	if (!isActive()) return true;
11689	CurrentSource = L;
11690	return CheckEnumValue<PT_Bool>(S, CodePtr(), A0);
11691	}
11692	#endif
11693	#ifdef GET_OPCODE_NAMES
11694	OP_CheckFunctionDecl,
11695	#endif
11696	#ifdef GET_INTERPFN_LIST
11697	&Interp_CheckFunctionDecl,
11698	#endif
11699	#ifdef GET_INTERPFN_DISPATCHERS
11700	PRESERVE_NONE
11701	static bool Interp_CheckFunctionDecl(InterpState &S) {
11702	{
11703	CodePtr OpPC = S.PC;
11704	const auto V0 = ReadArg<const FunctionDecl *>(S, S.PC);
11705	if (!CheckFunctionDecl(S, OpPC, V0)) return false;
11706	}
11707	#if USE_TAILCALLS
11708	MUSTTAIL return InterpNext(S);
11709	#else
11710	return true;
11711	#endif
11712	}
11713	#endif
11714	#ifdef GET_DISASM
11715	case OP_CheckFunctionDecl:
11716	Text.Op = PrintName("CheckFunctionDecl");
11717	Text.Args.push_back(printArg<const FunctionDecl *>(P, PC));
11718	break;
11719	#endif
11720	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11721	bool emitCheckFunctionDecl( const FunctionDecl * , SourceInfo);
11722	#endif
11723	#ifdef GET_LINK_IMPL
11724	bool ByteCodeEmitter::emitCheckFunctionDecl( const FunctionDecl * A0, SourceInfo L) {
11725	return emitOp<const FunctionDecl *>(OP_CheckFunctionDecl, A0, L);
11726	}
11727	#endif
11728	#ifdef GET_EVAL_IMPL
11729	bool EvalEmitter::emitCheckFunctionDecl( const FunctionDecl * A0, SourceInfo L) {
11730	if (!isActive()) return true;
11731	CurrentSource = L;
11732	return CheckFunctionDecl(S, CodePtr(), A0);
11733	}
11734	#endif
11735	#ifdef GET_OPCODE_NAMES
11736	OP_CheckLiteralType,
11737	#endif
11738	#ifdef GET_INTERPFN_LIST
11739	&Interp_CheckLiteralType,
11740	#endif
11741	#ifdef GET_INTERPFN_DISPATCHERS
11742	PRESERVE_NONE
11743	static bool Interp_CheckLiteralType(InterpState &S) {
11744	{
11745	CodePtr OpPC = S.PC;
11746	const auto V0 = ReadArg<const Type *>(S, S.PC);
11747	if (!CheckLiteralType(S, OpPC, V0)) return false;
11748	}
11749	#if USE_TAILCALLS
11750	MUSTTAIL return InterpNext(S);
11751	#else
11752	return true;
11753	#endif
11754	}
11755	#endif
11756	#ifdef GET_DISASM
11757	case OP_CheckLiteralType:
11758	Text.Op = PrintName("CheckLiteralType");
11759	Text.Args.push_back(printArg<const Type *>(P, PC));
11760	break;
11761	#endif
11762	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11763	bool emitCheckLiteralType( const Type * , SourceInfo);
11764	#endif
11765	#ifdef GET_LINK_IMPL
11766	bool ByteCodeEmitter::emitCheckLiteralType( const Type * A0, SourceInfo L) {
11767	return emitOp<const Type *>(OP_CheckLiteralType, A0, L);
11768	}
11769	#endif
11770	#ifdef GET_EVAL_IMPL
11771	bool EvalEmitter::emitCheckLiteralType( const Type * A0, SourceInfo L) {
11772	if (!isActive()) return true;
11773	CurrentSource = L;
11774	return CheckLiteralType(S, CodePtr(), A0);
11775	}
11776	#endif
11777	#ifdef GET_OPCODE_NAMES
11778	OP_CheckNewTypeMismatch,
11779	#endif
11780	#ifdef GET_INTERPFN_LIST
11781	&Interp_CheckNewTypeMismatch,
11782	#endif
11783	#ifdef GET_INTERPFN_DISPATCHERS
11784	PRESERVE_NONE
11785	static bool Interp_CheckNewTypeMismatch(InterpState &S) {
11786	{
11787	CodePtr OpPC = S.PC;
11788	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11789	if (!CheckNewTypeMismatch(S, OpPC, V0)) return false;
11790	}
11791	#if USE_TAILCALLS
11792	MUSTTAIL return InterpNext(S);
11793	#else
11794	return true;
11795	#endif
11796	}
11797	#endif
11798	#ifdef GET_DISASM
11799	case OP_CheckNewTypeMismatch:
11800	Text.Op = PrintName("CheckNewTypeMismatch");
11801	Text.Args.push_back(printArg<const Expr *>(P, PC));
11802	break;
11803	#endif
11804	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
11805	bool emitCheckNewTypeMismatch( const Expr * , SourceInfo);
11806	#endif
11807	#ifdef GET_LINK_IMPL
11808	bool ByteCodeEmitter::emitCheckNewTypeMismatch( const Expr * A0, SourceInfo L) {
11809	return emitOp<const Expr *>(OP_CheckNewTypeMismatch, A0, L);
11810	}
11811	#endif
11812	#ifdef GET_EVAL_IMPL
11813	bool EvalEmitter::emitCheckNewTypeMismatch( const Expr * A0, SourceInfo L) {
11814	if (!isActive()) return true;
11815	CurrentSource = L;
11816	return CheckNewTypeMismatch(S, CodePtr(), A0);
11817	}
11818	#endif
11819	#ifdef GET_OPCODE_NAMES
11820	OP_CheckNewTypeMismatchArraySint8,
11821	OP_CheckNewTypeMismatchArrayUint8,
11822	OP_CheckNewTypeMismatchArraySint16,
11823	OP_CheckNewTypeMismatchArrayUint16,
11824	OP_CheckNewTypeMismatchArraySint32,
11825	OP_CheckNewTypeMismatchArrayUint32,
11826	OP_CheckNewTypeMismatchArraySint64,
11827	OP_CheckNewTypeMismatchArrayUint64,
11828	OP_CheckNewTypeMismatchArrayIntAP,
11829	OP_CheckNewTypeMismatchArrayIntAPS,
11830	#endif
11831	#ifdef GET_INTERPFN_LIST
11832	&Interp_CheckNewTypeMismatchArraySint8,
11833	&Interp_CheckNewTypeMismatchArrayUint8,
11834	&Interp_CheckNewTypeMismatchArraySint16,
11835	&Interp_CheckNewTypeMismatchArrayUint16,
11836	&Interp_CheckNewTypeMismatchArraySint32,
11837	&Interp_CheckNewTypeMismatchArrayUint32,
11838	&Interp_CheckNewTypeMismatchArraySint64,
11839	&Interp_CheckNewTypeMismatchArrayUint64,
11840	&Interp_CheckNewTypeMismatchArrayIntAP,
11841	&Interp_CheckNewTypeMismatchArrayIntAPS,
11842	#endif
11843	#ifdef GET_INTERPFN_DISPATCHERS
11844	PRESERVE_NONE
11845	static bool Interp_CheckNewTypeMismatchArraySint8(InterpState &S) {
11846	{
11847	CodePtr OpPC = S.PC;
11848	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11849	if (!CheckNewTypeMismatchArray<PT_Sint8>(S, OpPC, V0)) return false;
11850	}
11851	#if USE_TAILCALLS
11852	MUSTTAIL return InterpNext(S);
11853	#else
11854	return true;
11855	#endif
11856	}
11857	PRESERVE_NONE
11858	static bool Interp_CheckNewTypeMismatchArrayUint8(InterpState &S) {
11859	{
11860	CodePtr OpPC = S.PC;
11861	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11862	if (!CheckNewTypeMismatchArray<PT_Uint8>(S, OpPC, V0)) return false;
11863	}
11864	#if USE_TAILCALLS
11865	MUSTTAIL return InterpNext(S);
11866	#else
11867	return true;
11868	#endif
11869	}
11870	PRESERVE_NONE
11871	static bool Interp_CheckNewTypeMismatchArraySint16(InterpState &S) {
11872	{
11873	CodePtr OpPC = S.PC;
11874	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11875	if (!CheckNewTypeMismatchArray<PT_Sint16>(S, OpPC, V0)) return false;
11876	}
11877	#if USE_TAILCALLS
11878	MUSTTAIL return InterpNext(S);
11879	#else
11880	return true;
11881	#endif
11882	}
11883	PRESERVE_NONE
11884	static bool Interp_CheckNewTypeMismatchArrayUint16(InterpState &S) {
11885	{
11886	CodePtr OpPC = S.PC;
11887	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11888	if (!CheckNewTypeMismatchArray<PT_Uint16>(S, OpPC, V0)) return false;
11889	}
11890	#if USE_TAILCALLS
11891	MUSTTAIL return InterpNext(S);
11892	#else
11893	return true;
11894	#endif
11895	}
11896	PRESERVE_NONE
11897	static bool Interp_CheckNewTypeMismatchArraySint32(InterpState &S) {
11898	{
11899	CodePtr OpPC = S.PC;
11900	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11901	if (!CheckNewTypeMismatchArray<PT_Sint32>(S, OpPC, V0)) return false;
11902	}
11903	#if USE_TAILCALLS
11904	MUSTTAIL return InterpNext(S);
11905	#else
11906	return true;
11907	#endif
11908	}
11909	PRESERVE_NONE
11910	static bool Interp_CheckNewTypeMismatchArrayUint32(InterpState &S) {
11911	{
11912	CodePtr OpPC = S.PC;
11913	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11914	if (!CheckNewTypeMismatchArray<PT_Uint32>(S, OpPC, V0)) return false;
11915	}
11916	#if USE_TAILCALLS
11917	MUSTTAIL return InterpNext(S);
11918	#else
11919	return true;
11920	#endif
11921	}
11922	PRESERVE_NONE
11923	static bool Interp_CheckNewTypeMismatchArraySint64(InterpState &S) {
11924	{
11925	CodePtr OpPC = S.PC;
11926	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11927	if (!CheckNewTypeMismatchArray<PT_Sint64>(S, OpPC, V0)) return false;
11928	}
11929	#if USE_TAILCALLS
11930	MUSTTAIL return InterpNext(S);
11931	#else
11932	return true;
11933	#endif
11934	}
11935	PRESERVE_NONE
11936	static bool Interp_CheckNewTypeMismatchArrayUint64(InterpState &S) {
11937	{
11938	CodePtr OpPC = S.PC;
11939	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11940	if (!CheckNewTypeMismatchArray<PT_Uint64>(S, OpPC, V0)) return false;
11941	}
11942	#if USE_TAILCALLS
11943	MUSTTAIL return InterpNext(S);
11944	#else
11945	return true;
11946	#endif
11947	}
11948	PRESERVE_NONE
11949	static bool Interp_CheckNewTypeMismatchArrayIntAP(InterpState &S) {
11950	{
11951	CodePtr OpPC = S.PC;
11952	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11953	if (!CheckNewTypeMismatchArray<PT_IntAP>(S, OpPC, V0)) return false;
11954	}
11955	#if USE_TAILCALLS
11956	MUSTTAIL return InterpNext(S);
11957	#else
11958	return true;
11959	#endif
11960	}
11961	PRESERVE_NONE
11962	static bool Interp_CheckNewTypeMismatchArrayIntAPS(InterpState &S) {
11963	{
11964	CodePtr OpPC = S.PC;
11965	const auto V0 = ReadArg<const Expr *>(S, S.PC);
11966	if (!CheckNewTypeMismatchArray<PT_IntAPS>(S, OpPC, V0)) return false;
11967	}
11968	#if USE_TAILCALLS
11969	MUSTTAIL return InterpNext(S);
11970	#else
11971	return true;
11972	#endif
11973	}
11974	#endif
11975	#ifdef GET_DISASM
11976	case OP_CheckNewTypeMismatchArraySint8:
11977	Text.Op = PrintName("CheckNewTypeMismatchArraySint8");
11978	Text.Args.push_back(printArg<const Expr *>(P, PC));
11979	break;
11980	case OP_CheckNewTypeMismatchArrayUint8:
11981	Text.Op = PrintName("CheckNewTypeMismatchArrayUint8");
11982	Text.Args.push_back(printArg<const Expr *>(P, PC));
11983	break;
11984	case OP_CheckNewTypeMismatchArraySint16:
11985	Text.Op = PrintName("CheckNewTypeMismatchArraySint16");
11986	Text.Args.push_back(printArg<const Expr *>(P, PC));
11987	break;
11988	case OP_CheckNewTypeMismatchArrayUint16:
11989	Text.Op = PrintName("CheckNewTypeMismatchArrayUint16");
11990	Text.Args.push_back(printArg<const Expr *>(P, PC));
11991	break;
11992	case OP_CheckNewTypeMismatchArraySint32:
11993	Text.Op = PrintName("CheckNewTypeMismatchArraySint32");
11994	Text.Args.push_back(printArg<const Expr *>(P, PC));
11995	break;
11996	case OP_CheckNewTypeMismatchArrayUint32:
11997	Text.Op = PrintName("CheckNewTypeMismatchArrayUint32");
11998	Text.Args.push_back(printArg<const Expr *>(P, PC));
11999	break;
12000	case OP_CheckNewTypeMismatchArraySint64:
12001	Text.Op = PrintName("CheckNewTypeMismatchArraySint64");
12002	Text.Args.push_back(printArg<const Expr *>(P, PC));
12003	break;
12004	case OP_CheckNewTypeMismatchArrayUint64:
12005	Text.Op = PrintName("CheckNewTypeMismatchArrayUint64");
12006	Text.Args.push_back(printArg<const Expr *>(P, PC));
12007	break;
12008	case OP_CheckNewTypeMismatchArrayIntAP:
12009	Text.Op = PrintName("CheckNewTypeMismatchArrayIntAP");
12010	Text.Args.push_back(printArg<const Expr *>(P, PC));
12011	break;
12012	case OP_CheckNewTypeMismatchArrayIntAPS:
12013	Text.Op = PrintName("CheckNewTypeMismatchArrayIntAPS");
12014	Text.Args.push_back(printArg<const Expr *>(P, PC));
12015	break;
12016	#endif
12017	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12018	bool emitCheckNewTypeMismatchArraySint8( const Expr * , SourceInfo);
12019	bool emitCheckNewTypeMismatchArrayUint8( const Expr * , SourceInfo);
12020	bool emitCheckNewTypeMismatchArraySint16( const Expr * , SourceInfo);
12021	bool emitCheckNewTypeMismatchArrayUint16( const Expr * , SourceInfo);
12022	bool emitCheckNewTypeMismatchArraySint32( const Expr * , SourceInfo);
12023	bool emitCheckNewTypeMismatchArrayUint32( const Expr * , SourceInfo);
12024	bool emitCheckNewTypeMismatchArraySint64( const Expr * , SourceInfo);
12025	bool emitCheckNewTypeMismatchArrayUint64( const Expr * , SourceInfo);
12026	bool emitCheckNewTypeMismatchArrayIntAP( const Expr * , SourceInfo);
12027	bool emitCheckNewTypeMismatchArrayIntAPS( const Expr * , SourceInfo);
12028	#endif
12029	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12030	[[nodiscard]] bool emitCheckNewTypeMismatchArray(PrimType, const Expr *, SourceInfo I);
12031	#endif
12032	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
12033	bool
12034	#if defined(GET_EVAL_IMPL)
12035	EvalEmitter
12036	#else
12037	ByteCodeEmitter
12038	#endif
12039	::emitCheckNewTypeMismatchArray(PrimType T0, const Expr * A0, SourceInfo I) {
12040	switch (T0) {
12041	case PT_Sint8:
12042	return emitCheckNewTypeMismatchArraySint8(A0, I);
12043	case PT_Uint8:
12044	return emitCheckNewTypeMismatchArrayUint8(A0, I);
12045	case PT_Sint16:
12046	return emitCheckNewTypeMismatchArraySint16(A0, I);
12047	case PT_Uint16:
12048	return emitCheckNewTypeMismatchArrayUint16(A0, I);
12049	case PT_Sint32:
12050	return emitCheckNewTypeMismatchArraySint32(A0, I);
12051	case PT_Uint32:
12052	return emitCheckNewTypeMismatchArrayUint32(A0, I);
12053	case PT_Sint64:
12054	return emitCheckNewTypeMismatchArraySint64(A0, I);
12055	case PT_Uint64:
12056	return emitCheckNewTypeMismatchArrayUint64(A0, I);
12057	case PT_IntAP:
12058	return emitCheckNewTypeMismatchArrayIntAP(A0, I);
12059	case PT_IntAPS:
12060	return emitCheckNewTypeMismatchArrayIntAPS(A0, I);
12061	default: llvm_unreachable("invalid type: emitCheckNewTypeMismatchArray");
12062	}
12063	llvm_unreachable("invalid enum value");
12064	}
12065	#endif
12066	#ifdef GET_LINK_IMPL
12067	bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, SourceInfo L) {
12068	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint8, A0, L);
12069	}
12070	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, SourceInfo L) {
12071	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint8, A0, L);
12072	}
12073	bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, SourceInfo L) {
12074	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint16, A0, L);
12075	}
12076	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, SourceInfo L) {
12077	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint16, A0, L);
12078	}
12079	bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, SourceInfo L) {
12080	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint32, A0, L);
12081	}
12082	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, SourceInfo L) {
12083	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint32, A0, L);
12084	}
12085	bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, SourceInfo L) {
12086	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint64, A0, L);
12087	}
12088	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, SourceInfo L) {
12089	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint64, A0, L);
12090	}
12091	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, SourceInfo L) {
12092	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayIntAP, A0, L);
12093	}
12094	bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, SourceInfo L) {
12095	return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayIntAPS, A0, L);
12096	}
12097	#endif
12098	#ifdef GET_EVAL_IMPL
12099	bool EvalEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, SourceInfo L) {
12100	if (!isActive()) return true;
12101	CurrentSource = L;
12102	return CheckNewTypeMismatchArray<PT_Sint8>(S, CodePtr(), A0);
12103	}
12104	bool EvalEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, SourceInfo L) {
12105	if (!isActive()) return true;
12106	CurrentSource = L;
12107	return CheckNewTypeMismatchArray<PT_Uint8>(S, CodePtr(), A0);
12108	}
12109	bool EvalEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, SourceInfo L) {
12110	if (!isActive()) return true;
12111	CurrentSource = L;
12112	return CheckNewTypeMismatchArray<PT_Sint16>(S, CodePtr(), A0);
12113	}
12114	bool EvalEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, SourceInfo L) {
12115	if (!isActive()) return true;
12116	CurrentSource = L;
12117	return CheckNewTypeMismatchArray<PT_Uint16>(S, CodePtr(), A0);
12118	}
12119	bool EvalEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, SourceInfo L) {
12120	if (!isActive()) return true;
12121	CurrentSource = L;
12122	return CheckNewTypeMismatchArray<PT_Sint32>(S, CodePtr(), A0);
12123	}
12124	bool EvalEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, SourceInfo L) {
12125	if (!isActive()) return true;
12126	CurrentSource = L;
12127	return CheckNewTypeMismatchArray<PT_Uint32>(S, CodePtr(), A0);
12128	}
12129	bool EvalEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, SourceInfo L) {
12130	if (!isActive()) return true;
12131	CurrentSource = L;
12132	return CheckNewTypeMismatchArray<PT_Sint64>(S, CodePtr(), A0);
12133	}
12134	bool EvalEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, SourceInfo L) {
12135	if (!isActive()) return true;
12136	CurrentSource = L;
12137	return CheckNewTypeMismatchArray<PT_Uint64>(S, CodePtr(), A0);
12138	}
12139	bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, SourceInfo L) {
12140	if (!isActive()) return true;
12141	CurrentSource = L;
12142	return CheckNewTypeMismatchArray<PT_IntAP>(S, CodePtr(), A0);
12143	}
12144	bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, SourceInfo L) {
12145	if (!isActive()) return true;
12146	CurrentSource = L;
12147	return CheckNewTypeMismatchArray<PT_IntAPS>(S, CodePtr(), A0);
12148	}
12149	#endif
12150	#ifdef GET_OPCODE_NAMES
12151	OP_CheckNonNullArgPtr,
12152	OP_CheckNonNullArgMemberPtr,
12153	#endif
12154	#ifdef GET_INTERPFN_LIST
12155	&Interp_CheckNonNullArgPtr,
12156	&Interp_CheckNonNullArgMemberPtr,
12157	#endif
12158	#ifdef GET_INTERPFN_DISPATCHERS
12159	PRESERVE_NONE
12160	static bool Interp_CheckNonNullArgPtr(InterpState &S) {
12161	if (!CheckNonNullArg<PT_Ptr>(S, S.PC)) return false;
12162	#if USE_TAILCALLS
12163	MUSTTAIL return InterpNext(S);
12164	#else
12165	return true;
12166	#endif
12167	}
12168	PRESERVE_NONE
12169	static bool Interp_CheckNonNullArgMemberPtr(InterpState &S) {
12170	if (!CheckNonNullArg<PT_MemberPtr>(S, S.PC)) return false;
12171	#if USE_TAILCALLS
12172	MUSTTAIL return InterpNext(S);
12173	#else
12174	return true;
12175	#endif
12176	}
12177	#endif
12178	#ifdef GET_DISASM
12179	case OP_CheckNonNullArgPtr:
12180	Text.Op = PrintName("CheckNonNullArgPtr");
12181	break;
12182	case OP_CheckNonNullArgMemberPtr:
12183	Text.Op = PrintName("CheckNonNullArgMemberPtr");
12184	break;
12185	#endif
12186	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12187	bool emitCheckNonNullArgPtr(SourceInfo);
12188	bool emitCheckNonNullArgMemberPtr(SourceInfo);
12189	#endif
12190	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12191	[[nodiscard]] bool emitCheckNonNullArg(PrimType, SourceInfo I);
12192	#endif
12193	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
12194	bool
12195	#if defined(GET_EVAL_IMPL)
12196	EvalEmitter
12197	#else
12198	ByteCodeEmitter
12199	#endif
12200	::emitCheckNonNullArg(PrimType T0, SourceInfo I) {
12201	switch (T0) {
12202	case PT_Ptr:
12203	return emitCheckNonNullArgPtr(I);
12204	case PT_MemberPtr:
12205	return emitCheckNonNullArgMemberPtr(I);
12206	default: llvm_unreachable("invalid type: emitCheckNonNullArg");
12207	}
12208	llvm_unreachable("invalid enum value");
12209	}
12210	#endif
12211	#ifdef GET_LINK_IMPL
12212	bool ByteCodeEmitter::emitCheckNonNullArgPtr(SourceInfo L) {
12213	return emitOp<>(OP_CheckNonNullArgPtr, L);
12214	}
12215	bool ByteCodeEmitter::emitCheckNonNullArgMemberPtr(SourceInfo L) {
12216	return emitOp<>(OP_CheckNonNullArgMemberPtr, L);
12217	}
12218	#endif
12219	#ifdef GET_EVAL_IMPL
12220	bool EvalEmitter::emitCheckNonNullArgPtr(SourceInfo L) {
12221	if (!isActive()) return true;
12222	CurrentSource = L;
12223	return CheckNonNullArg<PT_Ptr>(S, CodePtr());
12224	}
12225	bool EvalEmitter::emitCheckNonNullArgMemberPtr(SourceInfo L) {
12226	if (!isActive()) return true;
12227	CurrentSource = L;
12228	return CheckNonNullArg<PT_MemberPtr>(S, CodePtr());
12229	}
12230	#endif
12231	#ifdef GET_OPCODE_NAMES
12232	OP_CheckNull,
12233	#endif
12234	#ifdef GET_INTERPFN_LIST
12235	&Interp_CheckNull,
12236	#endif
12237	#ifdef GET_INTERPFN_DISPATCHERS
12238	PRESERVE_NONE
12239	static bool Interp_CheckNull(InterpState &S) {
12240	if (!CheckNull(S, S.PC)) return false;
12241	#if USE_TAILCALLS
12242	MUSTTAIL return InterpNext(S);
12243	#else
12244	return true;
12245	#endif
12246	}
12247	#endif
12248	#ifdef GET_DISASM
12249	case OP_CheckNull:
12250	Text.Op = PrintName("CheckNull");
12251	break;
12252	#endif
12253	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12254	bool emitCheckNull(SourceInfo);
12255	#endif
12256	#ifdef GET_LINK_IMPL
12257	bool ByteCodeEmitter::emitCheckNull(SourceInfo L) {
12258	return emitOp<>(OP_CheckNull, L);
12259	}
12260	#endif
12261	#ifdef GET_EVAL_IMPL
12262	bool EvalEmitter::emitCheckNull(SourceInfo L) {
12263	if (!isActive()) return true;
12264	CurrentSource = L;
12265	return CheckNull(S, CodePtr());
12266	}
12267	#endif
12268	#ifdef GET_OPCODE_NAMES
12269	OP_CheckPseudoDtor,
12270	#endif
12271	#ifdef GET_INTERPFN_LIST
12272	&Interp_CheckPseudoDtor,
12273	#endif
12274	#ifdef GET_INTERPFN_DISPATCHERS
12275	PRESERVE_NONE
12276	static bool Interp_CheckPseudoDtor(InterpState &S) {
12277	CheckPseudoDtor(S, S.PC);
12278	#if USE_TAILCALLS
12279	MUSTTAIL return InterpNext(S);
12280	#else
12281	return true;
12282	#endif
12283	}
12284	#endif
12285	#ifdef GET_DISASM
12286	case OP_CheckPseudoDtor:
12287	Text.Op = PrintName("CheckPseudoDtor");
12288	break;
12289	#endif
12290	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12291	bool emitCheckPseudoDtor(SourceInfo);
12292	#endif
12293	#ifdef GET_LINK_IMPL
12294	bool ByteCodeEmitter::emitCheckPseudoDtor(SourceInfo L) {
12295	return emitOp<>(OP_CheckPseudoDtor, L);
12296	}
12297	#endif
12298	#ifdef GET_EVAL_IMPL
12299	bool EvalEmitter::emitCheckPseudoDtor(SourceInfo L) {
12300	if (!isActive()) return true;
12301	CurrentSource = L;
12302	return CheckPseudoDtor(S, CodePtr());
12303	}
12304	#endif
12305	#ifdef GET_OPCODE_NAMES
12306	OP_CheckRefInit,
12307	#endif
12308	#ifdef GET_INTERPFN_LIST
12309	&Interp_CheckRefInit,
12310	#endif
12311	#ifdef GET_INTERPFN_DISPATCHERS
12312	PRESERVE_NONE
12313	static bool Interp_CheckRefInit(InterpState &S) {
12314	if (!CheckRefInit(S, S.PC)) return false;
12315	#if USE_TAILCALLS
12316	MUSTTAIL return InterpNext(S);
12317	#else
12318	return true;
12319	#endif
12320	}
12321	#endif
12322	#ifdef GET_DISASM
12323	case OP_CheckRefInit:
12324	Text.Op = PrintName("CheckRefInit");
12325	break;
12326	#endif
12327	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12328	bool emitCheckRefInit(SourceInfo);
12329	#endif
12330	#ifdef GET_LINK_IMPL
12331	bool ByteCodeEmitter::emitCheckRefInit(SourceInfo L) {
12332	return emitOp<>(OP_CheckRefInit, L);
12333	}
12334	#endif
12335	#ifdef GET_EVAL_IMPL
12336	bool EvalEmitter::emitCheckRefInit(SourceInfo L) {
12337	if (!isActive()) return true;
12338	CurrentSource = L;
12339	return CheckRefInit(S, CodePtr());
12340	}
12341	#endif
12342	#ifdef GET_OPCODE_NAMES
12343	OP_CompSint8,
12344	OP_CompUint8,
12345	OP_CompSint16,
12346	OP_CompUint16,
12347	OP_CompSint32,
12348	OP_CompUint32,
12349	OP_CompSint64,
12350	OP_CompUint64,
12351	OP_CompIntAP,
12352	OP_CompIntAPS,
12353	#endif
12354	#ifdef GET_INTERPFN_LIST
12355	&Interp_CompSint8,
12356	&Interp_CompUint8,
12357	&Interp_CompSint16,
12358	&Interp_CompUint16,
12359	&Interp_CompSint32,
12360	&Interp_CompUint32,
12361	&Interp_CompSint64,
12362	&Interp_CompUint64,
12363	&Interp_CompIntAP,
12364	&Interp_CompIntAPS,
12365	#endif
12366	#ifdef GET_INTERPFN_DISPATCHERS
12367	PRESERVE_NONE
12368	static bool Interp_CompSint8(InterpState &S) {
12369	if (!Comp<PT_Sint8>(S)) return false;
12370	#if USE_TAILCALLS
12371	MUSTTAIL return InterpNext(S);
12372	#else
12373	return true;
12374	#endif
12375	}
12376	PRESERVE_NONE
12377	static bool Interp_CompUint8(InterpState &S) {
12378	if (!Comp<PT_Uint8>(S)) return false;
12379	#if USE_TAILCALLS
12380	MUSTTAIL return InterpNext(S);
12381	#else
12382	return true;
12383	#endif
12384	}
12385	PRESERVE_NONE
12386	static bool Interp_CompSint16(InterpState &S) {
12387	if (!Comp<PT_Sint16>(S)) return false;
12388	#if USE_TAILCALLS
12389	MUSTTAIL return InterpNext(S);
12390	#else
12391	return true;
12392	#endif
12393	}
12394	PRESERVE_NONE
12395	static bool Interp_CompUint16(InterpState &S) {
12396	if (!Comp<PT_Uint16>(S)) return false;
12397	#if USE_TAILCALLS
12398	MUSTTAIL return InterpNext(S);
12399	#else
12400	return true;
12401	#endif
12402	}
12403	PRESERVE_NONE
12404	static bool Interp_CompSint32(InterpState &S) {
12405	if (!Comp<PT_Sint32>(S)) return false;
12406	#if USE_TAILCALLS
12407	MUSTTAIL return InterpNext(S);
12408	#else
12409	return true;
12410	#endif
12411	}
12412	PRESERVE_NONE
12413	static bool Interp_CompUint32(InterpState &S) {
12414	if (!Comp<PT_Uint32>(S)) return false;
12415	#if USE_TAILCALLS
12416	MUSTTAIL return InterpNext(S);
12417	#else
12418	return true;
12419	#endif
12420	}
12421	PRESERVE_NONE
12422	static bool Interp_CompSint64(InterpState &S) {
12423	if (!Comp<PT_Sint64>(S)) return false;
12424	#if USE_TAILCALLS
12425	MUSTTAIL return InterpNext(S);
12426	#else
12427	return true;
12428	#endif
12429	}
12430	PRESERVE_NONE
12431	static bool Interp_CompUint64(InterpState &S) {
12432	if (!Comp<PT_Uint64>(S)) return false;
12433	#if USE_TAILCALLS
12434	MUSTTAIL return InterpNext(S);
12435	#else
12436	return true;
12437	#endif
12438	}
12439	PRESERVE_NONE
12440	static bool Interp_CompIntAP(InterpState &S) {
12441	if (!Comp<PT_IntAP>(S)) return false;
12442	#if USE_TAILCALLS
12443	MUSTTAIL return InterpNext(S);
12444	#else
12445	return true;
12446	#endif
12447	}
12448	PRESERVE_NONE
12449	static bool Interp_CompIntAPS(InterpState &S) {
12450	if (!Comp<PT_IntAPS>(S)) return false;
12451	#if USE_TAILCALLS
12452	MUSTTAIL return InterpNext(S);
12453	#else
12454	return true;
12455	#endif
12456	}
12457	#endif
12458	#ifdef GET_DISASM
12459	case OP_CompSint8:
12460	Text.Op = PrintName("CompSint8");
12461	break;
12462	case OP_CompUint8:
12463	Text.Op = PrintName("CompUint8");
12464	break;
12465	case OP_CompSint16:
12466	Text.Op = PrintName("CompSint16");
12467	break;
12468	case OP_CompUint16:
12469	Text.Op = PrintName("CompUint16");
12470	break;
12471	case OP_CompSint32:
12472	Text.Op = PrintName("CompSint32");
12473	break;
12474	case OP_CompUint32:
12475	Text.Op = PrintName("CompUint32");
12476	break;
12477	case OP_CompSint64:
12478	Text.Op = PrintName("CompSint64");
12479	break;
12480	case OP_CompUint64:
12481	Text.Op = PrintName("CompUint64");
12482	break;
12483	case OP_CompIntAP:
12484	Text.Op = PrintName("CompIntAP");
12485	break;
12486	case OP_CompIntAPS:
12487	Text.Op = PrintName("CompIntAPS");
12488	break;
12489	#endif
12490	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12491	bool emitCompSint8(SourceInfo);
12492	bool emitCompUint8(SourceInfo);
12493	bool emitCompSint16(SourceInfo);
12494	bool emitCompUint16(SourceInfo);
12495	bool emitCompSint32(SourceInfo);
12496	bool emitCompUint32(SourceInfo);
12497	bool emitCompSint64(SourceInfo);
12498	bool emitCompUint64(SourceInfo);
12499	bool emitCompIntAP(SourceInfo);
12500	bool emitCompIntAPS(SourceInfo);
12501	#endif
12502	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12503	[[nodiscard]] bool emitComp(PrimType, SourceInfo I);
12504	#endif
12505	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
12506	bool
12507	#if defined(GET_EVAL_IMPL)
12508	EvalEmitter
12509	#else
12510	ByteCodeEmitter
12511	#endif
12512	::emitComp(PrimType T0, SourceInfo I) {
12513	switch (T0) {
12514	case PT_Sint8:
12515	return emitCompSint8(I);
12516	case PT_Uint8:
12517	return emitCompUint8(I);
12518	case PT_Sint16:
12519	return emitCompSint16(I);
12520	case PT_Uint16:
12521	return emitCompUint16(I);
12522	case PT_Sint32:
12523	return emitCompSint32(I);
12524	case PT_Uint32:
12525	return emitCompUint32(I);
12526	case PT_Sint64:
12527	return emitCompSint64(I);
12528	case PT_Uint64:
12529	return emitCompUint64(I);
12530	case PT_IntAP:
12531	return emitCompIntAP(I);
12532	case PT_IntAPS:
12533	return emitCompIntAPS(I);
12534	default: llvm_unreachable("invalid type: emitComp");
12535	}
12536	llvm_unreachable("invalid enum value");
12537	}
12538	#endif
12539	#ifdef GET_LINK_IMPL
12540	bool ByteCodeEmitter::emitCompSint8(SourceInfo L) {
12541	return emitOp<>(OP_CompSint8, L);
12542	}
12543	bool ByteCodeEmitter::emitCompUint8(SourceInfo L) {
12544	return emitOp<>(OP_CompUint8, L);
12545	}
12546	bool ByteCodeEmitter::emitCompSint16(SourceInfo L) {
12547	return emitOp<>(OP_CompSint16, L);
12548	}
12549	bool ByteCodeEmitter::emitCompUint16(SourceInfo L) {
12550	return emitOp<>(OP_CompUint16, L);
12551	}
12552	bool ByteCodeEmitter::emitCompSint32(SourceInfo L) {
12553	return emitOp<>(OP_CompSint32, L);
12554	}
12555	bool ByteCodeEmitter::emitCompUint32(SourceInfo L) {
12556	return emitOp<>(OP_CompUint32, L);
12557	}
12558	bool ByteCodeEmitter::emitCompSint64(SourceInfo L) {
12559	return emitOp<>(OP_CompSint64, L);
12560	}
12561	bool ByteCodeEmitter::emitCompUint64(SourceInfo L) {
12562	return emitOp<>(OP_CompUint64, L);
12563	}
12564	bool ByteCodeEmitter::emitCompIntAP(SourceInfo L) {
12565	return emitOp<>(OP_CompIntAP, L);
12566	}
12567	bool ByteCodeEmitter::emitCompIntAPS(SourceInfo L) {
12568	return emitOp<>(OP_CompIntAPS, L);
12569	}
12570	#endif
12571	#ifdef GET_EVAL_IMPL
12572	bool EvalEmitter::emitCompSint8(SourceInfo L) {
12573	if (!isActive()) return true;
12574	CurrentSource = L;
12575	return Comp<PT_Sint8>(S);
12576	}
12577	bool EvalEmitter::emitCompUint8(SourceInfo L) {
12578	if (!isActive()) return true;
12579	CurrentSource = L;
12580	return Comp<PT_Uint8>(S);
12581	}
12582	bool EvalEmitter::emitCompSint16(SourceInfo L) {
12583	if (!isActive()) return true;
12584	CurrentSource = L;
12585	return Comp<PT_Sint16>(S);
12586	}
12587	bool EvalEmitter::emitCompUint16(SourceInfo L) {
12588	if (!isActive()) return true;
12589	CurrentSource = L;
12590	return Comp<PT_Uint16>(S);
12591	}
12592	bool EvalEmitter::emitCompSint32(SourceInfo L) {
12593	if (!isActive()) return true;
12594	CurrentSource = L;
12595	return Comp<PT_Sint32>(S);
12596	}
12597	bool EvalEmitter::emitCompUint32(SourceInfo L) {
12598	if (!isActive()) return true;
12599	CurrentSource = L;
12600	return Comp<PT_Uint32>(S);
12601	}
12602	bool EvalEmitter::emitCompSint64(SourceInfo L) {
12603	if (!isActive()) return true;
12604	CurrentSource = L;
12605	return Comp<PT_Sint64>(S);
12606	}
12607	bool EvalEmitter::emitCompUint64(SourceInfo L) {
12608	if (!isActive()) return true;
12609	CurrentSource = L;
12610	return Comp<PT_Uint64>(S);
12611	}
12612	bool EvalEmitter::emitCompIntAP(SourceInfo L) {
12613	if (!isActive()) return true;
12614	CurrentSource = L;
12615	return Comp<PT_IntAP>(S);
12616	}
12617	bool EvalEmitter::emitCompIntAPS(SourceInfo L) {
12618	if (!isActive()) return true;
12619	CurrentSource = L;
12620	return Comp<PT_IntAPS>(S);
12621	}
12622	#endif
12623	#ifdef GET_OPCODE_NAMES
12624	OP_ConstBool,
12625	#endif
12626	#ifdef GET_INTERPFN_LIST
12627	&Interp_ConstBool,
12628	#endif
12629	#ifdef GET_INTERPFN_DISPATCHERS
12630	PRESERVE_NONE
12631	static bool Interp_ConstBool(InterpState &S) {
12632	{
12633	const auto V0 = ReadArg<bool>(S, S.PC);
12634	Const<PT_Bool>(S, V0);
12635	}
12636	#if USE_TAILCALLS
12637	MUSTTAIL return InterpNext(S);
12638	#else
12639	return true;
12640	#endif
12641	}
12642	#endif
12643	#ifdef GET_DISASM
12644	case OP_ConstBool:
12645	Text.Op = PrintName("ConstBool");
12646	Text.Args.push_back(printArg<bool>(P, PC));
12647	break;
12648	#endif
12649	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12650	bool emitConstBool( bool , SourceInfo);
12651	#endif
12652	#ifdef GET_LINK_IMPL
12653	bool ByteCodeEmitter::emitConstBool( bool A0, SourceInfo L) {
12654	return emitOp<bool>(OP_ConstBool, A0, L);
12655	}
12656	#endif
12657	#ifdef GET_EVAL_IMPL
12658	bool EvalEmitter::emitConstBool( bool A0, SourceInfo L) {
12659	if (!isActive()) return true;
12660	CurrentSource = L;
12661	return Const<PT_Bool>(S, A0);
12662	}
12663	#endif
12664	#ifdef GET_OPCODE_NAMES
12665	OP_ConstFixedPoint,
12666	#endif
12667	#ifdef GET_INTERPFN_LIST
12668	&Interp_ConstFixedPoint,
12669	#endif
12670	#ifdef GET_INTERPFN_DISPATCHERS
12671	PRESERVE_NONE
12672	static bool Interp_ConstFixedPoint(InterpState &S) {
12673	{
12674	const auto &V0 = ReadArg<FixedPoint>(S, S.PC);
12675	Const<PT_FixedPoint>(S, V0);
12676	}
12677	#if USE_TAILCALLS
12678	MUSTTAIL return InterpNext(S);
12679	#else
12680	return true;
12681	#endif
12682	}
12683	#endif
12684	#ifdef GET_DISASM
12685	case OP_ConstFixedPoint:
12686	Text.Op = PrintName("ConstFixedPoint");
12687	Text.Args.push_back(printArg<FixedPoint>(P, PC));
12688	break;
12689	#endif
12690	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12691	bool emitConstFixedPoint(const FixedPoint &, SourceInfo);
12692	#endif
12693	#ifdef GET_LINK_IMPL
12694	bool ByteCodeEmitter::emitConstFixedPoint(const FixedPoint &A0, SourceInfo L) {
12695	return emitOp<FixedPoint>(OP_ConstFixedPoint, A0, L);
12696	}
12697	#endif
12698	#ifdef GET_EVAL_IMPL
12699	bool EvalEmitter::emitConstFixedPoint(const FixedPoint &A0, SourceInfo L) {
12700	if (!isActive()) return true;
12701	CurrentSource = L;
12702	return Const<PT_FixedPoint>(S, A0);
12703	}
12704	#endif
12705	#ifdef GET_OPCODE_NAMES
12706	OP_ConstFloat,
12707	#endif
12708	#ifdef GET_INTERPFN_LIST
12709	&Interp_ConstFloat,
12710	#endif
12711	#ifdef GET_INTERPFN_DISPATCHERS
12712	PRESERVE_NONE
12713	static bool Interp_ConstFloat(InterpState &S) {
12714	{
12715	const auto &V0 = ReadArg<Floating>(S, S.PC);
12716	ConstFloat(S, V0);
12717	}
12718	#if USE_TAILCALLS
12719	MUSTTAIL return InterpNext(S);
12720	#else
12721	return true;
12722	#endif
12723	}
12724	#endif
12725	#ifdef GET_DISASM
12726	case OP_ConstFloat:
12727	Text.Op = PrintName("ConstFloat");
12728	Text.Args.push_back(printArg<Floating>(P, PC));
12729	break;
12730	#endif
12731	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12732	bool emitConstFloat(const Floating &, SourceInfo);
12733	#endif
12734	#ifdef GET_LINK_IMPL
12735	bool ByteCodeEmitter::emitConstFloat(const Floating &A0, SourceInfo L) {
12736	return emitOp<Floating>(OP_ConstFloat, A0, L);
12737	}
12738	#endif
12739	#ifdef GET_EVAL_IMPL
12740	bool EvalEmitter::emitConstFloat(const Floating &A0, SourceInfo L) {
12741	if (!isActive()) return true;
12742	CurrentSource = L;
12743	return ConstFloat(S, A0);
12744	}
12745	#endif
12746	#ifdef GET_OPCODE_NAMES
12747	OP_ConstIntAP,
12748	#endif
12749	#ifdef GET_INTERPFN_LIST
12750	&Interp_ConstIntAP,
12751	#endif
12752	#ifdef GET_INTERPFN_DISPATCHERS
12753	PRESERVE_NONE
12754	static bool Interp_ConstIntAP(InterpState &S) {
12755	{
12756	const auto &V0 = ReadArg<IntegralAP<false>>(S, S.PC);
12757	Const<PT_IntAP>(S, V0);
12758	}
12759	#if USE_TAILCALLS
12760	MUSTTAIL return InterpNext(S);
12761	#else
12762	return true;
12763	#endif
12764	}
12765	#endif
12766	#ifdef GET_DISASM
12767	case OP_ConstIntAP:
12768	Text.Op = PrintName("ConstIntAP");
12769	Text.Args.push_back(printArg<IntegralAP<false>>(P, PC));
12770	break;
12771	#endif
12772	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12773	bool emitConstIntAP(const IntegralAP<false> &, SourceInfo);
12774	#endif
12775	#ifdef GET_LINK_IMPL
12776	bool ByteCodeEmitter::emitConstIntAP(const IntegralAP<false> &A0, SourceInfo L) {
12777	return emitOp<IntegralAP<false>>(OP_ConstIntAP, A0, L);
12778	}
12779	#endif
12780	#ifdef GET_EVAL_IMPL
12781	bool EvalEmitter::emitConstIntAP(const IntegralAP<false> &A0, SourceInfo L) {
12782	if (!isActive()) return true;
12783	CurrentSource = L;
12784	return Const<PT_IntAP>(S, A0);
12785	}
12786	#endif
12787	#ifdef GET_OPCODE_NAMES
12788	OP_ConstIntAPS,
12789	#endif
12790	#ifdef GET_INTERPFN_LIST
12791	&Interp_ConstIntAPS,
12792	#endif
12793	#ifdef GET_INTERPFN_DISPATCHERS
12794	PRESERVE_NONE
12795	static bool Interp_ConstIntAPS(InterpState &S) {
12796	{
12797	const auto &V0 = ReadArg<IntegralAP<true>>(S, S.PC);
12798	Const<PT_IntAPS>(S, V0);
12799	}
12800	#if USE_TAILCALLS
12801	MUSTTAIL return InterpNext(S);
12802	#else
12803	return true;
12804	#endif
12805	}
12806	#endif
12807	#ifdef GET_DISASM
12808	case OP_ConstIntAPS:
12809	Text.Op = PrintName("ConstIntAPS");
12810	Text.Args.push_back(printArg<IntegralAP<true>>(P, PC));
12811	break;
12812	#endif
12813	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12814	bool emitConstIntAPS(const IntegralAP<true> &, SourceInfo);
12815	#endif
12816	#ifdef GET_LINK_IMPL
12817	bool ByteCodeEmitter::emitConstIntAPS(const IntegralAP<true> &A0, SourceInfo L) {
12818	return emitOp<IntegralAP<true>>(OP_ConstIntAPS, A0, L);
12819	}
12820	#endif
12821	#ifdef GET_EVAL_IMPL
12822	bool EvalEmitter::emitConstIntAPS(const IntegralAP<true> &A0, SourceInfo L) {
12823	if (!isActive()) return true;
12824	CurrentSource = L;
12825	return Const<PT_IntAPS>(S, A0);
12826	}
12827	#endif
12828	#ifdef GET_OPCODE_NAMES
12829	OP_ConstSint8,
12830	#endif
12831	#ifdef GET_INTERPFN_LIST
12832	&Interp_ConstSint8,
12833	#endif
12834	#ifdef GET_INTERPFN_DISPATCHERS
12835	PRESERVE_NONE
12836	static bool Interp_ConstSint8(InterpState &S) {
12837	{
12838	const auto V0 = ReadArg<int8_t>(S, S.PC);
12839	Const<PT_Sint8>(S, V0);
12840	}
12841	#if USE_TAILCALLS
12842	MUSTTAIL return InterpNext(S);
12843	#else
12844	return true;
12845	#endif
12846	}
12847	#endif
12848	#ifdef GET_DISASM
12849	case OP_ConstSint8:
12850	Text.Op = PrintName("ConstSint8");
12851	Text.Args.push_back(printArg<int8_t>(P, PC));
12852	break;
12853	#endif
12854	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12855	bool emitConstSint8( int8_t , SourceInfo);
12856	#endif
12857	#ifdef GET_LINK_IMPL
12858	bool ByteCodeEmitter::emitConstSint8( int8_t A0, SourceInfo L) {
12859	return emitOp<int8_t>(OP_ConstSint8, A0, L);
12860	}
12861	#endif
12862	#ifdef GET_EVAL_IMPL
12863	bool EvalEmitter::emitConstSint8( int8_t A0, SourceInfo L) {
12864	if (!isActive()) return true;
12865	CurrentSource = L;
12866	return Const<PT_Sint8>(S, A0);
12867	}
12868	#endif
12869	#ifdef GET_OPCODE_NAMES
12870	OP_ConstSint16,
12871	#endif
12872	#ifdef GET_INTERPFN_LIST
12873	&Interp_ConstSint16,
12874	#endif
12875	#ifdef GET_INTERPFN_DISPATCHERS
12876	PRESERVE_NONE
12877	static bool Interp_ConstSint16(InterpState &S) {
12878	{
12879	const auto V0 = ReadArg<int16_t>(S, S.PC);
12880	Const<PT_Sint16>(S, V0);
12881	}
12882	#if USE_TAILCALLS
12883	MUSTTAIL return InterpNext(S);
12884	#else
12885	return true;
12886	#endif
12887	}
12888	#endif
12889	#ifdef GET_DISASM
12890	case OP_ConstSint16:
12891	Text.Op = PrintName("ConstSint16");
12892	Text.Args.push_back(printArg<int16_t>(P, PC));
12893	break;
12894	#endif
12895	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12896	bool emitConstSint16( int16_t , SourceInfo);
12897	#endif
12898	#ifdef GET_LINK_IMPL
12899	bool ByteCodeEmitter::emitConstSint16( int16_t A0, SourceInfo L) {
12900	return emitOp<int16_t>(OP_ConstSint16, A0, L);
12901	}
12902	#endif
12903	#ifdef GET_EVAL_IMPL
12904	bool EvalEmitter::emitConstSint16( int16_t A0, SourceInfo L) {
12905	if (!isActive()) return true;
12906	CurrentSource = L;
12907	return Const<PT_Sint16>(S, A0);
12908	}
12909	#endif
12910	#ifdef GET_OPCODE_NAMES
12911	OP_ConstSint32,
12912	#endif
12913	#ifdef GET_INTERPFN_LIST
12914	&Interp_ConstSint32,
12915	#endif
12916	#ifdef GET_INTERPFN_DISPATCHERS
12917	PRESERVE_NONE
12918	static bool Interp_ConstSint32(InterpState &S) {
12919	{
12920	const auto V0 = ReadArg<int32_t>(S, S.PC);
12921	Const<PT_Sint32>(S, V0);
12922	}
12923	#if USE_TAILCALLS
12924	MUSTTAIL return InterpNext(S);
12925	#else
12926	return true;
12927	#endif
12928	}
12929	#endif
12930	#ifdef GET_DISASM
12931	case OP_ConstSint32:
12932	Text.Op = PrintName("ConstSint32");
12933	Text.Args.push_back(printArg<int32_t>(P, PC));
12934	break;
12935	#endif
12936	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12937	bool emitConstSint32( int32_t , SourceInfo);
12938	#endif
12939	#ifdef GET_LINK_IMPL
12940	bool ByteCodeEmitter::emitConstSint32( int32_t A0, SourceInfo L) {
12941	return emitOp<int32_t>(OP_ConstSint32, A0, L);
12942	}
12943	#endif
12944	#ifdef GET_EVAL_IMPL
12945	bool EvalEmitter::emitConstSint32( int32_t A0, SourceInfo L) {
12946	if (!isActive()) return true;
12947	CurrentSource = L;
12948	return Const<PT_Sint32>(S, A0);
12949	}
12950	#endif
12951	#ifdef GET_OPCODE_NAMES
12952	OP_ConstSint64,
12953	#endif
12954	#ifdef GET_INTERPFN_LIST
12955	&Interp_ConstSint64,
12956	#endif
12957	#ifdef GET_INTERPFN_DISPATCHERS
12958	PRESERVE_NONE
12959	static bool Interp_ConstSint64(InterpState &S) {
12960	{
12961	const auto V0 = ReadArg<int64_t>(S, S.PC);
12962	Const<PT_Sint64>(S, V0);
12963	}
12964	#if USE_TAILCALLS
12965	MUSTTAIL return InterpNext(S);
12966	#else
12967	return true;
12968	#endif
12969	}
12970	#endif
12971	#ifdef GET_DISASM
12972	case OP_ConstSint64:
12973	Text.Op = PrintName("ConstSint64");
12974	Text.Args.push_back(printArg<int64_t>(P, PC));
12975	break;
12976	#endif
12977	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
12978	bool emitConstSint64( int64_t , SourceInfo);
12979	#endif
12980	#ifdef GET_LINK_IMPL
12981	bool ByteCodeEmitter::emitConstSint64( int64_t A0, SourceInfo L) {
12982	return emitOp<int64_t>(OP_ConstSint64, A0, L);
12983	}
12984	#endif
12985	#ifdef GET_EVAL_IMPL
12986	bool EvalEmitter::emitConstSint64( int64_t A0, SourceInfo L) {
12987	if (!isActive()) return true;
12988	CurrentSource = L;
12989	return Const<PT_Sint64>(S, A0);
12990	}
12991	#endif
12992	#ifdef GET_OPCODE_NAMES
12993	OP_ConstUint8,
12994	#endif
12995	#ifdef GET_INTERPFN_LIST
12996	&Interp_ConstUint8,
12997	#endif
12998	#ifdef GET_INTERPFN_DISPATCHERS
12999	PRESERVE_NONE
13000	static bool Interp_ConstUint8(InterpState &S) {
13001	{
13002	const auto V0 = ReadArg<uint8_t>(S, S.PC);
13003	Const<PT_Uint8>(S, V0);
13004	}
13005	#if USE_TAILCALLS
13006	MUSTTAIL return InterpNext(S);
13007	#else
13008	return true;
13009	#endif
13010	}
13011	#endif
13012	#ifdef GET_DISASM
13013	case OP_ConstUint8:
13014	Text.Op = PrintName("ConstUint8");
13015	Text.Args.push_back(printArg<uint8_t>(P, PC));
13016	break;
13017	#endif
13018	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13019	bool emitConstUint8( uint8_t , SourceInfo);
13020	#endif
13021	#ifdef GET_LINK_IMPL
13022	bool ByteCodeEmitter::emitConstUint8( uint8_t A0, SourceInfo L) {
13023	return emitOp<uint8_t>(OP_ConstUint8, A0, L);
13024	}
13025	#endif
13026	#ifdef GET_EVAL_IMPL
13027	bool EvalEmitter::emitConstUint8( uint8_t A0, SourceInfo L) {
13028	if (!isActive()) return true;
13029	CurrentSource = L;
13030	return Const<PT_Uint8>(S, A0);
13031	}
13032	#endif
13033	#ifdef GET_OPCODE_NAMES
13034	OP_ConstUint16,
13035	#endif
13036	#ifdef GET_INTERPFN_LIST
13037	&Interp_ConstUint16,
13038	#endif
13039	#ifdef GET_INTERPFN_DISPATCHERS
13040	PRESERVE_NONE
13041	static bool Interp_ConstUint16(InterpState &S) {
13042	{
13043	const auto V0 = ReadArg<uint16_t>(S, S.PC);
13044	Const<PT_Uint16>(S, V0);
13045	}
13046	#if USE_TAILCALLS
13047	MUSTTAIL return InterpNext(S);
13048	#else
13049	return true;
13050	#endif
13051	}
13052	#endif
13053	#ifdef GET_DISASM
13054	case OP_ConstUint16:
13055	Text.Op = PrintName("ConstUint16");
13056	Text.Args.push_back(printArg<uint16_t>(P, PC));
13057	break;
13058	#endif
13059	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13060	bool emitConstUint16( uint16_t , SourceInfo);
13061	#endif
13062	#ifdef GET_LINK_IMPL
13063	bool ByteCodeEmitter::emitConstUint16( uint16_t A0, SourceInfo L) {
13064	return emitOp<uint16_t>(OP_ConstUint16, A0, L);
13065	}
13066	#endif
13067	#ifdef GET_EVAL_IMPL
13068	bool EvalEmitter::emitConstUint16( uint16_t A0, SourceInfo L) {
13069	if (!isActive()) return true;
13070	CurrentSource = L;
13071	return Const<PT_Uint16>(S, A0);
13072	}
13073	#endif
13074	#ifdef GET_OPCODE_NAMES
13075	OP_ConstUint32,
13076	#endif
13077	#ifdef GET_INTERPFN_LIST
13078	&Interp_ConstUint32,
13079	#endif
13080	#ifdef GET_INTERPFN_DISPATCHERS
13081	PRESERVE_NONE
13082	static bool Interp_ConstUint32(InterpState &S) {
13083	{
13084	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13085	Const<PT_Uint32>(S, V0);
13086	}
13087	#if USE_TAILCALLS
13088	MUSTTAIL return InterpNext(S);
13089	#else
13090	return true;
13091	#endif
13092	}
13093	#endif
13094	#ifdef GET_DISASM
13095	case OP_ConstUint32:
13096	Text.Op = PrintName("ConstUint32");
13097	Text.Args.push_back(printArg<uint32_t>(P, PC));
13098	break;
13099	#endif
13100	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13101	bool emitConstUint32( uint32_t , SourceInfo);
13102	#endif
13103	#ifdef GET_LINK_IMPL
13104	bool ByteCodeEmitter::emitConstUint32( uint32_t A0, SourceInfo L) {
13105	return emitOp<uint32_t>(OP_ConstUint32, A0, L);
13106	}
13107	#endif
13108	#ifdef GET_EVAL_IMPL
13109	bool EvalEmitter::emitConstUint32( uint32_t A0, SourceInfo L) {
13110	if (!isActive()) return true;
13111	CurrentSource = L;
13112	return Const<PT_Uint32>(S, A0);
13113	}
13114	#endif
13115	#ifdef GET_OPCODE_NAMES
13116	OP_ConstUint64,
13117	#endif
13118	#ifdef GET_INTERPFN_LIST
13119	&Interp_ConstUint64,
13120	#endif
13121	#ifdef GET_INTERPFN_DISPATCHERS
13122	PRESERVE_NONE
13123	static bool Interp_ConstUint64(InterpState &S) {
13124	{
13125	const auto V0 = ReadArg<uint64_t>(S, S.PC);
13126	Const<PT_Uint64>(S, V0);
13127	}
13128	#if USE_TAILCALLS
13129	MUSTTAIL return InterpNext(S);
13130	#else
13131	return true;
13132	#endif
13133	}
13134	#endif
13135	#ifdef GET_DISASM
13136	case OP_ConstUint64:
13137	Text.Op = PrintName("ConstUint64");
13138	Text.Args.push_back(printArg<uint64_t>(P, PC));
13139	break;
13140	#endif
13141	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13142	bool emitConstUint64( uint64_t , SourceInfo);
13143	#endif
13144	#ifdef GET_LINK_IMPL
13145	bool ByteCodeEmitter::emitConstUint64( uint64_t A0, SourceInfo L) {
13146	return emitOp<uint64_t>(OP_ConstUint64, A0, L);
13147	}
13148	#endif
13149	#ifdef GET_EVAL_IMPL
13150	bool EvalEmitter::emitConstUint64( uint64_t A0, SourceInfo L) {
13151	if (!isActive()) return true;
13152	CurrentSource = L;
13153	return Const<PT_Uint64>(S, A0);
13154	}
13155	#endif
13156	#ifdef GET_OPCODE_NAMES
13157	OP_CopyArraySint8,
13158	OP_CopyArrayUint8,
13159	OP_CopyArraySint16,
13160	OP_CopyArrayUint16,
13161	OP_CopyArraySint32,
13162	OP_CopyArrayUint32,
13163	OP_CopyArraySint64,
13164	OP_CopyArrayUint64,
13165	OP_CopyArrayIntAP,
13166	OP_CopyArrayIntAPS,
13167	OP_CopyArrayBool,
13168	OP_CopyArrayFixedPoint,
13169	OP_CopyArrayPtr,
13170	OP_CopyArrayMemberPtr,
13171	OP_CopyArrayFloat,
13172	#endif
13173	#ifdef GET_INTERPFN_LIST
13174	&Interp_CopyArraySint8,
13175	&Interp_CopyArrayUint8,
13176	&Interp_CopyArraySint16,
13177	&Interp_CopyArrayUint16,
13178	&Interp_CopyArraySint32,
13179	&Interp_CopyArrayUint32,
13180	&Interp_CopyArraySint64,
13181	&Interp_CopyArrayUint64,
13182	&Interp_CopyArrayIntAP,
13183	&Interp_CopyArrayIntAPS,
13184	&Interp_CopyArrayBool,
13185	&Interp_CopyArrayFixedPoint,
13186	&Interp_CopyArrayPtr,
13187	&Interp_CopyArrayMemberPtr,
13188	&Interp_CopyArrayFloat,
13189	#endif
13190	#ifdef GET_INTERPFN_DISPATCHERS
13191	PRESERVE_NONE
13192	static bool Interp_CopyArraySint8(InterpState &S) {
13193	{
13194	CodePtr OpPC = S.PC;
13195	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13196	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13197	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13198	if (!CopyArray<PT_Sint8>(S, OpPC, V0, V1, V2)) return false;
13199	}
13200	#if USE_TAILCALLS
13201	MUSTTAIL return InterpNext(S);
13202	#else
13203	return true;
13204	#endif
13205	}
13206	PRESERVE_NONE
13207	static bool Interp_CopyArrayUint8(InterpState &S) {
13208	{
13209	CodePtr OpPC = S.PC;
13210	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13211	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13212	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13213	if (!CopyArray<PT_Uint8>(S, OpPC, V0, V1, V2)) return false;
13214	}
13215	#if USE_TAILCALLS
13216	MUSTTAIL return InterpNext(S);
13217	#else
13218	return true;
13219	#endif
13220	}
13221	PRESERVE_NONE
13222	static bool Interp_CopyArraySint16(InterpState &S) {
13223	{
13224	CodePtr OpPC = S.PC;
13225	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13226	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13227	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13228	if (!CopyArray<PT_Sint16>(S, OpPC, V0, V1, V2)) return false;
13229	}
13230	#if USE_TAILCALLS
13231	MUSTTAIL return InterpNext(S);
13232	#else
13233	return true;
13234	#endif
13235	}
13236	PRESERVE_NONE
13237	static bool Interp_CopyArrayUint16(InterpState &S) {
13238	{
13239	CodePtr OpPC = S.PC;
13240	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13241	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13242	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13243	if (!CopyArray<PT_Uint16>(S, OpPC, V0, V1, V2)) return false;
13244	}
13245	#if USE_TAILCALLS
13246	MUSTTAIL return InterpNext(S);
13247	#else
13248	return true;
13249	#endif
13250	}
13251	PRESERVE_NONE
13252	static bool Interp_CopyArraySint32(InterpState &S) {
13253	{
13254	CodePtr OpPC = S.PC;
13255	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13256	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13257	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13258	if (!CopyArray<PT_Sint32>(S, OpPC, V0, V1, V2)) return false;
13259	}
13260	#if USE_TAILCALLS
13261	MUSTTAIL return InterpNext(S);
13262	#else
13263	return true;
13264	#endif
13265	}
13266	PRESERVE_NONE
13267	static bool Interp_CopyArrayUint32(InterpState &S) {
13268	{
13269	CodePtr OpPC = S.PC;
13270	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13271	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13272	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13273	if (!CopyArray<PT_Uint32>(S, OpPC, V0, V1, V2)) return false;
13274	}
13275	#if USE_TAILCALLS
13276	MUSTTAIL return InterpNext(S);
13277	#else
13278	return true;
13279	#endif
13280	}
13281	PRESERVE_NONE
13282	static bool Interp_CopyArraySint64(InterpState &S) {
13283	{
13284	CodePtr OpPC = S.PC;
13285	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13286	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13287	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13288	if (!CopyArray<PT_Sint64>(S, OpPC, V0, V1, V2)) return false;
13289	}
13290	#if USE_TAILCALLS
13291	MUSTTAIL return InterpNext(S);
13292	#else
13293	return true;
13294	#endif
13295	}
13296	PRESERVE_NONE
13297	static bool Interp_CopyArrayUint64(InterpState &S) {
13298	{
13299	CodePtr OpPC = S.PC;
13300	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13301	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13302	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13303	if (!CopyArray<PT_Uint64>(S, OpPC, V0, V1, V2)) return false;
13304	}
13305	#if USE_TAILCALLS
13306	MUSTTAIL return InterpNext(S);
13307	#else
13308	return true;
13309	#endif
13310	}
13311	PRESERVE_NONE
13312	static bool Interp_CopyArrayIntAP(InterpState &S) {
13313	{
13314	CodePtr OpPC = S.PC;
13315	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13316	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13317	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13318	if (!CopyArray<PT_IntAP>(S, OpPC, V0, V1, V2)) return false;
13319	}
13320	#if USE_TAILCALLS
13321	MUSTTAIL return InterpNext(S);
13322	#else
13323	return true;
13324	#endif
13325	}
13326	PRESERVE_NONE
13327	static bool Interp_CopyArrayIntAPS(InterpState &S) {
13328	{
13329	CodePtr OpPC = S.PC;
13330	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13331	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13332	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13333	if (!CopyArray<PT_IntAPS>(S, OpPC, V0, V1, V2)) return false;
13334	}
13335	#if USE_TAILCALLS
13336	MUSTTAIL return InterpNext(S);
13337	#else
13338	return true;
13339	#endif
13340	}
13341	PRESERVE_NONE
13342	static bool Interp_CopyArrayBool(InterpState &S) {
13343	{
13344	CodePtr OpPC = S.PC;
13345	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13346	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13347	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13348	if (!CopyArray<PT_Bool>(S, OpPC, V0, V1, V2)) return false;
13349	}
13350	#if USE_TAILCALLS
13351	MUSTTAIL return InterpNext(S);
13352	#else
13353	return true;
13354	#endif
13355	}
13356	PRESERVE_NONE
13357	static bool Interp_CopyArrayFixedPoint(InterpState &S) {
13358	{
13359	CodePtr OpPC = S.PC;
13360	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13361	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13362	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13363	if (!CopyArray<PT_FixedPoint>(S, OpPC, V0, V1, V2)) return false;
13364	}
13365	#if USE_TAILCALLS
13366	MUSTTAIL return InterpNext(S);
13367	#else
13368	return true;
13369	#endif
13370	}
13371	PRESERVE_NONE
13372	static bool Interp_CopyArrayPtr(InterpState &S) {
13373	{
13374	CodePtr OpPC = S.PC;
13375	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13376	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13377	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13378	if (!CopyArray<PT_Ptr>(S, OpPC, V0, V1, V2)) return false;
13379	}
13380	#if USE_TAILCALLS
13381	MUSTTAIL return InterpNext(S);
13382	#else
13383	return true;
13384	#endif
13385	}
13386	PRESERVE_NONE
13387	static bool Interp_CopyArrayMemberPtr(InterpState &S) {
13388	{
13389	CodePtr OpPC = S.PC;
13390	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13391	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13392	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13393	if (!CopyArray<PT_MemberPtr>(S, OpPC, V0, V1, V2)) return false;
13394	}
13395	#if USE_TAILCALLS
13396	MUSTTAIL return InterpNext(S);
13397	#else
13398	return true;
13399	#endif
13400	}
13401	PRESERVE_NONE
13402	static bool Interp_CopyArrayFloat(InterpState &S) {
13403	{
13404	CodePtr OpPC = S.PC;
13405	const auto V0 = ReadArg<uint32_t>(S, S.PC);
13406	const auto V1 = ReadArg<uint32_t>(S, S.PC);
13407	const auto V2 = ReadArg<uint32_t>(S, S.PC);
13408	if (!CopyArray<PT_Float>(S, OpPC, V0, V1, V2)) return false;
13409	}
13410	#if USE_TAILCALLS
13411	MUSTTAIL return InterpNext(S);
13412	#else
13413	return true;
13414	#endif
13415	}
13416	#endif
13417	#ifdef GET_DISASM
13418	case OP_CopyArraySint8:
13419	Text.Op = PrintName("CopyArraySint8");
13420	Text.Args.push_back(printArg<uint32_t>(P, PC));
13421	Text.Args.push_back(printArg<uint32_t>(P, PC));
13422	Text.Args.push_back(printArg<uint32_t>(P, PC));
13423	break;
13424	case OP_CopyArrayUint8:
13425	Text.Op = PrintName("CopyArrayUint8");
13426	Text.Args.push_back(printArg<uint32_t>(P, PC));
13427	Text.Args.push_back(printArg<uint32_t>(P, PC));
13428	Text.Args.push_back(printArg<uint32_t>(P, PC));
13429	break;
13430	case OP_CopyArraySint16:
13431	Text.Op = PrintName("CopyArraySint16");
13432	Text.Args.push_back(printArg<uint32_t>(P, PC));
13433	Text.Args.push_back(printArg<uint32_t>(P, PC));
13434	Text.Args.push_back(printArg<uint32_t>(P, PC));
13435	break;
13436	case OP_CopyArrayUint16:
13437	Text.Op = PrintName("CopyArrayUint16");
13438	Text.Args.push_back(printArg<uint32_t>(P, PC));
13439	Text.Args.push_back(printArg<uint32_t>(P, PC));
13440	Text.Args.push_back(printArg<uint32_t>(P, PC));
13441	break;
13442	case OP_CopyArraySint32:
13443	Text.Op = PrintName("CopyArraySint32");
13444	Text.Args.push_back(printArg<uint32_t>(P, PC));
13445	Text.Args.push_back(printArg<uint32_t>(P, PC));
13446	Text.Args.push_back(printArg<uint32_t>(P, PC));
13447	break;
13448	case OP_CopyArrayUint32:
13449	Text.Op = PrintName("CopyArrayUint32");
13450	Text.Args.push_back(printArg<uint32_t>(P, PC));
13451	Text.Args.push_back(printArg<uint32_t>(P, PC));
13452	Text.Args.push_back(printArg<uint32_t>(P, PC));
13453	break;
13454	case OP_CopyArraySint64:
13455	Text.Op = PrintName("CopyArraySint64");
13456	Text.Args.push_back(printArg<uint32_t>(P, PC));
13457	Text.Args.push_back(printArg<uint32_t>(P, PC));
13458	Text.Args.push_back(printArg<uint32_t>(P, PC));
13459	break;
13460	case OP_CopyArrayUint64:
13461	Text.Op = PrintName("CopyArrayUint64");
13462	Text.Args.push_back(printArg<uint32_t>(P, PC));
13463	Text.Args.push_back(printArg<uint32_t>(P, PC));
13464	Text.Args.push_back(printArg<uint32_t>(P, PC));
13465	break;
13466	case OP_CopyArrayIntAP:
13467	Text.Op = PrintName("CopyArrayIntAP");
13468	Text.Args.push_back(printArg<uint32_t>(P, PC));
13469	Text.Args.push_back(printArg<uint32_t>(P, PC));
13470	Text.Args.push_back(printArg<uint32_t>(P, PC));
13471	break;
13472	case OP_CopyArrayIntAPS:
13473	Text.Op = PrintName("CopyArrayIntAPS");
13474	Text.Args.push_back(printArg<uint32_t>(P, PC));
13475	Text.Args.push_back(printArg<uint32_t>(P, PC));
13476	Text.Args.push_back(printArg<uint32_t>(P, PC));
13477	break;
13478	case OP_CopyArrayBool:
13479	Text.Op = PrintName("CopyArrayBool");
13480	Text.Args.push_back(printArg<uint32_t>(P, PC));
13481	Text.Args.push_back(printArg<uint32_t>(P, PC));
13482	Text.Args.push_back(printArg<uint32_t>(P, PC));
13483	break;
13484	case OP_CopyArrayFixedPoint:
13485	Text.Op = PrintName("CopyArrayFixedPoint");
13486	Text.Args.push_back(printArg<uint32_t>(P, PC));
13487	Text.Args.push_back(printArg<uint32_t>(P, PC));
13488	Text.Args.push_back(printArg<uint32_t>(P, PC));
13489	break;
13490	case OP_CopyArrayPtr:
13491	Text.Op = PrintName("CopyArrayPtr");
13492	Text.Args.push_back(printArg<uint32_t>(P, PC));
13493	Text.Args.push_back(printArg<uint32_t>(P, PC));
13494	Text.Args.push_back(printArg<uint32_t>(P, PC));
13495	break;
13496	case OP_CopyArrayMemberPtr:
13497	Text.Op = PrintName("CopyArrayMemberPtr");
13498	Text.Args.push_back(printArg<uint32_t>(P, PC));
13499	Text.Args.push_back(printArg<uint32_t>(P, PC));
13500	Text.Args.push_back(printArg<uint32_t>(P, PC));
13501	break;
13502	case OP_CopyArrayFloat:
13503	Text.Op = PrintName("CopyArrayFloat");
13504	Text.Args.push_back(printArg<uint32_t>(P, PC));
13505	Text.Args.push_back(printArg<uint32_t>(P, PC));
13506	Text.Args.push_back(printArg<uint32_t>(P, PC));
13507	break;
13508	#endif
13509	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13510	bool emitCopyArraySint8( uint32_t , uint32_t , uint32_t , SourceInfo);
13511	bool emitCopyArrayUint8( uint32_t , uint32_t , uint32_t , SourceInfo);
13512	bool emitCopyArraySint16( uint32_t , uint32_t , uint32_t , SourceInfo);
13513	bool emitCopyArrayUint16( uint32_t , uint32_t , uint32_t , SourceInfo);
13514	bool emitCopyArraySint32( uint32_t , uint32_t , uint32_t , SourceInfo);
13515	bool emitCopyArrayUint32( uint32_t , uint32_t , uint32_t , SourceInfo);
13516	bool emitCopyArraySint64( uint32_t , uint32_t , uint32_t , SourceInfo);
13517	bool emitCopyArrayUint64( uint32_t , uint32_t , uint32_t , SourceInfo);
13518	bool emitCopyArrayIntAP( uint32_t , uint32_t , uint32_t , SourceInfo);
13519	bool emitCopyArrayIntAPS( uint32_t , uint32_t , uint32_t , SourceInfo);
13520	bool emitCopyArrayBool( uint32_t , uint32_t , uint32_t , SourceInfo);
13521	bool emitCopyArrayFixedPoint( uint32_t , uint32_t , uint32_t , SourceInfo);
13522	bool emitCopyArrayPtr( uint32_t , uint32_t , uint32_t , SourceInfo);
13523	bool emitCopyArrayMemberPtr( uint32_t , uint32_t , uint32_t , SourceInfo);
13524	bool emitCopyArrayFloat( uint32_t , uint32_t , uint32_t , SourceInfo);
13525	#endif
13526	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13527	[[nodiscard]] bool emitCopyArray(PrimType, uint32_t, uint32_t, uint32_t, SourceInfo I);
13528	#endif
13529	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
13530	bool
13531	#if defined(GET_EVAL_IMPL)
13532	EvalEmitter
13533	#else
13534	ByteCodeEmitter
13535	#endif
13536	::emitCopyArray(PrimType T0, uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo I) {
13537	switch (T0) {
13538	case PT_Sint8:
13539	return emitCopyArraySint8(A0, A1, A2, I);
13540	case PT_Uint8:
13541	return emitCopyArrayUint8(A0, A1, A2, I);
13542	case PT_Sint16:
13543	return emitCopyArraySint16(A0, A1, A2, I);
13544	case PT_Uint16:
13545	return emitCopyArrayUint16(A0, A1, A2, I);
13546	case PT_Sint32:
13547	return emitCopyArraySint32(A0, A1, A2, I);
13548	case PT_Uint32:
13549	return emitCopyArrayUint32(A0, A1, A2, I);
13550	case PT_Sint64:
13551	return emitCopyArraySint64(A0, A1, A2, I);
13552	case PT_Uint64:
13553	return emitCopyArrayUint64(A0, A1, A2, I);
13554	case PT_IntAP:
13555	return emitCopyArrayIntAP(A0, A1, A2, I);
13556	case PT_IntAPS:
13557	return emitCopyArrayIntAPS(A0, A1, A2, I);
13558	case PT_Bool:
13559	return emitCopyArrayBool(A0, A1, A2, I);
13560	case PT_FixedPoint:
13561	return emitCopyArrayFixedPoint(A0, A1, A2, I);
13562	case PT_Ptr:
13563	return emitCopyArrayPtr(A0, A1, A2, I);
13564	case PT_MemberPtr:
13565	return emitCopyArrayMemberPtr(A0, A1, A2, I);
13566	case PT_Float:
13567	return emitCopyArrayFloat(A0, A1, A2, I);
13568	}
13569	llvm_unreachable("invalid enum value");
13570	}
13571	#endif
13572	#ifdef GET_LINK_IMPL
13573	bool ByteCodeEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13574	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint8, A0, A1, A2, L);
13575	}
13576	bool ByteCodeEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13577	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint8, A0, A1, A2, L);
13578	}
13579	bool ByteCodeEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13580	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint16, A0, A1, A2, L);
13581	}
13582	bool ByteCodeEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13583	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint16, A0, A1, A2, L);
13584	}
13585	bool ByteCodeEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13586	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint32, A0, A1, A2, L);
13587	}
13588	bool ByteCodeEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13589	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint32, A0, A1, A2, L);
13590	}
13591	bool ByteCodeEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13592	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint64, A0, A1, A2, L);
13593	}
13594	bool ByteCodeEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13595	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint64, A0, A1, A2, L);
13596	}
13597	bool ByteCodeEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13598	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayIntAP, A0, A1, A2, L);
13599	}
13600	bool ByteCodeEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13601	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayIntAPS, A0, A1, A2, L);
13602	}
13603	bool ByteCodeEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13604	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayBool, A0, A1, A2, L);
13605	}
13606	bool ByteCodeEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13607	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayFixedPoint, A0, A1, A2, L);
13608	}
13609	bool ByteCodeEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13610	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayPtr, A0, A1, A2, L);
13611	}
13612	bool ByteCodeEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13613	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayMemberPtr, A0, A1, A2, L);
13614	}
13615	bool ByteCodeEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13616	return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayFloat, A0, A1, A2, L);
13617	}
13618	#endif
13619	#ifdef GET_EVAL_IMPL
13620	bool EvalEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13621	if (!isActive()) return true;
13622	CurrentSource = L;
13623	return CopyArray<PT_Sint8>(S, CodePtr(), A0, A1, A2);
13624	}
13625	bool EvalEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13626	if (!isActive()) return true;
13627	CurrentSource = L;
13628	return CopyArray<PT_Uint8>(S, CodePtr(), A0, A1, A2);
13629	}
13630	bool EvalEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13631	if (!isActive()) return true;
13632	CurrentSource = L;
13633	return CopyArray<PT_Sint16>(S, CodePtr(), A0, A1, A2);
13634	}
13635	bool EvalEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13636	if (!isActive()) return true;
13637	CurrentSource = L;
13638	return CopyArray<PT_Uint16>(S, CodePtr(), A0, A1, A2);
13639	}
13640	bool EvalEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13641	if (!isActive()) return true;
13642	CurrentSource = L;
13643	return CopyArray<PT_Sint32>(S, CodePtr(), A0, A1, A2);
13644	}
13645	bool EvalEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13646	if (!isActive()) return true;
13647	CurrentSource = L;
13648	return CopyArray<PT_Uint32>(S, CodePtr(), A0, A1, A2);
13649	}
13650	bool EvalEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13651	if (!isActive()) return true;
13652	CurrentSource = L;
13653	return CopyArray<PT_Sint64>(S, CodePtr(), A0, A1, A2);
13654	}
13655	bool EvalEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13656	if (!isActive()) return true;
13657	CurrentSource = L;
13658	return CopyArray<PT_Uint64>(S, CodePtr(), A0, A1, A2);
13659	}
13660	bool EvalEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13661	if (!isActive()) return true;
13662	CurrentSource = L;
13663	return CopyArray<PT_IntAP>(S, CodePtr(), A0, A1, A2);
13664	}
13665	bool EvalEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13666	if (!isActive()) return true;
13667	CurrentSource = L;
13668	return CopyArray<PT_IntAPS>(S, CodePtr(), A0, A1, A2);
13669	}
13670	bool EvalEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13671	if (!isActive()) return true;
13672	CurrentSource = L;
13673	return CopyArray<PT_Bool>(S, CodePtr(), A0, A1, A2);
13674	}
13675	bool EvalEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13676	if (!isActive()) return true;
13677	CurrentSource = L;
13678	return CopyArray<PT_FixedPoint>(S, CodePtr(), A0, A1, A2);
13679	}
13680	bool EvalEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13681	if (!isActive()) return true;
13682	CurrentSource = L;
13683	return CopyArray<PT_Ptr>(S, CodePtr(), A0, A1, A2);
13684	}
13685	bool EvalEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13686	if (!isActive()) return true;
13687	CurrentSource = L;
13688	return CopyArray<PT_MemberPtr>(S, CodePtr(), A0, A1, A2);
13689	}
13690	bool EvalEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13691	if (!isActive()) return true;
13692	CurrentSource = L;
13693	return CopyArray<PT_Float>(S, CodePtr(), A0, A1, A2);
13694	}
13695	#endif
13696	#ifdef GET_OPCODE_NAMES
13697	OP_CopyMemberPtrPath,
13698	#endif
13699	#ifdef GET_INTERPFN_LIST
13700	&Interp_CopyMemberPtrPath,
13701	#endif
13702	#ifdef GET_INTERPFN_DISPATCHERS
13703	PRESERVE_NONE
13704	static bool Interp_CopyMemberPtrPath(InterpState &S) {
13705	{
13706	const auto V0 = ReadArg<const RecordDecl *>(S, S.PC);
13707	const auto V1 = ReadArg<bool>(S, S.PC);
13708	CopyMemberPtrPath(S, V0, V1);
13709	}
13710	#if USE_TAILCALLS
13711	MUSTTAIL return InterpNext(S);
13712	#else
13713	return true;
13714	#endif
13715	}
13716	#endif
13717	#ifdef GET_DISASM
13718	case OP_CopyMemberPtrPath:
13719	Text.Op = PrintName("CopyMemberPtrPath");
13720	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
13721	Text.Args.push_back(printArg<bool>(P, PC));
13722	break;
13723	#endif
13724	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13725	bool emitCopyMemberPtrPath( const RecordDecl * , bool , SourceInfo);
13726	#endif
13727	#ifdef GET_LINK_IMPL
13728	bool ByteCodeEmitter::emitCopyMemberPtrPath( const RecordDecl * A0, bool A1, SourceInfo L) {
13729	return emitOp<const RecordDecl , bool*>(OP_CopyMemberPtrPath, A0, A1, L);
13730	}
13731	#endif
13732	#ifdef GET_EVAL_IMPL
13733	bool EvalEmitter::emitCopyMemberPtrPath( const RecordDecl * A0, bool A1, SourceInfo L) {
13734	if (!isActive()) return true;
13735	CurrentSource = L;
13736	return CopyMemberPtrPath(S, A0, A1);
13737	}
13738	#endif
13739	#ifdef GET_OPCODE_NAMES
13740	OP_CtorCheck,
13741	#endif
13742	#ifdef GET_INTERPFN_LIST
13743	&Interp_CtorCheck,
13744	#endif
13745	#ifdef GET_INTERPFN_DISPATCHERS
13746	PRESERVE_NONE
13747	static bool Interp_CtorCheck(InterpState &S) {
13748	if (!CtorCheck(S)) return false;
13749	#if USE_TAILCALLS
13750	MUSTTAIL return InterpNext(S);
13751	#else
13752	return true;
13753	#endif
13754	}
13755	#endif
13756	#ifdef GET_DISASM
13757	case OP_CtorCheck:
13758	Text.Op = PrintName("CtorCheck");
13759	break;
13760	#endif
13761	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
13762	bool emitCtorCheck(SourceInfo);
13763	#endif
13764	#ifdef GET_LINK_IMPL
13765	bool ByteCodeEmitter::emitCtorCheck(SourceInfo L) {
13766	return emitOp<>(OP_CtorCheck, L);
13767	}
13768	#endif
13769	#ifdef GET_EVAL_IMPL
13770	bool EvalEmitter::emitCtorCheck(SourceInfo L) {
13771	if (!isActive()) return true;
13772	CurrentSource = L;
13773	return CtorCheck(S);
13774	}
13775	#endif
13776	#ifdef GET_OPCODE_NAMES
13777	OP_DecSint8,
13778	OP_DecUint8,
13779	OP_DecSint16,
13780	OP_DecUint16,
13781	OP_DecSint32,
13782	OP_DecUint32,
13783	OP_DecSint64,
13784	OP_DecUint64,
13785	OP_DecIntAP,
13786	OP_DecIntAPS,
13787	OP_DecBool,
13788	OP_DecFixedPoint,
13789	#endif
13790	#ifdef GET_INTERPFN_LIST
13791	&Interp_DecSint8,
13792	&Interp_DecUint8,
13793	&Interp_DecSint16,
13794	&Interp_DecUint16,
13795	&Interp_DecSint32,
13796	&Interp_DecUint32,
13797	&Interp_DecSint64,
13798	&Interp_DecUint64,
13799	&Interp_DecIntAP,
13800	&Interp_DecIntAPS,
13801	&Interp_DecBool,
13802	&Interp_DecFixedPoint,
13803	#endif
13804	#ifdef GET_INTERPFN_DISPATCHERS
13805	PRESERVE_NONE
13806	static bool Interp_DecSint8(InterpState &S) {
13807	{
13808	CodePtr OpPC = S.PC;
13809	const auto V0 = ReadArg<bool>(S, S.PC);
13810	if (!Dec<PT_Sint8>(S, OpPC, V0)) return false;
13811	}
13812	#if USE_TAILCALLS
13813	MUSTTAIL return InterpNext(S);
13814	#else
13815	return true;
13816	#endif
13817	}
13818	PRESERVE_NONE
13819	static bool Interp_DecUint8(InterpState &S) {
13820	{
13821	CodePtr OpPC = S.PC;
13822	const auto V0 = ReadArg<bool>(S, S.PC);
13823	if (!Dec<PT_Uint8>(S, OpPC, V0)) return false;
13824	}
13825	#if USE_TAILCALLS
13826	MUSTTAIL return InterpNext(S);
13827	#else
13828	return true;
13829	#endif
13830	}
13831	PRESERVE_NONE
13832	static bool Interp_DecSint16(InterpState &S) {
13833	{
13834	CodePtr OpPC = S.PC;
13835	const auto V0 = ReadArg<bool>(S, S.PC);
13836	if (!Dec<PT_Sint16>(S, OpPC, V0)) return false;
13837	}
13838	#if USE_TAILCALLS
13839	MUSTTAIL return InterpNext(S);
13840	#else
13841	return true;
13842	#endif
13843	}
13844	PRESERVE_NONE
13845	static bool Interp_DecUint16(InterpState &S) {
13846	{
13847	CodePtr OpPC = S.PC;
13848	const auto V0 = ReadArg<bool>(S, S.PC);
13849	if (!Dec<PT_Uint16>(S, OpPC, V0)) return false;
13850	}
13851	#if USE_TAILCALLS
13852	MUSTTAIL return InterpNext(S);
13853	#else
13854	return true;
13855	#endif
13856	}
13857	PRESERVE_NONE
13858	static bool Interp_DecSint32(InterpState &S) {
13859	{
13860	CodePtr OpPC = S.PC;
13861	const auto V0 = ReadArg<bool>(S, S.PC);
13862	if (!Dec<PT_Sint32>(S, OpPC, V0)) return false;
13863	}
13864	#if USE_TAILCALLS
13865	MUSTTAIL return InterpNext(S);
13866	#else
13867	return true;
13868	#endif
13869	}
13870	PRESERVE_NONE
13871	static bool Interp_DecUint32(InterpState &S) {
13872	{
13873	CodePtr OpPC = S.PC;
13874	const auto V0 = ReadArg<bool>(S, S.PC);
13875	if (!Dec<PT_Uint32>(S, OpPC, V0)) return false;
13876	}
13877	#if USE_TAILCALLS
13878	MUSTTAIL return InterpNext(S);
13879	#else
13880	return true;
13881	#endif
13882	}
13883	PRESERVE_NONE
13884	static bool Interp_DecSint64(InterpState &S) {
13885	{
13886	CodePtr OpPC = S.PC;
13887	const auto V0 = ReadArg<bool>(S, S.PC);
13888	if (!Dec<PT_Sint64>(S, OpPC, V0)) return false;
13889	}
13890	#if USE_TAILCALLS
13891	MUSTTAIL return InterpNext(S);
13892	#else
13893	return true;
13894	#endif
13895	}
13896	PRESERVE_NONE
13897	static bool Interp_DecUint64(InterpState &S) {
13898	{
13899	CodePtr OpPC = S.PC;
13900	const auto V0 = ReadArg<bool>(S, S.PC);
13901	if (!Dec<PT_Uint64>(S, OpPC, V0)) return false;
13902	}
13903	#if USE_TAILCALLS
13904	MUSTTAIL return InterpNext(S);
13905	#else
13906	return true;
13907	#endif
13908	}
13909	PRESERVE_NONE
13910	static bool Interp_DecIntAP(InterpState &S) {
13911	{
13912	CodePtr OpPC = S.PC;
13913	const auto V0 = ReadArg<bool>(S, S.PC);
13914	if (!Dec<PT_IntAP>(S, OpPC, V0)) return false;
13915	}
13916	#if USE_TAILCALLS
13917	MUSTTAIL return InterpNext(S);
13918	#else
13919	return true;
13920	#endif
13921	}
13922	PRESERVE_NONE
13923	static bool Interp_DecIntAPS(InterpState &S) {
13924	{
13925	CodePtr OpPC = S.PC;
13926	const auto V0 = ReadArg<bool>(S, S.PC);
13927	if (!Dec<PT_IntAPS>(S, OpPC, V0)) return false;
13928	}
13929	#if USE_TAILCALLS
13930	MUSTTAIL return InterpNext(S);
13931	#else
13932	return true;
13933	#endif
13934	}
13935	PRESERVE_NONE
13936	static bool Interp_DecBool(InterpState &S) {
13937	{
13938	CodePtr OpPC = S.PC;
13939	const auto V0 = ReadArg<bool>(S, S.PC);
13940	if (!Dec<PT_Bool>(S, OpPC, V0)) return false;
13941	}
13942	#if USE_TAILCALLS
13943	MUSTTAIL return InterpNext(S);
13944	#else
13945	return true;
13946	#endif
13947	}
13948	PRESERVE_NONE
13949	static bool Interp_DecFixedPoint(InterpState &S) {
13950	{
13951	CodePtr OpPC = S.PC;
13952	const auto V0 = ReadArg<bool>(S, S.PC);
13953	if (!Dec<PT_FixedPoint>(S, OpPC, V0)) return false;
13954	}
13955	#if USE_TAILCALLS
13956	MUSTTAIL return InterpNext(S);
13957	#else
13958	return true;
13959	#endif
13960	}
13961	#endif
13962	#ifdef GET_DISASM
13963	case OP_DecSint8:
13964	Text.Op = PrintName("DecSint8");
13965	Text.Args.push_back(printArg<bool>(P, PC));
13966	break;
13967	case OP_DecUint8:
13968	Text.Op = PrintName("DecUint8");
13969	Text.Args.push_back(printArg<bool>(P, PC));
13970	break;
13971	case OP_DecSint16:
13972	Text.Op = PrintName("DecSint16");
13973	Text.Args.push_back(printArg<bool>(P, PC));
13974	break;
13975	case OP_DecUint16:
13976	Text.Op = PrintName("DecUint16");
13977	Text.Args.push_back(printArg<bool>(P, PC));
13978	break;
13979	case OP_DecSint32:
13980	Text.Op = PrintName("DecSint32");
13981	Text.Args.push_back(printArg<bool>(P, PC));
13982	break;
13983	case OP_DecUint32:
13984	Text.Op = PrintName("DecUint32");
13985	Text.Args.push_back(printArg<bool>(P, PC));
13986	break;
13987	case OP_DecSint64:
13988	Text.Op = PrintName("DecSint64");
13989	Text.Args.push_back(printArg<bool>(P, PC));
13990	break;
13991	case OP_DecUint64:
13992	Text.Op = PrintName("DecUint64");
13993	Text.Args.push_back(printArg<bool>(P, PC));
13994	break;
13995	case OP_DecIntAP:
13996	Text.Op = PrintName("DecIntAP");
13997	Text.Args.push_back(printArg<bool>(P, PC));
13998	break;
13999	case OP_DecIntAPS:
14000	Text.Op = PrintName("DecIntAPS");
14001	Text.Args.push_back(printArg<bool>(P, PC));
14002	break;
14003	case OP_DecBool:
14004	Text.Op = PrintName("DecBool");
14005	Text.Args.push_back(printArg<bool>(P, PC));
14006	break;
14007	case OP_DecFixedPoint:
14008	Text.Op = PrintName("DecFixedPoint");
14009	Text.Args.push_back(printArg<bool>(P, PC));
14010	break;
14011	#endif
14012	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14013	bool emitDecSint8( bool , SourceInfo);
14014	bool emitDecUint8( bool , SourceInfo);
14015	bool emitDecSint16( bool , SourceInfo);
14016	bool emitDecUint16( bool , SourceInfo);
14017	bool emitDecSint32( bool , SourceInfo);
14018	bool emitDecUint32( bool , SourceInfo);
14019	bool emitDecSint64( bool , SourceInfo);
14020	bool emitDecUint64( bool , SourceInfo);
14021	bool emitDecIntAP( bool , SourceInfo);
14022	bool emitDecIntAPS( bool , SourceInfo);
14023	bool emitDecBool( bool , SourceInfo);
14024	bool emitDecFixedPoint( bool , SourceInfo);
14025	#endif
14026	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14027	[[nodiscard]] bool emitDec(PrimType, bool, SourceInfo I);
14028	#endif
14029	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
14030	bool
14031	#if defined(GET_EVAL_IMPL)
14032	EvalEmitter
14033	#else
14034	ByteCodeEmitter
14035	#endif
14036	::emitDec(PrimType T0, bool A0, SourceInfo I) {
14037	switch (T0) {
14038	case PT_Sint8:
14039	return emitDecSint8(A0, I);
14040	case PT_Uint8:
14041	return emitDecUint8(A0, I);
14042	case PT_Sint16:
14043	return emitDecSint16(A0, I);
14044	case PT_Uint16:
14045	return emitDecUint16(A0, I);
14046	case PT_Sint32:
14047	return emitDecSint32(A0, I);
14048	case PT_Uint32:
14049	return emitDecUint32(A0, I);
14050	case PT_Sint64:
14051	return emitDecSint64(A0, I);
14052	case PT_Uint64:
14053	return emitDecUint64(A0, I);
14054	case PT_IntAP:
14055	return emitDecIntAP(A0, I);
14056	case PT_IntAPS:
14057	return emitDecIntAPS(A0, I);
14058	case PT_Bool:
14059	return emitDecBool(A0, I);
14060	case PT_FixedPoint:
14061	return emitDecFixedPoint(A0, I);
14062	default: llvm_unreachable("invalid type: emitDec");
14063	}
14064	llvm_unreachable("invalid enum value");
14065	}
14066	#endif
14067	#ifdef GET_LINK_IMPL
14068	bool ByteCodeEmitter::emitDecSint8( bool A0, SourceInfo L) {
14069	return emitOp<bool>(OP_DecSint8, A0, L);
14070	}
14071	bool ByteCodeEmitter::emitDecUint8( bool A0, SourceInfo L) {
14072	return emitOp<bool>(OP_DecUint8, A0, L);
14073	}
14074	bool ByteCodeEmitter::emitDecSint16( bool A0, SourceInfo L) {
14075	return emitOp<bool>(OP_DecSint16, A0, L);
14076	}
14077	bool ByteCodeEmitter::emitDecUint16( bool A0, SourceInfo L) {
14078	return emitOp<bool>(OP_DecUint16, A0, L);
14079	}
14080	bool ByteCodeEmitter::emitDecSint32( bool A0, SourceInfo L) {
14081	return emitOp<bool>(OP_DecSint32, A0, L);
14082	}
14083	bool ByteCodeEmitter::emitDecUint32( bool A0, SourceInfo L) {
14084	return emitOp<bool>(OP_DecUint32, A0, L);
14085	}
14086	bool ByteCodeEmitter::emitDecSint64( bool A0, SourceInfo L) {
14087	return emitOp<bool>(OP_DecSint64, A0, L);
14088	}
14089	bool ByteCodeEmitter::emitDecUint64( bool A0, SourceInfo L) {
14090	return emitOp<bool>(OP_DecUint64, A0, L);
14091	}
14092	bool ByteCodeEmitter::emitDecIntAP( bool A0, SourceInfo L) {
14093	return emitOp<bool>(OP_DecIntAP, A0, L);
14094	}
14095	bool ByteCodeEmitter::emitDecIntAPS( bool A0, SourceInfo L) {
14096	return emitOp<bool>(OP_DecIntAPS, A0, L);
14097	}
14098	bool ByteCodeEmitter::emitDecBool( bool A0, SourceInfo L) {
14099	return emitOp<bool>(OP_DecBool, A0, L);
14100	}
14101	bool ByteCodeEmitter::emitDecFixedPoint( bool A0, SourceInfo L) {
14102	return emitOp<bool>(OP_DecFixedPoint, A0, L);
14103	}
14104	#endif
14105	#ifdef GET_EVAL_IMPL
14106	bool EvalEmitter::emitDecSint8( bool A0, SourceInfo L) {
14107	if (!isActive()) return true;
14108	CurrentSource = L;
14109	return Dec<PT_Sint8>(S, CodePtr(), A0);
14110	}
14111	bool EvalEmitter::emitDecUint8( bool A0, SourceInfo L) {
14112	if (!isActive()) return true;
14113	CurrentSource = L;
14114	return Dec<PT_Uint8>(S, CodePtr(), A0);
14115	}
14116	bool EvalEmitter::emitDecSint16( bool A0, SourceInfo L) {
14117	if (!isActive()) return true;
14118	CurrentSource = L;
14119	return Dec<PT_Sint16>(S, CodePtr(), A0);
14120	}
14121	bool EvalEmitter::emitDecUint16( bool A0, SourceInfo L) {
14122	if (!isActive()) return true;
14123	CurrentSource = L;
14124	return Dec<PT_Uint16>(S, CodePtr(), A0);
14125	}
14126	bool EvalEmitter::emitDecSint32( bool A0, SourceInfo L) {
14127	if (!isActive()) return true;
14128	CurrentSource = L;
14129	return Dec<PT_Sint32>(S, CodePtr(), A0);
14130	}
14131	bool EvalEmitter::emitDecUint32( bool A0, SourceInfo L) {
14132	if (!isActive()) return true;
14133	CurrentSource = L;
14134	return Dec<PT_Uint32>(S, CodePtr(), A0);
14135	}
14136	bool EvalEmitter::emitDecSint64( bool A0, SourceInfo L) {
14137	if (!isActive()) return true;
14138	CurrentSource = L;
14139	return Dec<PT_Sint64>(S, CodePtr(), A0);
14140	}
14141	bool EvalEmitter::emitDecUint64( bool A0, SourceInfo L) {
14142	if (!isActive()) return true;
14143	CurrentSource = L;
14144	return Dec<PT_Uint64>(S, CodePtr(), A0);
14145	}
14146	bool EvalEmitter::emitDecIntAP( bool A0, SourceInfo L) {
14147	if (!isActive()) return true;
14148	CurrentSource = L;
14149	return Dec<PT_IntAP>(S, CodePtr(), A0);
14150	}
14151	bool EvalEmitter::emitDecIntAPS( bool A0, SourceInfo L) {
14152	if (!isActive()) return true;
14153	CurrentSource = L;
14154	return Dec<PT_IntAPS>(S, CodePtr(), A0);
14155	}
14156	bool EvalEmitter::emitDecBool( bool A0, SourceInfo L) {
14157	if (!isActive()) return true;
14158	CurrentSource = L;
14159	return Dec<PT_Bool>(S, CodePtr(), A0);
14160	}
14161	bool EvalEmitter::emitDecFixedPoint( bool A0, SourceInfo L) {
14162	if (!isActive()) return true;
14163	CurrentSource = L;
14164	return Dec<PT_FixedPoint>(S, CodePtr(), A0);
14165	}
14166	#endif
14167	#ifdef GET_OPCODE_NAMES
14168	OP_DecBitfieldSint8,
14169	OP_DecBitfieldUint8,
14170	OP_DecBitfieldSint16,
14171	OP_DecBitfieldUint16,
14172	OP_DecBitfieldSint32,
14173	OP_DecBitfieldUint32,
14174	OP_DecBitfieldSint64,
14175	OP_DecBitfieldUint64,
14176	OP_DecBitfieldIntAP,
14177	OP_DecBitfieldIntAPS,
14178	OP_DecBitfieldBool,
14179	OP_DecBitfieldFixedPoint,
14180	#endif
14181	#ifdef GET_INTERPFN_LIST
14182	&Interp_DecBitfieldSint8,
14183	&Interp_DecBitfieldUint8,
14184	&Interp_DecBitfieldSint16,
14185	&Interp_DecBitfieldUint16,
14186	&Interp_DecBitfieldSint32,
14187	&Interp_DecBitfieldUint32,
14188	&Interp_DecBitfieldSint64,
14189	&Interp_DecBitfieldUint64,
14190	&Interp_DecBitfieldIntAP,
14191	&Interp_DecBitfieldIntAPS,
14192	&Interp_DecBitfieldBool,
14193	&Interp_DecBitfieldFixedPoint,
14194	#endif
14195	#ifdef GET_INTERPFN_DISPATCHERS
14196	PRESERVE_NONE
14197	static bool Interp_DecBitfieldSint8(InterpState &S) {
14198	{
14199	CodePtr OpPC = S.PC;
14200	const auto V0 = ReadArg<bool>(S, S.PC);
14201	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14202	if (!DecBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
14203	}
14204	#if USE_TAILCALLS
14205	MUSTTAIL return InterpNext(S);
14206	#else
14207	return true;
14208	#endif
14209	}
14210	PRESERVE_NONE
14211	static bool Interp_DecBitfieldUint8(InterpState &S) {
14212	{
14213	CodePtr OpPC = S.PC;
14214	const auto V0 = ReadArg<bool>(S, S.PC);
14215	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14216	if (!DecBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
14217	}
14218	#if USE_TAILCALLS
14219	MUSTTAIL return InterpNext(S);
14220	#else
14221	return true;
14222	#endif
14223	}
14224	PRESERVE_NONE
14225	static bool Interp_DecBitfieldSint16(InterpState &S) {
14226	{
14227	CodePtr OpPC = S.PC;
14228	const auto V0 = ReadArg<bool>(S, S.PC);
14229	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14230	if (!DecBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
14231	}
14232	#if USE_TAILCALLS
14233	MUSTTAIL return InterpNext(S);
14234	#else
14235	return true;
14236	#endif
14237	}
14238	PRESERVE_NONE
14239	static bool Interp_DecBitfieldUint16(InterpState &S) {
14240	{
14241	CodePtr OpPC = S.PC;
14242	const auto V0 = ReadArg<bool>(S, S.PC);
14243	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14244	if (!DecBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
14245	}
14246	#if USE_TAILCALLS
14247	MUSTTAIL return InterpNext(S);
14248	#else
14249	return true;
14250	#endif
14251	}
14252	PRESERVE_NONE
14253	static bool Interp_DecBitfieldSint32(InterpState &S) {
14254	{
14255	CodePtr OpPC = S.PC;
14256	const auto V0 = ReadArg<bool>(S, S.PC);
14257	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14258	if (!DecBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
14259	}
14260	#if USE_TAILCALLS
14261	MUSTTAIL return InterpNext(S);
14262	#else
14263	return true;
14264	#endif
14265	}
14266	PRESERVE_NONE
14267	static bool Interp_DecBitfieldUint32(InterpState &S) {
14268	{
14269	CodePtr OpPC = S.PC;
14270	const auto V0 = ReadArg<bool>(S, S.PC);
14271	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14272	if (!DecBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
14273	}
14274	#if USE_TAILCALLS
14275	MUSTTAIL return InterpNext(S);
14276	#else
14277	return true;
14278	#endif
14279	}
14280	PRESERVE_NONE
14281	static bool Interp_DecBitfieldSint64(InterpState &S) {
14282	{
14283	CodePtr OpPC = S.PC;
14284	const auto V0 = ReadArg<bool>(S, S.PC);
14285	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14286	if (!DecBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
14287	}
14288	#if USE_TAILCALLS
14289	MUSTTAIL return InterpNext(S);
14290	#else
14291	return true;
14292	#endif
14293	}
14294	PRESERVE_NONE
14295	static bool Interp_DecBitfieldUint64(InterpState &S) {
14296	{
14297	CodePtr OpPC = S.PC;
14298	const auto V0 = ReadArg<bool>(S, S.PC);
14299	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14300	if (!DecBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
14301	}
14302	#if USE_TAILCALLS
14303	MUSTTAIL return InterpNext(S);
14304	#else
14305	return true;
14306	#endif
14307	}
14308	PRESERVE_NONE
14309	static bool Interp_DecBitfieldIntAP(InterpState &S) {
14310	{
14311	CodePtr OpPC = S.PC;
14312	const auto V0 = ReadArg<bool>(S, S.PC);
14313	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14314	if (!DecBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
14315	}
14316	#if USE_TAILCALLS
14317	MUSTTAIL return InterpNext(S);
14318	#else
14319	return true;
14320	#endif
14321	}
14322	PRESERVE_NONE
14323	static bool Interp_DecBitfieldIntAPS(InterpState &S) {
14324	{
14325	CodePtr OpPC = S.PC;
14326	const auto V0 = ReadArg<bool>(S, S.PC);
14327	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14328	if (!DecBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
14329	}
14330	#if USE_TAILCALLS
14331	MUSTTAIL return InterpNext(S);
14332	#else
14333	return true;
14334	#endif
14335	}
14336	PRESERVE_NONE
14337	static bool Interp_DecBitfieldBool(InterpState &S) {
14338	{
14339	CodePtr OpPC = S.PC;
14340	const auto V0 = ReadArg<bool>(S, S.PC);
14341	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14342	if (!DecBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
14343	}
14344	#if USE_TAILCALLS
14345	MUSTTAIL return InterpNext(S);
14346	#else
14347	return true;
14348	#endif
14349	}
14350	PRESERVE_NONE
14351	static bool Interp_DecBitfieldFixedPoint(InterpState &S) {
14352	{
14353	CodePtr OpPC = S.PC;
14354	const auto V0 = ReadArg<bool>(S, S.PC);
14355	const auto V1 = ReadArg<uint32_t>(S, S.PC);
14356	if (!DecBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
14357	}
14358	#if USE_TAILCALLS
14359	MUSTTAIL return InterpNext(S);
14360	#else
14361	return true;
14362	#endif
14363	}
14364	#endif
14365	#ifdef GET_DISASM
14366	case OP_DecBitfieldSint8:
14367	Text.Op = PrintName("DecBitfieldSint8");
14368	Text.Args.push_back(printArg<bool>(P, PC));
14369	Text.Args.push_back(printArg<uint32_t>(P, PC));
14370	break;
14371	case OP_DecBitfieldUint8:
14372	Text.Op = PrintName("DecBitfieldUint8");
14373	Text.Args.push_back(printArg<bool>(P, PC));
14374	Text.Args.push_back(printArg<uint32_t>(P, PC));
14375	break;
14376	case OP_DecBitfieldSint16:
14377	Text.Op = PrintName("DecBitfieldSint16");
14378	Text.Args.push_back(printArg<bool>(P, PC));
14379	Text.Args.push_back(printArg<uint32_t>(P, PC));
14380	break;
14381	case OP_DecBitfieldUint16:
14382	Text.Op = PrintName("DecBitfieldUint16");
14383	Text.Args.push_back(printArg<bool>(P, PC));
14384	Text.Args.push_back(printArg<uint32_t>(P, PC));
14385	break;
14386	case OP_DecBitfieldSint32:
14387	Text.Op = PrintName("DecBitfieldSint32");
14388	Text.Args.push_back(printArg<bool>(P, PC));
14389	Text.Args.push_back(printArg<uint32_t>(P, PC));
14390	break;
14391	case OP_DecBitfieldUint32:
14392	Text.Op = PrintName("DecBitfieldUint32");
14393	Text.Args.push_back(printArg<bool>(P, PC));
14394	Text.Args.push_back(printArg<uint32_t>(P, PC));
14395	break;
14396	case OP_DecBitfieldSint64:
14397	Text.Op = PrintName("DecBitfieldSint64");
14398	Text.Args.push_back(printArg<bool>(P, PC));
14399	Text.Args.push_back(printArg<uint32_t>(P, PC));
14400	break;
14401	case OP_DecBitfieldUint64:
14402	Text.Op = PrintName("DecBitfieldUint64");
14403	Text.Args.push_back(printArg<bool>(P, PC));
14404	Text.Args.push_back(printArg<uint32_t>(P, PC));
14405	break;
14406	case OP_DecBitfieldIntAP:
14407	Text.Op = PrintName("DecBitfieldIntAP");
14408	Text.Args.push_back(printArg<bool>(P, PC));
14409	Text.Args.push_back(printArg<uint32_t>(P, PC));
14410	break;
14411	case OP_DecBitfieldIntAPS:
14412	Text.Op = PrintName("DecBitfieldIntAPS");
14413	Text.Args.push_back(printArg<bool>(P, PC));
14414	Text.Args.push_back(printArg<uint32_t>(P, PC));
14415	break;
14416	case OP_DecBitfieldBool:
14417	Text.Op = PrintName("DecBitfieldBool");
14418	Text.Args.push_back(printArg<bool>(P, PC));
14419	Text.Args.push_back(printArg<uint32_t>(P, PC));
14420	break;
14421	case OP_DecBitfieldFixedPoint:
14422	Text.Op = PrintName("DecBitfieldFixedPoint");
14423	Text.Args.push_back(printArg<bool>(P, PC));
14424	Text.Args.push_back(printArg<uint32_t>(P, PC));
14425	break;
14426	#endif
14427	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14428	bool emitDecBitfieldSint8( bool , uint32_t , SourceInfo);
14429	bool emitDecBitfieldUint8( bool , uint32_t , SourceInfo);
14430	bool emitDecBitfieldSint16( bool , uint32_t , SourceInfo);
14431	bool emitDecBitfieldUint16( bool , uint32_t , SourceInfo);
14432	bool emitDecBitfieldSint32( bool , uint32_t , SourceInfo);
14433	bool emitDecBitfieldUint32( bool , uint32_t , SourceInfo);
14434	bool emitDecBitfieldSint64( bool , uint32_t , SourceInfo);
14435	bool emitDecBitfieldUint64( bool , uint32_t , SourceInfo);
14436	bool emitDecBitfieldIntAP( bool , uint32_t , SourceInfo);
14437	bool emitDecBitfieldIntAPS( bool , uint32_t , SourceInfo);
14438	bool emitDecBitfieldBool( bool , uint32_t , SourceInfo);
14439	bool emitDecBitfieldFixedPoint( bool , uint32_t , SourceInfo);
14440	#endif
14441	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14442	[[nodiscard]] bool emitDecBitfield(PrimType, bool, uint32_t, SourceInfo I);
14443	#endif
14444	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
14445	bool
14446	#if defined(GET_EVAL_IMPL)
14447	EvalEmitter
14448	#else
14449	ByteCodeEmitter
14450	#endif
14451	::emitDecBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
14452	switch (T0) {
14453	case PT_Sint8:
14454	return emitDecBitfieldSint8(A0, A1, I);
14455	case PT_Uint8:
14456	return emitDecBitfieldUint8(A0, A1, I);
14457	case PT_Sint16:
14458	return emitDecBitfieldSint16(A0, A1, I);
14459	case PT_Uint16:
14460	return emitDecBitfieldUint16(A0, A1, I);
14461	case PT_Sint32:
14462	return emitDecBitfieldSint32(A0, A1, I);
14463	case PT_Uint32:
14464	return emitDecBitfieldUint32(A0, A1, I);
14465	case PT_Sint64:
14466	return emitDecBitfieldSint64(A0, A1, I);
14467	case PT_Uint64:
14468	return emitDecBitfieldUint64(A0, A1, I);
14469	case PT_IntAP:
14470	return emitDecBitfieldIntAP(A0, A1, I);
14471	case PT_IntAPS:
14472	return emitDecBitfieldIntAPS(A0, A1, I);
14473	case PT_Bool:
14474	return emitDecBitfieldBool(A0, A1, I);
14475	case PT_FixedPoint:
14476	return emitDecBitfieldFixedPoint(A0, A1, I);
14477	default: llvm_unreachable("invalid type: emitDecBitfield");
14478	}
14479	llvm_unreachable("invalid enum value");
14480	}
14481	#endif
14482	#ifdef GET_LINK_IMPL
14483	bool ByteCodeEmitter::emitDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
14484	return emitOp<bool, uint32_t>(OP_DecBitfieldSint8, A0, A1, L);
14485	}
14486	bool ByteCodeEmitter::emitDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
14487	return emitOp<bool, uint32_t>(OP_DecBitfieldUint8, A0, A1, L);
14488	}
14489	bool ByteCodeEmitter::emitDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
14490	return emitOp<bool, uint32_t>(OP_DecBitfieldSint16, A0, A1, L);
14491	}
14492	bool ByteCodeEmitter::emitDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
14493	return emitOp<bool, uint32_t>(OP_DecBitfieldUint16, A0, A1, L);
14494	}
14495	bool ByteCodeEmitter::emitDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
14496	return emitOp<bool, uint32_t>(OP_DecBitfieldSint32, A0, A1, L);
14497	}
14498	bool ByteCodeEmitter::emitDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
14499	return emitOp<bool, uint32_t>(OP_DecBitfieldUint32, A0, A1, L);
14500	}
14501	bool ByteCodeEmitter::emitDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
14502	return emitOp<bool, uint32_t>(OP_DecBitfieldSint64, A0, A1, L);
14503	}
14504	bool ByteCodeEmitter::emitDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
14505	return emitOp<bool, uint32_t>(OP_DecBitfieldUint64, A0, A1, L);
14506	}
14507	bool ByteCodeEmitter::emitDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
14508	return emitOp<bool, uint32_t>(OP_DecBitfieldIntAP, A0, A1, L);
14509	}
14510	bool ByteCodeEmitter::emitDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
14511	return emitOp<bool, uint32_t>(OP_DecBitfieldIntAPS, A0, A1, L);
14512	}
14513	bool ByteCodeEmitter::emitDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
14514	return emitOp<bool, uint32_t>(OP_DecBitfieldBool, A0, A1, L);
14515	}
14516	bool ByteCodeEmitter::emitDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
14517	return emitOp<bool, uint32_t>(OP_DecBitfieldFixedPoint, A0, A1, L);
14518	}
14519	#endif
14520	#ifdef GET_EVAL_IMPL
14521	bool EvalEmitter::emitDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
14522	if (!isActive()) return true;
14523	CurrentSource = L;
14524	return DecBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
14525	}
14526	bool EvalEmitter::emitDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
14527	if (!isActive()) return true;
14528	CurrentSource = L;
14529	return DecBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
14530	}
14531	bool EvalEmitter::emitDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
14532	if (!isActive()) return true;
14533	CurrentSource = L;
14534	return DecBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
14535	}
14536	bool EvalEmitter::emitDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
14537	if (!isActive()) return true;
14538	CurrentSource = L;
14539	return DecBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
14540	}
14541	bool EvalEmitter::emitDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
14542	if (!isActive()) return true;
14543	CurrentSource = L;
14544	return DecBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
14545	}
14546	bool EvalEmitter::emitDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
14547	if (!isActive()) return true;
14548	CurrentSource = L;
14549	return DecBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
14550	}
14551	bool EvalEmitter::emitDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
14552	if (!isActive()) return true;
14553	CurrentSource = L;
14554	return DecBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
14555	}
14556	bool EvalEmitter::emitDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
14557	if (!isActive()) return true;
14558	CurrentSource = L;
14559	return DecBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
14560	}
14561	bool EvalEmitter::emitDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
14562	if (!isActive()) return true;
14563	CurrentSource = L;
14564	return DecBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
14565	}
14566	bool EvalEmitter::emitDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
14567	if (!isActive()) return true;
14568	CurrentSource = L;
14569	return DecBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
14570	}
14571	bool EvalEmitter::emitDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
14572	if (!isActive()) return true;
14573	CurrentSource = L;
14574	return DecBitfield<PT_Bool>(S, CodePtr(), A0, A1);
14575	}
14576	bool EvalEmitter::emitDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
14577	if (!isActive()) return true;
14578	CurrentSource = L;
14579	return DecBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
14580	}
14581	#endif
14582	#ifdef GET_OPCODE_NAMES
14583	OP_DecPopSint8,
14584	OP_DecPopUint8,
14585	OP_DecPopSint16,
14586	OP_DecPopUint16,
14587	OP_DecPopSint32,
14588	OP_DecPopUint32,
14589	OP_DecPopSint64,
14590	OP_DecPopUint64,
14591	OP_DecPopIntAP,
14592	OP_DecPopIntAPS,
14593	OP_DecPopBool,
14594	OP_DecPopFixedPoint,
14595	#endif
14596	#ifdef GET_INTERPFN_LIST
14597	&Interp_DecPopSint8,
14598	&Interp_DecPopUint8,
14599	&Interp_DecPopSint16,
14600	&Interp_DecPopUint16,
14601	&Interp_DecPopSint32,
14602	&Interp_DecPopUint32,
14603	&Interp_DecPopSint64,
14604	&Interp_DecPopUint64,
14605	&Interp_DecPopIntAP,
14606	&Interp_DecPopIntAPS,
14607	&Interp_DecPopBool,
14608	&Interp_DecPopFixedPoint,
14609	#endif
14610	#ifdef GET_INTERPFN_DISPATCHERS
14611	PRESERVE_NONE
14612	static bool Interp_DecPopSint8(InterpState &S) {
14613	{
14614	CodePtr OpPC = S.PC;
14615	const auto V0 = ReadArg<bool>(S, S.PC);
14616	if (!DecPop<PT_Sint8>(S, OpPC, V0)) return false;
14617	}
14618	#if USE_TAILCALLS
14619	MUSTTAIL return InterpNext(S);
14620	#else
14621	return true;
14622	#endif
14623	}
14624	PRESERVE_NONE
14625	static bool Interp_DecPopUint8(InterpState &S) {
14626	{
14627	CodePtr OpPC = S.PC;
14628	const auto V0 = ReadArg<bool>(S, S.PC);
14629	if (!DecPop<PT_Uint8>(S, OpPC, V0)) return false;
14630	}
14631	#if USE_TAILCALLS
14632	MUSTTAIL return InterpNext(S);
14633	#else
14634	return true;
14635	#endif
14636	}
14637	PRESERVE_NONE
14638	static bool Interp_DecPopSint16(InterpState &S) {
14639	{
14640	CodePtr OpPC = S.PC;
14641	const auto V0 = ReadArg<bool>(S, S.PC);
14642	if (!DecPop<PT_Sint16>(S, OpPC, V0)) return false;
14643	}
14644	#if USE_TAILCALLS
14645	MUSTTAIL return InterpNext(S);
14646	#else
14647	return true;
14648	#endif
14649	}
14650	PRESERVE_NONE
14651	static bool Interp_DecPopUint16(InterpState &S) {
14652	{
14653	CodePtr OpPC = S.PC;
14654	const auto V0 = ReadArg<bool>(S, S.PC);
14655	if (!DecPop<PT_Uint16>(S, OpPC, V0)) return false;
14656	}
14657	#if USE_TAILCALLS
14658	MUSTTAIL return InterpNext(S);
14659	#else
14660	return true;
14661	#endif
14662	}
14663	PRESERVE_NONE
14664	static bool Interp_DecPopSint32(InterpState &S) {
14665	{
14666	CodePtr OpPC = S.PC;
14667	const auto V0 = ReadArg<bool>(S, S.PC);
14668	if (!DecPop<PT_Sint32>(S, OpPC, V0)) return false;
14669	}
14670	#if USE_TAILCALLS
14671	MUSTTAIL return InterpNext(S);
14672	#else
14673	return true;
14674	#endif
14675	}
14676	PRESERVE_NONE
14677	static bool Interp_DecPopUint32(InterpState &S) {
14678	{
14679	CodePtr OpPC = S.PC;
14680	const auto V0 = ReadArg<bool>(S, S.PC);
14681	if (!DecPop<PT_Uint32>(S, OpPC, V0)) return false;
14682	}
14683	#if USE_TAILCALLS
14684	MUSTTAIL return InterpNext(S);
14685	#else
14686	return true;
14687	#endif
14688	}
14689	PRESERVE_NONE
14690	static bool Interp_DecPopSint64(InterpState &S) {
14691	{
14692	CodePtr OpPC = S.PC;
14693	const auto V0 = ReadArg<bool>(S, S.PC);
14694	if (!DecPop<PT_Sint64>(S, OpPC, V0)) return false;
14695	}
14696	#if USE_TAILCALLS
14697	MUSTTAIL return InterpNext(S);
14698	#else
14699	return true;
14700	#endif
14701	}
14702	PRESERVE_NONE
14703	static bool Interp_DecPopUint64(InterpState &S) {
14704	{
14705	CodePtr OpPC = S.PC;
14706	const auto V0 = ReadArg<bool>(S, S.PC);
14707	if (!DecPop<PT_Uint64>(S, OpPC, V0)) return false;
14708	}
14709	#if USE_TAILCALLS
14710	MUSTTAIL return InterpNext(S);
14711	#else
14712	return true;
14713	#endif
14714	}
14715	PRESERVE_NONE
14716	static bool Interp_DecPopIntAP(InterpState &S) {
14717	{
14718	CodePtr OpPC = S.PC;
14719	const auto V0 = ReadArg<bool>(S, S.PC);
14720	if (!DecPop<PT_IntAP>(S, OpPC, V0)) return false;
14721	}
14722	#if USE_TAILCALLS
14723	MUSTTAIL return InterpNext(S);
14724	#else
14725	return true;
14726	#endif
14727	}
14728	PRESERVE_NONE
14729	static bool Interp_DecPopIntAPS(InterpState &S) {
14730	{
14731	CodePtr OpPC = S.PC;
14732	const auto V0 = ReadArg<bool>(S, S.PC);
14733	if (!DecPop<PT_IntAPS>(S, OpPC, V0)) return false;
14734	}
14735	#if USE_TAILCALLS
14736	MUSTTAIL return InterpNext(S);
14737	#else
14738	return true;
14739	#endif
14740	}
14741	PRESERVE_NONE
14742	static bool Interp_DecPopBool(InterpState &S) {
14743	{
14744	CodePtr OpPC = S.PC;
14745	const auto V0 = ReadArg<bool>(S, S.PC);
14746	if (!DecPop<PT_Bool>(S, OpPC, V0)) return false;
14747	}
14748	#if USE_TAILCALLS
14749	MUSTTAIL return InterpNext(S);
14750	#else
14751	return true;
14752	#endif
14753	}
14754	PRESERVE_NONE
14755	static bool Interp_DecPopFixedPoint(InterpState &S) {
14756	{
14757	CodePtr OpPC = S.PC;
14758	const auto V0 = ReadArg<bool>(S, S.PC);
14759	if (!DecPop<PT_FixedPoint>(S, OpPC, V0)) return false;
14760	}
14761	#if USE_TAILCALLS
14762	MUSTTAIL return InterpNext(S);
14763	#else
14764	return true;
14765	#endif
14766	}
14767	#endif
14768	#ifdef GET_DISASM
14769	case OP_DecPopSint8:
14770	Text.Op = PrintName("DecPopSint8");
14771	Text.Args.push_back(printArg<bool>(P, PC));
14772	break;
14773	case OP_DecPopUint8:
14774	Text.Op = PrintName("DecPopUint8");
14775	Text.Args.push_back(printArg<bool>(P, PC));
14776	break;
14777	case OP_DecPopSint16:
14778	Text.Op = PrintName("DecPopSint16");
14779	Text.Args.push_back(printArg<bool>(P, PC));
14780	break;
14781	case OP_DecPopUint16:
14782	Text.Op = PrintName("DecPopUint16");
14783	Text.Args.push_back(printArg<bool>(P, PC));
14784	break;
14785	case OP_DecPopSint32:
14786	Text.Op = PrintName("DecPopSint32");
14787	Text.Args.push_back(printArg<bool>(P, PC));
14788	break;
14789	case OP_DecPopUint32:
14790	Text.Op = PrintName("DecPopUint32");
14791	Text.Args.push_back(printArg<bool>(P, PC));
14792	break;
14793	case OP_DecPopSint64:
14794	Text.Op = PrintName("DecPopSint64");
14795	Text.Args.push_back(printArg<bool>(P, PC));
14796	break;
14797	case OP_DecPopUint64:
14798	Text.Op = PrintName("DecPopUint64");
14799	Text.Args.push_back(printArg<bool>(P, PC));
14800	break;
14801	case OP_DecPopIntAP:
14802	Text.Op = PrintName("DecPopIntAP");
14803	Text.Args.push_back(printArg<bool>(P, PC));
14804	break;
14805	case OP_DecPopIntAPS:
14806	Text.Op = PrintName("DecPopIntAPS");
14807	Text.Args.push_back(printArg<bool>(P, PC));
14808	break;
14809	case OP_DecPopBool:
14810	Text.Op = PrintName("DecPopBool");
14811	Text.Args.push_back(printArg<bool>(P, PC));
14812	break;
14813	case OP_DecPopFixedPoint:
14814	Text.Op = PrintName("DecPopFixedPoint");
14815	Text.Args.push_back(printArg<bool>(P, PC));
14816	break;
14817	#endif
14818	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14819	bool emitDecPopSint8( bool , SourceInfo);
14820	bool emitDecPopUint8( bool , SourceInfo);
14821	bool emitDecPopSint16( bool , SourceInfo);
14822	bool emitDecPopUint16( bool , SourceInfo);
14823	bool emitDecPopSint32( bool , SourceInfo);
14824	bool emitDecPopUint32( bool , SourceInfo);
14825	bool emitDecPopSint64( bool , SourceInfo);
14826	bool emitDecPopUint64( bool , SourceInfo);
14827	bool emitDecPopIntAP( bool , SourceInfo);
14828	bool emitDecPopIntAPS( bool , SourceInfo);
14829	bool emitDecPopBool( bool , SourceInfo);
14830	bool emitDecPopFixedPoint( bool , SourceInfo);
14831	#endif
14832	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
14833	[[nodiscard]] bool emitDecPop(PrimType, bool, SourceInfo I);
14834	#endif
14835	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
14836	bool
14837	#if defined(GET_EVAL_IMPL)
14838	EvalEmitter
14839	#else
14840	ByteCodeEmitter
14841	#endif
14842	::emitDecPop(PrimType T0, bool A0, SourceInfo I) {
14843	switch (T0) {
14844	case PT_Sint8:
14845	return emitDecPopSint8(A0, I);
14846	case PT_Uint8:
14847	return emitDecPopUint8(A0, I);
14848	case PT_Sint16:
14849	return emitDecPopSint16(A0, I);
14850	case PT_Uint16:
14851	return emitDecPopUint16(A0, I);
14852	case PT_Sint32:
14853	return emitDecPopSint32(A0, I);
14854	case PT_Uint32:
14855	return emitDecPopUint32(A0, I);
14856	case PT_Sint64:
14857	return emitDecPopSint64(A0, I);
14858	case PT_Uint64:
14859	return emitDecPopUint64(A0, I);
14860	case PT_IntAP:
14861	return emitDecPopIntAP(A0, I);
14862	case PT_IntAPS:
14863	return emitDecPopIntAPS(A0, I);
14864	case PT_Bool:
14865	return emitDecPopBool(A0, I);
14866	case PT_FixedPoint:
14867	return emitDecPopFixedPoint(A0, I);
14868	default: llvm_unreachable("invalid type: emitDecPop");
14869	}
14870	llvm_unreachable("invalid enum value");
14871	}
14872	#endif
14873	#ifdef GET_LINK_IMPL
14874	bool ByteCodeEmitter::emitDecPopSint8( bool A0, SourceInfo L) {
14875	return emitOp<bool>(OP_DecPopSint8, A0, L);
14876	}
14877	bool ByteCodeEmitter::emitDecPopUint8( bool A0, SourceInfo L) {
14878	return emitOp<bool>(OP_DecPopUint8, A0, L);
14879	}
14880	bool ByteCodeEmitter::emitDecPopSint16( bool A0, SourceInfo L) {
14881	return emitOp<bool>(OP_DecPopSint16, A0, L);
14882	}
14883	bool ByteCodeEmitter::emitDecPopUint16( bool A0, SourceInfo L) {
14884	return emitOp<bool>(OP_DecPopUint16, A0, L);
14885	}
14886	bool ByteCodeEmitter::emitDecPopSint32( bool A0, SourceInfo L) {
14887	return emitOp<bool>(OP_DecPopSint32, A0, L);
14888	}
14889	bool ByteCodeEmitter::emitDecPopUint32( bool A0, SourceInfo L) {
14890	return emitOp<bool>(OP_DecPopUint32, A0, L);
14891	}
14892	bool ByteCodeEmitter::emitDecPopSint64( bool A0, SourceInfo L) {
14893	return emitOp<bool>(OP_DecPopSint64, A0, L);
14894	}
14895	bool ByteCodeEmitter::emitDecPopUint64( bool A0, SourceInfo L) {
14896	return emitOp<bool>(OP_DecPopUint64, A0, L);
14897	}
14898	bool ByteCodeEmitter::emitDecPopIntAP( bool A0, SourceInfo L) {
14899	return emitOp<bool>(OP_DecPopIntAP, A0, L);
14900	}
14901	bool ByteCodeEmitter::emitDecPopIntAPS( bool A0, SourceInfo L) {
14902	return emitOp<bool>(OP_DecPopIntAPS, A0, L);
14903	}
14904	bool ByteCodeEmitter::emitDecPopBool( bool A0, SourceInfo L) {
14905	return emitOp<bool>(OP_DecPopBool, A0, L);
14906	}
14907	bool ByteCodeEmitter::emitDecPopFixedPoint( bool A0, SourceInfo L) {
14908	return emitOp<bool>(OP_DecPopFixedPoint, A0, L);
14909	}
14910	#endif
14911	#ifdef GET_EVAL_IMPL
14912	bool EvalEmitter::emitDecPopSint8( bool A0, SourceInfo L) {
14913	if (!isActive()) return true;
14914	CurrentSource = L;
14915	return DecPop<PT_Sint8>(S, CodePtr(), A0);
14916	}
14917	bool EvalEmitter::emitDecPopUint8( bool A0, SourceInfo L) {
14918	if (!isActive()) return true;
14919	CurrentSource = L;
14920	return DecPop<PT_Uint8>(S, CodePtr(), A0);
14921	}
14922	bool EvalEmitter::emitDecPopSint16( bool A0, SourceInfo L) {
14923	if (!isActive()) return true;
14924	CurrentSource = L;
14925	return DecPop<PT_Sint16>(S, CodePtr(), A0);
14926	}
14927	bool EvalEmitter::emitDecPopUint16( bool A0, SourceInfo L) {
14928	if (!isActive()) return true;
14929	CurrentSource = L;
14930	return DecPop<PT_Uint16>(S, CodePtr(), A0);
14931	}
14932	bool EvalEmitter::emitDecPopSint32( bool A0, SourceInfo L) {
14933	if (!isActive()) return true;
14934	CurrentSource = L;
14935	return DecPop<PT_Sint32>(S, CodePtr(), A0);
14936	}
14937	bool EvalEmitter::emitDecPopUint32( bool A0, SourceInfo L) {
14938	if (!isActive()) return true;
14939	CurrentSource = L;
14940	return DecPop<PT_Uint32>(S, CodePtr(), A0);
14941	}
14942	bool EvalEmitter::emitDecPopSint64( bool A0, SourceInfo L) {
14943	if (!isActive()) return true;
14944	CurrentSource = L;
14945	return DecPop<PT_Sint64>(S, CodePtr(), A0);
14946	}
14947	bool EvalEmitter::emitDecPopUint64( bool A0, SourceInfo L) {
14948	if (!isActive()) return true;
14949	CurrentSource = L;
14950	return DecPop<PT_Uint64>(S, CodePtr(), A0);
14951	}
14952	bool EvalEmitter::emitDecPopIntAP( bool A0, SourceInfo L) {
14953	if (!isActive()) return true;
14954	CurrentSource = L;
14955	return DecPop<PT_IntAP>(S, CodePtr(), A0);
14956	}
14957	bool EvalEmitter::emitDecPopIntAPS( bool A0, SourceInfo L) {
14958	if (!isActive()) return true;
14959	CurrentSource = L;
14960	return DecPop<PT_IntAPS>(S, CodePtr(), A0);
14961	}
14962	bool EvalEmitter::emitDecPopBool( bool A0, SourceInfo L) {
14963	if (!isActive()) return true;
14964	CurrentSource = L;
14965	return DecPop<PT_Bool>(S, CodePtr(), A0);
14966	}
14967	bool EvalEmitter::emitDecPopFixedPoint( bool A0, SourceInfo L) {
14968	if (!isActive()) return true;
14969	CurrentSource = L;
14970	return DecPop<PT_FixedPoint>(S, CodePtr(), A0);
14971	}
14972	#endif
14973	#ifdef GET_OPCODE_NAMES
14974	OP_DecPopBitfieldSint8,
14975	OP_DecPopBitfieldUint8,
14976	OP_DecPopBitfieldSint16,
14977	OP_DecPopBitfieldUint16,
14978	OP_DecPopBitfieldSint32,
14979	OP_DecPopBitfieldUint32,
14980	OP_DecPopBitfieldSint64,
14981	OP_DecPopBitfieldUint64,
14982	OP_DecPopBitfieldIntAP,
14983	OP_DecPopBitfieldIntAPS,
14984	OP_DecPopBitfieldBool,
14985	OP_DecPopBitfieldFixedPoint,
14986	#endif
14987	#ifdef GET_INTERPFN_LIST
14988	&Interp_DecPopBitfieldSint8,
14989	&Interp_DecPopBitfieldUint8,
14990	&Interp_DecPopBitfieldSint16,
14991	&Interp_DecPopBitfieldUint16,
14992	&Interp_DecPopBitfieldSint32,
14993	&Interp_DecPopBitfieldUint32,
14994	&Interp_DecPopBitfieldSint64,
14995	&Interp_DecPopBitfieldUint64,
14996	&Interp_DecPopBitfieldIntAP,
14997	&Interp_DecPopBitfieldIntAPS,
14998	&Interp_DecPopBitfieldBool,
14999	&Interp_DecPopBitfieldFixedPoint,
15000	#endif
15001	#ifdef GET_INTERPFN_DISPATCHERS
15002	PRESERVE_NONE
15003	static bool Interp_DecPopBitfieldSint8(InterpState &S) {
15004	{
15005	CodePtr OpPC = S.PC;
15006	const auto V0 = ReadArg<bool>(S, S.PC);
15007	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15008	if (!DecPopBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
15009	}
15010	#if USE_TAILCALLS
15011	MUSTTAIL return InterpNext(S);
15012	#else
15013	return true;
15014	#endif
15015	}
15016	PRESERVE_NONE
15017	static bool Interp_DecPopBitfieldUint8(InterpState &S) {
15018	{
15019	CodePtr OpPC = S.PC;
15020	const auto V0 = ReadArg<bool>(S, S.PC);
15021	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15022	if (!DecPopBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
15023	}
15024	#if USE_TAILCALLS
15025	MUSTTAIL return InterpNext(S);
15026	#else
15027	return true;
15028	#endif
15029	}
15030	PRESERVE_NONE
15031	static bool Interp_DecPopBitfieldSint16(InterpState &S) {
15032	{
15033	CodePtr OpPC = S.PC;
15034	const auto V0 = ReadArg<bool>(S, S.PC);
15035	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15036	if (!DecPopBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
15037	}
15038	#if USE_TAILCALLS
15039	MUSTTAIL return InterpNext(S);
15040	#else
15041	return true;
15042	#endif
15043	}
15044	PRESERVE_NONE
15045	static bool Interp_DecPopBitfieldUint16(InterpState &S) {
15046	{
15047	CodePtr OpPC = S.PC;
15048	const auto V0 = ReadArg<bool>(S, S.PC);
15049	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15050	if (!DecPopBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
15051	}
15052	#if USE_TAILCALLS
15053	MUSTTAIL return InterpNext(S);
15054	#else
15055	return true;
15056	#endif
15057	}
15058	PRESERVE_NONE
15059	static bool Interp_DecPopBitfieldSint32(InterpState &S) {
15060	{
15061	CodePtr OpPC = S.PC;
15062	const auto V0 = ReadArg<bool>(S, S.PC);
15063	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15064	if (!DecPopBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
15065	}
15066	#if USE_TAILCALLS
15067	MUSTTAIL return InterpNext(S);
15068	#else
15069	return true;
15070	#endif
15071	}
15072	PRESERVE_NONE
15073	static bool Interp_DecPopBitfieldUint32(InterpState &S) {
15074	{
15075	CodePtr OpPC = S.PC;
15076	const auto V0 = ReadArg<bool>(S, S.PC);
15077	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15078	if (!DecPopBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
15079	}
15080	#if USE_TAILCALLS
15081	MUSTTAIL return InterpNext(S);
15082	#else
15083	return true;
15084	#endif
15085	}
15086	PRESERVE_NONE
15087	static bool Interp_DecPopBitfieldSint64(InterpState &S) {
15088	{
15089	CodePtr OpPC = S.PC;
15090	const auto V0 = ReadArg<bool>(S, S.PC);
15091	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15092	if (!DecPopBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
15093	}
15094	#if USE_TAILCALLS
15095	MUSTTAIL return InterpNext(S);
15096	#else
15097	return true;
15098	#endif
15099	}
15100	PRESERVE_NONE
15101	static bool Interp_DecPopBitfieldUint64(InterpState &S) {
15102	{
15103	CodePtr OpPC = S.PC;
15104	const auto V0 = ReadArg<bool>(S, S.PC);
15105	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15106	if (!DecPopBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
15107	}
15108	#if USE_TAILCALLS
15109	MUSTTAIL return InterpNext(S);
15110	#else
15111	return true;
15112	#endif
15113	}
15114	PRESERVE_NONE
15115	static bool Interp_DecPopBitfieldIntAP(InterpState &S) {
15116	{
15117	CodePtr OpPC = S.PC;
15118	const auto V0 = ReadArg<bool>(S, S.PC);
15119	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15120	if (!DecPopBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
15121	}
15122	#if USE_TAILCALLS
15123	MUSTTAIL return InterpNext(S);
15124	#else
15125	return true;
15126	#endif
15127	}
15128	PRESERVE_NONE
15129	static bool Interp_DecPopBitfieldIntAPS(InterpState &S) {
15130	{
15131	CodePtr OpPC = S.PC;
15132	const auto V0 = ReadArg<bool>(S, S.PC);
15133	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15134	if (!DecPopBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
15135	}
15136	#if USE_TAILCALLS
15137	MUSTTAIL return InterpNext(S);
15138	#else
15139	return true;
15140	#endif
15141	}
15142	PRESERVE_NONE
15143	static bool Interp_DecPopBitfieldBool(InterpState &S) {
15144	{
15145	CodePtr OpPC = S.PC;
15146	const auto V0 = ReadArg<bool>(S, S.PC);
15147	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15148	if (!DecPopBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
15149	}
15150	#if USE_TAILCALLS
15151	MUSTTAIL return InterpNext(S);
15152	#else
15153	return true;
15154	#endif
15155	}
15156	PRESERVE_NONE
15157	static bool Interp_DecPopBitfieldFixedPoint(InterpState &S) {
15158	{
15159	CodePtr OpPC = S.PC;
15160	const auto V0 = ReadArg<bool>(S, S.PC);
15161	const auto V1 = ReadArg<uint32_t>(S, S.PC);
15162	if (!DecPopBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
15163	}
15164	#if USE_TAILCALLS
15165	MUSTTAIL return InterpNext(S);
15166	#else
15167	return true;
15168	#endif
15169	}
15170	#endif
15171	#ifdef GET_DISASM
15172	case OP_DecPopBitfieldSint8:
15173	Text.Op = PrintName("DecPopBitfieldSint8");
15174	Text.Args.push_back(printArg<bool>(P, PC));
15175	Text.Args.push_back(printArg<uint32_t>(P, PC));
15176	break;
15177	case OP_DecPopBitfieldUint8:
15178	Text.Op = PrintName("DecPopBitfieldUint8");
15179	Text.Args.push_back(printArg<bool>(P, PC));
15180	Text.Args.push_back(printArg<uint32_t>(P, PC));
15181	break;
15182	case OP_DecPopBitfieldSint16:
15183	Text.Op = PrintName("DecPopBitfieldSint16");
15184	Text.Args.push_back(printArg<bool>(P, PC));
15185	Text.Args.push_back(printArg<uint32_t>(P, PC));
15186	break;
15187	case OP_DecPopBitfieldUint16:
15188	Text.Op = PrintName("DecPopBitfieldUint16");
15189	Text.Args.push_back(printArg<bool>(P, PC));
15190	Text.Args.push_back(printArg<uint32_t>(P, PC));
15191	break;
15192	case OP_DecPopBitfieldSint32:
15193	Text.Op = PrintName("DecPopBitfieldSint32");
15194	Text.Args.push_back(printArg<bool>(P, PC));
15195	Text.Args.push_back(printArg<uint32_t>(P, PC));
15196	break;
15197	case OP_DecPopBitfieldUint32:
15198	Text.Op = PrintName("DecPopBitfieldUint32");
15199	Text.Args.push_back(printArg<bool>(P, PC));
15200	Text.Args.push_back(printArg<uint32_t>(P, PC));
15201	break;
15202	case OP_DecPopBitfieldSint64:
15203	Text.Op = PrintName("DecPopBitfieldSint64");
15204	Text.Args.push_back(printArg<bool>(P, PC));
15205	Text.Args.push_back(printArg<uint32_t>(P, PC));
15206	break;
15207	case OP_DecPopBitfieldUint64:
15208	Text.Op = PrintName("DecPopBitfieldUint64");
15209	Text.Args.push_back(printArg<bool>(P, PC));
15210	Text.Args.push_back(printArg<uint32_t>(P, PC));
15211	break;
15212	case OP_DecPopBitfieldIntAP:
15213	Text.Op = PrintName("DecPopBitfieldIntAP");
15214	Text.Args.push_back(printArg<bool>(P, PC));
15215	Text.Args.push_back(printArg<uint32_t>(P, PC));
15216	break;
15217	case OP_DecPopBitfieldIntAPS:
15218	Text.Op = PrintName("DecPopBitfieldIntAPS");
15219	Text.Args.push_back(printArg<bool>(P, PC));
15220	Text.Args.push_back(printArg<uint32_t>(P, PC));
15221	break;
15222	case OP_DecPopBitfieldBool:
15223	Text.Op = PrintName("DecPopBitfieldBool");
15224	Text.Args.push_back(printArg<bool>(P, PC));
15225	Text.Args.push_back(printArg<uint32_t>(P, PC));
15226	break;
15227	case OP_DecPopBitfieldFixedPoint:
15228	Text.Op = PrintName("DecPopBitfieldFixedPoint");
15229	Text.Args.push_back(printArg<bool>(P, PC));
15230	Text.Args.push_back(printArg<uint32_t>(P, PC));
15231	break;
15232	#endif
15233	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15234	bool emitDecPopBitfieldSint8( bool , uint32_t , SourceInfo);
15235	bool emitDecPopBitfieldUint8( bool , uint32_t , SourceInfo);
15236	bool emitDecPopBitfieldSint16( bool , uint32_t , SourceInfo);
15237	bool emitDecPopBitfieldUint16( bool , uint32_t , SourceInfo);
15238	bool emitDecPopBitfieldSint32( bool , uint32_t , SourceInfo);
15239	bool emitDecPopBitfieldUint32( bool , uint32_t , SourceInfo);
15240	bool emitDecPopBitfieldSint64( bool , uint32_t , SourceInfo);
15241	bool emitDecPopBitfieldUint64( bool , uint32_t , SourceInfo);
15242	bool emitDecPopBitfieldIntAP( bool , uint32_t , SourceInfo);
15243	bool emitDecPopBitfieldIntAPS( bool , uint32_t , SourceInfo);
15244	bool emitDecPopBitfieldBool( bool , uint32_t , SourceInfo);
15245	bool emitDecPopBitfieldFixedPoint( bool , uint32_t , SourceInfo);
15246	#endif
15247	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15248	[[nodiscard]] bool emitDecPopBitfield(PrimType, bool, uint32_t, SourceInfo I);
15249	#endif
15250	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
15251	bool
15252	#if defined(GET_EVAL_IMPL)
15253	EvalEmitter
15254	#else
15255	ByteCodeEmitter
15256	#endif
15257	::emitDecPopBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
15258	switch (T0) {
15259	case PT_Sint8:
15260	return emitDecPopBitfieldSint8(A0, A1, I);
15261	case PT_Uint8:
15262	return emitDecPopBitfieldUint8(A0, A1, I);
15263	case PT_Sint16:
15264	return emitDecPopBitfieldSint16(A0, A1, I);
15265	case PT_Uint16:
15266	return emitDecPopBitfieldUint16(A0, A1, I);
15267	case PT_Sint32:
15268	return emitDecPopBitfieldSint32(A0, A1, I);
15269	case PT_Uint32:
15270	return emitDecPopBitfieldUint32(A0, A1, I);
15271	case PT_Sint64:
15272	return emitDecPopBitfieldSint64(A0, A1, I);
15273	case PT_Uint64:
15274	return emitDecPopBitfieldUint64(A0, A1, I);
15275	case PT_IntAP:
15276	return emitDecPopBitfieldIntAP(A0, A1, I);
15277	case PT_IntAPS:
15278	return emitDecPopBitfieldIntAPS(A0, A1, I);
15279	case PT_Bool:
15280	return emitDecPopBitfieldBool(A0, A1, I);
15281	case PT_FixedPoint:
15282	return emitDecPopBitfieldFixedPoint(A0, A1, I);
15283	default: llvm_unreachable("invalid type: emitDecPopBitfield");
15284	}
15285	llvm_unreachable("invalid enum value");
15286	}
15287	#endif
15288	#ifdef GET_LINK_IMPL
15289	bool ByteCodeEmitter::emitDecPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
15290	return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint8, A0, A1, L);
15291	}
15292	bool ByteCodeEmitter::emitDecPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
15293	return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint8, A0, A1, L);
15294	}
15295	bool ByteCodeEmitter::emitDecPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
15296	return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint16, A0, A1, L);
15297	}
15298	bool ByteCodeEmitter::emitDecPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
15299	return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint16, A0, A1, L);
15300	}
15301	bool ByteCodeEmitter::emitDecPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
15302	return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint32, A0, A1, L);
15303	}
15304	bool ByteCodeEmitter::emitDecPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
15305	return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint32, A0, A1, L);
15306	}
15307	bool ByteCodeEmitter::emitDecPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
15308	return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint64, A0, A1, L);
15309	}
15310	bool ByteCodeEmitter::emitDecPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
15311	return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint64, A0, A1, L);
15312	}
15313	bool ByteCodeEmitter::emitDecPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
15314	return emitOp<bool, uint32_t>(OP_DecPopBitfieldIntAP, A0, A1, L);
15315	}
15316	bool ByteCodeEmitter::emitDecPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
15317	return emitOp<bool, uint32_t>(OP_DecPopBitfieldIntAPS, A0, A1, L);
15318	}
15319	bool ByteCodeEmitter::emitDecPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
15320	return emitOp<bool, uint32_t>(OP_DecPopBitfieldBool, A0, A1, L);
15321	}
15322	bool ByteCodeEmitter::emitDecPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
15323	return emitOp<bool, uint32_t>(OP_DecPopBitfieldFixedPoint, A0, A1, L);
15324	}
15325	#endif
15326	#ifdef GET_EVAL_IMPL
15327	bool EvalEmitter::emitDecPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
15328	if (!isActive()) return true;
15329	CurrentSource = L;
15330	return DecPopBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
15331	}
15332	bool EvalEmitter::emitDecPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
15333	if (!isActive()) return true;
15334	CurrentSource = L;
15335	return DecPopBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
15336	}
15337	bool EvalEmitter::emitDecPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
15338	if (!isActive()) return true;
15339	CurrentSource = L;
15340	return DecPopBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
15341	}
15342	bool EvalEmitter::emitDecPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
15343	if (!isActive()) return true;
15344	CurrentSource = L;
15345	return DecPopBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
15346	}
15347	bool EvalEmitter::emitDecPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
15348	if (!isActive()) return true;
15349	CurrentSource = L;
15350	return DecPopBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
15351	}
15352	bool EvalEmitter::emitDecPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
15353	if (!isActive()) return true;
15354	CurrentSource = L;
15355	return DecPopBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
15356	}
15357	bool EvalEmitter::emitDecPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
15358	if (!isActive()) return true;
15359	CurrentSource = L;
15360	return DecPopBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
15361	}
15362	bool EvalEmitter::emitDecPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
15363	if (!isActive()) return true;
15364	CurrentSource = L;
15365	return DecPopBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
15366	}
15367	bool EvalEmitter::emitDecPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
15368	if (!isActive()) return true;
15369	CurrentSource = L;
15370	return DecPopBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
15371	}
15372	bool EvalEmitter::emitDecPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
15373	if (!isActive()) return true;
15374	CurrentSource = L;
15375	return DecPopBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
15376	}
15377	bool EvalEmitter::emitDecPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
15378	if (!isActive()) return true;
15379	CurrentSource = L;
15380	return DecPopBitfield<PT_Bool>(S, CodePtr(), A0, A1);
15381	}
15382	bool EvalEmitter::emitDecPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
15383	if (!isActive()) return true;
15384	CurrentSource = L;
15385	return DecPopBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
15386	}
15387	#endif
15388	#ifdef GET_OPCODE_NAMES
15389	OP_DecPtr,
15390	#endif
15391	#ifdef GET_INTERPFN_LIST
15392	&Interp_DecPtr,
15393	#endif
15394	#ifdef GET_INTERPFN_DISPATCHERS
15395	PRESERVE_NONE
15396	static bool Interp_DecPtr(InterpState &S) {
15397	if (!DecPtr(S, S.PC)) return false;
15398	#if USE_TAILCALLS
15399	MUSTTAIL return InterpNext(S);
15400	#else
15401	return true;
15402	#endif
15403	}
15404	#endif
15405	#ifdef GET_DISASM
15406	case OP_DecPtr:
15407	Text.Op = PrintName("DecPtr");
15408	break;
15409	#endif
15410	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15411	bool emitDecPtr(SourceInfo);
15412	#endif
15413	#ifdef GET_LINK_IMPL
15414	bool ByteCodeEmitter::emitDecPtr(SourceInfo L) {
15415	return emitOp<>(OP_DecPtr, L);
15416	}
15417	#endif
15418	#ifdef GET_EVAL_IMPL
15419	bool EvalEmitter::emitDecPtr(SourceInfo L) {
15420	if (!isActive()) return true;
15421	CurrentSource = L;
15422	return DecPtr(S, CodePtr());
15423	}
15424	#endif
15425	#ifdef GET_OPCODE_NAMES
15426	OP_DecayPtrPtrPtr,
15427	OP_DecayPtrPtrMemberPtr,
15428	OP_DecayPtrMemberPtrPtr,
15429	OP_DecayPtrMemberPtrMemberPtr,
15430	#endif
15431	#ifdef GET_INTERPFN_LIST
15432	&Interp_DecayPtrPtrPtr,
15433	&Interp_DecayPtrPtrMemberPtr,
15434	&Interp_DecayPtrMemberPtrPtr,
15435	&Interp_DecayPtrMemberPtrMemberPtr,
15436	#endif
15437	#ifdef GET_INTERPFN_DISPATCHERS
15438	PRESERVE_NONE
15439	static bool Interp_DecayPtrPtrPtr(InterpState &S) {
15440	if (!DecayPtr<PT_Ptr, PT_Ptr>(S)) return false;
15441	#if USE_TAILCALLS
15442	MUSTTAIL return InterpNext(S);
15443	#else
15444	return true;
15445	#endif
15446	}
15447	PRESERVE_NONE
15448	static bool Interp_DecayPtrPtrMemberPtr(InterpState &S) {
15449	if (!DecayPtr<PT_Ptr, PT_MemberPtr>(S)) return false;
15450	#if USE_TAILCALLS
15451	MUSTTAIL return InterpNext(S);
15452	#else
15453	return true;
15454	#endif
15455	}
15456	PRESERVE_NONE
15457	static bool Interp_DecayPtrMemberPtrPtr(InterpState &S) {
15458	if (!DecayPtr<PT_MemberPtr, PT_Ptr>(S)) return false;
15459	#if USE_TAILCALLS
15460	MUSTTAIL return InterpNext(S);
15461	#else
15462	return true;
15463	#endif
15464	}
15465	PRESERVE_NONE
15466	static bool Interp_DecayPtrMemberPtrMemberPtr(InterpState &S) {
15467	if (!DecayPtr<PT_MemberPtr, PT_MemberPtr>(S)) return false;
15468	#if USE_TAILCALLS
15469	MUSTTAIL return InterpNext(S);
15470	#else
15471	return true;
15472	#endif
15473	}
15474	#endif
15475	#ifdef GET_DISASM
15476	case OP_DecayPtrPtrPtr:
15477	Text.Op = PrintName("DecayPtrPtrPtr");
15478	break;
15479	case OP_DecayPtrPtrMemberPtr:
15480	Text.Op = PrintName("DecayPtrPtrMemberPtr");
15481	break;
15482	case OP_DecayPtrMemberPtrPtr:
15483	Text.Op = PrintName("DecayPtrMemberPtrPtr");
15484	break;
15485	case OP_DecayPtrMemberPtrMemberPtr:
15486	Text.Op = PrintName("DecayPtrMemberPtrMemberPtr");
15487	break;
15488	#endif
15489	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15490	bool emitDecayPtrPtrPtr(SourceInfo);
15491	bool emitDecayPtrPtrMemberPtr(SourceInfo);
15492	bool emitDecayPtrMemberPtrPtr(SourceInfo);
15493	bool emitDecayPtrMemberPtrMemberPtr(SourceInfo);
15494	#endif
15495	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15496	[[nodiscard]] bool emitDecayPtr(PrimType, PrimType, SourceInfo I);
15497	#endif
15498	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
15499	bool
15500	#if defined(GET_EVAL_IMPL)
15501	EvalEmitter
15502	#else
15503	ByteCodeEmitter
15504	#endif
15505	::emitDecayPtr(PrimType T0, PrimType T1, SourceInfo I) {
15506	switch (T0) {
15507	case PT_Ptr:
15508	switch (T1) {
15509	case PT_Ptr:
15510	return emitDecayPtrPtrPtr(I);
15511	case PT_MemberPtr:
15512	return emitDecayPtrPtrMemberPtr(I);
15513	default: llvm_unreachable("invalid type: emitDecayPtr");
15514	}
15515	llvm_unreachable("invalid enum value");
15516	case PT_MemberPtr:
15517	switch (T1) {
15518	case PT_Ptr:
15519	return emitDecayPtrMemberPtrPtr(I);
15520	case PT_MemberPtr:
15521	return emitDecayPtrMemberPtrMemberPtr(I);
15522	default: llvm_unreachable("invalid type: emitDecayPtr");
15523	}
15524	llvm_unreachable("invalid enum value");
15525	default: llvm_unreachable("invalid type: emitDecayPtr");
15526	}
15527	llvm_unreachable("invalid enum value");
15528	}
15529	#endif
15530	#ifdef GET_LINK_IMPL
15531	bool ByteCodeEmitter::emitDecayPtrPtrPtr(SourceInfo L) {
15532	return emitOp<>(OP_DecayPtrPtrPtr, L);
15533	}
15534	bool ByteCodeEmitter::emitDecayPtrPtrMemberPtr(SourceInfo L) {
15535	return emitOp<>(OP_DecayPtrPtrMemberPtr, L);
15536	}
15537	bool ByteCodeEmitter::emitDecayPtrMemberPtrPtr(SourceInfo L) {
15538	return emitOp<>(OP_DecayPtrMemberPtrPtr, L);
15539	}
15540	bool ByteCodeEmitter::emitDecayPtrMemberPtrMemberPtr(SourceInfo L) {
15541	return emitOp<>(OP_DecayPtrMemberPtrMemberPtr, L);
15542	}
15543	#endif
15544	#ifdef GET_EVAL_IMPL
15545	bool EvalEmitter::emitDecayPtrPtrPtr(SourceInfo L) {
15546	if (!isActive()) return true;
15547	CurrentSource = L;
15548	return DecayPtr<PT_Ptr, PT_Ptr>(S);
15549	}
15550	bool EvalEmitter::emitDecayPtrPtrMemberPtr(SourceInfo L) {
15551	if (!isActive()) return true;
15552	CurrentSource = L;
15553	return DecayPtr<PT_Ptr, PT_MemberPtr>(S);
15554	}
15555	bool EvalEmitter::emitDecayPtrMemberPtrPtr(SourceInfo L) {
15556	if (!isActive()) return true;
15557	CurrentSource = L;
15558	return DecayPtr<PT_MemberPtr, PT_Ptr>(S);
15559	}
15560	bool EvalEmitter::emitDecayPtrMemberPtrMemberPtr(SourceInfo L) {
15561	if (!isActive()) return true;
15562	CurrentSource = L;
15563	return DecayPtr<PT_MemberPtr, PT_MemberPtr>(S);
15564	}
15565	#endif
15566	#ifdef GET_OPCODE_NAMES
15567	OP_Decf,
15568	#endif
15569	#ifdef GET_INTERPFN_LIST
15570	&Interp_Decf,
15571	#endif
15572	#ifdef GET_INTERPFN_DISPATCHERS
15573	PRESERVE_NONE
15574	static bool Interp_Decf(InterpState &S) {
15575	{
15576	CodePtr OpPC = S.PC;
15577	const auto V0 = ReadArg<uint32_t>(S, S.PC);
15578	if (!Decf(S, OpPC, V0)) return false;
15579	}
15580	#if USE_TAILCALLS
15581	MUSTTAIL return InterpNext(S);
15582	#else
15583	return true;
15584	#endif
15585	}
15586	#endif
15587	#ifdef GET_DISASM
15588	case OP_Decf:
15589	Text.Op = PrintName("Decf");
15590	Text.Args.push_back(printArg<uint32_t>(P, PC));
15591	break;
15592	#endif
15593	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15594	bool emitDecf( uint32_t , SourceInfo);
15595	#endif
15596	#ifdef GET_LINK_IMPL
15597	bool ByteCodeEmitter::emitDecf( uint32_t A0, SourceInfo L) {
15598	return emitOp<uint32_t>(OP_Decf, A0, L);
15599	}
15600	#endif
15601	#ifdef GET_EVAL_IMPL
15602	bool EvalEmitter::emitDecf( uint32_t A0, SourceInfo L) {
15603	if (!isActive()) return true;
15604	CurrentSource = L;
15605	return Decf(S, CodePtr(), A0);
15606	}
15607	#endif
15608	#ifdef GET_OPCODE_NAMES
15609	OP_DecfPop,
15610	#endif
15611	#ifdef GET_INTERPFN_LIST
15612	&Interp_DecfPop,
15613	#endif
15614	#ifdef GET_INTERPFN_DISPATCHERS
15615	PRESERVE_NONE
15616	static bool Interp_DecfPop(InterpState &S) {
15617	{
15618	CodePtr OpPC = S.PC;
15619	const auto V0 = ReadArg<uint32_t>(S, S.PC);
15620	if (!DecfPop(S, OpPC, V0)) return false;
15621	}
15622	#if USE_TAILCALLS
15623	MUSTTAIL return InterpNext(S);
15624	#else
15625	return true;
15626	#endif
15627	}
15628	#endif
15629	#ifdef GET_DISASM
15630	case OP_DecfPop:
15631	Text.Op = PrintName("DecfPop");
15632	Text.Args.push_back(printArg<uint32_t>(P, PC));
15633	break;
15634	#endif
15635	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15636	bool emitDecfPop( uint32_t , SourceInfo);
15637	#endif
15638	#ifdef GET_LINK_IMPL
15639	bool ByteCodeEmitter::emitDecfPop( uint32_t A0, SourceInfo L) {
15640	return emitOp<uint32_t>(OP_DecfPop, A0, L);
15641	}
15642	#endif
15643	#ifdef GET_EVAL_IMPL
15644	bool EvalEmitter::emitDecfPop( uint32_t A0, SourceInfo L) {
15645	if (!isActive()) return true;
15646	CurrentSource = L;
15647	return DecfPop(S, CodePtr(), A0);
15648	}
15649	#endif
15650	#ifdef GET_OPCODE_NAMES
15651	OP_Destroy,
15652	#endif
15653	#ifdef GET_INTERPFN_LIST
15654	&Interp_Destroy,
15655	#endif
15656	#ifdef GET_INTERPFN_DISPATCHERS
15657	PRESERVE_NONE
15658	static bool Interp_Destroy(InterpState &S) {
15659	{
15660	CodePtr OpPC = S.PC;
15661	const auto V0 = ReadArg<uint32_t>(S, S.PC);
15662	if (!Destroy(S, OpPC, V0)) return false;
15663	}
15664	#if USE_TAILCALLS
15665	MUSTTAIL return InterpNext(S);
15666	#else
15667	return true;
15668	#endif
15669	}
15670	#endif
15671	#ifdef GET_DISASM
15672	case OP_Destroy:
15673	Text.Op = PrintName("Destroy");
15674	Text.Args.push_back(printArg<uint32_t>(P, PC));
15675	break;
15676	#endif
15677	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15678	bool emitDestroy( uint32_t , SourceInfo);
15679	#endif
15680	#ifdef GET_LINK_IMPL
15681	bool ByteCodeEmitter::emitDestroy( uint32_t A0, SourceInfo L) {
15682	return emitOp<uint32_t>(OP_Destroy, A0, L);
15683	}
15684	#endif
15685	#ifdef GET_OPCODE_NAMES
15686	OP_DiagTypeid,
15687	#endif
15688	#ifdef GET_INTERPFN_LIST
15689	&Interp_DiagTypeid,
15690	#endif
15691	#ifdef GET_INTERPFN_DISPATCHERS
15692	PRESERVE_NONE
15693	static bool Interp_DiagTypeid(InterpState &S) {
15694	if (!DiagTypeid(S, S.PC)) return false;
15695	#if USE_TAILCALLS
15696	MUSTTAIL return InterpNext(S);
15697	#else
15698	return true;
15699	#endif
15700	}
15701	#endif
15702	#ifdef GET_DISASM
15703	case OP_DiagTypeid:
15704	Text.Op = PrintName("DiagTypeid");
15705	break;
15706	#endif
15707	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15708	bool emitDiagTypeid(SourceInfo);
15709	#endif
15710	#ifdef GET_LINK_IMPL
15711	bool ByteCodeEmitter::emitDiagTypeid(SourceInfo L) {
15712	return emitOp<>(OP_DiagTypeid, L);
15713	}
15714	#endif
15715	#ifdef GET_EVAL_IMPL
15716	bool EvalEmitter::emitDiagTypeid(SourceInfo L) {
15717	if (!isActive()) return true;
15718	CurrentSource = L;
15719	return DiagTypeid(S, CodePtr());
15720	}
15721	#endif
15722	#ifdef GET_OPCODE_NAMES
15723	OP_DivSint8,
15724	OP_DivUint8,
15725	OP_DivSint16,
15726	OP_DivUint16,
15727	OP_DivSint32,
15728	OP_DivUint32,
15729	OP_DivSint64,
15730	OP_DivUint64,
15731	OP_DivIntAP,
15732	OP_DivIntAPS,
15733	OP_DivFixedPoint,
15734	#endif
15735	#ifdef GET_INTERPFN_LIST
15736	&Interp_DivSint8,
15737	&Interp_DivUint8,
15738	&Interp_DivSint16,
15739	&Interp_DivUint16,
15740	&Interp_DivSint32,
15741	&Interp_DivUint32,
15742	&Interp_DivSint64,
15743	&Interp_DivUint64,
15744	&Interp_DivIntAP,
15745	&Interp_DivIntAPS,
15746	&Interp_DivFixedPoint,
15747	#endif
15748	#ifdef GET_INTERPFN_DISPATCHERS
15749	PRESERVE_NONE
15750	static bool Interp_DivSint8(InterpState &S) {
15751	if (!Div<PT_Sint8>(S, S.PC)) return false;
15752	#if USE_TAILCALLS
15753	MUSTTAIL return InterpNext(S);
15754	#else
15755	return true;
15756	#endif
15757	}
15758	PRESERVE_NONE
15759	static bool Interp_DivUint8(InterpState &S) {
15760	if (!Div<PT_Uint8>(S, S.PC)) return false;
15761	#if USE_TAILCALLS
15762	MUSTTAIL return InterpNext(S);
15763	#else
15764	return true;
15765	#endif
15766	}
15767	PRESERVE_NONE
15768	static bool Interp_DivSint16(InterpState &S) {
15769	if (!Div<PT_Sint16>(S, S.PC)) return false;
15770	#if USE_TAILCALLS
15771	MUSTTAIL return InterpNext(S);
15772	#else
15773	return true;
15774	#endif
15775	}
15776	PRESERVE_NONE
15777	static bool Interp_DivUint16(InterpState &S) {
15778	if (!Div<PT_Uint16>(S, S.PC)) return false;
15779	#if USE_TAILCALLS
15780	MUSTTAIL return InterpNext(S);
15781	#else
15782	return true;
15783	#endif
15784	}
15785	PRESERVE_NONE
15786	static bool Interp_DivSint32(InterpState &S) {
15787	if (!Div<PT_Sint32>(S, S.PC)) return false;
15788	#if USE_TAILCALLS
15789	MUSTTAIL return InterpNext(S);
15790	#else
15791	return true;
15792	#endif
15793	}
15794	PRESERVE_NONE
15795	static bool Interp_DivUint32(InterpState &S) {
15796	if (!Div<PT_Uint32>(S, S.PC)) return false;
15797	#if USE_TAILCALLS
15798	MUSTTAIL return InterpNext(S);
15799	#else
15800	return true;
15801	#endif
15802	}
15803	PRESERVE_NONE
15804	static bool Interp_DivSint64(InterpState &S) {
15805	if (!Div<PT_Sint64>(S, S.PC)) return false;
15806	#if USE_TAILCALLS
15807	MUSTTAIL return InterpNext(S);
15808	#else
15809	return true;
15810	#endif
15811	}
15812	PRESERVE_NONE
15813	static bool Interp_DivUint64(InterpState &S) {
15814	if (!Div<PT_Uint64>(S, S.PC)) return false;
15815	#if USE_TAILCALLS
15816	MUSTTAIL return InterpNext(S);
15817	#else
15818	return true;
15819	#endif
15820	}
15821	PRESERVE_NONE
15822	static bool Interp_DivIntAP(InterpState &S) {
15823	if (!Div<PT_IntAP>(S, S.PC)) return false;
15824	#if USE_TAILCALLS
15825	MUSTTAIL return InterpNext(S);
15826	#else
15827	return true;
15828	#endif
15829	}
15830	PRESERVE_NONE
15831	static bool Interp_DivIntAPS(InterpState &S) {
15832	if (!Div<PT_IntAPS>(S, S.PC)) return false;
15833	#if USE_TAILCALLS
15834	MUSTTAIL return InterpNext(S);
15835	#else
15836	return true;
15837	#endif
15838	}
15839	PRESERVE_NONE
15840	static bool Interp_DivFixedPoint(InterpState &S) {
15841	if (!Div<PT_FixedPoint>(S, S.PC)) return false;
15842	#if USE_TAILCALLS
15843	MUSTTAIL return InterpNext(S);
15844	#else
15845	return true;
15846	#endif
15847	}
15848	#endif
15849	#ifdef GET_DISASM
15850	case OP_DivSint8:
15851	Text.Op = PrintName("DivSint8");
15852	break;
15853	case OP_DivUint8:
15854	Text.Op = PrintName("DivUint8");
15855	break;
15856	case OP_DivSint16:
15857	Text.Op = PrintName("DivSint16");
15858	break;
15859	case OP_DivUint16:
15860	Text.Op = PrintName("DivUint16");
15861	break;
15862	case OP_DivSint32:
15863	Text.Op = PrintName("DivSint32");
15864	break;
15865	case OP_DivUint32:
15866	Text.Op = PrintName("DivUint32");
15867	break;
15868	case OP_DivSint64:
15869	Text.Op = PrintName("DivSint64");
15870	break;
15871	case OP_DivUint64:
15872	Text.Op = PrintName("DivUint64");
15873	break;
15874	case OP_DivIntAP:
15875	Text.Op = PrintName("DivIntAP");
15876	break;
15877	case OP_DivIntAPS:
15878	Text.Op = PrintName("DivIntAPS");
15879	break;
15880	case OP_DivFixedPoint:
15881	Text.Op = PrintName("DivFixedPoint");
15882	break;
15883	#endif
15884	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15885	bool emitDivSint8(SourceInfo);
15886	bool emitDivUint8(SourceInfo);
15887	bool emitDivSint16(SourceInfo);
15888	bool emitDivUint16(SourceInfo);
15889	bool emitDivSint32(SourceInfo);
15890	bool emitDivUint32(SourceInfo);
15891	bool emitDivSint64(SourceInfo);
15892	bool emitDivUint64(SourceInfo);
15893	bool emitDivIntAP(SourceInfo);
15894	bool emitDivIntAPS(SourceInfo);
15895	bool emitDivFixedPoint(SourceInfo);
15896	#endif
15897	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
15898	[[nodiscard]] bool emitDiv(PrimType, SourceInfo I);
15899	#endif
15900	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
15901	bool
15902	#if defined(GET_EVAL_IMPL)
15903	EvalEmitter
15904	#else
15905	ByteCodeEmitter
15906	#endif
15907	::emitDiv(PrimType T0, SourceInfo I) {
15908	switch (T0) {
15909	case PT_Sint8:
15910	return emitDivSint8(I);
15911	case PT_Uint8:
15912	return emitDivUint8(I);
15913	case PT_Sint16:
15914	return emitDivSint16(I);
15915	case PT_Uint16:
15916	return emitDivUint16(I);
15917	case PT_Sint32:
15918	return emitDivSint32(I);
15919	case PT_Uint32:
15920	return emitDivUint32(I);
15921	case PT_Sint64:
15922	return emitDivSint64(I);
15923	case PT_Uint64:
15924	return emitDivUint64(I);
15925	case PT_IntAP:
15926	return emitDivIntAP(I);
15927	case PT_IntAPS:
15928	return emitDivIntAPS(I);
15929	case PT_FixedPoint:
15930	return emitDivFixedPoint(I);
15931	default: llvm_unreachable("invalid type: emitDiv");
15932	}
15933	llvm_unreachable("invalid enum value");
15934	}
15935	#endif
15936	#ifdef GET_LINK_IMPL
15937	bool ByteCodeEmitter::emitDivSint8(SourceInfo L) {
15938	return emitOp<>(OP_DivSint8, L);
15939	}
15940	bool ByteCodeEmitter::emitDivUint8(SourceInfo L) {
15941	return emitOp<>(OP_DivUint8, L);
15942	}
15943	bool ByteCodeEmitter::emitDivSint16(SourceInfo L) {
15944	return emitOp<>(OP_DivSint16, L);
15945	}
15946	bool ByteCodeEmitter::emitDivUint16(SourceInfo L) {
15947	return emitOp<>(OP_DivUint16, L);
15948	}
15949	bool ByteCodeEmitter::emitDivSint32(SourceInfo L) {
15950	return emitOp<>(OP_DivSint32, L);
15951	}
15952	bool ByteCodeEmitter::emitDivUint32(SourceInfo L) {
15953	return emitOp<>(OP_DivUint32, L);
15954	}
15955	bool ByteCodeEmitter::emitDivSint64(SourceInfo L) {
15956	return emitOp<>(OP_DivSint64, L);
15957	}
15958	bool ByteCodeEmitter::emitDivUint64(SourceInfo L) {
15959	return emitOp<>(OP_DivUint64, L);
15960	}
15961	bool ByteCodeEmitter::emitDivIntAP(SourceInfo L) {
15962	return emitOp<>(OP_DivIntAP, L);
15963	}
15964	bool ByteCodeEmitter::emitDivIntAPS(SourceInfo L) {
15965	return emitOp<>(OP_DivIntAPS, L);
15966	}
15967	bool ByteCodeEmitter::emitDivFixedPoint(SourceInfo L) {
15968	return emitOp<>(OP_DivFixedPoint, L);
15969	}
15970	#endif
15971	#ifdef GET_EVAL_IMPL
15972	bool EvalEmitter::emitDivSint8(SourceInfo L) {
15973	if (!isActive()) return true;
15974	CurrentSource = L;
15975	return Div<PT_Sint8>(S, CodePtr());
15976	}
15977	bool EvalEmitter::emitDivUint8(SourceInfo L) {
15978	if (!isActive()) return true;
15979	CurrentSource = L;
15980	return Div<PT_Uint8>(S, CodePtr());
15981	}
15982	bool EvalEmitter::emitDivSint16(SourceInfo L) {
15983	if (!isActive()) return true;
15984	CurrentSource = L;
15985	return Div<PT_Sint16>(S, CodePtr());
15986	}
15987	bool EvalEmitter::emitDivUint16(SourceInfo L) {
15988	if (!isActive()) return true;
15989	CurrentSource = L;
15990	return Div<PT_Uint16>(S, CodePtr());
15991	}
15992	bool EvalEmitter::emitDivSint32(SourceInfo L) {
15993	if (!isActive()) return true;
15994	CurrentSource = L;
15995	return Div<PT_Sint32>(S, CodePtr());
15996	}
15997	bool EvalEmitter::emitDivUint32(SourceInfo L) {
15998	if (!isActive()) return true;
15999	CurrentSource = L;
16000	return Div<PT_Uint32>(S, CodePtr());
16001	}
16002	bool EvalEmitter::emitDivSint64(SourceInfo L) {
16003	if (!isActive()) return true;
16004	CurrentSource = L;
16005	return Div<PT_Sint64>(S, CodePtr());
16006	}
16007	bool EvalEmitter::emitDivUint64(SourceInfo L) {
16008	if (!isActive()) return true;
16009	CurrentSource = L;
16010	return Div<PT_Uint64>(S, CodePtr());
16011	}
16012	bool EvalEmitter::emitDivIntAP(SourceInfo L) {
16013	if (!isActive()) return true;
16014	CurrentSource = L;
16015	return Div<PT_IntAP>(S, CodePtr());
16016	}
16017	bool EvalEmitter::emitDivIntAPS(SourceInfo L) {
16018	if (!isActive()) return true;
16019	CurrentSource = L;
16020	return Div<PT_IntAPS>(S, CodePtr());
16021	}
16022	bool EvalEmitter::emitDivFixedPoint(SourceInfo L) {
16023	if (!isActive()) return true;
16024	CurrentSource = L;
16025	return Div<PT_FixedPoint>(S, CodePtr());
16026	}
16027	#endif
16028	#ifdef GET_OPCODE_NAMES
16029	OP_DivcSint8,
16030	OP_DivcUint8,
16031	OP_DivcSint16,
16032	OP_DivcUint16,
16033	OP_DivcSint32,
16034	OP_DivcUint32,
16035	OP_DivcSint64,
16036	OP_DivcUint64,
16037	OP_DivcIntAP,
16038	OP_DivcIntAPS,
16039	OP_DivcFloat,
16040	#endif
16041	#ifdef GET_INTERPFN_LIST
16042	&Interp_DivcSint8,
16043	&Interp_DivcUint8,
16044	&Interp_DivcSint16,
16045	&Interp_DivcUint16,
16046	&Interp_DivcSint32,
16047	&Interp_DivcUint32,
16048	&Interp_DivcSint64,
16049	&Interp_DivcUint64,
16050	&Interp_DivcIntAP,
16051	&Interp_DivcIntAPS,
16052	&Interp_DivcFloat,
16053	#endif
16054	#ifdef GET_INTERPFN_DISPATCHERS
16055	PRESERVE_NONE
16056	static bool Interp_DivcSint8(InterpState &S) {
16057	if (!Divc<PT_Sint8>(S, S.PC)) return false;
16058	#if USE_TAILCALLS
16059	MUSTTAIL return InterpNext(S);
16060	#else
16061	return true;
16062	#endif
16063	}
16064	PRESERVE_NONE
16065	static bool Interp_DivcUint8(InterpState &S) {
16066	if (!Divc<PT_Uint8>(S, S.PC)) return false;
16067	#if USE_TAILCALLS
16068	MUSTTAIL return InterpNext(S);
16069	#else
16070	return true;
16071	#endif
16072	}
16073	PRESERVE_NONE
16074	static bool Interp_DivcSint16(InterpState &S) {
16075	if (!Divc<PT_Sint16>(S, S.PC)) return false;
16076	#if USE_TAILCALLS
16077	MUSTTAIL return InterpNext(S);
16078	#else
16079	return true;
16080	#endif
16081	}
16082	PRESERVE_NONE
16083	static bool Interp_DivcUint16(InterpState &S) {
16084	if (!Divc<PT_Uint16>(S, S.PC)) return false;
16085	#if USE_TAILCALLS
16086	MUSTTAIL return InterpNext(S);
16087	#else
16088	return true;
16089	#endif
16090	}
16091	PRESERVE_NONE
16092	static bool Interp_DivcSint32(InterpState &S) {
16093	if (!Divc<PT_Sint32>(S, S.PC)) return false;
16094	#if USE_TAILCALLS
16095	MUSTTAIL return InterpNext(S);
16096	#else
16097	return true;
16098	#endif
16099	}
16100	PRESERVE_NONE
16101	static bool Interp_DivcUint32(InterpState &S) {
16102	if (!Divc<PT_Uint32>(S, S.PC)) return false;
16103	#if USE_TAILCALLS
16104	MUSTTAIL return InterpNext(S);
16105	#else
16106	return true;
16107	#endif
16108	}
16109	PRESERVE_NONE
16110	static bool Interp_DivcSint64(InterpState &S) {
16111	if (!Divc<PT_Sint64>(S, S.PC)) return false;
16112	#if USE_TAILCALLS
16113	MUSTTAIL return InterpNext(S);
16114	#else
16115	return true;
16116	#endif
16117	}
16118	PRESERVE_NONE
16119	static bool Interp_DivcUint64(InterpState &S) {
16120	if (!Divc<PT_Uint64>(S, S.PC)) return false;
16121	#if USE_TAILCALLS
16122	MUSTTAIL return InterpNext(S);
16123	#else
16124	return true;
16125	#endif
16126	}
16127	PRESERVE_NONE
16128	static bool Interp_DivcIntAP(InterpState &S) {
16129	if (!Divc<PT_IntAP>(S, S.PC)) return false;
16130	#if USE_TAILCALLS
16131	MUSTTAIL return InterpNext(S);
16132	#else
16133	return true;
16134	#endif
16135	}
16136	PRESERVE_NONE
16137	static bool Interp_DivcIntAPS(InterpState &S) {
16138	if (!Divc<PT_IntAPS>(S, S.PC)) return false;
16139	#if USE_TAILCALLS
16140	MUSTTAIL return InterpNext(S);
16141	#else
16142	return true;
16143	#endif
16144	}
16145	PRESERVE_NONE
16146	static bool Interp_DivcFloat(InterpState &S) {
16147	if (!Divc<PT_Float>(S, S.PC)) return false;
16148	#if USE_TAILCALLS
16149	MUSTTAIL return InterpNext(S);
16150	#else
16151	return true;
16152	#endif
16153	}
16154	#endif
16155	#ifdef GET_DISASM
16156	case OP_DivcSint8:
16157	Text.Op = PrintName("DivcSint8");
16158	break;
16159	case OP_DivcUint8:
16160	Text.Op = PrintName("DivcUint8");
16161	break;
16162	case OP_DivcSint16:
16163	Text.Op = PrintName("DivcSint16");
16164	break;
16165	case OP_DivcUint16:
16166	Text.Op = PrintName("DivcUint16");
16167	break;
16168	case OP_DivcSint32:
16169	Text.Op = PrintName("DivcSint32");
16170	break;
16171	case OP_DivcUint32:
16172	Text.Op = PrintName("DivcUint32");
16173	break;
16174	case OP_DivcSint64:
16175	Text.Op = PrintName("DivcSint64");
16176	break;
16177	case OP_DivcUint64:
16178	Text.Op = PrintName("DivcUint64");
16179	break;
16180	case OP_DivcIntAP:
16181	Text.Op = PrintName("DivcIntAP");
16182	break;
16183	case OP_DivcIntAPS:
16184	Text.Op = PrintName("DivcIntAPS");
16185	break;
16186	case OP_DivcFloat:
16187	Text.Op = PrintName("DivcFloat");
16188	break;
16189	#endif
16190	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16191	bool emitDivcSint8(SourceInfo);
16192	bool emitDivcUint8(SourceInfo);
16193	bool emitDivcSint16(SourceInfo);
16194	bool emitDivcUint16(SourceInfo);
16195	bool emitDivcSint32(SourceInfo);
16196	bool emitDivcUint32(SourceInfo);
16197	bool emitDivcSint64(SourceInfo);
16198	bool emitDivcUint64(SourceInfo);
16199	bool emitDivcIntAP(SourceInfo);
16200	bool emitDivcIntAPS(SourceInfo);
16201	bool emitDivcFloat(SourceInfo);
16202	#endif
16203	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16204	[[nodiscard]] bool emitDivc(PrimType, SourceInfo I);
16205	#endif
16206	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
16207	bool
16208	#if defined(GET_EVAL_IMPL)
16209	EvalEmitter
16210	#else
16211	ByteCodeEmitter
16212	#endif
16213	::emitDivc(PrimType T0, SourceInfo I) {
16214	switch (T0) {
16215	case PT_Sint8:
16216	return emitDivcSint8(I);
16217	case PT_Uint8:
16218	return emitDivcUint8(I);
16219	case PT_Sint16:
16220	return emitDivcSint16(I);
16221	case PT_Uint16:
16222	return emitDivcUint16(I);
16223	case PT_Sint32:
16224	return emitDivcSint32(I);
16225	case PT_Uint32:
16226	return emitDivcUint32(I);
16227	case PT_Sint64:
16228	return emitDivcSint64(I);
16229	case PT_Uint64:
16230	return emitDivcUint64(I);
16231	case PT_IntAP:
16232	return emitDivcIntAP(I);
16233	case PT_IntAPS:
16234	return emitDivcIntAPS(I);
16235	case PT_Float:
16236	return emitDivcFloat(I);
16237	default: llvm_unreachable("invalid type: emitDivc");
16238	}
16239	llvm_unreachable("invalid enum value");
16240	}
16241	#endif
16242	#ifdef GET_LINK_IMPL
16243	bool ByteCodeEmitter::emitDivcSint8(SourceInfo L) {
16244	return emitOp<>(OP_DivcSint8, L);
16245	}
16246	bool ByteCodeEmitter::emitDivcUint8(SourceInfo L) {
16247	return emitOp<>(OP_DivcUint8, L);
16248	}
16249	bool ByteCodeEmitter::emitDivcSint16(SourceInfo L) {
16250	return emitOp<>(OP_DivcSint16, L);
16251	}
16252	bool ByteCodeEmitter::emitDivcUint16(SourceInfo L) {
16253	return emitOp<>(OP_DivcUint16, L);
16254	}
16255	bool ByteCodeEmitter::emitDivcSint32(SourceInfo L) {
16256	return emitOp<>(OP_DivcSint32, L);
16257	}
16258	bool ByteCodeEmitter::emitDivcUint32(SourceInfo L) {
16259	return emitOp<>(OP_DivcUint32, L);
16260	}
16261	bool ByteCodeEmitter::emitDivcSint64(SourceInfo L) {
16262	return emitOp<>(OP_DivcSint64, L);
16263	}
16264	bool ByteCodeEmitter::emitDivcUint64(SourceInfo L) {
16265	return emitOp<>(OP_DivcUint64, L);
16266	}
16267	bool ByteCodeEmitter::emitDivcIntAP(SourceInfo L) {
16268	return emitOp<>(OP_DivcIntAP, L);
16269	}
16270	bool ByteCodeEmitter::emitDivcIntAPS(SourceInfo L) {
16271	return emitOp<>(OP_DivcIntAPS, L);
16272	}
16273	bool ByteCodeEmitter::emitDivcFloat(SourceInfo L) {
16274	return emitOp<>(OP_DivcFloat, L);
16275	}
16276	#endif
16277	#ifdef GET_EVAL_IMPL
16278	bool EvalEmitter::emitDivcSint8(SourceInfo L) {
16279	if (!isActive()) return true;
16280	CurrentSource = L;
16281	return Divc<PT_Sint8>(S, CodePtr());
16282	}
16283	bool EvalEmitter::emitDivcUint8(SourceInfo L) {
16284	if (!isActive()) return true;
16285	CurrentSource = L;
16286	return Divc<PT_Uint8>(S, CodePtr());
16287	}
16288	bool EvalEmitter::emitDivcSint16(SourceInfo L) {
16289	if (!isActive()) return true;
16290	CurrentSource = L;
16291	return Divc<PT_Sint16>(S, CodePtr());
16292	}
16293	bool EvalEmitter::emitDivcUint16(SourceInfo L) {
16294	if (!isActive()) return true;
16295	CurrentSource = L;
16296	return Divc<PT_Uint16>(S, CodePtr());
16297	}
16298	bool EvalEmitter::emitDivcSint32(SourceInfo L) {
16299	if (!isActive()) return true;
16300	CurrentSource = L;
16301	return Divc<PT_Sint32>(S, CodePtr());
16302	}
16303	bool EvalEmitter::emitDivcUint32(SourceInfo L) {
16304	if (!isActive()) return true;
16305	CurrentSource = L;
16306	return Divc<PT_Uint32>(S, CodePtr());
16307	}
16308	bool EvalEmitter::emitDivcSint64(SourceInfo L) {
16309	if (!isActive()) return true;
16310	CurrentSource = L;
16311	return Divc<PT_Sint64>(S, CodePtr());
16312	}
16313	bool EvalEmitter::emitDivcUint64(SourceInfo L) {
16314	if (!isActive()) return true;
16315	CurrentSource = L;
16316	return Divc<PT_Uint64>(S, CodePtr());
16317	}
16318	bool EvalEmitter::emitDivcIntAP(SourceInfo L) {
16319	if (!isActive()) return true;
16320	CurrentSource = L;
16321	return Divc<PT_IntAP>(S, CodePtr());
16322	}
16323	bool EvalEmitter::emitDivcIntAPS(SourceInfo L) {
16324	if (!isActive()) return true;
16325	CurrentSource = L;
16326	return Divc<PT_IntAPS>(S, CodePtr());
16327	}
16328	bool EvalEmitter::emitDivcFloat(SourceInfo L) {
16329	if (!isActive()) return true;
16330	CurrentSource = L;
16331	return Divc<PT_Float>(S, CodePtr());
16332	}
16333	#endif
16334	#ifdef GET_OPCODE_NAMES
16335	OP_Divf,
16336	#endif
16337	#ifdef GET_INTERPFN_LIST
16338	&Interp_Divf,
16339	#endif
16340	#ifdef GET_INTERPFN_DISPATCHERS
16341	PRESERVE_NONE
16342	static bool Interp_Divf(InterpState &S) {
16343	{
16344	CodePtr OpPC = S.PC;
16345	const auto V0 = ReadArg<uint32_t>(S, S.PC);
16346	if (!Divf(S, OpPC, V0)) return false;
16347	}
16348	#if USE_TAILCALLS
16349	MUSTTAIL return InterpNext(S);
16350	#else
16351	return true;
16352	#endif
16353	}
16354	#endif
16355	#ifdef GET_DISASM
16356	case OP_Divf:
16357	Text.Op = PrintName("Divf");
16358	Text.Args.push_back(printArg<uint32_t>(P, PC));
16359	break;
16360	#endif
16361	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16362	bool emitDivf( uint32_t , SourceInfo);
16363	#endif
16364	#ifdef GET_LINK_IMPL
16365	bool ByteCodeEmitter::emitDivf( uint32_t A0, SourceInfo L) {
16366	return emitOp<uint32_t>(OP_Divf, A0, L);
16367	}
16368	#endif
16369	#ifdef GET_EVAL_IMPL
16370	bool EvalEmitter::emitDivf( uint32_t A0, SourceInfo L) {
16371	if (!isActive()) return true;
16372	CurrentSource = L;
16373	return Divf(S, CodePtr(), A0);
16374	}
16375	#endif
16376	#ifdef GET_OPCODE_NAMES
16377	OP_Dump,
16378	#endif
16379	#ifdef GET_INTERPFN_LIST
16380	&Interp_Dump,
16381	#endif
16382	#ifdef GET_INTERPFN_DISPATCHERS
16383	PRESERVE_NONE
16384	static bool Interp_Dump(InterpState &S) {
16385	if (!Dump(S)) return false;
16386	#if USE_TAILCALLS
16387	MUSTTAIL return InterpNext(S);
16388	#else
16389	return true;
16390	#endif
16391	}
16392	#endif
16393	#ifdef GET_DISASM
16394	case OP_Dump:
16395	Text.Op = PrintName("Dump");
16396	break;
16397	#endif
16398	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16399	bool emitDump(SourceInfo);
16400	#endif
16401	#ifdef GET_LINK_IMPL
16402	bool ByteCodeEmitter::emitDump(SourceInfo L) {
16403	return emitOp<>(OP_Dump, L);
16404	}
16405	#endif
16406	#ifdef GET_EVAL_IMPL
16407	bool EvalEmitter::emitDump(SourceInfo L) {
16408	if (!isActive()) return true;
16409	CurrentSource = L;
16410	return Dump(S);
16411	}
16412	#endif
16413	#ifdef GET_OPCODE_NAMES
16414	OP_DupSint8,
16415	OP_DupUint8,
16416	OP_DupSint16,
16417	OP_DupUint16,
16418	OP_DupSint32,
16419	OP_DupUint32,
16420	OP_DupSint64,
16421	OP_DupUint64,
16422	OP_DupIntAP,
16423	OP_DupIntAPS,
16424	OP_DupBool,
16425	OP_DupFixedPoint,
16426	OP_DupPtr,
16427	OP_DupMemberPtr,
16428	OP_DupFloat,
16429	#endif
16430	#ifdef GET_INTERPFN_LIST
16431	&Interp_DupSint8,
16432	&Interp_DupUint8,
16433	&Interp_DupSint16,
16434	&Interp_DupUint16,
16435	&Interp_DupSint32,
16436	&Interp_DupUint32,
16437	&Interp_DupSint64,
16438	&Interp_DupUint64,
16439	&Interp_DupIntAP,
16440	&Interp_DupIntAPS,
16441	&Interp_DupBool,
16442	&Interp_DupFixedPoint,
16443	&Interp_DupPtr,
16444	&Interp_DupMemberPtr,
16445	&Interp_DupFloat,
16446	#endif
16447	#ifdef GET_INTERPFN_DISPATCHERS
16448	PRESERVE_NONE
16449	static bool Interp_DupSint8(InterpState &S) {
16450	Dup<PT_Sint8>(S);
16451	#if USE_TAILCALLS
16452	MUSTTAIL return InterpNext(S);
16453	#else
16454	return true;
16455	#endif
16456	}
16457	PRESERVE_NONE
16458	static bool Interp_DupUint8(InterpState &S) {
16459	Dup<PT_Uint8>(S);
16460	#if USE_TAILCALLS
16461	MUSTTAIL return InterpNext(S);
16462	#else
16463	return true;
16464	#endif
16465	}
16466	PRESERVE_NONE
16467	static bool Interp_DupSint16(InterpState &S) {
16468	Dup<PT_Sint16>(S);
16469	#if USE_TAILCALLS
16470	MUSTTAIL return InterpNext(S);
16471	#else
16472	return true;
16473	#endif
16474	}
16475	PRESERVE_NONE
16476	static bool Interp_DupUint16(InterpState &S) {
16477	Dup<PT_Uint16>(S);
16478	#if USE_TAILCALLS
16479	MUSTTAIL return InterpNext(S);
16480	#else
16481	return true;
16482	#endif
16483	}
16484	PRESERVE_NONE
16485	static bool Interp_DupSint32(InterpState &S) {
16486	Dup<PT_Sint32>(S);
16487	#if USE_TAILCALLS
16488	MUSTTAIL return InterpNext(S);
16489	#else
16490	return true;
16491	#endif
16492	}
16493	PRESERVE_NONE
16494	static bool Interp_DupUint32(InterpState &S) {
16495	Dup<PT_Uint32>(S);
16496	#if USE_TAILCALLS
16497	MUSTTAIL return InterpNext(S);
16498	#else
16499	return true;
16500	#endif
16501	}
16502	PRESERVE_NONE
16503	static bool Interp_DupSint64(InterpState &S) {
16504	Dup<PT_Sint64>(S);
16505	#if USE_TAILCALLS
16506	MUSTTAIL return InterpNext(S);
16507	#else
16508	return true;
16509	#endif
16510	}
16511	PRESERVE_NONE
16512	static bool Interp_DupUint64(InterpState &S) {
16513	Dup<PT_Uint64>(S);
16514	#if USE_TAILCALLS
16515	MUSTTAIL return InterpNext(S);
16516	#else
16517	return true;
16518	#endif
16519	}
16520	PRESERVE_NONE
16521	static bool Interp_DupIntAP(InterpState &S) {
16522	Dup<PT_IntAP>(S);
16523	#if USE_TAILCALLS
16524	MUSTTAIL return InterpNext(S);
16525	#else
16526	return true;
16527	#endif
16528	}
16529	PRESERVE_NONE
16530	static bool Interp_DupIntAPS(InterpState &S) {
16531	Dup<PT_IntAPS>(S);
16532	#if USE_TAILCALLS
16533	MUSTTAIL return InterpNext(S);
16534	#else
16535	return true;
16536	#endif
16537	}
16538	PRESERVE_NONE
16539	static bool Interp_DupBool(InterpState &S) {
16540	Dup<PT_Bool>(S);
16541	#if USE_TAILCALLS
16542	MUSTTAIL return InterpNext(S);
16543	#else
16544	return true;
16545	#endif
16546	}
16547	PRESERVE_NONE
16548	static bool Interp_DupFixedPoint(InterpState &S) {
16549	Dup<PT_FixedPoint>(S);
16550	#if USE_TAILCALLS
16551	MUSTTAIL return InterpNext(S);
16552	#else
16553	return true;
16554	#endif
16555	}
16556	PRESERVE_NONE
16557	static bool Interp_DupPtr(InterpState &S) {
16558	Dup<PT_Ptr>(S);
16559	#if USE_TAILCALLS
16560	MUSTTAIL return InterpNext(S);
16561	#else
16562	return true;
16563	#endif
16564	}
16565	PRESERVE_NONE
16566	static bool Interp_DupMemberPtr(InterpState &S) {
16567	Dup<PT_MemberPtr>(S);
16568	#if USE_TAILCALLS
16569	MUSTTAIL return InterpNext(S);
16570	#else
16571	return true;
16572	#endif
16573	}
16574	PRESERVE_NONE
16575	static bool Interp_DupFloat(InterpState &S) {
16576	Dup<PT_Float>(S);
16577	#if USE_TAILCALLS
16578	MUSTTAIL return InterpNext(S);
16579	#else
16580	return true;
16581	#endif
16582	}
16583	#endif
16584	#ifdef GET_DISASM
16585	case OP_DupSint8:
16586	Text.Op = PrintName("DupSint8");
16587	break;
16588	case OP_DupUint8:
16589	Text.Op = PrintName("DupUint8");
16590	break;
16591	case OP_DupSint16:
16592	Text.Op = PrintName("DupSint16");
16593	break;
16594	case OP_DupUint16:
16595	Text.Op = PrintName("DupUint16");
16596	break;
16597	case OP_DupSint32:
16598	Text.Op = PrintName("DupSint32");
16599	break;
16600	case OP_DupUint32:
16601	Text.Op = PrintName("DupUint32");
16602	break;
16603	case OP_DupSint64:
16604	Text.Op = PrintName("DupSint64");
16605	break;
16606	case OP_DupUint64:
16607	Text.Op = PrintName("DupUint64");
16608	break;
16609	case OP_DupIntAP:
16610	Text.Op = PrintName("DupIntAP");
16611	break;
16612	case OP_DupIntAPS:
16613	Text.Op = PrintName("DupIntAPS");
16614	break;
16615	case OP_DupBool:
16616	Text.Op = PrintName("DupBool");
16617	break;
16618	case OP_DupFixedPoint:
16619	Text.Op = PrintName("DupFixedPoint");
16620	break;
16621	case OP_DupPtr:
16622	Text.Op = PrintName("DupPtr");
16623	break;
16624	case OP_DupMemberPtr:
16625	Text.Op = PrintName("DupMemberPtr");
16626	break;
16627	case OP_DupFloat:
16628	Text.Op = PrintName("DupFloat");
16629	break;
16630	#endif
16631	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16632	bool emitDupSint8(SourceInfo);
16633	bool emitDupUint8(SourceInfo);
16634	bool emitDupSint16(SourceInfo);
16635	bool emitDupUint16(SourceInfo);
16636	bool emitDupSint32(SourceInfo);
16637	bool emitDupUint32(SourceInfo);
16638	bool emitDupSint64(SourceInfo);
16639	bool emitDupUint64(SourceInfo);
16640	bool emitDupIntAP(SourceInfo);
16641	bool emitDupIntAPS(SourceInfo);
16642	bool emitDupBool(SourceInfo);
16643	bool emitDupFixedPoint(SourceInfo);
16644	bool emitDupPtr(SourceInfo);
16645	bool emitDupMemberPtr(SourceInfo);
16646	bool emitDupFloat(SourceInfo);
16647	#endif
16648	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16649	[[nodiscard]] bool emitDup(PrimType, SourceInfo I);
16650	#endif
16651	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
16652	bool
16653	#if defined(GET_EVAL_IMPL)
16654	EvalEmitter
16655	#else
16656	ByteCodeEmitter
16657	#endif
16658	::emitDup(PrimType T0, SourceInfo I) {
16659	switch (T0) {
16660	case PT_Sint8:
16661	return emitDupSint8(I);
16662	case PT_Uint8:
16663	return emitDupUint8(I);
16664	case PT_Sint16:
16665	return emitDupSint16(I);
16666	case PT_Uint16:
16667	return emitDupUint16(I);
16668	case PT_Sint32:
16669	return emitDupSint32(I);
16670	case PT_Uint32:
16671	return emitDupUint32(I);
16672	case PT_Sint64:
16673	return emitDupSint64(I);
16674	case PT_Uint64:
16675	return emitDupUint64(I);
16676	case PT_IntAP:
16677	return emitDupIntAP(I);
16678	case PT_IntAPS:
16679	return emitDupIntAPS(I);
16680	case PT_Bool:
16681	return emitDupBool(I);
16682	case PT_FixedPoint:
16683	return emitDupFixedPoint(I);
16684	case PT_Ptr:
16685	return emitDupPtr(I);
16686	case PT_MemberPtr:
16687	return emitDupMemberPtr(I);
16688	case PT_Float:
16689	return emitDupFloat(I);
16690	}
16691	llvm_unreachable("invalid enum value");
16692	}
16693	#endif
16694	#ifdef GET_LINK_IMPL
16695	bool ByteCodeEmitter::emitDupSint8(SourceInfo L) {
16696	return emitOp<>(OP_DupSint8, L);
16697	}
16698	bool ByteCodeEmitter::emitDupUint8(SourceInfo L) {
16699	return emitOp<>(OP_DupUint8, L);
16700	}
16701	bool ByteCodeEmitter::emitDupSint16(SourceInfo L) {
16702	return emitOp<>(OP_DupSint16, L);
16703	}
16704	bool ByteCodeEmitter::emitDupUint16(SourceInfo L) {
16705	return emitOp<>(OP_DupUint16, L);
16706	}
16707	bool ByteCodeEmitter::emitDupSint32(SourceInfo L) {
16708	return emitOp<>(OP_DupSint32, L);
16709	}
16710	bool ByteCodeEmitter::emitDupUint32(SourceInfo L) {
16711	return emitOp<>(OP_DupUint32, L);
16712	}
16713	bool ByteCodeEmitter::emitDupSint64(SourceInfo L) {
16714	return emitOp<>(OP_DupSint64, L);
16715	}
16716	bool ByteCodeEmitter::emitDupUint64(SourceInfo L) {
16717	return emitOp<>(OP_DupUint64, L);
16718	}
16719	bool ByteCodeEmitter::emitDupIntAP(SourceInfo L) {
16720	return emitOp<>(OP_DupIntAP, L);
16721	}
16722	bool ByteCodeEmitter::emitDupIntAPS(SourceInfo L) {
16723	return emitOp<>(OP_DupIntAPS, L);
16724	}
16725	bool ByteCodeEmitter::emitDupBool(SourceInfo L) {
16726	return emitOp<>(OP_DupBool, L);
16727	}
16728	bool ByteCodeEmitter::emitDupFixedPoint(SourceInfo L) {
16729	return emitOp<>(OP_DupFixedPoint, L);
16730	}
16731	bool ByteCodeEmitter::emitDupPtr(SourceInfo L) {
16732	return emitOp<>(OP_DupPtr, L);
16733	}
16734	bool ByteCodeEmitter::emitDupMemberPtr(SourceInfo L) {
16735	return emitOp<>(OP_DupMemberPtr, L);
16736	}
16737	bool ByteCodeEmitter::emitDupFloat(SourceInfo L) {
16738	return emitOp<>(OP_DupFloat, L);
16739	}
16740	#endif
16741	#ifdef GET_EVAL_IMPL
16742	bool EvalEmitter::emitDupSint8(SourceInfo L) {
16743	if (!isActive()) return true;
16744	CurrentSource = L;
16745	return Dup<PT_Sint8>(S);
16746	}
16747	bool EvalEmitter::emitDupUint8(SourceInfo L) {
16748	if (!isActive()) return true;
16749	CurrentSource = L;
16750	return Dup<PT_Uint8>(S);
16751	}
16752	bool EvalEmitter::emitDupSint16(SourceInfo L) {
16753	if (!isActive()) return true;
16754	CurrentSource = L;
16755	return Dup<PT_Sint16>(S);
16756	}
16757	bool EvalEmitter::emitDupUint16(SourceInfo L) {
16758	if (!isActive()) return true;
16759	CurrentSource = L;
16760	return Dup<PT_Uint16>(S);
16761	}
16762	bool EvalEmitter::emitDupSint32(SourceInfo L) {
16763	if (!isActive()) return true;
16764	CurrentSource = L;
16765	return Dup<PT_Sint32>(S);
16766	}
16767	bool EvalEmitter::emitDupUint32(SourceInfo L) {
16768	if (!isActive()) return true;
16769	CurrentSource = L;
16770	return Dup<PT_Uint32>(S);
16771	}
16772	bool EvalEmitter::emitDupSint64(SourceInfo L) {
16773	if (!isActive()) return true;
16774	CurrentSource = L;
16775	return Dup<PT_Sint64>(S);
16776	}
16777	bool EvalEmitter::emitDupUint64(SourceInfo L) {
16778	if (!isActive()) return true;
16779	CurrentSource = L;
16780	return Dup<PT_Uint64>(S);
16781	}
16782	bool EvalEmitter::emitDupIntAP(SourceInfo L) {
16783	if (!isActive()) return true;
16784	CurrentSource = L;
16785	return Dup<PT_IntAP>(S);
16786	}
16787	bool EvalEmitter::emitDupIntAPS(SourceInfo L) {
16788	if (!isActive()) return true;
16789	CurrentSource = L;
16790	return Dup<PT_IntAPS>(S);
16791	}
16792	bool EvalEmitter::emitDupBool(SourceInfo L) {
16793	if (!isActive()) return true;
16794	CurrentSource = L;
16795	return Dup<PT_Bool>(S);
16796	}
16797	bool EvalEmitter::emitDupFixedPoint(SourceInfo L) {
16798	if (!isActive()) return true;
16799	CurrentSource = L;
16800	return Dup<PT_FixedPoint>(S);
16801	}
16802	bool EvalEmitter::emitDupPtr(SourceInfo L) {
16803	if (!isActive()) return true;
16804	CurrentSource = L;
16805	return Dup<PT_Ptr>(S);
16806	}
16807	bool EvalEmitter::emitDupMemberPtr(SourceInfo L) {
16808	if (!isActive()) return true;
16809	CurrentSource = L;
16810	return Dup<PT_MemberPtr>(S);
16811	}
16812	bool EvalEmitter::emitDupFloat(SourceInfo L) {
16813	if (!isActive()) return true;
16814	CurrentSource = L;
16815	return Dup<PT_Float>(S);
16816	}
16817	#endif
16818	#ifdef GET_OPCODE_NAMES
16819	OP_DynamicCast,
16820	#endif
16821	#ifdef GET_INTERPFN_LIST
16822	&Interp_DynamicCast,
16823	#endif
16824	#ifdef GET_INTERPFN_DISPATCHERS
16825	PRESERVE_NONE
16826	static bool Interp_DynamicCast(InterpState &S) {
16827	{
16828	CodePtr OpPC = S.PC;
16829	const auto V0 = ReadArg<const Type *>(S, S.PC);
16830	const auto V1 = ReadArg<bool>(S, S.PC);
16831	if (!DynamicCast(S, OpPC, V0, V1)) return false;
16832	}
16833	#if USE_TAILCALLS
16834	MUSTTAIL return InterpNext(S);
16835	#else
16836	return true;
16837	#endif
16838	}
16839	#endif
16840	#ifdef GET_DISASM
16841	case OP_DynamicCast:
16842	Text.Op = PrintName("DynamicCast");
16843	Text.Args.push_back(printArg<const Type *>(P, PC));
16844	Text.Args.push_back(printArg<bool>(P, PC));
16845	break;
16846	#endif
16847	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
16848	bool emitDynamicCast( const Type * , bool , SourceInfo);
16849	#endif
16850	#ifdef GET_LINK_IMPL
16851	bool ByteCodeEmitter::emitDynamicCast( const Type * A0, bool A1, SourceInfo L) {
16852	return emitOp<const Type , bool*>(OP_DynamicCast, A0, A1, L);
16853	}
16854	#endif
16855	#ifdef GET_EVAL_IMPL
16856	bool EvalEmitter::emitDynamicCast( const Type * A0, bool A1, SourceInfo L) {
16857	if (!isActive()) return true;
16858	CurrentSource = L;
16859	return DynamicCast(S, CodePtr(), A0, A1);
16860	}
16861	#endif
16862	#ifdef GET_OPCODE_NAMES
16863	OP_EQSint8,
16864	OP_EQUint8,
16865	OP_EQSint16,
16866	OP_EQUint16,
16867	OP_EQSint32,
16868	OP_EQUint32,
16869	OP_EQSint64,
16870	OP_EQUint64,
16871	OP_EQIntAP,
16872	OP_EQIntAPS,
16873	OP_EQBool,
16874	OP_EQFixedPoint,
16875	OP_EQPtr,
16876	OP_EQMemberPtr,
16877	OP_EQFloat,
16878	#endif
16879	#ifdef GET_INTERPFN_LIST
16880	&Interp_EQSint8,
16881	&Interp_EQUint8,
16882	&Interp_EQSint16,
16883	&Interp_EQUint16,
16884	&Interp_EQSint32,
16885	&Interp_EQUint32,
16886	&Interp_EQSint64,
16887	&Interp_EQUint64,
16888	&Interp_EQIntAP,
16889	&Interp_EQIntAPS,
16890	&Interp_EQBool,
16891	&Interp_EQFixedPoint,
16892	&Interp_EQPtr,
16893	&Interp_EQMemberPtr,
16894	&Interp_EQFloat,
16895	#endif
16896	#ifdef GET_INTERPFN_DISPATCHERS
16897	PRESERVE_NONE
16898	static bool Interp_EQSint8(InterpState &S) {
16899	if (!EQ<PT_Sint8>(S, S.PC)) return false;
16900	#if USE_TAILCALLS
16901	MUSTTAIL return InterpNext(S);
16902	#else
16903	return true;
16904	#endif
16905	}
16906	PRESERVE_NONE
16907	static bool Interp_EQUint8(InterpState &S) {
16908	if (!EQ<PT_Uint8>(S, S.PC)) return false;
16909	#if USE_TAILCALLS
16910	MUSTTAIL return InterpNext(S);
16911	#else
16912	return true;
16913	#endif
16914	}
16915	PRESERVE_NONE
16916	static bool Interp_EQSint16(InterpState &S) {
16917	if (!EQ<PT_Sint16>(S, S.PC)) return false;
16918	#if USE_TAILCALLS
16919	MUSTTAIL return InterpNext(S);
16920	#else
16921	return true;
16922	#endif
16923	}
16924	PRESERVE_NONE
16925	static bool Interp_EQUint16(InterpState &S) {
16926	if (!EQ<PT_Uint16>(S, S.PC)) return false;
16927	#if USE_TAILCALLS
16928	MUSTTAIL return InterpNext(S);
16929	#else
16930	return true;
16931	#endif
16932	}
16933	PRESERVE_NONE
16934	static bool Interp_EQSint32(InterpState &S) {
16935	if (!EQ<PT_Sint32>(S, S.PC)) return false;
16936	#if USE_TAILCALLS
16937	MUSTTAIL return InterpNext(S);
16938	#else
16939	return true;
16940	#endif
16941	}
16942	PRESERVE_NONE
16943	static bool Interp_EQUint32(InterpState &S) {
16944	if (!EQ<PT_Uint32>(S, S.PC)) return false;
16945	#if USE_TAILCALLS
16946	MUSTTAIL return InterpNext(S);
16947	#else
16948	return true;
16949	#endif
16950	}
16951	PRESERVE_NONE
16952	static bool Interp_EQSint64(InterpState &S) {
16953	if (!EQ<PT_Sint64>(S, S.PC)) return false;
16954	#if USE_TAILCALLS
16955	MUSTTAIL return InterpNext(S);
16956	#else
16957	return true;
16958	#endif
16959	}
16960	PRESERVE_NONE
16961	static bool Interp_EQUint64(InterpState &S) {
16962	if (!EQ<PT_Uint64>(S, S.PC)) return false;
16963	#if USE_TAILCALLS
16964	MUSTTAIL return InterpNext(S);
16965	#else
16966	return true;
16967	#endif
16968	}
16969	PRESERVE_NONE
16970	static bool Interp_EQIntAP(InterpState &S) {
16971	if (!EQ<PT_IntAP>(S, S.PC)) return false;
16972	#if USE_TAILCALLS
16973	MUSTTAIL return InterpNext(S);
16974	#else
16975	return true;
16976	#endif
16977	}
16978	PRESERVE_NONE
16979	static bool Interp_EQIntAPS(InterpState &S) {
16980	if (!EQ<PT_IntAPS>(S, S.PC)) return false;
16981	#if USE_TAILCALLS
16982	MUSTTAIL return InterpNext(S);
16983	#else
16984	return true;
16985	#endif
16986	}
16987	PRESERVE_NONE
16988	static bool Interp_EQBool(InterpState &S) {
16989	if (!EQ<PT_Bool>(S, S.PC)) return false;
16990	#if USE_TAILCALLS
16991	MUSTTAIL return InterpNext(S);
16992	#else
16993	return true;
16994	#endif
16995	}
16996	PRESERVE_NONE
16997	static bool Interp_EQFixedPoint(InterpState &S) {
16998	if (!EQ<PT_FixedPoint>(S, S.PC)) return false;
16999	#if USE_TAILCALLS
17000	MUSTTAIL return InterpNext(S);
17001	#else
17002	return true;
17003	#endif
17004	}
17005	PRESERVE_NONE
17006	static bool Interp_EQPtr(InterpState &S) {
17007	if (!EQ<PT_Ptr>(S, S.PC)) return false;
17008	#if USE_TAILCALLS
17009	MUSTTAIL return InterpNext(S);
17010	#else
17011	return true;
17012	#endif
17013	}
17014	PRESERVE_NONE
17015	static bool Interp_EQMemberPtr(InterpState &S) {
17016	if (!EQ<PT_MemberPtr>(S, S.PC)) return false;
17017	#if USE_TAILCALLS
17018	MUSTTAIL return InterpNext(S);
17019	#else
17020	return true;
17021	#endif
17022	}
17023	PRESERVE_NONE
17024	static bool Interp_EQFloat(InterpState &S) {
17025	if (!EQ<PT_Float>(S, S.PC)) return false;
17026	#if USE_TAILCALLS
17027	MUSTTAIL return InterpNext(S);
17028	#else
17029	return true;
17030	#endif
17031	}
17032	#endif
17033	#ifdef GET_DISASM
17034	case OP_EQSint8:
17035	Text.Op = PrintName("EQSint8");
17036	break;
17037	case OP_EQUint8:
17038	Text.Op = PrintName("EQUint8");
17039	break;
17040	case OP_EQSint16:
17041	Text.Op = PrintName("EQSint16");
17042	break;
17043	case OP_EQUint16:
17044	Text.Op = PrintName("EQUint16");
17045	break;
17046	case OP_EQSint32:
17047	Text.Op = PrintName("EQSint32");
17048	break;
17049	case OP_EQUint32:
17050	Text.Op = PrintName("EQUint32");
17051	break;
17052	case OP_EQSint64:
17053	Text.Op = PrintName("EQSint64");
17054	break;
17055	case OP_EQUint64:
17056	Text.Op = PrintName("EQUint64");
17057	break;
17058	case OP_EQIntAP:
17059	Text.Op = PrintName("EQIntAP");
17060	break;
17061	case OP_EQIntAPS:
17062	Text.Op = PrintName("EQIntAPS");
17063	break;
17064	case OP_EQBool:
17065	Text.Op = PrintName("EQBool");
17066	break;
17067	case OP_EQFixedPoint:
17068	Text.Op = PrintName("EQFixedPoint");
17069	break;
17070	case OP_EQPtr:
17071	Text.Op = PrintName("EQPtr");
17072	break;
17073	case OP_EQMemberPtr:
17074	Text.Op = PrintName("EQMemberPtr");
17075	break;
17076	case OP_EQFloat:
17077	Text.Op = PrintName("EQFloat");
17078	break;
17079	#endif
17080	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17081	bool emitEQSint8(SourceInfo);
17082	bool emitEQUint8(SourceInfo);
17083	bool emitEQSint16(SourceInfo);
17084	bool emitEQUint16(SourceInfo);
17085	bool emitEQSint32(SourceInfo);
17086	bool emitEQUint32(SourceInfo);
17087	bool emitEQSint64(SourceInfo);
17088	bool emitEQUint64(SourceInfo);
17089	bool emitEQIntAP(SourceInfo);
17090	bool emitEQIntAPS(SourceInfo);
17091	bool emitEQBool(SourceInfo);
17092	bool emitEQFixedPoint(SourceInfo);
17093	bool emitEQPtr(SourceInfo);
17094	bool emitEQMemberPtr(SourceInfo);
17095	bool emitEQFloat(SourceInfo);
17096	#endif
17097	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17098	[[nodiscard]] bool emitEQ(PrimType, SourceInfo I);
17099	#endif
17100	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
17101	bool
17102	#if defined(GET_EVAL_IMPL)
17103	EvalEmitter
17104	#else
17105	ByteCodeEmitter
17106	#endif
17107	::emitEQ(PrimType T0, SourceInfo I) {
17108	switch (T0) {
17109	case PT_Sint8:
17110	return emitEQSint8(I);
17111	case PT_Uint8:
17112	return emitEQUint8(I);
17113	case PT_Sint16:
17114	return emitEQSint16(I);
17115	case PT_Uint16:
17116	return emitEQUint16(I);
17117	case PT_Sint32:
17118	return emitEQSint32(I);
17119	case PT_Uint32:
17120	return emitEQUint32(I);
17121	case PT_Sint64:
17122	return emitEQSint64(I);
17123	case PT_Uint64:
17124	return emitEQUint64(I);
17125	case PT_IntAP:
17126	return emitEQIntAP(I);
17127	case PT_IntAPS:
17128	return emitEQIntAPS(I);
17129	case PT_Bool:
17130	return emitEQBool(I);
17131	case PT_FixedPoint:
17132	return emitEQFixedPoint(I);
17133	case PT_Ptr:
17134	return emitEQPtr(I);
17135	case PT_MemberPtr:
17136	return emitEQMemberPtr(I);
17137	case PT_Float:
17138	return emitEQFloat(I);
17139	}
17140	llvm_unreachable("invalid enum value");
17141	}
17142	#endif
17143	#ifdef GET_LINK_IMPL
17144	bool ByteCodeEmitter::emitEQSint8(SourceInfo L) {
17145	return emitOp<>(OP_EQSint8, L);
17146	}
17147	bool ByteCodeEmitter::emitEQUint8(SourceInfo L) {
17148	return emitOp<>(OP_EQUint8, L);
17149	}
17150	bool ByteCodeEmitter::emitEQSint16(SourceInfo L) {
17151	return emitOp<>(OP_EQSint16, L);
17152	}
17153	bool ByteCodeEmitter::emitEQUint16(SourceInfo L) {
17154	return emitOp<>(OP_EQUint16, L);
17155	}
17156	bool ByteCodeEmitter::emitEQSint32(SourceInfo L) {
17157	return emitOp<>(OP_EQSint32, L);
17158	}
17159	bool ByteCodeEmitter::emitEQUint32(SourceInfo L) {
17160	return emitOp<>(OP_EQUint32, L);
17161	}
17162	bool ByteCodeEmitter::emitEQSint64(SourceInfo L) {
17163	return emitOp<>(OP_EQSint64, L);
17164	}
17165	bool ByteCodeEmitter::emitEQUint64(SourceInfo L) {
17166	return emitOp<>(OP_EQUint64, L);
17167	}
17168	bool ByteCodeEmitter::emitEQIntAP(SourceInfo L) {
17169	return emitOp<>(OP_EQIntAP, L);
17170	}
17171	bool ByteCodeEmitter::emitEQIntAPS(SourceInfo L) {
17172	return emitOp<>(OP_EQIntAPS, L);
17173	}
17174	bool ByteCodeEmitter::emitEQBool(SourceInfo L) {
17175	return emitOp<>(OP_EQBool, L);
17176	}
17177	bool ByteCodeEmitter::emitEQFixedPoint(SourceInfo L) {
17178	return emitOp<>(OP_EQFixedPoint, L);
17179	}
17180	bool ByteCodeEmitter::emitEQPtr(SourceInfo L) {
17181	return emitOp<>(OP_EQPtr, L);
17182	}
17183	bool ByteCodeEmitter::emitEQMemberPtr(SourceInfo L) {
17184	return emitOp<>(OP_EQMemberPtr, L);
17185	}
17186	bool ByteCodeEmitter::emitEQFloat(SourceInfo L) {
17187	return emitOp<>(OP_EQFloat, L);
17188	}
17189	#endif
17190	#ifdef GET_EVAL_IMPL
17191	bool EvalEmitter::emitEQSint8(SourceInfo L) {
17192	if (!isActive()) return true;
17193	CurrentSource = L;
17194	return EQ<PT_Sint8>(S, CodePtr());
17195	}
17196	bool EvalEmitter::emitEQUint8(SourceInfo L) {
17197	if (!isActive()) return true;
17198	CurrentSource = L;
17199	return EQ<PT_Uint8>(S, CodePtr());
17200	}
17201	bool EvalEmitter::emitEQSint16(SourceInfo L) {
17202	if (!isActive()) return true;
17203	CurrentSource = L;
17204	return EQ<PT_Sint16>(S, CodePtr());
17205	}
17206	bool EvalEmitter::emitEQUint16(SourceInfo L) {
17207	if (!isActive()) return true;
17208	CurrentSource = L;
17209	return EQ<PT_Uint16>(S, CodePtr());
17210	}
17211	bool EvalEmitter::emitEQSint32(SourceInfo L) {
17212	if (!isActive()) return true;
17213	CurrentSource = L;
17214	return EQ<PT_Sint32>(S, CodePtr());
17215	}
17216	bool EvalEmitter::emitEQUint32(SourceInfo L) {
17217	if (!isActive()) return true;
17218	CurrentSource = L;
17219	return EQ<PT_Uint32>(S, CodePtr());
17220	}
17221	bool EvalEmitter::emitEQSint64(SourceInfo L) {
17222	if (!isActive()) return true;
17223	CurrentSource = L;
17224	return EQ<PT_Sint64>(S, CodePtr());
17225	}
17226	bool EvalEmitter::emitEQUint64(SourceInfo L) {
17227	if (!isActive()) return true;
17228	CurrentSource = L;
17229	return EQ<PT_Uint64>(S, CodePtr());
17230	}
17231	bool EvalEmitter::emitEQIntAP(SourceInfo L) {
17232	if (!isActive()) return true;
17233	CurrentSource = L;
17234	return EQ<PT_IntAP>(S, CodePtr());
17235	}
17236	bool EvalEmitter::emitEQIntAPS(SourceInfo L) {
17237	if (!isActive()) return true;
17238	CurrentSource = L;
17239	return EQ<PT_IntAPS>(S, CodePtr());
17240	}
17241	bool EvalEmitter::emitEQBool(SourceInfo L) {
17242	if (!isActive()) return true;
17243	CurrentSource = L;
17244	return EQ<PT_Bool>(S, CodePtr());
17245	}
17246	bool EvalEmitter::emitEQFixedPoint(SourceInfo L) {
17247	if (!isActive()) return true;
17248	CurrentSource = L;
17249	return EQ<PT_FixedPoint>(S, CodePtr());
17250	}
17251	bool EvalEmitter::emitEQPtr(SourceInfo L) {
17252	if (!isActive()) return true;
17253	CurrentSource = L;
17254	return EQ<PT_Ptr>(S, CodePtr());
17255	}
17256	bool EvalEmitter::emitEQMemberPtr(SourceInfo L) {
17257	if (!isActive()) return true;
17258	CurrentSource = L;
17259	return EQ<PT_MemberPtr>(S, CodePtr());
17260	}
17261	bool EvalEmitter::emitEQFloat(SourceInfo L) {
17262	if (!isActive()) return true;
17263	CurrentSource = L;
17264	return EQ<PT_Float>(S, CodePtr());
17265	}
17266	#endif
17267	#ifdef GET_OPCODE_NAMES
17268	OP_EnableLocal,
17269	#endif
17270	#ifdef GET_INTERPFN_LIST
17271	&Interp_EnableLocal,
17272	#endif
17273	#ifdef GET_INTERPFN_DISPATCHERS
17274	PRESERVE_NONE
17275	static bool Interp_EnableLocal(InterpState &S) {
17276	{
17277	const auto V0 = ReadArg<uint32_t>(S, S.PC);
17278	EnableLocal(S, V0);
17279	}
17280	#if USE_TAILCALLS
17281	MUSTTAIL return InterpNext(S);
17282	#else
17283	return true;
17284	#endif
17285	}
17286	#endif
17287	#ifdef GET_DISASM
17288	case OP_EnableLocal:
17289	Text.Op = PrintName("EnableLocal");
17290	Text.Args.push_back(printArg<uint32_t>(P, PC));
17291	break;
17292	#endif
17293	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17294	bool emitEnableLocal( uint32_t , SourceInfo);
17295	#endif
17296	#ifdef GET_LINK_IMPL
17297	bool ByteCodeEmitter::emitEnableLocal( uint32_t A0, SourceInfo L) {
17298	return emitOp<uint32_t>(OP_EnableLocal, A0, L);
17299	}
17300	#endif
17301	#ifdef GET_OPCODE_NAMES
17302	OP_EndInit,
17303	#endif
17304	#ifdef GET_INTERPFN_LIST
17305	&Interp_EndInit,
17306	#endif
17307	#ifdef GET_INTERPFN_DISPATCHERS
17308	PRESERVE_NONE
17309	static bool Interp_EndInit(InterpState &S) {
17310	EndInit(S);
17311	#if USE_TAILCALLS
17312	MUSTTAIL return InterpNext(S);
17313	#else
17314	return true;
17315	#endif
17316	}
17317	#endif
17318	#ifdef GET_DISASM
17319	case OP_EndInit:
17320	Text.Op = PrintName("EndInit");
17321	break;
17322	#endif
17323	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17324	bool emitEndInit(SourceInfo);
17325	#endif
17326	#ifdef GET_LINK_IMPL
17327	bool ByteCodeEmitter::emitEndInit(SourceInfo L) {
17328	return emitOp<>(OP_EndInit, L);
17329	}
17330	#endif
17331	#ifdef GET_EVAL_IMPL
17332	bool EvalEmitter::emitEndInit(SourceInfo L) {
17333	if (!isActive()) return true;
17334	CurrentSource = L;
17335	return EndInit(S);
17336	}
17337	#endif
17338	#ifdef GET_OPCODE_NAMES
17339	OP_EndLifetime,
17340	#endif
17341	#ifdef GET_INTERPFN_LIST
17342	&Interp_EndLifetime,
17343	#endif
17344	#ifdef GET_INTERPFN_DISPATCHERS
17345	PRESERVE_NONE
17346	static bool Interp_EndLifetime(InterpState &S) {
17347	if (!EndLifetime(S, S.PC)) return false;
17348	#if USE_TAILCALLS
17349	MUSTTAIL return InterpNext(S);
17350	#else
17351	return true;
17352	#endif
17353	}
17354	#endif
17355	#ifdef GET_DISASM
17356	case OP_EndLifetime:
17357	Text.Op = PrintName("EndLifetime");
17358	break;
17359	#endif
17360	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17361	bool emitEndLifetime(SourceInfo);
17362	#endif
17363	#ifdef GET_LINK_IMPL
17364	bool ByteCodeEmitter::emitEndLifetime(SourceInfo L) {
17365	return emitOp<>(OP_EndLifetime, L);
17366	}
17367	#endif
17368	#ifdef GET_EVAL_IMPL
17369	bool EvalEmitter::emitEndLifetime(SourceInfo L) {
17370	if (!isActive()) return true;
17371	CurrentSource = L;
17372	return EndLifetime(S, CodePtr());
17373	}
17374	#endif
17375	#ifdef GET_OPCODE_NAMES
17376	OP_EndSpeculation,
17377	#endif
17378	#ifdef GET_INTERPFN_LIST
17379	&Interp_EndSpeculation,
17380	#endif
17381	#ifdef GET_INTERPFN_DISPATCHERS
17382	PRESERVE_NONE
17383	static bool Interp_EndSpeculation(InterpState &S) {
17384	MUSTTAIL return EndSpeculation(S);
17385	}
17386	#endif
17387	#ifdef GET_DISASM
17388	case OP_EndSpeculation:
17389	Text.Op = PrintName("EndSpeculation");
17390	break;
17391	#endif
17392	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17393	bool emitEndSpeculation(SourceInfo);
17394	#endif
17395	#ifdef GET_LINK_IMPL
17396	bool ByteCodeEmitter::emitEndSpeculation(SourceInfo L) {
17397	return emitOp<>(OP_EndSpeculation, L);
17398	}
17399	#endif
17400	#ifdef GET_EVAL_IMPL
17401	bool EvalEmitter::emitEndSpeculation(SourceInfo L) {
17402	if (!isActive()) return true;
17403	CurrentSource = L;
17404	return EndSpeculation(S);
17405	}
17406	#endif
17407	#ifdef GET_OPCODE_NAMES
17408	OP_Error,
17409	#endif
17410	#ifdef GET_INTERPFN_LIST
17411	&Interp_Error,
17412	#endif
17413	#ifdef GET_INTERPFN_DISPATCHERS
17414	PRESERVE_NONE
17415	static bool Interp_Error(InterpState &S) {
17416	if (!Error(S)) return false;
17417	#if USE_TAILCALLS
17418	MUSTTAIL return InterpNext(S);
17419	#else
17420	return true;
17421	#endif
17422	}
17423	#endif
17424	#ifdef GET_DISASM
17425	case OP_Error:
17426	Text.Op = PrintName("Error");
17427	break;
17428	#endif
17429	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17430	bool emitError(SourceInfo);
17431	#endif
17432	#ifdef GET_LINK_IMPL
17433	bool ByteCodeEmitter::emitError(SourceInfo L) {
17434	return emitOp<>(OP_Error, L);
17435	}
17436	#endif
17437	#ifdef GET_EVAL_IMPL
17438	bool EvalEmitter::emitError(SourceInfo L) {
17439	if (!isActive()) return true;
17440	CurrentSource = L;
17441	return Error(S);
17442	}
17443	#endif
17444	#ifdef GET_OPCODE_NAMES
17445	OP_ExpandPtr,
17446	#endif
17447	#ifdef GET_INTERPFN_LIST
17448	&Interp_ExpandPtr,
17449	#endif
17450	#ifdef GET_INTERPFN_DISPATCHERS
17451	PRESERVE_NONE
17452	static bool Interp_ExpandPtr(InterpState &S) {
17453	ExpandPtr(S);
17454	#if USE_TAILCALLS
17455	MUSTTAIL return InterpNext(S);
17456	#else
17457	return true;
17458	#endif
17459	}
17460	#endif
17461	#ifdef GET_DISASM
17462	case OP_ExpandPtr:
17463	Text.Op = PrintName("ExpandPtr");
17464	break;
17465	#endif
17466	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17467	bool emitExpandPtr(SourceInfo);
17468	#endif
17469	#ifdef GET_LINK_IMPL
17470	bool ByteCodeEmitter::emitExpandPtr(SourceInfo L) {
17471	return emitOp<>(OP_ExpandPtr, L);
17472	}
17473	#endif
17474	#ifdef GET_EVAL_IMPL
17475	bool EvalEmitter::emitExpandPtr(SourceInfo L) {
17476	if (!isActive()) return true;
17477	CurrentSource = L;
17478	return ExpandPtr(S);
17479	}
17480	#endif
17481	#ifdef GET_OPCODE_NAMES
17482	OP_FinishInit,
17483	#endif
17484	#ifdef GET_INTERPFN_LIST
17485	&Interp_FinishInit,
17486	#endif
17487	#ifdef GET_INTERPFN_DISPATCHERS
17488	PRESERVE_NONE
17489	static bool Interp_FinishInit(InterpState &S) {
17490	FinishInit(S);
17491	#if USE_TAILCALLS
17492	MUSTTAIL return InterpNext(S);
17493	#else
17494	return true;
17495	#endif
17496	}
17497	#endif
17498	#ifdef GET_DISASM
17499	case OP_FinishInit:
17500	Text.Op = PrintName("FinishInit");
17501	break;
17502	#endif
17503	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17504	bool emitFinishInit(SourceInfo);
17505	#endif
17506	#ifdef GET_LINK_IMPL
17507	bool ByteCodeEmitter::emitFinishInit(SourceInfo L) {
17508	return emitOp<>(OP_FinishInit, L);
17509	}
17510	#endif
17511	#ifdef GET_EVAL_IMPL
17512	bool EvalEmitter::emitFinishInit(SourceInfo L) {
17513	if (!isActive()) return true;
17514	CurrentSource = L;
17515	return FinishInit(S);
17516	}
17517	#endif
17518	#ifdef GET_OPCODE_NAMES
17519	OP_FinishInitActivate,
17520	#endif
17521	#ifdef GET_INTERPFN_LIST
17522	&Interp_FinishInitActivate,
17523	#endif
17524	#ifdef GET_INTERPFN_DISPATCHERS
17525	PRESERVE_NONE
17526	static bool Interp_FinishInitActivate(InterpState &S) {
17527	FinishInitActivate(S);
17528	#if USE_TAILCALLS
17529	MUSTTAIL return InterpNext(S);
17530	#else
17531	return true;
17532	#endif
17533	}
17534	#endif
17535	#ifdef GET_DISASM
17536	case OP_FinishInitActivate:
17537	Text.Op = PrintName("FinishInitActivate");
17538	break;
17539	#endif
17540	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17541	bool emitFinishInitActivate(SourceInfo);
17542	#endif
17543	#ifdef GET_LINK_IMPL
17544	bool ByteCodeEmitter::emitFinishInitActivate(SourceInfo L) {
17545	return emitOp<>(OP_FinishInitActivate, L);
17546	}
17547	#endif
17548	#ifdef GET_EVAL_IMPL
17549	bool EvalEmitter::emitFinishInitActivate(SourceInfo L) {
17550	if (!isActive()) return true;
17551	CurrentSource = L;
17552	return FinishInitActivate(S);
17553	}
17554	#endif
17555	#ifdef GET_OPCODE_NAMES
17556	OP_FinishInitActivatePop,
17557	#endif
17558	#ifdef GET_INTERPFN_LIST
17559	&Interp_FinishInitActivatePop,
17560	#endif
17561	#ifdef GET_INTERPFN_DISPATCHERS
17562	PRESERVE_NONE
17563	static bool Interp_FinishInitActivatePop(InterpState &S) {
17564	FinishInitActivatePop(S);
17565	#if USE_TAILCALLS
17566	MUSTTAIL return InterpNext(S);
17567	#else
17568	return true;
17569	#endif
17570	}
17571	#endif
17572	#ifdef GET_DISASM
17573	case OP_FinishInitActivatePop:
17574	Text.Op = PrintName("FinishInitActivatePop");
17575	break;
17576	#endif
17577	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17578	bool emitFinishInitActivatePop(SourceInfo);
17579	#endif
17580	#ifdef GET_LINK_IMPL
17581	bool ByteCodeEmitter::emitFinishInitActivatePop(SourceInfo L) {
17582	return emitOp<>(OP_FinishInitActivatePop, L);
17583	}
17584	#endif
17585	#ifdef GET_EVAL_IMPL
17586	bool EvalEmitter::emitFinishInitActivatePop(SourceInfo L) {
17587	if (!isActive()) return true;
17588	CurrentSource = L;
17589	return FinishInitActivatePop(S);
17590	}
17591	#endif
17592	#ifdef GET_OPCODE_NAMES
17593	OP_FinishInitGlobal,
17594	#endif
17595	#ifdef GET_INTERPFN_LIST
17596	&Interp_FinishInitGlobal,
17597	#endif
17598	#ifdef GET_INTERPFN_DISPATCHERS
17599	PRESERVE_NONE
17600	static bool Interp_FinishInitGlobal(InterpState &S) {
17601	FinishInitGlobal(S);
17602	#if USE_TAILCALLS
17603	MUSTTAIL return InterpNext(S);
17604	#else
17605	return true;
17606	#endif
17607	}
17608	#endif
17609	#ifdef GET_DISASM
17610	case OP_FinishInitGlobal:
17611	Text.Op = PrintName("FinishInitGlobal");
17612	break;
17613	#endif
17614	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17615	bool emitFinishInitGlobal(SourceInfo);
17616	#endif
17617	#ifdef GET_LINK_IMPL
17618	bool ByteCodeEmitter::emitFinishInitGlobal(SourceInfo L) {
17619	return emitOp<>(OP_FinishInitGlobal, L);
17620	}
17621	#endif
17622	#ifdef GET_EVAL_IMPL
17623	bool EvalEmitter::emitFinishInitGlobal(SourceInfo L) {
17624	if (!isActive()) return true;
17625	CurrentSource = L;
17626	return FinishInitGlobal(S);
17627	}
17628	#endif
17629	#ifdef GET_OPCODE_NAMES
17630	OP_FinishInitPop,
17631	#endif
17632	#ifdef GET_INTERPFN_LIST
17633	&Interp_FinishInitPop,
17634	#endif
17635	#ifdef GET_INTERPFN_DISPATCHERS
17636	PRESERVE_NONE
17637	static bool Interp_FinishInitPop(InterpState &S) {
17638	FinishInitPop(S);
17639	#if USE_TAILCALLS
17640	MUSTTAIL return InterpNext(S);
17641	#else
17642	return true;
17643	#endif
17644	}
17645	#endif
17646	#ifdef GET_DISASM
17647	case OP_FinishInitPop:
17648	Text.Op = PrintName("FinishInitPop");
17649	break;
17650	#endif
17651	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
17652	bool emitFinishInitPop(SourceInfo);
17653	#endif
17654	#ifdef GET_LINK_IMPL
17655	bool ByteCodeEmitter::emitFinishInitPop(SourceInfo L) {
17656	return emitOp<>(OP_FinishInitPop, L);
17657	}
17658	#endif
17659	#ifdef GET_EVAL_IMPL
17660	bool EvalEmitter::emitFinishInitPop(SourceInfo L) {
17661	if (!isActive()) return true;
17662	CurrentSource = L;
17663	return FinishInitPop(S);
17664	}
17665	#endif
17666	#ifdef GET_OPCODE_NAMES
17667	OP_FlipSint8Sint8,
17668	OP_FlipSint8Uint8,
17669	OP_FlipSint8Sint16,
17670	OP_FlipSint8Uint16,
17671	OP_FlipSint8Sint32,
17672	OP_FlipSint8Uint32,
17673	OP_FlipSint8Sint64,
17674	OP_FlipSint8Uint64,
17675	OP_FlipSint8IntAP,
17676	OP_FlipSint8IntAPS,
17677	OP_FlipSint8Bool,
17678	OP_FlipSint8FixedPoint,
17679	OP_FlipSint8Ptr,
17680	OP_FlipSint8MemberPtr,
17681	OP_FlipSint8Float,
17682	OP_FlipUint8Sint8,
17683	OP_FlipUint8Uint8,
17684	OP_FlipUint8Sint16,
17685	OP_FlipUint8Uint16,
17686	OP_FlipUint8Sint32,
17687	OP_FlipUint8Uint32,
17688	OP_FlipUint8Sint64,
17689	OP_FlipUint8Uint64,
17690	OP_FlipUint8IntAP,
17691	OP_FlipUint8IntAPS,
17692	OP_FlipUint8Bool,
17693	OP_FlipUint8FixedPoint,
17694	OP_FlipUint8Ptr,
17695	OP_FlipUint8MemberPtr,
17696	OP_FlipUint8Float,
17697	OP_FlipSint16Sint8,
17698	OP_FlipSint16Uint8,
17699	OP_FlipSint16Sint16,
17700	OP_FlipSint16Uint16,
17701	OP_FlipSint16Sint32,
17702	OP_FlipSint16Uint32,
17703	OP_FlipSint16Sint64,
17704	OP_FlipSint16Uint64,
17705	OP_FlipSint16IntAP,
17706	OP_FlipSint16IntAPS,
17707	OP_FlipSint16Bool,
17708	OP_FlipSint16FixedPoint,
17709	OP_FlipSint16Ptr,
17710	OP_FlipSint16MemberPtr,
17711	OP_FlipSint16Float,
17712	OP_FlipUint16Sint8,
17713	OP_FlipUint16Uint8,
17714	OP_FlipUint16Sint16,
17715	OP_FlipUint16Uint16,
17716	OP_FlipUint16Sint32,
17717	OP_FlipUint16Uint32,
17718	OP_FlipUint16Sint64,
17719	OP_FlipUint16Uint64,
17720	OP_FlipUint16IntAP,
17721	OP_FlipUint16IntAPS,
17722	OP_FlipUint16Bool,
17723	OP_FlipUint16FixedPoint,
17724	OP_FlipUint16Ptr,
17725	OP_FlipUint16MemberPtr,
17726	OP_FlipUint16Float,
17727	OP_FlipSint32Sint8,
17728	OP_FlipSint32Uint8,
17729	OP_FlipSint32Sint16,
17730	OP_FlipSint32Uint16,
17731	OP_FlipSint32Sint32,
17732	OP_FlipSint32Uint32,
17733	OP_FlipSint32Sint64,
17734	OP_FlipSint32Uint64,
17735	OP_FlipSint32IntAP,
17736	OP_FlipSint32IntAPS,
17737	OP_FlipSint32Bool,
17738	OP_FlipSint32FixedPoint,
17739	OP_FlipSint32Ptr,
17740	OP_FlipSint32MemberPtr,
17741	OP_FlipSint32Float,
17742	OP_FlipUint32Sint8,
17743	OP_FlipUint32Uint8,
17744	OP_FlipUint32Sint16,
17745	OP_FlipUint32Uint16,
17746	OP_FlipUint32Sint32,
17747	OP_FlipUint32Uint32,
17748	OP_FlipUint32Sint64,
17749	OP_FlipUint32Uint64,
17750	OP_FlipUint32IntAP,
17751	OP_FlipUint32IntAPS,
17752	OP_FlipUint32Bool,
17753	OP_FlipUint32FixedPoint,
17754	OP_FlipUint32Ptr,
17755	OP_FlipUint32MemberPtr,
17756	OP_FlipUint32Float,
17757	OP_FlipSint64Sint8,
17758	OP_FlipSint64Uint8,
17759	OP_FlipSint64Sint16,
17760	OP_FlipSint64Uint16,
17761	OP_FlipSint64Sint32,
17762	OP_FlipSint64Uint32,
17763	OP_FlipSint64Sint64,
17764	OP_FlipSint64Uint64,
17765	OP_FlipSint64IntAP,
17766	OP_FlipSint64IntAPS,
17767	OP_FlipSint64Bool,
17768	OP_FlipSint64FixedPoint,
17769	OP_FlipSint64Ptr,
17770	OP_FlipSint64MemberPtr,
17771	OP_FlipSint64Float,
17772	OP_FlipUint64Sint8,
17773	OP_FlipUint64Uint8,
17774	OP_FlipUint64Sint16,
17775	OP_FlipUint64Uint16,
17776	OP_FlipUint64Sint32,
17777	OP_FlipUint64Uint32,
17778	OP_FlipUint64Sint64,
17779	OP_FlipUint64Uint64,
17780	OP_FlipUint64IntAP,
17781	OP_FlipUint64IntAPS,
17782	OP_FlipUint64Bool,
17783	OP_FlipUint64FixedPoint,
17784	OP_FlipUint64Ptr,
17785	OP_FlipUint64MemberPtr,
17786	OP_FlipUint64Float,
17787	OP_FlipIntAPSint8,
17788	OP_FlipIntAPUint8,
17789	OP_FlipIntAPSint16,
17790	OP_FlipIntAPUint16,
17791	OP_FlipIntAPSint32,
17792	OP_FlipIntAPUint32,
17793	OP_FlipIntAPSint64,
17794	OP_FlipIntAPUint64,
17795	OP_FlipIntAPIntAP,
17796	OP_FlipIntAPIntAPS,
17797	OP_FlipIntAPBool,
17798	OP_FlipIntAPFixedPoint,
17799	OP_FlipIntAPPtr,
17800	OP_FlipIntAPMemberPtr,
17801	OP_FlipIntAPFloat,
17802	OP_FlipIntAPSSint8,
17803	OP_FlipIntAPSUint8,
17804	OP_FlipIntAPSSint16,
17805	OP_FlipIntAPSUint16,
17806	OP_FlipIntAPSSint32,
17807	OP_FlipIntAPSUint32,
17808	OP_FlipIntAPSSint64,
17809	OP_FlipIntAPSUint64,
17810	OP_FlipIntAPSIntAP,
17811	OP_FlipIntAPSIntAPS,
17812	OP_FlipIntAPSBool,
17813	OP_FlipIntAPSFixedPoint,
17814	OP_FlipIntAPSPtr,
17815	OP_FlipIntAPSMemberPtr,
17816	OP_FlipIntAPSFloat,
17817	OP_FlipBoolSint8,
17818	OP_FlipBoolUint8,
17819	OP_FlipBoolSint16,
17820	OP_FlipBoolUint16,
17821	OP_FlipBoolSint32,
17822	OP_FlipBoolUint32,
17823	OP_FlipBoolSint64,
17824	OP_FlipBoolUint64,
17825	OP_FlipBoolIntAP,
17826	OP_FlipBoolIntAPS,
17827	OP_FlipBoolBool,
17828	OP_FlipBoolFixedPoint,
17829	OP_FlipBoolPtr,
17830	OP_FlipBoolMemberPtr,
17831	OP_FlipBoolFloat,
17832	OP_FlipFixedPointSint8,
17833	OP_FlipFixedPointUint8,
17834	OP_FlipFixedPointSint16,
17835	OP_FlipFixedPointUint16,
17836	OP_FlipFixedPointSint32,
17837	OP_FlipFixedPointUint32,
17838	OP_FlipFixedPointSint64,
17839	OP_FlipFixedPointUint64,
17840	OP_FlipFixedPointIntAP,
17841	OP_FlipFixedPointIntAPS,
17842	OP_FlipFixedPointBool,
17843	OP_FlipFixedPointFixedPoint,
17844	OP_FlipFixedPointPtr,
17845	OP_FlipFixedPointMemberPtr,
17846	OP_FlipFixedPointFloat,
17847	OP_FlipPtrSint8,
17848	OP_FlipPtrUint8,
17849	OP_FlipPtrSint16,
17850	OP_FlipPtrUint16,
17851	OP_FlipPtrSint32,
17852	OP_FlipPtrUint32,
17853	OP_FlipPtrSint64,
17854	OP_FlipPtrUint64,
17855	OP_FlipPtrIntAP,
17856	OP_FlipPtrIntAPS,
17857	OP_FlipPtrBool,
17858	OP_FlipPtrFixedPoint,
17859	OP_FlipPtrPtr,
17860	OP_FlipPtrMemberPtr,
17861	OP_FlipPtrFloat,
17862	OP_FlipMemberPtrSint8,
17863	OP_FlipMemberPtrUint8,
17864	OP_FlipMemberPtrSint16,
17865	OP_FlipMemberPtrUint16,
17866	OP_FlipMemberPtrSint32,
17867	OP_FlipMemberPtrUint32,
17868	OP_FlipMemberPtrSint64,
17869	OP_FlipMemberPtrUint64,
17870	OP_FlipMemberPtrIntAP,
17871	OP_FlipMemberPtrIntAPS,
17872	OP_FlipMemberPtrBool,
17873	OP_FlipMemberPtrFixedPoint,
17874	OP_FlipMemberPtrPtr,
17875	OP_FlipMemberPtrMemberPtr,
17876	OP_FlipMemberPtrFloat,
17877	OP_FlipFloatSint8,
17878	OP_FlipFloatUint8,
17879	OP_FlipFloatSint16,
17880	OP_FlipFloatUint16,
17881	OP_FlipFloatSint32,
17882	OP_FlipFloatUint32,
17883	OP_FlipFloatSint64,
17884	OP_FlipFloatUint64,
17885	OP_FlipFloatIntAP,
17886	OP_FlipFloatIntAPS,
17887	OP_FlipFloatBool,
17888	OP_FlipFloatFixedPoint,
17889	OP_FlipFloatPtr,
17890	OP_FlipFloatMemberPtr,
17891	OP_FlipFloatFloat,
17892	#endif
17893	#ifdef GET_INTERPFN_LIST
17894	&Interp_FlipSint8Sint8,
17895	&Interp_FlipSint8Uint8,
17896	&Interp_FlipSint8Sint16,
17897	&Interp_FlipSint8Uint16,
17898	&Interp_FlipSint8Sint32,
17899	&Interp_FlipSint8Uint32,
17900	&Interp_FlipSint8Sint64,
17901	&Interp_FlipSint8Uint64,
17902	&Interp_FlipSint8IntAP,
17903	&Interp_FlipSint8IntAPS,
17904	&Interp_FlipSint8Bool,
17905	&Interp_FlipSint8FixedPoint,
17906	&Interp_FlipSint8Ptr,
17907	&Interp_FlipSint8MemberPtr,
17908	&Interp_FlipSint8Float,
17909	&Interp_FlipUint8Sint8,
17910	&Interp_FlipUint8Uint8,
17911	&Interp_FlipUint8Sint16,
17912	&Interp_FlipUint8Uint16,
17913	&Interp_FlipUint8Sint32,
17914	&Interp_FlipUint8Uint32,
17915	&Interp_FlipUint8Sint64,
17916	&Interp_FlipUint8Uint64,
17917	&Interp_FlipUint8IntAP,
17918	&Interp_FlipUint8IntAPS,
17919	&Interp_FlipUint8Bool,
17920	&Interp_FlipUint8FixedPoint,
17921	&Interp_FlipUint8Ptr,
17922	&Interp_FlipUint8MemberPtr,
17923	&Interp_FlipUint8Float,
17924	&Interp_FlipSint16Sint8,
17925	&Interp_FlipSint16Uint8,
17926	&Interp_FlipSint16Sint16,
17927	&Interp_FlipSint16Uint16,
17928	&Interp_FlipSint16Sint32,
17929	&Interp_FlipSint16Uint32,
17930	&Interp_FlipSint16Sint64,
17931	&Interp_FlipSint16Uint64,
17932	&Interp_FlipSint16IntAP,
17933	&Interp_FlipSint16IntAPS,
17934	&Interp_FlipSint16Bool,
17935	&Interp_FlipSint16FixedPoint,
17936	&Interp_FlipSint16Ptr,
17937	&Interp_FlipSint16MemberPtr,
17938	&Interp_FlipSint16Float,
17939	&Interp_FlipUint16Sint8,
17940	&Interp_FlipUint16Uint8,
17941	&Interp_FlipUint16Sint16,
17942	&Interp_FlipUint16Uint16,
17943	&Interp_FlipUint16Sint32,
17944	&Interp_FlipUint16Uint32,
17945	&Interp_FlipUint16Sint64,
17946	&Interp_FlipUint16Uint64,
17947	&Interp_FlipUint16IntAP,
17948	&Interp_FlipUint16IntAPS,
17949	&Interp_FlipUint16Bool,
17950	&Interp_FlipUint16FixedPoint,
17951	&Interp_FlipUint16Ptr,
17952	&Interp_FlipUint16MemberPtr,
17953	&Interp_FlipUint16Float,
17954	&Interp_FlipSint32Sint8,
17955	&Interp_FlipSint32Uint8,
17956	&Interp_FlipSint32Sint16,
17957	&Interp_FlipSint32Uint16,
17958	&Interp_FlipSint32Sint32,
17959	&Interp_FlipSint32Uint32,
17960	&Interp_FlipSint32Sint64,
17961	&Interp_FlipSint32Uint64,
17962	&Interp_FlipSint32IntAP,
17963	&Interp_FlipSint32IntAPS,
17964	&Interp_FlipSint32Bool,
17965	&Interp_FlipSint32FixedPoint,
17966	&Interp_FlipSint32Ptr,
17967	&Interp_FlipSint32MemberPtr,
17968	&Interp_FlipSint32Float,
17969	&Interp_FlipUint32Sint8,
17970	&Interp_FlipUint32Uint8,
17971	&Interp_FlipUint32Sint16,
17972	&Interp_FlipUint32Uint16,
17973	&Interp_FlipUint32Sint32,
17974	&Interp_FlipUint32Uint32,
17975	&Interp_FlipUint32Sint64,
17976	&Interp_FlipUint32Uint64,
17977	&Interp_FlipUint32IntAP,
17978	&Interp_FlipUint32IntAPS,
17979	&Interp_FlipUint32Bool,
17980	&Interp_FlipUint32FixedPoint,
17981	&Interp_FlipUint32Ptr,
17982	&Interp_FlipUint32MemberPtr,
17983	&Interp_FlipUint32Float,
17984	&Interp_FlipSint64Sint8,
17985	&Interp_FlipSint64Uint8,
17986	&Interp_FlipSint64Sint16,
17987	&Interp_FlipSint64Uint16,
17988	&Interp_FlipSint64Sint32,
17989	&Interp_FlipSint64Uint32,
17990	&Interp_FlipSint64Sint64,
17991	&Interp_FlipSint64Uint64,
17992	&Interp_FlipSint64IntAP,
17993	&Interp_FlipSint64IntAPS,
17994	&Interp_FlipSint64Bool,
17995	&Interp_FlipSint64FixedPoint,
17996	&Interp_FlipSint64Ptr,
17997	&Interp_FlipSint64MemberPtr,
17998	&Interp_FlipSint64Float,
17999	&Interp_FlipUint64Sint8,
18000	&Interp_FlipUint64Uint8,
18001	&Interp_FlipUint64Sint16,
18002	&Interp_FlipUint64Uint16,
18003	&Interp_FlipUint64Sint32,
18004	&Interp_FlipUint64Uint32,
18005	&Interp_FlipUint64Sint64,
18006	&Interp_FlipUint64Uint64,
18007	&Interp_FlipUint64IntAP,
18008	&Interp_FlipUint64IntAPS,
18009	&Interp_FlipUint64Bool,
18010	&Interp_FlipUint64FixedPoint,
18011	&Interp_FlipUint64Ptr,
18012	&Interp_FlipUint64MemberPtr,
18013	&Interp_FlipUint64Float,
18014	&Interp_FlipIntAPSint8,
18015	&Interp_FlipIntAPUint8,
18016	&Interp_FlipIntAPSint16,
18017	&Interp_FlipIntAPUint16,
18018	&Interp_FlipIntAPSint32,
18019	&Interp_FlipIntAPUint32,
18020	&Interp_FlipIntAPSint64,
18021	&Interp_FlipIntAPUint64,
18022	&Interp_FlipIntAPIntAP,
18023	&Interp_FlipIntAPIntAPS,
18024	&Interp_FlipIntAPBool,
18025	&Interp_FlipIntAPFixedPoint,
18026	&Interp_FlipIntAPPtr,
18027	&Interp_FlipIntAPMemberPtr,
18028	&Interp_FlipIntAPFloat,
18029	&Interp_FlipIntAPSSint8,
18030	&Interp_FlipIntAPSUint8,
18031	&Interp_FlipIntAPSSint16,
18032	&Interp_FlipIntAPSUint16,
18033	&Interp_FlipIntAPSSint32,
18034	&Interp_FlipIntAPSUint32,
18035	&Interp_FlipIntAPSSint64,
18036	&Interp_FlipIntAPSUint64,
18037	&Interp_FlipIntAPSIntAP,
18038	&Interp_FlipIntAPSIntAPS,
18039	&Interp_FlipIntAPSBool,
18040	&Interp_FlipIntAPSFixedPoint,
18041	&Interp_FlipIntAPSPtr,
18042	&Interp_FlipIntAPSMemberPtr,
18043	&Interp_FlipIntAPSFloat,
18044	&Interp_FlipBoolSint8,
18045	&Interp_FlipBoolUint8,
18046	&Interp_FlipBoolSint16,
18047	&Interp_FlipBoolUint16,
18048	&Interp_FlipBoolSint32,
18049	&Interp_FlipBoolUint32,
18050	&Interp_FlipBoolSint64,
18051	&Interp_FlipBoolUint64,
18052	&Interp_FlipBoolIntAP,
18053	&Interp_FlipBoolIntAPS,
18054	&Interp_FlipBoolBool,
18055	&Interp_FlipBoolFixedPoint,
18056	&Interp_FlipBoolPtr,
18057	&Interp_FlipBoolMemberPtr,
18058	&Interp_FlipBoolFloat,
18059	&Interp_FlipFixedPointSint8,
18060	&Interp_FlipFixedPointUint8,
18061	&Interp_FlipFixedPointSint16,
18062	&Interp_FlipFixedPointUint16,
18063	&Interp_FlipFixedPointSint32,
18064	&Interp_FlipFixedPointUint32,
18065	&Interp_FlipFixedPointSint64,
18066	&Interp_FlipFixedPointUint64,
18067	&Interp_FlipFixedPointIntAP,
18068	&Interp_FlipFixedPointIntAPS,
18069	&Interp_FlipFixedPointBool,
18070	&Interp_FlipFixedPointFixedPoint,
18071	&Interp_FlipFixedPointPtr,
18072	&Interp_FlipFixedPointMemberPtr,
18073	&Interp_FlipFixedPointFloat,
18074	&Interp_FlipPtrSint8,
18075	&Interp_FlipPtrUint8,
18076	&Interp_FlipPtrSint16,
18077	&Interp_FlipPtrUint16,
18078	&Interp_FlipPtrSint32,
18079	&Interp_FlipPtrUint32,
18080	&Interp_FlipPtrSint64,
18081	&Interp_FlipPtrUint64,
18082	&Interp_FlipPtrIntAP,
18083	&Interp_FlipPtrIntAPS,
18084	&Interp_FlipPtrBool,
18085	&Interp_FlipPtrFixedPoint,
18086	&Interp_FlipPtrPtr,
18087	&Interp_FlipPtrMemberPtr,
18088	&Interp_FlipPtrFloat,
18089	&Interp_FlipMemberPtrSint8,
18090	&Interp_FlipMemberPtrUint8,
18091	&Interp_FlipMemberPtrSint16,
18092	&Interp_FlipMemberPtrUint16,
18093	&Interp_FlipMemberPtrSint32,
18094	&Interp_FlipMemberPtrUint32,
18095	&Interp_FlipMemberPtrSint64,
18096	&Interp_FlipMemberPtrUint64,
18097	&Interp_FlipMemberPtrIntAP,
18098	&Interp_FlipMemberPtrIntAPS,
18099	&Interp_FlipMemberPtrBool,
18100	&Interp_FlipMemberPtrFixedPoint,
18101	&Interp_FlipMemberPtrPtr,
18102	&Interp_FlipMemberPtrMemberPtr,
18103	&Interp_FlipMemberPtrFloat,
18104	&Interp_FlipFloatSint8,
18105	&Interp_FlipFloatUint8,
18106	&Interp_FlipFloatSint16,
18107	&Interp_FlipFloatUint16,
18108	&Interp_FlipFloatSint32,
18109	&Interp_FlipFloatUint32,
18110	&Interp_FlipFloatSint64,
18111	&Interp_FlipFloatUint64,
18112	&Interp_FlipFloatIntAP,
18113	&Interp_FlipFloatIntAPS,
18114	&Interp_FlipFloatBool,
18115	&Interp_FlipFloatFixedPoint,
18116	&Interp_FlipFloatPtr,
18117	&Interp_FlipFloatMemberPtr,
18118	&Interp_FlipFloatFloat,
18119	#endif
18120	#ifdef GET_INTERPFN_DISPATCHERS
18121	PRESERVE_NONE
18122	static bool Interp_FlipSint8Sint8(InterpState &S) {
18123	Flip<PT_Sint8, PT_Sint8>(S);
18124	#if USE_TAILCALLS
18125	MUSTTAIL return InterpNext(S);
18126	#else
18127	return true;
18128	#endif
18129	}
18130	PRESERVE_NONE
18131	static bool Interp_FlipSint8Uint8(InterpState &S) {
18132	Flip<PT_Sint8, PT_Uint8>(S);
18133	#if USE_TAILCALLS
18134	MUSTTAIL return InterpNext(S);
18135	#else
18136	return true;
18137	#endif
18138	}
18139	PRESERVE_NONE
18140	static bool Interp_FlipSint8Sint16(InterpState &S) {
18141	Flip<PT_Sint8, PT_Sint16>(S);
18142	#if USE_TAILCALLS
18143	MUSTTAIL return InterpNext(S);
18144	#else
18145	return true;
18146	#endif
18147	}
18148	PRESERVE_NONE
18149	static bool Interp_FlipSint8Uint16(InterpState &S) {
18150	Flip<PT_Sint8, PT_Uint16>(S);
18151	#if USE_TAILCALLS
18152	MUSTTAIL return InterpNext(S);
18153	#else
18154	return true;
18155	#endif
18156	}
18157	PRESERVE_NONE
18158	static bool Interp_FlipSint8Sint32(InterpState &S) {
18159	Flip<PT_Sint8, PT_Sint32>(S);
18160	#if USE_TAILCALLS
18161	MUSTTAIL return InterpNext(S);
18162	#else
18163	return true;
18164	#endif
18165	}
18166	PRESERVE_NONE
18167	static bool Interp_FlipSint8Uint32(InterpState &S) {
18168	Flip<PT_Sint8, PT_Uint32>(S);
18169	#if USE_TAILCALLS
18170	MUSTTAIL return InterpNext(S);
18171	#else
18172	return true;
18173	#endif
18174	}
18175	PRESERVE_NONE
18176	static bool Interp_FlipSint8Sint64(InterpState &S) {
18177	Flip<PT_Sint8, PT_Sint64>(S);
18178	#if USE_TAILCALLS
18179	MUSTTAIL return InterpNext(S);
18180	#else
18181	return true;
18182	#endif
18183	}
18184	PRESERVE_NONE
18185	static bool Interp_FlipSint8Uint64(InterpState &S) {
18186	Flip<PT_Sint8, PT_Uint64>(S);
18187	#if USE_TAILCALLS
18188	MUSTTAIL return InterpNext(S);
18189	#else
18190	return true;
18191	#endif
18192	}
18193	PRESERVE_NONE
18194	static bool Interp_FlipSint8IntAP(InterpState &S) {
18195	Flip<PT_Sint8, PT_IntAP>(S);
18196	#if USE_TAILCALLS
18197	MUSTTAIL return InterpNext(S);
18198	#else
18199	return true;
18200	#endif
18201	}
18202	PRESERVE_NONE
18203	static bool Interp_FlipSint8IntAPS(InterpState &S) {
18204	Flip<PT_Sint8, PT_IntAPS>(S);
18205	#if USE_TAILCALLS
18206	MUSTTAIL return InterpNext(S);
18207	#else
18208	return true;
18209	#endif
18210	}
18211	PRESERVE_NONE
18212	static bool Interp_FlipSint8Bool(InterpState &S) {
18213	Flip<PT_Sint8, PT_Bool>(S);
18214	#if USE_TAILCALLS
18215	MUSTTAIL return InterpNext(S);
18216	#else
18217	return true;
18218	#endif
18219	}
18220	PRESERVE_NONE
18221	static bool Interp_FlipSint8FixedPoint(InterpState &S) {
18222	Flip<PT_Sint8, PT_FixedPoint>(S);
18223	#if USE_TAILCALLS
18224	MUSTTAIL return InterpNext(S);
18225	#else
18226	return true;
18227	#endif
18228	}
18229	PRESERVE_NONE
18230	static bool Interp_FlipSint8Ptr(InterpState &S) {
18231	Flip<PT_Sint8, PT_Ptr>(S);
18232	#if USE_TAILCALLS
18233	MUSTTAIL return InterpNext(S);
18234	#else
18235	return true;
18236	#endif
18237	}
18238	PRESERVE_NONE
18239	static bool Interp_FlipSint8MemberPtr(InterpState &S) {
18240	Flip<PT_Sint8, PT_MemberPtr>(S);
18241	#if USE_TAILCALLS
18242	MUSTTAIL return InterpNext(S);
18243	#else
18244	return true;
18245	#endif
18246	}
18247	PRESERVE_NONE
18248	static bool Interp_FlipSint8Float(InterpState &S) {
18249	Flip<PT_Sint8, PT_Float>(S);
18250	#if USE_TAILCALLS
18251	MUSTTAIL return InterpNext(S);
18252	#else
18253	return true;
18254	#endif
18255	}
18256	PRESERVE_NONE
18257	static bool Interp_FlipUint8Sint8(InterpState &S) {
18258	Flip<PT_Uint8, PT_Sint8>(S);
18259	#if USE_TAILCALLS
18260	MUSTTAIL return InterpNext(S);
18261	#else
18262	return true;
18263	#endif
18264	}
18265	PRESERVE_NONE
18266	static bool Interp_FlipUint8Uint8(InterpState &S) {
18267	Flip<PT_Uint8, PT_Uint8>(S);
18268	#if USE_TAILCALLS
18269	MUSTTAIL return InterpNext(S);
18270	#else
18271	return true;
18272	#endif
18273	}
18274	PRESERVE_NONE
18275	static bool Interp_FlipUint8Sint16(InterpState &S) {
18276	Flip<PT_Uint8, PT_Sint16>(S);
18277	#if USE_TAILCALLS
18278	MUSTTAIL return InterpNext(S);
18279	#else
18280	return true;
18281	#endif
18282	}
18283	PRESERVE_NONE
18284	static bool Interp_FlipUint8Uint16(InterpState &S) {
18285	Flip<PT_Uint8, PT_Uint16>(S);
18286	#if USE_TAILCALLS
18287	MUSTTAIL return InterpNext(S);
18288	#else
18289	return true;
18290	#endif
18291	}
18292	PRESERVE_NONE
18293	static bool Interp_FlipUint8Sint32(InterpState &S) {
18294	Flip<PT_Uint8, PT_Sint32>(S);
18295	#if USE_TAILCALLS
18296	MUSTTAIL return InterpNext(S);
18297	#else
18298	return true;
18299	#endif
18300	}
18301	PRESERVE_NONE
18302	static bool Interp_FlipUint8Uint32(InterpState &S) {
18303	Flip<PT_Uint8, PT_Uint32>(S);
18304	#if USE_TAILCALLS
18305	MUSTTAIL return InterpNext(S);
18306	#else
18307	return true;
18308	#endif
18309	}
18310	PRESERVE_NONE
18311	static bool Interp_FlipUint8Sint64(InterpState &S) {
18312	Flip<PT_Uint8, PT_Sint64>(S);
18313	#if USE_TAILCALLS
18314	MUSTTAIL return InterpNext(S);
18315	#else
18316	return true;
18317	#endif
18318	}
18319	PRESERVE_NONE
18320	static bool Interp_FlipUint8Uint64(InterpState &S) {
18321	Flip<PT_Uint8, PT_Uint64>(S);
18322	#if USE_TAILCALLS
18323	MUSTTAIL return InterpNext(S);
18324	#else
18325	return true;
18326	#endif
18327	}
18328	PRESERVE_NONE
18329	static bool Interp_FlipUint8IntAP(InterpState &S) {
18330	Flip<PT_Uint8, PT_IntAP>(S);
18331	#if USE_TAILCALLS
18332	MUSTTAIL return InterpNext(S);
18333	#else
18334	return true;
18335	#endif
18336	}
18337	PRESERVE_NONE
18338	static bool Interp_FlipUint8IntAPS(InterpState &S) {
18339	Flip<PT_Uint8, PT_IntAPS>(S);
18340	#if USE_TAILCALLS
18341	MUSTTAIL return InterpNext(S);
18342	#else
18343	return true;
18344	#endif
18345	}
18346	PRESERVE_NONE
18347	static bool Interp_FlipUint8Bool(InterpState &S) {
18348	Flip<PT_Uint8, PT_Bool>(S);
18349	#if USE_TAILCALLS
18350	MUSTTAIL return InterpNext(S);
18351	#else
18352	return true;
18353	#endif
18354	}
18355	PRESERVE_NONE
18356	static bool Interp_FlipUint8FixedPoint(InterpState &S) {
18357	Flip<PT_Uint8, PT_FixedPoint>(S);
18358	#if USE_TAILCALLS
18359	MUSTTAIL return InterpNext(S);
18360	#else
18361	return true;
18362	#endif
18363	}
18364	PRESERVE_NONE
18365	static bool Interp_FlipUint8Ptr(InterpState &S) {
18366	Flip<PT_Uint8, PT_Ptr>(S);
18367	#if USE_TAILCALLS
18368	MUSTTAIL return InterpNext(S);
18369	#else
18370	return true;
18371	#endif
18372	}
18373	PRESERVE_NONE
18374	static bool Interp_FlipUint8MemberPtr(InterpState &S) {
18375	Flip<PT_Uint8, PT_MemberPtr>(S);
18376	#if USE_TAILCALLS
18377	MUSTTAIL return InterpNext(S);
18378	#else
18379	return true;
18380	#endif
18381	}
18382	PRESERVE_NONE
18383	static bool Interp_FlipUint8Float(InterpState &S) {
18384	Flip<PT_Uint8, PT_Float>(S);
18385	#if USE_TAILCALLS
18386	MUSTTAIL return InterpNext(S);
18387	#else
18388	return true;
18389	#endif
18390	}
18391	PRESERVE_NONE
18392	static bool Interp_FlipSint16Sint8(InterpState &S) {
18393	Flip<PT_Sint16, PT_Sint8>(S);
18394	#if USE_TAILCALLS
18395	MUSTTAIL return InterpNext(S);
18396	#else
18397	return true;
18398	#endif
18399	}
18400	PRESERVE_NONE
18401	static bool Interp_FlipSint16Uint8(InterpState &S) {
18402	Flip<PT_Sint16, PT_Uint8>(S);
18403	#if USE_TAILCALLS
18404	MUSTTAIL return InterpNext(S);
18405	#else
18406	return true;
18407	#endif
18408	}
18409	PRESERVE_NONE
18410	static bool Interp_FlipSint16Sint16(InterpState &S) {
18411	Flip<PT_Sint16, PT_Sint16>(S);
18412	#if USE_TAILCALLS
18413	MUSTTAIL return InterpNext(S);
18414	#else
18415	return true;
18416	#endif
18417	}
18418	PRESERVE_NONE
18419	static bool Interp_FlipSint16Uint16(InterpState &S) {
18420	Flip<PT_Sint16, PT_Uint16>(S);
18421	#if USE_TAILCALLS
18422	MUSTTAIL return InterpNext(S);
18423	#else
18424	return true;
18425	#endif
18426	}
18427	PRESERVE_NONE
18428	static bool Interp_FlipSint16Sint32(InterpState &S) {
18429	Flip<PT_Sint16, PT_Sint32>(S);
18430	#if USE_TAILCALLS
18431	MUSTTAIL return InterpNext(S);
18432	#else
18433	return true;
18434	#endif
18435	}
18436	PRESERVE_NONE
18437	static bool Interp_FlipSint16Uint32(InterpState &S) {
18438	Flip<PT_Sint16, PT_Uint32>(S);
18439	#if USE_TAILCALLS
18440	MUSTTAIL return InterpNext(S);
18441	#else
18442	return true;
18443	#endif
18444	}
18445	PRESERVE_NONE
18446	static bool Interp_FlipSint16Sint64(InterpState &S) {
18447	Flip<PT_Sint16, PT_Sint64>(S);
18448	#if USE_TAILCALLS
18449	MUSTTAIL return InterpNext(S);
18450	#else
18451	return true;
18452	#endif
18453	}
18454	PRESERVE_NONE
18455	static bool Interp_FlipSint16Uint64(InterpState &S) {
18456	Flip<PT_Sint16, PT_Uint64>(S);
18457	#if USE_TAILCALLS
18458	MUSTTAIL return InterpNext(S);
18459	#else
18460	return true;
18461	#endif
18462	}
18463	PRESERVE_NONE
18464	static bool Interp_FlipSint16IntAP(InterpState &S) {
18465	Flip<PT_Sint16, PT_IntAP>(S);
18466	#if USE_TAILCALLS
18467	MUSTTAIL return InterpNext(S);
18468	#else
18469	return true;
18470	#endif
18471	}
18472	PRESERVE_NONE
18473	static bool Interp_FlipSint16IntAPS(InterpState &S) {
18474	Flip<PT_Sint16, PT_IntAPS>(S);
18475	#if USE_TAILCALLS
18476	MUSTTAIL return InterpNext(S);
18477	#else
18478	return true;
18479	#endif
18480	}
18481	PRESERVE_NONE
18482	static bool Interp_FlipSint16Bool(InterpState &S) {
18483	Flip<PT_Sint16, PT_Bool>(S);
18484	#if USE_TAILCALLS
18485	MUSTTAIL return InterpNext(S);
18486	#else
18487	return true;
18488	#endif
18489	}
18490	PRESERVE_NONE
18491	static bool Interp_FlipSint16FixedPoint(InterpState &S) {
18492	Flip<PT_Sint16, PT_FixedPoint>(S);
18493	#if USE_TAILCALLS
18494	MUSTTAIL return InterpNext(S);
18495	#else
18496	return true;
18497	#endif
18498	}
18499	PRESERVE_NONE
18500	static bool Interp_FlipSint16Ptr(InterpState &S) {
18501	Flip<PT_Sint16, PT_Ptr>(S);
18502	#if USE_TAILCALLS
18503	MUSTTAIL return InterpNext(S);
18504	#else
18505	return true;
18506	#endif
18507	}
18508	PRESERVE_NONE
18509	static bool Interp_FlipSint16MemberPtr(InterpState &S) {
18510	Flip<PT_Sint16, PT_MemberPtr>(S);
18511	#if USE_TAILCALLS
18512	MUSTTAIL return InterpNext(S);
18513	#else
18514	return true;
18515	#endif
18516	}
18517	PRESERVE_NONE
18518	static bool Interp_FlipSint16Float(InterpState &S) {
18519	Flip<PT_Sint16, PT_Float>(S);
18520	#if USE_TAILCALLS
18521	MUSTTAIL return InterpNext(S);
18522	#else
18523	return true;
18524	#endif
18525	}
18526	PRESERVE_NONE
18527	static bool Interp_FlipUint16Sint8(InterpState &S) {
18528	Flip<PT_Uint16, PT_Sint8>(S);
18529	#if USE_TAILCALLS
18530	MUSTTAIL return InterpNext(S);
18531	#else
18532	return true;
18533	#endif
18534	}
18535	PRESERVE_NONE
18536	static bool Interp_FlipUint16Uint8(InterpState &S) {
18537	Flip<PT_Uint16, PT_Uint8>(S);
18538	#if USE_TAILCALLS
18539	MUSTTAIL return InterpNext(S);
18540	#else
18541	return true;
18542	#endif
18543	}
18544	PRESERVE_NONE
18545	static bool Interp_FlipUint16Sint16(InterpState &S) {
18546	Flip<PT_Uint16, PT_Sint16>(S);
18547	#if USE_TAILCALLS
18548	MUSTTAIL return InterpNext(S);
18549	#else
18550	return true;
18551	#endif
18552	}
18553	PRESERVE_NONE
18554	static bool Interp_FlipUint16Uint16(InterpState &S) {
18555	Flip<PT_Uint16, PT_Uint16>(S);
18556	#if USE_TAILCALLS
18557	MUSTTAIL return InterpNext(S);
18558	#else
18559	return true;
18560	#endif
18561	}
18562	PRESERVE_NONE
18563	static bool Interp_FlipUint16Sint32(InterpState &S) {
18564	Flip<PT_Uint16, PT_Sint32>(S);
18565	#if USE_TAILCALLS
18566	MUSTTAIL return InterpNext(S);
18567	#else
18568	return true;
18569	#endif
18570	}
18571	PRESERVE_NONE
18572	static bool Interp_FlipUint16Uint32(InterpState &S) {
18573	Flip<PT_Uint16, PT_Uint32>(S);
18574	#if USE_TAILCALLS
18575	MUSTTAIL return InterpNext(S);
18576	#else
18577	return true;
18578	#endif
18579	}
18580	PRESERVE_NONE
18581	static bool Interp_FlipUint16Sint64(InterpState &S) {
18582	Flip<PT_Uint16, PT_Sint64>(S);
18583	#if USE_TAILCALLS
18584	MUSTTAIL return InterpNext(S);
18585	#else
18586	return true;
18587	#endif
18588	}
18589	PRESERVE_NONE
18590	static bool Interp_FlipUint16Uint64(InterpState &S) {
18591	Flip<PT_Uint16, PT_Uint64>(S);
18592	#if USE_TAILCALLS
18593	MUSTTAIL return InterpNext(S);
18594	#else
18595	return true;
18596	#endif
18597	}
18598	PRESERVE_NONE
18599	static bool Interp_FlipUint16IntAP(InterpState &S) {
18600	Flip<PT_Uint16, PT_IntAP>(S);
18601	#if USE_TAILCALLS
18602	MUSTTAIL return InterpNext(S);
18603	#else
18604	return true;
18605	#endif
18606	}
18607	PRESERVE_NONE
18608	static bool Interp_FlipUint16IntAPS(InterpState &S) {
18609	Flip<PT_Uint16, PT_IntAPS>(S);
18610	#if USE_TAILCALLS
18611	MUSTTAIL return InterpNext(S);
18612	#else
18613	return true;
18614	#endif
18615	}
18616	PRESERVE_NONE
18617	static bool Interp_FlipUint16Bool(InterpState &S) {
18618	Flip<PT_Uint16, PT_Bool>(S);
18619	#if USE_TAILCALLS
18620	MUSTTAIL return InterpNext(S);
18621	#else
18622	return true;
18623	#endif
18624	}
18625	PRESERVE_NONE
18626	static bool Interp_FlipUint16FixedPoint(InterpState &S) {
18627	Flip<PT_Uint16, PT_FixedPoint>(S);
18628	#if USE_TAILCALLS
18629	MUSTTAIL return InterpNext(S);
18630	#else
18631	return true;
18632	#endif
18633	}
18634	PRESERVE_NONE
18635	static bool Interp_FlipUint16Ptr(InterpState &S) {
18636	Flip<PT_Uint16, PT_Ptr>(S);
18637	#if USE_TAILCALLS
18638	MUSTTAIL return InterpNext(S);
18639	#else
18640	return true;
18641	#endif
18642	}
18643	PRESERVE_NONE
18644	static bool Interp_FlipUint16MemberPtr(InterpState &S) {
18645	Flip<PT_Uint16, PT_MemberPtr>(S);
18646	#if USE_TAILCALLS
18647	MUSTTAIL return InterpNext(S);
18648	#else
18649	return true;
18650	#endif
18651	}
18652	PRESERVE_NONE
18653	static bool Interp_FlipUint16Float(InterpState &S) {
18654	Flip<PT_Uint16, PT_Float>(S);
18655	#if USE_TAILCALLS
18656	MUSTTAIL return InterpNext(S);
18657	#else
18658	return true;
18659	#endif
18660	}
18661	PRESERVE_NONE
18662	static bool Interp_FlipSint32Sint8(InterpState &S) {
18663	Flip<PT_Sint32, PT_Sint8>(S);
18664	#if USE_TAILCALLS
18665	MUSTTAIL return InterpNext(S);
18666	#else
18667	return true;
18668	#endif
18669	}
18670	PRESERVE_NONE
18671	static bool Interp_FlipSint32Uint8(InterpState &S) {
18672	Flip<PT_Sint32, PT_Uint8>(S);
18673	#if USE_TAILCALLS
18674	MUSTTAIL return InterpNext(S);
18675	#else
18676	return true;
18677	#endif
18678	}
18679	PRESERVE_NONE
18680	static bool Interp_FlipSint32Sint16(InterpState &S) {
18681	Flip<PT_Sint32, PT_Sint16>(S);
18682	#if USE_TAILCALLS
18683	MUSTTAIL return InterpNext(S);
18684	#else
18685	return true;
18686	#endif
18687	}
18688	PRESERVE_NONE
18689	static bool Interp_FlipSint32Uint16(InterpState &S) {
18690	Flip<PT_Sint32, PT_Uint16>(S);
18691	#if USE_TAILCALLS
18692	MUSTTAIL return InterpNext(S);
18693	#else
18694	return true;
18695	#endif
18696	}
18697	PRESERVE_NONE
18698	static bool Interp_FlipSint32Sint32(InterpState &S) {
18699	Flip<PT_Sint32, PT_Sint32>(S);
18700	#if USE_TAILCALLS
18701	MUSTTAIL return InterpNext(S);
18702	#else
18703	return true;
18704	#endif
18705	}
18706	PRESERVE_NONE
18707	static bool Interp_FlipSint32Uint32(InterpState &S) {
18708	Flip<PT_Sint32, PT_Uint32>(S);
18709	#if USE_TAILCALLS
18710	MUSTTAIL return InterpNext(S);
18711	#else
18712	return true;
18713	#endif
18714	}
18715	PRESERVE_NONE
18716	static bool Interp_FlipSint32Sint64(InterpState &S) {
18717	Flip<PT_Sint32, PT_Sint64>(S);
18718	#if USE_TAILCALLS
18719	MUSTTAIL return InterpNext(S);
18720	#else
18721	return true;
18722	#endif
18723	}
18724	PRESERVE_NONE
18725	static bool Interp_FlipSint32Uint64(InterpState &S) {
18726	Flip<PT_Sint32, PT_Uint64>(S);
18727	#if USE_TAILCALLS
18728	MUSTTAIL return InterpNext(S);
18729	#else
18730	return true;
18731	#endif
18732	}
18733	PRESERVE_NONE
18734	static bool Interp_FlipSint32IntAP(InterpState &S) {
18735	Flip<PT_Sint32, PT_IntAP>(S);
18736	#if USE_TAILCALLS
18737	MUSTTAIL return InterpNext(S);
18738	#else
18739	return true;
18740	#endif
18741	}
18742	PRESERVE_NONE
18743	static bool Interp_FlipSint32IntAPS(InterpState &S) {
18744	Flip<PT_Sint32, PT_IntAPS>(S);
18745	#if USE_TAILCALLS
18746	MUSTTAIL return InterpNext(S);
18747	#else
18748	return true;
18749	#endif
18750	}
18751	PRESERVE_NONE
18752	static bool Interp_FlipSint32Bool(InterpState &S) {
18753	Flip<PT_Sint32, PT_Bool>(S);
18754	#if USE_TAILCALLS
18755	MUSTTAIL return InterpNext(S);
18756	#else
18757	return true;
18758	#endif
18759	}
18760	PRESERVE_NONE
18761	static bool Interp_FlipSint32FixedPoint(InterpState &S) {
18762	Flip<PT_Sint32, PT_FixedPoint>(S);
18763	#if USE_TAILCALLS
18764	MUSTTAIL return InterpNext(S);
18765	#else
18766	return true;
18767	#endif
18768	}
18769	PRESERVE_NONE
18770	static bool Interp_FlipSint32Ptr(InterpState &S) {
18771	Flip<PT_Sint32, PT_Ptr>(S);
18772	#if USE_TAILCALLS
18773	MUSTTAIL return InterpNext(S);
18774	#else
18775	return true;
18776	#endif
18777	}
18778	PRESERVE_NONE
18779	static bool Interp_FlipSint32MemberPtr(InterpState &S) {
18780	Flip<PT_Sint32, PT_MemberPtr>(S);
18781	#if USE_TAILCALLS
18782	MUSTTAIL return InterpNext(S);
18783	#else
18784	return true;
18785	#endif
18786	}
18787	PRESERVE_NONE
18788	static bool Interp_FlipSint32Float(InterpState &S) {
18789	Flip<PT_Sint32, PT_Float>(S);
18790	#if USE_TAILCALLS
18791	MUSTTAIL return InterpNext(S);
18792	#else
18793	return true;
18794	#endif
18795	}
18796	PRESERVE_NONE
18797	static bool Interp_FlipUint32Sint8(InterpState &S) {
18798	Flip<PT_Uint32, PT_Sint8>(S);
18799	#if USE_TAILCALLS
18800	MUSTTAIL return InterpNext(S);
18801	#else
18802	return true;
18803	#endif
18804	}
18805	PRESERVE_NONE
18806	static bool Interp_FlipUint32Uint8(InterpState &S) {
18807	Flip<PT_Uint32, PT_Uint8>(S);
18808	#if USE_TAILCALLS
18809	MUSTTAIL return InterpNext(S);
18810	#else
18811	return true;
18812	#endif
18813	}
18814	PRESERVE_NONE
18815	static bool Interp_FlipUint32Sint16(InterpState &S) {
18816	Flip<PT_Uint32, PT_Sint16>(S);
18817	#if USE_TAILCALLS
18818	MUSTTAIL return InterpNext(S);
18819	#else
18820	return true;
18821	#endif
18822	}
18823	PRESERVE_NONE
18824	static bool Interp_FlipUint32Uint16(InterpState &S) {
18825	Flip<PT_Uint32, PT_Uint16>(S);
18826	#if USE_TAILCALLS
18827	MUSTTAIL return InterpNext(S);
18828	#else
18829	return true;
18830	#endif
18831	}
18832	PRESERVE_NONE
18833	static bool Interp_FlipUint32Sint32(InterpState &S) {
18834	Flip<PT_Uint32, PT_Sint32>(S);
18835	#if USE_TAILCALLS
18836	MUSTTAIL return InterpNext(S);
18837	#else
18838	return true;
18839	#endif
18840	}
18841	PRESERVE_NONE
18842	static bool Interp_FlipUint32Uint32(InterpState &S) {
18843	Flip<PT_Uint32, PT_Uint32>(S);
18844	#if USE_TAILCALLS
18845	MUSTTAIL return InterpNext(S);
18846	#else
18847	return true;
18848	#endif
18849	}
18850	PRESERVE_NONE
18851	static bool Interp_FlipUint32Sint64(InterpState &S) {
18852	Flip<PT_Uint32, PT_Sint64>(S);
18853	#if USE_TAILCALLS
18854	MUSTTAIL return InterpNext(S);
18855	#else
18856	return true;
18857	#endif
18858	}
18859	PRESERVE_NONE
18860	static bool Interp_FlipUint32Uint64(InterpState &S) {
18861	Flip<PT_Uint32, PT_Uint64>(S);
18862	#if USE_TAILCALLS
18863	MUSTTAIL return InterpNext(S);
18864	#else
18865	return true;
18866	#endif
18867	}
18868	PRESERVE_NONE
18869	static bool Interp_FlipUint32IntAP(InterpState &S) {
18870	Flip<PT_Uint32, PT_IntAP>(S);
18871	#if USE_TAILCALLS
18872	MUSTTAIL return InterpNext(S);
18873	#else
18874	return true;
18875	#endif
18876	}
18877	PRESERVE_NONE
18878	static bool Interp_FlipUint32IntAPS(InterpState &S) {
18879	Flip<PT_Uint32, PT_IntAPS>(S);
18880	#if USE_TAILCALLS
18881	MUSTTAIL return InterpNext(S);
18882	#else
18883	return true;
18884	#endif
18885	}
18886	PRESERVE_NONE
18887	static bool Interp_FlipUint32Bool(InterpState &S) {
18888	Flip<PT_Uint32, PT_Bool>(S);
18889	#if USE_TAILCALLS
18890	MUSTTAIL return InterpNext(S);
18891	#else
18892	return true;
18893	#endif
18894	}
18895	PRESERVE_NONE
18896	static bool Interp_FlipUint32FixedPoint(InterpState &S) {
18897	Flip<PT_Uint32, PT_FixedPoint>(S);
18898	#if USE_TAILCALLS
18899	MUSTTAIL return InterpNext(S);
18900	#else
18901	return true;
18902	#endif
18903	}
18904	PRESERVE_NONE
18905	static bool Interp_FlipUint32Ptr(InterpState &S) {
18906	Flip<PT_Uint32, PT_Ptr>(S);
18907	#if USE_TAILCALLS
18908	MUSTTAIL return InterpNext(S);
18909	#else
18910	return true;
18911	#endif
18912	}
18913	PRESERVE_NONE
18914	static bool Interp_FlipUint32MemberPtr(InterpState &S) {
18915	Flip<PT_Uint32, PT_MemberPtr>(S);
18916	#if USE_TAILCALLS
18917	MUSTTAIL return InterpNext(S);
18918	#else
18919	return true;
18920	#endif
18921	}
18922	PRESERVE_NONE
18923	static bool Interp_FlipUint32Float(InterpState &S) {
18924	Flip<PT_Uint32, PT_Float>(S);
18925	#if USE_TAILCALLS
18926	MUSTTAIL return InterpNext(S);
18927	#else
18928	return true;
18929	#endif
18930	}
18931	PRESERVE_NONE
18932	static bool Interp_FlipSint64Sint8(InterpState &S) {
18933	Flip<PT_Sint64, PT_Sint8>(S);
18934	#if USE_TAILCALLS
18935	MUSTTAIL return InterpNext(S);
18936	#else
18937	return true;
18938	#endif
18939	}
18940	PRESERVE_NONE
18941	static bool Interp_FlipSint64Uint8(InterpState &S) {
18942	Flip<PT_Sint64, PT_Uint8>(S);
18943	#if USE_TAILCALLS
18944	MUSTTAIL return InterpNext(S);
18945	#else
18946	return true;
18947	#endif
18948	}
18949	PRESERVE_NONE
18950	static bool Interp_FlipSint64Sint16(InterpState &S) {
18951	Flip<PT_Sint64, PT_Sint16>(S);
18952	#if USE_TAILCALLS
18953	MUSTTAIL return InterpNext(S);
18954	#else
18955	return true;
18956	#endif
18957	}
18958	PRESERVE_NONE
18959	static bool Interp_FlipSint64Uint16(InterpState &S) {
18960	Flip<PT_Sint64, PT_Uint16>(S);
18961	#if USE_TAILCALLS
18962	MUSTTAIL return InterpNext(S);
18963	#else
18964	return true;
18965	#endif
18966	}
18967	PRESERVE_NONE
18968	static bool Interp_FlipSint64Sint32(InterpState &S) {
18969	Flip<PT_Sint64, PT_Sint32>(S);
18970	#if USE_TAILCALLS
18971	MUSTTAIL return InterpNext(S);
18972	#else
18973	return true;
18974	#endif
18975	}
18976	PRESERVE_NONE
18977	static bool Interp_FlipSint64Uint32(InterpState &S) {
18978	Flip<PT_Sint64, PT_Uint32>(S);
18979	#if USE_TAILCALLS
18980	MUSTTAIL return InterpNext(S);
18981	#else
18982	return true;
18983	#endif
18984	}
18985	PRESERVE_NONE
18986	static bool Interp_FlipSint64Sint64(InterpState &S) {
18987	Flip<PT_Sint64, PT_Sint64>(S);
18988	#if USE_TAILCALLS
18989	MUSTTAIL return InterpNext(S);
18990	#else
18991	return true;
18992	#endif
18993	}
18994	PRESERVE_NONE
18995	static bool Interp_FlipSint64Uint64(InterpState &S) {
18996	Flip<PT_Sint64, PT_Uint64>(S);
18997	#if USE_TAILCALLS
18998	MUSTTAIL return InterpNext(S);
18999	#else
19000	return true;
19001	#endif
19002	}
19003	PRESERVE_NONE
19004	static bool Interp_FlipSint64IntAP(InterpState &S) {
19005	Flip<PT_Sint64, PT_IntAP>(S);
19006	#if USE_TAILCALLS
19007	MUSTTAIL return InterpNext(S);
19008	#else
19009	return true;
19010	#endif
19011	}
19012	PRESERVE_NONE
19013	static bool Interp_FlipSint64IntAPS(InterpState &S) {
19014	Flip<PT_Sint64, PT_IntAPS>(S);
19015	#if USE_TAILCALLS
19016	MUSTTAIL return InterpNext(S);
19017	#else
19018	return true;
19019	#endif
19020	}
19021	PRESERVE_NONE
19022	static bool Interp_FlipSint64Bool(InterpState &S) {
19023	Flip<PT_Sint64, PT_Bool>(S);
19024	#if USE_TAILCALLS
19025	MUSTTAIL return InterpNext(S);
19026	#else
19027	return true;
19028	#endif
19029	}
19030	PRESERVE_NONE
19031	static bool Interp_FlipSint64FixedPoint(InterpState &S) {
19032	Flip<PT_Sint64, PT_FixedPoint>(S);
19033	#if USE_TAILCALLS
19034	MUSTTAIL return InterpNext(S);
19035	#else
19036	return true;
19037	#endif
19038	}
19039	PRESERVE_NONE
19040	static bool Interp_FlipSint64Ptr(InterpState &S) {
19041	Flip<PT_Sint64, PT_Ptr>(S);
19042	#if USE_TAILCALLS
19043	MUSTTAIL return InterpNext(S);
19044	#else
19045	return true;
19046	#endif
19047	}
19048	PRESERVE_NONE
19049	static bool Interp_FlipSint64MemberPtr(InterpState &S) {
19050	Flip<PT_Sint64, PT_MemberPtr>(S);
19051	#if USE_TAILCALLS
19052	MUSTTAIL return InterpNext(S);
19053	#else
19054	return true;
19055	#endif
19056	}
19057	PRESERVE_NONE
19058	static bool Interp_FlipSint64Float(InterpState &S) {
19059	Flip<PT_Sint64, PT_Float>(S);
19060	#if USE_TAILCALLS
19061	MUSTTAIL return InterpNext(S);
19062	#else
19063	return true;
19064	#endif
19065	}
19066	PRESERVE_NONE
19067	static bool Interp_FlipUint64Sint8(InterpState &S) {
19068	Flip<PT_Uint64, PT_Sint8>(S);
19069	#if USE_TAILCALLS
19070	MUSTTAIL return InterpNext(S);
19071	#else
19072	return true;
19073	#endif
19074	}
19075	PRESERVE_NONE
19076	static bool Interp_FlipUint64Uint8(InterpState &S) {
19077	Flip<PT_Uint64, PT_Uint8>(S);
19078	#if USE_TAILCALLS
19079	MUSTTAIL return InterpNext(S);
19080	#else
19081	return true;
19082	#endif
19083	}
19084	PRESERVE_NONE
19085	static bool Interp_FlipUint64Sint16(InterpState &S) {
19086	Flip<PT_Uint64, PT_Sint16>(S);
19087	#if USE_TAILCALLS
19088	MUSTTAIL return InterpNext(S);
19089	#else
19090	return true;
19091	#endif
19092	}
19093	PRESERVE_NONE
19094	static bool Interp_FlipUint64Uint16(InterpState &S) {
19095	Flip<PT_Uint64, PT_Uint16>(S);
19096	#if USE_TAILCALLS
19097	MUSTTAIL return InterpNext(S);
19098	#else
19099	return true;
19100	#endif
19101	}
19102	PRESERVE_NONE
19103	static bool Interp_FlipUint64Sint32(InterpState &S) {
19104	Flip<PT_Uint64, PT_Sint32>(S);
19105	#if USE_TAILCALLS
19106	MUSTTAIL return InterpNext(S);
19107	#else
19108	return true;
19109	#endif
19110	}
19111	PRESERVE_NONE
19112	static bool Interp_FlipUint64Uint32(InterpState &S) {
19113	Flip<PT_Uint64, PT_Uint32>(S);
19114	#if USE_TAILCALLS
19115	MUSTTAIL return InterpNext(S);
19116	#else
19117	return true;
19118	#endif
19119	}
19120	PRESERVE_NONE
19121	static bool Interp_FlipUint64Sint64(InterpState &S) {
19122	Flip<PT_Uint64, PT_Sint64>(S);
19123	#if USE_TAILCALLS
19124	MUSTTAIL return InterpNext(S);
19125	#else
19126	return true;
19127	#endif
19128	}
19129	PRESERVE_NONE
19130	static bool Interp_FlipUint64Uint64(InterpState &S) {
19131	Flip<PT_Uint64, PT_Uint64>(S);
19132	#if USE_TAILCALLS
19133	MUSTTAIL return InterpNext(S);
19134	#else
19135	return true;
19136	#endif
19137	}
19138	PRESERVE_NONE
19139	static bool Interp_FlipUint64IntAP(InterpState &S) {
19140	Flip<PT_Uint64, PT_IntAP>(S);
19141	#if USE_TAILCALLS
19142	MUSTTAIL return InterpNext(S);
19143	#else
19144	return true;
19145	#endif
19146	}
19147	PRESERVE_NONE
19148	static bool Interp_FlipUint64IntAPS(InterpState &S) {
19149	Flip<PT_Uint64, PT_IntAPS>(S);
19150	#if USE_TAILCALLS
19151	MUSTTAIL return InterpNext(S);
19152	#else
19153	return true;
19154	#endif
19155	}
19156	PRESERVE_NONE
19157	static bool Interp_FlipUint64Bool(InterpState &S) {
19158	Flip<PT_Uint64, PT_Bool>(S);
19159	#if USE_TAILCALLS
19160	MUSTTAIL return InterpNext(S);
19161	#else
19162	return true;
19163	#endif
19164	}
19165	PRESERVE_NONE
19166	static bool Interp_FlipUint64FixedPoint(InterpState &S) {
19167	Flip<PT_Uint64, PT_FixedPoint>(S);
19168	#if USE_TAILCALLS
19169	MUSTTAIL return InterpNext(S);
19170	#else
19171	return true;
19172	#endif
19173	}
19174	PRESERVE_NONE
19175	static bool Interp_FlipUint64Ptr(InterpState &S) {
19176	Flip<PT_Uint64, PT_Ptr>(S);
19177	#if USE_TAILCALLS
19178	MUSTTAIL return InterpNext(S);
19179	#else
19180	return true;
19181	#endif
19182	}
19183	PRESERVE_NONE
19184	static bool Interp_FlipUint64MemberPtr(InterpState &S) {
19185	Flip<PT_Uint64, PT_MemberPtr>(S);
19186	#if USE_TAILCALLS
19187	MUSTTAIL return InterpNext(S);
19188	#else
19189	return true;
19190	#endif
19191	}
19192	PRESERVE_NONE
19193	static bool Interp_FlipUint64Float(InterpState &S) {
19194	Flip<PT_Uint64, PT_Float>(S);
19195	#if USE_TAILCALLS
19196	MUSTTAIL return InterpNext(S);
19197	#else
19198	return true;
19199	#endif
19200	}
19201	PRESERVE_NONE
19202	static bool Interp_FlipIntAPSint8(InterpState &S) {
19203	Flip<PT_IntAP, PT_Sint8>(S);
19204	#if USE_TAILCALLS
19205	MUSTTAIL return InterpNext(S);
19206	#else
19207	return true;
19208	#endif
19209	}
19210	PRESERVE_NONE
19211	static bool Interp_FlipIntAPUint8(InterpState &S) {
19212	Flip<PT_IntAP, PT_Uint8>(S);
19213	#if USE_TAILCALLS
19214	MUSTTAIL return InterpNext(S);
19215	#else
19216	return true;
19217	#endif
19218	}
19219	PRESERVE_NONE
19220	static bool Interp_FlipIntAPSint16(InterpState &S) {
19221	Flip<PT_IntAP, PT_Sint16>(S);
19222	#if USE_TAILCALLS
19223	MUSTTAIL return InterpNext(S);
19224	#else
19225	return true;
19226	#endif
19227	}
19228	PRESERVE_NONE
19229	static bool Interp_FlipIntAPUint16(InterpState &S) {
19230	Flip<PT_IntAP, PT_Uint16>(S);
19231	#if USE_TAILCALLS
19232	MUSTTAIL return InterpNext(S);
19233	#else
19234	return true;
19235	#endif
19236	}
19237	PRESERVE_NONE
19238	static bool Interp_FlipIntAPSint32(InterpState &S) {
19239	Flip<PT_IntAP, PT_Sint32>(S);
19240	#if USE_TAILCALLS
19241	MUSTTAIL return InterpNext(S);
19242	#else
19243	return true;
19244	#endif
19245	}
19246	PRESERVE_NONE
19247	static bool Interp_FlipIntAPUint32(InterpState &S) {
19248	Flip<PT_IntAP, PT_Uint32>(S);
19249	#if USE_TAILCALLS
19250	MUSTTAIL return InterpNext(S);
19251	#else
19252	return true;
19253	#endif
19254	}
19255	PRESERVE_NONE
19256	static bool Interp_FlipIntAPSint64(InterpState &S) {
19257	Flip<PT_IntAP, PT_Sint64>(S);
19258	#if USE_TAILCALLS
19259	MUSTTAIL return InterpNext(S);
19260	#else
19261	return true;
19262	#endif
19263	}
19264	PRESERVE_NONE
19265	static bool Interp_FlipIntAPUint64(InterpState &S) {
19266	Flip<PT_IntAP, PT_Uint64>(S);
19267	#if USE_TAILCALLS
19268	MUSTTAIL return InterpNext(S);
19269	#else
19270	return true;
19271	#endif
19272	}
19273	PRESERVE_NONE
19274	static bool Interp_FlipIntAPIntAP(InterpState &S) {
19275	Flip<PT_IntAP, PT_IntAP>(S);
19276	#if USE_TAILCALLS
19277	MUSTTAIL return InterpNext(S);
19278	#else
19279	return true;
19280	#endif
19281	}
19282	PRESERVE_NONE
19283	static bool Interp_FlipIntAPIntAPS(InterpState &S) {
19284	Flip<PT_IntAP, PT_IntAPS>(S);
19285	#if USE_TAILCALLS
19286	MUSTTAIL return InterpNext(S);
19287	#else
19288	return true;
19289	#endif
19290	}
19291	PRESERVE_NONE
19292	static bool Interp_FlipIntAPBool(InterpState &S) {
19293	Flip<PT_IntAP, PT_Bool>(S);
19294	#if USE_TAILCALLS
19295	MUSTTAIL return InterpNext(S);
19296	#else
19297	return true;
19298	#endif
19299	}
19300	PRESERVE_NONE
19301	static bool Interp_FlipIntAPFixedPoint(InterpState &S) {
19302	Flip<PT_IntAP, PT_FixedPoint>(S);
19303	#if USE_TAILCALLS
19304	MUSTTAIL return InterpNext(S);
19305	#else
19306	return true;
19307	#endif
19308	}
19309	PRESERVE_NONE
19310	static bool Interp_FlipIntAPPtr(InterpState &S) {
19311	Flip<PT_IntAP, PT_Ptr>(S);
19312	#if USE_TAILCALLS
19313	MUSTTAIL return InterpNext(S);
19314	#else
19315	return true;
19316	#endif
19317	}
19318	PRESERVE_NONE
19319	static bool Interp_FlipIntAPMemberPtr(InterpState &S) {
19320	Flip<PT_IntAP, PT_MemberPtr>(S);
19321	#if USE_TAILCALLS
19322	MUSTTAIL return InterpNext(S);
19323	#else
19324	return true;
19325	#endif
19326	}
19327	PRESERVE_NONE
19328	static bool Interp_FlipIntAPFloat(InterpState &S) {
19329	Flip<PT_IntAP, PT_Float>(S);
19330	#if USE_TAILCALLS
19331	MUSTTAIL return InterpNext(S);
19332	#else
19333	return true;
19334	#endif
19335	}
19336	PRESERVE_NONE
19337	static bool Interp_FlipIntAPSSint8(InterpState &S) {
19338	Flip<PT_IntAPS, PT_Sint8>(S);
19339	#if USE_TAILCALLS
19340	MUSTTAIL return InterpNext(S);
19341	#else
19342	return true;
19343	#endif
19344	}
19345	PRESERVE_NONE
19346	static bool Interp_FlipIntAPSUint8(InterpState &S) {
19347	Flip<PT_IntAPS, PT_Uint8>(S);
19348	#if USE_TAILCALLS
19349	MUSTTAIL return InterpNext(S);
19350	#else
19351	return true;
19352	#endif
19353	}
19354	PRESERVE_NONE
19355	static bool Interp_FlipIntAPSSint16(InterpState &S) {
19356	Flip<PT_IntAPS, PT_Sint16>(S);
19357	#if USE_TAILCALLS
19358	MUSTTAIL return InterpNext(S);
19359	#else
19360	return true;
19361	#endif
19362	}
19363	PRESERVE_NONE
19364	static bool Interp_FlipIntAPSUint16(InterpState &S) {
19365	Flip<PT_IntAPS, PT_Uint16>(S);
19366	#if USE_TAILCALLS
19367	MUSTTAIL return InterpNext(S);
19368	#else
19369	return true;
19370	#endif
19371	}
19372	PRESERVE_NONE
19373	static bool Interp_FlipIntAPSSint32(InterpState &S) {
19374	Flip<PT_IntAPS, PT_Sint32>(S);
19375	#if USE_TAILCALLS
19376	MUSTTAIL return InterpNext(S);
19377	#else
19378	return true;
19379	#endif
19380	}
19381	PRESERVE_NONE
19382	static bool Interp_FlipIntAPSUint32(InterpState &S) {
19383	Flip<PT_IntAPS, PT_Uint32>(S);
19384	#if USE_TAILCALLS
19385	MUSTTAIL return InterpNext(S);
19386	#else
19387	return true;
19388	#endif
19389	}
19390	PRESERVE_NONE
19391	static bool Interp_FlipIntAPSSint64(InterpState &S) {
19392	Flip<PT_IntAPS, PT_Sint64>(S);
19393	#if USE_TAILCALLS
19394	MUSTTAIL return InterpNext(S);
19395	#else
19396	return true;
19397	#endif
19398	}
19399	PRESERVE_NONE
19400	static bool Interp_FlipIntAPSUint64(InterpState &S) {
19401	Flip<PT_IntAPS, PT_Uint64>(S);
19402	#if USE_TAILCALLS
19403	MUSTTAIL return InterpNext(S);
19404	#else
19405	return true;
19406	#endif
19407	}
19408	PRESERVE_NONE
19409	static bool Interp_FlipIntAPSIntAP(InterpState &S) {
19410	Flip<PT_IntAPS, PT_IntAP>(S);
19411	#if USE_TAILCALLS
19412	MUSTTAIL return InterpNext(S);
19413	#else
19414	return true;
19415	#endif
19416	}
19417	PRESERVE_NONE
19418	static bool Interp_FlipIntAPSIntAPS(InterpState &S) {
19419	Flip<PT_IntAPS, PT_IntAPS>(S);
19420	#if USE_TAILCALLS
19421	MUSTTAIL return InterpNext(S);
19422	#else
19423	return true;
19424	#endif
19425	}
19426	PRESERVE_NONE
19427	static bool Interp_FlipIntAPSBool(InterpState &S) {
19428	Flip<PT_IntAPS, PT_Bool>(S);
19429	#if USE_TAILCALLS
19430	MUSTTAIL return InterpNext(S);
19431	#else
19432	return true;
19433	#endif
19434	}
19435	PRESERVE_NONE
19436	static bool Interp_FlipIntAPSFixedPoint(InterpState &S) {
19437	Flip<PT_IntAPS, PT_FixedPoint>(S);
19438	#if USE_TAILCALLS
19439	MUSTTAIL return InterpNext(S);
19440	#else
19441	return true;
19442	#endif
19443	}
19444	PRESERVE_NONE
19445	static bool Interp_FlipIntAPSPtr(InterpState &S) {
19446	Flip<PT_IntAPS, PT_Ptr>(S);
19447	#if USE_TAILCALLS
19448	MUSTTAIL return InterpNext(S);
19449	#else
19450	return true;
19451	#endif
19452	}
19453	PRESERVE_NONE
19454	static bool Interp_FlipIntAPSMemberPtr(InterpState &S) {
19455	Flip<PT_IntAPS, PT_MemberPtr>(S);
19456	#if USE_TAILCALLS
19457	MUSTTAIL return InterpNext(S);
19458	#else
19459	return true;
19460	#endif
19461	}
19462	PRESERVE_NONE
19463	static bool Interp_FlipIntAPSFloat(InterpState &S) {
19464	Flip<PT_IntAPS, PT_Float>(S);
19465	#if USE_TAILCALLS
19466	MUSTTAIL return InterpNext(S);
19467	#else
19468	return true;
19469	#endif
19470	}
19471	PRESERVE_NONE
19472	static bool Interp_FlipBoolSint8(InterpState &S) {
19473	Flip<PT_Bool, PT_Sint8>(S);
19474	#if USE_TAILCALLS
19475	MUSTTAIL return InterpNext(S);
19476	#else
19477	return true;
19478	#endif
19479	}
19480	PRESERVE_NONE
19481	static bool Interp_FlipBoolUint8(InterpState &S) {
19482	Flip<PT_Bool, PT_Uint8>(S);
19483	#if USE_TAILCALLS
19484	MUSTTAIL return InterpNext(S);
19485	#else
19486	return true;
19487	#endif
19488	}
19489	PRESERVE_NONE
19490	static bool Interp_FlipBoolSint16(InterpState &S) {
19491	Flip<PT_Bool, PT_Sint16>(S);
19492	#if USE_TAILCALLS
19493	MUSTTAIL return InterpNext(S);
19494	#else
19495	return true;
19496	#endif
19497	}
19498	PRESERVE_NONE
19499	static bool Interp_FlipBoolUint16(InterpState &S) {
19500	Flip<PT_Bool, PT_Uint16>(S);
19501	#if USE_TAILCALLS
19502	MUSTTAIL return InterpNext(S);
19503	#else
19504	return true;
19505	#endif
19506	}
19507	PRESERVE_NONE
19508	static bool Interp_FlipBoolSint32(InterpState &S) {
19509	Flip<PT_Bool, PT_Sint32>(S);
19510	#if USE_TAILCALLS
19511	MUSTTAIL return InterpNext(S);
19512	#else
19513	return true;
19514	#endif
19515	}
19516	PRESERVE_NONE
19517	static bool Interp_FlipBoolUint32(InterpState &S) {
19518	Flip<PT_Bool, PT_Uint32>(S);
19519	#if USE_TAILCALLS
19520	MUSTTAIL return InterpNext(S);
19521	#else
19522	return true;
19523	#endif
19524	}
19525	PRESERVE_NONE
19526	static bool Interp_FlipBoolSint64(InterpState &S) {
19527	Flip<PT_Bool, PT_Sint64>(S);
19528	#if USE_TAILCALLS
19529	MUSTTAIL return InterpNext(S);
19530	#else
19531	return true;
19532	#endif
19533	}
19534	PRESERVE_NONE
19535	static bool Interp_FlipBoolUint64(InterpState &S) {
19536	Flip<PT_Bool, PT_Uint64>(S);
19537	#if USE_TAILCALLS
19538	MUSTTAIL return InterpNext(S);
19539	#else
19540	return true;
19541	#endif
19542	}
19543	PRESERVE_NONE
19544	static bool Interp_FlipBoolIntAP(InterpState &S) {
19545	Flip<PT_Bool, PT_IntAP>(S);
19546	#if USE_TAILCALLS
19547	MUSTTAIL return InterpNext(S);
19548	#else
19549	return true;
19550	#endif
19551	}
19552	PRESERVE_NONE
19553	static bool Interp_FlipBoolIntAPS(InterpState &S) {
19554	Flip<PT_Bool, PT_IntAPS>(S);
19555	#if USE_TAILCALLS
19556	MUSTTAIL return InterpNext(S);
19557	#else
19558	return true;
19559	#endif
19560	}
19561	PRESERVE_NONE
19562	static bool Interp_FlipBoolBool(InterpState &S) {
19563	Flip<PT_Bool, PT_Bool>(S);
19564	#if USE_TAILCALLS
19565	MUSTTAIL return InterpNext(S);
19566	#else
19567	return true;
19568	#endif
19569	}
19570	PRESERVE_NONE
19571	static bool Interp_FlipBoolFixedPoint(InterpState &S) {
19572	Flip<PT_Bool, PT_FixedPoint>(S);
19573	#if USE_TAILCALLS
19574	MUSTTAIL return InterpNext(S);
19575	#else
19576	return true;
19577	#endif
19578	}
19579	PRESERVE_NONE
19580	static bool Interp_FlipBoolPtr(InterpState &S) {
19581	Flip<PT_Bool, PT_Ptr>(S);
19582	#if USE_TAILCALLS
19583	MUSTTAIL return InterpNext(S);
19584	#else
19585	return true;
19586	#endif
19587	}
19588	PRESERVE_NONE
19589	static bool Interp_FlipBoolMemberPtr(InterpState &S) {
19590	Flip<PT_Bool, PT_MemberPtr>(S);
19591	#if USE_TAILCALLS
19592	MUSTTAIL return InterpNext(S);
19593	#else
19594	return true;
19595	#endif
19596	}
19597	PRESERVE_NONE
19598	static bool Interp_FlipBoolFloat(InterpState &S) {
19599	Flip<PT_Bool, PT_Float>(S);
19600	#if USE_TAILCALLS
19601	MUSTTAIL return InterpNext(S);
19602	#else
19603	return true;
19604	#endif
19605	}
19606	PRESERVE_NONE
19607	static bool Interp_FlipFixedPointSint8(InterpState &S) {
19608	Flip<PT_FixedPoint, PT_Sint8>(S);
19609	#if USE_TAILCALLS
19610	MUSTTAIL return InterpNext(S);
19611	#else
19612	return true;
19613	#endif
19614	}
19615	PRESERVE_NONE
19616	static bool Interp_FlipFixedPointUint8(InterpState &S) {
19617	Flip<PT_FixedPoint, PT_Uint8>(S);
19618	#if USE_TAILCALLS
19619	MUSTTAIL return InterpNext(S);
19620	#else
19621	return true;
19622	#endif
19623	}
19624	PRESERVE_NONE
19625	static bool Interp_FlipFixedPointSint16(InterpState &S) {
19626	Flip<PT_FixedPoint, PT_Sint16>(S);
19627	#if USE_TAILCALLS
19628	MUSTTAIL return InterpNext(S);
19629	#else
19630	return true;
19631	#endif
19632	}
19633	PRESERVE_NONE
19634	static bool Interp_FlipFixedPointUint16(InterpState &S) {
19635	Flip<PT_FixedPoint, PT_Uint16>(S);
19636	#if USE_TAILCALLS
19637	MUSTTAIL return InterpNext(S);
19638	#else
19639	return true;
19640	#endif
19641	}
19642	PRESERVE_NONE
19643	static bool Interp_FlipFixedPointSint32(InterpState &S) {
19644	Flip<PT_FixedPoint, PT_Sint32>(S);
19645	#if USE_TAILCALLS
19646	MUSTTAIL return InterpNext(S);
19647	#else
19648	return true;
19649	#endif
19650	}
19651	PRESERVE_NONE
19652	static bool Interp_FlipFixedPointUint32(InterpState &S) {
19653	Flip<PT_FixedPoint, PT_Uint32>(S);
19654	#if USE_TAILCALLS
19655	MUSTTAIL return InterpNext(S);
19656	#else
19657	return true;
19658	#endif
19659	}
19660	PRESERVE_NONE
19661	static bool Interp_FlipFixedPointSint64(InterpState &S) {
19662	Flip<PT_FixedPoint, PT_Sint64>(S);
19663	#if USE_TAILCALLS
19664	MUSTTAIL return InterpNext(S);
19665	#else
19666	return true;
19667	#endif
19668	}
19669	PRESERVE_NONE
19670	static bool Interp_FlipFixedPointUint64(InterpState &S) {
19671	Flip<PT_FixedPoint, PT_Uint64>(S);
19672	#if USE_TAILCALLS
19673	MUSTTAIL return InterpNext(S);
19674	#else
19675	return true;
19676	#endif
19677	}
19678	PRESERVE_NONE
19679	static bool Interp_FlipFixedPointIntAP(InterpState &S) {
19680	Flip<PT_FixedPoint, PT_IntAP>(S);
19681	#if USE_TAILCALLS
19682	MUSTTAIL return InterpNext(S);
19683	#else
19684	return true;
19685	#endif
19686	}
19687	PRESERVE_NONE
19688	static bool Interp_FlipFixedPointIntAPS(InterpState &S) {
19689	Flip<PT_FixedPoint, PT_IntAPS>(S);
19690	#if USE_TAILCALLS
19691	MUSTTAIL return InterpNext(S);
19692	#else
19693	return true;
19694	#endif
19695	}
19696	PRESERVE_NONE
19697	static bool Interp_FlipFixedPointBool(InterpState &S) {
19698	Flip<PT_FixedPoint, PT_Bool>(S);
19699	#if USE_TAILCALLS
19700	MUSTTAIL return InterpNext(S);
19701	#else
19702	return true;
19703	#endif
19704	}
19705	PRESERVE_NONE
19706	static bool Interp_FlipFixedPointFixedPoint(InterpState &S) {
19707	Flip<PT_FixedPoint, PT_FixedPoint>(S);
19708	#if USE_TAILCALLS
19709	MUSTTAIL return InterpNext(S);
19710	#else
19711	return true;
19712	#endif
19713	}
19714	PRESERVE_NONE
19715	static bool Interp_FlipFixedPointPtr(InterpState &S) {
19716	Flip<PT_FixedPoint, PT_Ptr>(S);
19717	#if USE_TAILCALLS
19718	MUSTTAIL return InterpNext(S);
19719	#else
19720	return true;
19721	#endif
19722	}
19723	PRESERVE_NONE
19724	static bool Interp_FlipFixedPointMemberPtr(InterpState &S) {
19725	Flip<PT_FixedPoint, PT_MemberPtr>(S);
19726	#if USE_TAILCALLS
19727	MUSTTAIL return InterpNext(S);
19728	#else
19729	return true;
19730	#endif
19731	}
19732	PRESERVE_NONE
19733	static bool Interp_FlipFixedPointFloat(InterpState &S) {
19734	Flip<PT_FixedPoint, PT_Float>(S);
19735	#if USE_TAILCALLS
19736	MUSTTAIL return InterpNext(S);
19737	#else
19738	return true;
19739	#endif
19740	}
19741	PRESERVE_NONE
19742	static bool Interp_FlipPtrSint8(InterpState &S) {
19743	Flip<PT_Ptr, PT_Sint8>(S);
19744	#if USE_TAILCALLS
19745	MUSTTAIL return InterpNext(S);
19746	#else
19747	return true;
19748	#endif
19749	}
19750	PRESERVE_NONE
19751	static bool Interp_FlipPtrUint8(InterpState &S) {
19752	Flip<PT_Ptr, PT_Uint8>(S);
19753	#if USE_TAILCALLS
19754	MUSTTAIL return InterpNext(S);
19755	#else
19756	return true;
19757	#endif
19758	}
19759	PRESERVE_NONE
19760	static bool Interp_FlipPtrSint16(InterpState &S) {
19761	Flip<PT_Ptr, PT_Sint16>(S);
19762	#if USE_TAILCALLS
19763	MUSTTAIL return InterpNext(S);
19764	#else
19765	return true;
19766	#endif
19767	}
19768	PRESERVE_NONE
19769	static bool Interp_FlipPtrUint16(InterpState &S) {
19770	Flip<PT_Ptr, PT_Uint16>(S);
19771	#if USE_TAILCALLS
19772	MUSTTAIL return InterpNext(S);
19773	#else
19774	return true;
19775	#endif
19776	}
19777	PRESERVE_NONE
19778	static bool Interp_FlipPtrSint32(InterpState &S) {
19779	Flip<PT_Ptr, PT_Sint32>(S);
19780	#if USE_TAILCALLS
19781	MUSTTAIL return InterpNext(S);
19782	#else
19783	return true;
19784	#endif
19785	}
19786	PRESERVE_NONE
19787	static bool Interp_FlipPtrUint32(InterpState &S) {
19788	Flip<PT_Ptr, PT_Uint32>(S);
19789	#if USE_TAILCALLS
19790	MUSTTAIL return InterpNext(S);
19791	#else
19792	return true;
19793	#endif
19794	}
19795	PRESERVE_NONE
19796	static bool Interp_FlipPtrSint64(InterpState &S) {
19797	Flip<PT_Ptr, PT_Sint64>(S);
19798	#if USE_TAILCALLS
19799	MUSTTAIL return InterpNext(S);
19800	#else
19801	return true;
19802	#endif
19803	}
19804	PRESERVE_NONE
19805	static bool Interp_FlipPtrUint64(InterpState &S) {
19806	Flip<PT_Ptr, PT_Uint64>(S);
19807	#if USE_TAILCALLS
19808	MUSTTAIL return InterpNext(S);
19809	#else
19810	return true;
19811	#endif
19812	}
19813	PRESERVE_NONE
19814	static bool Interp_FlipPtrIntAP(InterpState &S) {
19815	Flip<PT_Ptr, PT_IntAP>(S);
19816	#if USE_TAILCALLS
19817	MUSTTAIL return InterpNext(S);
19818	#else
19819	return true;
19820	#endif
19821	}
19822	PRESERVE_NONE
19823	static bool Interp_FlipPtrIntAPS(InterpState &S) {
19824	Flip<PT_Ptr, PT_IntAPS>(S);
19825	#if USE_TAILCALLS
19826	MUSTTAIL return InterpNext(S);
19827	#else
19828	return true;
19829	#endif
19830	}
19831	PRESERVE_NONE
19832	static bool Interp_FlipPtrBool(InterpState &S) {
19833	Flip<PT_Ptr, PT_Bool>(S);
19834	#if USE_TAILCALLS
19835	MUSTTAIL return InterpNext(S);
19836	#else
19837	return true;
19838	#endif
19839	}
19840	PRESERVE_NONE
19841	static bool Interp_FlipPtrFixedPoint(InterpState &S) {
19842	Flip<PT_Ptr, PT_FixedPoint>(S);
19843	#if USE_TAILCALLS
19844	MUSTTAIL return InterpNext(S);
19845	#else
19846	return true;
19847	#endif
19848	}
19849	PRESERVE_NONE
19850	static bool Interp_FlipPtrPtr(InterpState &S) {
19851	Flip<PT_Ptr, PT_Ptr>(S);
19852	#if USE_TAILCALLS
19853	MUSTTAIL return InterpNext(S);
19854	#else
19855	return true;
19856	#endif
19857	}
19858	PRESERVE_NONE
19859	static bool Interp_FlipPtrMemberPtr(InterpState &S) {
19860	Flip<PT_Ptr, PT_MemberPtr>(S);
19861	#if USE_TAILCALLS
19862	MUSTTAIL return InterpNext(S);
19863	#else
19864	return true;
19865	#endif
19866	}
19867	PRESERVE_NONE
19868	static bool Interp_FlipPtrFloat(InterpState &S) {
19869	Flip<PT_Ptr, PT_Float>(S);
19870	#if USE_TAILCALLS
19871	MUSTTAIL return InterpNext(S);
19872	#else
19873	return true;
19874	#endif
19875	}
19876	PRESERVE_NONE
19877	static bool Interp_FlipMemberPtrSint8(InterpState &S) {
19878	Flip<PT_MemberPtr, PT_Sint8>(S);
19879	#if USE_TAILCALLS
19880	MUSTTAIL return InterpNext(S);
19881	#else
19882	return true;
19883	#endif
19884	}
19885	PRESERVE_NONE
19886	static bool Interp_FlipMemberPtrUint8(InterpState &S) {
19887	Flip<PT_MemberPtr, PT_Uint8>(S);
19888	#if USE_TAILCALLS
19889	MUSTTAIL return InterpNext(S);
19890	#else
19891	return true;
19892	#endif
19893	}
19894	PRESERVE_NONE
19895	static bool Interp_FlipMemberPtrSint16(InterpState &S) {
19896	Flip<PT_MemberPtr, PT_Sint16>(S);
19897	#if USE_TAILCALLS
19898	MUSTTAIL return InterpNext(S);
19899	#else
19900	return true;
19901	#endif
19902	}
19903	PRESERVE_NONE
19904	static bool Interp_FlipMemberPtrUint16(InterpState &S) {
19905	Flip<PT_MemberPtr, PT_Uint16>(S);
19906	#if USE_TAILCALLS
19907	MUSTTAIL return InterpNext(S);
19908	#else
19909	return true;
19910	#endif
19911	}
19912	PRESERVE_NONE
19913	static bool Interp_FlipMemberPtrSint32(InterpState &S) {
19914	Flip<PT_MemberPtr, PT_Sint32>(S);
19915	#if USE_TAILCALLS
19916	MUSTTAIL return InterpNext(S);
19917	#else
19918	return true;
19919	#endif
19920	}
19921	PRESERVE_NONE
19922	static bool Interp_FlipMemberPtrUint32(InterpState &S) {
19923	Flip<PT_MemberPtr, PT_Uint32>(S);
19924	#if USE_TAILCALLS
19925	MUSTTAIL return InterpNext(S);
19926	#else
19927	return true;
19928	#endif
19929	}
19930	PRESERVE_NONE
19931	static bool Interp_FlipMemberPtrSint64(InterpState &S) {
19932	Flip<PT_MemberPtr, PT_Sint64>(S);
19933	#if USE_TAILCALLS
19934	MUSTTAIL return InterpNext(S);
19935	#else
19936	return true;
19937	#endif
19938	}
19939	PRESERVE_NONE
19940	static bool Interp_FlipMemberPtrUint64(InterpState &S) {
19941	Flip<PT_MemberPtr, PT_Uint64>(S);
19942	#if USE_TAILCALLS
19943	MUSTTAIL return InterpNext(S);
19944	#else
19945	return true;
19946	#endif
19947	}
19948	PRESERVE_NONE
19949	static bool Interp_FlipMemberPtrIntAP(InterpState &S) {
19950	Flip<PT_MemberPtr, PT_IntAP>(S);
19951	#if USE_TAILCALLS
19952	MUSTTAIL return InterpNext(S);
19953	#else
19954	return true;
19955	#endif
19956	}
19957	PRESERVE_NONE
19958	static bool Interp_FlipMemberPtrIntAPS(InterpState &S) {
19959	Flip<PT_MemberPtr, PT_IntAPS>(S);
19960	#if USE_TAILCALLS
19961	MUSTTAIL return InterpNext(S);
19962	#else
19963	return true;
19964	#endif
19965	}
19966	PRESERVE_NONE
19967	static bool Interp_FlipMemberPtrBool(InterpState &S) {
19968	Flip<PT_MemberPtr, PT_Bool>(S);
19969	#if USE_TAILCALLS
19970	MUSTTAIL return InterpNext(S);
19971	#else
19972	return true;
19973	#endif
19974	}
19975	PRESERVE_NONE
19976	static bool Interp_FlipMemberPtrFixedPoint(InterpState &S) {
19977	Flip<PT_MemberPtr, PT_FixedPoint>(S);
19978	#if USE_TAILCALLS
19979	MUSTTAIL return InterpNext(S);
19980	#else
19981	return true;
19982	#endif
19983	}
19984	PRESERVE_NONE
19985	static bool Interp_FlipMemberPtrPtr(InterpState &S) {
19986	Flip<PT_MemberPtr, PT_Ptr>(S);
19987	#if USE_TAILCALLS
19988	MUSTTAIL return InterpNext(S);
19989	#else
19990	return true;
19991	#endif
19992	}
19993	PRESERVE_NONE
19994	static bool Interp_FlipMemberPtrMemberPtr(InterpState &S) {
19995	Flip<PT_MemberPtr, PT_MemberPtr>(S);
19996	#if USE_TAILCALLS
19997	MUSTTAIL return InterpNext(S);
19998	#else
19999	return true;
20000	#endif
20001	}
20002	PRESERVE_NONE
20003	static bool Interp_FlipMemberPtrFloat(InterpState &S) {
20004	Flip<PT_MemberPtr, PT_Float>(S);
20005	#if USE_TAILCALLS
20006	MUSTTAIL return InterpNext(S);
20007	#else
20008	return true;
20009	#endif
20010	}
20011	PRESERVE_NONE
20012	static bool Interp_FlipFloatSint8(InterpState &S) {
20013	Flip<PT_Float, PT_Sint8>(S);
20014	#if USE_TAILCALLS
20015	MUSTTAIL return InterpNext(S);
20016	#else
20017	return true;
20018	#endif
20019	}
20020	PRESERVE_NONE
20021	static bool Interp_FlipFloatUint8(InterpState &S) {
20022	Flip<PT_Float, PT_Uint8>(S);
20023	#if USE_TAILCALLS
20024	MUSTTAIL return InterpNext(S);
20025	#else
20026	return true;
20027	#endif
20028	}
20029	PRESERVE_NONE
20030	static bool Interp_FlipFloatSint16(InterpState &S) {
20031	Flip<PT_Float, PT_Sint16>(S);
20032	#if USE_TAILCALLS
20033	MUSTTAIL return InterpNext(S);
20034	#else
20035	return true;
20036	#endif
20037	}
20038	PRESERVE_NONE
20039	static bool Interp_FlipFloatUint16(InterpState &S) {
20040	Flip<PT_Float, PT_Uint16>(S);
20041	#if USE_TAILCALLS
20042	MUSTTAIL return InterpNext(S);
20043	#else
20044	return true;
20045	#endif
20046	}
20047	PRESERVE_NONE
20048	static bool Interp_FlipFloatSint32(InterpState &S) {
20049	Flip<PT_Float, PT_Sint32>(S);
20050	#if USE_TAILCALLS
20051	MUSTTAIL return InterpNext(S);
20052	#else
20053	return true;
20054	#endif
20055	}
20056	PRESERVE_NONE
20057	static bool Interp_FlipFloatUint32(InterpState &S) {
20058	Flip<PT_Float, PT_Uint32>(S);
20059	#if USE_TAILCALLS
20060	MUSTTAIL return InterpNext(S);
20061	#else
20062	return true;
20063	#endif
20064	}
20065	PRESERVE_NONE
20066	static bool Interp_FlipFloatSint64(InterpState &S) {
20067	Flip<PT_Float, PT_Sint64>(S);
20068	#if USE_TAILCALLS
20069	MUSTTAIL return InterpNext(S);
20070	#else
20071	return true;
20072	#endif
20073	}
20074	PRESERVE_NONE
20075	static bool Interp_FlipFloatUint64(InterpState &S) {
20076	Flip<PT_Float, PT_Uint64>(S);
20077	#if USE_TAILCALLS
20078	MUSTTAIL return InterpNext(S);
20079	#else
20080	return true;
20081	#endif
20082	}
20083	PRESERVE_NONE
20084	static bool Interp_FlipFloatIntAP(InterpState &S) {
20085	Flip<PT_Float, PT_IntAP>(S);
20086	#if USE_TAILCALLS
20087	MUSTTAIL return InterpNext(S);
20088	#else
20089	return true;
20090	#endif
20091	}
20092	PRESERVE_NONE
20093	static bool Interp_FlipFloatIntAPS(InterpState &S) {
20094	Flip<PT_Float, PT_IntAPS>(S);
20095	#if USE_TAILCALLS
20096	MUSTTAIL return InterpNext(S);
20097	#else
20098	return true;
20099	#endif
20100	}
20101	PRESERVE_NONE
20102	static bool Interp_FlipFloatBool(InterpState &S) {
20103	Flip<PT_Float, PT_Bool>(S);
20104	#if USE_TAILCALLS
20105	MUSTTAIL return InterpNext(S);
20106	#else
20107	return true;
20108	#endif
20109	}
20110	PRESERVE_NONE
20111	static bool Interp_FlipFloatFixedPoint(InterpState &S) {
20112	Flip<PT_Float, PT_FixedPoint>(S);
20113	#if USE_TAILCALLS
20114	MUSTTAIL return InterpNext(S);
20115	#else
20116	return true;
20117	#endif
20118	}
20119	PRESERVE_NONE
20120	static bool Interp_FlipFloatPtr(InterpState &S) {
20121	Flip<PT_Float, PT_Ptr>(S);
20122	#if USE_TAILCALLS
20123	MUSTTAIL return InterpNext(S);
20124	#else
20125	return true;
20126	#endif
20127	}
20128	PRESERVE_NONE
20129	static bool Interp_FlipFloatMemberPtr(InterpState &S) {
20130	Flip<PT_Float, PT_MemberPtr>(S);
20131	#if USE_TAILCALLS
20132	MUSTTAIL return InterpNext(S);
20133	#else
20134	return true;
20135	#endif
20136	}
20137	PRESERVE_NONE
20138	static bool Interp_FlipFloatFloat(InterpState &S) {
20139	Flip<PT_Float, PT_Float>(S);
20140	#if USE_TAILCALLS
20141	MUSTTAIL return InterpNext(S);
20142	#else
20143	return true;
20144	#endif
20145	}
20146	#endif
20147	#ifdef GET_DISASM
20148	case OP_FlipSint8Sint8:
20149	Text.Op = PrintName("FlipSint8Sint8");
20150	break;
20151	case OP_FlipSint8Uint8:
20152	Text.Op = PrintName("FlipSint8Uint8");
20153	break;
20154	case OP_FlipSint8Sint16:
20155	Text.Op = PrintName("FlipSint8Sint16");
20156	break;
20157	case OP_FlipSint8Uint16:
20158	Text.Op = PrintName("FlipSint8Uint16");
20159	break;
20160	case OP_FlipSint8Sint32:
20161	Text.Op = PrintName("FlipSint8Sint32");
20162	break;
20163	case OP_FlipSint8Uint32:
20164	Text.Op = PrintName("FlipSint8Uint32");
20165	break;
20166	case OP_FlipSint8Sint64:
20167	Text.Op = PrintName("FlipSint8Sint64");
20168	break;
20169	case OP_FlipSint8Uint64:
20170	Text.Op = PrintName("FlipSint8Uint64");
20171	break;
20172	case OP_FlipSint8IntAP:
20173	Text.Op = PrintName("FlipSint8IntAP");
20174	break;
20175	case OP_FlipSint8IntAPS:
20176	Text.Op = PrintName("FlipSint8IntAPS");
20177	break;
20178	case OP_FlipSint8Bool:
20179	Text.Op = PrintName("FlipSint8Bool");
20180	break;
20181	case OP_FlipSint8FixedPoint:
20182	Text.Op = PrintName("FlipSint8FixedPoint");
20183	break;
20184	case OP_FlipSint8Ptr:
20185	Text.Op = PrintName("FlipSint8Ptr");
20186	break;
20187	case OP_FlipSint8MemberPtr:
20188	Text.Op = PrintName("FlipSint8MemberPtr");
20189	break;
20190	case OP_FlipSint8Float:
20191	Text.Op = PrintName("FlipSint8Float");
20192	break;
20193	case OP_FlipUint8Sint8:
20194	Text.Op = PrintName("FlipUint8Sint8");
20195	break;
20196	case OP_FlipUint8Uint8:
20197	Text.Op = PrintName("FlipUint8Uint8");
20198	break;
20199	case OP_FlipUint8Sint16:
20200	Text.Op = PrintName("FlipUint8Sint16");
20201	break;
20202	case OP_FlipUint8Uint16:
20203	Text.Op = PrintName("FlipUint8Uint16");
20204	break;
20205	case OP_FlipUint8Sint32:
20206	Text.Op = PrintName("FlipUint8Sint32");
20207	break;
20208	case OP_FlipUint8Uint32:
20209	Text.Op = PrintName("FlipUint8Uint32");
20210	break;
20211	case OP_FlipUint8Sint64:
20212	Text.Op = PrintName("FlipUint8Sint64");
20213	break;
20214	case OP_FlipUint8Uint64:
20215	Text.Op = PrintName("FlipUint8Uint64");
20216	break;
20217	case OP_FlipUint8IntAP:
20218	Text.Op = PrintName("FlipUint8IntAP");
20219	break;
20220	case OP_FlipUint8IntAPS:
20221	Text.Op = PrintName("FlipUint8IntAPS");
20222	break;
20223	case OP_FlipUint8Bool:
20224	Text.Op = PrintName("FlipUint8Bool");
20225	break;
20226	case OP_FlipUint8FixedPoint:
20227	Text.Op = PrintName("FlipUint8FixedPoint");
20228	break;
20229	case OP_FlipUint8Ptr:
20230	Text.Op = PrintName("FlipUint8Ptr");
20231	break;
20232	case OP_FlipUint8MemberPtr:
20233	Text.Op = PrintName("FlipUint8MemberPtr");
20234	break;
20235	case OP_FlipUint8Float:
20236	Text.Op = PrintName("FlipUint8Float");
20237	break;
20238	case OP_FlipSint16Sint8:
20239	Text.Op = PrintName("FlipSint16Sint8");
20240	break;
20241	case OP_FlipSint16Uint8:
20242	Text.Op = PrintName("FlipSint16Uint8");
20243	break;
20244	case OP_FlipSint16Sint16:
20245	Text.Op = PrintName("FlipSint16Sint16");
20246	break;
20247	case OP_FlipSint16Uint16:
20248	Text.Op = PrintName("FlipSint16Uint16");
20249	break;
20250	case OP_FlipSint16Sint32:
20251	Text.Op = PrintName("FlipSint16Sint32");
20252	break;
20253	case OP_FlipSint16Uint32:
20254	Text.Op = PrintName("FlipSint16Uint32");
20255	break;
20256	case OP_FlipSint16Sint64:
20257	Text.Op = PrintName("FlipSint16Sint64");
20258	break;
20259	case OP_FlipSint16Uint64:
20260	Text.Op = PrintName("FlipSint16Uint64");
20261	break;
20262	case OP_FlipSint16IntAP:
20263	Text.Op = PrintName("FlipSint16IntAP");
20264	break;
20265	case OP_FlipSint16IntAPS:
20266	Text.Op = PrintName("FlipSint16IntAPS");
20267	break;
20268	case OP_FlipSint16Bool:
20269	Text.Op = PrintName("FlipSint16Bool");
20270	break;
20271	case OP_FlipSint16FixedPoint:
20272	Text.Op = PrintName("FlipSint16FixedPoint");
20273	break;
20274	case OP_FlipSint16Ptr:
20275	Text.Op = PrintName("FlipSint16Ptr");
20276	break;
20277	case OP_FlipSint16MemberPtr:
20278	Text.Op = PrintName("FlipSint16MemberPtr");
20279	break;
20280	case OP_FlipSint16Float:
20281	Text.Op = PrintName("FlipSint16Float");
20282	break;
20283	case OP_FlipUint16Sint8:
20284	Text.Op = PrintName("FlipUint16Sint8");
20285	break;
20286	case OP_FlipUint16Uint8:
20287	Text.Op = PrintName("FlipUint16Uint8");
20288	break;
20289	case OP_FlipUint16Sint16:
20290	Text.Op = PrintName("FlipUint16Sint16");
20291	break;
20292	case OP_FlipUint16Uint16:
20293	Text.Op = PrintName("FlipUint16Uint16");
20294	break;
20295	case OP_FlipUint16Sint32:
20296	Text.Op = PrintName("FlipUint16Sint32");
20297	break;
20298	case OP_FlipUint16Uint32:
20299	Text.Op = PrintName("FlipUint16Uint32");
20300	break;
20301	case OP_FlipUint16Sint64:
20302	Text.Op = PrintName("FlipUint16Sint64");
20303	break;
20304	case OP_FlipUint16Uint64:
20305	Text.Op = PrintName("FlipUint16Uint64");
20306	break;
20307	case OP_FlipUint16IntAP:
20308	Text.Op = PrintName("FlipUint16IntAP");
20309	break;
20310	case OP_FlipUint16IntAPS:
20311	Text.Op = PrintName("FlipUint16IntAPS");
20312	break;
20313	case OP_FlipUint16Bool:
20314	Text.Op = PrintName("FlipUint16Bool");
20315	break;
20316	case OP_FlipUint16FixedPoint:
20317	Text.Op = PrintName("FlipUint16FixedPoint");
20318	break;
20319	case OP_FlipUint16Ptr:
20320	Text.Op = PrintName("FlipUint16Ptr");
20321	break;
20322	case OP_FlipUint16MemberPtr:
20323	Text.Op = PrintName("FlipUint16MemberPtr");
20324	break;
20325	case OP_FlipUint16Float:
20326	Text.Op = PrintName("FlipUint16Float");
20327	break;
20328	case OP_FlipSint32Sint8:
20329	Text.Op = PrintName("FlipSint32Sint8");
20330	break;
20331	case OP_FlipSint32Uint8:
20332	Text.Op = PrintName("FlipSint32Uint8");
20333	break;
20334	case OP_FlipSint32Sint16:
20335	Text.Op = PrintName("FlipSint32Sint16");
20336	break;
20337	case OP_FlipSint32Uint16:
20338	Text.Op = PrintName("FlipSint32Uint16");
20339	break;
20340	case OP_FlipSint32Sint32:
20341	Text.Op = PrintName("FlipSint32Sint32");
20342	break;
20343	case OP_FlipSint32Uint32:
20344	Text.Op = PrintName("FlipSint32Uint32");
20345	break;
20346	case OP_FlipSint32Sint64:
20347	Text.Op = PrintName("FlipSint32Sint64");
20348	break;
20349	case OP_FlipSint32Uint64:
20350	Text.Op = PrintName("FlipSint32Uint64");
20351	break;
20352	case OP_FlipSint32IntAP:
20353	Text.Op = PrintName("FlipSint32IntAP");
20354	break;
20355	case OP_FlipSint32IntAPS:
20356	Text.Op = PrintName("FlipSint32IntAPS");
20357	break;
20358	case OP_FlipSint32Bool:
20359	Text.Op = PrintName("FlipSint32Bool");
20360	break;
20361	case OP_FlipSint32FixedPoint:
20362	Text.Op = PrintName("FlipSint32FixedPoint");
20363	break;
20364	case OP_FlipSint32Ptr:
20365	Text.Op = PrintName("FlipSint32Ptr");
20366	break;
20367	case OP_FlipSint32MemberPtr:
20368	Text.Op = PrintName("FlipSint32MemberPtr");
20369	break;
20370	case OP_FlipSint32Float:
20371	Text.Op = PrintName("FlipSint32Float");
20372	break;
20373	case OP_FlipUint32Sint8:
20374	Text.Op = PrintName("FlipUint32Sint8");
20375	break;
20376	case OP_FlipUint32Uint8:
20377	Text.Op = PrintName("FlipUint32Uint8");
20378	break;
20379	case OP_FlipUint32Sint16:
20380	Text.Op = PrintName("FlipUint32Sint16");
20381	break;
20382	case OP_FlipUint32Uint16:
20383	Text.Op = PrintName("FlipUint32Uint16");
20384	break;
20385	case OP_FlipUint32Sint32:
20386	Text.Op = PrintName("FlipUint32Sint32");
20387	break;
20388	case OP_FlipUint32Uint32:
20389	Text.Op = PrintName("FlipUint32Uint32");
20390	break;
20391	case OP_FlipUint32Sint64:
20392	Text.Op = PrintName("FlipUint32Sint64");
20393	break;
20394	case OP_FlipUint32Uint64:
20395	Text.Op = PrintName("FlipUint32Uint64");
20396	break;
20397	case OP_FlipUint32IntAP:
20398	Text.Op = PrintName("FlipUint32IntAP");
20399	break;
20400	case OP_FlipUint32IntAPS:
20401	Text.Op = PrintName("FlipUint32IntAPS");
20402	break;
20403	case OP_FlipUint32Bool:
20404	Text.Op = PrintName("FlipUint32Bool");
20405	break;
20406	case OP_FlipUint32FixedPoint:
20407	Text.Op = PrintName("FlipUint32FixedPoint");
20408	break;
20409	case OP_FlipUint32Ptr:
20410	Text.Op = PrintName("FlipUint32Ptr");
20411	break;
20412	case OP_FlipUint32MemberPtr:
20413	Text.Op = PrintName("FlipUint32MemberPtr");
20414	break;
20415	case OP_FlipUint32Float:
20416	Text.Op = PrintName("FlipUint32Float");
20417	break;
20418	case OP_FlipSint64Sint8:
20419	Text.Op = PrintName("FlipSint64Sint8");
20420	break;
20421	case OP_FlipSint64Uint8:
20422	Text.Op = PrintName("FlipSint64Uint8");
20423	break;
20424	case OP_FlipSint64Sint16:
20425	Text.Op = PrintName("FlipSint64Sint16");
20426	break;
20427	case OP_FlipSint64Uint16:
20428	Text.Op = PrintName("FlipSint64Uint16");
20429	break;
20430	case OP_FlipSint64Sint32:
20431	Text.Op = PrintName("FlipSint64Sint32");
20432	break;
20433	case OP_FlipSint64Uint32:
20434	Text.Op = PrintName("FlipSint64Uint32");
20435	break;
20436	case OP_FlipSint64Sint64:
20437	Text.Op = PrintName("FlipSint64Sint64");
20438	break;
20439	case OP_FlipSint64Uint64:
20440	Text.Op = PrintName("FlipSint64Uint64");
20441	break;
20442	case OP_FlipSint64IntAP:
20443	Text.Op = PrintName("FlipSint64IntAP");
20444	break;
20445	case OP_FlipSint64IntAPS:
20446	Text.Op = PrintName("FlipSint64IntAPS");
20447	break;
20448	case OP_FlipSint64Bool:
20449	Text.Op = PrintName("FlipSint64Bool");
20450	break;
20451	case OP_FlipSint64FixedPoint:
20452	Text.Op = PrintName("FlipSint64FixedPoint");
20453	break;
20454	case OP_FlipSint64Ptr:
20455	Text.Op = PrintName("FlipSint64Ptr");
20456	break;
20457	case OP_FlipSint64MemberPtr:
20458	Text.Op = PrintName("FlipSint64MemberPtr");
20459	break;
20460	case OP_FlipSint64Float:
20461	Text.Op = PrintName("FlipSint64Float");
20462	break;
20463	case OP_FlipUint64Sint8:
20464	Text.Op = PrintName("FlipUint64Sint8");
20465	break;
20466	case OP_FlipUint64Uint8:
20467	Text.Op = PrintName("FlipUint64Uint8");
20468	break;
20469	case OP_FlipUint64Sint16:
20470	Text.Op = PrintName("FlipUint64Sint16");
20471	break;
20472	case OP_FlipUint64Uint16:
20473	Text.Op = PrintName("FlipUint64Uint16");
20474	break;
20475	case OP_FlipUint64Sint32:
20476	Text.Op = PrintName("FlipUint64Sint32");
20477	break;
20478	case OP_FlipUint64Uint32:
20479	Text.Op = PrintName("FlipUint64Uint32");
20480	break;
20481	case OP_FlipUint64Sint64:
20482	Text.Op = PrintName("FlipUint64Sint64");
20483	break;
20484	case OP_FlipUint64Uint64:
20485	Text.Op = PrintName("FlipUint64Uint64");
20486	break;
20487	case OP_FlipUint64IntAP:
20488	Text.Op = PrintName("FlipUint64IntAP");
20489	break;
20490	case OP_FlipUint64IntAPS:
20491	Text.Op = PrintName("FlipUint64IntAPS");
20492	break;
20493	case OP_FlipUint64Bool:
20494	Text.Op = PrintName("FlipUint64Bool");
20495	break;
20496	case OP_FlipUint64FixedPoint:
20497	Text.Op = PrintName("FlipUint64FixedPoint");
20498	break;
20499	case OP_FlipUint64Ptr:
20500	Text.Op = PrintName("FlipUint64Ptr");
20501	break;
20502	case OP_FlipUint64MemberPtr:
20503	Text.Op = PrintName("FlipUint64MemberPtr");
20504	break;
20505	case OP_FlipUint64Float:
20506	Text.Op = PrintName("FlipUint64Float");
20507	break;
20508	case OP_FlipIntAPSint8:
20509	Text.Op = PrintName("FlipIntAPSint8");
20510	break;
20511	case OP_FlipIntAPUint8:
20512	Text.Op = PrintName("FlipIntAPUint8");
20513	break;
20514	case OP_FlipIntAPSint16:
20515	Text.Op = PrintName("FlipIntAPSint16");
20516	break;
20517	case OP_FlipIntAPUint16:
20518	Text.Op = PrintName("FlipIntAPUint16");
20519	break;
20520	case OP_FlipIntAPSint32:
20521	Text.Op = PrintName("FlipIntAPSint32");
20522	break;
20523	case OP_FlipIntAPUint32:
20524	Text.Op = PrintName("FlipIntAPUint32");
20525	break;
20526	case OP_FlipIntAPSint64:
20527	Text.Op = PrintName("FlipIntAPSint64");
20528	break;
20529	case OP_FlipIntAPUint64:
20530	Text.Op = PrintName("FlipIntAPUint64");
20531	break;
20532	case OP_FlipIntAPIntAP:
20533	Text.Op = PrintName("FlipIntAPIntAP");
20534	break;
20535	case OP_FlipIntAPIntAPS:
20536	Text.Op = PrintName("FlipIntAPIntAPS");
20537	break;
20538	case OP_FlipIntAPBool:
20539	Text.Op = PrintName("FlipIntAPBool");
20540	break;
20541	case OP_FlipIntAPFixedPoint:
20542	Text.Op = PrintName("FlipIntAPFixedPoint");
20543	break;
20544	case OP_FlipIntAPPtr:
20545	Text.Op = PrintName("FlipIntAPPtr");
20546	break;
20547	case OP_FlipIntAPMemberPtr:
20548	Text.Op = PrintName("FlipIntAPMemberPtr");
20549	break;
20550	case OP_FlipIntAPFloat:
20551	Text.Op = PrintName("FlipIntAPFloat");
20552	break;
20553	case OP_FlipIntAPSSint8:
20554	Text.Op = PrintName("FlipIntAPSSint8");
20555	break;
20556	case OP_FlipIntAPSUint8:
20557	Text.Op = PrintName("FlipIntAPSUint8");
20558	break;
20559	case OP_FlipIntAPSSint16:
20560	Text.Op = PrintName("FlipIntAPSSint16");
20561	break;
20562	case OP_FlipIntAPSUint16:
20563	Text.Op = PrintName("FlipIntAPSUint16");
20564	break;
20565	case OP_FlipIntAPSSint32:
20566	Text.Op = PrintName("FlipIntAPSSint32");
20567	break;
20568	case OP_FlipIntAPSUint32:
20569	Text.Op = PrintName("FlipIntAPSUint32");
20570	break;
20571	case OP_FlipIntAPSSint64:
20572	Text.Op = PrintName("FlipIntAPSSint64");
20573	break;
20574	case OP_FlipIntAPSUint64:
20575	Text.Op = PrintName("FlipIntAPSUint64");
20576	break;
20577	case OP_FlipIntAPSIntAP:
20578	Text.Op = PrintName("FlipIntAPSIntAP");
20579	break;
20580	case OP_FlipIntAPSIntAPS:
20581	Text.Op = PrintName("FlipIntAPSIntAPS");
20582	break;
20583	case OP_FlipIntAPSBool:
20584	Text.Op = PrintName("FlipIntAPSBool");
20585	break;
20586	case OP_FlipIntAPSFixedPoint:
20587	Text.Op = PrintName("FlipIntAPSFixedPoint");
20588	break;
20589	case OP_FlipIntAPSPtr:
20590	Text.Op = PrintName("FlipIntAPSPtr");
20591	break;
20592	case OP_FlipIntAPSMemberPtr:
20593	Text.Op = PrintName("FlipIntAPSMemberPtr");
20594	break;
20595	case OP_FlipIntAPSFloat:
20596	Text.Op = PrintName("FlipIntAPSFloat");
20597	break;
20598	case OP_FlipBoolSint8:
20599	Text.Op = PrintName("FlipBoolSint8");
20600	break;
20601	case OP_FlipBoolUint8:
20602	Text.Op = PrintName("FlipBoolUint8");
20603	break;
20604	case OP_FlipBoolSint16:
20605	Text.Op = PrintName("FlipBoolSint16");
20606	break;
20607	case OP_FlipBoolUint16:
20608	Text.Op = PrintName("FlipBoolUint16");
20609	break;
20610	case OP_FlipBoolSint32:
20611	Text.Op = PrintName("FlipBoolSint32");
20612	break;
20613	case OP_FlipBoolUint32:
20614	Text.Op = PrintName("FlipBoolUint32");
20615	break;
20616	case OP_FlipBoolSint64:
20617	Text.Op = PrintName("FlipBoolSint64");
20618	break;
20619	case OP_FlipBoolUint64:
20620	Text.Op = PrintName("FlipBoolUint64");
20621	break;
20622	case OP_FlipBoolIntAP:
20623	Text.Op = PrintName("FlipBoolIntAP");
20624	break;
20625	case OP_FlipBoolIntAPS:
20626	Text.Op = PrintName("FlipBoolIntAPS");
20627	break;
20628	case OP_FlipBoolBool:
20629	Text.Op = PrintName("FlipBoolBool");
20630	break;
20631	case OP_FlipBoolFixedPoint:
20632	Text.Op = PrintName("FlipBoolFixedPoint");
20633	break;
20634	case OP_FlipBoolPtr:
20635	Text.Op = PrintName("FlipBoolPtr");
20636	break;
20637	case OP_FlipBoolMemberPtr:
20638	Text.Op = PrintName("FlipBoolMemberPtr");
20639	break;
20640	case OP_FlipBoolFloat:
20641	Text.Op = PrintName("FlipBoolFloat");
20642	break;
20643	case OP_FlipFixedPointSint8:
20644	Text.Op = PrintName("FlipFixedPointSint8");
20645	break;
20646	case OP_FlipFixedPointUint8:
20647	Text.Op = PrintName("FlipFixedPointUint8");
20648	break;
20649	case OP_FlipFixedPointSint16:
20650	Text.Op = PrintName("FlipFixedPointSint16");
20651	break;
20652	case OP_FlipFixedPointUint16:
20653	Text.Op = PrintName("FlipFixedPointUint16");
20654	break;
20655	case OP_FlipFixedPointSint32:
20656	Text.Op = PrintName("FlipFixedPointSint32");
20657	break;
20658	case OP_FlipFixedPointUint32:
20659	Text.Op = PrintName("FlipFixedPointUint32");
20660	break;
20661	case OP_FlipFixedPointSint64:
20662	Text.Op = PrintName("FlipFixedPointSint64");
20663	break;
20664	case OP_FlipFixedPointUint64:
20665	Text.Op = PrintName("FlipFixedPointUint64");
20666	break;
20667	case OP_FlipFixedPointIntAP:
20668	Text.Op = PrintName("FlipFixedPointIntAP");
20669	break;
20670	case OP_FlipFixedPointIntAPS:
20671	Text.Op = PrintName("FlipFixedPointIntAPS");
20672	break;
20673	case OP_FlipFixedPointBool:
20674	Text.Op = PrintName("FlipFixedPointBool");
20675	break;
20676	case OP_FlipFixedPointFixedPoint:
20677	Text.Op = PrintName("FlipFixedPointFixedPoint");
20678	break;
20679	case OP_FlipFixedPointPtr:
20680	Text.Op = PrintName("FlipFixedPointPtr");
20681	break;
20682	case OP_FlipFixedPointMemberPtr:
20683	Text.Op = PrintName("FlipFixedPointMemberPtr");
20684	break;
20685	case OP_FlipFixedPointFloat:
20686	Text.Op = PrintName("FlipFixedPointFloat");
20687	break;
20688	case OP_FlipPtrSint8:
20689	Text.Op = PrintName("FlipPtrSint8");
20690	break;
20691	case OP_FlipPtrUint8:
20692	Text.Op = PrintName("FlipPtrUint8");
20693	break;
20694	case OP_FlipPtrSint16:
20695	Text.Op = PrintName("FlipPtrSint16");
20696	break;
20697	case OP_FlipPtrUint16:
20698	Text.Op = PrintName("FlipPtrUint16");
20699	break;
20700	case OP_FlipPtrSint32:
20701	Text.Op = PrintName("FlipPtrSint32");
20702	break;
20703	case OP_FlipPtrUint32:
20704	Text.Op = PrintName("FlipPtrUint32");
20705	break;
20706	case OP_FlipPtrSint64:
20707	Text.Op = PrintName("FlipPtrSint64");
20708	break;
20709	case OP_FlipPtrUint64:
20710	Text.Op = PrintName("FlipPtrUint64");
20711	break;
20712	case OP_FlipPtrIntAP:
20713	Text.Op = PrintName("FlipPtrIntAP");
20714	break;
20715	case OP_FlipPtrIntAPS:
20716	Text.Op = PrintName("FlipPtrIntAPS");
20717	break;
20718	case OP_FlipPtrBool:
20719	Text.Op = PrintName("FlipPtrBool");
20720	break;
20721	case OP_FlipPtrFixedPoint:
20722	Text.Op = PrintName("FlipPtrFixedPoint");
20723	break;
20724	case OP_FlipPtrPtr:
20725	Text.Op = PrintName("FlipPtrPtr");
20726	break;
20727	case OP_FlipPtrMemberPtr:
20728	Text.Op = PrintName("FlipPtrMemberPtr");
20729	break;
20730	case OP_FlipPtrFloat:
20731	Text.Op = PrintName("FlipPtrFloat");
20732	break;
20733	case OP_FlipMemberPtrSint8:
20734	Text.Op = PrintName("FlipMemberPtrSint8");
20735	break;
20736	case OP_FlipMemberPtrUint8:
20737	Text.Op = PrintName("FlipMemberPtrUint8");
20738	break;
20739	case OP_FlipMemberPtrSint16:
20740	Text.Op = PrintName("FlipMemberPtrSint16");
20741	break;
20742	case OP_FlipMemberPtrUint16:
20743	Text.Op = PrintName("FlipMemberPtrUint16");
20744	break;
20745	case OP_FlipMemberPtrSint32:
20746	Text.Op = PrintName("FlipMemberPtrSint32");
20747	break;
20748	case OP_FlipMemberPtrUint32:
20749	Text.Op = PrintName("FlipMemberPtrUint32");
20750	break;
20751	case OP_FlipMemberPtrSint64:
20752	Text.Op = PrintName("FlipMemberPtrSint64");
20753	break;
20754	case OP_FlipMemberPtrUint64:
20755	Text.Op = PrintName("FlipMemberPtrUint64");
20756	break;
20757	case OP_FlipMemberPtrIntAP:
20758	Text.Op = PrintName("FlipMemberPtrIntAP");
20759	break;
20760	case OP_FlipMemberPtrIntAPS:
20761	Text.Op = PrintName("FlipMemberPtrIntAPS");
20762	break;
20763	case OP_FlipMemberPtrBool:
20764	Text.Op = PrintName("FlipMemberPtrBool");
20765	break;
20766	case OP_FlipMemberPtrFixedPoint:
20767	Text.Op = PrintName("FlipMemberPtrFixedPoint");
20768	break;
20769	case OP_FlipMemberPtrPtr:
20770	Text.Op = PrintName("FlipMemberPtrPtr");
20771	break;
20772	case OP_FlipMemberPtrMemberPtr:
20773	Text.Op = PrintName("FlipMemberPtrMemberPtr");
20774	break;
20775	case OP_FlipMemberPtrFloat:
20776	Text.Op = PrintName("FlipMemberPtrFloat");
20777	break;
20778	case OP_FlipFloatSint8:
20779	Text.Op = PrintName("FlipFloatSint8");
20780	break;
20781	case OP_FlipFloatUint8:
20782	Text.Op = PrintName("FlipFloatUint8");
20783	break;
20784	case OP_FlipFloatSint16:
20785	Text.Op = PrintName("FlipFloatSint16");
20786	break;
20787	case OP_FlipFloatUint16:
20788	Text.Op = PrintName("FlipFloatUint16");
20789	break;
20790	case OP_FlipFloatSint32:
20791	Text.Op = PrintName("FlipFloatSint32");
20792	break;
20793	case OP_FlipFloatUint32:
20794	Text.Op = PrintName("FlipFloatUint32");
20795	break;
20796	case OP_FlipFloatSint64:
20797	Text.Op = PrintName("FlipFloatSint64");
20798	break;
20799	case OP_FlipFloatUint64:
20800	Text.Op = PrintName("FlipFloatUint64");
20801	break;
20802	case OP_FlipFloatIntAP:
20803	Text.Op = PrintName("FlipFloatIntAP");
20804	break;
20805	case OP_FlipFloatIntAPS:
20806	Text.Op = PrintName("FlipFloatIntAPS");
20807	break;
20808	case OP_FlipFloatBool:
20809	Text.Op = PrintName("FlipFloatBool");
20810	break;
20811	case OP_FlipFloatFixedPoint:
20812	Text.Op = PrintName("FlipFloatFixedPoint");
20813	break;
20814	case OP_FlipFloatPtr:
20815	Text.Op = PrintName("FlipFloatPtr");
20816	break;
20817	case OP_FlipFloatMemberPtr:
20818	Text.Op = PrintName("FlipFloatMemberPtr");
20819	break;
20820	case OP_FlipFloatFloat:
20821	Text.Op = PrintName("FlipFloatFloat");
20822	break;
20823	#endif
20824	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
20825	bool emitFlipSint8Sint8(SourceInfo);
20826	bool emitFlipSint8Uint8(SourceInfo);
20827	bool emitFlipSint8Sint16(SourceInfo);
20828	bool emitFlipSint8Uint16(SourceInfo);
20829	bool emitFlipSint8Sint32(SourceInfo);
20830	bool emitFlipSint8Uint32(SourceInfo);
20831	bool emitFlipSint8Sint64(SourceInfo);
20832	bool emitFlipSint8Uint64(SourceInfo);
20833	bool emitFlipSint8IntAP(SourceInfo);
20834	bool emitFlipSint8IntAPS(SourceInfo);
20835	bool emitFlipSint8Bool(SourceInfo);
20836	bool emitFlipSint8FixedPoint(SourceInfo);
20837	bool emitFlipSint8Ptr(SourceInfo);
20838	bool emitFlipSint8MemberPtr(SourceInfo);
20839	bool emitFlipSint8Float(SourceInfo);
20840	bool emitFlipUint8Sint8(SourceInfo);
20841	bool emitFlipUint8Uint8(SourceInfo);
20842	bool emitFlipUint8Sint16(SourceInfo);
20843	bool emitFlipUint8Uint16(SourceInfo);
20844	bool emitFlipUint8Sint32(SourceInfo);
20845	bool emitFlipUint8Uint32(SourceInfo);
20846	bool emitFlipUint8Sint64(SourceInfo);
20847	bool emitFlipUint8Uint64(SourceInfo);
20848	bool emitFlipUint8IntAP(SourceInfo);
20849	bool emitFlipUint8IntAPS(SourceInfo);
20850	bool emitFlipUint8Bool(SourceInfo);
20851	bool emitFlipUint8FixedPoint(SourceInfo);
20852	bool emitFlipUint8Ptr(SourceInfo);
20853	bool emitFlipUint8MemberPtr(SourceInfo);
20854	bool emitFlipUint8Float(SourceInfo);
20855	bool emitFlipSint16Sint8(SourceInfo);
20856	bool emitFlipSint16Uint8(SourceInfo);
20857	bool emitFlipSint16Sint16(SourceInfo);
20858	bool emitFlipSint16Uint16(SourceInfo);
20859	bool emitFlipSint16Sint32(SourceInfo);
20860	bool emitFlipSint16Uint32(SourceInfo);
20861	bool emitFlipSint16Sint64(SourceInfo);
20862	bool emitFlipSint16Uint64(SourceInfo);
20863	bool emitFlipSint16IntAP(SourceInfo);
20864	bool emitFlipSint16IntAPS(SourceInfo);
20865	bool emitFlipSint16Bool(SourceInfo);
20866	bool emitFlipSint16FixedPoint(SourceInfo);
20867	bool emitFlipSint16Ptr(SourceInfo);
20868	bool emitFlipSint16MemberPtr(SourceInfo);
20869	bool emitFlipSint16Float(SourceInfo);
20870	bool emitFlipUint16Sint8(SourceInfo);
20871	bool emitFlipUint16Uint8(SourceInfo);
20872	bool emitFlipUint16Sint16(SourceInfo);
20873	bool emitFlipUint16Uint16(SourceInfo);
20874	bool emitFlipUint16Sint32(SourceInfo);
20875	bool emitFlipUint16Uint32(SourceInfo);
20876	bool emitFlipUint16Sint64(SourceInfo);
20877	bool emitFlipUint16Uint64(SourceInfo);
20878	bool emitFlipUint16IntAP(SourceInfo);
20879	bool emitFlipUint16IntAPS(SourceInfo);
20880	bool emitFlipUint16Bool(SourceInfo);
20881	bool emitFlipUint16FixedPoint(SourceInfo);
20882	bool emitFlipUint16Ptr(SourceInfo);
20883	bool emitFlipUint16MemberPtr(SourceInfo);
20884	bool emitFlipUint16Float(SourceInfo);
20885	bool emitFlipSint32Sint8(SourceInfo);
20886	bool emitFlipSint32Uint8(SourceInfo);
20887	bool emitFlipSint32Sint16(SourceInfo);
20888	bool emitFlipSint32Uint16(SourceInfo);
20889	bool emitFlipSint32Sint32(SourceInfo);
20890	bool emitFlipSint32Uint32(SourceInfo);
20891	bool emitFlipSint32Sint64(SourceInfo);
20892	bool emitFlipSint32Uint64(SourceInfo);
20893	bool emitFlipSint32IntAP(SourceInfo);
20894	bool emitFlipSint32IntAPS(SourceInfo);
20895	bool emitFlipSint32Bool(SourceInfo);
20896	bool emitFlipSint32FixedPoint(SourceInfo);
20897	bool emitFlipSint32Ptr(SourceInfo);
20898	bool emitFlipSint32MemberPtr(SourceInfo);
20899	bool emitFlipSint32Float(SourceInfo);
20900	bool emitFlipUint32Sint8(SourceInfo);
20901	bool emitFlipUint32Uint8(SourceInfo);
20902	bool emitFlipUint32Sint16(SourceInfo);
20903	bool emitFlipUint32Uint16(SourceInfo);
20904	bool emitFlipUint32Sint32(SourceInfo);
20905	bool emitFlipUint32Uint32(SourceInfo);
20906	bool emitFlipUint32Sint64(SourceInfo);
20907	bool emitFlipUint32Uint64(SourceInfo);
20908	bool emitFlipUint32IntAP(SourceInfo);
20909	bool emitFlipUint32IntAPS(SourceInfo);
20910	bool emitFlipUint32Bool(SourceInfo);
20911	bool emitFlipUint32FixedPoint(SourceInfo);
20912	bool emitFlipUint32Ptr(SourceInfo);
20913	bool emitFlipUint32MemberPtr(SourceInfo);
20914	bool emitFlipUint32Float(SourceInfo);
20915	bool emitFlipSint64Sint8(SourceInfo);
20916	bool emitFlipSint64Uint8(SourceInfo);
20917	bool emitFlipSint64Sint16(SourceInfo);
20918	bool emitFlipSint64Uint16(SourceInfo);
20919	bool emitFlipSint64Sint32(SourceInfo);
20920	bool emitFlipSint64Uint32(SourceInfo);
20921	bool emitFlipSint64Sint64(SourceInfo);
20922	bool emitFlipSint64Uint64(SourceInfo);
20923	bool emitFlipSint64IntAP(SourceInfo);
20924	bool emitFlipSint64IntAPS(SourceInfo);
20925	bool emitFlipSint64Bool(SourceInfo);
20926	bool emitFlipSint64FixedPoint(SourceInfo);
20927	bool emitFlipSint64Ptr(SourceInfo);
20928	bool emitFlipSint64MemberPtr(SourceInfo);
20929	bool emitFlipSint64Float(SourceInfo);
20930	bool emitFlipUint64Sint8(SourceInfo);
20931	bool emitFlipUint64Uint8(SourceInfo);
20932	bool emitFlipUint64Sint16(SourceInfo);
20933	bool emitFlipUint64Uint16(SourceInfo);
20934	bool emitFlipUint64Sint32(SourceInfo);
20935	bool emitFlipUint64Uint32(SourceInfo);
20936	bool emitFlipUint64Sint64(SourceInfo);
20937	bool emitFlipUint64Uint64(SourceInfo);
20938	bool emitFlipUint64IntAP(SourceInfo);
20939	bool emitFlipUint64IntAPS(SourceInfo);
20940	bool emitFlipUint64Bool(SourceInfo);
20941	bool emitFlipUint64FixedPoint(SourceInfo);
20942	bool emitFlipUint64Ptr(SourceInfo);
20943	bool emitFlipUint64MemberPtr(SourceInfo);
20944	bool emitFlipUint64Float(SourceInfo);
20945	bool emitFlipIntAPSint8(SourceInfo);
20946	bool emitFlipIntAPUint8(SourceInfo);
20947	bool emitFlipIntAPSint16(SourceInfo);
20948	bool emitFlipIntAPUint16(SourceInfo);
20949	bool emitFlipIntAPSint32(SourceInfo);
20950	bool emitFlipIntAPUint32(SourceInfo);
20951	bool emitFlipIntAPSint64(SourceInfo);
20952	bool emitFlipIntAPUint64(SourceInfo);
20953	bool emitFlipIntAPIntAP(SourceInfo);
20954	bool emitFlipIntAPIntAPS(SourceInfo);
20955	bool emitFlipIntAPBool(SourceInfo);
20956	bool emitFlipIntAPFixedPoint(SourceInfo);
20957	bool emitFlipIntAPPtr(SourceInfo);
20958	bool emitFlipIntAPMemberPtr(SourceInfo);
20959	bool emitFlipIntAPFloat(SourceInfo);
20960	bool emitFlipIntAPSSint8(SourceInfo);
20961	bool emitFlipIntAPSUint8(SourceInfo);
20962	bool emitFlipIntAPSSint16(SourceInfo);
20963	bool emitFlipIntAPSUint16(SourceInfo);
20964	bool emitFlipIntAPSSint32(SourceInfo);
20965	bool emitFlipIntAPSUint32(SourceInfo);
20966	bool emitFlipIntAPSSint64(SourceInfo);
20967	bool emitFlipIntAPSUint64(SourceInfo);
20968	bool emitFlipIntAPSIntAP(SourceInfo);
20969	bool emitFlipIntAPSIntAPS(SourceInfo);
20970	bool emitFlipIntAPSBool(SourceInfo);
20971	bool emitFlipIntAPSFixedPoint(SourceInfo);
20972	bool emitFlipIntAPSPtr(SourceInfo);
20973	bool emitFlipIntAPSMemberPtr(SourceInfo);
20974	bool emitFlipIntAPSFloat(SourceInfo);
20975	bool emitFlipBoolSint8(SourceInfo);
20976	bool emitFlipBoolUint8(SourceInfo);
20977	bool emitFlipBoolSint16(SourceInfo);
20978	bool emitFlipBoolUint16(SourceInfo);
20979	bool emitFlipBoolSint32(SourceInfo);
20980	bool emitFlipBoolUint32(SourceInfo);
20981	bool emitFlipBoolSint64(SourceInfo);
20982	bool emitFlipBoolUint64(SourceInfo);
20983	bool emitFlipBoolIntAP(SourceInfo);
20984	bool emitFlipBoolIntAPS(SourceInfo);
20985	bool emitFlipBoolBool(SourceInfo);
20986	bool emitFlipBoolFixedPoint(SourceInfo);
20987	bool emitFlipBoolPtr(SourceInfo);
20988	bool emitFlipBoolMemberPtr(SourceInfo);
20989	bool emitFlipBoolFloat(SourceInfo);
20990	bool emitFlipFixedPointSint8(SourceInfo);
20991	bool emitFlipFixedPointUint8(SourceInfo);
20992	bool emitFlipFixedPointSint16(SourceInfo);
20993	bool emitFlipFixedPointUint16(SourceInfo);
20994	bool emitFlipFixedPointSint32(SourceInfo);
20995	bool emitFlipFixedPointUint32(SourceInfo);
20996	bool emitFlipFixedPointSint64(SourceInfo);
20997	bool emitFlipFixedPointUint64(SourceInfo);
20998	bool emitFlipFixedPointIntAP(SourceInfo);
20999	bool emitFlipFixedPointIntAPS(SourceInfo);
21000	bool emitFlipFixedPointBool(SourceInfo);
21001	bool emitFlipFixedPointFixedPoint(SourceInfo);
21002	bool emitFlipFixedPointPtr(SourceInfo);
21003	bool emitFlipFixedPointMemberPtr(SourceInfo);
21004	bool emitFlipFixedPointFloat(SourceInfo);
21005	bool emitFlipPtrSint8(SourceInfo);
21006	bool emitFlipPtrUint8(SourceInfo);
21007	bool emitFlipPtrSint16(SourceInfo);
21008	bool emitFlipPtrUint16(SourceInfo);
21009	bool emitFlipPtrSint32(SourceInfo);
21010	bool emitFlipPtrUint32(SourceInfo);
21011	bool emitFlipPtrSint64(SourceInfo);
21012	bool emitFlipPtrUint64(SourceInfo);
21013	bool emitFlipPtrIntAP(SourceInfo);
21014	bool emitFlipPtrIntAPS(SourceInfo);
21015	bool emitFlipPtrBool(SourceInfo);
21016	bool emitFlipPtrFixedPoint(SourceInfo);
21017	bool emitFlipPtrPtr(SourceInfo);
21018	bool emitFlipPtrMemberPtr(SourceInfo);
21019	bool emitFlipPtrFloat(SourceInfo);
21020	bool emitFlipMemberPtrSint8(SourceInfo);
21021	bool emitFlipMemberPtrUint8(SourceInfo);
21022	bool emitFlipMemberPtrSint16(SourceInfo);
21023	bool emitFlipMemberPtrUint16(SourceInfo);
21024	bool emitFlipMemberPtrSint32(SourceInfo);
21025	bool emitFlipMemberPtrUint32(SourceInfo);
21026	bool emitFlipMemberPtrSint64(SourceInfo);
21027	bool emitFlipMemberPtrUint64(SourceInfo);
21028	bool emitFlipMemberPtrIntAP(SourceInfo);
21029	bool emitFlipMemberPtrIntAPS(SourceInfo);
21030	bool emitFlipMemberPtrBool(SourceInfo);
21031	bool emitFlipMemberPtrFixedPoint(SourceInfo);
21032	bool emitFlipMemberPtrPtr(SourceInfo);
21033	bool emitFlipMemberPtrMemberPtr(SourceInfo);
21034	bool emitFlipMemberPtrFloat(SourceInfo);
21035	bool emitFlipFloatSint8(SourceInfo);
21036	bool emitFlipFloatUint8(SourceInfo);
21037	bool emitFlipFloatSint16(SourceInfo);
21038	bool emitFlipFloatUint16(SourceInfo);
21039	bool emitFlipFloatSint32(SourceInfo);
21040	bool emitFlipFloatUint32(SourceInfo);
21041	bool emitFlipFloatSint64(SourceInfo);
21042	bool emitFlipFloatUint64(SourceInfo);
21043	bool emitFlipFloatIntAP(SourceInfo);
21044	bool emitFlipFloatIntAPS(SourceInfo);
21045	bool emitFlipFloatBool(SourceInfo);
21046	bool emitFlipFloatFixedPoint(SourceInfo);
21047	bool emitFlipFloatPtr(SourceInfo);
21048	bool emitFlipFloatMemberPtr(SourceInfo);
21049	bool emitFlipFloatFloat(SourceInfo);
21050	#endif
21051	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
21052	[[nodiscard]] bool emitFlip(PrimType, PrimType, SourceInfo I);
21053	#endif
21054	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
21055	bool
21056	#if defined(GET_EVAL_IMPL)
21057	EvalEmitter
21058	#else
21059	ByteCodeEmitter
21060	#endif
21061	::emitFlip(PrimType T0, PrimType T1, SourceInfo I) {
21062	switch (T0) {
21063	case PT_Sint8:
21064	switch (T1) {
21065	case PT_Sint8:
21066	return emitFlipSint8Sint8(I);
21067	case PT_Uint8:
21068	return emitFlipSint8Uint8(I);
21069	case PT_Sint16:
21070	return emitFlipSint8Sint16(I);
21071	case PT_Uint16:
21072	return emitFlipSint8Uint16(I);
21073	case PT_Sint32:
21074	return emitFlipSint8Sint32(I);
21075	case PT_Uint32:
21076	return emitFlipSint8Uint32(I);
21077	case PT_Sint64:
21078	return emitFlipSint8Sint64(I);
21079	case PT_Uint64:
21080	return emitFlipSint8Uint64(I);
21081	case PT_IntAP:
21082	return emitFlipSint8IntAP(I);
21083	case PT_IntAPS:
21084	return emitFlipSint8IntAPS(I);
21085	case PT_Bool:
21086	return emitFlipSint8Bool(I);
21087	case PT_FixedPoint:
21088	return emitFlipSint8FixedPoint(I);
21089	case PT_Ptr:
21090	return emitFlipSint8Ptr(I);
21091	case PT_MemberPtr:
21092	return emitFlipSint8MemberPtr(I);
21093	case PT_Float:
21094	return emitFlipSint8Float(I);
21095	}
21096	llvm_unreachable("invalid enum value");
21097	case PT_Uint8:
21098	switch (T1) {
21099	case PT_Sint8:
21100	return emitFlipUint8Sint8(I);
21101	case PT_Uint8:
21102	return emitFlipUint8Uint8(I);
21103	case PT_Sint16:
21104	return emitFlipUint8Sint16(I);
21105	case PT_Uint16:
21106	return emitFlipUint8Uint16(I);
21107	case PT_Sint32:
21108	return emitFlipUint8Sint32(I);
21109	case PT_Uint32:
21110	return emitFlipUint8Uint32(I);
21111	case PT_Sint64:
21112	return emitFlipUint8Sint64(I);
21113	case PT_Uint64:
21114	return emitFlipUint8Uint64(I);
21115	case PT_IntAP:
21116	return emitFlipUint8IntAP(I);
21117	case PT_IntAPS:
21118	return emitFlipUint8IntAPS(I);
21119	case PT_Bool:
21120	return emitFlipUint8Bool(I);
21121	case PT_FixedPoint:
21122	return emitFlipUint8FixedPoint(I);
21123	case PT_Ptr:
21124	return emitFlipUint8Ptr(I);
21125	case PT_MemberPtr:
21126	return emitFlipUint8MemberPtr(I);
21127	case PT_Float:
21128	return emitFlipUint8Float(I);
21129	}
21130	llvm_unreachable("invalid enum value");
21131	case PT_Sint16:
21132	switch (T1) {
21133	case PT_Sint8:
21134	return emitFlipSint16Sint8(I);
21135	case PT_Uint8:
21136	return emitFlipSint16Uint8(I);
21137	case PT_Sint16:
21138	return emitFlipSint16Sint16(I);
21139	case PT_Uint16:
21140	return emitFlipSint16Uint16(I);
21141	case PT_Sint32:
21142	return emitFlipSint16Sint32(I);
21143	case PT_Uint32:
21144	return emitFlipSint16Uint32(I);
21145	case PT_Sint64:
21146	return emitFlipSint16Sint64(I);
21147	case PT_Uint64:
21148	return emitFlipSint16Uint64(I);
21149	case PT_IntAP:
21150	return emitFlipSint16IntAP(I);
21151	case PT_IntAPS:
21152	return emitFlipSint16IntAPS(I);
21153	case PT_Bool:
21154	return emitFlipSint16Bool(I);
21155	case PT_FixedPoint:
21156	return emitFlipSint16FixedPoint(I);
21157	case PT_Ptr:
21158	return emitFlipSint16Ptr(I);
21159	case PT_MemberPtr:
21160	return emitFlipSint16MemberPtr(I);
21161	case PT_Float:
21162	return emitFlipSint16Float(I);
21163	}
21164	llvm_unreachable("invalid enum value");
21165	case PT_Uint16:
21166	switch (T1) {
21167	case PT_Sint8:
21168	return emitFlipUint16Sint8(I);
21169	case PT_Uint8:
21170	return emitFlipUint16Uint8(I);
21171	case PT_Sint16:
21172	return emitFlipUint16Sint16(I);
21173	case PT_Uint16:
21174	return emitFlipUint16Uint16(I);
21175	case PT_Sint32:
21176	return emitFlipUint16Sint32(I);
21177	case PT_Uint32:
21178	return emitFlipUint16Uint32(I);
21179	case PT_Sint64:
21180	return emitFlipUint16Sint64(I);
21181	case PT_Uint64:
21182	return emitFlipUint16Uint64(I);
21183	case PT_IntAP:
21184	return emitFlipUint16IntAP(I);
21185	case PT_IntAPS:
21186	return emitFlipUint16IntAPS(I);
21187	case PT_Bool:
21188	return emitFlipUint16Bool(I);
21189	case PT_FixedPoint:
21190	return emitFlipUint16FixedPoint(I);
21191	case PT_Ptr:
21192	return emitFlipUint16Ptr(I);
21193	case PT_MemberPtr:
21194	return emitFlipUint16MemberPtr(I);
21195	case PT_Float:
21196	return emitFlipUint16Float(I);
21197	}
21198	llvm_unreachable("invalid enum value");
21199	case PT_Sint32:
21200	switch (T1) {
21201	case PT_Sint8:
21202	return emitFlipSint32Sint8(I);
21203	case PT_Uint8:
21204	return emitFlipSint32Uint8(I);
21205	case PT_Sint16:
21206	return emitFlipSint32Sint16(I);
21207	case PT_Uint16:
21208	return emitFlipSint32Uint16(I);
21209	case PT_Sint32:
21210	return emitFlipSint32Sint32(I);
21211	case PT_Uint32:
21212	return emitFlipSint32Uint32(I);
21213	case PT_Sint64:
21214	return emitFlipSint32Sint64(I);
21215	case PT_Uint64:
21216	return emitFlipSint32Uint64(I);
21217	case PT_IntAP:
21218	return emitFlipSint32IntAP(I);
21219	case PT_IntAPS:
21220	return emitFlipSint32IntAPS(I);
21221	case PT_Bool:
21222	return emitFlipSint32Bool(I);
21223	case PT_FixedPoint:
21224	return emitFlipSint32FixedPoint(I);
21225	case PT_Ptr:
21226	return emitFlipSint32Ptr(I);
21227	case PT_MemberPtr:
21228	return emitFlipSint32MemberPtr(I);
21229	case PT_Float:
21230	return emitFlipSint32Float(I);
21231	}
21232	llvm_unreachable("invalid enum value");
21233	case PT_Uint32:
21234	switch (T1) {
21235	case PT_Sint8:
21236	return emitFlipUint32Sint8(I);
21237	case PT_Uint8:
21238	return emitFlipUint32Uint8(I);
21239	case PT_Sint16:
21240	return emitFlipUint32Sint16(I);
21241	case PT_Uint16:
21242	return emitFlipUint32Uint16(I);
21243	case PT_Sint32:
21244	return emitFlipUint32Sint32(I);
21245	case PT_Uint32:
21246	return emitFlipUint32Uint32(I);
21247	case PT_Sint64:
21248	return emitFlipUint32Sint64(I);
21249	case PT_Uint64:
21250	return emitFlipUint32Uint64(I);
21251	case PT_IntAP:
21252	return emitFlipUint32IntAP(I);
21253	case PT_IntAPS:
21254	return emitFlipUint32IntAPS(I);
21255	case PT_Bool:
21256	return emitFlipUint32Bool(I);
21257	case PT_FixedPoint:
21258	return emitFlipUint32FixedPoint(I);
21259	case PT_Ptr:
21260	return emitFlipUint32Ptr(I);
21261	case PT_MemberPtr:
21262	return emitFlipUint32MemberPtr(I);
21263	case PT_Float:
21264	return emitFlipUint32Float(I);
21265	}
21266	llvm_unreachable("invalid enum value");
21267	case PT_Sint64:
21268	switch (T1) {
21269	case PT_Sint8:
21270	return emitFlipSint64Sint8(I);
21271	case PT_Uint8:
21272	return emitFlipSint64Uint8(I);
21273	case PT_Sint16:
21274	return emitFlipSint64Sint16(I);
21275	case PT_Uint16:
21276	return emitFlipSint64Uint16(I);
21277	case PT_Sint32:
21278	return emitFlipSint64Sint32(I);
21279	case PT_Uint32:
21280	return emitFlipSint64Uint32(I);
21281	case PT_Sint64:
21282	return emitFlipSint64Sint64(I);
21283	case PT_Uint64:
21284	return emitFlipSint64Uint64(I);
21285	case PT_IntAP:
21286	return emitFlipSint64IntAP(I);
21287	case PT_IntAPS:
21288	return emitFlipSint64IntAPS(I);
21289	case PT_Bool:
21290	return emitFlipSint64Bool(I);
21291	case PT_FixedPoint:
21292	return emitFlipSint64FixedPoint(I);
21293	case PT_Ptr:
21294	return emitFlipSint64Ptr(I);
21295	case PT_MemberPtr:
21296	return emitFlipSint64MemberPtr(I);
21297	case PT_Float:
21298	return emitFlipSint64Float(I);
21299	}
21300	llvm_unreachable("invalid enum value");
21301	case PT_Uint64:
21302	switch (T1) {
21303	case PT_Sint8:
21304	return emitFlipUint64Sint8(I);
21305	case PT_Uint8:
21306	return emitFlipUint64Uint8(I);
21307	case PT_Sint16:
21308	return emitFlipUint64Sint16(I);
21309	case PT_Uint16:
21310	return emitFlipUint64Uint16(I);
21311	case PT_Sint32:
21312	return emitFlipUint64Sint32(I);
21313	case PT_Uint32:
21314	return emitFlipUint64Uint32(I);
21315	case PT_Sint64:
21316	return emitFlipUint64Sint64(I);
21317	case PT_Uint64:
21318	return emitFlipUint64Uint64(I);
21319	case PT_IntAP:
21320	return emitFlipUint64IntAP(I);
21321	case PT_IntAPS:
21322	return emitFlipUint64IntAPS(I);
21323	case PT_Bool:
21324	return emitFlipUint64Bool(I);
21325	case PT_FixedPoint:
21326	return emitFlipUint64FixedPoint(I);
21327	case PT_Ptr:
21328	return emitFlipUint64Ptr(I);
21329	case PT_MemberPtr:
21330	return emitFlipUint64MemberPtr(I);
21331	case PT_Float:
21332	return emitFlipUint64Float(I);
21333	}
21334	llvm_unreachable("invalid enum value");
21335	case PT_IntAP:
21336	switch (T1) {
21337	case PT_Sint8:
21338	return emitFlipIntAPSint8(I);
21339	case PT_Uint8:
21340	return emitFlipIntAPUint8(I);
21341	case PT_Sint16:
21342	return emitFlipIntAPSint16(I);
21343	case PT_Uint16:
21344	return emitFlipIntAPUint16(I);
21345	case PT_Sint32:
21346	return emitFlipIntAPSint32(I);
21347	case PT_Uint32:
21348	return emitFlipIntAPUint32(I);
21349	case PT_Sint64:
21350	return emitFlipIntAPSint64(I);
21351	case PT_Uint64:
21352	return emitFlipIntAPUint64(I);
21353	case PT_IntAP:
21354	return emitFlipIntAPIntAP(I);
21355	case PT_IntAPS:
21356	return emitFlipIntAPIntAPS(I);
21357	case PT_Bool:
21358	return emitFlipIntAPBool(I);
21359	case PT_FixedPoint:
21360	return emitFlipIntAPFixedPoint(I);
21361	case PT_Ptr:
21362	return emitFlipIntAPPtr(I);
21363	case PT_MemberPtr:
21364	return emitFlipIntAPMemberPtr(I);
21365	case PT_Float:
21366	return emitFlipIntAPFloat(I);
21367	}
21368	llvm_unreachable("invalid enum value");
21369	case PT_IntAPS:
21370	switch (T1) {
21371	case PT_Sint8:
21372	return emitFlipIntAPSSint8(I);
21373	case PT_Uint8:
21374	return emitFlipIntAPSUint8(I);
21375	case PT_Sint16:
21376	return emitFlipIntAPSSint16(I);
21377	case PT_Uint16:
21378	return emitFlipIntAPSUint16(I);
21379	case PT_Sint32:
21380	return emitFlipIntAPSSint32(I);
21381	case PT_Uint32:
21382	return emitFlipIntAPSUint32(I);
21383	case PT_Sint64:
21384	return emitFlipIntAPSSint64(I);
21385	case PT_Uint64:
21386	return emitFlipIntAPSUint64(I);
21387	case PT_IntAP:
21388	return emitFlipIntAPSIntAP(I);
21389	case PT_IntAPS:
21390	return emitFlipIntAPSIntAPS(I);
21391	case PT_Bool:
21392	return emitFlipIntAPSBool(I);
21393	case PT_FixedPoint:
21394	return emitFlipIntAPSFixedPoint(I);
21395	case PT_Ptr:
21396	return emitFlipIntAPSPtr(I);
21397	case PT_MemberPtr:
21398	return emitFlipIntAPSMemberPtr(I);
21399	case PT_Float:
21400	return emitFlipIntAPSFloat(I);
21401	}
21402	llvm_unreachable("invalid enum value");
21403	case PT_Bool:
21404	switch (T1) {
21405	case PT_Sint8:
21406	return emitFlipBoolSint8(I);
21407	case PT_Uint8:
21408	return emitFlipBoolUint8(I);
21409	case PT_Sint16:
21410	return emitFlipBoolSint16(I);
21411	case PT_Uint16:
21412	return emitFlipBoolUint16(I);
21413	case PT_Sint32:
21414	return emitFlipBoolSint32(I);
21415	case PT_Uint32:
21416	return emitFlipBoolUint32(I);
21417	case PT_Sint64:
21418	return emitFlipBoolSint64(I);
21419	case PT_Uint64:
21420	return emitFlipBoolUint64(I);
21421	case PT_IntAP:
21422	return emitFlipBoolIntAP(I);
21423	case PT_IntAPS:
21424	return emitFlipBoolIntAPS(I);
21425	case PT_Bool:
21426	return emitFlipBoolBool(I);
21427	case PT_FixedPoint:
21428	return emitFlipBoolFixedPoint(I);
21429	case PT_Ptr:
21430	return emitFlipBoolPtr(I);
21431	case PT_MemberPtr:
21432	return emitFlipBoolMemberPtr(I);
21433	case PT_Float:
21434	return emitFlipBoolFloat(I);
21435	}
21436	llvm_unreachable("invalid enum value");
21437	case PT_FixedPoint:
21438	switch (T1) {
21439	case PT_Sint8:
21440	return emitFlipFixedPointSint8(I);
21441	case PT_Uint8:
21442	return emitFlipFixedPointUint8(I);
21443	case PT_Sint16:
21444	return emitFlipFixedPointSint16(I);
21445	case PT_Uint16:
21446	return emitFlipFixedPointUint16(I);
21447	case PT_Sint32:
21448	return emitFlipFixedPointSint32(I);
21449	case PT_Uint32:
21450	return emitFlipFixedPointUint32(I);
21451	case PT_Sint64:
21452	return emitFlipFixedPointSint64(I);
21453	case PT_Uint64:
21454	return emitFlipFixedPointUint64(I);
21455	case PT_IntAP:
21456	return emitFlipFixedPointIntAP(I);
21457	case PT_IntAPS:
21458	return emitFlipFixedPointIntAPS(I);
21459	case PT_Bool:
21460	return emitFlipFixedPointBool(I);
21461	case PT_FixedPoint:
21462	return emitFlipFixedPointFixedPoint(I);
21463	case PT_Ptr:
21464	return emitFlipFixedPointPtr(I);
21465	case PT_MemberPtr:
21466	return emitFlipFixedPointMemberPtr(I);
21467	case PT_Float:
21468	return emitFlipFixedPointFloat(I);
21469	}
21470	llvm_unreachable("invalid enum value");
21471	case PT_Ptr:
21472	switch (T1) {
21473	case PT_Sint8:
21474	return emitFlipPtrSint8(I);
21475	case PT_Uint8:
21476	return emitFlipPtrUint8(I);
21477	case PT_Sint16:
21478	return emitFlipPtrSint16(I);
21479	case PT_Uint16:
21480	return emitFlipPtrUint16(I);
21481	case PT_Sint32:
21482	return emitFlipPtrSint32(I);
21483	case PT_Uint32:
21484	return emitFlipPtrUint32(I);
21485	case PT_Sint64:
21486	return emitFlipPtrSint64(I);
21487	case PT_Uint64:
21488	return emitFlipPtrUint64(I);
21489	case PT_IntAP:
21490	return emitFlipPtrIntAP(I);
21491	case PT_IntAPS:
21492	return emitFlipPtrIntAPS(I);
21493	case PT_Bool:
21494	return emitFlipPtrBool(I);
21495	case PT_FixedPoint:
21496	return emitFlipPtrFixedPoint(I);
21497	case PT_Ptr:
21498	return emitFlipPtrPtr(I);
21499	case PT_MemberPtr:
21500	return emitFlipPtrMemberPtr(I);
21501	case PT_Float:
21502	return emitFlipPtrFloat(I);
21503	}
21504	llvm_unreachable("invalid enum value");
21505	case PT_MemberPtr:
21506	switch (T1) {
21507	case PT_Sint8:
21508	return emitFlipMemberPtrSint8(I);
21509	case PT_Uint8:
21510	return emitFlipMemberPtrUint8(I);
21511	case PT_Sint16:
21512	return emitFlipMemberPtrSint16(I);
21513	case PT_Uint16:
21514	return emitFlipMemberPtrUint16(I);
21515	case PT_Sint32:
21516	return emitFlipMemberPtrSint32(I);
21517	case PT_Uint32:
21518	return emitFlipMemberPtrUint32(I);
21519	case PT_Sint64:
21520	return emitFlipMemberPtrSint64(I);
21521	case PT_Uint64:
21522	return emitFlipMemberPtrUint64(I);
21523	case PT_IntAP:
21524	return emitFlipMemberPtrIntAP(I);
21525	case PT_IntAPS:
21526	return emitFlipMemberPtrIntAPS(I);
21527	case PT_Bool:
21528	return emitFlipMemberPtrBool(I);
21529	case PT_FixedPoint:
21530	return emitFlipMemberPtrFixedPoint(I);
21531	case PT_Ptr:
21532	return emitFlipMemberPtrPtr(I);
21533	case PT_MemberPtr:
21534	return emitFlipMemberPtrMemberPtr(I);
21535	case PT_Float:
21536	return emitFlipMemberPtrFloat(I);
21537	}
21538	llvm_unreachable("invalid enum value");
21539	case PT_Float:
21540	switch (T1) {
21541	case PT_Sint8:
21542	return emitFlipFloatSint8(I);
21543	case PT_Uint8:
21544	return emitFlipFloatUint8(I);
21545	case PT_Sint16:
21546	return emitFlipFloatSint16(I);
21547	case PT_Uint16:
21548	return emitFlipFloatUint16(I);
21549	case PT_Sint32:
21550	return emitFlipFloatSint32(I);
21551	case PT_Uint32:
21552	return emitFlipFloatUint32(I);
21553	case PT_Sint64:
21554	return emitFlipFloatSint64(I);
21555	case PT_Uint64:
21556	return emitFlipFloatUint64(I);
21557	case PT_IntAP:
21558	return emitFlipFloatIntAP(I);
21559	case PT_IntAPS:
21560	return emitFlipFloatIntAPS(I);
21561	case PT_Bool:
21562	return emitFlipFloatBool(I);
21563	case PT_FixedPoint:
21564	return emitFlipFloatFixedPoint(I);
21565	case PT_Ptr:
21566	return emitFlipFloatPtr(I);
21567	case PT_MemberPtr:
21568	return emitFlipFloatMemberPtr(I);
21569	case PT_Float:
21570	return emitFlipFloatFloat(I);
21571	}
21572	llvm_unreachable("invalid enum value");
21573	}
21574	llvm_unreachable("invalid enum value");
21575	}
21576	#endif
21577	#ifdef GET_LINK_IMPL
21578	bool ByteCodeEmitter::emitFlipSint8Sint8(SourceInfo L) {
21579	return emitOp<>(OP_FlipSint8Sint8, L);
21580	}
21581	bool ByteCodeEmitter::emitFlipSint8Uint8(SourceInfo L) {
21582	return emitOp<>(OP_FlipSint8Uint8, L);
21583	}
21584	bool ByteCodeEmitter::emitFlipSint8Sint16(SourceInfo L) {
21585	return emitOp<>(OP_FlipSint8Sint16, L);
21586	}
21587	bool ByteCodeEmitter::emitFlipSint8Uint16(SourceInfo L) {
21588	return emitOp<>(OP_FlipSint8Uint16, L);
21589	}
21590	bool ByteCodeEmitter::emitFlipSint8Sint32(SourceInfo L) {
21591	return emitOp<>(OP_FlipSint8Sint32, L);
21592	}
21593	bool ByteCodeEmitter::emitFlipSint8Uint32(SourceInfo L) {
21594	return emitOp<>(OP_FlipSint8Uint32, L);
21595	}
21596	bool ByteCodeEmitter::emitFlipSint8Sint64(SourceInfo L) {
21597	return emitOp<>(OP_FlipSint8Sint64, L);
21598	}
21599	bool ByteCodeEmitter::emitFlipSint8Uint64(SourceInfo L) {
21600	return emitOp<>(OP_FlipSint8Uint64, L);
21601	}
21602	bool ByteCodeEmitter::emitFlipSint8IntAP(SourceInfo L) {
21603	return emitOp<>(OP_FlipSint8IntAP, L);
21604	}
21605	bool ByteCodeEmitter::emitFlipSint8IntAPS(SourceInfo L) {
21606	return emitOp<>(OP_FlipSint8IntAPS, L);
21607	}
21608	bool ByteCodeEmitter::emitFlipSint8Bool(SourceInfo L) {
21609	return emitOp<>(OP_FlipSint8Bool, L);
21610	}
21611	bool ByteCodeEmitter::emitFlipSint8FixedPoint(SourceInfo L) {
21612	return emitOp<>(OP_FlipSint8FixedPoint, L);
21613	}
21614	bool ByteCodeEmitter::emitFlipSint8Ptr(SourceInfo L) {
21615	return emitOp<>(OP_FlipSint8Ptr, L);
21616	}
21617	bool ByteCodeEmitter::emitFlipSint8MemberPtr(SourceInfo L) {
21618	return emitOp<>(OP_FlipSint8MemberPtr, L);
21619	}
21620	bool ByteCodeEmitter::emitFlipSint8Float(SourceInfo L) {
21621	return emitOp<>(OP_FlipSint8Float, L);
21622	}
21623	bool ByteCodeEmitter::emitFlipUint8Sint8(SourceInfo L) {
21624	return emitOp<>(OP_FlipUint8Sint8, L);
21625	}
21626	bool ByteCodeEmitter::emitFlipUint8Uint8(SourceInfo L) {
21627	return emitOp<>(OP_FlipUint8Uint8, L);
21628	}
21629	bool ByteCodeEmitter::emitFlipUint8Sint16(SourceInfo L) {
21630	return emitOp<>(OP_FlipUint8Sint16, L);
21631	}
21632	bool ByteCodeEmitter::emitFlipUint8Uint16(SourceInfo L) {
21633	return emitOp<>(OP_FlipUint8Uint16, L);
21634	}
21635	bool ByteCodeEmitter::emitFlipUint8Sint32(SourceInfo L) {
21636	return emitOp<>(OP_FlipUint8Sint32, L);
21637	}
21638	bool ByteCodeEmitter::emitFlipUint8Uint32(SourceInfo L) {
21639	return emitOp<>(OP_FlipUint8Uint32, L);
21640	}
21641	bool ByteCodeEmitter::emitFlipUint8Sint64(SourceInfo L) {
21642	return emitOp<>(OP_FlipUint8Sint64, L);
21643	}
21644	bool ByteCodeEmitter::emitFlipUint8Uint64(SourceInfo L) {
21645	return emitOp<>(OP_FlipUint8Uint64, L);
21646	}
21647	bool ByteCodeEmitter::emitFlipUint8IntAP(SourceInfo L) {
21648	return emitOp<>(OP_FlipUint8IntAP, L);
21649	}
21650	bool ByteCodeEmitter::emitFlipUint8IntAPS(SourceInfo L) {
21651	return emitOp<>(OP_FlipUint8IntAPS, L);
21652	}
21653	bool ByteCodeEmitter::emitFlipUint8Bool(SourceInfo L) {
21654	return emitOp<>(OP_FlipUint8Bool, L);
21655	}
21656	bool ByteCodeEmitter::emitFlipUint8FixedPoint(SourceInfo L) {
21657	return emitOp<>(OP_FlipUint8FixedPoint, L);
21658	}
21659	bool ByteCodeEmitter::emitFlipUint8Ptr(SourceInfo L) {
21660	return emitOp<>(OP_FlipUint8Ptr, L);
21661	}
21662	bool ByteCodeEmitter::emitFlipUint8MemberPtr(SourceInfo L) {
21663	return emitOp<>(OP_FlipUint8MemberPtr, L);
21664	}
21665	bool ByteCodeEmitter::emitFlipUint8Float(SourceInfo L) {
21666	return emitOp<>(OP_FlipUint8Float, L);
21667	}
21668	bool ByteCodeEmitter::emitFlipSint16Sint8(SourceInfo L) {
21669	return emitOp<>(OP_FlipSint16Sint8, L);
21670	}
21671	bool ByteCodeEmitter::emitFlipSint16Uint8(SourceInfo L) {
21672	return emitOp<>(OP_FlipSint16Uint8, L);
21673	}
21674	bool ByteCodeEmitter::emitFlipSint16Sint16(SourceInfo L) {
21675	return emitOp<>(OP_FlipSint16Sint16, L);
21676	}
21677	bool ByteCodeEmitter::emitFlipSint16Uint16(SourceInfo L) {
21678	return emitOp<>(OP_FlipSint16Uint16, L);
21679	}
21680	bool ByteCodeEmitter::emitFlipSint16Sint32(SourceInfo L) {
21681	return emitOp<>(OP_FlipSint16Sint32, L);
21682	}
21683	bool ByteCodeEmitter::emitFlipSint16Uint32(SourceInfo L) {
21684	return emitOp<>(OP_FlipSint16Uint32, L);
21685	}
21686	bool ByteCodeEmitter::emitFlipSint16Sint64(SourceInfo L) {
21687	return emitOp<>(OP_FlipSint16Sint64, L);
21688	}
21689	bool ByteCodeEmitter::emitFlipSint16Uint64(SourceInfo L) {
21690	return emitOp<>(OP_FlipSint16Uint64, L);
21691	}
21692	bool ByteCodeEmitter::emitFlipSint16IntAP(SourceInfo L) {
21693	return emitOp<>(OP_FlipSint16IntAP, L);
21694	}
21695	bool ByteCodeEmitter::emitFlipSint16IntAPS(SourceInfo L) {
21696	return emitOp<>(OP_FlipSint16IntAPS, L);
21697	}
21698	bool ByteCodeEmitter::emitFlipSint16Bool(SourceInfo L) {
21699	return emitOp<>(OP_FlipSint16Bool, L);
21700	}
21701	bool ByteCodeEmitter::emitFlipSint16FixedPoint(SourceInfo L) {
21702	return emitOp<>(OP_FlipSint16FixedPoint, L);
21703	}
21704	bool ByteCodeEmitter::emitFlipSint16Ptr(SourceInfo L) {
21705	return emitOp<>(OP_FlipSint16Ptr, L);
21706	}
21707	bool ByteCodeEmitter::emitFlipSint16MemberPtr(SourceInfo L) {
21708	return emitOp<>(OP_FlipSint16MemberPtr, L);
21709	}
21710	bool ByteCodeEmitter::emitFlipSint16Float(SourceInfo L) {
21711	return emitOp<>(OP_FlipSint16Float, L);
21712	}
21713	bool ByteCodeEmitter::emitFlipUint16Sint8(SourceInfo L) {
21714	return emitOp<>(OP_FlipUint16Sint8, L);
21715	}
21716	bool ByteCodeEmitter::emitFlipUint16Uint8(SourceInfo L) {
21717	return emitOp<>(OP_FlipUint16Uint8, L);
21718	}
21719	bool ByteCodeEmitter::emitFlipUint16Sint16(SourceInfo L) {
21720	return emitOp<>(OP_FlipUint16Sint16, L);
21721	}
21722	bool ByteCodeEmitter::emitFlipUint16Uint16(SourceInfo L) {
21723	return emitOp<>(OP_FlipUint16Uint16, L);
21724	}
21725	bool ByteCodeEmitter::emitFlipUint16Sint32(SourceInfo L) {
21726	return emitOp<>(OP_FlipUint16Sint32, L);
21727	}
21728	bool ByteCodeEmitter::emitFlipUint16Uint32(SourceInfo L) {
21729	return emitOp<>(OP_FlipUint16Uint32, L);
21730	}
21731	bool ByteCodeEmitter::emitFlipUint16Sint64(SourceInfo L) {
21732	return emitOp<>(OP_FlipUint16Sint64, L);
21733	}
21734	bool ByteCodeEmitter::emitFlipUint16Uint64(SourceInfo L) {
21735	return emitOp<>(OP_FlipUint16Uint64, L);
21736	}
21737	bool ByteCodeEmitter::emitFlipUint16IntAP(SourceInfo L) {
21738	return emitOp<>(OP_FlipUint16IntAP, L);
21739	}
21740	bool ByteCodeEmitter::emitFlipUint16IntAPS(SourceInfo L) {
21741	return emitOp<>(OP_FlipUint16IntAPS, L);
21742	}
21743	bool ByteCodeEmitter::emitFlipUint16Bool(SourceInfo L) {
21744	return emitOp<>(OP_FlipUint16Bool, L);
21745	}
21746	bool ByteCodeEmitter::emitFlipUint16FixedPoint(SourceInfo L) {
21747	return emitOp<>(OP_FlipUint16FixedPoint, L);
21748	}
21749	bool ByteCodeEmitter::emitFlipUint16Ptr(SourceInfo L) {
21750	return emitOp<>(OP_FlipUint16Ptr, L);
21751	}
21752	bool ByteCodeEmitter::emitFlipUint16MemberPtr(SourceInfo L) {
21753	return emitOp<>(OP_FlipUint16MemberPtr, L);
21754	}
21755	bool ByteCodeEmitter::emitFlipUint16Float(SourceInfo L) {
21756	return emitOp<>(OP_FlipUint16Float, L);
21757	}
21758	bool ByteCodeEmitter::emitFlipSint32Sint8(SourceInfo L) {
21759	return emitOp<>(OP_FlipSint32Sint8, L);
21760	}
21761	bool ByteCodeEmitter::emitFlipSint32Uint8(SourceInfo L) {
21762	return emitOp<>(OP_FlipSint32Uint8, L);
21763	}
21764	bool ByteCodeEmitter::emitFlipSint32Sint16(SourceInfo L) {
21765	return emitOp<>(OP_FlipSint32Sint16, L);
21766	}
21767	bool ByteCodeEmitter::emitFlipSint32Uint16(SourceInfo L) {
21768	return emitOp<>(OP_FlipSint32Uint16, L);
21769	}
21770	bool ByteCodeEmitter::emitFlipSint32Sint32(SourceInfo L) {
21771	return emitOp<>(OP_FlipSint32Sint32, L);
21772	}
21773	bool ByteCodeEmitter::emitFlipSint32Uint32(SourceInfo L) {
21774	return emitOp<>(OP_FlipSint32Uint32, L);
21775	}
21776	bool ByteCodeEmitter::emitFlipSint32Sint64(SourceInfo L) {
21777	return emitOp<>(OP_FlipSint32Sint64, L);
21778	}
21779	bool ByteCodeEmitter::emitFlipSint32Uint64(SourceInfo L) {
21780	return emitOp<>(OP_FlipSint32Uint64, L);
21781	}
21782	bool ByteCodeEmitter::emitFlipSint32IntAP(SourceInfo L) {
21783	return emitOp<>(OP_FlipSint32IntAP, L);
21784	}
21785	bool ByteCodeEmitter::emitFlipSint32IntAPS(SourceInfo L) {
21786	return emitOp<>(OP_FlipSint32IntAPS, L);
21787	}
21788	bool ByteCodeEmitter::emitFlipSint32Bool(SourceInfo L) {
21789	return emitOp<>(OP_FlipSint32Bool, L);
21790	}
21791	bool ByteCodeEmitter::emitFlipSint32FixedPoint(SourceInfo L) {
21792	return emitOp<>(OP_FlipSint32FixedPoint, L);
21793	}
21794	bool ByteCodeEmitter::emitFlipSint32Ptr(SourceInfo L) {
21795	return emitOp<>(OP_FlipSint32Ptr, L);
21796	}
21797	bool ByteCodeEmitter::emitFlipSint32MemberPtr(SourceInfo L) {
21798	return emitOp<>(OP_FlipSint32MemberPtr, L);
21799	}
21800	bool ByteCodeEmitter::emitFlipSint32Float(SourceInfo L) {
21801	return emitOp<>(OP_FlipSint32Float, L);
21802	}
21803	bool ByteCodeEmitter::emitFlipUint32Sint8(SourceInfo L) {
21804	return emitOp<>(OP_FlipUint32Sint8, L);
21805	}
21806	bool ByteCodeEmitter::emitFlipUint32Uint8(SourceInfo L) {
21807	return emitOp<>(OP_FlipUint32Uint8, L);
21808	}
21809	bool ByteCodeEmitter::emitFlipUint32Sint16(SourceInfo L) {
21810	return emitOp<>(OP_FlipUint32Sint16, L);
21811	}
21812	bool ByteCodeEmitter::emitFlipUint32Uint16(SourceInfo L) {
21813	return emitOp<>(OP_FlipUint32Uint16, L);
21814	}
21815	bool ByteCodeEmitter::emitFlipUint32Sint32(SourceInfo L) {
21816	return emitOp<>(OP_FlipUint32Sint32, L);
21817	}
21818	bool ByteCodeEmitter::emitFlipUint32Uint32(SourceInfo L) {
21819	return emitOp<>(OP_FlipUint32Uint32, L);
21820	}
21821	bool ByteCodeEmitter::emitFlipUint32Sint64(SourceInfo L) {
21822	return emitOp<>(OP_FlipUint32Sint64, L);
21823	}
21824	bool ByteCodeEmitter::emitFlipUint32Uint64(SourceInfo L) {
21825	return emitOp<>(OP_FlipUint32Uint64, L);
21826	}
21827	bool ByteCodeEmitter::emitFlipUint32IntAP(SourceInfo L) {
21828	return emitOp<>(OP_FlipUint32IntAP, L);
21829	}
21830	bool ByteCodeEmitter::emitFlipUint32IntAPS(SourceInfo L) {
21831	return emitOp<>(OP_FlipUint32IntAPS, L);
21832	}
21833	bool ByteCodeEmitter::emitFlipUint32Bool(SourceInfo L) {
21834	return emitOp<>(OP_FlipUint32Bool, L);
21835	}
21836	bool ByteCodeEmitter::emitFlipUint32FixedPoint(SourceInfo L) {
21837	return emitOp<>(OP_FlipUint32FixedPoint, L);
21838	}
21839	bool ByteCodeEmitter::emitFlipUint32Ptr(SourceInfo L) {
21840	return emitOp<>(OP_FlipUint32Ptr, L);
21841	}
21842	bool ByteCodeEmitter::emitFlipUint32MemberPtr(SourceInfo L) {
21843	return emitOp<>(OP_FlipUint32MemberPtr, L);
21844	}
21845	bool ByteCodeEmitter::emitFlipUint32Float(SourceInfo L) {
21846	return emitOp<>(OP_FlipUint32Float, L);
21847	}
21848	bool ByteCodeEmitter::emitFlipSint64Sint8(SourceInfo L) {
21849	return emitOp<>(OP_FlipSint64Sint8, L);
21850	}
21851	bool ByteCodeEmitter::emitFlipSint64Uint8(SourceInfo L) {
21852	return emitOp<>(OP_FlipSint64Uint8, L);
21853	}
21854	bool ByteCodeEmitter::emitFlipSint64Sint16(SourceInfo L) {
21855	return emitOp<>(OP_FlipSint64Sint16, L);
21856	}
21857	bool ByteCodeEmitter::emitFlipSint64Uint16(SourceInfo L) {
21858	return emitOp<>(OP_FlipSint64Uint16, L);
21859	}
21860	bool ByteCodeEmitter::emitFlipSint64Sint32(SourceInfo L) {
21861	return emitOp<>(OP_FlipSint64Sint32, L);
21862	}
21863	bool ByteCodeEmitter::emitFlipSint64Uint32(SourceInfo L) {
21864	return emitOp<>(OP_FlipSint64Uint32, L);
21865	}
21866	bool ByteCodeEmitter::emitFlipSint64Sint64(SourceInfo L) {
21867	return emitOp<>(OP_FlipSint64Sint64, L);
21868	}
21869	bool ByteCodeEmitter::emitFlipSint64Uint64(SourceInfo L) {
21870	return emitOp<>(OP_FlipSint64Uint64, L);
21871	}
21872	bool ByteCodeEmitter::emitFlipSint64IntAP(SourceInfo L) {
21873	return emitOp<>(OP_FlipSint64IntAP, L);
21874	}
21875	bool ByteCodeEmitter::emitFlipSint64IntAPS(SourceInfo L) {
21876	return emitOp<>(OP_FlipSint64IntAPS, L);
21877	}
21878	bool ByteCodeEmitter::emitFlipSint64Bool(SourceInfo L) {
21879	return emitOp<>(OP_FlipSint64Bool, L);
21880	}
21881	bool ByteCodeEmitter::emitFlipSint64FixedPoint(SourceInfo L) {
21882	return emitOp<>(OP_FlipSint64FixedPoint, L);
21883	}
21884	bool ByteCodeEmitter::emitFlipSint64Ptr(SourceInfo L) {
21885	return emitOp<>(OP_FlipSint64Ptr, L);
21886	}
21887	bool ByteCodeEmitter::emitFlipSint64MemberPtr(SourceInfo L) {
21888	return emitOp<>(OP_FlipSint64MemberPtr, L);
21889	}
21890	bool ByteCodeEmitter::emitFlipSint64Float(SourceInfo L) {
21891	return emitOp<>(OP_FlipSint64Float, L);
21892	}
21893	bool ByteCodeEmitter::emitFlipUint64Sint8(SourceInfo L) {
21894	return emitOp<>(OP_FlipUint64Sint8, L);
21895	}
21896	bool ByteCodeEmitter::emitFlipUint64Uint8(SourceInfo L) {
21897	return emitOp<>(OP_FlipUint64Uint8, L);
21898	}
21899	bool ByteCodeEmitter::emitFlipUint64Sint16(SourceInfo L) {
21900	return emitOp<>(OP_FlipUint64Sint16, L);
21901	}
21902	bool ByteCodeEmitter::emitFlipUint64Uint16(SourceInfo L) {
21903	return emitOp<>(OP_FlipUint64Uint16, L);
21904	}
21905	bool ByteCodeEmitter::emitFlipUint64Sint32(SourceInfo L) {
21906	return emitOp<>(OP_FlipUint64Sint32, L);
21907	}
21908	bool ByteCodeEmitter::emitFlipUint64Uint32(SourceInfo L) {
21909	return emitOp<>(OP_FlipUint64Uint32, L);
21910	}
21911	bool ByteCodeEmitter::emitFlipUint64Sint64(SourceInfo L) {
21912	return emitOp<>(OP_FlipUint64Sint64, L);
21913	}
21914	bool ByteCodeEmitter::emitFlipUint64Uint64(SourceInfo L) {
21915	return emitOp<>(OP_FlipUint64Uint64, L);
21916	}
21917	bool ByteCodeEmitter::emitFlipUint64IntAP(SourceInfo L) {
21918	return emitOp<>(OP_FlipUint64IntAP, L);
21919	}
21920	bool ByteCodeEmitter::emitFlipUint64IntAPS(SourceInfo L) {
21921	return emitOp<>(OP_FlipUint64IntAPS, L);
21922	}
21923	bool ByteCodeEmitter::emitFlipUint64Bool(SourceInfo L) {
21924	return emitOp<>(OP_FlipUint64Bool, L);
21925	}
21926	bool ByteCodeEmitter::emitFlipUint64FixedPoint(SourceInfo L) {
21927	return emitOp<>(OP_FlipUint64FixedPoint, L);
21928	}
21929	bool ByteCodeEmitter::emitFlipUint64Ptr(SourceInfo L) {
21930	return emitOp<>(OP_FlipUint64Ptr, L);
21931	}
21932	bool ByteCodeEmitter::emitFlipUint64MemberPtr(SourceInfo L) {
21933	return emitOp<>(OP_FlipUint64MemberPtr, L);
21934	}
21935	bool ByteCodeEmitter::emitFlipUint64Float(SourceInfo L) {
21936	return emitOp<>(OP_FlipUint64Float, L);
21937	}
21938	bool ByteCodeEmitter::emitFlipIntAPSint8(SourceInfo L) {
21939	return emitOp<>(OP_FlipIntAPSint8, L);
21940	}
21941	bool ByteCodeEmitter::emitFlipIntAPUint8(SourceInfo L) {
21942	return emitOp<>(OP_FlipIntAPUint8, L);
21943	}
21944	bool ByteCodeEmitter::emitFlipIntAPSint16(SourceInfo L) {
21945	return emitOp<>(OP_FlipIntAPSint16, L);
21946	}
21947	bool ByteCodeEmitter::emitFlipIntAPUint16(SourceInfo L) {
21948	return emitOp<>(OP_FlipIntAPUint16, L);
21949	}
21950	bool ByteCodeEmitter::emitFlipIntAPSint32(SourceInfo L) {
21951	return emitOp<>(OP_FlipIntAPSint32, L);
21952	}
21953	bool ByteCodeEmitter::emitFlipIntAPUint32(SourceInfo L) {
21954	return emitOp<>(OP_FlipIntAPUint32, L);
21955	}
21956	bool ByteCodeEmitter::emitFlipIntAPSint64(SourceInfo L) {
21957	return emitOp<>(OP_FlipIntAPSint64, L);
21958	}
21959	bool ByteCodeEmitter::emitFlipIntAPUint64(SourceInfo L) {
21960	return emitOp<>(OP_FlipIntAPUint64, L);
21961	}
21962	bool ByteCodeEmitter::emitFlipIntAPIntAP(SourceInfo L) {
21963	return emitOp<>(OP_FlipIntAPIntAP, L);
21964	}
21965	bool ByteCodeEmitter::emitFlipIntAPIntAPS(SourceInfo L) {
21966	return emitOp<>(OP_FlipIntAPIntAPS, L);
21967	}
21968	bool ByteCodeEmitter::emitFlipIntAPBool(SourceInfo L) {
21969	return emitOp<>(OP_FlipIntAPBool, L);
21970	}
21971	bool ByteCodeEmitter::emitFlipIntAPFixedPoint(SourceInfo L) {
21972	return emitOp<>(OP_FlipIntAPFixedPoint, L);
21973	}
21974	bool ByteCodeEmitter::emitFlipIntAPPtr(SourceInfo L) {
21975	return emitOp<>(OP_FlipIntAPPtr, L);
21976	}
21977	bool ByteCodeEmitter::emitFlipIntAPMemberPtr(SourceInfo L) {
21978	return emitOp<>(OP_FlipIntAPMemberPtr, L);
21979	}
21980	bool ByteCodeEmitter::emitFlipIntAPFloat(SourceInfo L) {
21981	return emitOp<>(OP_FlipIntAPFloat, L);
21982	}
21983	bool ByteCodeEmitter::emitFlipIntAPSSint8(SourceInfo L) {
21984	return emitOp<>(OP_FlipIntAPSSint8, L);
21985	}
21986	bool ByteCodeEmitter::emitFlipIntAPSUint8(SourceInfo L) {
21987	return emitOp<>(OP_FlipIntAPSUint8, L);
21988	}
21989	bool ByteCodeEmitter::emitFlipIntAPSSint16(SourceInfo L) {
21990	return emitOp<>(OP_FlipIntAPSSint16, L);
21991	}
21992	bool ByteCodeEmitter::emitFlipIntAPSUint16(SourceInfo L) {
21993	return emitOp<>(OP_FlipIntAPSUint16, L);
21994	}
21995	bool ByteCodeEmitter::emitFlipIntAPSSint32(SourceInfo L) {
21996	return emitOp<>(OP_FlipIntAPSSint32, L);
21997	}
21998	bool ByteCodeEmitter::emitFlipIntAPSUint32(SourceInfo L) {
21999	return emitOp<>(OP_FlipIntAPSUint32, L);
22000	}
22001	bool ByteCodeEmitter::emitFlipIntAPSSint64(SourceInfo L) {
22002	return emitOp<>(OP_FlipIntAPSSint64, L);
22003	}
22004	bool ByteCodeEmitter::emitFlipIntAPSUint64(SourceInfo L) {
22005	return emitOp<>(OP_FlipIntAPSUint64, L);
22006	}
22007	bool ByteCodeEmitter::emitFlipIntAPSIntAP(SourceInfo L) {
22008	return emitOp<>(OP_FlipIntAPSIntAP, L);
22009	}
22010	bool ByteCodeEmitter::emitFlipIntAPSIntAPS(SourceInfo L) {
22011	return emitOp<>(OP_FlipIntAPSIntAPS, L);
22012	}
22013	bool ByteCodeEmitter::emitFlipIntAPSBool(SourceInfo L) {
22014	return emitOp<>(OP_FlipIntAPSBool, L);
22015	}
22016	bool ByteCodeEmitter::emitFlipIntAPSFixedPoint(SourceInfo L) {
22017	return emitOp<>(OP_FlipIntAPSFixedPoint, L);
22018	}
22019	bool ByteCodeEmitter::emitFlipIntAPSPtr(SourceInfo L) {
22020	return emitOp<>(OP_FlipIntAPSPtr, L);
22021	}
22022	bool ByteCodeEmitter::emitFlipIntAPSMemberPtr(SourceInfo L) {
22023	return emitOp<>(OP_FlipIntAPSMemberPtr, L);
22024	}
22025	bool ByteCodeEmitter::emitFlipIntAPSFloat(SourceInfo L) {
22026	return emitOp<>(OP_FlipIntAPSFloat, L);
22027	}
22028	bool ByteCodeEmitter::emitFlipBoolSint8(SourceInfo L) {
22029	return emitOp<>(OP_FlipBoolSint8, L);
22030	}
22031	bool ByteCodeEmitter::emitFlipBoolUint8(SourceInfo L) {
22032	return emitOp<>(OP_FlipBoolUint8, L);
22033	}
22034	bool ByteCodeEmitter::emitFlipBoolSint16(SourceInfo L) {
22035	return emitOp<>(OP_FlipBoolSint16, L);
22036	}
22037	bool ByteCodeEmitter::emitFlipBoolUint16(SourceInfo L) {
22038	return emitOp<>(OP_FlipBoolUint16, L);
22039	}
22040	bool ByteCodeEmitter::emitFlipBoolSint32(SourceInfo L) {
22041	return emitOp<>(OP_FlipBoolSint32, L);
22042	}
22043	bool ByteCodeEmitter::emitFlipBoolUint32(SourceInfo L) {
22044	return emitOp<>(OP_FlipBoolUint32, L);
22045	}
22046	bool ByteCodeEmitter::emitFlipBoolSint64(SourceInfo L) {
22047	return emitOp<>(OP_FlipBoolSint64, L);
22048	}
22049	bool ByteCodeEmitter::emitFlipBoolUint64(SourceInfo L) {
22050	return emitOp<>(OP_FlipBoolUint64, L);
22051	}
22052	bool ByteCodeEmitter::emitFlipBoolIntAP(SourceInfo L) {
22053	return emitOp<>(OP_FlipBoolIntAP, L);
22054	}
22055	bool ByteCodeEmitter::emitFlipBoolIntAPS(SourceInfo L) {
22056	return emitOp<>(OP_FlipBoolIntAPS, L);
22057	}
22058	bool ByteCodeEmitter::emitFlipBoolBool(SourceInfo L) {
22059	return emitOp<>(OP_FlipBoolBool, L);
22060	}
22061	bool ByteCodeEmitter::emitFlipBoolFixedPoint(SourceInfo L) {
22062	return emitOp<>(OP_FlipBoolFixedPoint, L);
22063	}
22064	bool ByteCodeEmitter::emitFlipBoolPtr(SourceInfo L) {
22065	return emitOp<>(OP_FlipBoolPtr, L);
22066	}
22067	bool ByteCodeEmitter::emitFlipBoolMemberPtr(SourceInfo L) {
22068	return emitOp<>(OP_FlipBoolMemberPtr, L);
22069	}
22070	bool ByteCodeEmitter::emitFlipBoolFloat(SourceInfo L) {
22071	return emitOp<>(OP_FlipBoolFloat, L);
22072	}
22073	bool ByteCodeEmitter::emitFlipFixedPointSint8(SourceInfo L) {
22074	return emitOp<>(OP_FlipFixedPointSint8, L);
22075	}
22076	bool ByteCodeEmitter::emitFlipFixedPointUint8(SourceInfo L) {
22077	return emitOp<>(OP_FlipFixedPointUint8, L);
22078	}
22079	bool ByteCodeEmitter::emitFlipFixedPointSint16(SourceInfo L) {
22080	return emitOp<>(OP_FlipFixedPointSint16, L);
22081	}
22082	bool ByteCodeEmitter::emitFlipFixedPointUint16(SourceInfo L) {
22083	return emitOp<>(OP_FlipFixedPointUint16, L);
22084	}
22085	bool ByteCodeEmitter::emitFlipFixedPointSint32(SourceInfo L) {
22086	return emitOp<>(OP_FlipFixedPointSint32, L);
22087	}
22088	bool ByteCodeEmitter::emitFlipFixedPointUint32(SourceInfo L) {
22089	return emitOp<>(OP_FlipFixedPointUint32, L);
22090	}
22091	bool ByteCodeEmitter::emitFlipFixedPointSint64(SourceInfo L) {
22092	return emitOp<>(OP_FlipFixedPointSint64, L);
22093	}
22094	bool ByteCodeEmitter::emitFlipFixedPointUint64(SourceInfo L) {
22095	return emitOp<>(OP_FlipFixedPointUint64, L);
22096	}
22097	bool ByteCodeEmitter::emitFlipFixedPointIntAP(SourceInfo L) {
22098	return emitOp<>(OP_FlipFixedPointIntAP, L);
22099	}
22100	bool ByteCodeEmitter::emitFlipFixedPointIntAPS(SourceInfo L) {
22101	return emitOp<>(OP_FlipFixedPointIntAPS, L);
22102	}
22103	bool ByteCodeEmitter::emitFlipFixedPointBool(SourceInfo L) {
22104	return emitOp<>(OP_FlipFixedPointBool, L);
22105	}
22106	bool ByteCodeEmitter::emitFlipFixedPointFixedPoint(SourceInfo L) {
22107	return emitOp<>(OP_FlipFixedPointFixedPoint, L);
22108	}
22109	bool ByteCodeEmitter::emitFlipFixedPointPtr(SourceInfo L) {
22110	return emitOp<>(OP_FlipFixedPointPtr, L);
22111	}
22112	bool ByteCodeEmitter::emitFlipFixedPointMemberPtr(SourceInfo L) {
22113	return emitOp<>(OP_FlipFixedPointMemberPtr, L);
22114	}
22115	bool ByteCodeEmitter::emitFlipFixedPointFloat(SourceInfo L) {
22116	return emitOp<>(OP_FlipFixedPointFloat, L);
22117	}
22118	bool ByteCodeEmitter::emitFlipPtrSint8(SourceInfo L) {
22119	return emitOp<>(OP_FlipPtrSint8, L);
22120	}
22121	bool ByteCodeEmitter::emitFlipPtrUint8(SourceInfo L) {
22122	return emitOp<>(OP_FlipPtrUint8, L);
22123	}
22124	bool ByteCodeEmitter::emitFlipPtrSint16(SourceInfo L) {
22125	return emitOp<>(OP_FlipPtrSint16, L);
22126	}
22127	bool ByteCodeEmitter::emitFlipPtrUint16(SourceInfo L) {
22128	return emitOp<>(OP_FlipPtrUint16, L);
22129	}
22130	bool ByteCodeEmitter::emitFlipPtrSint32(SourceInfo L) {
22131	return emitOp<>(OP_FlipPtrSint32, L);
22132	}
22133	bool ByteCodeEmitter::emitFlipPtrUint32(SourceInfo L) {
22134	return emitOp<>(OP_FlipPtrUint32, L);
22135	}
22136	bool ByteCodeEmitter::emitFlipPtrSint64(SourceInfo L) {
22137	return emitOp<>(OP_FlipPtrSint64, L);
22138	}
22139	bool ByteCodeEmitter::emitFlipPtrUint64(SourceInfo L) {
22140	return emitOp<>(OP_FlipPtrUint64, L);
22141	}
22142	bool ByteCodeEmitter::emitFlipPtrIntAP(SourceInfo L) {
22143	return emitOp<>(OP_FlipPtrIntAP, L);
22144	}
22145	bool ByteCodeEmitter::emitFlipPtrIntAPS(SourceInfo L) {
22146	return emitOp<>(OP_FlipPtrIntAPS, L);
22147	}
22148	bool ByteCodeEmitter::emitFlipPtrBool(SourceInfo L) {
22149	return emitOp<>(OP_FlipPtrBool, L);
22150	}
22151	bool ByteCodeEmitter::emitFlipPtrFixedPoint(SourceInfo L) {
22152	return emitOp<>(OP_FlipPtrFixedPoint, L);
22153	}
22154	bool ByteCodeEmitter::emitFlipPtrPtr(SourceInfo L) {
22155	return emitOp<>(OP_FlipPtrPtr, L);
22156	}
22157	bool ByteCodeEmitter::emitFlipPtrMemberPtr(SourceInfo L) {
22158	return emitOp<>(OP_FlipPtrMemberPtr, L);
22159	}
22160	bool ByteCodeEmitter::emitFlipPtrFloat(SourceInfo L) {
22161	return emitOp<>(OP_FlipPtrFloat, L);
22162	}
22163	bool ByteCodeEmitter::emitFlipMemberPtrSint8(SourceInfo L) {
22164	return emitOp<>(OP_FlipMemberPtrSint8, L);
22165	}
22166	bool ByteCodeEmitter::emitFlipMemberPtrUint8(SourceInfo L) {
22167	return emitOp<>(OP_FlipMemberPtrUint8, L);
22168	}
22169	bool ByteCodeEmitter::emitFlipMemberPtrSint16(SourceInfo L) {
22170	return emitOp<>(OP_FlipMemberPtrSint16, L);
22171	}
22172	bool ByteCodeEmitter::emitFlipMemberPtrUint16(SourceInfo L) {
22173	return emitOp<>(OP_FlipMemberPtrUint16, L);
22174	}
22175	bool ByteCodeEmitter::emitFlipMemberPtrSint32(SourceInfo L) {
22176	return emitOp<>(OP_FlipMemberPtrSint32, L);
22177	}
22178	bool ByteCodeEmitter::emitFlipMemberPtrUint32(SourceInfo L) {
22179	return emitOp<>(OP_FlipMemberPtrUint32, L);
22180	}
22181	bool ByteCodeEmitter::emitFlipMemberPtrSint64(SourceInfo L) {
22182	return emitOp<>(OP_FlipMemberPtrSint64, L);
22183	}
22184	bool ByteCodeEmitter::emitFlipMemberPtrUint64(SourceInfo L) {
22185	return emitOp<>(OP_FlipMemberPtrUint64, L);
22186	}
22187	bool ByteCodeEmitter::emitFlipMemberPtrIntAP(SourceInfo L) {
22188	return emitOp<>(OP_FlipMemberPtrIntAP, L);
22189	}
22190	bool ByteCodeEmitter::emitFlipMemberPtrIntAPS(SourceInfo L) {
22191	return emitOp<>(OP_FlipMemberPtrIntAPS, L);
22192	}
22193	bool ByteCodeEmitter::emitFlipMemberPtrBool(SourceInfo L) {
22194	return emitOp<>(OP_FlipMemberPtrBool, L);
22195	}
22196	bool ByteCodeEmitter::emitFlipMemberPtrFixedPoint(SourceInfo L) {
22197	return emitOp<>(OP_FlipMemberPtrFixedPoint, L);
22198	}
22199	bool ByteCodeEmitter::emitFlipMemberPtrPtr(SourceInfo L) {
22200	return emitOp<>(OP_FlipMemberPtrPtr, L);
22201	}
22202	bool ByteCodeEmitter::emitFlipMemberPtrMemberPtr(SourceInfo L) {
22203	return emitOp<>(OP_FlipMemberPtrMemberPtr, L);
22204	}
22205	bool ByteCodeEmitter::emitFlipMemberPtrFloat(SourceInfo L) {
22206	return emitOp<>(OP_FlipMemberPtrFloat, L);
22207	}
22208	bool ByteCodeEmitter::emitFlipFloatSint8(SourceInfo L) {
22209	return emitOp<>(OP_FlipFloatSint8, L);
22210	}
22211	bool ByteCodeEmitter::emitFlipFloatUint8(SourceInfo L) {
22212	return emitOp<>(OP_FlipFloatUint8, L);
22213	}
22214	bool ByteCodeEmitter::emitFlipFloatSint16(SourceInfo L) {
22215	return emitOp<>(OP_FlipFloatSint16, L);
22216	}
22217	bool ByteCodeEmitter::emitFlipFloatUint16(SourceInfo L) {
22218	return emitOp<>(OP_FlipFloatUint16, L);
22219	}
22220	bool ByteCodeEmitter::emitFlipFloatSint32(SourceInfo L) {
22221	return emitOp<>(OP_FlipFloatSint32, L);
22222	}
22223	bool ByteCodeEmitter::emitFlipFloatUint32(SourceInfo L) {
22224	return emitOp<>(OP_FlipFloatUint32, L);
22225	}
22226	bool ByteCodeEmitter::emitFlipFloatSint64(SourceInfo L) {
22227	return emitOp<>(OP_FlipFloatSint64, L);
22228	}
22229	bool ByteCodeEmitter::emitFlipFloatUint64(SourceInfo L) {
22230	return emitOp<>(OP_FlipFloatUint64, L);
22231	}
22232	bool ByteCodeEmitter::emitFlipFloatIntAP(SourceInfo L) {
22233	return emitOp<>(OP_FlipFloatIntAP, L);
22234	}
22235	bool ByteCodeEmitter::emitFlipFloatIntAPS(SourceInfo L) {
22236	return emitOp<>(OP_FlipFloatIntAPS, L);
22237	}
22238	bool ByteCodeEmitter::emitFlipFloatBool(SourceInfo L) {
22239	return emitOp<>(OP_FlipFloatBool, L);
22240	}
22241	bool ByteCodeEmitter::emitFlipFloatFixedPoint(SourceInfo L) {
22242	return emitOp<>(OP_FlipFloatFixedPoint, L);
22243	}
22244	bool ByteCodeEmitter::emitFlipFloatPtr(SourceInfo L) {
22245	return emitOp<>(OP_FlipFloatPtr, L);
22246	}
22247	bool ByteCodeEmitter::emitFlipFloatMemberPtr(SourceInfo L) {
22248	return emitOp<>(OP_FlipFloatMemberPtr, L);
22249	}
22250	bool ByteCodeEmitter::emitFlipFloatFloat(SourceInfo L) {
22251	return emitOp<>(OP_FlipFloatFloat, L);
22252	}
22253	#endif
22254	#ifdef GET_EVAL_IMPL
22255	bool EvalEmitter::emitFlipSint8Sint8(SourceInfo L) {
22256	if (!isActive()) return true;
22257	CurrentSource = L;
22258	return Flip<PT_Sint8, PT_Sint8>(S);
22259	}
22260	bool EvalEmitter::emitFlipSint8Uint8(SourceInfo L) {
22261	if (!isActive()) return true;
22262	CurrentSource = L;
22263	return Flip<PT_Sint8, PT_Uint8>(S);
22264	}
22265	bool EvalEmitter::emitFlipSint8Sint16(SourceInfo L) {
22266	if (!isActive()) return true;
22267	CurrentSource = L;
22268	return Flip<PT_Sint8, PT_Sint16>(S);
22269	}
22270	bool EvalEmitter::emitFlipSint8Uint16(SourceInfo L) {
22271	if (!isActive()) return true;
22272	CurrentSource = L;
22273	return Flip<PT_Sint8, PT_Uint16>(S);
22274	}
22275	bool EvalEmitter::emitFlipSint8Sint32(SourceInfo L) {
22276	if (!isActive()) return true;
22277	CurrentSource = L;
22278	return Flip<PT_Sint8, PT_Sint32>(S);
22279	}
22280	bool EvalEmitter::emitFlipSint8Uint32(SourceInfo L) {
22281	if (!isActive()) return true;
22282	CurrentSource = L;
22283	return Flip<PT_Sint8, PT_Uint32>(S);
22284	}
22285	bool EvalEmitter::emitFlipSint8Sint64(SourceInfo L) {
22286	if (!isActive()) return true;
22287	CurrentSource = L;
22288	return Flip<PT_Sint8, PT_Sint64>(S);
22289	}
22290	bool EvalEmitter::emitFlipSint8Uint64(SourceInfo L) {
22291	if (!isActive()) return true;
22292	CurrentSource = L;
22293	return Flip<PT_Sint8, PT_Uint64>(S);
22294	}
22295	bool EvalEmitter::emitFlipSint8IntAP(SourceInfo L) {
22296	if (!isActive()) return true;
22297	CurrentSource = L;
22298	return Flip<PT_Sint8, PT_IntAP>(S);
22299	}
22300	bool EvalEmitter::emitFlipSint8IntAPS(SourceInfo L) {
22301	if (!isActive()) return true;
22302	CurrentSource = L;
22303	return Flip<PT_Sint8, PT_IntAPS>(S);
22304	}
22305	bool EvalEmitter::emitFlipSint8Bool(SourceInfo L) {
22306	if (!isActive()) return true;
22307	CurrentSource = L;
22308	return Flip<PT_Sint8, PT_Bool>(S);
22309	}
22310	bool EvalEmitter::emitFlipSint8FixedPoint(SourceInfo L) {
22311	if (!isActive()) return true;
22312	CurrentSource = L;
22313	return Flip<PT_Sint8, PT_FixedPoint>(S);
22314	}
22315	bool EvalEmitter::emitFlipSint8Ptr(SourceInfo L) {
22316	if (!isActive()) return true;
22317	CurrentSource = L;
22318	return Flip<PT_Sint8, PT_Ptr>(S);
22319	}
22320	bool EvalEmitter::emitFlipSint8MemberPtr(SourceInfo L) {
22321	if (!isActive()) return true;
22322	CurrentSource = L;
22323	return Flip<PT_Sint8, PT_MemberPtr>(S);
22324	}
22325	bool EvalEmitter::emitFlipSint8Float(SourceInfo L) {
22326	if (!isActive()) return true;
22327	CurrentSource = L;
22328	return Flip<PT_Sint8, PT_Float>(S);
22329	}
22330	bool EvalEmitter::emitFlipUint8Sint8(SourceInfo L) {
22331	if (!isActive()) return true;
22332	CurrentSource = L;
22333	return Flip<PT_Uint8, PT_Sint8>(S);
22334	}
22335	bool EvalEmitter::emitFlipUint8Uint8(SourceInfo L) {
22336	if (!isActive()) return true;
22337	CurrentSource = L;
22338	return Flip<PT_Uint8, PT_Uint8>(S);
22339	}
22340	bool EvalEmitter::emitFlipUint8Sint16(SourceInfo L) {
22341	if (!isActive()) return true;
22342	CurrentSource = L;
22343	return Flip<PT_Uint8, PT_Sint16>(S);
22344	}
22345	bool EvalEmitter::emitFlipUint8Uint16(SourceInfo L) {
22346	if (!isActive()) return true;
22347	CurrentSource = L;
22348	return Flip<PT_Uint8, PT_Uint16>(S);
22349	}
22350	bool EvalEmitter::emitFlipUint8Sint32(SourceInfo L) {
22351	if (!isActive()) return true;
22352	CurrentSource = L;
22353	return Flip<PT_Uint8, PT_Sint32>(S);
22354	}
22355	bool EvalEmitter::emitFlipUint8Uint32(SourceInfo L) {
22356	if (!isActive()) return true;
22357	CurrentSource = L;
22358	return Flip<PT_Uint8, PT_Uint32>(S);
22359	}
22360	bool EvalEmitter::emitFlipUint8Sint64(SourceInfo L) {
22361	if (!isActive()) return true;
22362	CurrentSource = L;
22363	return Flip<PT_Uint8, PT_Sint64>(S);
22364	}
22365	bool EvalEmitter::emitFlipUint8Uint64(SourceInfo L) {
22366	if (!isActive()) return true;
22367	CurrentSource = L;
22368	return Flip<PT_Uint8, PT_Uint64>(S);
22369	}
22370	bool EvalEmitter::emitFlipUint8IntAP(SourceInfo L) {
22371	if (!isActive()) return true;
22372	CurrentSource = L;
22373	return Flip<PT_Uint8, PT_IntAP>(S);
22374	}
22375	bool EvalEmitter::emitFlipUint8IntAPS(SourceInfo L) {
22376	if (!isActive()) return true;
22377	CurrentSource = L;
22378	return Flip<PT_Uint8, PT_IntAPS>(S);
22379	}
22380	bool EvalEmitter::emitFlipUint8Bool(SourceInfo L) {
22381	if (!isActive()) return true;
22382	CurrentSource = L;
22383	return Flip<PT_Uint8, PT_Bool>(S);
22384	}
22385	bool EvalEmitter::emitFlipUint8FixedPoint(SourceInfo L) {
22386	if (!isActive()) return true;
22387	CurrentSource = L;
22388	return Flip<PT_Uint8, PT_FixedPoint>(S);
22389	}
22390	bool EvalEmitter::emitFlipUint8Ptr(SourceInfo L) {
22391	if (!isActive()) return true;
22392	CurrentSource = L;
22393	return Flip<PT_Uint8, PT_Ptr>(S);
22394	}
22395	bool EvalEmitter::emitFlipUint8MemberPtr(SourceInfo L) {
22396	if (!isActive()) return true;
22397	CurrentSource = L;
22398	return Flip<PT_Uint8, PT_MemberPtr>(S);
22399	}
22400	bool EvalEmitter::emitFlipUint8Float(SourceInfo L) {
22401	if (!isActive()) return true;
22402	CurrentSource = L;
22403	return Flip<PT_Uint8, PT_Float>(S);
22404	}
22405	bool EvalEmitter::emitFlipSint16Sint8(SourceInfo L) {
22406	if (!isActive()) return true;
22407	CurrentSource = L;
22408	return Flip<PT_Sint16, PT_Sint8>(S);
22409	}
22410	bool EvalEmitter::emitFlipSint16Uint8(SourceInfo L) {
22411	if (!isActive()) return true;
22412	CurrentSource = L;
22413	return Flip<PT_Sint16, PT_Uint8>(S);
22414	}
22415	bool EvalEmitter::emitFlipSint16Sint16(SourceInfo L) {
22416	if (!isActive()) return true;
22417	CurrentSource = L;
22418	return Flip<PT_Sint16, PT_Sint16>(S);
22419	}
22420	bool EvalEmitter::emitFlipSint16Uint16(SourceInfo L) {
22421	if (!isActive()) return true;
22422	CurrentSource = L;
22423	return Flip<PT_Sint16, PT_Uint16>(S);
22424	}
22425	bool EvalEmitter::emitFlipSint16Sint32(SourceInfo L) {
22426	if (!isActive()) return true;
22427	CurrentSource = L;
22428	return Flip<PT_Sint16, PT_Sint32>(S);
22429	}
22430	bool EvalEmitter::emitFlipSint16Uint32(SourceInfo L) {
22431	if (!isActive()) return true;
22432	CurrentSource = L;
22433	return Flip<PT_Sint16, PT_Uint32>(S);
22434	}
22435	bool EvalEmitter::emitFlipSint16Sint64(SourceInfo L) {
22436	if (!isActive()) return true;
22437	CurrentSource = L;
22438	return Flip<PT_Sint16, PT_Sint64>(S);
22439	}
22440	bool EvalEmitter::emitFlipSint16Uint64(SourceInfo L) {
22441	if (!isActive()) return true;
22442	CurrentSource = L;
22443	return Flip<PT_Sint16, PT_Uint64>(S);
22444	}
22445	bool EvalEmitter::emitFlipSint16IntAP(SourceInfo L) {
22446	if (!isActive()) return true;
22447	CurrentSource = L;
22448	return Flip<PT_Sint16, PT_IntAP>(S);
22449	}
22450	bool EvalEmitter::emitFlipSint16IntAPS(SourceInfo L) {
22451	if (!isActive()) return true;
22452	CurrentSource = L;
22453	return Flip<PT_Sint16, PT_IntAPS>(S);
22454	}
22455	bool EvalEmitter::emitFlipSint16Bool(SourceInfo L) {
22456	if (!isActive()) return true;
22457	CurrentSource = L;
22458	return Flip<PT_Sint16, PT_Bool>(S);
22459	}
22460	bool EvalEmitter::emitFlipSint16FixedPoint(SourceInfo L) {
22461	if (!isActive()) return true;
22462	CurrentSource = L;
22463	return Flip<PT_Sint16, PT_FixedPoint>(S);
22464	}
22465	bool EvalEmitter::emitFlipSint16Ptr(SourceInfo L) {
22466	if (!isActive()) return true;
22467	CurrentSource = L;
22468	return Flip<PT_Sint16, PT_Ptr>(S);
22469	}
22470	bool EvalEmitter::emitFlipSint16MemberPtr(SourceInfo L) {
22471	if (!isActive()) return true;
22472	CurrentSource = L;
22473	return Flip<PT_Sint16, PT_MemberPtr>(S);
22474	}
22475	bool EvalEmitter::emitFlipSint16Float(SourceInfo L) {
22476	if (!isActive()) return true;
22477	CurrentSource = L;
22478	return Flip<PT_Sint16, PT_Float>(S);
22479	}
22480	bool EvalEmitter::emitFlipUint16Sint8(SourceInfo L) {
22481	if (!isActive()) return true;
22482	CurrentSource = L;
22483	return Flip<PT_Uint16, PT_Sint8>(S);
22484	}
22485	bool EvalEmitter::emitFlipUint16Uint8(SourceInfo L) {
22486	if (!isActive()) return true;
22487	CurrentSource = L;
22488	return Flip<PT_Uint16, PT_Uint8>(S);
22489	}
22490	bool EvalEmitter::emitFlipUint16Sint16(SourceInfo L) {
22491	if (!isActive()) return true;
22492	CurrentSource = L;
22493	return Flip<PT_Uint16, PT_Sint16>(S);
22494	}
22495	bool EvalEmitter::emitFlipUint16Uint16(SourceInfo L) {
22496	if (!isActive()) return true;
22497	CurrentSource = L;
22498	return Flip<PT_Uint16, PT_Uint16>(S);
22499	}
22500	bool EvalEmitter::emitFlipUint16Sint32(SourceInfo L) {
22501	if (!isActive()) return true;
22502	CurrentSource = L;
22503	return Flip<PT_Uint16, PT_Sint32>(S);
22504	}
22505	bool EvalEmitter::emitFlipUint16Uint32(SourceInfo L) {
22506	if (!isActive()) return true;
22507	CurrentSource = L;
22508	return Flip<PT_Uint16, PT_Uint32>(S);
22509	}
22510	bool EvalEmitter::emitFlipUint16Sint64(SourceInfo L) {
22511	if (!isActive()) return true;
22512	CurrentSource = L;
22513	return Flip<PT_Uint16, PT_Sint64>(S);
22514	}
22515	bool EvalEmitter::emitFlipUint16Uint64(SourceInfo L) {
22516	if (!isActive()) return true;
22517	CurrentSource = L;
22518	return Flip<PT_Uint16, PT_Uint64>(S);
22519	}
22520	bool EvalEmitter::emitFlipUint16IntAP(SourceInfo L) {
22521	if (!isActive()) return true;
22522	CurrentSource = L;
22523	return Flip<PT_Uint16, PT_IntAP>(S);
22524	}
22525	bool EvalEmitter::emitFlipUint16IntAPS(SourceInfo L) {
22526	if (!isActive()) return true;
22527	CurrentSource = L;
22528	return Flip<PT_Uint16, PT_IntAPS>(S);
22529	}
22530	bool EvalEmitter::emitFlipUint16Bool(SourceInfo L) {
22531	if (!isActive()) return true;
22532	CurrentSource = L;
22533	return Flip<PT_Uint16, PT_Bool>(S);
22534	}
22535	bool EvalEmitter::emitFlipUint16FixedPoint(SourceInfo L) {
22536	if (!isActive()) return true;
22537	CurrentSource = L;
22538	return Flip<PT_Uint16, PT_FixedPoint>(S);
22539	}
22540	bool EvalEmitter::emitFlipUint16Ptr(SourceInfo L) {
22541	if (!isActive()) return true;
22542	CurrentSource = L;
22543	return Flip<PT_Uint16, PT_Ptr>(S);
22544	}
22545	bool EvalEmitter::emitFlipUint16MemberPtr(SourceInfo L) {
22546	if (!isActive()) return true;
22547	CurrentSource = L;
22548	return Flip<PT_Uint16, PT_MemberPtr>(S);
22549	}
22550	bool EvalEmitter::emitFlipUint16Float(SourceInfo L) {
22551	if (!isActive()) return true;
22552	CurrentSource = L;
22553	return Flip<PT_Uint16, PT_Float>(S);
22554	}
22555	bool EvalEmitter::emitFlipSint32Sint8(SourceInfo L) {
22556	if (!isActive()) return true;
22557	CurrentSource = L;
22558	return Flip<PT_Sint32, PT_Sint8>(S);
22559	}
22560	bool EvalEmitter::emitFlipSint32Uint8(SourceInfo L) {
22561	if (!isActive()) return true;
22562	CurrentSource = L;
22563	return Flip<PT_Sint32, PT_Uint8>(S);
22564	}
22565	bool EvalEmitter::emitFlipSint32Sint16(SourceInfo L) {
22566	if (!isActive()) return true;
22567	CurrentSource = L;
22568	return Flip<PT_Sint32, PT_Sint16>(S);
22569	}
22570	bool EvalEmitter::emitFlipSint32Uint16(SourceInfo L) {
22571	if (!isActive()) return true;
22572	CurrentSource = L;
22573	return Flip<PT_Sint32, PT_Uint16>(S);
22574	}
22575	bool EvalEmitter::emitFlipSint32Sint32(SourceInfo L) {
22576	if (!isActive()) return true;
22577	CurrentSource = L;
22578	return Flip<PT_Sint32, PT_Sint32>(S);
22579	}
22580	bool EvalEmitter::emitFlipSint32Uint32(SourceInfo L) {
22581	if (!isActive()) return true;
22582	CurrentSource = L;
22583	return Flip<PT_Sint32, PT_Uint32>(S);
22584	}
22585	bool EvalEmitter::emitFlipSint32Sint64(SourceInfo L) {
22586	if (!isActive()) return true;
22587	CurrentSource = L;
22588	return Flip<PT_Sint32, PT_Sint64>(S);
22589	}
22590	bool EvalEmitter::emitFlipSint32Uint64(SourceInfo L) {
22591	if (!isActive()) return true;
22592	CurrentSource = L;
22593	return Flip<PT_Sint32, PT_Uint64>(S);
22594	}
22595	bool EvalEmitter::emitFlipSint32IntAP(SourceInfo L) {
22596	if (!isActive()) return true;
22597	CurrentSource = L;
22598	return Flip<PT_Sint32, PT_IntAP>(S);
22599	}
22600	bool EvalEmitter::emitFlipSint32IntAPS(SourceInfo L) {
22601	if (!isActive()) return true;
22602	CurrentSource = L;
22603	return Flip<PT_Sint32, PT_IntAPS>(S);
22604	}
22605	bool EvalEmitter::emitFlipSint32Bool(SourceInfo L) {
22606	if (!isActive()) return true;
22607	CurrentSource = L;
22608	return Flip<PT_Sint32, PT_Bool>(S);
22609	}
22610	bool EvalEmitter::emitFlipSint32FixedPoint(SourceInfo L) {
22611	if (!isActive()) return true;
22612	CurrentSource = L;
22613	return Flip<PT_Sint32, PT_FixedPoint>(S);
22614	}
22615	bool EvalEmitter::emitFlipSint32Ptr(SourceInfo L) {
22616	if (!isActive()) return true;
22617	CurrentSource = L;
22618	return Flip<PT_Sint32, PT_Ptr>(S);
22619	}
22620	bool EvalEmitter::emitFlipSint32MemberPtr(SourceInfo L) {
22621	if (!isActive()) return true;
22622	CurrentSource = L;
22623	return Flip<PT_Sint32, PT_MemberPtr>(S);
22624	}
22625	bool EvalEmitter::emitFlipSint32Float(SourceInfo L) {
22626	if (!isActive()) return true;
22627	CurrentSource = L;
22628	return Flip<PT_Sint32, PT_Float>(S);
22629	}
22630	bool EvalEmitter::emitFlipUint32Sint8(SourceInfo L) {
22631	if (!isActive()) return true;
22632	CurrentSource = L;
22633	return Flip<PT_Uint32, PT_Sint8>(S);
22634	}
22635	bool EvalEmitter::emitFlipUint32Uint8(SourceInfo L) {
22636	if (!isActive()) return true;
22637	CurrentSource = L;
22638	return Flip<PT_Uint32, PT_Uint8>(S);
22639	}
22640	bool EvalEmitter::emitFlipUint32Sint16(SourceInfo L) {
22641	if (!isActive()) return true;
22642	CurrentSource = L;
22643	return Flip<PT_Uint32, PT_Sint16>(S);
22644	}
22645	bool EvalEmitter::emitFlipUint32Uint16(SourceInfo L) {
22646	if (!isActive()) return true;
22647	CurrentSource = L;
22648	return Flip<PT_Uint32, PT_Uint16>(S);
22649	}
22650	bool EvalEmitter::emitFlipUint32Sint32(SourceInfo L) {
22651	if (!isActive()) return true;
22652	CurrentSource = L;
22653	return Flip<PT_Uint32, PT_Sint32>(S);
22654	}
22655	bool EvalEmitter::emitFlipUint32Uint32(SourceInfo L) {
22656	if (!isActive()) return true;
22657	CurrentSource = L;
22658	return Flip<PT_Uint32, PT_Uint32>(S);
22659	}
22660	bool EvalEmitter::emitFlipUint32Sint64(SourceInfo L) {
22661	if (!isActive()) return true;
22662	CurrentSource = L;
22663	return Flip<PT_Uint32, PT_Sint64>(S);
22664	}
22665	bool EvalEmitter::emitFlipUint32Uint64(SourceInfo L) {
22666	if (!isActive()) return true;
22667	CurrentSource = L;
22668	return Flip<PT_Uint32, PT_Uint64>(S);
22669	}
22670	bool EvalEmitter::emitFlipUint32IntAP(SourceInfo L) {
22671	if (!isActive()) return true;
22672	CurrentSource = L;
22673	return Flip<PT_Uint32, PT_IntAP>(S);
22674	}
22675	bool EvalEmitter::emitFlipUint32IntAPS(SourceInfo L) {
22676	if (!isActive()) return true;
22677	CurrentSource = L;
22678	return Flip<PT_Uint32, PT_IntAPS>(S);
22679	}
22680	bool EvalEmitter::emitFlipUint32Bool(SourceInfo L) {
22681	if (!isActive()) return true;
22682	CurrentSource = L;
22683	return Flip<PT_Uint32, PT_Bool>(S);
22684	}
22685	bool EvalEmitter::emitFlipUint32FixedPoint(SourceInfo L) {
22686	if (!isActive()) return true;
22687	CurrentSource = L;
22688	return Flip<PT_Uint32, PT_FixedPoint>(S);
22689	}
22690	bool EvalEmitter::emitFlipUint32Ptr(SourceInfo L) {
22691	if (!isActive()) return true;
22692	CurrentSource = L;
22693	return Flip<PT_Uint32, PT_Ptr>(S);
22694	}
22695	bool EvalEmitter::emitFlipUint32MemberPtr(SourceInfo L) {
22696	if (!isActive()) return true;
22697	CurrentSource = L;
22698	return Flip<PT_Uint32, PT_MemberPtr>(S);
22699	}
22700	bool EvalEmitter::emitFlipUint32Float(SourceInfo L) {
22701	if (!isActive()) return true;
22702	CurrentSource = L;
22703	return Flip<PT_Uint32, PT_Float>(S);
22704	}
22705	bool EvalEmitter::emitFlipSint64Sint8(SourceInfo L) {
22706	if (!isActive()) return true;
22707	CurrentSource = L;
22708	return Flip<PT_Sint64, PT_Sint8>(S);
22709	}
22710	bool EvalEmitter::emitFlipSint64Uint8(SourceInfo L) {
22711	if (!isActive()) return true;
22712	CurrentSource = L;
22713	return Flip<PT_Sint64, PT_Uint8>(S);
22714	}
22715	bool EvalEmitter::emitFlipSint64Sint16(SourceInfo L) {
22716	if (!isActive()) return true;
22717	CurrentSource = L;
22718	return Flip<PT_Sint64, PT_Sint16>(S);
22719	}
22720	bool EvalEmitter::emitFlipSint64Uint16(SourceInfo L) {
22721	if (!isActive()) return true;
22722	CurrentSource = L;
22723	return Flip<PT_Sint64, PT_Uint16>(S);
22724	}
22725	bool EvalEmitter::emitFlipSint64Sint32(SourceInfo L) {
22726	if (!isActive()) return true;
22727	CurrentSource = L;
22728	return Flip<PT_Sint64, PT_Sint32>(S);
22729	}
22730	bool EvalEmitter::emitFlipSint64Uint32(SourceInfo L) {
22731	if (!isActive()) return true;
22732	CurrentSource = L;
22733	return Flip<PT_Sint64, PT_Uint32>(S);
22734	}
22735	bool EvalEmitter::emitFlipSint64Sint64(SourceInfo L) {
22736	if (!isActive()) return true;
22737	CurrentSource = L;
22738	return Flip<PT_Sint64, PT_Sint64>(S);
22739	}
22740	bool EvalEmitter::emitFlipSint64Uint64(SourceInfo L) {
22741	if (!isActive()) return true;
22742	CurrentSource = L;
22743	return Flip<PT_Sint64, PT_Uint64>(S);
22744	}
22745	bool EvalEmitter::emitFlipSint64IntAP(SourceInfo L) {
22746	if (!isActive()) return true;
22747	CurrentSource = L;
22748	return Flip<PT_Sint64, PT_IntAP>(S);
22749	}
22750	bool EvalEmitter::emitFlipSint64IntAPS(SourceInfo L) {
22751	if (!isActive()) return true;
22752	CurrentSource = L;
22753	return Flip<PT_Sint64, PT_IntAPS>(S);
22754	}
22755	bool EvalEmitter::emitFlipSint64Bool(SourceInfo L) {
22756	if (!isActive()) return true;
22757	CurrentSource = L;
22758	return Flip<PT_Sint64, PT_Bool>(S);
22759	}
22760	bool EvalEmitter::emitFlipSint64FixedPoint(SourceInfo L) {
22761	if (!isActive()) return true;
22762	CurrentSource = L;
22763	return Flip<PT_Sint64, PT_FixedPoint>(S);
22764	}
22765	bool EvalEmitter::emitFlipSint64Ptr(SourceInfo L) {
22766	if (!isActive()) return true;
22767	CurrentSource = L;
22768	return Flip<PT_Sint64, PT_Ptr>(S);
22769	}
22770	bool EvalEmitter::emitFlipSint64MemberPtr(SourceInfo L) {
22771	if (!isActive()) return true;
22772	CurrentSource = L;
22773	return Flip<PT_Sint64, PT_MemberPtr>(S);
22774	}
22775	bool EvalEmitter::emitFlipSint64Float(SourceInfo L) {
22776	if (!isActive()) return true;
22777	CurrentSource = L;
22778	return Flip<PT_Sint64, PT_Float>(S);
22779	}
22780	bool EvalEmitter::emitFlipUint64Sint8(SourceInfo L) {
22781	if (!isActive()) return true;
22782	CurrentSource = L;
22783	return Flip<PT_Uint64, PT_Sint8>(S);
22784	}
22785	bool EvalEmitter::emitFlipUint64Uint8(SourceInfo L) {
22786	if (!isActive()) return true;
22787	CurrentSource = L;
22788	return Flip<PT_Uint64, PT_Uint8>(S);
22789	}
22790	bool EvalEmitter::emitFlipUint64Sint16(SourceInfo L) {
22791	if (!isActive()) return true;
22792	CurrentSource = L;
22793	return Flip<PT_Uint64, PT_Sint16>(S);
22794	}
22795	bool EvalEmitter::emitFlipUint64Uint16(SourceInfo L) {
22796	if (!isActive()) return true;
22797	CurrentSource = L;
22798	return Flip<PT_Uint64, PT_Uint16>(S);
22799	}
22800	bool EvalEmitter::emitFlipUint64Sint32(SourceInfo L) {
22801	if (!isActive()) return true;
22802	CurrentSource = L;
22803	return Flip<PT_Uint64, PT_Sint32>(S);
22804	}
22805	bool EvalEmitter::emitFlipUint64Uint32(SourceInfo L) {
22806	if (!isActive()) return true;
22807	CurrentSource = L;
22808	return Flip<PT_Uint64, PT_Uint32>(S);
22809	}
22810	bool EvalEmitter::emitFlipUint64Sint64(SourceInfo L) {
22811	if (!isActive()) return true;
22812	CurrentSource = L;
22813	return Flip<PT_Uint64, PT_Sint64>(S);
22814	}
22815	bool EvalEmitter::emitFlipUint64Uint64(SourceInfo L) {
22816	if (!isActive()) return true;
22817	CurrentSource = L;
22818	return Flip<PT_Uint64, PT_Uint64>(S);
22819	}
22820	bool EvalEmitter::emitFlipUint64IntAP(SourceInfo L) {
22821	if (!isActive()) return true;
22822	CurrentSource = L;
22823	return Flip<PT_Uint64, PT_IntAP>(S);
22824	}
22825	bool EvalEmitter::emitFlipUint64IntAPS(SourceInfo L) {
22826	if (!isActive()) return true;
22827	CurrentSource = L;
22828	return Flip<PT_Uint64, PT_IntAPS>(S);
22829	}
22830	bool EvalEmitter::emitFlipUint64Bool(SourceInfo L) {
22831	if (!isActive()) return true;
22832	CurrentSource = L;
22833	return Flip<PT_Uint64, PT_Bool>(S);
22834	}
22835	bool EvalEmitter::emitFlipUint64FixedPoint(SourceInfo L) {
22836	if (!isActive()) return true;
22837	CurrentSource = L;
22838	return Flip<PT_Uint64, PT_FixedPoint>(S);
22839	}
22840	bool EvalEmitter::emitFlipUint64Ptr(SourceInfo L) {
22841	if (!isActive()) return true;
22842	CurrentSource = L;
22843	return Flip<PT_Uint64, PT_Ptr>(S);
22844	}
22845	bool EvalEmitter::emitFlipUint64MemberPtr(SourceInfo L) {
22846	if (!isActive()) return true;
22847	CurrentSource = L;
22848	return Flip<PT_Uint64, PT_MemberPtr>(S);
22849	}
22850	bool EvalEmitter::emitFlipUint64Float(SourceInfo L) {
22851	if (!isActive()) return true;
22852	CurrentSource = L;
22853	return Flip<PT_Uint64, PT_Float>(S);
22854	}
22855	bool EvalEmitter::emitFlipIntAPSint8(SourceInfo L) {
22856	if (!isActive()) return true;
22857	CurrentSource = L;
22858	return Flip<PT_IntAP, PT_Sint8>(S);
22859	}
22860	bool EvalEmitter::emitFlipIntAPUint8(SourceInfo L) {
22861	if (!isActive()) return true;
22862	CurrentSource = L;
22863	return Flip<PT_IntAP, PT_Uint8>(S);
22864	}
22865	bool EvalEmitter::emitFlipIntAPSint16(SourceInfo L) {
22866	if (!isActive()) return true;
22867	CurrentSource = L;
22868	return Flip<PT_IntAP, PT_Sint16>(S);
22869	}
22870	bool EvalEmitter::emitFlipIntAPUint16(SourceInfo L) {
22871	if (!isActive()) return true;
22872	CurrentSource = L;
22873	return Flip<PT_IntAP, PT_Uint16>(S);
22874	}
22875	bool EvalEmitter::emitFlipIntAPSint32(SourceInfo L) {
22876	if (!isActive()) return true;
22877	CurrentSource = L;
22878	return Flip<PT_IntAP, PT_Sint32>(S);
22879	}
22880	bool EvalEmitter::emitFlipIntAPUint32(SourceInfo L) {
22881	if (!isActive()) return true;
22882	CurrentSource = L;
22883	return Flip<PT_IntAP, PT_Uint32>(S);
22884	}
22885	bool EvalEmitter::emitFlipIntAPSint64(SourceInfo L) {
22886	if (!isActive()) return true;
22887	CurrentSource = L;
22888	return Flip<PT_IntAP, PT_Sint64>(S);
22889	}
22890	bool EvalEmitter::emitFlipIntAPUint64(SourceInfo L) {
22891	if (!isActive()) return true;
22892	CurrentSource = L;
22893	return Flip<PT_IntAP, PT_Uint64>(S);
22894	}
22895	bool EvalEmitter::emitFlipIntAPIntAP(SourceInfo L) {
22896	if (!isActive()) return true;
22897	CurrentSource = L;
22898	return Flip<PT_IntAP, PT_IntAP>(S);
22899	}
22900	bool EvalEmitter::emitFlipIntAPIntAPS(SourceInfo L) {
22901	if (!isActive()) return true;
22902	CurrentSource = L;
22903	return Flip<PT_IntAP, PT_IntAPS>(S);
22904	}
22905	bool EvalEmitter::emitFlipIntAPBool(SourceInfo L) {
22906	if (!isActive()) return true;
22907	CurrentSource = L;
22908	return Flip<PT_IntAP, PT_Bool>(S);
22909	}
22910	bool EvalEmitter::emitFlipIntAPFixedPoint(SourceInfo L) {
22911	if (!isActive()) return true;
22912	CurrentSource = L;
22913	return Flip<PT_IntAP, PT_FixedPoint>(S);
22914	}
22915	bool EvalEmitter::emitFlipIntAPPtr(SourceInfo L) {
22916	if (!isActive()) return true;
22917	CurrentSource = L;
22918	return Flip<PT_IntAP, PT_Ptr>(S);
22919	}
22920	bool EvalEmitter::emitFlipIntAPMemberPtr(SourceInfo L) {
22921	if (!isActive()) return true;
22922	CurrentSource = L;
22923	return Flip<PT_IntAP, PT_MemberPtr>(S);
22924	}
22925	bool EvalEmitter::emitFlipIntAPFloat(SourceInfo L) {
22926	if (!isActive()) return true;
22927	CurrentSource = L;
22928	return Flip<PT_IntAP, PT_Float>(S);
22929	}
22930	bool EvalEmitter::emitFlipIntAPSSint8(SourceInfo L) {
22931	if (!isActive()) return true;
22932	CurrentSource = L;
22933	return Flip<PT_IntAPS, PT_Sint8>(S);
22934	}
22935	bool EvalEmitter::emitFlipIntAPSUint8(SourceInfo L) {
22936	if (!isActive()) return true;
22937	CurrentSource = L;
22938	return Flip<PT_IntAPS, PT_Uint8>(S);
22939	}
22940	bool EvalEmitter::emitFlipIntAPSSint16(SourceInfo L) {
22941	if (!isActive()) return true;
22942	CurrentSource = L;
22943	return Flip<PT_IntAPS, PT_Sint16>(S);
22944	}
22945	bool EvalEmitter::emitFlipIntAPSUint16(SourceInfo L) {
22946	if (!isActive()) return true;
22947	CurrentSource = L;
22948	return Flip<PT_IntAPS, PT_Uint16>(S);
22949	}
22950	bool EvalEmitter::emitFlipIntAPSSint32(SourceInfo L) {
22951	if (!isActive()) return true;
22952	CurrentSource = L;
22953	return Flip<PT_IntAPS, PT_Sint32>(S);
22954	}
22955	bool EvalEmitter::emitFlipIntAPSUint32(SourceInfo L) {
22956	if (!isActive()) return true;
22957	CurrentSource = L;
22958	return Flip<PT_IntAPS, PT_Uint32>(S);
22959	}
22960	bool EvalEmitter::emitFlipIntAPSSint64(SourceInfo L) {
22961	if (!isActive()) return true;
22962	CurrentSource = L;
22963	return Flip<PT_IntAPS, PT_Sint64>(S);
22964	}
22965	bool EvalEmitter::emitFlipIntAPSUint64(SourceInfo L) {
22966	if (!isActive()) return true;
22967	CurrentSource = L;
22968	return Flip<PT_IntAPS, PT_Uint64>(S);
22969	}
22970	bool EvalEmitter::emitFlipIntAPSIntAP(SourceInfo L) {
22971	if (!isActive()) return true;
22972	CurrentSource = L;
22973	return Flip<PT_IntAPS, PT_IntAP>(S);
22974	}
22975	bool EvalEmitter::emitFlipIntAPSIntAPS(SourceInfo L) {
22976	if (!isActive()) return true;
22977	CurrentSource = L;
22978	return Flip<PT_IntAPS, PT_IntAPS>(S);
22979	}
22980	bool EvalEmitter::emitFlipIntAPSBool(SourceInfo L) {
22981	if (!isActive()) return true;
22982	CurrentSource = L;
22983	return Flip<PT_IntAPS, PT_Bool>(S);
22984	}
22985	bool EvalEmitter::emitFlipIntAPSFixedPoint(SourceInfo L) {
22986	if (!isActive()) return true;
22987	CurrentSource = L;
22988	return Flip<PT_IntAPS, PT_FixedPoint>(S);
22989	}
22990	bool EvalEmitter::emitFlipIntAPSPtr(SourceInfo L) {
22991	if (!isActive()) return true;
22992	CurrentSource = L;
22993	return Flip<PT_IntAPS, PT_Ptr>(S);
22994	}
22995	bool EvalEmitter::emitFlipIntAPSMemberPtr(SourceInfo L) {
22996	if (!isActive()) return true;
22997	CurrentSource = L;
22998	return Flip<PT_IntAPS, PT_MemberPtr>(S);
22999	}
23000	bool EvalEmitter::emitFlipIntAPSFloat(SourceInfo L) {
23001	if (!isActive()) return true;
23002	CurrentSource = L;
23003	return Flip<PT_IntAPS, PT_Float>(S);
23004	}
23005	bool EvalEmitter::emitFlipBoolSint8(SourceInfo L) {
23006	if (!isActive()) return true;
23007	CurrentSource = L;
23008	return Flip<PT_Bool, PT_Sint8>(S);
23009	}
23010	bool EvalEmitter::emitFlipBoolUint8(SourceInfo L) {
23011	if (!isActive()) return true;
23012	CurrentSource = L;
23013	return Flip<PT_Bool, PT_Uint8>(S);
23014	}
23015	bool EvalEmitter::emitFlipBoolSint16(SourceInfo L) {
23016	if (!isActive()) return true;
23017	CurrentSource = L;
23018	return Flip<PT_Bool, PT_Sint16>(S);
23019	}
23020	bool EvalEmitter::emitFlipBoolUint16(SourceInfo L) {
23021	if (!isActive()) return true;
23022	CurrentSource = L;
23023	return Flip<PT_Bool, PT_Uint16>(S);
23024	}
23025	bool EvalEmitter::emitFlipBoolSint32(SourceInfo L) {
23026	if (!isActive()) return true;
23027	CurrentSource = L;
23028	return Flip<PT_Bool, PT_Sint32>(S);
23029	}
23030	bool EvalEmitter::emitFlipBoolUint32(SourceInfo L) {
23031	if (!isActive()) return true;
23032	CurrentSource = L;
23033	return Flip<PT_Bool, PT_Uint32>(S);
23034	}
23035	bool EvalEmitter::emitFlipBoolSint64(SourceInfo L) {
23036	if (!isActive()) return true;
23037	CurrentSource = L;
23038	return Flip<PT_Bool, PT_Sint64>(S);
23039	}
23040	bool EvalEmitter::emitFlipBoolUint64(SourceInfo L) {
23041	if (!isActive()) return true;
23042	CurrentSource = L;
23043	return Flip<PT_Bool, PT_Uint64>(S);
23044	}
23045	bool EvalEmitter::emitFlipBoolIntAP(SourceInfo L) {
23046	if (!isActive()) return true;
23047	CurrentSource = L;
23048	return Flip<PT_Bool, PT_IntAP>(S);
23049	}
23050	bool EvalEmitter::emitFlipBoolIntAPS(SourceInfo L) {
23051	if (!isActive()) return true;
23052	CurrentSource = L;
23053	return Flip<PT_Bool, PT_IntAPS>(S);
23054	}
23055	bool EvalEmitter::emitFlipBoolBool(SourceInfo L) {
23056	if (!isActive()) return true;
23057	CurrentSource = L;
23058	return Flip<PT_Bool, PT_Bool>(S);
23059	}
23060	bool EvalEmitter::emitFlipBoolFixedPoint(SourceInfo L) {
23061	if (!isActive()) return true;
23062	CurrentSource = L;
23063	return Flip<PT_Bool, PT_FixedPoint>(S);
23064	}
23065	bool EvalEmitter::emitFlipBoolPtr(SourceInfo L) {
23066	if (!isActive()) return true;
23067	CurrentSource = L;
23068	return Flip<PT_Bool, PT_Ptr>(S);
23069	}
23070	bool EvalEmitter::emitFlipBoolMemberPtr(SourceInfo L) {
23071	if (!isActive()) return true;
23072	CurrentSource = L;
23073	return Flip<PT_Bool, PT_MemberPtr>(S);
23074	}
23075	bool EvalEmitter::emitFlipBoolFloat(SourceInfo L) {
23076	if (!isActive()) return true;
23077	CurrentSource = L;
23078	return Flip<PT_Bool, PT_Float>(S);
23079	}
23080	bool EvalEmitter::emitFlipFixedPointSint8(SourceInfo L) {
23081	if (!isActive()) return true;
23082	CurrentSource = L;
23083	return Flip<PT_FixedPoint, PT_Sint8>(S);
23084	}
23085	bool EvalEmitter::emitFlipFixedPointUint8(SourceInfo L) {
23086	if (!isActive()) return true;
23087	CurrentSource = L;
23088	return Flip<PT_FixedPoint, PT_Uint8>(S);
23089	}
23090	bool EvalEmitter::emitFlipFixedPointSint16(SourceInfo L) {
23091	if (!isActive()) return true;
23092	CurrentSource = L;
23093	return Flip<PT_FixedPoint, PT_Sint16>(S);
23094	}
23095	bool EvalEmitter::emitFlipFixedPointUint16(SourceInfo L) {
23096	if (!isActive()) return true;
23097	CurrentSource = L;
23098	return Flip<PT_FixedPoint, PT_Uint16>(S);
23099	}
23100	bool EvalEmitter::emitFlipFixedPointSint32(SourceInfo L) {
23101	if (!isActive()) return true;
23102	CurrentSource = L;
23103	return Flip<PT_FixedPoint, PT_Sint32>(S);
23104	}
23105	bool EvalEmitter::emitFlipFixedPointUint32(SourceInfo L) {
23106	if (!isActive()) return true;
23107	CurrentSource = L;
23108	return Flip<PT_FixedPoint, PT_Uint32>(S);
23109	}
23110	bool EvalEmitter::emitFlipFixedPointSint64(SourceInfo L) {
23111	if (!isActive()) return true;
23112	CurrentSource = L;
23113	return Flip<PT_FixedPoint, PT_Sint64>(S);
23114	}
23115	bool EvalEmitter::emitFlipFixedPointUint64(SourceInfo L) {
23116	if (!isActive()) return true;
23117	CurrentSource = L;
23118	return Flip<PT_FixedPoint, PT_Uint64>(S);
23119	}
23120	bool EvalEmitter::emitFlipFixedPointIntAP(SourceInfo L) {
23121	if (!isActive()) return true;
23122	CurrentSource = L;
23123	return Flip<PT_FixedPoint, PT_IntAP>(S);
23124	}
23125	bool EvalEmitter::emitFlipFixedPointIntAPS(SourceInfo L) {
23126	if (!isActive()) return true;
23127	CurrentSource = L;
23128	return Flip<PT_FixedPoint, PT_IntAPS>(S);
23129	}
23130	bool EvalEmitter::emitFlipFixedPointBool(SourceInfo L) {
23131	if (!isActive()) return true;
23132	CurrentSource = L;
23133	return Flip<PT_FixedPoint, PT_Bool>(S);
23134	}
23135	bool EvalEmitter::emitFlipFixedPointFixedPoint(SourceInfo L) {
23136	if (!isActive()) return true;
23137	CurrentSource = L;
23138	return Flip<PT_FixedPoint, PT_FixedPoint>(S);
23139	}
23140	bool EvalEmitter::emitFlipFixedPointPtr(SourceInfo L) {
23141	if (!isActive()) return true;
23142	CurrentSource = L;
23143	return Flip<PT_FixedPoint, PT_Ptr>(S);
23144	}
23145	bool EvalEmitter::emitFlipFixedPointMemberPtr(SourceInfo L) {
23146	if (!isActive()) return true;
23147	CurrentSource = L;
23148	return Flip<PT_FixedPoint, PT_MemberPtr>(S);
23149	}
23150	bool EvalEmitter::emitFlipFixedPointFloat(SourceInfo L) {
23151	if (!isActive()) return true;
23152	CurrentSource = L;
23153	return Flip<PT_FixedPoint, PT_Float>(S);
23154	}
23155	bool EvalEmitter::emitFlipPtrSint8(SourceInfo L) {
23156	if (!isActive()) return true;
23157	CurrentSource = L;
23158	return Flip<PT_Ptr, PT_Sint8>(S);
23159	}
23160	bool EvalEmitter::emitFlipPtrUint8(SourceInfo L) {
23161	if (!isActive()) return true;
23162	CurrentSource = L;
23163	return Flip<PT_Ptr, PT_Uint8>(S);
23164	}
23165	bool EvalEmitter::emitFlipPtrSint16(SourceInfo L) {
23166	if (!isActive()) return true;
23167	CurrentSource = L;
23168	return Flip<PT_Ptr, PT_Sint16>(S);
23169	}
23170	bool EvalEmitter::emitFlipPtrUint16(SourceInfo L) {
23171	if (!isActive()) return true;
23172	CurrentSource = L;
23173	return Flip<PT_Ptr, PT_Uint16>(S);
23174	}
23175	bool EvalEmitter::emitFlipPtrSint32(SourceInfo L) {
23176	if (!isActive()) return true;
23177	CurrentSource = L;
23178	return Flip<PT_Ptr, PT_Sint32>(S);
23179	}
23180	bool EvalEmitter::emitFlipPtrUint32(SourceInfo L) {
23181	if (!isActive()) return true;
23182	CurrentSource = L;
23183	return Flip<PT_Ptr, PT_Uint32>(S);
23184	}
23185	bool EvalEmitter::emitFlipPtrSint64(SourceInfo L) {
23186	if (!isActive()) return true;
23187	CurrentSource = L;
23188	return Flip<PT_Ptr, PT_Sint64>(S);
23189	}
23190	bool EvalEmitter::emitFlipPtrUint64(SourceInfo L) {
23191	if (!isActive()) return true;
23192	CurrentSource = L;
23193	return Flip<PT_Ptr, PT_Uint64>(S);
23194	}
23195	bool EvalEmitter::emitFlipPtrIntAP(SourceInfo L) {
23196	if (!isActive()) return true;
23197	CurrentSource = L;
23198	return Flip<PT_Ptr, PT_IntAP>(S);
23199	}
23200	bool EvalEmitter::emitFlipPtrIntAPS(SourceInfo L) {
23201	if (!isActive()) return true;
23202	CurrentSource = L;
23203	return Flip<PT_Ptr, PT_IntAPS>(S);
23204	}
23205	bool EvalEmitter::emitFlipPtrBool(SourceInfo L) {
23206	if (!isActive()) return true;
23207	CurrentSource = L;
23208	return Flip<PT_Ptr, PT_Bool>(S);
23209	}
23210	bool EvalEmitter::emitFlipPtrFixedPoint(SourceInfo L) {
23211	if (!isActive()) return true;
23212	CurrentSource = L;
23213	return Flip<PT_Ptr, PT_FixedPoint>(S);
23214	}
23215	bool EvalEmitter::emitFlipPtrPtr(SourceInfo L) {
23216	if (!isActive()) return true;
23217	CurrentSource = L;
23218	return Flip<PT_Ptr, PT_Ptr>(S);
23219	}
23220	bool EvalEmitter::emitFlipPtrMemberPtr(SourceInfo L) {
23221	if (!isActive()) return true;
23222	CurrentSource = L;
23223	return Flip<PT_Ptr, PT_MemberPtr>(S);
23224	}
23225	bool EvalEmitter::emitFlipPtrFloat(SourceInfo L) {
23226	if (!isActive()) return true;
23227	CurrentSource = L;
23228	return Flip<PT_Ptr, PT_Float>(S);
23229	}
23230	bool EvalEmitter::emitFlipMemberPtrSint8(SourceInfo L) {
23231	if (!isActive()) return true;
23232	CurrentSource = L;
23233	return Flip<PT_MemberPtr, PT_Sint8>(S);
23234	}
23235	bool EvalEmitter::emitFlipMemberPtrUint8(SourceInfo L) {
23236	if (!isActive()) return true;
23237	CurrentSource = L;
23238	return Flip<PT_MemberPtr, PT_Uint8>(S);
23239	}
23240	bool EvalEmitter::emitFlipMemberPtrSint16(SourceInfo L) {
23241	if (!isActive()) return true;
23242	CurrentSource = L;
23243	return Flip<PT_MemberPtr, PT_Sint16>(S);
23244	}
23245	bool EvalEmitter::emitFlipMemberPtrUint16(SourceInfo L) {
23246	if (!isActive()) return true;
23247	CurrentSource = L;
23248	return Flip<PT_MemberPtr, PT_Uint16>(S);
23249	}
23250	bool EvalEmitter::emitFlipMemberPtrSint32(SourceInfo L) {
23251	if (!isActive()) return true;
23252	CurrentSource = L;
23253	return Flip<PT_MemberPtr, PT_Sint32>(S);
23254	}
23255	bool EvalEmitter::emitFlipMemberPtrUint32(SourceInfo L) {
23256	if (!isActive()) return true;
23257	CurrentSource = L;
23258	return Flip<PT_MemberPtr, PT_Uint32>(S);
23259	}
23260	bool EvalEmitter::emitFlipMemberPtrSint64(SourceInfo L) {
23261	if (!isActive()) return true;
23262	CurrentSource = L;
23263	return Flip<PT_MemberPtr, PT_Sint64>(S);
23264	}
23265	bool EvalEmitter::emitFlipMemberPtrUint64(SourceInfo L) {
23266	if (!isActive()) return true;
23267	CurrentSource = L;
23268	return Flip<PT_MemberPtr, PT_Uint64>(S);
23269	}
23270	bool EvalEmitter::emitFlipMemberPtrIntAP(SourceInfo L) {
23271	if (!isActive()) return true;
23272	CurrentSource = L;
23273	return Flip<PT_MemberPtr, PT_IntAP>(S);
23274	}
23275	bool EvalEmitter::emitFlipMemberPtrIntAPS(SourceInfo L) {
23276	if (!isActive()) return true;
23277	CurrentSource = L;
23278	return Flip<PT_MemberPtr, PT_IntAPS>(S);
23279	}
23280	bool EvalEmitter::emitFlipMemberPtrBool(SourceInfo L) {
23281	if (!isActive()) return true;
23282	CurrentSource = L;
23283	return Flip<PT_MemberPtr, PT_Bool>(S);
23284	}
23285	bool EvalEmitter::emitFlipMemberPtrFixedPoint(SourceInfo L) {
23286	if (!isActive()) return true;
23287	CurrentSource = L;
23288	return Flip<PT_MemberPtr, PT_FixedPoint>(S);
23289	}
23290	bool EvalEmitter::emitFlipMemberPtrPtr(SourceInfo L) {
23291	if (!isActive()) return true;
23292	CurrentSource = L;
23293	return Flip<PT_MemberPtr, PT_Ptr>(S);
23294	}
23295	bool EvalEmitter::emitFlipMemberPtrMemberPtr(SourceInfo L) {
23296	if (!isActive()) return true;
23297	CurrentSource = L;
23298	return Flip<PT_MemberPtr, PT_MemberPtr>(S);
23299	}
23300	bool EvalEmitter::emitFlipMemberPtrFloat(SourceInfo L) {
23301	if (!isActive()) return true;
23302	CurrentSource = L;
23303	return Flip<PT_MemberPtr, PT_Float>(S);
23304	}
23305	bool EvalEmitter::emitFlipFloatSint8(SourceInfo L) {
23306	if (!isActive()) return true;
23307	CurrentSource = L;
23308	return Flip<PT_Float, PT_Sint8>(S);
23309	}
23310	bool EvalEmitter::emitFlipFloatUint8(SourceInfo L) {
23311	if (!isActive()) return true;
23312	CurrentSource = L;
23313	return Flip<PT_Float, PT_Uint8>(S);
23314	}
23315	bool EvalEmitter::emitFlipFloatSint16(SourceInfo L) {
23316	if (!isActive()) return true;
23317	CurrentSource = L;
23318	return Flip<PT_Float, PT_Sint16>(S);
23319	}
23320	bool EvalEmitter::emitFlipFloatUint16(SourceInfo L) {
23321	if (!isActive()) return true;
23322	CurrentSource = L;
23323	return Flip<PT_Float, PT_Uint16>(S);
23324	}
23325	bool EvalEmitter::emitFlipFloatSint32(SourceInfo L) {
23326	if (!isActive()) return true;
23327	CurrentSource = L;
23328	return Flip<PT_Float, PT_Sint32>(S);
23329	}
23330	bool EvalEmitter::emitFlipFloatUint32(SourceInfo L) {
23331	if (!isActive()) return true;
23332	CurrentSource = L;
23333	return Flip<PT_Float, PT_Uint32>(S);
23334	}
23335	bool EvalEmitter::emitFlipFloatSint64(SourceInfo L) {
23336	if (!isActive()) return true;
23337	CurrentSource = L;
23338	return Flip<PT_Float, PT_Sint64>(S);
23339	}
23340	bool EvalEmitter::emitFlipFloatUint64(SourceInfo L) {
23341	if (!isActive()) return true;
23342	CurrentSource = L;
23343	return Flip<PT_Float, PT_Uint64>(S);
23344	}
23345	bool EvalEmitter::emitFlipFloatIntAP(SourceInfo L) {
23346	if (!isActive()) return true;
23347	CurrentSource = L;
23348	return Flip<PT_Float, PT_IntAP>(S);
23349	}
23350	bool EvalEmitter::emitFlipFloatIntAPS(SourceInfo L) {
23351	if (!isActive()) return true;
23352	CurrentSource = L;
23353	return Flip<PT_Float, PT_IntAPS>(S);
23354	}
23355	bool EvalEmitter::emitFlipFloatBool(SourceInfo L) {
23356	if (!isActive()) return true;
23357	CurrentSource = L;
23358	return Flip<PT_Float, PT_Bool>(S);
23359	}
23360	bool EvalEmitter::emitFlipFloatFixedPoint(SourceInfo L) {
23361	if (!isActive()) return true;
23362	CurrentSource = L;
23363	return Flip<PT_Float, PT_FixedPoint>(S);
23364	}
23365	bool EvalEmitter::emitFlipFloatPtr(SourceInfo L) {
23366	if (!isActive()) return true;
23367	CurrentSource = L;
23368	return Flip<PT_Float, PT_Ptr>(S);
23369	}
23370	bool EvalEmitter::emitFlipFloatMemberPtr(SourceInfo L) {
23371	if (!isActive()) return true;
23372	CurrentSource = L;
23373	return Flip<PT_Float, PT_MemberPtr>(S);
23374	}
23375	bool EvalEmitter::emitFlipFloatFloat(SourceInfo L) {
23376	if (!isActive()) return true;
23377	CurrentSource = L;
23378	return Flip<PT_Float, PT_Float>(S);
23379	}
23380	#endif
23381	#ifdef GET_OPCODE_NAMES
23382	OP_FnPtrCast,
23383	#endif
23384	#ifdef GET_INTERPFN_LIST
23385	&Interp_FnPtrCast,
23386	#endif
23387	#ifdef GET_INTERPFN_DISPATCHERS
23388	PRESERVE_NONE
23389	static bool Interp_FnPtrCast(InterpState &S) {
23390	if (!FnPtrCast(S, S.PC)) return false;
23391	#if USE_TAILCALLS
23392	MUSTTAIL return InterpNext(S);
23393	#else
23394	return true;
23395	#endif
23396	}
23397	#endif
23398	#ifdef GET_DISASM
23399	case OP_FnPtrCast:
23400	Text.Op = PrintName("FnPtrCast");
23401	break;
23402	#endif
23403	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
23404	bool emitFnPtrCast(SourceInfo);
23405	#endif
23406	#ifdef GET_LINK_IMPL
23407	bool ByteCodeEmitter::emitFnPtrCast(SourceInfo L) {
23408	return emitOp<>(OP_FnPtrCast, L);
23409	}
23410	#endif
23411	#ifdef GET_EVAL_IMPL
23412	bool EvalEmitter::emitFnPtrCast(SourceInfo L) {
23413	if (!isActive()) return true;
23414	CurrentSource = L;
23415	return FnPtrCast(S, CodePtr());
23416	}
23417	#endif
23418	#ifdef GET_OPCODE_NAMES
23419	OP_Free,
23420	#endif
23421	#ifdef GET_INTERPFN_LIST
23422	&Interp_Free,
23423	#endif
23424	#ifdef GET_INTERPFN_DISPATCHERS
23425	PRESERVE_NONE
23426	static bool Interp_Free(InterpState &S) {
23427	{
23428	CodePtr OpPC = S.PC;
23429	const auto V0 = ReadArg<bool>(S, S.PC);
23430	const auto V1 = ReadArg<bool>(S, S.PC);
23431	if (!Free(S, OpPC, V0, V1)) return false;
23432	}
23433	#if USE_TAILCALLS
23434	MUSTTAIL return InterpNext(S);
23435	#else
23436	return true;
23437	#endif
23438	}
23439	#endif
23440	#ifdef GET_DISASM
23441	case OP_Free:
23442	Text.Op = PrintName("Free");
23443	Text.Args.push_back(printArg<bool>(P, PC));
23444	Text.Args.push_back(printArg<bool>(P, PC));
23445	break;
23446	#endif
23447	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
23448	bool emitFree( bool , bool , SourceInfo);
23449	#endif
23450	#ifdef GET_LINK_IMPL
23451	bool ByteCodeEmitter::emitFree( bool A0, bool A1, SourceInfo L) {
23452	return emitOp<bool, bool>(OP_Free, A0, A1, L);
23453	}
23454	#endif
23455	#ifdef GET_EVAL_IMPL
23456	bool EvalEmitter::emitFree( bool A0, bool A1, SourceInfo L) {
23457	if (!isActive()) return true;
23458	CurrentSource = L;
23459	return Free(S, CodePtr(), A0, A1);
23460	}
23461	#endif
23462	#ifdef GET_OPCODE_NAMES
23463	OP_GESint8,
23464	OP_GEUint8,
23465	OP_GESint16,
23466	OP_GEUint16,
23467	OP_GESint32,
23468	OP_GEUint32,
23469	OP_GESint64,
23470	OP_GEUint64,
23471	OP_GEIntAP,
23472	OP_GEIntAPS,
23473	OP_GEBool,
23474	OP_GEFixedPoint,
23475	OP_GEPtr,
23476	OP_GEFloat,
23477	#endif
23478	#ifdef GET_INTERPFN_LIST
23479	&Interp_GESint8,
23480	&Interp_GEUint8,
23481	&Interp_GESint16,
23482	&Interp_GEUint16,
23483	&Interp_GESint32,
23484	&Interp_GEUint32,
23485	&Interp_GESint64,
23486	&Interp_GEUint64,
23487	&Interp_GEIntAP,
23488	&Interp_GEIntAPS,
23489	&Interp_GEBool,
23490	&Interp_GEFixedPoint,
23491	&Interp_GEPtr,
23492	&Interp_GEFloat,
23493	#endif
23494	#ifdef GET_INTERPFN_DISPATCHERS
23495	PRESERVE_NONE
23496	static bool Interp_GESint8(InterpState &S) {
23497	if (!GE<PT_Sint8>(S, S.PC)) return false;
23498	#if USE_TAILCALLS
23499	MUSTTAIL return InterpNext(S);
23500	#else
23501	return true;
23502	#endif
23503	}
23504	PRESERVE_NONE
23505	static bool Interp_GEUint8(InterpState &S) {
23506	if (!GE<PT_Uint8>(S, S.PC)) return false;
23507	#if USE_TAILCALLS
23508	MUSTTAIL return InterpNext(S);
23509	#else
23510	return true;
23511	#endif
23512	}
23513	PRESERVE_NONE
23514	static bool Interp_GESint16(InterpState &S) {
23515	if (!GE<PT_Sint16>(S, S.PC)) return false;
23516	#if USE_TAILCALLS
23517	MUSTTAIL return InterpNext(S);
23518	#else
23519	return true;
23520	#endif
23521	}
23522	PRESERVE_NONE
23523	static bool Interp_GEUint16(InterpState &S) {
23524	if (!GE<PT_Uint16>(S, S.PC)) return false;
23525	#if USE_TAILCALLS
23526	MUSTTAIL return InterpNext(S);
23527	#else
23528	return true;
23529	#endif
23530	}
23531	PRESERVE_NONE
23532	static bool Interp_GESint32(InterpState &S) {
23533	if (!GE<PT_Sint32>(S, S.PC)) return false;
23534	#if USE_TAILCALLS
23535	MUSTTAIL return InterpNext(S);
23536	#else
23537	return true;
23538	#endif
23539	}
23540	PRESERVE_NONE
23541	static bool Interp_GEUint32(InterpState &S) {
23542	if (!GE<PT_Uint32>(S, S.PC)) return false;
23543	#if USE_TAILCALLS
23544	MUSTTAIL return InterpNext(S);
23545	#else
23546	return true;
23547	#endif
23548	}
23549	PRESERVE_NONE
23550	static bool Interp_GESint64(InterpState &S) {
23551	if (!GE<PT_Sint64>(S, S.PC)) return false;
23552	#if USE_TAILCALLS
23553	MUSTTAIL return InterpNext(S);
23554	#else
23555	return true;
23556	#endif
23557	}
23558	PRESERVE_NONE
23559	static bool Interp_GEUint64(InterpState &S) {
23560	if (!GE<PT_Uint64>(S, S.PC)) return false;
23561	#if USE_TAILCALLS
23562	MUSTTAIL return InterpNext(S);
23563	#else
23564	return true;
23565	#endif
23566	}
23567	PRESERVE_NONE
23568	static bool Interp_GEIntAP(InterpState &S) {
23569	if (!GE<PT_IntAP>(S, S.PC)) return false;
23570	#if USE_TAILCALLS
23571	MUSTTAIL return InterpNext(S);
23572	#else
23573	return true;
23574	#endif
23575	}
23576	PRESERVE_NONE
23577	static bool Interp_GEIntAPS(InterpState &S) {
23578	if (!GE<PT_IntAPS>(S, S.PC)) return false;
23579	#if USE_TAILCALLS
23580	MUSTTAIL return InterpNext(S);
23581	#else
23582	return true;
23583	#endif
23584	}
23585	PRESERVE_NONE
23586	static bool Interp_GEBool(InterpState &S) {
23587	if (!GE<PT_Bool>(S, S.PC)) return false;
23588	#if USE_TAILCALLS
23589	MUSTTAIL return InterpNext(S);
23590	#else
23591	return true;
23592	#endif
23593	}
23594	PRESERVE_NONE
23595	static bool Interp_GEFixedPoint(InterpState &S) {
23596	if (!GE<PT_FixedPoint>(S, S.PC)) return false;
23597	#if USE_TAILCALLS
23598	MUSTTAIL return InterpNext(S);
23599	#else
23600	return true;
23601	#endif
23602	}
23603	PRESERVE_NONE
23604	static bool Interp_GEPtr(InterpState &S) {
23605	if (!GE<PT_Ptr>(S, S.PC)) return false;
23606	#if USE_TAILCALLS
23607	MUSTTAIL return InterpNext(S);
23608	#else
23609	return true;
23610	#endif
23611	}
23612	PRESERVE_NONE
23613	static bool Interp_GEFloat(InterpState &S) {
23614	if (!GE<PT_Float>(S, S.PC)) return false;
23615	#if USE_TAILCALLS
23616	MUSTTAIL return InterpNext(S);
23617	#else
23618	return true;
23619	#endif
23620	}
23621	#endif
23622	#ifdef GET_DISASM
23623	case OP_GESint8:
23624	Text.Op = PrintName("GESint8");
23625	break;
23626	case OP_GEUint8:
23627	Text.Op = PrintName("GEUint8");
23628	break;
23629	case OP_GESint16:
23630	Text.Op = PrintName("GESint16");
23631	break;
23632	case OP_GEUint16:
23633	Text.Op = PrintName("GEUint16");
23634	break;
23635	case OP_GESint32:
23636	Text.Op = PrintName("GESint32");
23637	break;
23638	case OP_GEUint32:
23639	Text.Op = PrintName("GEUint32");
23640	break;
23641	case OP_GESint64:
23642	Text.Op = PrintName("GESint64");
23643	break;
23644	case OP_GEUint64:
23645	Text.Op = PrintName("GEUint64");
23646	break;
23647	case OP_GEIntAP:
23648	Text.Op = PrintName("GEIntAP");
23649	break;
23650	case OP_GEIntAPS:
23651	Text.Op = PrintName("GEIntAPS");
23652	break;
23653	case OP_GEBool:
23654	Text.Op = PrintName("GEBool");
23655	break;
23656	case OP_GEFixedPoint:
23657	Text.Op = PrintName("GEFixedPoint");
23658	break;
23659	case OP_GEPtr:
23660	Text.Op = PrintName("GEPtr");
23661	break;
23662	case OP_GEFloat:
23663	Text.Op = PrintName("GEFloat");
23664	break;
23665	#endif
23666	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
23667	bool emitGESint8(SourceInfo);
23668	bool emitGEUint8(SourceInfo);
23669	bool emitGESint16(SourceInfo);
23670	bool emitGEUint16(SourceInfo);
23671	bool emitGESint32(SourceInfo);
23672	bool emitGEUint32(SourceInfo);
23673	bool emitGESint64(SourceInfo);
23674	bool emitGEUint64(SourceInfo);
23675	bool emitGEIntAP(SourceInfo);
23676	bool emitGEIntAPS(SourceInfo);
23677	bool emitGEBool(SourceInfo);
23678	bool emitGEFixedPoint(SourceInfo);
23679	bool emitGEPtr(SourceInfo);
23680	bool emitGEFloat(SourceInfo);
23681	#endif
23682	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
23683	[[nodiscard]] bool emitGE(PrimType, SourceInfo I);
23684	#endif
23685	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
23686	bool
23687	#if defined(GET_EVAL_IMPL)
23688	EvalEmitter
23689	#else
23690	ByteCodeEmitter
23691	#endif
23692	::emitGE(PrimType T0, SourceInfo I) {
23693	switch (T0) {
23694	case PT_Sint8:
23695	return emitGESint8(I);
23696	case PT_Uint8:
23697	return emitGEUint8(I);
23698	case PT_Sint16:
23699	return emitGESint16(I);
23700	case PT_Uint16:
23701	return emitGEUint16(I);
23702	case PT_Sint32:
23703	return emitGESint32(I);
23704	case PT_Uint32:
23705	return emitGEUint32(I);
23706	case PT_Sint64:
23707	return emitGESint64(I);
23708	case PT_Uint64:
23709	return emitGEUint64(I);
23710	case PT_IntAP:
23711	return emitGEIntAP(I);
23712	case PT_IntAPS:
23713	return emitGEIntAPS(I);
23714	case PT_Bool:
23715	return emitGEBool(I);
23716	case PT_FixedPoint:
23717	return emitGEFixedPoint(I);
23718	case PT_Ptr:
23719	return emitGEPtr(I);
23720	case PT_Float:
23721	return emitGEFloat(I);
23722	default: llvm_unreachable("invalid type: emitGE");
23723	}
23724	llvm_unreachable("invalid enum value");
23725	}
23726	#endif
23727	#ifdef GET_LINK_IMPL
23728	bool ByteCodeEmitter::emitGESint8(SourceInfo L) {
23729	return emitOp<>(OP_GESint8, L);
23730	}
23731	bool ByteCodeEmitter::emitGEUint8(SourceInfo L) {
23732	return emitOp<>(OP_GEUint8, L);
23733	}
23734	bool ByteCodeEmitter::emitGESint16(SourceInfo L) {
23735	return emitOp<>(OP_GESint16, L);
23736	}
23737	bool ByteCodeEmitter::emitGEUint16(SourceInfo L) {
23738	return emitOp<>(OP_GEUint16, L);
23739	}
23740	bool ByteCodeEmitter::emitGESint32(SourceInfo L) {
23741	return emitOp<>(OP_GESint32, L);
23742	}
23743	bool ByteCodeEmitter::emitGEUint32(SourceInfo L) {
23744	return emitOp<>(OP_GEUint32, L);
23745	}
23746	bool ByteCodeEmitter::emitGESint64(SourceInfo L) {
23747	return emitOp<>(OP_GESint64, L);
23748	}
23749	bool ByteCodeEmitter::emitGEUint64(SourceInfo L) {
23750	return emitOp<>(OP_GEUint64, L);
23751	}
23752	bool ByteCodeEmitter::emitGEIntAP(SourceInfo L) {
23753	return emitOp<>(OP_GEIntAP, L);
23754	}
23755	bool ByteCodeEmitter::emitGEIntAPS(SourceInfo L) {
23756	return emitOp<>(OP_GEIntAPS, L);
23757	}
23758	bool ByteCodeEmitter::emitGEBool(SourceInfo L) {
23759	return emitOp<>(OP_GEBool, L);
23760	}
23761	bool ByteCodeEmitter::emitGEFixedPoint(SourceInfo L) {
23762	return emitOp<>(OP_GEFixedPoint, L);
23763	}
23764	bool ByteCodeEmitter::emitGEPtr(SourceInfo L) {
23765	return emitOp<>(OP_GEPtr, L);
23766	}
23767	bool ByteCodeEmitter::emitGEFloat(SourceInfo L) {
23768	return emitOp<>(OP_GEFloat, L);
23769	}
23770	#endif
23771	#ifdef GET_EVAL_IMPL
23772	bool EvalEmitter::emitGESint8(SourceInfo L) {
23773	if (!isActive()) return true;
23774	CurrentSource = L;
23775	return GE<PT_Sint8>(S, CodePtr());
23776	}
23777	bool EvalEmitter::emitGEUint8(SourceInfo L) {
23778	if (!isActive()) return true;
23779	CurrentSource = L;
23780	return GE<PT_Uint8>(S, CodePtr());
23781	}
23782	bool EvalEmitter::emitGESint16(SourceInfo L) {
23783	if (!isActive()) return true;
23784	CurrentSource = L;
23785	return GE<PT_Sint16>(S, CodePtr());
23786	}
23787	bool EvalEmitter::emitGEUint16(SourceInfo L) {
23788	if (!isActive()) return true;
23789	CurrentSource = L;
23790	return GE<PT_Uint16>(S, CodePtr());
23791	}
23792	bool EvalEmitter::emitGESint32(SourceInfo L) {
23793	if (!isActive()) return true;
23794	CurrentSource = L;
23795	return GE<PT_Sint32>(S, CodePtr());
23796	}
23797	bool EvalEmitter::emitGEUint32(SourceInfo L) {
23798	if (!isActive()) return true;
23799	CurrentSource = L;
23800	return GE<PT_Uint32>(S, CodePtr());
23801	}
23802	bool EvalEmitter::emitGESint64(SourceInfo L) {
23803	if (!isActive()) return true;
23804	CurrentSource = L;
23805	return GE<PT_Sint64>(S, CodePtr());
23806	}
23807	bool EvalEmitter::emitGEUint64(SourceInfo L) {
23808	if (!isActive()) return true;
23809	CurrentSource = L;
23810	return GE<PT_Uint64>(S, CodePtr());
23811	}
23812	bool EvalEmitter::emitGEIntAP(SourceInfo L) {
23813	if (!isActive()) return true;
23814	CurrentSource = L;
23815	return GE<PT_IntAP>(S, CodePtr());
23816	}
23817	bool EvalEmitter::emitGEIntAPS(SourceInfo L) {
23818	if (!isActive()) return true;
23819	CurrentSource = L;
23820	return GE<PT_IntAPS>(S, CodePtr());
23821	}
23822	bool EvalEmitter::emitGEBool(SourceInfo L) {
23823	if (!isActive()) return true;
23824	CurrentSource = L;
23825	return GE<PT_Bool>(S, CodePtr());
23826	}
23827	bool EvalEmitter::emitGEFixedPoint(SourceInfo L) {
23828	if (!isActive()) return true;
23829	CurrentSource = L;
23830	return GE<PT_FixedPoint>(S, CodePtr());
23831	}
23832	bool EvalEmitter::emitGEPtr(SourceInfo L) {
23833	if (!isActive()) return true;
23834	CurrentSource = L;
23835	return GE<PT_Ptr>(S, CodePtr());
23836	}
23837	bool EvalEmitter::emitGEFloat(SourceInfo L) {
23838	if (!isActive()) return true;
23839	CurrentSource = L;
23840	return GE<PT_Float>(S, CodePtr());
23841	}
23842	#endif
23843	#ifdef GET_OPCODE_NAMES
23844	OP_GTSint8,
23845	OP_GTUint8,
23846	OP_GTSint16,
23847	OP_GTUint16,
23848	OP_GTSint32,
23849	OP_GTUint32,
23850	OP_GTSint64,
23851	OP_GTUint64,
23852	OP_GTIntAP,
23853	OP_GTIntAPS,
23854	OP_GTBool,
23855	OP_GTFixedPoint,
23856	OP_GTPtr,
23857	OP_GTFloat,
23858	#endif
23859	#ifdef GET_INTERPFN_LIST
23860	&Interp_GTSint8,
23861	&Interp_GTUint8,
23862	&Interp_GTSint16,
23863	&Interp_GTUint16,
23864	&Interp_GTSint32,
23865	&Interp_GTUint32,
23866	&Interp_GTSint64,
23867	&Interp_GTUint64,
23868	&Interp_GTIntAP,
23869	&Interp_GTIntAPS,
23870	&Interp_GTBool,
23871	&Interp_GTFixedPoint,
23872	&Interp_GTPtr,
23873	&Interp_GTFloat,
23874	#endif
23875	#ifdef GET_INTERPFN_DISPATCHERS
23876	PRESERVE_NONE
23877	static bool Interp_GTSint8(InterpState &S) {
23878	if (!GT<PT_Sint8>(S, S.PC)) return false;
23879	#if USE_TAILCALLS
23880	MUSTTAIL return InterpNext(S);
23881	#else
23882	return true;
23883	#endif
23884	}
23885	PRESERVE_NONE
23886	static bool Interp_GTUint8(InterpState &S) {
23887	if (!GT<PT_Uint8>(S, S.PC)) return false;
23888	#if USE_TAILCALLS
23889	MUSTTAIL return InterpNext(S);
23890	#else
23891	return true;
23892	#endif
23893	}
23894	PRESERVE_NONE
23895	static bool Interp_GTSint16(InterpState &S) {
23896	if (!GT<PT_Sint16>(S, S.PC)) return false;
23897	#if USE_TAILCALLS
23898	MUSTTAIL return InterpNext(S);
23899	#else
23900	return true;
23901	#endif
23902	}
23903	PRESERVE_NONE
23904	static bool Interp_GTUint16(InterpState &S) {
23905	if (!GT<PT_Uint16>(S, S.PC)) return false;
23906	#if USE_TAILCALLS
23907	MUSTTAIL return InterpNext(S);
23908	#else
23909	return true;
23910	#endif
23911	}
23912	PRESERVE_NONE
23913	static bool Interp_GTSint32(InterpState &S) {
23914	if (!GT<PT_Sint32>(S, S.PC)) return false;
23915	#if USE_TAILCALLS
23916	MUSTTAIL return InterpNext(S);
23917	#else
23918	return true;
23919	#endif
23920	}
23921	PRESERVE_NONE
23922	static bool Interp_GTUint32(InterpState &S) {
23923	if (!GT<PT_Uint32>(S, S.PC)) return false;
23924	#if USE_TAILCALLS
23925	MUSTTAIL return InterpNext(S);
23926	#else
23927	return true;
23928	#endif
23929	}
23930	PRESERVE_NONE
23931	static bool Interp_GTSint64(InterpState &S) {
23932	if (!GT<PT_Sint64>(S, S.PC)) return false;
23933	#if USE_TAILCALLS
23934	MUSTTAIL return InterpNext(S);
23935	#else
23936	return true;
23937	#endif
23938	}
23939	PRESERVE_NONE
23940	static bool Interp_GTUint64(InterpState &S) {
23941	if (!GT<PT_Uint64>(S, S.PC)) return false;
23942	#if USE_TAILCALLS
23943	MUSTTAIL return InterpNext(S);
23944	#else
23945	return true;
23946	#endif
23947	}
23948	PRESERVE_NONE
23949	static bool Interp_GTIntAP(InterpState &S) {
23950	if (!GT<PT_IntAP>(S, S.PC)) return false;
23951	#if USE_TAILCALLS
23952	MUSTTAIL return InterpNext(S);
23953	#else
23954	return true;
23955	#endif
23956	}
23957	PRESERVE_NONE
23958	static bool Interp_GTIntAPS(InterpState &S) {
23959	if (!GT<PT_IntAPS>(S, S.PC)) return false;
23960	#if USE_TAILCALLS
23961	MUSTTAIL return InterpNext(S);
23962	#else
23963	return true;
23964	#endif
23965	}
23966	PRESERVE_NONE
23967	static bool Interp_GTBool(InterpState &S) {
23968	if (!GT<PT_Bool>(S, S.PC)) return false;
23969	#if USE_TAILCALLS
23970	MUSTTAIL return InterpNext(S);
23971	#else
23972	return true;
23973	#endif
23974	}
23975	PRESERVE_NONE
23976	static bool Interp_GTFixedPoint(InterpState &S) {
23977	if (!GT<PT_FixedPoint>(S, S.PC)) return false;
23978	#if USE_TAILCALLS
23979	MUSTTAIL return InterpNext(S);
23980	#else
23981	return true;
23982	#endif
23983	}
23984	PRESERVE_NONE
23985	static bool Interp_GTPtr(InterpState &S) {
23986	if (!GT<PT_Ptr>(S, S.PC)) return false;
23987	#if USE_TAILCALLS
23988	MUSTTAIL return InterpNext(S);
23989	#else
23990	return true;
23991	#endif
23992	}
23993	PRESERVE_NONE
23994	static bool Interp_GTFloat(InterpState &S) {
23995	if (!GT<PT_Float>(S, S.PC)) return false;
23996	#if USE_TAILCALLS
23997	MUSTTAIL return InterpNext(S);
23998	#else
23999	return true;
24000	#endif
24001	}
24002	#endif
24003	#ifdef GET_DISASM
24004	case OP_GTSint8:
24005	Text.Op = PrintName("GTSint8");
24006	break;
24007	case OP_GTUint8:
24008	Text.Op = PrintName("GTUint8");
24009	break;
24010	case OP_GTSint16:
24011	Text.Op = PrintName("GTSint16");
24012	break;
24013	case OP_GTUint16:
24014	Text.Op = PrintName("GTUint16");
24015	break;
24016	case OP_GTSint32:
24017	Text.Op = PrintName("GTSint32");
24018	break;
24019	case OP_GTUint32:
24020	Text.Op = PrintName("GTUint32");
24021	break;
24022	case OP_GTSint64:
24023	Text.Op = PrintName("GTSint64");
24024	break;
24025	case OP_GTUint64:
24026	Text.Op = PrintName("GTUint64");
24027	break;
24028	case OP_GTIntAP:
24029	Text.Op = PrintName("GTIntAP");
24030	break;
24031	case OP_GTIntAPS:
24032	Text.Op = PrintName("GTIntAPS");
24033	break;
24034	case OP_GTBool:
24035	Text.Op = PrintName("GTBool");
24036	break;
24037	case OP_GTFixedPoint:
24038	Text.Op = PrintName("GTFixedPoint");
24039	break;
24040	case OP_GTPtr:
24041	Text.Op = PrintName("GTPtr");
24042	break;
24043	case OP_GTFloat:
24044	Text.Op = PrintName("GTFloat");
24045	break;
24046	#endif
24047	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24048	bool emitGTSint8(SourceInfo);
24049	bool emitGTUint8(SourceInfo);
24050	bool emitGTSint16(SourceInfo);
24051	bool emitGTUint16(SourceInfo);
24052	bool emitGTSint32(SourceInfo);
24053	bool emitGTUint32(SourceInfo);
24054	bool emitGTSint64(SourceInfo);
24055	bool emitGTUint64(SourceInfo);
24056	bool emitGTIntAP(SourceInfo);
24057	bool emitGTIntAPS(SourceInfo);
24058	bool emitGTBool(SourceInfo);
24059	bool emitGTFixedPoint(SourceInfo);
24060	bool emitGTPtr(SourceInfo);
24061	bool emitGTFloat(SourceInfo);
24062	#endif
24063	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24064	[[nodiscard]] bool emitGT(PrimType, SourceInfo I);
24065	#endif
24066	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
24067	bool
24068	#if defined(GET_EVAL_IMPL)
24069	EvalEmitter
24070	#else
24071	ByteCodeEmitter
24072	#endif
24073	::emitGT(PrimType T0, SourceInfo I) {
24074	switch (T0) {
24075	case PT_Sint8:
24076	return emitGTSint8(I);
24077	case PT_Uint8:
24078	return emitGTUint8(I);
24079	case PT_Sint16:
24080	return emitGTSint16(I);
24081	case PT_Uint16:
24082	return emitGTUint16(I);
24083	case PT_Sint32:
24084	return emitGTSint32(I);
24085	case PT_Uint32:
24086	return emitGTUint32(I);
24087	case PT_Sint64:
24088	return emitGTSint64(I);
24089	case PT_Uint64:
24090	return emitGTUint64(I);
24091	case PT_IntAP:
24092	return emitGTIntAP(I);
24093	case PT_IntAPS:
24094	return emitGTIntAPS(I);
24095	case PT_Bool:
24096	return emitGTBool(I);
24097	case PT_FixedPoint:
24098	return emitGTFixedPoint(I);
24099	case PT_Ptr:
24100	return emitGTPtr(I);
24101	case PT_Float:
24102	return emitGTFloat(I);
24103	default: llvm_unreachable("invalid type: emitGT");
24104	}
24105	llvm_unreachable("invalid enum value");
24106	}
24107	#endif
24108	#ifdef GET_LINK_IMPL
24109	bool ByteCodeEmitter::emitGTSint8(SourceInfo L) {
24110	return emitOp<>(OP_GTSint8, L);
24111	}
24112	bool ByteCodeEmitter::emitGTUint8(SourceInfo L) {
24113	return emitOp<>(OP_GTUint8, L);
24114	}
24115	bool ByteCodeEmitter::emitGTSint16(SourceInfo L) {
24116	return emitOp<>(OP_GTSint16, L);
24117	}
24118	bool ByteCodeEmitter::emitGTUint16(SourceInfo L) {
24119	return emitOp<>(OP_GTUint16, L);
24120	}
24121	bool ByteCodeEmitter::emitGTSint32(SourceInfo L) {
24122	return emitOp<>(OP_GTSint32, L);
24123	}
24124	bool ByteCodeEmitter::emitGTUint32(SourceInfo L) {
24125	return emitOp<>(OP_GTUint32, L);
24126	}
24127	bool ByteCodeEmitter::emitGTSint64(SourceInfo L) {
24128	return emitOp<>(OP_GTSint64, L);
24129	}
24130	bool ByteCodeEmitter::emitGTUint64(SourceInfo L) {
24131	return emitOp<>(OP_GTUint64, L);
24132	}
24133	bool ByteCodeEmitter::emitGTIntAP(SourceInfo L) {
24134	return emitOp<>(OP_GTIntAP, L);
24135	}
24136	bool ByteCodeEmitter::emitGTIntAPS(SourceInfo L) {
24137	return emitOp<>(OP_GTIntAPS, L);
24138	}
24139	bool ByteCodeEmitter::emitGTBool(SourceInfo L) {
24140	return emitOp<>(OP_GTBool, L);
24141	}
24142	bool ByteCodeEmitter::emitGTFixedPoint(SourceInfo L) {
24143	return emitOp<>(OP_GTFixedPoint, L);
24144	}
24145	bool ByteCodeEmitter::emitGTPtr(SourceInfo L) {
24146	return emitOp<>(OP_GTPtr, L);
24147	}
24148	bool ByteCodeEmitter::emitGTFloat(SourceInfo L) {
24149	return emitOp<>(OP_GTFloat, L);
24150	}
24151	#endif
24152	#ifdef GET_EVAL_IMPL
24153	bool EvalEmitter::emitGTSint8(SourceInfo L) {
24154	if (!isActive()) return true;
24155	CurrentSource = L;
24156	return GT<PT_Sint8>(S, CodePtr());
24157	}
24158	bool EvalEmitter::emitGTUint8(SourceInfo L) {
24159	if (!isActive()) return true;
24160	CurrentSource = L;
24161	return GT<PT_Uint8>(S, CodePtr());
24162	}
24163	bool EvalEmitter::emitGTSint16(SourceInfo L) {
24164	if (!isActive()) return true;
24165	CurrentSource = L;
24166	return GT<PT_Sint16>(S, CodePtr());
24167	}
24168	bool EvalEmitter::emitGTUint16(SourceInfo L) {
24169	if (!isActive()) return true;
24170	CurrentSource = L;
24171	return GT<PT_Uint16>(S, CodePtr());
24172	}
24173	bool EvalEmitter::emitGTSint32(SourceInfo L) {
24174	if (!isActive()) return true;
24175	CurrentSource = L;
24176	return GT<PT_Sint32>(S, CodePtr());
24177	}
24178	bool EvalEmitter::emitGTUint32(SourceInfo L) {
24179	if (!isActive()) return true;
24180	CurrentSource = L;
24181	return GT<PT_Uint32>(S, CodePtr());
24182	}
24183	bool EvalEmitter::emitGTSint64(SourceInfo L) {
24184	if (!isActive()) return true;
24185	CurrentSource = L;
24186	return GT<PT_Sint64>(S, CodePtr());
24187	}
24188	bool EvalEmitter::emitGTUint64(SourceInfo L) {
24189	if (!isActive()) return true;
24190	CurrentSource = L;
24191	return GT<PT_Uint64>(S, CodePtr());
24192	}
24193	bool EvalEmitter::emitGTIntAP(SourceInfo L) {
24194	if (!isActive()) return true;
24195	CurrentSource = L;
24196	return GT<PT_IntAP>(S, CodePtr());
24197	}
24198	bool EvalEmitter::emitGTIntAPS(SourceInfo L) {
24199	if (!isActive()) return true;
24200	CurrentSource = L;
24201	return GT<PT_IntAPS>(S, CodePtr());
24202	}
24203	bool EvalEmitter::emitGTBool(SourceInfo L) {
24204	if (!isActive()) return true;
24205	CurrentSource = L;
24206	return GT<PT_Bool>(S, CodePtr());
24207	}
24208	bool EvalEmitter::emitGTFixedPoint(SourceInfo L) {
24209	if (!isActive()) return true;
24210	CurrentSource = L;
24211	return GT<PT_FixedPoint>(S, CodePtr());
24212	}
24213	bool EvalEmitter::emitGTPtr(SourceInfo L) {
24214	if (!isActive()) return true;
24215	CurrentSource = L;
24216	return GT<PT_Ptr>(S, CodePtr());
24217	}
24218	bool EvalEmitter::emitGTFloat(SourceInfo L) {
24219	if (!isActive()) return true;
24220	CurrentSource = L;
24221	return GT<PT_Float>(S, CodePtr());
24222	}
24223	#endif
24224	#ifdef GET_OPCODE_NAMES
24225	OP_GetFieldSint8,
24226	OP_GetFieldUint8,
24227	OP_GetFieldSint16,
24228	OP_GetFieldUint16,
24229	OP_GetFieldSint32,
24230	OP_GetFieldUint32,
24231	OP_GetFieldSint64,
24232	OP_GetFieldUint64,
24233	OP_GetFieldIntAP,
24234	OP_GetFieldIntAPS,
24235	OP_GetFieldBool,
24236	OP_GetFieldFixedPoint,
24237	OP_GetFieldPtr,
24238	OP_GetFieldMemberPtr,
24239	OP_GetFieldFloat,
24240	#endif
24241	#ifdef GET_INTERPFN_LIST
24242	&Interp_GetFieldSint8,
24243	&Interp_GetFieldUint8,
24244	&Interp_GetFieldSint16,
24245	&Interp_GetFieldUint16,
24246	&Interp_GetFieldSint32,
24247	&Interp_GetFieldUint32,
24248	&Interp_GetFieldSint64,
24249	&Interp_GetFieldUint64,
24250	&Interp_GetFieldIntAP,
24251	&Interp_GetFieldIntAPS,
24252	&Interp_GetFieldBool,
24253	&Interp_GetFieldFixedPoint,
24254	&Interp_GetFieldPtr,
24255	&Interp_GetFieldMemberPtr,
24256	&Interp_GetFieldFloat,
24257	#endif
24258	#ifdef GET_INTERPFN_DISPATCHERS
24259	PRESERVE_NONE
24260	static bool Interp_GetFieldSint8(InterpState &S) {
24261	{
24262	CodePtr OpPC = S.PC;
24263	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24264	if (!GetField<PT_Sint8>(S, OpPC, V0)) return false;
24265	}
24266	#if USE_TAILCALLS
24267	MUSTTAIL return InterpNext(S);
24268	#else
24269	return true;
24270	#endif
24271	}
24272	PRESERVE_NONE
24273	static bool Interp_GetFieldUint8(InterpState &S) {
24274	{
24275	CodePtr OpPC = S.PC;
24276	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24277	if (!GetField<PT_Uint8>(S, OpPC, V0)) return false;
24278	}
24279	#if USE_TAILCALLS
24280	MUSTTAIL return InterpNext(S);
24281	#else
24282	return true;
24283	#endif
24284	}
24285	PRESERVE_NONE
24286	static bool Interp_GetFieldSint16(InterpState &S) {
24287	{
24288	CodePtr OpPC = S.PC;
24289	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24290	if (!GetField<PT_Sint16>(S, OpPC, V0)) return false;
24291	}
24292	#if USE_TAILCALLS
24293	MUSTTAIL return InterpNext(S);
24294	#else
24295	return true;
24296	#endif
24297	}
24298	PRESERVE_NONE
24299	static bool Interp_GetFieldUint16(InterpState &S) {
24300	{
24301	CodePtr OpPC = S.PC;
24302	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24303	if (!GetField<PT_Uint16>(S, OpPC, V0)) return false;
24304	}
24305	#if USE_TAILCALLS
24306	MUSTTAIL return InterpNext(S);
24307	#else
24308	return true;
24309	#endif
24310	}
24311	PRESERVE_NONE
24312	static bool Interp_GetFieldSint32(InterpState &S) {
24313	{
24314	CodePtr OpPC = S.PC;
24315	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24316	if (!GetField<PT_Sint32>(S, OpPC, V0)) return false;
24317	}
24318	#if USE_TAILCALLS
24319	MUSTTAIL return InterpNext(S);
24320	#else
24321	return true;
24322	#endif
24323	}
24324	PRESERVE_NONE
24325	static bool Interp_GetFieldUint32(InterpState &S) {
24326	{
24327	CodePtr OpPC = S.PC;
24328	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24329	if (!GetField<PT_Uint32>(S, OpPC, V0)) return false;
24330	}
24331	#if USE_TAILCALLS
24332	MUSTTAIL return InterpNext(S);
24333	#else
24334	return true;
24335	#endif
24336	}
24337	PRESERVE_NONE
24338	static bool Interp_GetFieldSint64(InterpState &S) {
24339	{
24340	CodePtr OpPC = S.PC;
24341	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24342	if (!GetField<PT_Sint64>(S, OpPC, V0)) return false;
24343	}
24344	#if USE_TAILCALLS
24345	MUSTTAIL return InterpNext(S);
24346	#else
24347	return true;
24348	#endif
24349	}
24350	PRESERVE_NONE
24351	static bool Interp_GetFieldUint64(InterpState &S) {
24352	{
24353	CodePtr OpPC = S.PC;
24354	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24355	if (!GetField<PT_Uint64>(S, OpPC, V0)) return false;
24356	}
24357	#if USE_TAILCALLS
24358	MUSTTAIL return InterpNext(S);
24359	#else
24360	return true;
24361	#endif
24362	}
24363	PRESERVE_NONE
24364	static bool Interp_GetFieldIntAP(InterpState &S) {
24365	{
24366	CodePtr OpPC = S.PC;
24367	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24368	if (!GetField<PT_IntAP>(S, OpPC, V0)) return false;
24369	}
24370	#if USE_TAILCALLS
24371	MUSTTAIL return InterpNext(S);
24372	#else
24373	return true;
24374	#endif
24375	}
24376	PRESERVE_NONE
24377	static bool Interp_GetFieldIntAPS(InterpState &S) {
24378	{
24379	CodePtr OpPC = S.PC;
24380	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24381	if (!GetField<PT_IntAPS>(S, OpPC, V0)) return false;
24382	}
24383	#if USE_TAILCALLS
24384	MUSTTAIL return InterpNext(S);
24385	#else
24386	return true;
24387	#endif
24388	}
24389	PRESERVE_NONE
24390	static bool Interp_GetFieldBool(InterpState &S) {
24391	{
24392	CodePtr OpPC = S.PC;
24393	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24394	if (!GetField<PT_Bool>(S, OpPC, V0)) return false;
24395	}
24396	#if USE_TAILCALLS
24397	MUSTTAIL return InterpNext(S);
24398	#else
24399	return true;
24400	#endif
24401	}
24402	PRESERVE_NONE
24403	static bool Interp_GetFieldFixedPoint(InterpState &S) {
24404	{
24405	CodePtr OpPC = S.PC;
24406	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24407	if (!GetField<PT_FixedPoint>(S, OpPC, V0)) return false;
24408	}
24409	#if USE_TAILCALLS
24410	MUSTTAIL return InterpNext(S);
24411	#else
24412	return true;
24413	#endif
24414	}
24415	PRESERVE_NONE
24416	static bool Interp_GetFieldPtr(InterpState &S) {
24417	{
24418	CodePtr OpPC = S.PC;
24419	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24420	if (!GetField<PT_Ptr>(S, OpPC, V0)) return false;
24421	}
24422	#if USE_TAILCALLS
24423	MUSTTAIL return InterpNext(S);
24424	#else
24425	return true;
24426	#endif
24427	}
24428	PRESERVE_NONE
24429	static bool Interp_GetFieldMemberPtr(InterpState &S) {
24430	{
24431	CodePtr OpPC = S.PC;
24432	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24433	if (!GetField<PT_MemberPtr>(S, OpPC, V0)) return false;
24434	}
24435	#if USE_TAILCALLS
24436	MUSTTAIL return InterpNext(S);
24437	#else
24438	return true;
24439	#endif
24440	}
24441	PRESERVE_NONE
24442	static bool Interp_GetFieldFloat(InterpState &S) {
24443	{
24444	CodePtr OpPC = S.PC;
24445	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24446	if (!GetField<PT_Float>(S, OpPC, V0)) return false;
24447	}
24448	#if USE_TAILCALLS
24449	MUSTTAIL return InterpNext(S);
24450	#else
24451	return true;
24452	#endif
24453	}
24454	#endif
24455	#ifdef GET_DISASM
24456	case OP_GetFieldSint8:
24457	Text.Op = PrintName("GetFieldSint8");
24458	Text.Args.push_back(printArg<uint32_t>(P, PC));
24459	break;
24460	case OP_GetFieldUint8:
24461	Text.Op = PrintName("GetFieldUint8");
24462	Text.Args.push_back(printArg<uint32_t>(P, PC));
24463	break;
24464	case OP_GetFieldSint16:
24465	Text.Op = PrintName("GetFieldSint16");
24466	Text.Args.push_back(printArg<uint32_t>(P, PC));
24467	break;
24468	case OP_GetFieldUint16:
24469	Text.Op = PrintName("GetFieldUint16");
24470	Text.Args.push_back(printArg<uint32_t>(P, PC));
24471	break;
24472	case OP_GetFieldSint32:
24473	Text.Op = PrintName("GetFieldSint32");
24474	Text.Args.push_back(printArg<uint32_t>(P, PC));
24475	break;
24476	case OP_GetFieldUint32:
24477	Text.Op = PrintName("GetFieldUint32");
24478	Text.Args.push_back(printArg<uint32_t>(P, PC));
24479	break;
24480	case OP_GetFieldSint64:
24481	Text.Op = PrintName("GetFieldSint64");
24482	Text.Args.push_back(printArg<uint32_t>(P, PC));
24483	break;
24484	case OP_GetFieldUint64:
24485	Text.Op = PrintName("GetFieldUint64");
24486	Text.Args.push_back(printArg<uint32_t>(P, PC));
24487	break;
24488	case OP_GetFieldIntAP:
24489	Text.Op = PrintName("GetFieldIntAP");
24490	Text.Args.push_back(printArg<uint32_t>(P, PC));
24491	break;
24492	case OP_GetFieldIntAPS:
24493	Text.Op = PrintName("GetFieldIntAPS");
24494	Text.Args.push_back(printArg<uint32_t>(P, PC));
24495	break;
24496	case OP_GetFieldBool:
24497	Text.Op = PrintName("GetFieldBool");
24498	Text.Args.push_back(printArg<uint32_t>(P, PC));
24499	break;
24500	case OP_GetFieldFixedPoint:
24501	Text.Op = PrintName("GetFieldFixedPoint");
24502	Text.Args.push_back(printArg<uint32_t>(P, PC));
24503	break;
24504	case OP_GetFieldPtr:
24505	Text.Op = PrintName("GetFieldPtr");
24506	Text.Args.push_back(printArg<uint32_t>(P, PC));
24507	break;
24508	case OP_GetFieldMemberPtr:
24509	Text.Op = PrintName("GetFieldMemberPtr");
24510	Text.Args.push_back(printArg<uint32_t>(P, PC));
24511	break;
24512	case OP_GetFieldFloat:
24513	Text.Op = PrintName("GetFieldFloat");
24514	Text.Args.push_back(printArg<uint32_t>(P, PC));
24515	break;
24516	#endif
24517	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24518	bool emitGetFieldSint8( uint32_t , SourceInfo);
24519	bool emitGetFieldUint8( uint32_t , SourceInfo);
24520	bool emitGetFieldSint16( uint32_t , SourceInfo);
24521	bool emitGetFieldUint16( uint32_t , SourceInfo);
24522	bool emitGetFieldSint32( uint32_t , SourceInfo);
24523	bool emitGetFieldUint32( uint32_t , SourceInfo);
24524	bool emitGetFieldSint64( uint32_t , SourceInfo);
24525	bool emitGetFieldUint64( uint32_t , SourceInfo);
24526	bool emitGetFieldIntAP( uint32_t , SourceInfo);
24527	bool emitGetFieldIntAPS( uint32_t , SourceInfo);
24528	bool emitGetFieldBool( uint32_t , SourceInfo);
24529	bool emitGetFieldFixedPoint( uint32_t , SourceInfo);
24530	bool emitGetFieldPtr( uint32_t , SourceInfo);
24531	bool emitGetFieldMemberPtr( uint32_t , SourceInfo);
24532	bool emitGetFieldFloat( uint32_t , SourceInfo);
24533	#endif
24534	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24535	[[nodiscard]] bool emitGetField(PrimType, uint32_t, SourceInfo I);
24536	#endif
24537	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
24538	bool
24539	#if defined(GET_EVAL_IMPL)
24540	EvalEmitter
24541	#else
24542	ByteCodeEmitter
24543	#endif
24544	::emitGetField(PrimType T0, uint32_t A0, SourceInfo I) {
24545	switch (T0) {
24546	case PT_Sint8:
24547	return emitGetFieldSint8(A0, I);
24548	case PT_Uint8:
24549	return emitGetFieldUint8(A0, I);
24550	case PT_Sint16:
24551	return emitGetFieldSint16(A0, I);
24552	case PT_Uint16:
24553	return emitGetFieldUint16(A0, I);
24554	case PT_Sint32:
24555	return emitGetFieldSint32(A0, I);
24556	case PT_Uint32:
24557	return emitGetFieldUint32(A0, I);
24558	case PT_Sint64:
24559	return emitGetFieldSint64(A0, I);
24560	case PT_Uint64:
24561	return emitGetFieldUint64(A0, I);
24562	case PT_IntAP:
24563	return emitGetFieldIntAP(A0, I);
24564	case PT_IntAPS:
24565	return emitGetFieldIntAPS(A0, I);
24566	case PT_Bool:
24567	return emitGetFieldBool(A0, I);
24568	case PT_FixedPoint:
24569	return emitGetFieldFixedPoint(A0, I);
24570	case PT_Ptr:
24571	return emitGetFieldPtr(A0, I);
24572	case PT_MemberPtr:
24573	return emitGetFieldMemberPtr(A0, I);
24574	case PT_Float:
24575	return emitGetFieldFloat(A0, I);
24576	}
24577	llvm_unreachable("invalid enum value");
24578	}
24579	#endif
24580	#ifdef GET_LINK_IMPL
24581	bool ByteCodeEmitter::emitGetFieldSint8( uint32_t A0, SourceInfo L) {
24582	return emitOp<uint32_t>(OP_GetFieldSint8, A0, L);
24583	}
24584	bool ByteCodeEmitter::emitGetFieldUint8( uint32_t A0, SourceInfo L) {
24585	return emitOp<uint32_t>(OP_GetFieldUint8, A0, L);
24586	}
24587	bool ByteCodeEmitter::emitGetFieldSint16( uint32_t A0, SourceInfo L) {
24588	return emitOp<uint32_t>(OP_GetFieldSint16, A0, L);
24589	}
24590	bool ByteCodeEmitter::emitGetFieldUint16( uint32_t A0, SourceInfo L) {
24591	return emitOp<uint32_t>(OP_GetFieldUint16, A0, L);
24592	}
24593	bool ByteCodeEmitter::emitGetFieldSint32( uint32_t A0, SourceInfo L) {
24594	return emitOp<uint32_t>(OP_GetFieldSint32, A0, L);
24595	}
24596	bool ByteCodeEmitter::emitGetFieldUint32( uint32_t A0, SourceInfo L) {
24597	return emitOp<uint32_t>(OP_GetFieldUint32, A0, L);
24598	}
24599	bool ByteCodeEmitter::emitGetFieldSint64( uint32_t A0, SourceInfo L) {
24600	return emitOp<uint32_t>(OP_GetFieldSint64, A0, L);
24601	}
24602	bool ByteCodeEmitter::emitGetFieldUint64( uint32_t A0, SourceInfo L) {
24603	return emitOp<uint32_t>(OP_GetFieldUint64, A0, L);
24604	}
24605	bool ByteCodeEmitter::emitGetFieldIntAP( uint32_t A0, SourceInfo L) {
24606	return emitOp<uint32_t>(OP_GetFieldIntAP, A0, L);
24607	}
24608	bool ByteCodeEmitter::emitGetFieldIntAPS( uint32_t A0, SourceInfo L) {
24609	return emitOp<uint32_t>(OP_GetFieldIntAPS, A0, L);
24610	}
24611	bool ByteCodeEmitter::emitGetFieldBool( uint32_t A0, SourceInfo L) {
24612	return emitOp<uint32_t>(OP_GetFieldBool, A0, L);
24613	}
24614	bool ByteCodeEmitter::emitGetFieldFixedPoint( uint32_t A0, SourceInfo L) {
24615	return emitOp<uint32_t>(OP_GetFieldFixedPoint, A0, L);
24616	}
24617	bool ByteCodeEmitter::emitGetFieldPtr( uint32_t A0, SourceInfo L) {
24618	return emitOp<uint32_t>(OP_GetFieldPtr, A0, L);
24619	}
24620	bool ByteCodeEmitter::emitGetFieldMemberPtr( uint32_t A0, SourceInfo L) {
24621	return emitOp<uint32_t>(OP_GetFieldMemberPtr, A0, L);
24622	}
24623	bool ByteCodeEmitter::emitGetFieldFloat( uint32_t A0, SourceInfo L) {
24624	return emitOp<uint32_t>(OP_GetFieldFloat, A0, L);
24625	}
24626	#endif
24627	#ifdef GET_EVAL_IMPL
24628	bool EvalEmitter::emitGetFieldSint8( uint32_t A0, SourceInfo L) {
24629	if (!isActive()) return true;
24630	CurrentSource = L;
24631	return GetField<PT_Sint8>(S, CodePtr(), A0);
24632	}
24633	bool EvalEmitter::emitGetFieldUint8( uint32_t A0, SourceInfo L) {
24634	if (!isActive()) return true;
24635	CurrentSource = L;
24636	return GetField<PT_Uint8>(S, CodePtr(), A0);
24637	}
24638	bool EvalEmitter::emitGetFieldSint16( uint32_t A0, SourceInfo L) {
24639	if (!isActive()) return true;
24640	CurrentSource = L;
24641	return GetField<PT_Sint16>(S, CodePtr(), A0);
24642	}
24643	bool EvalEmitter::emitGetFieldUint16( uint32_t A0, SourceInfo L) {
24644	if (!isActive()) return true;
24645	CurrentSource = L;
24646	return GetField<PT_Uint16>(S, CodePtr(), A0);
24647	}
24648	bool EvalEmitter::emitGetFieldSint32( uint32_t A0, SourceInfo L) {
24649	if (!isActive()) return true;
24650	CurrentSource = L;
24651	return GetField<PT_Sint32>(S, CodePtr(), A0);
24652	}
24653	bool EvalEmitter::emitGetFieldUint32( uint32_t A0, SourceInfo L) {
24654	if (!isActive()) return true;
24655	CurrentSource = L;
24656	return GetField<PT_Uint32>(S, CodePtr(), A0);
24657	}
24658	bool EvalEmitter::emitGetFieldSint64( uint32_t A0, SourceInfo L) {
24659	if (!isActive()) return true;
24660	CurrentSource = L;
24661	return GetField<PT_Sint64>(S, CodePtr(), A0);
24662	}
24663	bool EvalEmitter::emitGetFieldUint64( uint32_t A0, SourceInfo L) {
24664	if (!isActive()) return true;
24665	CurrentSource = L;
24666	return GetField<PT_Uint64>(S, CodePtr(), A0);
24667	}
24668	bool EvalEmitter::emitGetFieldIntAP( uint32_t A0, SourceInfo L) {
24669	if (!isActive()) return true;
24670	CurrentSource = L;
24671	return GetField<PT_IntAP>(S, CodePtr(), A0);
24672	}
24673	bool EvalEmitter::emitGetFieldIntAPS( uint32_t A0, SourceInfo L) {
24674	if (!isActive()) return true;
24675	CurrentSource = L;
24676	return GetField<PT_IntAPS>(S, CodePtr(), A0);
24677	}
24678	bool EvalEmitter::emitGetFieldBool( uint32_t A0, SourceInfo L) {
24679	if (!isActive()) return true;
24680	CurrentSource = L;
24681	return GetField<PT_Bool>(S, CodePtr(), A0);
24682	}
24683	bool EvalEmitter::emitGetFieldFixedPoint( uint32_t A0, SourceInfo L) {
24684	if (!isActive()) return true;
24685	CurrentSource = L;
24686	return GetField<PT_FixedPoint>(S, CodePtr(), A0);
24687	}
24688	bool EvalEmitter::emitGetFieldPtr( uint32_t A0, SourceInfo L) {
24689	if (!isActive()) return true;
24690	CurrentSource = L;
24691	return GetField<PT_Ptr>(S, CodePtr(), A0);
24692	}
24693	bool EvalEmitter::emitGetFieldMemberPtr( uint32_t A0, SourceInfo L) {
24694	if (!isActive()) return true;
24695	CurrentSource = L;
24696	return GetField<PT_MemberPtr>(S, CodePtr(), A0);
24697	}
24698	bool EvalEmitter::emitGetFieldFloat( uint32_t A0, SourceInfo L) {
24699	if (!isActive()) return true;
24700	CurrentSource = L;
24701	return GetField<PT_Float>(S, CodePtr(), A0);
24702	}
24703	#endif
24704	#ifdef GET_OPCODE_NAMES
24705	OP_GetFieldPopSint8,
24706	OP_GetFieldPopUint8,
24707	OP_GetFieldPopSint16,
24708	OP_GetFieldPopUint16,
24709	OP_GetFieldPopSint32,
24710	OP_GetFieldPopUint32,
24711	OP_GetFieldPopSint64,
24712	OP_GetFieldPopUint64,
24713	OP_GetFieldPopIntAP,
24714	OP_GetFieldPopIntAPS,
24715	OP_GetFieldPopBool,
24716	OP_GetFieldPopFixedPoint,
24717	OP_GetFieldPopPtr,
24718	OP_GetFieldPopMemberPtr,
24719	OP_GetFieldPopFloat,
24720	#endif
24721	#ifdef GET_INTERPFN_LIST
24722	&Interp_GetFieldPopSint8,
24723	&Interp_GetFieldPopUint8,
24724	&Interp_GetFieldPopSint16,
24725	&Interp_GetFieldPopUint16,
24726	&Interp_GetFieldPopSint32,
24727	&Interp_GetFieldPopUint32,
24728	&Interp_GetFieldPopSint64,
24729	&Interp_GetFieldPopUint64,
24730	&Interp_GetFieldPopIntAP,
24731	&Interp_GetFieldPopIntAPS,
24732	&Interp_GetFieldPopBool,
24733	&Interp_GetFieldPopFixedPoint,
24734	&Interp_GetFieldPopPtr,
24735	&Interp_GetFieldPopMemberPtr,
24736	&Interp_GetFieldPopFloat,
24737	#endif
24738	#ifdef GET_INTERPFN_DISPATCHERS
24739	PRESERVE_NONE
24740	static bool Interp_GetFieldPopSint8(InterpState &S) {
24741	{
24742	CodePtr OpPC = S.PC;
24743	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24744	if (!GetFieldPop<PT_Sint8>(S, OpPC, V0)) return false;
24745	}
24746	#if USE_TAILCALLS
24747	MUSTTAIL return InterpNext(S);
24748	#else
24749	return true;
24750	#endif
24751	}
24752	PRESERVE_NONE
24753	static bool Interp_GetFieldPopUint8(InterpState &S) {
24754	{
24755	CodePtr OpPC = S.PC;
24756	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24757	if (!GetFieldPop<PT_Uint8>(S, OpPC, V0)) return false;
24758	}
24759	#if USE_TAILCALLS
24760	MUSTTAIL return InterpNext(S);
24761	#else
24762	return true;
24763	#endif
24764	}
24765	PRESERVE_NONE
24766	static bool Interp_GetFieldPopSint16(InterpState &S) {
24767	{
24768	CodePtr OpPC = S.PC;
24769	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24770	if (!GetFieldPop<PT_Sint16>(S, OpPC, V0)) return false;
24771	}
24772	#if USE_TAILCALLS
24773	MUSTTAIL return InterpNext(S);
24774	#else
24775	return true;
24776	#endif
24777	}
24778	PRESERVE_NONE
24779	static bool Interp_GetFieldPopUint16(InterpState &S) {
24780	{
24781	CodePtr OpPC = S.PC;
24782	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24783	if (!GetFieldPop<PT_Uint16>(S, OpPC, V0)) return false;
24784	}
24785	#if USE_TAILCALLS
24786	MUSTTAIL return InterpNext(S);
24787	#else
24788	return true;
24789	#endif
24790	}
24791	PRESERVE_NONE
24792	static bool Interp_GetFieldPopSint32(InterpState &S) {
24793	{
24794	CodePtr OpPC = S.PC;
24795	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24796	if (!GetFieldPop<PT_Sint32>(S, OpPC, V0)) return false;
24797	}
24798	#if USE_TAILCALLS
24799	MUSTTAIL return InterpNext(S);
24800	#else
24801	return true;
24802	#endif
24803	}
24804	PRESERVE_NONE
24805	static bool Interp_GetFieldPopUint32(InterpState &S) {
24806	{
24807	CodePtr OpPC = S.PC;
24808	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24809	if (!GetFieldPop<PT_Uint32>(S, OpPC, V0)) return false;
24810	}
24811	#if USE_TAILCALLS
24812	MUSTTAIL return InterpNext(S);
24813	#else
24814	return true;
24815	#endif
24816	}
24817	PRESERVE_NONE
24818	static bool Interp_GetFieldPopSint64(InterpState &S) {
24819	{
24820	CodePtr OpPC = S.PC;
24821	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24822	if (!GetFieldPop<PT_Sint64>(S, OpPC, V0)) return false;
24823	}
24824	#if USE_TAILCALLS
24825	MUSTTAIL return InterpNext(S);
24826	#else
24827	return true;
24828	#endif
24829	}
24830	PRESERVE_NONE
24831	static bool Interp_GetFieldPopUint64(InterpState &S) {
24832	{
24833	CodePtr OpPC = S.PC;
24834	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24835	if (!GetFieldPop<PT_Uint64>(S, OpPC, V0)) return false;
24836	}
24837	#if USE_TAILCALLS
24838	MUSTTAIL return InterpNext(S);
24839	#else
24840	return true;
24841	#endif
24842	}
24843	PRESERVE_NONE
24844	static bool Interp_GetFieldPopIntAP(InterpState &S) {
24845	{
24846	CodePtr OpPC = S.PC;
24847	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24848	if (!GetFieldPop<PT_IntAP>(S, OpPC, V0)) return false;
24849	}
24850	#if USE_TAILCALLS
24851	MUSTTAIL return InterpNext(S);
24852	#else
24853	return true;
24854	#endif
24855	}
24856	PRESERVE_NONE
24857	static bool Interp_GetFieldPopIntAPS(InterpState &S) {
24858	{
24859	CodePtr OpPC = S.PC;
24860	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24861	if (!GetFieldPop<PT_IntAPS>(S, OpPC, V0)) return false;
24862	}
24863	#if USE_TAILCALLS
24864	MUSTTAIL return InterpNext(S);
24865	#else
24866	return true;
24867	#endif
24868	}
24869	PRESERVE_NONE
24870	static bool Interp_GetFieldPopBool(InterpState &S) {
24871	{
24872	CodePtr OpPC = S.PC;
24873	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24874	if (!GetFieldPop<PT_Bool>(S, OpPC, V0)) return false;
24875	}
24876	#if USE_TAILCALLS
24877	MUSTTAIL return InterpNext(S);
24878	#else
24879	return true;
24880	#endif
24881	}
24882	PRESERVE_NONE
24883	static bool Interp_GetFieldPopFixedPoint(InterpState &S) {
24884	{
24885	CodePtr OpPC = S.PC;
24886	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24887	if (!GetFieldPop<PT_FixedPoint>(S, OpPC, V0)) return false;
24888	}
24889	#if USE_TAILCALLS
24890	MUSTTAIL return InterpNext(S);
24891	#else
24892	return true;
24893	#endif
24894	}
24895	PRESERVE_NONE
24896	static bool Interp_GetFieldPopPtr(InterpState &S) {
24897	{
24898	CodePtr OpPC = S.PC;
24899	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24900	if (!GetFieldPop<PT_Ptr>(S, OpPC, V0)) return false;
24901	}
24902	#if USE_TAILCALLS
24903	MUSTTAIL return InterpNext(S);
24904	#else
24905	return true;
24906	#endif
24907	}
24908	PRESERVE_NONE
24909	static bool Interp_GetFieldPopMemberPtr(InterpState &S) {
24910	{
24911	CodePtr OpPC = S.PC;
24912	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24913	if (!GetFieldPop<PT_MemberPtr>(S, OpPC, V0)) return false;
24914	}
24915	#if USE_TAILCALLS
24916	MUSTTAIL return InterpNext(S);
24917	#else
24918	return true;
24919	#endif
24920	}
24921	PRESERVE_NONE
24922	static bool Interp_GetFieldPopFloat(InterpState &S) {
24923	{
24924	CodePtr OpPC = S.PC;
24925	const auto V0 = ReadArg<uint32_t>(S, S.PC);
24926	if (!GetFieldPop<PT_Float>(S, OpPC, V0)) return false;
24927	}
24928	#if USE_TAILCALLS
24929	MUSTTAIL return InterpNext(S);
24930	#else
24931	return true;
24932	#endif
24933	}
24934	#endif
24935	#ifdef GET_DISASM
24936	case OP_GetFieldPopSint8:
24937	Text.Op = PrintName("GetFieldPopSint8");
24938	Text.Args.push_back(printArg<uint32_t>(P, PC));
24939	break;
24940	case OP_GetFieldPopUint8:
24941	Text.Op = PrintName("GetFieldPopUint8");
24942	Text.Args.push_back(printArg<uint32_t>(P, PC));
24943	break;
24944	case OP_GetFieldPopSint16:
24945	Text.Op = PrintName("GetFieldPopSint16");
24946	Text.Args.push_back(printArg<uint32_t>(P, PC));
24947	break;
24948	case OP_GetFieldPopUint16:
24949	Text.Op = PrintName("GetFieldPopUint16");
24950	Text.Args.push_back(printArg<uint32_t>(P, PC));
24951	break;
24952	case OP_GetFieldPopSint32:
24953	Text.Op = PrintName("GetFieldPopSint32");
24954	Text.Args.push_back(printArg<uint32_t>(P, PC));
24955	break;
24956	case OP_GetFieldPopUint32:
24957	Text.Op = PrintName("GetFieldPopUint32");
24958	Text.Args.push_back(printArg<uint32_t>(P, PC));
24959	break;
24960	case OP_GetFieldPopSint64:
24961	Text.Op = PrintName("GetFieldPopSint64");
24962	Text.Args.push_back(printArg<uint32_t>(P, PC));
24963	break;
24964	case OP_GetFieldPopUint64:
24965	Text.Op = PrintName("GetFieldPopUint64");
24966	Text.Args.push_back(printArg<uint32_t>(P, PC));
24967	break;
24968	case OP_GetFieldPopIntAP:
24969	Text.Op = PrintName("GetFieldPopIntAP");
24970	Text.Args.push_back(printArg<uint32_t>(P, PC));
24971	break;
24972	case OP_GetFieldPopIntAPS:
24973	Text.Op = PrintName("GetFieldPopIntAPS");
24974	Text.Args.push_back(printArg<uint32_t>(P, PC));
24975	break;
24976	case OP_GetFieldPopBool:
24977	Text.Op = PrintName("GetFieldPopBool");
24978	Text.Args.push_back(printArg<uint32_t>(P, PC));
24979	break;
24980	case OP_GetFieldPopFixedPoint:
24981	Text.Op = PrintName("GetFieldPopFixedPoint");
24982	Text.Args.push_back(printArg<uint32_t>(P, PC));
24983	break;
24984	case OP_GetFieldPopPtr:
24985	Text.Op = PrintName("GetFieldPopPtr");
24986	Text.Args.push_back(printArg<uint32_t>(P, PC));
24987	break;
24988	case OP_GetFieldPopMemberPtr:
24989	Text.Op = PrintName("GetFieldPopMemberPtr");
24990	Text.Args.push_back(printArg<uint32_t>(P, PC));
24991	break;
24992	case OP_GetFieldPopFloat:
24993	Text.Op = PrintName("GetFieldPopFloat");
24994	Text.Args.push_back(printArg<uint32_t>(P, PC));
24995	break;
24996	#endif
24997	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
24998	bool emitGetFieldPopSint8( uint32_t , SourceInfo);
24999	bool emitGetFieldPopUint8( uint32_t , SourceInfo);
25000	bool emitGetFieldPopSint16( uint32_t , SourceInfo);
25001	bool emitGetFieldPopUint16( uint32_t , SourceInfo);
25002	bool emitGetFieldPopSint32( uint32_t , SourceInfo);
25003	bool emitGetFieldPopUint32( uint32_t , SourceInfo);
25004	bool emitGetFieldPopSint64( uint32_t , SourceInfo);
25005	bool emitGetFieldPopUint64( uint32_t , SourceInfo);
25006	bool emitGetFieldPopIntAP( uint32_t , SourceInfo);
25007	bool emitGetFieldPopIntAPS( uint32_t , SourceInfo);
25008	bool emitGetFieldPopBool( uint32_t , SourceInfo);
25009	bool emitGetFieldPopFixedPoint( uint32_t , SourceInfo);
25010	bool emitGetFieldPopPtr( uint32_t , SourceInfo);
25011	bool emitGetFieldPopMemberPtr( uint32_t , SourceInfo);
25012	bool emitGetFieldPopFloat( uint32_t , SourceInfo);
25013	#endif
25014	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
25015	[[nodiscard]] bool emitGetFieldPop(PrimType, uint32_t, SourceInfo I);
25016	#endif
25017	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
25018	bool
25019	#if defined(GET_EVAL_IMPL)
25020	EvalEmitter
25021	#else
25022	ByteCodeEmitter
25023	#endif
25024	::emitGetFieldPop(PrimType T0, uint32_t A0, SourceInfo I) {
25025	switch (T0) {
25026	case PT_Sint8:
25027	return emitGetFieldPopSint8(A0, I);
25028	case PT_Uint8:
25029	return emitGetFieldPopUint8(A0, I);
25030	case PT_Sint16:
25031	return emitGetFieldPopSint16(A0, I);
25032	case PT_Uint16:
25033	return emitGetFieldPopUint16(A0, I);
25034	case PT_Sint32:
25035	return emitGetFieldPopSint32(A0, I);
25036	case PT_Uint32:
25037	return emitGetFieldPopUint32(A0, I);
25038	case PT_Sint64:
25039	return emitGetFieldPopSint64(A0, I);
25040	case PT_Uint64:
25041	return emitGetFieldPopUint64(A0, I);
25042	case PT_IntAP:
25043	return emitGetFieldPopIntAP(A0, I);
25044	case PT_IntAPS:
25045	return emitGetFieldPopIntAPS(A0, I);
25046	case PT_Bool:
25047	return emitGetFieldPopBool(A0, I);
25048	case PT_FixedPoint:
25049	return emitGetFieldPopFixedPoint(A0, I);
25050	case PT_Ptr:
25051	return emitGetFieldPopPtr(A0, I);
25052	case PT_MemberPtr:
25053	return emitGetFieldPopMemberPtr(A0, I);
25054	case PT_Float:
25055	return emitGetFieldPopFloat(A0, I);
25056	}
25057	llvm_unreachable("invalid enum value");
25058	}
25059	#endif
25060	#ifdef GET_LINK_IMPL
25061	bool ByteCodeEmitter::emitGetFieldPopSint8( uint32_t A0, SourceInfo L) {
25062	return emitOp<uint32_t>(OP_GetFieldPopSint8, A0, L);
25063	}
25064	bool ByteCodeEmitter::emitGetFieldPopUint8( uint32_t A0, SourceInfo L) {
25065	return emitOp<uint32_t>(OP_GetFieldPopUint8, A0, L);
25066	}
25067	bool ByteCodeEmitter::emitGetFieldPopSint16( uint32_t A0, SourceInfo L) {
25068	return emitOp<uint32_t>(OP_GetFieldPopSint16, A0, L);
25069	}
25070	bool ByteCodeEmitter::emitGetFieldPopUint16( uint32_t A0, SourceInfo L) {
25071	return emitOp<uint32_t>(OP_GetFieldPopUint16, A0, L);
25072	}
25073	bool ByteCodeEmitter::emitGetFieldPopSint32( uint32_t A0, SourceInfo L) {
25074	return emitOp<uint32_t>(OP_GetFieldPopSint32, A0, L);
25075	}
25076	bool ByteCodeEmitter::emitGetFieldPopUint32( uint32_t A0, SourceInfo L) {
25077	return emitOp<uint32_t>(OP_GetFieldPopUint32, A0, L);
25078	}
25079	bool ByteCodeEmitter::emitGetFieldPopSint64( uint32_t A0, SourceInfo L) {
25080	return emitOp<uint32_t>(OP_GetFieldPopSint64, A0, L);
25081	}
25082	bool ByteCodeEmitter::emitGetFieldPopUint64( uint32_t A0, SourceInfo L) {
25083	return emitOp<uint32_t>(OP_GetFieldPopUint64, A0, L);
25084	}
25085	bool ByteCodeEmitter::emitGetFieldPopIntAP( uint32_t A0, SourceInfo L) {
25086	return emitOp<uint32_t>(OP_GetFieldPopIntAP, A0, L);
25087	}
25088	bool ByteCodeEmitter::emitGetFieldPopIntAPS( uint32_t A0, SourceInfo L) {
25089	return emitOp<uint32_t>(OP_GetFieldPopIntAPS, A0, L);
25090	}
25091	bool ByteCodeEmitter::emitGetFieldPopBool( uint32_t A0, SourceInfo L) {
25092	return emitOp<uint32_t>(OP_GetFieldPopBool, A0, L);
25093	}
25094	bool ByteCodeEmitter::emitGetFieldPopFixedPoint( uint32_t A0, SourceInfo L) {
25095	return emitOp<uint32_t>(OP_GetFieldPopFixedPoint, A0, L);
25096	}
25097	bool ByteCodeEmitter::emitGetFieldPopPtr( uint32_t A0, SourceInfo L) {
25098	return emitOp<uint32_t>(OP_GetFieldPopPtr, A0, L);
25099	}
25100	bool ByteCodeEmitter::emitGetFieldPopMemberPtr( uint32_t A0, SourceInfo L) {
25101	return emitOp<uint32_t>(OP_GetFieldPopMemberPtr, A0, L);
25102	}
25103	bool ByteCodeEmitter::emitGetFieldPopFloat( uint32_t A0, SourceInfo L) {
25104	return emitOp<uint32_t>(OP_GetFieldPopFloat, A0, L);
25105	}
25106	#endif
25107	#ifdef GET_EVAL_IMPL
25108	bool EvalEmitter::emitGetFieldPopSint8( uint32_t A0, SourceInfo L) {
25109	if (!isActive()) return true;
25110	CurrentSource = L;
25111	return GetFieldPop<PT_Sint8>(S, CodePtr(), A0);
25112	}
25113	bool EvalEmitter::emitGetFieldPopUint8( uint32_t A0, SourceInfo L) {
25114	if (!isActive()) return true;
25115	CurrentSource = L;
25116	return GetFieldPop<PT_Uint8>(S, CodePtr(), A0);
25117	}
25118	bool EvalEmitter::emitGetFieldPopSint16( uint32_t A0, SourceInfo L) {
25119	if (!isActive()) return true;
25120	CurrentSource = L;
25121	return GetFieldPop<PT_Sint16>(S, CodePtr(), A0);
25122	}
25123	bool EvalEmitter::emitGetFieldPopUint16( uint32_t A0, SourceInfo L) {
25124	if (!isActive()) return true;
25125	CurrentSource = L;
25126	return GetFieldPop<PT_Uint16>(S, CodePtr(), A0);
25127	}
25128	bool EvalEmitter::emitGetFieldPopSint32( uint32_t A0, SourceInfo L) {
25129	if (!isActive()) return true;
25130	CurrentSource = L;
25131	return GetFieldPop<PT_Sint32>(S, CodePtr(), A0);
25132	}
25133	bool EvalEmitter::emitGetFieldPopUint32( uint32_t A0, SourceInfo L) {
25134	if (!isActive()) return true;
25135	CurrentSource = L;
25136	return GetFieldPop<PT_Uint32>(S, CodePtr(), A0);
25137	}
25138	bool EvalEmitter::emitGetFieldPopSint64( uint32_t A0, SourceInfo L) {
25139	if (!isActive()) return true;
25140	CurrentSource = L;
25141	return GetFieldPop<PT_Sint64>(S, CodePtr(), A0);
25142	}
25143	bool EvalEmitter::emitGetFieldPopUint64( uint32_t A0, SourceInfo L) {
25144	if (!isActive()) return true;
25145	CurrentSource = L;
25146	return GetFieldPop<PT_Uint64>(S, CodePtr(), A0);
25147	}
25148	bool EvalEmitter::emitGetFieldPopIntAP( uint32_t A0, SourceInfo L) {
25149	if (!isActive()) return true;
25150	CurrentSource = L;
25151	return GetFieldPop<PT_IntAP>(S, CodePtr(), A0);
25152	}
25153	bool EvalEmitter::emitGetFieldPopIntAPS( uint32_t A0, SourceInfo L) {
25154	if (!isActive()) return true;
25155	CurrentSource = L;
25156	return GetFieldPop<PT_IntAPS>(S, CodePtr(), A0);
25157	}
25158	bool EvalEmitter::emitGetFieldPopBool( uint32_t A0, SourceInfo L) {
25159	if (!isActive()) return true;
25160	CurrentSource = L;
25161	return GetFieldPop<PT_Bool>(S, CodePtr(), A0);
25162	}
25163	bool EvalEmitter::emitGetFieldPopFixedPoint( uint32_t A0, SourceInfo L) {
25164	if (!isActive()) return true;
25165	CurrentSource = L;
25166	return GetFieldPop<PT_FixedPoint>(S, CodePtr(), A0);
25167	}
25168	bool EvalEmitter::emitGetFieldPopPtr( uint32_t A0, SourceInfo L) {
25169	if (!isActive()) return true;
25170	CurrentSource = L;
25171	return GetFieldPop<PT_Ptr>(S, CodePtr(), A0);
25172	}
25173	bool EvalEmitter::emitGetFieldPopMemberPtr( uint32_t A0, SourceInfo L) {
25174	if (!isActive()) return true;
25175	CurrentSource = L;
25176	return GetFieldPop<PT_MemberPtr>(S, CodePtr(), A0);
25177	}
25178	bool EvalEmitter::emitGetFieldPopFloat( uint32_t A0, SourceInfo L) {
25179	if (!isActive()) return true;
25180	CurrentSource = L;
25181	return GetFieldPop<PT_Float>(S, CodePtr(), A0);
25182	}
25183	#endif
25184	#ifdef GET_OPCODE_NAMES
25185	OP_GetFnPtr,
25186	#endif
25187	#ifdef GET_INTERPFN_LIST
25188	&Interp_GetFnPtr,
25189	#endif
25190	#ifdef GET_INTERPFN_DISPATCHERS
25191	PRESERVE_NONE
25192	static bool Interp_GetFnPtr(InterpState &S) {
25193	{
25194	const auto V0 = ReadArg<const Function *>(S, S.PC);
25195	GetFnPtr(S, V0);
25196	}
25197	#if USE_TAILCALLS
25198	MUSTTAIL return InterpNext(S);
25199	#else
25200	return true;
25201	#endif
25202	}
25203	#endif
25204	#ifdef GET_DISASM
25205	case OP_GetFnPtr:
25206	Text.Op = PrintName("GetFnPtr");
25207	Text.Args.push_back(printArg<const Function *>(P, PC));
25208	break;
25209	#endif
25210	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
25211	bool emitGetFnPtr( const Function * , SourceInfo);
25212	#endif
25213	#ifdef GET_LINK_IMPL
25214	bool ByteCodeEmitter::emitGetFnPtr( const Function * A0, SourceInfo L) {
25215	return emitOp<const Function *>(OP_GetFnPtr, A0, L);
25216	}
25217	#endif
25218	#ifdef GET_EVAL_IMPL
25219	bool EvalEmitter::emitGetFnPtr( const Function * A0, SourceInfo L) {
25220	if (!isActive()) return true;
25221	CurrentSource = L;
25222	return GetFnPtr(S, A0);
25223	}
25224	#endif
25225	#ifdef GET_OPCODE_NAMES
25226	OP_GetGlobalSint8,
25227	OP_GetGlobalUint8,
25228	OP_GetGlobalSint16,
25229	OP_GetGlobalUint16,
25230	OP_GetGlobalSint32,
25231	OP_GetGlobalUint32,
25232	OP_GetGlobalSint64,
25233	OP_GetGlobalUint64,
25234	OP_GetGlobalIntAP,
25235	OP_GetGlobalIntAPS,
25236	OP_GetGlobalBool,
25237	OP_GetGlobalFixedPoint,
25238	OP_GetGlobalPtr,
25239	OP_GetGlobalMemberPtr,
25240	OP_GetGlobalFloat,
25241	#endif
25242	#ifdef GET_INTERPFN_LIST
25243	&Interp_GetGlobalSint8,
25244	&Interp_GetGlobalUint8,
25245	&Interp_GetGlobalSint16,
25246	&Interp_GetGlobalUint16,
25247	&Interp_GetGlobalSint32,
25248	&Interp_GetGlobalUint32,
25249	&Interp_GetGlobalSint64,
25250	&Interp_GetGlobalUint64,
25251	&Interp_GetGlobalIntAP,
25252	&Interp_GetGlobalIntAPS,
25253	&Interp_GetGlobalBool,
25254	&Interp_GetGlobalFixedPoint,
25255	&Interp_GetGlobalPtr,
25256	&Interp_GetGlobalMemberPtr,
25257	&Interp_GetGlobalFloat,
25258	#endif
25259	#ifdef GET_INTERPFN_DISPATCHERS
25260	PRESERVE_NONE
25261	static bool Interp_GetGlobalSint8(InterpState &S) {
25262	{
25263	CodePtr OpPC = S.PC;
25264	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25265	if (!GetGlobal<PT_Sint8>(S, OpPC, V0)) return false;
25266	}
25267	#if USE_TAILCALLS
25268	MUSTTAIL return InterpNext(S);
25269	#else
25270	return true;
25271	#endif
25272	}
25273	PRESERVE_NONE
25274	static bool Interp_GetGlobalUint8(InterpState &S) {
25275	{
25276	CodePtr OpPC = S.PC;
25277	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25278	if (!GetGlobal<PT_Uint8>(S, OpPC, V0)) return false;
25279	}
25280	#if USE_TAILCALLS
25281	MUSTTAIL return InterpNext(S);
25282	#else
25283	return true;
25284	#endif
25285	}
25286	PRESERVE_NONE
25287	static bool Interp_GetGlobalSint16(InterpState &S) {
25288	{
25289	CodePtr OpPC = S.PC;
25290	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25291	if (!GetGlobal<PT_Sint16>(S, OpPC, V0)) return false;
25292	}
25293	#if USE_TAILCALLS
25294	MUSTTAIL return InterpNext(S);
25295	#else
25296	return true;
25297	#endif
25298	}
25299	PRESERVE_NONE
25300	static bool Interp_GetGlobalUint16(InterpState &S) {
25301	{
25302	CodePtr OpPC = S.PC;
25303	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25304	if (!GetGlobal<PT_Uint16>(S, OpPC, V0)) return false;
25305	}
25306	#if USE_TAILCALLS
25307	MUSTTAIL return InterpNext(S);
25308	#else
25309	return true;
25310	#endif
25311	}
25312	PRESERVE_NONE
25313	static bool Interp_GetGlobalSint32(InterpState &S) {
25314	{
25315	CodePtr OpPC = S.PC;
25316	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25317	if (!GetGlobal<PT_Sint32>(S, OpPC, V0)) return false;
25318	}
25319	#if USE_TAILCALLS
25320	MUSTTAIL return InterpNext(S);
25321	#else
25322	return true;
25323	#endif
25324	}
25325	PRESERVE_NONE
25326	static bool Interp_GetGlobalUint32(InterpState &S) {
25327	{
25328	CodePtr OpPC = S.PC;
25329	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25330	if (!GetGlobal<PT_Uint32>(S, OpPC, V0)) return false;
25331	}
25332	#if USE_TAILCALLS
25333	MUSTTAIL return InterpNext(S);
25334	#else
25335	return true;
25336	#endif
25337	}
25338	PRESERVE_NONE
25339	static bool Interp_GetGlobalSint64(InterpState &S) {
25340	{
25341	CodePtr OpPC = S.PC;
25342	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25343	if (!GetGlobal<PT_Sint64>(S, OpPC, V0)) return false;
25344	}
25345	#if USE_TAILCALLS
25346	MUSTTAIL return InterpNext(S);
25347	#else
25348	return true;
25349	#endif
25350	}
25351	PRESERVE_NONE
25352	static bool Interp_GetGlobalUint64(InterpState &S) {
25353	{
25354	CodePtr OpPC = S.PC;
25355	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25356	if (!GetGlobal<PT_Uint64>(S, OpPC, V0)) return false;
25357	}
25358	#if USE_TAILCALLS
25359	MUSTTAIL return InterpNext(S);
25360	#else
25361	return true;
25362	#endif
25363	}
25364	PRESERVE_NONE
25365	static bool Interp_GetGlobalIntAP(InterpState &S) {
25366	{
25367	CodePtr OpPC = S.PC;
25368	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25369	if (!GetGlobal<PT_IntAP>(S, OpPC, V0)) return false;
25370	}
25371	#if USE_TAILCALLS
25372	MUSTTAIL return InterpNext(S);
25373	#else
25374	return true;
25375	#endif
25376	}
25377	PRESERVE_NONE
25378	static bool Interp_GetGlobalIntAPS(InterpState &S) {
25379	{
25380	CodePtr OpPC = S.PC;
25381	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25382	if (!GetGlobal<PT_IntAPS>(S, OpPC, V0)) return false;
25383	}
25384	#if USE_TAILCALLS
25385	MUSTTAIL return InterpNext(S);
25386	#else
25387	return true;
25388	#endif
25389	}
25390	PRESERVE_NONE
25391	static bool Interp_GetGlobalBool(InterpState &S) {
25392	{
25393	CodePtr OpPC = S.PC;
25394	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25395	if (!GetGlobal<PT_Bool>(S, OpPC, V0)) return false;
25396	}
25397	#if USE_TAILCALLS
25398	MUSTTAIL return InterpNext(S);
25399	#else
25400	return true;
25401	#endif
25402	}
25403	PRESERVE_NONE
25404	static bool Interp_GetGlobalFixedPoint(InterpState &S) {
25405	{
25406	CodePtr OpPC = S.PC;
25407	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25408	if (!GetGlobal<PT_FixedPoint>(S, OpPC, V0)) return false;
25409	}
25410	#if USE_TAILCALLS
25411	MUSTTAIL return InterpNext(S);
25412	#else
25413	return true;
25414	#endif
25415	}
25416	PRESERVE_NONE
25417	static bool Interp_GetGlobalPtr(InterpState &S) {
25418	{
25419	CodePtr OpPC = S.PC;
25420	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25421	if (!GetGlobal<PT_Ptr>(S, OpPC, V0)) return false;
25422	}
25423	#if USE_TAILCALLS
25424	MUSTTAIL return InterpNext(S);
25425	#else
25426	return true;
25427	#endif
25428	}
25429	PRESERVE_NONE
25430	static bool Interp_GetGlobalMemberPtr(InterpState &S) {
25431	{
25432	CodePtr OpPC = S.PC;
25433	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25434	if (!GetGlobal<PT_MemberPtr>(S, OpPC, V0)) return false;
25435	}
25436	#if USE_TAILCALLS
25437	MUSTTAIL return InterpNext(S);
25438	#else
25439	return true;
25440	#endif
25441	}
25442	PRESERVE_NONE
25443	static bool Interp_GetGlobalFloat(InterpState &S) {
25444	{
25445	CodePtr OpPC = S.PC;
25446	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25447	if (!GetGlobal<PT_Float>(S, OpPC, V0)) return false;
25448	}
25449	#if USE_TAILCALLS
25450	MUSTTAIL return InterpNext(S);
25451	#else
25452	return true;
25453	#endif
25454	}
25455	#endif
25456	#ifdef GET_DISASM
25457	case OP_GetGlobalSint8:
25458	Text.Op = PrintName("GetGlobalSint8");
25459	Text.Args.push_back(printArg<uint32_t>(P, PC));
25460	break;
25461	case OP_GetGlobalUint8:
25462	Text.Op = PrintName("GetGlobalUint8");
25463	Text.Args.push_back(printArg<uint32_t>(P, PC));
25464	break;
25465	case OP_GetGlobalSint16:
25466	Text.Op = PrintName("GetGlobalSint16");
25467	Text.Args.push_back(printArg<uint32_t>(P, PC));
25468	break;
25469	case OP_GetGlobalUint16:
25470	Text.Op = PrintName("GetGlobalUint16");
25471	Text.Args.push_back(printArg<uint32_t>(P, PC));
25472	break;
25473	case OP_GetGlobalSint32:
25474	Text.Op = PrintName("GetGlobalSint32");
25475	Text.Args.push_back(printArg<uint32_t>(P, PC));
25476	break;
25477	case OP_GetGlobalUint32:
25478	Text.Op = PrintName("GetGlobalUint32");
25479	Text.Args.push_back(printArg<uint32_t>(P, PC));
25480	break;
25481	case OP_GetGlobalSint64:
25482	Text.Op = PrintName("GetGlobalSint64");
25483	Text.Args.push_back(printArg<uint32_t>(P, PC));
25484	break;
25485	case OP_GetGlobalUint64:
25486	Text.Op = PrintName("GetGlobalUint64");
25487	Text.Args.push_back(printArg<uint32_t>(P, PC));
25488	break;
25489	case OP_GetGlobalIntAP:
25490	Text.Op = PrintName("GetGlobalIntAP");
25491	Text.Args.push_back(printArg<uint32_t>(P, PC));
25492	break;
25493	case OP_GetGlobalIntAPS:
25494	Text.Op = PrintName("GetGlobalIntAPS");
25495	Text.Args.push_back(printArg<uint32_t>(P, PC));
25496	break;
25497	case OP_GetGlobalBool:
25498	Text.Op = PrintName("GetGlobalBool");
25499	Text.Args.push_back(printArg<uint32_t>(P, PC));
25500	break;
25501	case OP_GetGlobalFixedPoint:
25502	Text.Op = PrintName("GetGlobalFixedPoint");
25503	Text.Args.push_back(printArg<uint32_t>(P, PC));
25504	break;
25505	case OP_GetGlobalPtr:
25506	Text.Op = PrintName("GetGlobalPtr");
25507	Text.Args.push_back(printArg<uint32_t>(P, PC));
25508	break;
25509	case OP_GetGlobalMemberPtr:
25510	Text.Op = PrintName("GetGlobalMemberPtr");
25511	Text.Args.push_back(printArg<uint32_t>(P, PC));
25512	break;
25513	case OP_GetGlobalFloat:
25514	Text.Op = PrintName("GetGlobalFloat");
25515	Text.Args.push_back(printArg<uint32_t>(P, PC));
25516	break;
25517	#endif
25518	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
25519	bool emitGetGlobalSint8( uint32_t , SourceInfo);
25520	bool emitGetGlobalUint8( uint32_t , SourceInfo);
25521	bool emitGetGlobalSint16( uint32_t , SourceInfo);
25522	bool emitGetGlobalUint16( uint32_t , SourceInfo);
25523	bool emitGetGlobalSint32( uint32_t , SourceInfo);
25524	bool emitGetGlobalUint32( uint32_t , SourceInfo);
25525	bool emitGetGlobalSint64( uint32_t , SourceInfo);
25526	bool emitGetGlobalUint64( uint32_t , SourceInfo);
25527	bool emitGetGlobalIntAP( uint32_t , SourceInfo);
25528	bool emitGetGlobalIntAPS( uint32_t , SourceInfo);
25529	bool emitGetGlobalBool( uint32_t , SourceInfo);
25530	bool emitGetGlobalFixedPoint( uint32_t , SourceInfo);
25531	bool emitGetGlobalPtr( uint32_t , SourceInfo);
25532	bool emitGetGlobalMemberPtr( uint32_t , SourceInfo);
25533	bool emitGetGlobalFloat( uint32_t , SourceInfo);
25534	#endif
25535	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
25536	[[nodiscard]] bool emitGetGlobal(PrimType, uint32_t, SourceInfo I);
25537	#endif
25538	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
25539	bool
25540	#if defined(GET_EVAL_IMPL)
25541	EvalEmitter
25542	#else
25543	ByteCodeEmitter
25544	#endif
25545	::emitGetGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
25546	switch (T0) {
25547	case PT_Sint8:
25548	return emitGetGlobalSint8(A0, I);
25549	case PT_Uint8:
25550	return emitGetGlobalUint8(A0, I);
25551	case PT_Sint16:
25552	return emitGetGlobalSint16(A0, I);
25553	case PT_Uint16:
25554	return emitGetGlobalUint16(A0, I);
25555	case PT_Sint32:
25556	return emitGetGlobalSint32(A0, I);
25557	case PT_Uint32:
25558	return emitGetGlobalUint32(A0, I);
25559	case PT_Sint64:
25560	return emitGetGlobalSint64(A0, I);
25561	case PT_Uint64:
25562	return emitGetGlobalUint64(A0, I);
25563	case PT_IntAP:
25564	return emitGetGlobalIntAP(A0, I);
25565	case PT_IntAPS:
25566	return emitGetGlobalIntAPS(A0, I);
25567	case PT_Bool:
25568	return emitGetGlobalBool(A0, I);
25569	case PT_FixedPoint:
25570	return emitGetGlobalFixedPoint(A0, I);
25571	case PT_Ptr:
25572	return emitGetGlobalPtr(A0, I);
25573	case PT_MemberPtr:
25574	return emitGetGlobalMemberPtr(A0, I);
25575	case PT_Float:
25576	return emitGetGlobalFloat(A0, I);
25577	}
25578	llvm_unreachable("invalid enum value");
25579	}
25580	#endif
25581	#ifdef GET_LINK_IMPL
25582	bool ByteCodeEmitter::emitGetGlobalSint8( uint32_t A0, SourceInfo L) {
25583	return emitOp<uint32_t>(OP_GetGlobalSint8, A0, L);
25584	}
25585	bool ByteCodeEmitter::emitGetGlobalUint8( uint32_t A0, SourceInfo L) {
25586	return emitOp<uint32_t>(OP_GetGlobalUint8, A0, L);
25587	}
25588	bool ByteCodeEmitter::emitGetGlobalSint16( uint32_t A0, SourceInfo L) {
25589	return emitOp<uint32_t>(OP_GetGlobalSint16, A0, L);
25590	}
25591	bool ByteCodeEmitter::emitGetGlobalUint16( uint32_t A0, SourceInfo L) {
25592	return emitOp<uint32_t>(OP_GetGlobalUint16, A0, L);
25593	}
25594	bool ByteCodeEmitter::emitGetGlobalSint32( uint32_t A0, SourceInfo L) {
25595	return emitOp<uint32_t>(OP_GetGlobalSint32, A0, L);
25596	}
25597	bool ByteCodeEmitter::emitGetGlobalUint32( uint32_t A0, SourceInfo L) {
25598	return emitOp<uint32_t>(OP_GetGlobalUint32, A0, L);
25599	}
25600	bool ByteCodeEmitter::emitGetGlobalSint64( uint32_t A0, SourceInfo L) {
25601	return emitOp<uint32_t>(OP_GetGlobalSint64, A0, L);
25602	}
25603	bool ByteCodeEmitter::emitGetGlobalUint64( uint32_t A0, SourceInfo L) {
25604	return emitOp<uint32_t>(OP_GetGlobalUint64, A0, L);
25605	}
25606	bool ByteCodeEmitter::emitGetGlobalIntAP( uint32_t A0, SourceInfo L) {
25607	return emitOp<uint32_t>(OP_GetGlobalIntAP, A0, L);
25608	}
25609	bool ByteCodeEmitter::emitGetGlobalIntAPS( uint32_t A0, SourceInfo L) {
25610	return emitOp<uint32_t>(OP_GetGlobalIntAPS, A0, L);
25611	}
25612	bool ByteCodeEmitter::emitGetGlobalBool( uint32_t A0, SourceInfo L) {
25613	return emitOp<uint32_t>(OP_GetGlobalBool, A0, L);
25614	}
25615	bool ByteCodeEmitter::emitGetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
25616	return emitOp<uint32_t>(OP_GetGlobalFixedPoint, A0, L);
25617	}
25618	bool ByteCodeEmitter::emitGetGlobalPtr( uint32_t A0, SourceInfo L) {
25619	return emitOp<uint32_t>(OP_GetGlobalPtr, A0, L);
25620	}
25621	bool ByteCodeEmitter::emitGetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
25622	return emitOp<uint32_t>(OP_GetGlobalMemberPtr, A0, L);
25623	}
25624	bool ByteCodeEmitter::emitGetGlobalFloat( uint32_t A0, SourceInfo L) {
25625	return emitOp<uint32_t>(OP_GetGlobalFloat, A0, L);
25626	}
25627	#endif
25628	#ifdef GET_EVAL_IMPL
25629	bool EvalEmitter::emitGetGlobalSint8( uint32_t A0, SourceInfo L) {
25630	if (!isActive()) return true;
25631	CurrentSource = L;
25632	return GetGlobal<PT_Sint8>(S, CodePtr(), A0);
25633	}
25634	bool EvalEmitter::emitGetGlobalUint8( uint32_t A0, SourceInfo L) {
25635	if (!isActive()) return true;
25636	CurrentSource = L;
25637	return GetGlobal<PT_Uint8>(S, CodePtr(), A0);
25638	}
25639	bool EvalEmitter::emitGetGlobalSint16( uint32_t A0, SourceInfo L) {
25640	if (!isActive()) return true;
25641	CurrentSource = L;
25642	return GetGlobal<PT_Sint16>(S, CodePtr(), A0);
25643	}
25644	bool EvalEmitter::emitGetGlobalUint16( uint32_t A0, SourceInfo L) {
25645	if (!isActive()) return true;
25646	CurrentSource = L;
25647	return GetGlobal<PT_Uint16>(S, CodePtr(), A0);
25648	}
25649	bool EvalEmitter::emitGetGlobalSint32( uint32_t A0, SourceInfo L) {
25650	if (!isActive()) return true;
25651	CurrentSource = L;
25652	return GetGlobal<PT_Sint32>(S, CodePtr(), A0);
25653	}
25654	bool EvalEmitter::emitGetGlobalUint32( uint32_t A0, SourceInfo L) {
25655	if (!isActive()) return true;
25656	CurrentSource = L;
25657	return GetGlobal<PT_Uint32>(S, CodePtr(), A0);
25658	}
25659	bool EvalEmitter::emitGetGlobalSint64( uint32_t A0, SourceInfo L) {
25660	if (!isActive()) return true;
25661	CurrentSource = L;
25662	return GetGlobal<PT_Sint64>(S, CodePtr(), A0);
25663	}
25664	bool EvalEmitter::emitGetGlobalUint64( uint32_t A0, SourceInfo L) {
25665	if (!isActive()) return true;
25666	CurrentSource = L;
25667	return GetGlobal<PT_Uint64>(S, CodePtr(), A0);
25668	}
25669	bool EvalEmitter::emitGetGlobalIntAP( uint32_t A0, SourceInfo L) {
25670	if (!isActive()) return true;
25671	CurrentSource = L;
25672	return GetGlobal<PT_IntAP>(S, CodePtr(), A0);
25673	}
25674	bool EvalEmitter::emitGetGlobalIntAPS( uint32_t A0, SourceInfo L) {
25675	if (!isActive()) return true;
25676	CurrentSource = L;
25677	return GetGlobal<PT_IntAPS>(S, CodePtr(), A0);
25678	}
25679	bool EvalEmitter::emitGetGlobalBool( uint32_t A0, SourceInfo L) {
25680	if (!isActive()) return true;
25681	CurrentSource = L;
25682	return GetGlobal<PT_Bool>(S, CodePtr(), A0);
25683	}
25684	bool EvalEmitter::emitGetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
25685	if (!isActive()) return true;
25686	CurrentSource = L;
25687	return GetGlobal<PT_FixedPoint>(S, CodePtr(), A0);
25688	}
25689	bool EvalEmitter::emitGetGlobalPtr( uint32_t A0, SourceInfo L) {
25690	if (!isActive()) return true;
25691	CurrentSource = L;
25692	return GetGlobal<PT_Ptr>(S, CodePtr(), A0);
25693	}
25694	bool EvalEmitter::emitGetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
25695	if (!isActive()) return true;
25696	CurrentSource = L;
25697	return GetGlobal<PT_MemberPtr>(S, CodePtr(), A0);
25698	}
25699	bool EvalEmitter::emitGetGlobalFloat( uint32_t A0, SourceInfo L) {
25700	if (!isActive()) return true;
25701	CurrentSource = L;
25702	return GetGlobal<PT_Float>(S, CodePtr(), A0);
25703	}
25704	#endif
25705	#ifdef GET_OPCODE_NAMES
25706	OP_GetGlobalUncheckedSint8,
25707	OP_GetGlobalUncheckedUint8,
25708	OP_GetGlobalUncheckedSint16,
25709	OP_GetGlobalUncheckedUint16,
25710	OP_GetGlobalUncheckedSint32,
25711	OP_GetGlobalUncheckedUint32,
25712	OP_GetGlobalUncheckedSint64,
25713	OP_GetGlobalUncheckedUint64,
25714	OP_GetGlobalUncheckedIntAP,
25715	OP_GetGlobalUncheckedIntAPS,
25716	OP_GetGlobalUncheckedBool,
25717	OP_GetGlobalUncheckedFixedPoint,
25718	OP_GetGlobalUncheckedPtr,
25719	OP_GetGlobalUncheckedMemberPtr,
25720	OP_GetGlobalUncheckedFloat,
25721	#endif
25722	#ifdef GET_INTERPFN_LIST
25723	&Interp_GetGlobalUncheckedSint8,
25724	&Interp_GetGlobalUncheckedUint8,
25725	&Interp_GetGlobalUncheckedSint16,
25726	&Interp_GetGlobalUncheckedUint16,
25727	&Interp_GetGlobalUncheckedSint32,
25728	&Interp_GetGlobalUncheckedUint32,
25729	&Interp_GetGlobalUncheckedSint64,
25730	&Interp_GetGlobalUncheckedUint64,
25731	&Interp_GetGlobalUncheckedIntAP,
25732	&Interp_GetGlobalUncheckedIntAPS,
25733	&Interp_GetGlobalUncheckedBool,
25734	&Interp_GetGlobalUncheckedFixedPoint,
25735	&Interp_GetGlobalUncheckedPtr,
25736	&Interp_GetGlobalUncheckedMemberPtr,
25737	&Interp_GetGlobalUncheckedFloat,
25738	#endif
25739	#ifdef GET_INTERPFN_DISPATCHERS
25740	PRESERVE_NONE
25741	static bool Interp_GetGlobalUncheckedSint8(InterpState &S) {
25742	{
25743	CodePtr OpPC = S.PC;
25744	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25745	if (!GetGlobalUnchecked<PT_Sint8>(S, OpPC, V0)) return false;
25746	}
25747	#if USE_TAILCALLS
25748	MUSTTAIL return InterpNext(S);
25749	#else
25750	return true;
25751	#endif
25752	}
25753	PRESERVE_NONE
25754	static bool Interp_GetGlobalUncheckedUint8(InterpState &S) {
25755	{
25756	CodePtr OpPC = S.PC;
25757	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25758	if (!GetGlobalUnchecked<PT_Uint8>(S, OpPC, V0)) return false;
25759	}
25760	#if USE_TAILCALLS
25761	MUSTTAIL return InterpNext(S);
25762	#else
25763	return true;
25764	#endif
25765	}
25766	PRESERVE_NONE
25767	static bool Interp_GetGlobalUncheckedSint16(InterpState &S) {
25768	{
25769	CodePtr OpPC = S.PC;
25770	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25771	if (!GetGlobalUnchecked<PT_Sint16>(S, OpPC, V0)) return false;
25772	}
25773	#if USE_TAILCALLS
25774	MUSTTAIL return InterpNext(S);
25775	#else
25776	return true;
25777	#endif
25778	}
25779	PRESERVE_NONE
25780	static bool Interp_GetGlobalUncheckedUint16(InterpState &S) {
25781	{
25782	CodePtr OpPC = S.PC;
25783	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25784	if (!GetGlobalUnchecked<PT_Uint16>(S, OpPC, V0)) return false;
25785	}
25786	#if USE_TAILCALLS
25787	MUSTTAIL return InterpNext(S);
25788	#else
25789	return true;
25790	#endif
25791	}
25792	PRESERVE_NONE
25793	static bool Interp_GetGlobalUncheckedSint32(InterpState &S) {
25794	{
25795	CodePtr OpPC = S.PC;
25796	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25797	if (!GetGlobalUnchecked<PT_Sint32>(S, OpPC, V0)) return false;
25798	}
25799	#if USE_TAILCALLS
25800	MUSTTAIL return InterpNext(S);
25801	#else
25802	return true;
25803	#endif
25804	}
25805	PRESERVE_NONE
25806	static bool Interp_GetGlobalUncheckedUint32(InterpState &S) {
25807	{
25808	CodePtr OpPC = S.PC;
25809	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25810	if (!GetGlobalUnchecked<PT_Uint32>(S, OpPC, V0)) return false;
25811	}
25812	#if USE_TAILCALLS
25813	MUSTTAIL return InterpNext(S);
25814	#else
25815	return true;
25816	#endif
25817	}
25818	PRESERVE_NONE
25819	static bool Interp_GetGlobalUncheckedSint64(InterpState &S) {
25820	{
25821	CodePtr OpPC = S.PC;
25822	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25823	if (!GetGlobalUnchecked<PT_Sint64>(S, OpPC, V0)) return false;
25824	}
25825	#if USE_TAILCALLS
25826	MUSTTAIL return InterpNext(S);
25827	#else
25828	return true;
25829	#endif
25830	}
25831	PRESERVE_NONE
25832	static bool Interp_GetGlobalUncheckedUint64(InterpState &S) {
25833	{
25834	CodePtr OpPC = S.PC;
25835	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25836	if (!GetGlobalUnchecked<PT_Uint64>(S, OpPC, V0)) return false;
25837	}
25838	#if USE_TAILCALLS
25839	MUSTTAIL return InterpNext(S);
25840	#else
25841	return true;
25842	#endif
25843	}
25844	PRESERVE_NONE
25845	static bool Interp_GetGlobalUncheckedIntAP(InterpState &S) {
25846	{
25847	CodePtr OpPC = S.PC;
25848	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25849	if (!GetGlobalUnchecked<PT_IntAP>(S, OpPC, V0)) return false;
25850	}
25851	#if USE_TAILCALLS
25852	MUSTTAIL return InterpNext(S);
25853	#else
25854	return true;
25855	#endif
25856	}
25857	PRESERVE_NONE
25858	static bool Interp_GetGlobalUncheckedIntAPS(InterpState &S) {
25859	{
25860	CodePtr OpPC = S.PC;
25861	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25862	if (!GetGlobalUnchecked<PT_IntAPS>(S, OpPC, V0)) return false;
25863	}
25864	#if USE_TAILCALLS
25865	MUSTTAIL return InterpNext(S);
25866	#else
25867	return true;
25868	#endif
25869	}
25870	PRESERVE_NONE
25871	static bool Interp_GetGlobalUncheckedBool(InterpState &S) {
25872	{
25873	CodePtr OpPC = S.PC;
25874	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25875	if (!GetGlobalUnchecked<PT_Bool>(S, OpPC, V0)) return false;
25876	}
25877	#if USE_TAILCALLS
25878	MUSTTAIL return InterpNext(S);
25879	#else
25880	return true;
25881	#endif
25882	}
25883	PRESERVE_NONE
25884	static bool Interp_GetGlobalUncheckedFixedPoint(InterpState &S) {
25885	{
25886	CodePtr OpPC = S.PC;
25887	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25888	if (!GetGlobalUnchecked<PT_FixedPoint>(S, OpPC, V0)) return false;
25889	}
25890	#if USE_TAILCALLS
25891	MUSTTAIL return InterpNext(S);
25892	#else
25893	return true;
25894	#endif
25895	}
25896	PRESERVE_NONE
25897	static bool Interp_GetGlobalUncheckedPtr(InterpState &S) {
25898	{
25899	CodePtr OpPC = S.PC;
25900	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25901	if (!GetGlobalUnchecked<PT_Ptr>(S, OpPC, V0)) return false;
25902	}
25903	#if USE_TAILCALLS
25904	MUSTTAIL return InterpNext(S);
25905	#else
25906	return true;
25907	#endif
25908	}
25909	PRESERVE_NONE
25910	static bool Interp_GetGlobalUncheckedMemberPtr(InterpState &S) {
25911	{
25912	CodePtr OpPC = S.PC;
25913	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25914	if (!GetGlobalUnchecked<PT_MemberPtr>(S, OpPC, V0)) return false;
25915	}
25916	#if USE_TAILCALLS
25917	MUSTTAIL return InterpNext(S);
25918	#else
25919	return true;
25920	#endif
25921	}
25922	PRESERVE_NONE
25923	static bool Interp_GetGlobalUncheckedFloat(InterpState &S) {
25924	{
25925	CodePtr OpPC = S.PC;
25926	const auto V0 = ReadArg<uint32_t>(S, S.PC);
25927	if (!GetGlobalUnchecked<PT_Float>(S, OpPC, V0)) return false;
25928	}
25929	#if USE_TAILCALLS
25930	MUSTTAIL return InterpNext(S);
25931	#else
25932	return true;
25933	#endif
25934	}
25935	#endif
25936	#ifdef GET_DISASM
25937	case OP_GetGlobalUncheckedSint8:
25938	Text.Op = PrintName("GetGlobalUncheckedSint8");
25939	Text.Args.push_back(printArg<uint32_t>(P, PC));
25940	break;
25941	case OP_GetGlobalUncheckedUint8:
25942	Text.Op = PrintName("GetGlobalUncheckedUint8");
25943	Text.Args.push_back(printArg<uint32_t>(P, PC));
25944	break;
25945	case OP_GetGlobalUncheckedSint16:
25946	Text.Op = PrintName("GetGlobalUncheckedSint16");
25947	Text.Args.push_back(printArg<uint32_t>(P, PC));
25948	break;
25949	case OP_GetGlobalUncheckedUint16:
25950	Text.Op = PrintName("GetGlobalUncheckedUint16");
25951	Text.Args.push_back(printArg<uint32_t>(P, PC));
25952	break;
25953	case OP_GetGlobalUncheckedSint32:
25954	Text.Op = PrintName("GetGlobalUncheckedSint32");
25955	Text.Args.push_back(printArg<uint32_t>(P, PC));
25956	break;
25957	case OP_GetGlobalUncheckedUint32:
25958	Text.Op = PrintName("GetGlobalUncheckedUint32");
25959	Text.Args.push_back(printArg<uint32_t>(P, PC));
25960	break;
25961	case OP_GetGlobalUncheckedSint64:
25962	Text.Op = PrintName("GetGlobalUncheckedSint64");
25963	Text.Args.push_back(printArg<uint32_t>(P, PC));
25964	break;
25965	case OP_GetGlobalUncheckedUint64:
25966	Text.Op = PrintName("GetGlobalUncheckedUint64");
25967	Text.Args.push_back(printArg<uint32_t>(P, PC));
25968	break;
25969	case OP_GetGlobalUncheckedIntAP:
25970	Text.Op = PrintName("GetGlobalUncheckedIntAP");
25971	Text.Args.push_back(printArg<uint32_t>(P, PC));
25972	break;
25973	case OP_GetGlobalUncheckedIntAPS:
25974	Text.Op = PrintName("GetGlobalUncheckedIntAPS");
25975	Text.Args.push_back(printArg<uint32_t>(P, PC));
25976	break;
25977	case OP_GetGlobalUncheckedBool:
25978	Text.Op = PrintName("GetGlobalUncheckedBool");
25979	Text.Args.push_back(printArg<uint32_t>(P, PC));
25980	break;
25981	case OP_GetGlobalUncheckedFixedPoint:
25982	Text.Op = PrintName("GetGlobalUncheckedFixedPoint");
25983	Text.Args.push_back(printArg<uint32_t>(P, PC));
25984	break;
25985	case OP_GetGlobalUncheckedPtr:
25986	Text.Op = PrintName("GetGlobalUncheckedPtr");
25987	Text.Args.push_back(printArg<uint32_t>(P, PC));
25988	break;
25989	case OP_GetGlobalUncheckedMemberPtr:
25990	Text.Op = PrintName("GetGlobalUncheckedMemberPtr");
25991	Text.Args.push_back(printArg<uint32_t>(P, PC));
25992	break;
25993	case OP_GetGlobalUncheckedFloat:
25994	Text.Op = PrintName("GetGlobalUncheckedFloat");
25995	Text.Args.push_back(printArg<uint32_t>(P, PC));
25996	break;
25997	#endif
25998	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
25999	bool emitGetGlobalUncheckedSint8( uint32_t , SourceInfo);
26000	bool emitGetGlobalUncheckedUint8( uint32_t , SourceInfo);
26001	bool emitGetGlobalUncheckedSint16( uint32_t , SourceInfo);
26002	bool emitGetGlobalUncheckedUint16( uint32_t , SourceInfo);
26003	bool emitGetGlobalUncheckedSint32( uint32_t , SourceInfo);
26004	bool emitGetGlobalUncheckedUint32( uint32_t , SourceInfo);
26005	bool emitGetGlobalUncheckedSint64( uint32_t , SourceInfo);
26006	bool emitGetGlobalUncheckedUint64( uint32_t , SourceInfo);
26007	bool emitGetGlobalUncheckedIntAP( uint32_t , SourceInfo);
26008	bool emitGetGlobalUncheckedIntAPS( uint32_t , SourceInfo);
26009	bool emitGetGlobalUncheckedBool( uint32_t , SourceInfo);
26010	bool emitGetGlobalUncheckedFixedPoint( uint32_t , SourceInfo);
26011	bool emitGetGlobalUncheckedPtr( uint32_t , SourceInfo);
26012	bool emitGetGlobalUncheckedMemberPtr( uint32_t , SourceInfo);
26013	bool emitGetGlobalUncheckedFloat( uint32_t , SourceInfo);
26014	#endif
26015	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
26016	[[nodiscard]] bool emitGetGlobalUnchecked(PrimType, uint32_t, SourceInfo I);
26017	#endif
26018	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
26019	bool
26020	#if defined(GET_EVAL_IMPL)
26021	EvalEmitter
26022	#else
26023	ByteCodeEmitter
26024	#endif
26025	::emitGetGlobalUnchecked(PrimType T0, uint32_t A0, SourceInfo I) {
26026	switch (T0) {
26027	case PT_Sint8:
26028	return emitGetGlobalUncheckedSint8(A0, I);
26029	case PT_Uint8:
26030	return emitGetGlobalUncheckedUint8(A0, I);
26031	case PT_Sint16:
26032	return emitGetGlobalUncheckedSint16(A0, I);
26033	case PT_Uint16:
26034	return emitGetGlobalUncheckedUint16(A0, I);
26035	case PT_Sint32:
26036	return emitGetGlobalUncheckedSint32(A0, I);
26037	case PT_Uint32:
26038	return emitGetGlobalUncheckedUint32(A0, I);
26039	case PT_Sint64:
26040	return emitGetGlobalUncheckedSint64(A0, I);
26041	case PT_Uint64:
26042	return emitGetGlobalUncheckedUint64(A0, I);
26043	case PT_IntAP:
26044	return emitGetGlobalUncheckedIntAP(A0, I);
26045	case PT_IntAPS:
26046	return emitGetGlobalUncheckedIntAPS(A0, I);
26047	case PT_Bool:
26048	return emitGetGlobalUncheckedBool(A0, I);
26049	case PT_FixedPoint:
26050	return emitGetGlobalUncheckedFixedPoint(A0, I);
26051	case PT_Ptr:
26052	return emitGetGlobalUncheckedPtr(A0, I);
26053	case PT_MemberPtr:
26054	return emitGetGlobalUncheckedMemberPtr(A0, I);
26055	case PT_Float:
26056	return emitGetGlobalUncheckedFloat(A0, I);
26057	}
26058	llvm_unreachable("invalid enum value");
26059	}
26060	#endif
26061	#ifdef GET_LINK_IMPL
26062	bool ByteCodeEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, SourceInfo L) {
26063	return emitOp<uint32_t>(OP_GetGlobalUncheckedSint8, A0, L);
26064	}
26065	bool ByteCodeEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, SourceInfo L) {
26066	return emitOp<uint32_t>(OP_GetGlobalUncheckedUint8, A0, L);
26067	}
26068	bool ByteCodeEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, SourceInfo L) {
26069	return emitOp<uint32_t>(OP_GetGlobalUncheckedSint16, A0, L);
26070	}
26071	bool ByteCodeEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, SourceInfo L) {
26072	return emitOp<uint32_t>(OP_GetGlobalUncheckedUint16, A0, L);
26073	}
26074	bool ByteCodeEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, SourceInfo L) {
26075	return emitOp<uint32_t>(OP_GetGlobalUncheckedSint32, A0, L);
26076	}
26077	bool ByteCodeEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, SourceInfo L) {
26078	return emitOp<uint32_t>(OP_GetGlobalUncheckedUint32, A0, L);
26079	}
26080	bool ByteCodeEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, SourceInfo L) {
26081	return emitOp<uint32_t>(OP_GetGlobalUncheckedSint64, A0, L);
26082	}
26083	bool ByteCodeEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, SourceInfo L) {
26084	return emitOp<uint32_t>(OP_GetGlobalUncheckedUint64, A0, L);
26085	}
26086	bool ByteCodeEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, SourceInfo L) {
26087	return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAP, A0, L);
26088	}
26089	bool ByteCodeEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, SourceInfo L) {
26090	return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAPS, A0, L);
26091	}
26092	bool ByteCodeEmitter::emitGetGlobalUncheckedBool( uint32_t A0, SourceInfo L) {
26093	return emitOp<uint32_t>(OP_GetGlobalUncheckedBool, A0, L);
26094	}
26095	bool ByteCodeEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, SourceInfo L) {
26096	return emitOp<uint32_t>(OP_GetGlobalUncheckedFixedPoint, A0, L);
26097	}
26098	bool ByteCodeEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, SourceInfo L) {
26099	return emitOp<uint32_t>(OP_GetGlobalUncheckedPtr, A0, L);
26100	}
26101	bool ByteCodeEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, SourceInfo L) {
26102	return emitOp<uint32_t>(OP_GetGlobalUncheckedMemberPtr, A0, L);
26103	}
26104	bool ByteCodeEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, SourceInfo L) {
26105	return emitOp<uint32_t>(OP_GetGlobalUncheckedFloat, A0, L);
26106	}
26107	#endif
26108	#ifdef GET_EVAL_IMPL
26109	bool EvalEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, SourceInfo L) {
26110	if (!isActive()) return true;
26111	CurrentSource = L;
26112	return GetGlobalUnchecked<PT_Sint8>(S, CodePtr(), A0);
26113	}
26114	bool EvalEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, SourceInfo L) {
26115	if (!isActive()) return true;
26116	CurrentSource = L;
26117	return GetGlobalUnchecked<PT_Uint8>(S, CodePtr(), A0);
26118	}
26119	bool EvalEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, SourceInfo L) {
26120	if (!isActive()) return true;
26121	CurrentSource = L;
26122	return GetGlobalUnchecked<PT_Sint16>(S, CodePtr(), A0);
26123	}
26124	bool EvalEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, SourceInfo L) {
26125	if (!isActive()) return true;
26126	CurrentSource = L;
26127	return GetGlobalUnchecked<PT_Uint16>(S, CodePtr(), A0);
26128	}
26129	bool EvalEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, SourceInfo L) {
26130	if (!isActive()) return true;
26131	CurrentSource = L;
26132	return GetGlobalUnchecked<PT_Sint32>(S, CodePtr(), A0);
26133	}
26134	bool EvalEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, SourceInfo L) {
26135	if (!isActive()) return true;
26136	CurrentSource = L;
26137	return GetGlobalUnchecked<PT_Uint32>(S, CodePtr(), A0);
26138	}
26139	bool EvalEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, SourceInfo L) {
26140	if (!isActive()) return true;
26141	CurrentSource = L;
26142	return GetGlobalUnchecked<PT_Sint64>(S, CodePtr(), A0);
26143	}
26144	bool EvalEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, SourceInfo L) {
26145	if (!isActive()) return true;
26146	CurrentSource = L;
26147	return GetGlobalUnchecked<PT_Uint64>(S, CodePtr(), A0);
26148	}
26149	bool EvalEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, SourceInfo L) {
26150	if (!isActive()) return true;
26151	CurrentSource = L;
26152	return GetGlobalUnchecked<PT_IntAP>(S, CodePtr(), A0);
26153	}
26154	bool EvalEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, SourceInfo L) {
26155	if (!isActive()) return true;
26156	CurrentSource = L;
26157	return GetGlobalUnchecked<PT_IntAPS>(S, CodePtr(), A0);
26158	}
26159	bool EvalEmitter::emitGetGlobalUncheckedBool( uint32_t A0, SourceInfo L) {
26160	if (!isActive()) return true;
26161	CurrentSource = L;
26162	return GetGlobalUnchecked<PT_Bool>(S, CodePtr(), A0);
26163	}
26164	bool EvalEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, SourceInfo L) {
26165	if (!isActive()) return true;
26166	CurrentSource = L;
26167	return GetGlobalUnchecked<PT_FixedPoint>(S, CodePtr(), A0);
26168	}
26169	bool EvalEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, SourceInfo L) {
26170	if (!isActive()) return true;
26171	CurrentSource = L;
26172	return GetGlobalUnchecked<PT_Ptr>(S, CodePtr(), A0);
26173	}
26174	bool EvalEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, SourceInfo L) {
26175	if (!isActive()) return true;
26176	CurrentSource = L;
26177	return GetGlobalUnchecked<PT_MemberPtr>(S, CodePtr(), A0);
26178	}
26179	bool EvalEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, SourceInfo L) {
26180	if (!isActive()) return true;
26181	CurrentSource = L;
26182	return GetGlobalUnchecked<PT_Float>(S, CodePtr(), A0);
26183	}
26184	#endif
26185	#ifdef GET_OPCODE_NAMES
26186	OP_GetIntPtrSint8,
26187	OP_GetIntPtrUint8,
26188	OP_GetIntPtrSint16,
26189	OP_GetIntPtrUint16,
26190	OP_GetIntPtrSint32,
26191	OP_GetIntPtrUint32,
26192	OP_GetIntPtrSint64,
26193	OP_GetIntPtrUint64,
26194	OP_GetIntPtrIntAP,
26195	OP_GetIntPtrIntAPS,
26196	OP_GetIntPtrBool,
26197	OP_GetIntPtrFixedPoint,
26198	#endif
26199	#ifdef GET_INTERPFN_LIST
26200	&Interp_GetIntPtrSint8,
26201	&Interp_GetIntPtrUint8,
26202	&Interp_GetIntPtrSint16,
26203	&Interp_GetIntPtrUint16,
26204	&Interp_GetIntPtrSint32,
26205	&Interp_GetIntPtrUint32,
26206	&Interp_GetIntPtrSint64,
26207	&Interp_GetIntPtrUint64,
26208	&Interp_GetIntPtrIntAP,
26209	&Interp_GetIntPtrIntAPS,
26210	&Interp_GetIntPtrBool,
26211	&Interp_GetIntPtrFixedPoint,
26212	#endif
26213	#ifdef GET_INTERPFN_DISPATCHERS
26214	PRESERVE_NONE
26215	static bool Interp_GetIntPtrSint8(InterpState &S) {
26216	{
26217	CodePtr OpPC = S.PC;
26218	const auto V0 = ReadArg<const Type *>(S, S.PC);
26219	if (!GetIntPtr<PT_Sint8>(S, OpPC, V0)) return false;
26220	}
26221	#if USE_TAILCALLS
26222	MUSTTAIL return InterpNext(S);
26223	#else
26224	return true;
26225	#endif
26226	}
26227	PRESERVE_NONE
26228	static bool Interp_GetIntPtrUint8(InterpState &S) {
26229	{
26230	CodePtr OpPC = S.PC;
26231	const auto V0 = ReadArg<const Type *>(S, S.PC);
26232	if (!GetIntPtr<PT_Uint8>(S, OpPC, V0)) return false;
26233	}
26234	#if USE_TAILCALLS
26235	MUSTTAIL return InterpNext(S);
26236	#else
26237	return true;
26238	#endif
26239	}
26240	PRESERVE_NONE
26241	static bool Interp_GetIntPtrSint16(InterpState &S) {
26242	{
26243	CodePtr OpPC = S.PC;
26244	const auto V0 = ReadArg<const Type *>(S, S.PC);
26245	if (!GetIntPtr<PT_Sint16>(S, OpPC, V0)) return false;
26246	}
26247	#if USE_TAILCALLS
26248	MUSTTAIL return InterpNext(S);
26249	#else
26250	return true;
26251	#endif
26252	}
26253	PRESERVE_NONE
26254	static bool Interp_GetIntPtrUint16(InterpState &S) {
26255	{
26256	CodePtr OpPC = S.PC;
26257	const auto V0 = ReadArg<const Type *>(S, S.PC);
26258	if (!GetIntPtr<PT_Uint16>(S, OpPC, V0)) return false;
26259	}
26260	#if USE_TAILCALLS
26261	MUSTTAIL return InterpNext(S);
26262	#else
26263	return true;
26264	#endif
26265	}
26266	PRESERVE_NONE
26267	static bool Interp_GetIntPtrSint32(InterpState &S) {
26268	{
26269	CodePtr OpPC = S.PC;
26270	const auto V0 = ReadArg<const Type *>(S, S.PC);
26271	if (!GetIntPtr<PT_Sint32>(S, OpPC, V0)) return false;
26272	}
26273	#if USE_TAILCALLS
26274	MUSTTAIL return InterpNext(S);
26275	#else
26276	return true;
26277	#endif
26278	}
26279	PRESERVE_NONE
26280	static bool Interp_GetIntPtrUint32(InterpState &S) {
26281	{
26282	CodePtr OpPC = S.PC;
26283	const auto V0 = ReadArg<const Type *>(S, S.PC);
26284	if (!GetIntPtr<PT_Uint32>(S, OpPC, V0)) return false;
26285	}
26286	#if USE_TAILCALLS
26287	MUSTTAIL return InterpNext(S);
26288	#else
26289	return true;
26290	#endif
26291	}
26292	PRESERVE_NONE
26293	static bool Interp_GetIntPtrSint64(InterpState &S) {
26294	{
26295	CodePtr OpPC = S.PC;
26296	const auto V0 = ReadArg<const Type *>(S, S.PC);
26297	if (!GetIntPtr<PT_Sint64>(S, OpPC, V0)) return false;
26298	}
26299	#if USE_TAILCALLS
26300	MUSTTAIL return InterpNext(S);
26301	#else
26302	return true;
26303	#endif
26304	}
26305	PRESERVE_NONE
26306	static bool Interp_GetIntPtrUint64(InterpState &S) {
26307	{
26308	CodePtr OpPC = S.PC;
26309	const auto V0 = ReadArg<const Type *>(S, S.PC);
26310	if (!GetIntPtr<PT_Uint64>(S, OpPC, V0)) return false;
26311	}
26312	#if USE_TAILCALLS
26313	MUSTTAIL return InterpNext(S);
26314	#else
26315	return true;
26316	#endif
26317	}
26318	PRESERVE_NONE
26319	static bool Interp_GetIntPtrIntAP(InterpState &S) {
26320	{
26321	CodePtr OpPC = S.PC;
26322	const auto V0 = ReadArg<const Type *>(S, S.PC);
26323	if (!GetIntPtr<PT_IntAP>(S, OpPC, V0)) return false;
26324	}
26325	#if USE_TAILCALLS
26326	MUSTTAIL return InterpNext(S);
26327	#else
26328	return true;
26329	#endif
26330	}
26331	PRESERVE_NONE
26332	static bool Interp_GetIntPtrIntAPS(InterpState &S) {
26333	{
26334	CodePtr OpPC = S.PC;
26335	const auto V0 = ReadArg<const Type *>(S, S.PC);
26336	if (!GetIntPtr<PT_IntAPS>(S, OpPC, V0)) return false;
26337	}
26338	#if USE_TAILCALLS
26339	MUSTTAIL return InterpNext(S);
26340	#else
26341	return true;
26342	#endif
26343	}
26344	PRESERVE_NONE
26345	static bool Interp_GetIntPtrBool(InterpState &S) {
26346	{
26347	CodePtr OpPC = S.PC;
26348	const auto V0 = ReadArg<const Type *>(S, S.PC);
26349	if (!GetIntPtr<PT_Bool>(S, OpPC, V0)) return false;
26350	}
26351	#if USE_TAILCALLS
26352	MUSTTAIL return InterpNext(S);
26353	#else
26354	return true;
26355	#endif
26356	}
26357	PRESERVE_NONE
26358	static bool Interp_GetIntPtrFixedPoint(InterpState &S) {
26359	{
26360	CodePtr OpPC = S.PC;
26361	const auto V0 = ReadArg<const Type *>(S, S.PC);
26362	if (!GetIntPtr<PT_FixedPoint>(S, OpPC, V0)) return false;
26363	}
26364	#if USE_TAILCALLS
26365	MUSTTAIL return InterpNext(S);
26366	#else
26367	return true;
26368	#endif
26369	}
26370	#endif
26371	#ifdef GET_DISASM
26372	case OP_GetIntPtrSint8:
26373	Text.Op = PrintName("GetIntPtrSint8");
26374	Text.Args.push_back(printArg<const Type *>(P, PC));
26375	break;
26376	case OP_GetIntPtrUint8:
26377	Text.Op = PrintName("GetIntPtrUint8");
26378	Text.Args.push_back(printArg<const Type *>(P, PC));
26379	break;
26380	case OP_GetIntPtrSint16:
26381	Text.Op = PrintName("GetIntPtrSint16");
26382	Text.Args.push_back(printArg<const Type *>(P, PC));
26383	break;
26384	case OP_GetIntPtrUint16:
26385	Text.Op = PrintName("GetIntPtrUint16");
26386	Text.Args.push_back(printArg<const Type *>(P, PC));
26387	break;
26388	case OP_GetIntPtrSint32:
26389	Text.Op = PrintName("GetIntPtrSint32");
26390	Text.Args.push_back(printArg<const Type *>(P, PC));
26391	break;
26392	case OP_GetIntPtrUint32:
26393	Text.Op = PrintName("GetIntPtrUint32");
26394	Text.Args.push_back(printArg<const Type *>(P, PC));
26395	break;
26396	case OP_GetIntPtrSint64:
26397	Text.Op = PrintName("GetIntPtrSint64");
26398	Text.Args.push_back(printArg<const Type *>(P, PC));
26399	break;
26400	case OP_GetIntPtrUint64:
26401	Text.Op = PrintName("GetIntPtrUint64");
26402	Text.Args.push_back(printArg<const Type *>(P, PC));
26403	break;
26404	case OP_GetIntPtrIntAP:
26405	Text.Op = PrintName("GetIntPtrIntAP");
26406	Text.Args.push_back(printArg<const Type *>(P, PC));
26407	break;
26408	case OP_GetIntPtrIntAPS:
26409	Text.Op = PrintName("GetIntPtrIntAPS");
26410	Text.Args.push_back(printArg<const Type *>(P, PC));
26411	break;
26412	case OP_GetIntPtrBool:
26413	Text.Op = PrintName("GetIntPtrBool");
26414	Text.Args.push_back(printArg<const Type *>(P, PC));
26415	break;
26416	case OP_GetIntPtrFixedPoint:
26417	Text.Op = PrintName("GetIntPtrFixedPoint");
26418	Text.Args.push_back(printArg<const Type *>(P, PC));
26419	break;
26420	#endif
26421	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
26422	bool emitGetIntPtrSint8( const Type * , SourceInfo);
26423	bool emitGetIntPtrUint8( const Type * , SourceInfo);
26424	bool emitGetIntPtrSint16( const Type * , SourceInfo);
26425	bool emitGetIntPtrUint16( const Type * , SourceInfo);
26426	bool emitGetIntPtrSint32( const Type * , SourceInfo);
26427	bool emitGetIntPtrUint32( const Type * , SourceInfo);
26428	bool emitGetIntPtrSint64( const Type * , SourceInfo);
26429	bool emitGetIntPtrUint64( const Type * , SourceInfo);
26430	bool emitGetIntPtrIntAP( const Type * , SourceInfo);
26431	bool emitGetIntPtrIntAPS( const Type * , SourceInfo);
26432	bool emitGetIntPtrBool( const Type * , SourceInfo);
26433	bool emitGetIntPtrFixedPoint( const Type * , SourceInfo);
26434	#endif
26435	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
26436	[[nodiscard]] bool emitGetIntPtr(PrimType, const Type *, SourceInfo I);
26437	#endif
26438	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
26439	bool
26440	#if defined(GET_EVAL_IMPL)
26441	EvalEmitter
26442	#else
26443	ByteCodeEmitter
26444	#endif
26445	::emitGetIntPtr(PrimType T0, const Type * A0, SourceInfo I) {
26446	switch (T0) {
26447	case PT_Sint8:
26448	return emitGetIntPtrSint8(A0, I);
26449	case PT_Uint8:
26450	return emitGetIntPtrUint8(A0, I);
26451	case PT_Sint16:
26452	return emitGetIntPtrSint16(A0, I);
26453	case PT_Uint16:
26454	return emitGetIntPtrUint16(A0, I);
26455	case PT_Sint32:
26456	return emitGetIntPtrSint32(A0, I);
26457	case PT_Uint32:
26458	return emitGetIntPtrUint32(A0, I);
26459	case PT_Sint64:
26460	return emitGetIntPtrSint64(A0, I);
26461	case PT_Uint64:
26462	return emitGetIntPtrUint64(A0, I);
26463	case PT_IntAP:
26464	return emitGetIntPtrIntAP(A0, I);
26465	case PT_IntAPS:
26466	return emitGetIntPtrIntAPS(A0, I);
26467	case PT_Bool:
26468	return emitGetIntPtrBool(A0, I);
26469	case PT_FixedPoint:
26470	return emitGetIntPtrFixedPoint(A0, I);
26471	default: llvm_unreachable("invalid type: emitGetIntPtr");
26472	}
26473	llvm_unreachable("invalid enum value");
26474	}
26475	#endif
26476	#ifdef GET_LINK_IMPL
26477	bool ByteCodeEmitter::emitGetIntPtrSint8( const Type * A0, SourceInfo L) {
26478	return emitOp<const Type *>(OP_GetIntPtrSint8, A0, L);
26479	}
26480	bool ByteCodeEmitter::emitGetIntPtrUint8( const Type * A0, SourceInfo L) {
26481	return emitOp<const Type *>(OP_GetIntPtrUint8, A0, L);
26482	}
26483	bool ByteCodeEmitter::emitGetIntPtrSint16( const Type * A0, SourceInfo L) {
26484	return emitOp<const Type *>(OP_GetIntPtrSint16, A0, L);
26485	}
26486	bool ByteCodeEmitter::emitGetIntPtrUint16( const Type * A0, SourceInfo L) {
26487	return emitOp<const Type *>(OP_GetIntPtrUint16, A0, L);
26488	}
26489	bool ByteCodeEmitter::emitGetIntPtrSint32( const Type * A0, SourceInfo L) {
26490	return emitOp<const Type *>(OP_GetIntPtrSint32, A0, L);
26491	}
26492	bool ByteCodeEmitter::emitGetIntPtrUint32( const Type * A0, SourceInfo L) {
26493	return emitOp<const Type *>(OP_GetIntPtrUint32, A0, L);
26494	}
26495	bool ByteCodeEmitter::emitGetIntPtrSint64( const Type * A0, SourceInfo L) {
26496	return emitOp<const Type *>(OP_GetIntPtrSint64, A0, L);
26497	}
26498	bool ByteCodeEmitter::emitGetIntPtrUint64( const Type * A0, SourceInfo L) {
26499	return emitOp<const Type *>(OP_GetIntPtrUint64, A0, L);
26500	}
26501	bool ByteCodeEmitter::emitGetIntPtrIntAP( const Type * A0, SourceInfo L) {
26502	return emitOp<const Type *>(OP_GetIntPtrIntAP, A0, L);
26503	}
26504	bool ByteCodeEmitter::emitGetIntPtrIntAPS( const Type * A0, SourceInfo L) {
26505	return emitOp<const Type *>(OP_GetIntPtrIntAPS, A0, L);
26506	}
26507	bool ByteCodeEmitter::emitGetIntPtrBool( const Type * A0, SourceInfo L) {
26508	return emitOp<const Type *>(OP_GetIntPtrBool, A0, L);
26509	}
26510	bool ByteCodeEmitter::emitGetIntPtrFixedPoint( const Type * A0, SourceInfo L) {
26511	return emitOp<const Type *>(OP_GetIntPtrFixedPoint, A0, L);
26512	}
26513	#endif
26514	#ifdef GET_EVAL_IMPL
26515	bool EvalEmitter::emitGetIntPtrSint8( const Type * A0, SourceInfo L) {
26516	if (!isActive()) return true;
26517	CurrentSource = L;
26518	return GetIntPtr<PT_Sint8>(S, CodePtr(), A0);
26519	}
26520	bool EvalEmitter::emitGetIntPtrUint8( const Type * A0, SourceInfo L) {
26521	if (!isActive()) return true;
26522	CurrentSource = L;
26523	return GetIntPtr<PT_Uint8>(S, CodePtr(), A0);
26524	}
26525	bool EvalEmitter::emitGetIntPtrSint16( const Type * A0, SourceInfo L) {
26526	if (!isActive()) return true;
26527	CurrentSource = L;
26528	return GetIntPtr<PT_Sint16>(S, CodePtr(), A0);
26529	}
26530	bool EvalEmitter::emitGetIntPtrUint16( const Type * A0, SourceInfo L) {
26531	if (!isActive()) return true;
26532	CurrentSource = L;
26533	return GetIntPtr<PT_Uint16>(S, CodePtr(), A0);
26534	}
26535	bool EvalEmitter::emitGetIntPtrSint32( const Type * A0, SourceInfo L) {
26536	if (!isActive()) return true;
26537	CurrentSource = L;
26538	return GetIntPtr<PT_Sint32>(S, CodePtr(), A0);
26539	}
26540	bool EvalEmitter::emitGetIntPtrUint32( const Type * A0, SourceInfo L) {
26541	if (!isActive()) return true;
26542	CurrentSource = L;
26543	return GetIntPtr<PT_Uint32>(S, CodePtr(), A0);
26544	}
26545	bool EvalEmitter::emitGetIntPtrSint64( const Type * A0, SourceInfo L) {
26546	if (!isActive()) return true;
26547	CurrentSource = L;
26548	return GetIntPtr<PT_Sint64>(S, CodePtr(), A0);
26549	}
26550	bool EvalEmitter::emitGetIntPtrUint64( const Type * A0, SourceInfo L) {
26551	if (!isActive()) return true;
26552	CurrentSource = L;
26553	return GetIntPtr<PT_Uint64>(S, CodePtr(), A0);
26554	}
26555	bool EvalEmitter::emitGetIntPtrIntAP( const Type * A0, SourceInfo L) {
26556	if (!isActive()) return true;
26557	CurrentSource = L;
26558	return GetIntPtr<PT_IntAP>(S, CodePtr(), A0);
26559	}
26560	bool EvalEmitter::emitGetIntPtrIntAPS( const Type * A0, SourceInfo L) {
26561	if (!isActive()) return true;
26562	CurrentSource = L;
26563	return GetIntPtr<PT_IntAPS>(S, CodePtr(), A0);
26564	}
26565	bool EvalEmitter::emitGetIntPtrBool( const Type * A0, SourceInfo L) {
26566	if (!isActive()) return true;
26567	CurrentSource = L;
26568	return GetIntPtr<PT_Bool>(S, CodePtr(), A0);
26569	}
26570	bool EvalEmitter::emitGetIntPtrFixedPoint( const Type * A0, SourceInfo L) {
26571	if (!isActive()) return true;
26572	CurrentSource = L;
26573	return GetIntPtr<PT_FixedPoint>(S, CodePtr(), A0);
26574	}
26575	#endif
26576	#ifdef GET_OPCODE_NAMES
26577	OP_GetLocalSint8,
26578	OP_GetLocalUint8,
26579	OP_GetLocalSint16,
26580	OP_GetLocalUint16,
26581	OP_GetLocalSint32,
26582	OP_GetLocalUint32,
26583	OP_GetLocalSint64,
26584	OP_GetLocalUint64,
26585	OP_GetLocalIntAP,
26586	OP_GetLocalIntAPS,
26587	OP_GetLocalBool,
26588	OP_GetLocalFixedPoint,
26589	OP_GetLocalPtr,
26590	OP_GetLocalMemberPtr,
26591	OP_GetLocalFloat,
26592	#endif
26593	#ifdef GET_INTERPFN_LIST
26594	&Interp_GetLocalSint8,
26595	&Interp_GetLocalUint8,
26596	&Interp_GetLocalSint16,
26597	&Interp_GetLocalUint16,
26598	&Interp_GetLocalSint32,
26599	&Interp_GetLocalUint32,
26600	&Interp_GetLocalSint64,
26601	&Interp_GetLocalUint64,
26602	&Interp_GetLocalIntAP,
26603	&Interp_GetLocalIntAPS,
26604	&Interp_GetLocalBool,
26605	&Interp_GetLocalFixedPoint,
26606	&Interp_GetLocalPtr,
26607	&Interp_GetLocalMemberPtr,
26608	&Interp_GetLocalFloat,
26609	#endif
26610	#ifdef GET_INTERPFN_DISPATCHERS
26611	PRESERVE_NONE
26612	static bool Interp_GetLocalSint8(InterpState &S) {
26613	{
26614	CodePtr OpPC = S.PC;
26615	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26616	if (!GetLocal<PT_Sint8>(S, OpPC, V0)) return false;
26617	}
26618	#if USE_TAILCALLS
26619	MUSTTAIL return InterpNext(S);
26620	#else
26621	return true;
26622	#endif
26623	}
26624	PRESERVE_NONE
26625	static bool Interp_GetLocalUint8(InterpState &S) {
26626	{
26627	CodePtr OpPC = S.PC;
26628	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26629	if (!GetLocal<PT_Uint8>(S, OpPC, V0)) return false;
26630	}
26631	#if USE_TAILCALLS
26632	MUSTTAIL return InterpNext(S);
26633	#else
26634	return true;
26635	#endif
26636	}
26637	PRESERVE_NONE
26638	static bool Interp_GetLocalSint16(InterpState &S) {
26639	{
26640	CodePtr OpPC = S.PC;
26641	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26642	if (!GetLocal<PT_Sint16>(S, OpPC, V0)) return false;
26643	}
26644	#if USE_TAILCALLS
26645	MUSTTAIL return InterpNext(S);
26646	#else
26647	return true;
26648	#endif
26649	}
26650	PRESERVE_NONE
26651	static bool Interp_GetLocalUint16(InterpState &S) {
26652	{
26653	CodePtr OpPC = S.PC;
26654	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26655	if (!GetLocal<PT_Uint16>(S, OpPC, V0)) return false;
26656	}
26657	#if USE_TAILCALLS
26658	MUSTTAIL return InterpNext(S);
26659	#else
26660	return true;
26661	#endif
26662	}
26663	PRESERVE_NONE
26664	static bool Interp_GetLocalSint32(InterpState &S) {
26665	{
26666	CodePtr OpPC = S.PC;
26667	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26668	if (!GetLocal<PT_Sint32>(S, OpPC, V0)) return false;
26669	}
26670	#if USE_TAILCALLS
26671	MUSTTAIL return InterpNext(S);
26672	#else
26673	return true;
26674	#endif
26675	}
26676	PRESERVE_NONE
26677	static bool Interp_GetLocalUint32(InterpState &S) {
26678	{
26679	CodePtr OpPC = S.PC;
26680	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26681	if (!GetLocal<PT_Uint32>(S, OpPC, V0)) return false;
26682	}
26683	#if USE_TAILCALLS
26684	MUSTTAIL return InterpNext(S);
26685	#else
26686	return true;
26687	#endif
26688	}
26689	PRESERVE_NONE
26690	static bool Interp_GetLocalSint64(InterpState &S) {
26691	{
26692	CodePtr OpPC = S.PC;
26693	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26694	if (!GetLocal<PT_Sint64>(S, OpPC, V0)) return false;
26695	}
26696	#if USE_TAILCALLS
26697	MUSTTAIL return InterpNext(S);
26698	#else
26699	return true;
26700	#endif
26701	}
26702	PRESERVE_NONE
26703	static bool Interp_GetLocalUint64(InterpState &S) {
26704	{
26705	CodePtr OpPC = S.PC;
26706	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26707	if (!GetLocal<PT_Uint64>(S, OpPC, V0)) return false;
26708	}
26709	#if USE_TAILCALLS
26710	MUSTTAIL return InterpNext(S);
26711	#else
26712	return true;
26713	#endif
26714	}
26715	PRESERVE_NONE
26716	static bool Interp_GetLocalIntAP(InterpState &S) {
26717	{
26718	CodePtr OpPC = S.PC;
26719	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26720	if (!GetLocal<PT_IntAP>(S, OpPC, V0)) return false;
26721	}
26722	#if USE_TAILCALLS
26723	MUSTTAIL return InterpNext(S);
26724	#else
26725	return true;
26726	#endif
26727	}
26728	PRESERVE_NONE
26729	static bool Interp_GetLocalIntAPS(InterpState &S) {
26730	{
26731	CodePtr OpPC = S.PC;
26732	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26733	if (!GetLocal<PT_IntAPS>(S, OpPC, V0)) return false;
26734	}
26735	#if USE_TAILCALLS
26736	MUSTTAIL return InterpNext(S);
26737	#else
26738	return true;
26739	#endif
26740	}
26741	PRESERVE_NONE
26742	static bool Interp_GetLocalBool(InterpState &S) {
26743	{
26744	CodePtr OpPC = S.PC;
26745	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26746	if (!GetLocal<PT_Bool>(S, OpPC, V0)) return false;
26747	}
26748	#if USE_TAILCALLS
26749	MUSTTAIL return InterpNext(S);
26750	#else
26751	return true;
26752	#endif
26753	}
26754	PRESERVE_NONE
26755	static bool Interp_GetLocalFixedPoint(InterpState &S) {
26756	{
26757	CodePtr OpPC = S.PC;
26758	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26759	if (!GetLocal<PT_FixedPoint>(S, OpPC, V0)) return false;
26760	}
26761	#if USE_TAILCALLS
26762	MUSTTAIL return InterpNext(S);
26763	#else
26764	return true;
26765	#endif
26766	}
26767	PRESERVE_NONE
26768	static bool Interp_GetLocalPtr(InterpState &S) {
26769	{
26770	CodePtr OpPC = S.PC;
26771	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26772	if (!GetLocal<PT_Ptr>(S, OpPC, V0)) return false;
26773	}
26774	#if USE_TAILCALLS
26775	MUSTTAIL return InterpNext(S);
26776	#else
26777	return true;
26778	#endif
26779	}
26780	PRESERVE_NONE
26781	static bool Interp_GetLocalMemberPtr(InterpState &S) {
26782	{
26783	CodePtr OpPC = S.PC;
26784	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26785	if (!GetLocal<PT_MemberPtr>(S, OpPC, V0)) return false;
26786	}
26787	#if USE_TAILCALLS
26788	MUSTTAIL return InterpNext(S);
26789	#else
26790	return true;
26791	#endif
26792	}
26793	PRESERVE_NONE
26794	static bool Interp_GetLocalFloat(InterpState &S) {
26795	{
26796	CodePtr OpPC = S.PC;
26797	const auto V0 = ReadArg<uint32_t>(S, S.PC);
26798	if (!GetLocal<PT_Float>(S, OpPC, V0)) return false;
26799	}
26800	#if USE_TAILCALLS
26801	MUSTTAIL return InterpNext(S);
26802	#else
26803	return true;
26804	#endif
26805	}
26806	#endif
26807	#ifdef GET_DISASM
26808	case OP_GetLocalSint8:
26809	Text.Op = PrintName("GetLocalSint8");
26810	Text.Args.push_back(printArg<uint32_t>(P, PC));
26811	break;
26812	case OP_GetLocalUint8:
26813	Text.Op = PrintName("GetLocalUint8");
26814	Text.Args.push_back(printArg<uint32_t>(P, PC));
26815	break;
26816	case OP_GetLocalSint16:
26817	Text.Op = PrintName("GetLocalSint16");
26818	Text.Args.push_back(printArg<uint32_t>(P, PC));
26819	break;
26820	case OP_GetLocalUint16:
26821	Text.Op = PrintName("GetLocalUint16");
26822	Text.Args.push_back(printArg<uint32_t>(P, PC));
26823	break;
26824	case OP_GetLocalSint32:
26825	Text.Op = PrintName("GetLocalSint32");
26826	Text.Args.push_back(printArg<uint32_t>(P, PC));
26827	break;
26828	case OP_GetLocalUint32:
26829	Text.Op = PrintName("GetLocalUint32");
26830	Text.Args.push_back(printArg<uint32_t>(P, PC));
26831	break;
26832	case OP_GetLocalSint64:
26833	Text.Op = PrintName("GetLocalSint64");
26834	Text.Args.push_back(printArg<uint32_t>(P, PC));
26835	break;
26836	case OP_GetLocalUint64:
26837	Text.Op = PrintName("GetLocalUint64");
26838	Text.Args.push_back(printArg<uint32_t>(P, PC));
26839	break;
26840	case OP_GetLocalIntAP:
26841	Text.Op = PrintName("GetLocalIntAP");
26842	Text.Args.push_back(printArg<uint32_t>(P, PC));
26843	break;
26844	case OP_GetLocalIntAPS:
26845	Text.Op = PrintName("GetLocalIntAPS");
26846	Text.Args.push_back(printArg<uint32_t>(P, PC));
26847	break;
26848	case OP_GetLocalBool:
26849	Text.Op = PrintName("GetLocalBool");
26850	Text.Args.push_back(printArg<uint32_t>(P, PC));
26851	break;
26852	case OP_GetLocalFixedPoint:
26853	Text.Op = PrintName("GetLocalFixedPoint");
26854	Text.Args.push_back(printArg<uint32_t>(P, PC));
26855	break;
26856	case OP_GetLocalPtr:
26857	Text.Op = PrintName("GetLocalPtr");
26858	Text.Args.push_back(printArg<uint32_t>(P, PC));
26859	break;
26860	case OP_GetLocalMemberPtr:
26861	Text.Op = PrintName("GetLocalMemberPtr");
26862	Text.Args.push_back(printArg<uint32_t>(P, PC));
26863	break;
26864	case OP_GetLocalFloat:
26865	Text.Op = PrintName("GetLocalFloat");
26866	Text.Args.push_back(printArg<uint32_t>(P, PC));
26867	break;
26868	#endif
26869	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
26870	bool emitGetLocalSint8( uint32_t , SourceInfo);
26871	bool emitGetLocalUint8( uint32_t , SourceInfo);
26872	bool emitGetLocalSint16( uint32_t , SourceInfo);
26873	bool emitGetLocalUint16( uint32_t , SourceInfo);
26874	bool emitGetLocalSint32( uint32_t , SourceInfo);
26875	bool emitGetLocalUint32( uint32_t , SourceInfo);
26876	bool emitGetLocalSint64( uint32_t , SourceInfo);
26877	bool emitGetLocalUint64( uint32_t , SourceInfo);
26878	bool emitGetLocalIntAP( uint32_t , SourceInfo);
26879	bool emitGetLocalIntAPS( uint32_t , SourceInfo);
26880	bool emitGetLocalBool( uint32_t , SourceInfo);
26881	bool emitGetLocalFixedPoint( uint32_t , SourceInfo);
26882	bool emitGetLocalPtr( uint32_t , SourceInfo);
26883	bool emitGetLocalMemberPtr( uint32_t , SourceInfo);
26884	bool emitGetLocalFloat( uint32_t , SourceInfo);
26885	#if defined(GET_EVAL_PROTO)
26886	template<PrimType>
26887	bool emitGetLocal(uint32_t, SourceInfo);
26888	#endif
26889	#endif
26890	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
26891	[[nodiscard]] bool emitGetLocal(PrimType, uint32_t, SourceInfo I);
26892	#endif
26893	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
26894	bool
26895	#if defined(GET_EVAL_IMPL)
26896	EvalEmitter
26897	#else
26898	ByteCodeEmitter
26899	#endif
26900	::emitGetLocal(PrimType T0, uint32_t A0, SourceInfo I) {
26901	switch (T0) {
26902	case PT_Sint8:
26903	#ifdef GET_LINK_IMPL
26904	return emitGetLocalSint8
26905	#else
26906	return emitGetLocal<PT_Sint8>
26907	#endif
26908	(A0, I);
26909	case PT_Uint8:
26910	#ifdef GET_LINK_IMPL
26911	return emitGetLocalUint8
26912	#else
26913	return emitGetLocal<PT_Uint8>
26914	#endif
26915	(A0, I);
26916	case PT_Sint16:
26917	#ifdef GET_LINK_IMPL
26918	return emitGetLocalSint16
26919	#else
26920	return emitGetLocal<PT_Sint16>
26921	#endif
26922	(A0, I);
26923	case PT_Uint16:
26924	#ifdef GET_LINK_IMPL
26925	return emitGetLocalUint16
26926	#else
26927	return emitGetLocal<PT_Uint16>
26928	#endif
26929	(A0, I);
26930	case PT_Sint32:
26931	#ifdef GET_LINK_IMPL
26932	return emitGetLocalSint32
26933	#else
26934	return emitGetLocal<PT_Sint32>
26935	#endif
26936	(A0, I);
26937	case PT_Uint32:
26938	#ifdef GET_LINK_IMPL
26939	return emitGetLocalUint32
26940	#else
26941	return emitGetLocal<PT_Uint32>
26942	#endif
26943	(A0, I);
26944	case PT_Sint64:
26945	#ifdef GET_LINK_IMPL
26946	return emitGetLocalSint64
26947	#else
26948	return emitGetLocal<PT_Sint64>
26949	#endif
26950	(A0, I);
26951	case PT_Uint64:
26952	#ifdef GET_LINK_IMPL
26953	return emitGetLocalUint64
26954	#else
26955	return emitGetLocal<PT_Uint64>
26956	#endif
26957	(A0, I);
26958	case PT_IntAP:
26959	#ifdef GET_LINK_IMPL
26960	return emitGetLocalIntAP
26961	#else
26962	return emitGetLocal<PT_IntAP>
26963	#endif
26964	(A0, I);
26965	case PT_IntAPS:
26966	#ifdef GET_LINK_IMPL
26967	return emitGetLocalIntAPS
26968	#else
26969	return emitGetLocal<PT_IntAPS>
26970	#endif
26971	(A0, I);
26972	case PT_Bool:
26973	#ifdef GET_LINK_IMPL
26974	return emitGetLocalBool
26975	#else
26976	return emitGetLocal<PT_Bool>
26977	#endif
26978	(A0, I);
26979	case PT_FixedPoint:
26980	#ifdef GET_LINK_IMPL
26981	return emitGetLocalFixedPoint
26982	#else
26983	return emitGetLocal<PT_FixedPoint>
26984	#endif
26985	(A0, I);
26986	case PT_Ptr:
26987	#ifdef GET_LINK_IMPL
26988	return emitGetLocalPtr
26989	#else
26990	return emitGetLocal<PT_Ptr>
26991	#endif
26992	(A0, I);
26993	case PT_MemberPtr:
26994	#ifdef GET_LINK_IMPL
26995	return emitGetLocalMemberPtr
26996	#else
26997	return emitGetLocal<PT_MemberPtr>
26998	#endif
26999	(A0, I);
27000	case PT_Float:
27001	#ifdef GET_LINK_IMPL
27002	return emitGetLocalFloat
27003	#else
27004	return emitGetLocal<PT_Float>
27005	#endif
27006	(A0, I);
27007	}
27008	llvm_unreachable("invalid enum value");
27009	}
27010	#endif
27011	#ifdef GET_LINK_IMPL
27012	bool ByteCodeEmitter::emitGetLocalSint8( uint32_t A0, SourceInfo L) {
27013	return emitOp<uint32_t>(OP_GetLocalSint8, A0, L);
27014	}
27015	bool ByteCodeEmitter::emitGetLocalUint8( uint32_t A0, SourceInfo L) {
27016	return emitOp<uint32_t>(OP_GetLocalUint8, A0, L);
27017	}
27018	bool ByteCodeEmitter::emitGetLocalSint16( uint32_t A0, SourceInfo L) {
27019	return emitOp<uint32_t>(OP_GetLocalSint16, A0, L);
27020	}
27021	bool ByteCodeEmitter::emitGetLocalUint16( uint32_t A0, SourceInfo L) {
27022	return emitOp<uint32_t>(OP_GetLocalUint16, A0, L);
27023	}
27024	bool ByteCodeEmitter::emitGetLocalSint32( uint32_t A0, SourceInfo L) {
27025	return emitOp<uint32_t>(OP_GetLocalSint32, A0, L);
27026	}
27027	bool ByteCodeEmitter::emitGetLocalUint32( uint32_t A0, SourceInfo L) {
27028	return emitOp<uint32_t>(OP_GetLocalUint32, A0, L);
27029	}
27030	bool ByteCodeEmitter::emitGetLocalSint64( uint32_t A0, SourceInfo L) {
27031	return emitOp<uint32_t>(OP_GetLocalSint64, A0, L);
27032	}
27033	bool ByteCodeEmitter::emitGetLocalUint64( uint32_t A0, SourceInfo L) {
27034	return emitOp<uint32_t>(OP_GetLocalUint64, A0, L);
27035	}
27036	bool ByteCodeEmitter::emitGetLocalIntAP( uint32_t A0, SourceInfo L) {
27037	return emitOp<uint32_t>(OP_GetLocalIntAP, A0, L);
27038	}
27039	bool ByteCodeEmitter::emitGetLocalIntAPS( uint32_t A0, SourceInfo L) {
27040	return emitOp<uint32_t>(OP_GetLocalIntAPS, A0, L);
27041	}
27042	bool ByteCodeEmitter::emitGetLocalBool( uint32_t A0, SourceInfo L) {
27043	return emitOp<uint32_t>(OP_GetLocalBool, A0, L);
27044	}
27045	bool ByteCodeEmitter::emitGetLocalFixedPoint( uint32_t A0, SourceInfo L) {
27046	return emitOp<uint32_t>(OP_GetLocalFixedPoint, A0, L);
27047	}
27048	bool ByteCodeEmitter::emitGetLocalPtr( uint32_t A0, SourceInfo L) {
27049	return emitOp<uint32_t>(OP_GetLocalPtr, A0, L);
27050	}
27051	bool ByteCodeEmitter::emitGetLocalMemberPtr( uint32_t A0, SourceInfo L) {
27052	return emitOp<uint32_t>(OP_GetLocalMemberPtr, A0, L);
27053	}
27054	bool ByteCodeEmitter::emitGetLocalFloat( uint32_t A0, SourceInfo L) {
27055	return emitOp<uint32_t>(OP_GetLocalFloat, A0, L);
27056	}
27057	#endif
27058	#ifdef GET_OPCODE_NAMES
27059	OP_GetLocalEnabled,
27060	#endif
27061	#ifdef GET_INTERPFN_LIST
27062	&Interp_GetLocalEnabled,
27063	#endif
27064	#ifdef GET_INTERPFN_DISPATCHERS
27065	PRESERVE_NONE
27066	static bool Interp_GetLocalEnabled(InterpState &S) {
27067	{
27068	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27069	GetLocalEnabled(S, V0);
27070	}
27071	#if USE_TAILCALLS
27072	MUSTTAIL return InterpNext(S);
27073	#else
27074	return true;
27075	#endif
27076	}
27077	#endif
27078	#ifdef GET_DISASM
27079	case OP_GetLocalEnabled:
27080	Text.Op = PrintName("GetLocalEnabled");
27081	Text.Args.push_back(printArg<uint32_t>(P, PC));
27082	break;
27083	#endif
27084	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27085	bool emitGetLocalEnabled( uint32_t , SourceInfo);
27086	#endif
27087	#ifdef GET_LINK_IMPL
27088	bool ByteCodeEmitter::emitGetLocalEnabled( uint32_t A0, SourceInfo L) {
27089	return emitOp<uint32_t>(OP_GetLocalEnabled, A0, L);
27090	}
27091	#endif
27092	#ifdef GET_OPCODE_NAMES
27093	OP_GetMemberPtr,
27094	#endif
27095	#ifdef GET_INTERPFN_LIST
27096	&Interp_GetMemberPtr,
27097	#endif
27098	#ifdef GET_INTERPFN_DISPATCHERS
27099	PRESERVE_NONE
27100	static bool Interp_GetMemberPtr(InterpState &S) {
27101	{
27102	const auto V0 = ReadArg<const ValueDecl*>(S, S.PC);
27103	GetMemberPtr(S, V0);
27104	}
27105	#if USE_TAILCALLS
27106	MUSTTAIL return InterpNext(S);
27107	#else
27108	return true;
27109	#endif
27110	}
27111	#endif
27112	#ifdef GET_DISASM
27113	case OP_GetMemberPtr:
27114	Text.Op = PrintName("GetMemberPtr");
27115	Text.Args.push_back(printArg<const ValueDecl*>(P, PC));
27116	break;
27117	#endif
27118	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27119	bool emitGetMemberPtr( const ValueDecl* , SourceInfo);
27120	#endif
27121	#ifdef GET_LINK_IMPL
27122	bool ByteCodeEmitter::emitGetMemberPtr( const ValueDecl* A0, SourceInfo L) {
27123	return emitOp<const ValueDecl*>(OP_GetMemberPtr, A0, L);
27124	}
27125	#endif
27126	#ifdef GET_EVAL_IMPL
27127	bool EvalEmitter::emitGetMemberPtr( const ValueDecl* A0, SourceInfo L) {
27128	if (!isActive()) return true;
27129	CurrentSource = L;
27130	return GetMemberPtr(S, A0);
27131	}
27132	#endif
27133	#ifdef GET_OPCODE_NAMES
27134	OP_GetMemberPtrBase,
27135	#endif
27136	#ifdef GET_INTERPFN_LIST
27137	&Interp_GetMemberPtrBase,
27138	#endif
27139	#ifdef GET_INTERPFN_DISPATCHERS
27140	PRESERVE_NONE
27141	static bool Interp_GetMemberPtrBase(InterpState &S) {
27142	if (!GetMemberPtrBase(S)) return false;
27143	#if USE_TAILCALLS
27144	MUSTTAIL return InterpNext(S);
27145	#else
27146	return true;
27147	#endif
27148	}
27149	#endif
27150	#ifdef GET_DISASM
27151	case OP_GetMemberPtrBase:
27152	Text.Op = PrintName("GetMemberPtrBase");
27153	break;
27154	#endif
27155	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27156	bool emitGetMemberPtrBase(SourceInfo);
27157	#endif
27158	#ifdef GET_LINK_IMPL
27159	bool ByteCodeEmitter::emitGetMemberPtrBase(SourceInfo L) {
27160	return emitOp<>(OP_GetMemberPtrBase, L);
27161	}
27162	#endif
27163	#ifdef GET_EVAL_IMPL
27164	bool EvalEmitter::emitGetMemberPtrBase(SourceInfo L) {
27165	if (!isActive()) return true;
27166	CurrentSource = L;
27167	return GetMemberPtrBase(S);
27168	}
27169	#endif
27170	#ifdef GET_OPCODE_NAMES
27171	OP_GetMemberPtrDecl,
27172	#endif
27173	#ifdef GET_INTERPFN_LIST
27174	&Interp_GetMemberPtrDecl,
27175	#endif
27176	#ifdef GET_INTERPFN_DISPATCHERS
27177	PRESERVE_NONE
27178	static bool Interp_GetMemberPtrDecl(InterpState &S) {
27179	if (!GetMemberPtrDecl(S)) return false;
27180	#if USE_TAILCALLS
27181	MUSTTAIL return InterpNext(S);
27182	#else
27183	return true;
27184	#endif
27185	}
27186	#endif
27187	#ifdef GET_DISASM
27188	case OP_GetMemberPtrDecl:
27189	Text.Op = PrintName("GetMemberPtrDecl");
27190	break;
27191	#endif
27192	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27193	bool emitGetMemberPtrDecl(SourceInfo);
27194	#endif
27195	#ifdef GET_LINK_IMPL
27196	bool ByteCodeEmitter::emitGetMemberPtrDecl(SourceInfo L) {
27197	return emitOp<>(OP_GetMemberPtrDecl, L);
27198	}
27199	#endif
27200	#ifdef GET_EVAL_IMPL
27201	bool EvalEmitter::emitGetMemberPtrDecl(SourceInfo L) {
27202	if (!isActive()) return true;
27203	CurrentSource = L;
27204	return GetMemberPtrDecl(S);
27205	}
27206	#endif
27207	#ifdef GET_OPCODE_NAMES
27208	OP_GetParamSint8,
27209	OP_GetParamUint8,
27210	OP_GetParamSint16,
27211	OP_GetParamUint16,
27212	OP_GetParamSint32,
27213	OP_GetParamUint32,
27214	OP_GetParamSint64,
27215	OP_GetParamUint64,
27216	OP_GetParamIntAP,
27217	OP_GetParamIntAPS,
27218	OP_GetParamBool,
27219	OP_GetParamFixedPoint,
27220	OP_GetParamPtr,
27221	OP_GetParamMemberPtr,
27222	OP_GetParamFloat,
27223	#endif
27224	#ifdef GET_INTERPFN_LIST
27225	&Interp_GetParamSint8,
27226	&Interp_GetParamUint8,
27227	&Interp_GetParamSint16,
27228	&Interp_GetParamUint16,
27229	&Interp_GetParamSint32,
27230	&Interp_GetParamUint32,
27231	&Interp_GetParamSint64,
27232	&Interp_GetParamUint64,
27233	&Interp_GetParamIntAP,
27234	&Interp_GetParamIntAPS,
27235	&Interp_GetParamBool,
27236	&Interp_GetParamFixedPoint,
27237	&Interp_GetParamPtr,
27238	&Interp_GetParamMemberPtr,
27239	&Interp_GetParamFloat,
27240	#endif
27241	#ifdef GET_INTERPFN_DISPATCHERS
27242	PRESERVE_NONE
27243	static bool Interp_GetParamSint8(InterpState &S) {
27244	{
27245	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27246	if (!GetParam<PT_Sint8>(S, V0)) return false;
27247	}
27248	#if USE_TAILCALLS
27249	MUSTTAIL return InterpNext(S);
27250	#else
27251	return true;
27252	#endif
27253	}
27254	PRESERVE_NONE
27255	static bool Interp_GetParamUint8(InterpState &S) {
27256	{
27257	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27258	if (!GetParam<PT_Uint8>(S, V0)) return false;
27259	}
27260	#if USE_TAILCALLS
27261	MUSTTAIL return InterpNext(S);
27262	#else
27263	return true;
27264	#endif
27265	}
27266	PRESERVE_NONE
27267	static bool Interp_GetParamSint16(InterpState &S) {
27268	{
27269	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27270	if (!GetParam<PT_Sint16>(S, V0)) return false;
27271	}
27272	#if USE_TAILCALLS
27273	MUSTTAIL return InterpNext(S);
27274	#else
27275	return true;
27276	#endif
27277	}
27278	PRESERVE_NONE
27279	static bool Interp_GetParamUint16(InterpState &S) {
27280	{
27281	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27282	if (!GetParam<PT_Uint16>(S, V0)) return false;
27283	}
27284	#if USE_TAILCALLS
27285	MUSTTAIL return InterpNext(S);
27286	#else
27287	return true;
27288	#endif
27289	}
27290	PRESERVE_NONE
27291	static bool Interp_GetParamSint32(InterpState &S) {
27292	{
27293	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27294	if (!GetParam<PT_Sint32>(S, V0)) return false;
27295	}
27296	#if USE_TAILCALLS
27297	MUSTTAIL return InterpNext(S);
27298	#else
27299	return true;
27300	#endif
27301	}
27302	PRESERVE_NONE
27303	static bool Interp_GetParamUint32(InterpState &S) {
27304	{
27305	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27306	if (!GetParam<PT_Uint32>(S, V0)) return false;
27307	}
27308	#if USE_TAILCALLS
27309	MUSTTAIL return InterpNext(S);
27310	#else
27311	return true;
27312	#endif
27313	}
27314	PRESERVE_NONE
27315	static bool Interp_GetParamSint64(InterpState &S) {
27316	{
27317	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27318	if (!GetParam<PT_Sint64>(S, V0)) return false;
27319	}
27320	#if USE_TAILCALLS
27321	MUSTTAIL return InterpNext(S);
27322	#else
27323	return true;
27324	#endif
27325	}
27326	PRESERVE_NONE
27327	static bool Interp_GetParamUint64(InterpState &S) {
27328	{
27329	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27330	if (!GetParam<PT_Uint64>(S, V0)) return false;
27331	}
27332	#if USE_TAILCALLS
27333	MUSTTAIL return InterpNext(S);
27334	#else
27335	return true;
27336	#endif
27337	}
27338	PRESERVE_NONE
27339	static bool Interp_GetParamIntAP(InterpState &S) {
27340	{
27341	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27342	if (!GetParam<PT_IntAP>(S, V0)) return false;
27343	}
27344	#if USE_TAILCALLS
27345	MUSTTAIL return InterpNext(S);
27346	#else
27347	return true;
27348	#endif
27349	}
27350	PRESERVE_NONE
27351	static bool Interp_GetParamIntAPS(InterpState &S) {
27352	{
27353	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27354	if (!GetParam<PT_IntAPS>(S, V0)) return false;
27355	}
27356	#if USE_TAILCALLS
27357	MUSTTAIL return InterpNext(S);
27358	#else
27359	return true;
27360	#endif
27361	}
27362	PRESERVE_NONE
27363	static bool Interp_GetParamBool(InterpState &S) {
27364	{
27365	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27366	if (!GetParam<PT_Bool>(S, V0)) return false;
27367	}
27368	#if USE_TAILCALLS
27369	MUSTTAIL return InterpNext(S);
27370	#else
27371	return true;
27372	#endif
27373	}
27374	PRESERVE_NONE
27375	static bool Interp_GetParamFixedPoint(InterpState &S) {
27376	{
27377	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27378	if (!GetParam<PT_FixedPoint>(S, V0)) return false;
27379	}
27380	#if USE_TAILCALLS
27381	MUSTTAIL return InterpNext(S);
27382	#else
27383	return true;
27384	#endif
27385	}
27386	PRESERVE_NONE
27387	static bool Interp_GetParamPtr(InterpState &S) {
27388	{
27389	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27390	if (!GetParam<PT_Ptr>(S, V0)) return false;
27391	}
27392	#if USE_TAILCALLS
27393	MUSTTAIL return InterpNext(S);
27394	#else
27395	return true;
27396	#endif
27397	}
27398	PRESERVE_NONE
27399	static bool Interp_GetParamMemberPtr(InterpState &S) {
27400	{
27401	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27402	if (!GetParam<PT_MemberPtr>(S, V0)) return false;
27403	}
27404	#if USE_TAILCALLS
27405	MUSTTAIL return InterpNext(S);
27406	#else
27407	return true;
27408	#endif
27409	}
27410	PRESERVE_NONE
27411	static bool Interp_GetParamFloat(InterpState &S) {
27412	{
27413	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27414	if (!GetParam<PT_Float>(S, V0)) return false;
27415	}
27416	#if USE_TAILCALLS
27417	MUSTTAIL return InterpNext(S);
27418	#else
27419	return true;
27420	#endif
27421	}
27422	#endif
27423	#ifdef GET_DISASM
27424	case OP_GetParamSint8:
27425	Text.Op = PrintName("GetParamSint8");
27426	Text.Args.push_back(printArg<uint32_t>(P, PC));
27427	break;
27428	case OP_GetParamUint8:
27429	Text.Op = PrintName("GetParamUint8");
27430	Text.Args.push_back(printArg<uint32_t>(P, PC));
27431	break;
27432	case OP_GetParamSint16:
27433	Text.Op = PrintName("GetParamSint16");
27434	Text.Args.push_back(printArg<uint32_t>(P, PC));
27435	break;
27436	case OP_GetParamUint16:
27437	Text.Op = PrintName("GetParamUint16");
27438	Text.Args.push_back(printArg<uint32_t>(P, PC));
27439	break;
27440	case OP_GetParamSint32:
27441	Text.Op = PrintName("GetParamSint32");
27442	Text.Args.push_back(printArg<uint32_t>(P, PC));
27443	break;
27444	case OP_GetParamUint32:
27445	Text.Op = PrintName("GetParamUint32");
27446	Text.Args.push_back(printArg<uint32_t>(P, PC));
27447	break;
27448	case OP_GetParamSint64:
27449	Text.Op = PrintName("GetParamSint64");
27450	Text.Args.push_back(printArg<uint32_t>(P, PC));
27451	break;
27452	case OP_GetParamUint64:
27453	Text.Op = PrintName("GetParamUint64");
27454	Text.Args.push_back(printArg<uint32_t>(P, PC));
27455	break;
27456	case OP_GetParamIntAP:
27457	Text.Op = PrintName("GetParamIntAP");
27458	Text.Args.push_back(printArg<uint32_t>(P, PC));
27459	break;
27460	case OP_GetParamIntAPS:
27461	Text.Op = PrintName("GetParamIntAPS");
27462	Text.Args.push_back(printArg<uint32_t>(P, PC));
27463	break;
27464	case OP_GetParamBool:
27465	Text.Op = PrintName("GetParamBool");
27466	Text.Args.push_back(printArg<uint32_t>(P, PC));
27467	break;
27468	case OP_GetParamFixedPoint:
27469	Text.Op = PrintName("GetParamFixedPoint");
27470	Text.Args.push_back(printArg<uint32_t>(P, PC));
27471	break;
27472	case OP_GetParamPtr:
27473	Text.Op = PrintName("GetParamPtr");
27474	Text.Args.push_back(printArg<uint32_t>(P, PC));
27475	break;
27476	case OP_GetParamMemberPtr:
27477	Text.Op = PrintName("GetParamMemberPtr");
27478	Text.Args.push_back(printArg<uint32_t>(P, PC));
27479	break;
27480	case OP_GetParamFloat:
27481	Text.Op = PrintName("GetParamFloat");
27482	Text.Args.push_back(printArg<uint32_t>(P, PC));
27483	break;
27484	#endif
27485	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27486	bool emitGetParamSint8( uint32_t , SourceInfo);
27487	bool emitGetParamUint8( uint32_t , SourceInfo);
27488	bool emitGetParamSint16( uint32_t , SourceInfo);
27489	bool emitGetParamUint16( uint32_t , SourceInfo);
27490	bool emitGetParamSint32( uint32_t , SourceInfo);
27491	bool emitGetParamUint32( uint32_t , SourceInfo);
27492	bool emitGetParamSint64( uint32_t , SourceInfo);
27493	bool emitGetParamUint64( uint32_t , SourceInfo);
27494	bool emitGetParamIntAP( uint32_t , SourceInfo);
27495	bool emitGetParamIntAPS( uint32_t , SourceInfo);
27496	bool emitGetParamBool( uint32_t , SourceInfo);
27497	bool emitGetParamFixedPoint( uint32_t , SourceInfo);
27498	bool emitGetParamPtr( uint32_t , SourceInfo);
27499	bool emitGetParamMemberPtr( uint32_t , SourceInfo);
27500	bool emitGetParamFloat( uint32_t , SourceInfo);
27501	#endif
27502	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27503	[[nodiscard]] bool emitGetParam(PrimType, uint32_t, SourceInfo I);
27504	#endif
27505	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
27506	bool
27507	#if defined(GET_EVAL_IMPL)
27508	EvalEmitter
27509	#else
27510	ByteCodeEmitter
27511	#endif
27512	::emitGetParam(PrimType T0, uint32_t A0, SourceInfo I) {
27513	switch (T0) {
27514	case PT_Sint8:
27515	return emitGetParamSint8(A0, I);
27516	case PT_Uint8:
27517	return emitGetParamUint8(A0, I);
27518	case PT_Sint16:
27519	return emitGetParamSint16(A0, I);
27520	case PT_Uint16:
27521	return emitGetParamUint16(A0, I);
27522	case PT_Sint32:
27523	return emitGetParamSint32(A0, I);
27524	case PT_Uint32:
27525	return emitGetParamUint32(A0, I);
27526	case PT_Sint64:
27527	return emitGetParamSint64(A0, I);
27528	case PT_Uint64:
27529	return emitGetParamUint64(A0, I);
27530	case PT_IntAP:
27531	return emitGetParamIntAP(A0, I);
27532	case PT_IntAPS:
27533	return emitGetParamIntAPS(A0, I);
27534	case PT_Bool:
27535	return emitGetParamBool(A0, I);
27536	case PT_FixedPoint:
27537	return emitGetParamFixedPoint(A0, I);
27538	case PT_Ptr:
27539	return emitGetParamPtr(A0, I);
27540	case PT_MemberPtr:
27541	return emitGetParamMemberPtr(A0, I);
27542	case PT_Float:
27543	return emitGetParamFloat(A0, I);
27544	}
27545	llvm_unreachable("invalid enum value");
27546	}
27547	#endif
27548	#ifdef GET_LINK_IMPL
27549	bool ByteCodeEmitter::emitGetParamSint8( uint32_t A0, SourceInfo L) {
27550	return emitOp<uint32_t>(OP_GetParamSint8, A0, L);
27551	}
27552	bool ByteCodeEmitter::emitGetParamUint8( uint32_t A0, SourceInfo L) {
27553	return emitOp<uint32_t>(OP_GetParamUint8, A0, L);
27554	}
27555	bool ByteCodeEmitter::emitGetParamSint16( uint32_t A0, SourceInfo L) {
27556	return emitOp<uint32_t>(OP_GetParamSint16, A0, L);
27557	}
27558	bool ByteCodeEmitter::emitGetParamUint16( uint32_t A0, SourceInfo L) {
27559	return emitOp<uint32_t>(OP_GetParamUint16, A0, L);
27560	}
27561	bool ByteCodeEmitter::emitGetParamSint32( uint32_t A0, SourceInfo L) {
27562	return emitOp<uint32_t>(OP_GetParamSint32, A0, L);
27563	}
27564	bool ByteCodeEmitter::emitGetParamUint32( uint32_t A0, SourceInfo L) {
27565	return emitOp<uint32_t>(OP_GetParamUint32, A0, L);
27566	}
27567	bool ByteCodeEmitter::emitGetParamSint64( uint32_t A0, SourceInfo L) {
27568	return emitOp<uint32_t>(OP_GetParamSint64, A0, L);
27569	}
27570	bool ByteCodeEmitter::emitGetParamUint64( uint32_t A0, SourceInfo L) {
27571	return emitOp<uint32_t>(OP_GetParamUint64, A0, L);
27572	}
27573	bool ByteCodeEmitter::emitGetParamIntAP( uint32_t A0, SourceInfo L) {
27574	return emitOp<uint32_t>(OP_GetParamIntAP, A0, L);
27575	}
27576	bool ByteCodeEmitter::emitGetParamIntAPS( uint32_t A0, SourceInfo L) {
27577	return emitOp<uint32_t>(OP_GetParamIntAPS, A0, L);
27578	}
27579	bool ByteCodeEmitter::emitGetParamBool( uint32_t A0, SourceInfo L) {
27580	return emitOp<uint32_t>(OP_GetParamBool, A0, L);
27581	}
27582	bool ByteCodeEmitter::emitGetParamFixedPoint( uint32_t A0, SourceInfo L) {
27583	return emitOp<uint32_t>(OP_GetParamFixedPoint, A0, L);
27584	}
27585	bool ByteCodeEmitter::emitGetParamPtr( uint32_t A0, SourceInfo L) {
27586	return emitOp<uint32_t>(OP_GetParamPtr, A0, L);
27587	}
27588	bool ByteCodeEmitter::emitGetParamMemberPtr( uint32_t A0, SourceInfo L) {
27589	return emitOp<uint32_t>(OP_GetParamMemberPtr, A0, L);
27590	}
27591	bool ByteCodeEmitter::emitGetParamFloat( uint32_t A0, SourceInfo L) {
27592	return emitOp<uint32_t>(OP_GetParamFloat, A0, L);
27593	}
27594	#endif
27595	#ifdef GET_EVAL_IMPL
27596	bool EvalEmitter::emitGetParamSint8( uint32_t A0, SourceInfo L) {
27597	if (!isActive()) return true;
27598	CurrentSource = L;
27599	return GetParam<PT_Sint8>(S, A0);
27600	}
27601	bool EvalEmitter::emitGetParamUint8( uint32_t A0, SourceInfo L) {
27602	if (!isActive()) return true;
27603	CurrentSource = L;
27604	return GetParam<PT_Uint8>(S, A0);
27605	}
27606	bool EvalEmitter::emitGetParamSint16( uint32_t A0, SourceInfo L) {
27607	if (!isActive()) return true;
27608	CurrentSource = L;
27609	return GetParam<PT_Sint16>(S, A0);
27610	}
27611	bool EvalEmitter::emitGetParamUint16( uint32_t A0, SourceInfo L) {
27612	if (!isActive()) return true;
27613	CurrentSource = L;
27614	return GetParam<PT_Uint16>(S, A0);
27615	}
27616	bool EvalEmitter::emitGetParamSint32( uint32_t A0, SourceInfo L) {
27617	if (!isActive()) return true;
27618	CurrentSource = L;
27619	return GetParam<PT_Sint32>(S, A0);
27620	}
27621	bool EvalEmitter::emitGetParamUint32( uint32_t A0, SourceInfo L) {
27622	if (!isActive()) return true;
27623	CurrentSource = L;
27624	return GetParam<PT_Uint32>(S, A0);
27625	}
27626	bool EvalEmitter::emitGetParamSint64( uint32_t A0, SourceInfo L) {
27627	if (!isActive()) return true;
27628	CurrentSource = L;
27629	return GetParam<PT_Sint64>(S, A0);
27630	}
27631	bool EvalEmitter::emitGetParamUint64( uint32_t A0, SourceInfo L) {
27632	if (!isActive()) return true;
27633	CurrentSource = L;
27634	return GetParam<PT_Uint64>(S, A0);
27635	}
27636	bool EvalEmitter::emitGetParamIntAP( uint32_t A0, SourceInfo L) {
27637	if (!isActive()) return true;
27638	CurrentSource = L;
27639	return GetParam<PT_IntAP>(S, A0);
27640	}
27641	bool EvalEmitter::emitGetParamIntAPS( uint32_t A0, SourceInfo L) {
27642	if (!isActive()) return true;
27643	CurrentSource = L;
27644	return GetParam<PT_IntAPS>(S, A0);
27645	}
27646	bool EvalEmitter::emitGetParamBool( uint32_t A0, SourceInfo L) {
27647	if (!isActive()) return true;
27648	CurrentSource = L;
27649	return GetParam<PT_Bool>(S, A0);
27650	}
27651	bool EvalEmitter::emitGetParamFixedPoint( uint32_t A0, SourceInfo L) {
27652	if (!isActive()) return true;
27653	CurrentSource = L;
27654	return GetParam<PT_FixedPoint>(S, A0);
27655	}
27656	bool EvalEmitter::emitGetParamPtr( uint32_t A0, SourceInfo L) {
27657	if (!isActive()) return true;
27658	CurrentSource = L;
27659	return GetParam<PT_Ptr>(S, A0);
27660	}
27661	bool EvalEmitter::emitGetParamMemberPtr( uint32_t A0, SourceInfo L) {
27662	if (!isActive()) return true;
27663	CurrentSource = L;
27664	return GetParam<PT_MemberPtr>(S, A0);
27665	}
27666	bool EvalEmitter::emitGetParamFloat( uint32_t A0, SourceInfo L) {
27667	if (!isActive()) return true;
27668	CurrentSource = L;
27669	return GetParam<PT_Float>(S, A0);
27670	}
27671	#endif
27672	#ifdef GET_OPCODE_NAMES
27673	OP_GetPtrBase,
27674	#endif
27675	#ifdef GET_INTERPFN_LIST
27676	&Interp_GetPtrBase,
27677	#endif
27678	#ifdef GET_INTERPFN_DISPATCHERS
27679	PRESERVE_NONE
27680	static bool Interp_GetPtrBase(InterpState &S) {
27681	{
27682	CodePtr OpPC = S.PC;
27683	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27684	if (!GetPtrBase(S, OpPC, V0)) return false;
27685	}
27686	#if USE_TAILCALLS
27687	MUSTTAIL return InterpNext(S);
27688	#else
27689	return true;
27690	#endif
27691	}
27692	#endif
27693	#ifdef GET_DISASM
27694	case OP_GetPtrBase:
27695	Text.Op = PrintName("GetPtrBase");
27696	Text.Args.push_back(printArg<uint32_t>(P, PC));
27697	break;
27698	#endif
27699	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27700	bool emitGetPtrBase( uint32_t , SourceInfo);
27701	#endif
27702	#ifdef GET_LINK_IMPL
27703	bool ByteCodeEmitter::emitGetPtrBase( uint32_t A0, SourceInfo L) {
27704	return emitOp<uint32_t>(OP_GetPtrBase, A0, L);
27705	}
27706	#endif
27707	#ifdef GET_EVAL_IMPL
27708	bool EvalEmitter::emitGetPtrBase( uint32_t A0, SourceInfo L) {
27709	if (!isActive()) return true;
27710	CurrentSource = L;
27711	return GetPtrBase(S, CodePtr(), A0);
27712	}
27713	#endif
27714	#ifdef GET_OPCODE_NAMES
27715	OP_GetPtrBasePop,
27716	#endif
27717	#ifdef GET_INTERPFN_LIST
27718	&Interp_GetPtrBasePop,
27719	#endif
27720	#ifdef GET_INTERPFN_DISPATCHERS
27721	PRESERVE_NONE
27722	static bool Interp_GetPtrBasePop(InterpState &S) {
27723	{
27724	CodePtr OpPC = S.PC;
27725	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27726	const auto V1 = ReadArg<bool>(S, S.PC);
27727	if (!GetPtrBasePop(S, OpPC, V0, V1)) return false;
27728	}
27729	#if USE_TAILCALLS
27730	MUSTTAIL return InterpNext(S);
27731	#else
27732	return true;
27733	#endif
27734	}
27735	#endif
27736	#ifdef GET_DISASM
27737	case OP_GetPtrBasePop:
27738	Text.Op = PrintName("GetPtrBasePop");
27739	Text.Args.push_back(printArg<uint32_t>(P, PC));
27740	Text.Args.push_back(printArg<bool>(P, PC));
27741	break;
27742	#endif
27743	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27744	bool emitGetPtrBasePop( uint32_t , bool , SourceInfo);
27745	#endif
27746	#ifdef GET_LINK_IMPL
27747	bool ByteCodeEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, SourceInfo L) {
27748	return emitOp<uint32_t, bool>(OP_GetPtrBasePop, A0, A1, L);
27749	}
27750	#endif
27751	#ifdef GET_EVAL_IMPL
27752	bool EvalEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, SourceInfo L) {
27753	if (!isActive()) return true;
27754	CurrentSource = L;
27755	return GetPtrBasePop(S, CodePtr(), A0, A1);
27756	}
27757	#endif
27758	#ifdef GET_OPCODE_NAMES
27759	OP_GetPtrDerivedPop,
27760	#endif
27761	#ifdef GET_INTERPFN_LIST
27762	&Interp_GetPtrDerivedPop,
27763	#endif
27764	#ifdef GET_INTERPFN_DISPATCHERS
27765	PRESERVE_NONE
27766	static bool Interp_GetPtrDerivedPop(InterpState &S) {
27767	{
27768	CodePtr OpPC = S.PC;
27769	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27770	const auto V1 = ReadArg<bool>(S, S.PC);
27771	const auto V2 = ReadArg<const Type *>(S, S.PC);
27772	if (!GetPtrDerivedPop(S, OpPC, V0, V1, V2)) return false;
27773	}
27774	#if USE_TAILCALLS
27775	MUSTTAIL return InterpNext(S);
27776	#else
27777	return true;
27778	#endif
27779	}
27780	#endif
27781	#ifdef GET_DISASM
27782	case OP_GetPtrDerivedPop:
27783	Text.Op = PrintName("GetPtrDerivedPop");
27784	Text.Args.push_back(printArg<uint32_t>(P, PC));
27785	Text.Args.push_back(printArg<bool>(P, PC));
27786	Text.Args.push_back(printArg<const Type *>(P, PC));
27787	break;
27788	#endif
27789	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27790	bool emitGetPtrDerivedPop( uint32_t , bool , const Type * , SourceInfo);
27791	#endif
27792	#ifdef GET_LINK_IMPL
27793	bool ByteCodeEmitter::emitGetPtrDerivedPop( uint32_t A0, bool A1, const Type * A2, SourceInfo L) {
27794	return emitOp<uint32_t, bool, const Type *>(OP_GetPtrDerivedPop, A0, A1, A2, L);
27795	}
27796	#endif
27797	#ifdef GET_EVAL_IMPL
27798	bool EvalEmitter::emitGetPtrDerivedPop( uint32_t A0, bool A1, const Type * A2, SourceInfo L) {
27799	if (!isActive()) return true;
27800	CurrentSource = L;
27801	return GetPtrDerivedPop(S, CodePtr(), A0, A1, A2);
27802	}
27803	#endif
27804	#ifdef GET_OPCODE_NAMES
27805	OP_GetPtrField,
27806	#endif
27807	#ifdef GET_INTERPFN_LIST
27808	&Interp_GetPtrField,
27809	#endif
27810	#ifdef GET_INTERPFN_DISPATCHERS
27811	PRESERVE_NONE
27812	static bool Interp_GetPtrField(InterpState &S) {
27813	{
27814	CodePtr OpPC = S.PC;
27815	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27816	if (!GetPtrField(S, OpPC, V0)) return false;
27817	}
27818	#if USE_TAILCALLS
27819	MUSTTAIL return InterpNext(S);
27820	#else
27821	return true;
27822	#endif
27823	}
27824	#endif
27825	#ifdef GET_DISASM
27826	case OP_GetPtrField:
27827	Text.Op = PrintName("GetPtrField");
27828	Text.Args.push_back(printArg<uint32_t>(P, PC));
27829	break;
27830	#endif
27831	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27832	bool emitGetPtrField( uint32_t , SourceInfo);
27833	#endif
27834	#ifdef GET_LINK_IMPL
27835	bool ByteCodeEmitter::emitGetPtrField( uint32_t A0, SourceInfo L) {
27836	return emitOp<uint32_t>(OP_GetPtrField, A0, L);
27837	}
27838	#endif
27839	#ifdef GET_EVAL_IMPL
27840	bool EvalEmitter::emitGetPtrField( uint32_t A0, SourceInfo L) {
27841	if (!isActive()) return true;
27842	CurrentSource = L;
27843	return GetPtrField(S, CodePtr(), A0);
27844	}
27845	#endif
27846	#ifdef GET_OPCODE_NAMES
27847	OP_GetPtrFieldPop,
27848	#endif
27849	#ifdef GET_INTERPFN_LIST
27850	&Interp_GetPtrFieldPop,
27851	#endif
27852	#ifdef GET_INTERPFN_DISPATCHERS
27853	PRESERVE_NONE
27854	static bool Interp_GetPtrFieldPop(InterpState &S) {
27855	{
27856	CodePtr OpPC = S.PC;
27857	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27858	if (!GetPtrFieldPop(S, OpPC, V0)) return false;
27859	}
27860	#if USE_TAILCALLS
27861	MUSTTAIL return InterpNext(S);
27862	#else
27863	return true;
27864	#endif
27865	}
27866	#endif
27867	#ifdef GET_DISASM
27868	case OP_GetPtrFieldPop:
27869	Text.Op = PrintName("GetPtrFieldPop");
27870	Text.Args.push_back(printArg<uint32_t>(P, PC));
27871	break;
27872	#endif
27873	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27874	bool emitGetPtrFieldPop( uint32_t , SourceInfo);
27875	#endif
27876	#ifdef GET_LINK_IMPL
27877	bool ByteCodeEmitter::emitGetPtrFieldPop( uint32_t A0, SourceInfo L) {
27878	return emitOp<uint32_t>(OP_GetPtrFieldPop, A0, L);
27879	}
27880	#endif
27881	#ifdef GET_EVAL_IMPL
27882	bool EvalEmitter::emitGetPtrFieldPop( uint32_t A0, SourceInfo L) {
27883	if (!isActive()) return true;
27884	CurrentSource = L;
27885	return GetPtrFieldPop(S, CodePtr(), A0);
27886	}
27887	#endif
27888	#ifdef GET_OPCODE_NAMES
27889	OP_GetPtrGlobal,
27890	#endif
27891	#ifdef GET_INTERPFN_LIST
27892	&Interp_GetPtrGlobal,
27893	#endif
27894	#ifdef GET_INTERPFN_DISPATCHERS
27895	PRESERVE_NONE
27896	static bool Interp_GetPtrGlobal(InterpState &S) {
27897	{
27898	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27899	if (!GetPtrGlobal(S, V0)) return false;
27900	}
27901	#if USE_TAILCALLS
27902	MUSTTAIL return InterpNext(S);
27903	#else
27904	return true;
27905	#endif
27906	}
27907	#endif
27908	#ifdef GET_DISASM
27909	case OP_GetPtrGlobal:
27910	Text.Op = PrintName("GetPtrGlobal");
27911	Text.Args.push_back(printArg<uint32_t>(P, PC));
27912	break;
27913	#endif
27914	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27915	bool emitGetPtrGlobal( uint32_t , SourceInfo);
27916	#endif
27917	#ifdef GET_LINK_IMPL
27918	bool ByteCodeEmitter::emitGetPtrGlobal( uint32_t A0, SourceInfo L) {
27919	return emitOp<uint32_t>(OP_GetPtrGlobal, A0, L);
27920	}
27921	#endif
27922	#ifdef GET_EVAL_IMPL
27923	bool EvalEmitter::emitGetPtrGlobal( uint32_t A0, SourceInfo L) {
27924	if (!isActive()) return true;
27925	CurrentSource = L;
27926	return GetPtrGlobal(S, A0);
27927	}
27928	#endif
27929	#ifdef GET_OPCODE_NAMES
27930	OP_GetPtrLocal,
27931	#endif
27932	#ifdef GET_INTERPFN_LIST
27933	&Interp_GetPtrLocal,
27934	#endif
27935	#ifdef GET_INTERPFN_DISPATCHERS
27936	PRESERVE_NONE
27937	static bool Interp_GetPtrLocal(InterpState &S) {
27938	{
27939	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27940	if (!GetPtrLocal(S, V0)) return false;
27941	}
27942	#if USE_TAILCALLS
27943	MUSTTAIL return InterpNext(S);
27944	#else
27945	return true;
27946	#endif
27947	}
27948	#endif
27949	#ifdef GET_DISASM
27950	case OP_GetPtrLocal:
27951	Text.Op = PrintName("GetPtrLocal");
27952	Text.Args.push_back(printArg<uint32_t>(P, PC));
27953	break;
27954	#endif
27955	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27956	bool emitGetPtrLocal( uint32_t , SourceInfo);
27957	#endif
27958	#ifdef GET_LINK_IMPL
27959	bool ByteCodeEmitter::emitGetPtrLocal( uint32_t A0, SourceInfo L) {
27960	return emitOp<uint32_t>(OP_GetPtrLocal, A0, L);
27961	}
27962	#endif
27963	#ifdef GET_OPCODE_NAMES
27964	OP_GetPtrParam,
27965	#endif
27966	#ifdef GET_INTERPFN_LIST
27967	&Interp_GetPtrParam,
27968	#endif
27969	#ifdef GET_INTERPFN_DISPATCHERS
27970	PRESERVE_NONE
27971	static bool Interp_GetPtrParam(InterpState &S) {
27972	{
27973	const auto V0 = ReadArg<uint32_t>(S, S.PC);
27974	if (!GetPtrParam(S, V0)) return false;
27975	}
27976	#if USE_TAILCALLS
27977	MUSTTAIL return InterpNext(S);
27978	#else
27979	return true;
27980	#endif
27981	}
27982	#endif
27983	#ifdef GET_DISASM
27984	case OP_GetPtrParam:
27985	Text.Op = PrintName("GetPtrParam");
27986	Text.Args.push_back(printArg<uint32_t>(P, PC));
27987	break;
27988	#endif
27989	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
27990	bool emitGetPtrParam( uint32_t , SourceInfo);
27991	#endif
27992	#ifdef GET_LINK_IMPL
27993	bool ByteCodeEmitter::emitGetPtrParam( uint32_t A0, SourceInfo L) {
27994	return emitOp<uint32_t>(OP_GetPtrParam, A0, L);
27995	}
27996	#endif
27997	#ifdef GET_EVAL_IMPL
27998	bool EvalEmitter::emitGetPtrParam( uint32_t A0, SourceInfo L) {
27999	if (!isActive()) return true;
28000	CurrentSource = L;
28001	return GetPtrParam(S, A0);
28002	}
28003	#endif
28004	#ifdef GET_OPCODE_NAMES
28005	OP_GetPtrThisBase,
28006	#endif
28007	#ifdef GET_INTERPFN_LIST
28008	&Interp_GetPtrThisBase,
28009	#endif
28010	#ifdef GET_INTERPFN_DISPATCHERS
28011	PRESERVE_NONE
28012	static bool Interp_GetPtrThisBase(InterpState &S) {
28013	{
28014	CodePtr OpPC = S.PC;
28015	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28016	if (!GetPtrThisBase(S, OpPC, V0)) return false;
28017	}
28018	#if USE_TAILCALLS
28019	MUSTTAIL return InterpNext(S);
28020	#else
28021	return true;
28022	#endif
28023	}
28024	#endif
28025	#ifdef GET_DISASM
28026	case OP_GetPtrThisBase:
28027	Text.Op = PrintName("GetPtrThisBase");
28028	Text.Args.push_back(printArg<uint32_t>(P, PC));
28029	break;
28030	#endif
28031	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28032	bool emitGetPtrThisBase( uint32_t , SourceInfo);
28033	#endif
28034	#ifdef GET_LINK_IMPL
28035	bool ByteCodeEmitter::emitGetPtrThisBase( uint32_t A0, SourceInfo L) {
28036	return emitOp<uint32_t>(OP_GetPtrThisBase, A0, L);
28037	}
28038	#endif
28039	#ifdef GET_EVAL_IMPL
28040	bool EvalEmitter::emitGetPtrThisBase( uint32_t A0, SourceInfo L) {
28041	if (!isActive()) return true;
28042	CurrentSource = L;
28043	return GetPtrThisBase(S, CodePtr(), A0);
28044	}
28045	#endif
28046	#ifdef GET_OPCODE_NAMES
28047	OP_GetPtrThisField,
28048	#endif
28049	#ifdef GET_INTERPFN_LIST
28050	&Interp_GetPtrThisField,
28051	#endif
28052	#ifdef GET_INTERPFN_DISPATCHERS
28053	PRESERVE_NONE
28054	static bool Interp_GetPtrThisField(InterpState &S) {
28055	{
28056	CodePtr OpPC = S.PC;
28057	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28058	if (!GetPtrThisField(S, OpPC, V0)) return false;
28059	}
28060	#if USE_TAILCALLS
28061	MUSTTAIL return InterpNext(S);
28062	#else
28063	return true;
28064	#endif
28065	}
28066	#endif
28067	#ifdef GET_DISASM
28068	case OP_GetPtrThisField:
28069	Text.Op = PrintName("GetPtrThisField");
28070	Text.Args.push_back(printArg<uint32_t>(P, PC));
28071	break;
28072	#endif
28073	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28074	bool emitGetPtrThisField( uint32_t , SourceInfo);
28075	#endif
28076	#ifdef GET_LINK_IMPL
28077	bool ByteCodeEmitter::emitGetPtrThisField( uint32_t A0, SourceInfo L) {
28078	return emitOp<uint32_t>(OP_GetPtrThisField, A0, L);
28079	}
28080	#endif
28081	#ifdef GET_EVAL_IMPL
28082	bool EvalEmitter::emitGetPtrThisField( uint32_t A0, SourceInfo L) {
28083	if (!isActive()) return true;
28084	CurrentSource = L;
28085	return GetPtrThisField(S, CodePtr(), A0);
28086	}
28087	#endif
28088	#ifdef GET_OPCODE_NAMES
28089	OP_GetPtrThisVirtBase,
28090	#endif
28091	#ifdef GET_INTERPFN_LIST
28092	&Interp_GetPtrThisVirtBase,
28093	#endif
28094	#ifdef GET_INTERPFN_DISPATCHERS
28095	PRESERVE_NONE
28096	static bool Interp_GetPtrThisVirtBase(InterpState &S) {
28097	{
28098	CodePtr OpPC = S.PC;
28099	const auto V0 = ReadArg<const RecordDecl *>(S, S.PC);
28100	if (!GetPtrThisVirtBase(S, OpPC, V0)) return false;
28101	}
28102	#if USE_TAILCALLS
28103	MUSTTAIL return InterpNext(S);
28104	#else
28105	return true;
28106	#endif
28107	}
28108	#endif
28109	#ifdef GET_DISASM
28110	case OP_GetPtrThisVirtBase:
28111	Text.Op = PrintName("GetPtrThisVirtBase");
28112	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
28113	break;
28114	#endif
28115	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28116	bool emitGetPtrThisVirtBase( const RecordDecl * , SourceInfo);
28117	#endif
28118	#ifdef GET_LINK_IMPL
28119	bool ByteCodeEmitter::emitGetPtrThisVirtBase( const RecordDecl * A0, SourceInfo L) {
28120	return emitOp<const RecordDecl *>(OP_GetPtrThisVirtBase, A0, L);
28121	}
28122	#endif
28123	#ifdef GET_EVAL_IMPL
28124	bool EvalEmitter::emitGetPtrThisVirtBase( const RecordDecl * A0, SourceInfo L) {
28125	if (!isActive()) return true;
28126	CurrentSource = L;
28127	return GetPtrThisVirtBase(S, CodePtr(), A0);
28128	}
28129	#endif
28130	#ifdef GET_OPCODE_NAMES
28131	OP_GetPtrVirtBase,
28132	#endif
28133	#ifdef GET_INTERPFN_LIST
28134	&Interp_GetPtrVirtBase,
28135	#endif
28136	#ifdef GET_INTERPFN_DISPATCHERS
28137	PRESERVE_NONE
28138	static bool Interp_GetPtrVirtBase(InterpState &S) {
28139	{
28140	CodePtr OpPC = S.PC;
28141	const auto V0 = ReadArg<const RecordDecl *>(S, S.PC);
28142	if (!GetPtrVirtBase(S, OpPC, V0)) return false;
28143	}
28144	#if USE_TAILCALLS
28145	MUSTTAIL return InterpNext(S);
28146	#else
28147	return true;
28148	#endif
28149	}
28150	#endif
28151	#ifdef GET_DISASM
28152	case OP_GetPtrVirtBase:
28153	Text.Op = PrintName("GetPtrVirtBase");
28154	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
28155	break;
28156	#endif
28157	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28158	bool emitGetPtrVirtBase( const RecordDecl * , SourceInfo);
28159	#endif
28160	#ifdef GET_LINK_IMPL
28161	bool ByteCodeEmitter::emitGetPtrVirtBase( const RecordDecl * A0, SourceInfo L) {
28162	return emitOp<const RecordDecl *>(OP_GetPtrVirtBase, A0, L);
28163	}
28164	#endif
28165	#ifdef GET_EVAL_IMPL
28166	bool EvalEmitter::emitGetPtrVirtBase( const RecordDecl * A0, SourceInfo L) {
28167	if (!isActive()) return true;
28168	CurrentSource = L;
28169	return GetPtrVirtBase(S, CodePtr(), A0);
28170	}
28171	#endif
28172	#ifdef GET_OPCODE_NAMES
28173	OP_GetPtrVirtBasePop,
28174	#endif
28175	#ifdef GET_INTERPFN_LIST
28176	&Interp_GetPtrVirtBasePop,
28177	#endif
28178	#ifdef GET_INTERPFN_DISPATCHERS
28179	PRESERVE_NONE
28180	static bool Interp_GetPtrVirtBasePop(InterpState &S) {
28181	{
28182	CodePtr OpPC = S.PC;
28183	const auto V0 = ReadArg<const RecordDecl *>(S, S.PC);
28184	if (!GetPtrVirtBasePop(S, OpPC, V0)) return false;
28185	}
28186	#if USE_TAILCALLS
28187	MUSTTAIL return InterpNext(S);
28188	#else
28189	return true;
28190	#endif
28191	}
28192	#endif
28193	#ifdef GET_DISASM
28194	case OP_GetPtrVirtBasePop:
28195	Text.Op = PrintName("GetPtrVirtBasePop");
28196	Text.Args.push_back(printArg<const RecordDecl *>(P, PC));
28197	break;
28198	#endif
28199	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28200	bool emitGetPtrVirtBasePop( const RecordDecl * , SourceInfo);
28201	#endif
28202	#ifdef GET_LINK_IMPL
28203	bool ByteCodeEmitter::emitGetPtrVirtBasePop( const RecordDecl * A0, SourceInfo L) {
28204	return emitOp<const RecordDecl *>(OP_GetPtrVirtBasePop, A0, L);
28205	}
28206	#endif
28207	#ifdef GET_EVAL_IMPL
28208	bool EvalEmitter::emitGetPtrVirtBasePop( const RecordDecl * A0, SourceInfo L) {
28209	if (!isActive()) return true;
28210	CurrentSource = L;
28211	return GetPtrVirtBasePop(S, CodePtr(), A0);
28212	}
28213	#endif
28214	#ifdef GET_OPCODE_NAMES
28215	OP_GetRefGlobal,
28216	#endif
28217	#ifdef GET_INTERPFN_LIST
28218	&Interp_GetRefGlobal,
28219	#endif
28220	#ifdef GET_INTERPFN_DISPATCHERS
28221	PRESERVE_NONE
28222	static bool Interp_GetRefGlobal(InterpState &S) {
28223	{
28224	CodePtr OpPC = S.PC;
28225	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28226	if (!GetRefGlobal(S, OpPC, V0)) return false;
28227	}
28228	#if USE_TAILCALLS
28229	MUSTTAIL return InterpNext(S);
28230	#else
28231	return true;
28232	#endif
28233	}
28234	#endif
28235	#ifdef GET_DISASM
28236	case OP_GetRefGlobal:
28237	Text.Op = PrintName("GetRefGlobal");
28238	Text.Args.push_back(printArg<uint32_t>(P, PC));
28239	break;
28240	#endif
28241	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28242	bool emitGetRefGlobal( uint32_t , SourceInfo);
28243	#endif
28244	#ifdef GET_LINK_IMPL
28245	bool ByteCodeEmitter::emitGetRefGlobal( uint32_t A0, SourceInfo L) {
28246	return emitOp<uint32_t>(OP_GetRefGlobal, A0, L);
28247	}
28248	#endif
28249	#ifdef GET_EVAL_IMPL
28250	bool EvalEmitter::emitGetRefGlobal( uint32_t A0, SourceInfo L) {
28251	if (!isActive()) return true;
28252	CurrentSource = L;
28253	return GetRefGlobal(S, CodePtr(), A0);
28254	}
28255	#endif
28256	#ifdef GET_OPCODE_NAMES
28257	OP_GetRefLocal,
28258	#endif
28259	#ifdef GET_INTERPFN_LIST
28260	&Interp_GetRefLocal,
28261	#endif
28262	#ifdef GET_INTERPFN_DISPATCHERS
28263	PRESERVE_NONE
28264	static bool Interp_GetRefLocal(InterpState &S) {
28265	{
28266	CodePtr OpPC = S.PC;
28267	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28268	if (!GetRefLocal(S, OpPC, V0)) return false;
28269	}
28270	#if USE_TAILCALLS
28271	MUSTTAIL return InterpNext(S);
28272	#else
28273	return true;
28274	#endif
28275	}
28276	#endif
28277	#ifdef GET_DISASM
28278	case OP_GetRefLocal:
28279	Text.Op = PrintName("GetRefLocal");
28280	Text.Args.push_back(printArg<uint32_t>(P, PC));
28281	break;
28282	#endif
28283	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28284	bool emitGetRefLocal( uint32_t , SourceInfo);
28285	#endif
28286	#ifdef GET_LINK_IMPL
28287	bool ByteCodeEmitter::emitGetRefLocal( uint32_t A0, SourceInfo L) {
28288	return emitOp<uint32_t>(OP_GetRefLocal, A0, L);
28289	}
28290	#endif
28291	#ifdef GET_OPCODE_NAMES
28292	OP_GetThisFieldSint8,
28293	OP_GetThisFieldUint8,
28294	OP_GetThisFieldSint16,
28295	OP_GetThisFieldUint16,
28296	OP_GetThisFieldSint32,
28297	OP_GetThisFieldUint32,
28298	OP_GetThisFieldSint64,
28299	OP_GetThisFieldUint64,
28300	OP_GetThisFieldIntAP,
28301	OP_GetThisFieldIntAPS,
28302	OP_GetThisFieldBool,
28303	OP_GetThisFieldFixedPoint,
28304	OP_GetThisFieldPtr,
28305	OP_GetThisFieldMemberPtr,
28306	OP_GetThisFieldFloat,
28307	#endif
28308	#ifdef GET_INTERPFN_LIST
28309	&Interp_GetThisFieldSint8,
28310	&Interp_GetThisFieldUint8,
28311	&Interp_GetThisFieldSint16,
28312	&Interp_GetThisFieldUint16,
28313	&Interp_GetThisFieldSint32,
28314	&Interp_GetThisFieldUint32,
28315	&Interp_GetThisFieldSint64,
28316	&Interp_GetThisFieldUint64,
28317	&Interp_GetThisFieldIntAP,
28318	&Interp_GetThisFieldIntAPS,
28319	&Interp_GetThisFieldBool,
28320	&Interp_GetThisFieldFixedPoint,
28321	&Interp_GetThisFieldPtr,
28322	&Interp_GetThisFieldMemberPtr,
28323	&Interp_GetThisFieldFloat,
28324	#endif
28325	#ifdef GET_INTERPFN_DISPATCHERS
28326	PRESERVE_NONE
28327	static bool Interp_GetThisFieldSint8(InterpState &S) {
28328	{
28329	CodePtr OpPC = S.PC;
28330	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28331	if (!GetThisField<PT_Sint8>(S, OpPC, V0)) return false;
28332	}
28333	#if USE_TAILCALLS
28334	MUSTTAIL return InterpNext(S);
28335	#else
28336	return true;
28337	#endif
28338	}
28339	PRESERVE_NONE
28340	static bool Interp_GetThisFieldUint8(InterpState &S) {
28341	{
28342	CodePtr OpPC = S.PC;
28343	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28344	if (!GetThisField<PT_Uint8>(S, OpPC, V0)) return false;
28345	}
28346	#if USE_TAILCALLS
28347	MUSTTAIL return InterpNext(S);
28348	#else
28349	return true;
28350	#endif
28351	}
28352	PRESERVE_NONE
28353	static bool Interp_GetThisFieldSint16(InterpState &S) {
28354	{
28355	CodePtr OpPC = S.PC;
28356	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28357	if (!GetThisField<PT_Sint16>(S, OpPC, V0)) return false;
28358	}
28359	#if USE_TAILCALLS
28360	MUSTTAIL return InterpNext(S);
28361	#else
28362	return true;
28363	#endif
28364	}
28365	PRESERVE_NONE
28366	static bool Interp_GetThisFieldUint16(InterpState &S) {
28367	{
28368	CodePtr OpPC = S.PC;
28369	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28370	if (!GetThisField<PT_Uint16>(S, OpPC, V0)) return false;
28371	}
28372	#if USE_TAILCALLS
28373	MUSTTAIL return InterpNext(S);
28374	#else
28375	return true;
28376	#endif
28377	}
28378	PRESERVE_NONE
28379	static bool Interp_GetThisFieldSint32(InterpState &S) {
28380	{
28381	CodePtr OpPC = S.PC;
28382	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28383	if (!GetThisField<PT_Sint32>(S, OpPC, V0)) return false;
28384	}
28385	#if USE_TAILCALLS
28386	MUSTTAIL return InterpNext(S);
28387	#else
28388	return true;
28389	#endif
28390	}
28391	PRESERVE_NONE
28392	static bool Interp_GetThisFieldUint32(InterpState &S) {
28393	{
28394	CodePtr OpPC = S.PC;
28395	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28396	if (!GetThisField<PT_Uint32>(S, OpPC, V0)) return false;
28397	}
28398	#if USE_TAILCALLS
28399	MUSTTAIL return InterpNext(S);
28400	#else
28401	return true;
28402	#endif
28403	}
28404	PRESERVE_NONE
28405	static bool Interp_GetThisFieldSint64(InterpState &S) {
28406	{
28407	CodePtr OpPC = S.PC;
28408	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28409	if (!GetThisField<PT_Sint64>(S, OpPC, V0)) return false;
28410	}
28411	#if USE_TAILCALLS
28412	MUSTTAIL return InterpNext(S);
28413	#else
28414	return true;
28415	#endif
28416	}
28417	PRESERVE_NONE
28418	static bool Interp_GetThisFieldUint64(InterpState &S) {
28419	{
28420	CodePtr OpPC = S.PC;
28421	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28422	if (!GetThisField<PT_Uint64>(S, OpPC, V0)) return false;
28423	}
28424	#if USE_TAILCALLS
28425	MUSTTAIL return InterpNext(S);
28426	#else
28427	return true;
28428	#endif
28429	}
28430	PRESERVE_NONE
28431	static bool Interp_GetThisFieldIntAP(InterpState &S) {
28432	{
28433	CodePtr OpPC = S.PC;
28434	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28435	if (!GetThisField<PT_IntAP>(S, OpPC, V0)) return false;
28436	}
28437	#if USE_TAILCALLS
28438	MUSTTAIL return InterpNext(S);
28439	#else
28440	return true;
28441	#endif
28442	}
28443	PRESERVE_NONE
28444	static bool Interp_GetThisFieldIntAPS(InterpState &S) {
28445	{
28446	CodePtr OpPC = S.PC;
28447	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28448	if (!GetThisField<PT_IntAPS>(S, OpPC, V0)) return false;
28449	}
28450	#if USE_TAILCALLS
28451	MUSTTAIL return InterpNext(S);
28452	#else
28453	return true;
28454	#endif
28455	}
28456	PRESERVE_NONE
28457	static bool Interp_GetThisFieldBool(InterpState &S) {
28458	{
28459	CodePtr OpPC = S.PC;
28460	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28461	if (!GetThisField<PT_Bool>(S, OpPC, V0)) return false;
28462	}
28463	#if USE_TAILCALLS
28464	MUSTTAIL return InterpNext(S);
28465	#else
28466	return true;
28467	#endif
28468	}
28469	PRESERVE_NONE
28470	static bool Interp_GetThisFieldFixedPoint(InterpState &S) {
28471	{
28472	CodePtr OpPC = S.PC;
28473	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28474	if (!GetThisField<PT_FixedPoint>(S, OpPC, V0)) return false;
28475	}
28476	#if USE_TAILCALLS
28477	MUSTTAIL return InterpNext(S);
28478	#else
28479	return true;
28480	#endif
28481	}
28482	PRESERVE_NONE
28483	static bool Interp_GetThisFieldPtr(InterpState &S) {
28484	{
28485	CodePtr OpPC = S.PC;
28486	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28487	if (!GetThisField<PT_Ptr>(S, OpPC, V0)) return false;
28488	}
28489	#if USE_TAILCALLS
28490	MUSTTAIL return InterpNext(S);
28491	#else
28492	return true;
28493	#endif
28494	}
28495	PRESERVE_NONE
28496	static bool Interp_GetThisFieldMemberPtr(InterpState &S) {
28497	{
28498	CodePtr OpPC = S.PC;
28499	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28500	if (!GetThisField<PT_MemberPtr>(S, OpPC, V0)) return false;
28501	}
28502	#if USE_TAILCALLS
28503	MUSTTAIL return InterpNext(S);
28504	#else
28505	return true;
28506	#endif
28507	}
28508	PRESERVE_NONE
28509	static bool Interp_GetThisFieldFloat(InterpState &S) {
28510	{
28511	CodePtr OpPC = S.PC;
28512	const auto V0 = ReadArg<uint32_t>(S, S.PC);
28513	if (!GetThisField<PT_Float>(S, OpPC, V0)) return false;
28514	}
28515	#if USE_TAILCALLS
28516	MUSTTAIL return InterpNext(S);
28517	#else
28518	return true;
28519	#endif
28520	}
28521	#endif
28522	#ifdef GET_DISASM
28523	case OP_GetThisFieldSint8:
28524	Text.Op = PrintName("GetThisFieldSint8");
28525	Text.Args.push_back(printArg<uint32_t>(P, PC));
28526	break;
28527	case OP_GetThisFieldUint8:
28528	Text.Op = PrintName("GetThisFieldUint8");
28529	Text.Args.push_back(printArg<uint32_t>(P, PC));
28530	break;
28531	case OP_GetThisFieldSint16:
28532	Text.Op = PrintName("GetThisFieldSint16");
28533	Text.Args.push_back(printArg<uint32_t>(P, PC));
28534	break;
28535	case OP_GetThisFieldUint16:
28536	Text.Op = PrintName("GetThisFieldUint16");
28537	Text.Args.push_back(printArg<uint32_t>(P, PC));
28538	break;
28539	case OP_GetThisFieldSint32:
28540	Text.Op = PrintName("GetThisFieldSint32");
28541	Text.Args.push_back(printArg<uint32_t>(P, PC));
28542	break;
28543	case OP_GetThisFieldUint32:
28544	Text.Op = PrintName("GetThisFieldUint32");
28545	Text.Args.push_back(printArg<uint32_t>(P, PC));
28546	break;
28547	case OP_GetThisFieldSint64:
28548	Text.Op = PrintName("GetThisFieldSint64");
28549	Text.Args.push_back(printArg<uint32_t>(P, PC));
28550	break;
28551	case OP_GetThisFieldUint64:
28552	Text.Op = PrintName("GetThisFieldUint64");
28553	Text.Args.push_back(printArg<uint32_t>(P, PC));
28554	break;
28555	case OP_GetThisFieldIntAP:
28556	Text.Op = PrintName("GetThisFieldIntAP");
28557	Text.Args.push_back(printArg<uint32_t>(P, PC));
28558	break;
28559	case OP_GetThisFieldIntAPS:
28560	Text.Op = PrintName("GetThisFieldIntAPS");
28561	Text.Args.push_back(printArg<uint32_t>(P, PC));
28562	break;
28563	case OP_GetThisFieldBool:
28564	Text.Op = PrintName("GetThisFieldBool");
28565	Text.Args.push_back(printArg<uint32_t>(P, PC));
28566	break;
28567	case OP_GetThisFieldFixedPoint:
28568	Text.Op = PrintName("GetThisFieldFixedPoint");
28569	Text.Args.push_back(printArg<uint32_t>(P, PC));
28570	break;
28571	case OP_GetThisFieldPtr:
28572	Text.Op = PrintName("GetThisFieldPtr");
28573	Text.Args.push_back(printArg<uint32_t>(P, PC));
28574	break;
28575	case OP_GetThisFieldMemberPtr:
28576	Text.Op = PrintName("GetThisFieldMemberPtr");
28577	Text.Args.push_back(printArg<uint32_t>(P, PC));
28578	break;
28579	case OP_GetThisFieldFloat:
28580	Text.Op = PrintName("GetThisFieldFloat");
28581	Text.Args.push_back(printArg<uint32_t>(P, PC));
28582	break;
28583	#endif
28584	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28585	bool emitGetThisFieldSint8( uint32_t , SourceInfo);
28586	bool emitGetThisFieldUint8( uint32_t , SourceInfo);
28587	bool emitGetThisFieldSint16( uint32_t , SourceInfo);
28588	bool emitGetThisFieldUint16( uint32_t , SourceInfo);
28589	bool emitGetThisFieldSint32( uint32_t , SourceInfo);
28590	bool emitGetThisFieldUint32( uint32_t , SourceInfo);
28591	bool emitGetThisFieldSint64( uint32_t , SourceInfo);
28592	bool emitGetThisFieldUint64( uint32_t , SourceInfo);
28593	bool emitGetThisFieldIntAP( uint32_t , SourceInfo);
28594	bool emitGetThisFieldIntAPS( uint32_t , SourceInfo);
28595	bool emitGetThisFieldBool( uint32_t , SourceInfo);
28596	bool emitGetThisFieldFixedPoint( uint32_t , SourceInfo);
28597	bool emitGetThisFieldPtr( uint32_t , SourceInfo);
28598	bool emitGetThisFieldMemberPtr( uint32_t , SourceInfo);
28599	bool emitGetThisFieldFloat( uint32_t , SourceInfo);
28600	#endif
28601	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28602	[[nodiscard]] bool emitGetThisField(PrimType, uint32_t, SourceInfo I);
28603	#endif
28604	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
28605	bool
28606	#if defined(GET_EVAL_IMPL)
28607	EvalEmitter
28608	#else
28609	ByteCodeEmitter
28610	#endif
28611	::emitGetThisField(PrimType T0, uint32_t A0, SourceInfo I) {
28612	switch (T0) {
28613	case PT_Sint8:
28614	return emitGetThisFieldSint8(A0, I);
28615	case PT_Uint8:
28616	return emitGetThisFieldUint8(A0, I);
28617	case PT_Sint16:
28618	return emitGetThisFieldSint16(A0, I);
28619	case PT_Uint16:
28620	return emitGetThisFieldUint16(A0, I);
28621	case PT_Sint32:
28622	return emitGetThisFieldSint32(A0, I);
28623	case PT_Uint32:
28624	return emitGetThisFieldUint32(A0, I);
28625	case PT_Sint64:
28626	return emitGetThisFieldSint64(A0, I);
28627	case PT_Uint64:
28628	return emitGetThisFieldUint64(A0, I);
28629	case PT_IntAP:
28630	return emitGetThisFieldIntAP(A0, I);
28631	case PT_IntAPS:
28632	return emitGetThisFieldIntAPS(A0, I);
28633	case PT_Bool:
28634	return emitGetThisFieldBool(A0, I);
28635	case PT_FixedPoint:
28636	return emitGetThisFieldFixedPoint(A0, I);
28637	case PT_Ptr:
28638	return emitGetThisFieldPtr(A0, I);
28639	case PT_MemberPtr:
28640	return emitGetThisFieldMemberPtr(A0, I);
28641	case PT_Float:
28642	return emitGetThisFieldFloat(A0, I);
28643	}
28644	llvm_unreachable("invalid enum value");
28645	}
28646	#endif
28647	#ifdef GET_LINK_IMPL
28648	bool ByteCodeEmitter::emitGetThisFieldSint8( uint32_t A0, SourceInfo L) {
28649	return emitOp<uint32_t>(OP_GetThisFieldSint8, A0, L);
28650	}
28651	bool ByteCodeEmitter::emitGetThisFieldUint8( uint32_t A0, SourceInfo L) {
28652	return emitOp<uint32_t>(OP_GetThisFieldUint8, A0, L);
28653	}
28654	bool ByteCodeEmitter::emitGetThisFieldSint16( uint32_t A0, SourceInfo L) {
28655	return emitOp<uint32_t>(OP_GetThisFieldSint16, A0, L);
28656	}
28657	bool ByteCodeEmitter::emitGetThisFieldUint16( uint32_t A0, SourceInfo L) {
28658	return emitOp<uint32_t>(OP_GetThisFieldUint16, A0, L);
28659	}
28660	bool ByteCodeEmitter::emitGetThisFieldSint32( uint32_t A0, SourceInfo L) {
28661	return emitOp<uint32_t>(OP_GetThisFieldSint32, A0, L);
28662	}
28663	bool ByteCodeEmitter::emitGetThisFieldUint32( uint32_t A0, SourceInfo L) {
28664	return emitOp<uint32_t>(OP_GetThisFieldUint32, A0, L);
28665	}
28666	bool ByteCodeEmitter::emitGetThisFieldSint64( uint32_t A0, SourceInfo L) {
28667	return emitOp<uint32_t>(OP_GetThisFieldSint64, A0, L);
28668	}
28669	bool ByteCodeEmitter::emitGetThisFieldUint64( uint32_t A0, SourceInfo L) {
28670	return emitOp<uint32_t>(OP_GetThisFieldUint64, A0, L);
28671	}
28672	bool ByteCodeEmitter::emitGetThisFieldIntAP( uint32_t A0, SourceInfo L) {
28673	return emitOp<uint32_t>(OP_GetThisFieldIntAP, A0, L);
28674	}
28675	bool ByteCodeEmitter::emitGetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
28676	return emitOp<uint32_t>(OP_GetThisFieldIntAPS, A0, L);
28677	}
28678	bool ByteCodeEmitter::emitGetThisFieldBool( uint32_t A0, SourceInfo L) {
28679	return emitOp<uint32_t>(OP_GetThisFieldBool, A0, L);
28680	}
28681	bool ByteCodeEmitter::emitGetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
28682	return emitOp<uint32_t>(OP_GetThisFieldFixedPoint, A0, L);
28683	}
28684	bool ByteCodeEmitter::emitGetThisFieldPtr( uint32_t A0, SourceInfo L) {
28685	return emitOp<uint32_t>(OP_GetThisFieldPtr, A0, L);
28686	}
28687	bool ByteCodeEmitter::emitGetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
28688	return emitOp<uint32_t>(OP_GetThisFieldMemberPtr, A0, L);
28689	}
28690	bool ByteCodeEmitter::emitGetThisFieldFloat( uint32_t A0, SourceInfo L) {
28691	return emitOp<uint32_t>(OP_GetThisFieldFloat, A0, L);
28692	}
28693	#endif
28694	#ifdef GET_EVAL_IMPL
28695	bool EvalEmitter::emitGetThisFieldSint8( uint32_t A0, SourceInfo L) {
28696	if (!isActive()) return true;
28697	CurrentSource = L;
28698	return GetThisField<PT_Sint8>(S, CodePtr(), A0);
28699	}
28700	bool EvalEmitter::emitGetThisFieldUint8( uint32_t A0, SourceInfo L) {
28701	if (!isActive()) return true;
28702	CurrentSource = L;
28703	return GetThisField<PT_Uint8>(S, CodePtr(), A0);
28704	}
28705	bool EvalEmitter::emitGetThisFieldSint16( uint32_t A0, SourceInfo L) {
28706	if (!isActive()) return true;
28707	CurrentSource = L;
28708	return GetThisField<PT_Sint16>(S, CodePtr(), A0);
28709	}
28710	bool EvalEmitter::emitGetThisFieldUint16( uint32_t A0, SourceInfo L) {
28711	if (!isActive()) return true;
28712	CurrentSource = L;
28713	return GetThisField<PT_Uint16>(S, CodePtr(), A0);
28714	}
28715	bool EvalEmitter::emitGetThisFieldSint32( uint32_t A0, SourceInfo L) {
28716	if (!isActive()) return true;
28717	CurrentSource = L;
28718	return GetThisField<PT_Sint32>(S, CodePtr(), A0);
28719	}
28720	bool EvalEmitter::emitGetThisFieldUint32( uint32_t A0, SourceInfo L) {
28721	if (!isActive()) return true;
28722	CurrentSource = L;
28723	return GetThisField<PT_Uint32>(S, CodePtr(), A0);
28724	}
28725	bool EvalEmitter::emitGetThisFieldSint64( uint32_t A0, SourceInfo L) {
28726	if (!isActive()) return true;
28727	CurrentSource = L;
28728	return GetThisField<PT_Sint64>(S, CodePtr(), A0);
28729	}
28730	bool EvalEmitter::emitGetThisFieldUint64( uint32_t A0, SourceInfo L) {
28731	if (!isActive()) return true;
28732	CurrentSource = L;
28733	return GetThisField<PT_Uint64>(S, CodePtr(), A0);
28734	}
28735	bool EvalEmitter::emitGetThisFieldIntAP( uint32_t A0, SourceInfo L) {
28736	if (!isActive()) return true;
28737	CurrentSource = L;
28738	return GetThisField<PT_IntAP>(S, CodePtr(), A0);
28739	}
28740	bool EvalEmitter::emitGetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
28741	if (!isActive()) return true;
28742	CurrentSource = L;
28743	return GetThisField<PT_IntAPS>(S, CodePtr(), A0);
28744	}
28745	bool EvalEmitter::emitGetThisFieldBool( uint32_t A0, SourceInfo L) {
28746	if (!isActive()) return true;
28747	CurrentSource = L;
28748	return GetThisField<PT_Bool>(S, CodePtr(), A0);
28749	}
28750	bool EvalEmitter::emitGetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
28751	if (!isActive()) return true;
28752	CurrentSource = L;
28753	return GetThisField<PT_FixedPoint>(S, CodePtr(), A0);
28754	}
28755	bool EvalEmitter::emitGetThisFieldPtr( uint32_t A0, SourceInfo L) {
28756	if (!isActive()) return true;
28757	CurrentSource = L;
28758	return GetThisField<PT_Ptr>(S, CodePtr(), A0);
28759	}
28760	bool EvalEmitter::emitGetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
28761	if (!isActive()) return true;
28762	CurrentSource = L;
28763	return GetThisField<PT_MemberPtr>(S, CodePtr(), A0);
28764	}
28765	bool EvalEmitter::emitGetThisFieldFloat( uint32_t A0, SourceInfo L) {
28766	if (!isActive()) return true;
28767	CurrentSource = L;
28768	return GetThisField<PT_Float>(S, CodePtr(), A0);
28769	}
28770	#endif
28771	#ifdef GET_OPCODE_NAMES
28772	OP_GetTypeid,
28773	#endif
28774	#ifdef GET_INTERPFN_LIST
28775	&Interp_GetTypeid,
28776	#endif
28777	#ifdef GET_INTERPFN_DISPATCHERS
28778	PRESERVE_NONE
28779	static bool Interp_GetTypeid(InterpState &S) {
28780	{
28781	const auto V0 = ReadArg<const Type *>(S, S.PC);
28782	const auto V1 = ReadArg<const Type *>(S, S.PC);
28783	GetTypeid(S, V0, V1);
28784	}
28785	#if USE_TAILCALLS
28786	MUSTTAIL return InterpNext(S);
28787	#else
28788	return true;
28789	#endif
28790	}
28791	#endif
28792	#ifdef GET_DISASM
28793	case OP_GetTypeid:
28794	Text.Op = PrintName("GetTypeid");
28795	Text.Args.push_back(printArg<const Type *>(P, PC));
28796	Text.Args.push_back(printArg<const Type *>(P, PC));
28797	break;
28798	#endif
28799	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28800	bool emitGetTypeid( const Type * , const Type * , SourceInfo);
28801	#endif
28802	#ifdef GET_LINK_IMPL
28803	bool ByteCodeEmitter::emitGetTypeid( const Type * A0, const Type * A1, SourceInfo L) {
28804	return emitOp<const Type , const* Type *>(OP_GetTypeid, A0, A1, L);
28805	}
28806	#endif
28807	#ifdef GET_EVAL_IMPL
28808	bool EvalEmitter::emitGetTypeid( const Type * A0, const Type * A1, SourceInfo L) {
28809	if (!isActive()) return true;
28810	CurrentSource = L;
28811	return GetTypeid(S, A0, A1);
28812	}
28813	#endif
28814	#ifdef GET_OPCODE_NAMES
28815	OP_GetTypeidPtr,
28816	#endif
28817	#ifdef GET_INTERPFN_LIST
28818	&Interp_GetTypeidPtr,
28819	#endif
28820	#ifdef GET_INTERPFN_DISPATCHERS
28821	PRESERVE_NONE
28822	static bool Interp_GetTypeidPtr(InterpState &S) {
28823	{
28824	CodePtr OpPC = S.PC;
28825	const auto V0 = ReadArg<const Type *>(S, S.PC);
28826	if (!GetTypeidPtr(S, OpPC, V0)) return false;
28827	}
28828	#if USE_TAILCALLS
28829	MUSTTAIL return InterpNext(S);
28830	#else
28831	return true;
28832	#endif
28833	}
28834	#endif
28835	#ifdef GET_DISASM
28836	case OP_GetTypeidPtr:
28837	Text.Op = PrintName("GetTypeidPtr");
28838	Text.Args.push_back(printArg<const Type *>(P, PC));
28839	break;
28840	#endif
28841	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
28842	bool emitGetTypeidPtr( const Type * , SourceInfo);
28843	#endif
28844	#ifdef GET_LINK_IMPL
28845	bool ByteCodeEmitter::emitGetTypeidPtr( const Type * A0, SourceInfo L) {
28846	return emitOp<const Type *>(OP_GetTypeidPtr, A0, L);
28847	}
28848	#endif
28849	#ifdef GET_EVAL_IMPL
28850	bool EvalEmitter::emitGetTypeidPtr( const Type * A0, SourceInfo L) {
28851	if (!isActive()) return true;
28852	CurrentSource = L;
28853	return GetTypeidPtr(S, CodePtr(), A0);
28854	}
28855	#endif
28856	#ifdef GET_OPCODE_NAMES
28857	OP_IncSint8,
28858	OP_IncUint8,
28859	OP_IncSint16,
28860	OP_IncUint16,
28861	OP_IncSint32,
28862	OP_IncUint32,
28863	OP_IncSint64,
28864	OP_IncUint64,
28865	OP_IncIntAP,
28866	OP_IncIntAPS,
28867	OP_IncBool,
28868	OP_IncFixedPoint,
28869	#endif
28870	#ifdef GET_INTERPFN_LIST
28871	&Interp_IncSint8,
28872	&Interp_IncUint8,
28873	&Interp_IncSint16,
28874	&Interp_IncUint16,
28875	&Interp_IncSint32,
28876	&Interp_IncUint32,
28877	&Interp_IncSint64,
28878	&Interp_IncUint64,
28879	&Interp_IncIntAP,
28880	&Interp_IncIntAPS,
28881	&Interp_IncBool,
28882	&Interp_IncFixedPoint,
28883	#endif
28884	#ifdef GET_INTERPFN_DISPATCHERS
28885	PRESERVE_NONE
28886	static bool Interp_IncSint8(InterpState &S) {
28887	{
28888	CodePtr OpPC = S.PC;
28889	const auto V0 = ReadArg<bool>(S, S.PC);
28890	if (!Inc<PT_Sint8>(S, OpPC, V0)) return false;
28891	}
28892	#if USE_TAILCALLS
28893	MUSTTAIL return InterpNext(S);
28894	#else
28895	return true;
28896	#endif
28897	}
28898	PRESERVE_NONE
28899	static bool Interp_IncUint8(InterpState &S) {
28900	{
28901	CodePtr OpPC = S.PC;
28902	const auto V0 = ReadArg<bool>(S, S.PC);
28903	if (!Inc<PT_Uint8>(S, OpPC, V0)) return false;
28904	}
28905	#if USE_TAILCALLS
28906	MUSTTAIL return InterpNext(S);
28907	#else
28908	return true;
28909	#endif
28910	}
28911	PRESERVE_NONE
28912	static bool Interp_IncSint16(InterpState &S) {
28913	{
28914	CodePtr OpPC = S.PC;
28915	const auto V0 = ReadArg<bool>(S, S.PC);
28916	if (!Inc<PT_Sint16>(S, OpPC, V0)) return false;
28917	}
28918	#if USE_TAILCALLS
28919	MUSTTAIL return InterpNext(S);
28920	#else
28921	return true;
28922	#endif
28923	}
28924	PRESERVE_NONE
28925	static bool Interp_IncUint16(InterpState &S) {
28926	{
28927	CodePtr OpPC = S.PC;
28928	const auto V0 = ReadArg<bool>(S, S.PC);
28929	if (!Inc<PT_Uint16>(S, OpPC, V0)) return false;
28930	}
28931	#if USE_TAILCALLS
28932	MUSTTAIL return InterpNext(S);
28933	#else
28934	return true;
28935	#endif
28936	}
28937	PRESERVE_NONE
28938	static bool Interp_IncSint32(InterpState &S) {
28939	{
28940	CodePtr OpPC = S.PC;
28941	const auto V0 = ReadArg<bool>(S, S.PC);
28942	if (!Inc<PT_Sint32>(S, OpPC, V0)) return false;
28943	}
28944	#if USE_TAILCALLS
28945	MUSTTAIL return InterpNext(S);
28946	#else
28947	return true;
28948	#endif
28949	}
28950	PRESERVE_NONE
28951	static bool Interp_IncUint32(InterpState &S) {
28952	{
28953	CodePtr OpPC = S.PC;
28954	const auto V0 = ReadArg<bool>(S, S.PC);
28955	if (!Inc<PT_Uint32>(S, OpPC, V0)) return false;
28956	}
28957	#if USE_TAILCALLS
28958	MUSTTAIL return InterpNext(S);
28959	#else
28960	return true;
28961	#endif
28962	}
28963	PRESERVE_NONE
28964	static bool Interp_IncSint64(InterpState &S) {
28965	{
28966	CodePtr OpPC = S.PC;
28967	const auto V0 = ReadArg<bool>(S, S.PC);
28968	if (!Inc<PT_Sint64>(S, OpPC, V0)) return false;
28969	}
28970	#if USE_TAILCALLS
28971	MUSTTAIL return InterpNext(S);
28972	#else
28973	return true;
28974	#endif
28975	}
28976	PRESERVE_NONE
28977	static bool Interp_IncUint64(InterpState &S) {
28978	{
28979	CodePtr OpPC = S.PC;
28980	const auto V0 = ReadArg<bool>(S, S.PC);
28981	if (!Inc<PT_Uint64>(S, OpPC, V0)) return false;
28982	}
28983	#if USE_TAILCALLS
28984	MUSTTAIL return InterpNext(S);
28985	#else
28986	return true;
28987	#endif
28988	}
28989	PRESERVE_NONE
28990	static bool Interp_IncIntAP(InterpState &S) {
28991	{
28992	CodePtr OpPC = S.PC;
28993	const auto V0 = ReadArg<bool>(S, S.PC);
28994	if (!Inc<PT_IntAP>(S, OpPC, V0)) return false;
28995	}
28996	#if USE_TAILCALLS
28997	MUSTTAIL return InterpNext(S);
28998	#else
28999	return true;
29000	#endif
29001	}
29002	PRESERVE_NONE
29003	static bool Interp_IncIntAPS(InterpState &S) {
29004	{
29005	CodePtr OpPC = S.PC;
29006	const auto V0 = ReadArg<bool>(S, S.PC);
29007	if (!Inc<PT_IntAPS>(S, OpPC, V0)) return false;
29008	}
29009	#if USE_TAILCALLS
29010	MUSTTAIL return InterpNext(S);
29011	#else
29012	return true;
29013	#endif
29014	}
29015	PRESERVE_NONE
29016	static bool Interp_IncBool(InterpState &S) {
29017	{
29018	CodePtr OpPC = S.PC;
29019	const auto V0 = ReadArg<bool>(S, S.PC);
29020	if (!Inc<PT_Bool>(S, OpPC, V0)) return false;
29021	}
29022	#if USE_TAILCALLS
29023	MUSTTAIL return InterpNext(S);
29024	#else
29025	return true;
29026	#endif
29027	}
29028	PRESERVE_NONE
29029	static bool Interp_IncFixedPoint(InterpState &S) {
29030	{
29031	CodePtr OpPC = S.PC;
29032	const auto V0 = ReadArg<bool>(S, S.PC);
29033	if (!Inc<PT_FixedPoint>(S, OpPC, V0)) return false;
29034	}
29035	#if USE_TAILCALLS
29036	MUSTTAIL return InterpNext(S);
29037	#else
29038	return true;
29039	#endif
29040	}
29041	#endif
29042	#ifdef GET_DISASM
29043	case OP_IncSint8:
29044	Text.Op = PrintName("IncSint8");
29045	Text.Args.push_back(printArg<bool>(P, PC));
29046	break;
29047	case OP_IncUint8:
29048	Text.Op = PrintName("IncUint8");
29049	Text.Args.push_back(printArg<bool>(P, PC));
29050	break;
29051	case OP_IncSint16:
29052	Text.Op = PrintName("IncSint16");
29053	Text.Args.push_back(printArg<bool>(P, PC));
29054	break;
29055	case OP_IncUint16:
29056	Text.Op = PrintName("IncUint16");
29057	Text.Args.push_back(printArg<bool>(P, PC));
29058	break;
29059	case OP_IncSint32:
29060	Text.Op = PrintName("IncSint32");
29061	Text.Args.push_back(printArg<bool>(P, PC));
29062	break;
29063	case OP_IncUint32:
29064	Text.Op = PrintName("IncUint32");
29065	Text.Args.push_back(printArg<bool>(P, PC));
29066	break;
29067	case OP_IncSint64:
29068	Text.Op = PrintName("IncSint64");
29069	Text.Args.push_back(printArg<bool>(P, PC));
29070	break;
29071	case OP_IncUint64:
29072	Text.Op = PrintName("IncUint64");
29073	Text.Args.push_back(printArg<bool>(P, PC));
29074	break;
29075	case OP_IncIntAP:
29076	Text.Op = PrintName("IncIntAP");
29077	Text.Args.push_back(printArg<bool>(P, PC));
29078	break;
29079	case OP_IncIntAPS:
29080	Text.Op = PrintName("IncIntAPS");
29081	Text.Args.push_back(printArg<bool>(P, PC));
29082	break;
29083	case OP_IncBool:
29084	Text.Op = PrintName("IncBool");
29085	Text.Args.push_back(printArg<bool>(P, PC));
29086	break;
29087	case OP_IncFixedPoint:
29088	Text.Op = PrintName("IncFixedPoint");
29089	Text.Args.push_back(printArg<bool>(P, PC));
29090	break;
29091	#endif
29092	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29093	bool emitIncSint8( bool , SourceInfo);
29094	bool emitIncUint8( bool , SourceInfo);
29095	bool emitIncSint16( bool , SourceInfo);
29096	bool emitIncUint16( bool , SourceInfo);
29097	bool emitIncSint32( bool , SourceInfo);
29098	bool emitIncUint32( bool , SourceInfo);
29099	bool emitIncSint64( bool , SourceInfo);
29100	bool emitIncUint64( bool , SourceInfo);
29101	bool emitIncIntAP( bool , SourceInfo);
29102	bool emitIncIntAPS( bool , SourceInfo);
29103	bool emitIncBool( bool , SourceInfo);
29104	bool emitIncFixedPoint( bool , SourceInfo);
29105	#endif
29106	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29107	[[nodiscard]] bool emitInc(PrimType, bool, SourceInfo I);
29108	#endif
29109	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
29110	bool
29111	#if defined(GET_EVAL_IMPL)
29112	EvalEmitter
29113	#else
29114	ByteCodeEmitter
29115	#endif
29116	::emitInc(PrimType T0, bool A0, SourceInfo I) {
29117	switch (T0) {
29118	case PT_Sint8:
29119	return emitIncSint8(A0, I);
29120	case PT_Uint8:
29121	return emitIncUint8(A0, I);
29122	case PT_Sint16:
29123	return emitIncSint16(A0, I);
29124	case PT_Uint16:
29125	return emitIncUint16(A0, I);
29126	case PT_Sint32:
29127	return emitIncSint32(A0, I);
29128	case PT_Uint32:
29129	return emitIncUint32(A0, I);
29130	case PT_Sint64:
29131	return emitIncSint64(A0, I);
29132	case PT_Uint64:
29133	return emitIncUint64(A0, I);
29134	case PT_IntAP:
29135	return emitIncIntAP(A0, I);
29136	case PT_IntAPS:
29137	return emitIncIntAPS(A0, I);
29138	case PT_Bool:
29139	return emitIncBool(A0, I);
29140	case PT_FixedPoint:
29141	return emitIncFixedPoint(A0, I);
29142	default: llvm_unreachable("invalid type: emitInc");
29143	}
29144	llvm_unreachable("invalid enum value");
29145	}
29146	#endif
29147	#ifdef GET_LINK_IMPL
29148	bool ByteCodeEmitter::emitIncSint8( bool A0, SourceInfo L) {
29149	return emitOp<bool>(OP_IncSint8, A0, L);
29150	}
29151	bool ByteCodeEmitter::emitIncUint8( bool A0, SourceInfo L) {
29152	return emitOp<bool>(OP_IncUint8, A0, L);
29153	}
29154	bool ByteCodeEmitter::emitIncSint16( bool A0, SourceInfo L) {
29155	return emitOp<bool>(OP_IncSint16, A0, L);
29156	}
29157	bool ByteCodeEmitter::emitIncUint16( bool A0, SourceInfo L) {
29158	return emitOp<bool>(OP_IncUint16, A0, L);
29159	}
29160	bool ByteCodeEmitter::emitIncSint32( bool A0, SourceInfo L) {
29161	return emitOp<bool>(OP_IncSint32, A0, L);
29162	}
29163	bool ByteCodeEmitter::emitIncUint32( bool A0, SourceInfo L) {
29164	return emitOp<bool>(OP_IncUint32, A0, L);
29165	}
29166	bool ByteCodeEmitter::emitIncSint64( bool A0, SourceInfo L) {
29167	return emitOp<bool>(OP_IncSint64, A0, L);
29168	}
29169	bool ByteCodeEmitter::emitIncUint64( bool A0, SourceInfo L) {
29170	return emitOp<bool>(OP_IncUint64, A0, L);
29171	}
29172	bool ByteCodeEmitter::emitIncIntAP( bool A0, SourceInfo L) {
29173	return emitOp<bool>(OP_IncIntAP, A0, L);
29174	}
29175	bool ByteCodeEmitter::emitIncIntAPS( bool A0, SourceInfo L) {
29176	return emitOp<bool>(OP_IncIntAPS, A0, L);
29177	}
29178	bool ByteCodeEmitter::emitIncBool( bool A0, SourceInfo L) {
29179	return emitOp<bool>(OP_IncBool, A0, L);
29180	}
29181	bool ByteCodeEmitter::emitIncFixedPoint( bool A0, SourceInfo L) {
29182	return emitOp<bool>(OP_IncFixedPoint, A0, L);
29183	}
29184	#endif
29185	#ifdef GET_EVAL_IMPL
29186	bool EvalEmitter::emitIncSint8( bool A0, SourceInfo L) {
29187	if (!isActive()) return true;
29188	CurrentSource = L;
29189	return Inc<PT_Sint8>(S, CodePtr(), A0);
29190	}
29191	bool EvalEmitter::emitIncUint8( bool A0, SourceInfo L) {
29192	if (!isActive()) return true;
29193	CurrentSource = L;
29194	return Inc<PT_Uint8>(S, CodePtr(), A0);
29195	}
29196	bool EvalEmitter::emitIncSint16( bool A0, SourceInfo L) {
29197	if (!isActive()) return true;
29198	CurrentSource = L;
29199	return Inc<PT_Sint16>(S, CodePtr(), A0);
29200	}
29201	bool EvalEmitter::emitIncUint16( bool A0, SourceInfo L) {
29202	if (!isActive()) return true;
29203	CurrentSource = L;
29204	return Inc<PT_Uint16>(S, CodePtr(), A0);
29205	}
29206	bool EvalEmitter::emitIncSint32( bool A0, SourceInfo L) {
29207	if (!isActive()) return true;
29208	CurrentSource = L;
29209	return Inc<PT_Sint32>(S, CodePtr(), A0);
29210	}
29211	bool EvalEmitter::emitIncUint32( bool A0, SourceInfo L) {
29212	if (!isActive()) return true;
29213	CurrentSource = L;
29214	return Inc<PT_Uint32>(S, CodePtr(), A0);
29215	}
29216	bool EvalEmitter::emitIncSint64( bool A0, SourceInfo L) {
29217	if (!isActive()) return true;
29218	CurrentSource = L;
29219	return Inc<PT_Sint64>(S, CodePtr(), A0);
29220	}
29221	bool EvalEmitter::emitIncUint64( bool A0, SourceInfo L) {
29222	if (!isActive()) return true;
29223	CurrentSource = L;
29224	return Inc<PT_Uint64>(S, CodePtr(), A0);
29225	}
29226	bool EvalEmitter::emitIncIntAP( bool A0, SourceInfo L) {
29227	if (!isActive()) return true;
29228	CurrentSource = L;
29229	return Inc<PT_IntAP>(S, CodePtr(), A0);
29230	}
29231	bool EvalEmitter::emitIncIntAPS( bool A0, SourceInfo L) {
29232	if (!isActive()) return true;
29233	CurrentSource = L;
29234	return Inc<PT_IntAPS>(S, CodePtr(), A0);
29235	}
29236	bool EvalEmitter::emitIncBool( bool A0, SourceInfo L) {
29237	if (!isActive()) return true;
29238	CurrentSource = L;
29239	return Inc<PT_Bool>(S, CodePtr(), A0);
29240	}
29241	bool EvalEmitter::emitIncFixedPoint( bool A0, SourceInfo L) {
29242	if (!isActive()) return true;
29243	CurrentSource = L;
29244	return Inc<PT_FixedPoint>(S, CodePtr(), A0);
29245	}
29246	#endif
29247	#ifdef GET_OPCODE_NAMES
29248	OP_IncBitfieldSint8,
29249	OP_IncBitfieldUint8,
29250	OP_IncBitfieldSint16,
29251	OP_IncBitfieldUint16,
29252	OP_IncBitfieldSint32,
29253	OP_IncBitfieldUint32,
29254	OP_IncBitfieldSint64,
29255	OP_IncBitfieldUint64,
29256	OP_IncBitfieldIntAP,
29257	OP_IncBitfieldIntAPS,
29258	OP_IncBitfieldBool,
29259	OP_IncBitfieldFixedPoint,
29260	#endif
29261	#ifdef GET_INTERPFN_LIST
29262	&Interp_IncBitfieldSint8,
29263	&Interp_IncBitfieldUint8,
29264	&Interp_IncBitfieldSint16,
29265	&Interp_IncBitfieldUint16,
29266	&Interp_IncBitfieldSint32,
29267	&Interp_IncBitfieldUint32,
29268	&Interp_IncBitfieldSint64,
29269	&Interp_IncBitfieldUint64,
29270	&Interp_IncBitfieldIntAP,
29271	&Interp_IncBitfieldIntAPS,
29272	&Interp_IncBitfieldBool,
29273	&Interp_IncBitfieldFixedPoint,
29274	#endif
29275	#ifdef GET_INTERPFN_DISPATCHERS
29276	PRESERVE_NONE
29277	static bool Interp_IncBitfieldSint8(InterpState &S) {
29278	{
29279	CodePtr OpPC = S.PC;
29280	const auto V0 = ReadArg<bool>(S, S.PC);
29281	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29282	if (!IncBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
29283	}
29284	#if USE_TAILCALLS
29285	MUSTTAIL return InterpNext(S);
29286	#else
29287	return true;
29288	#endif
29289	}
29290	PRESERVE_NONE
29291	static bool Interp_IncBitfieldUint8(InterpState &S) {
29292	{
29293	CodePtr OpPC = S.PC;
29294	const auto V0 = ReadArg<bool>(S, S.PC);
29295	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29296	if (!IncBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
29297	}
29298	#if USE_TAILCALLS
29299	MUSTTAIL return InterpNext(S);
29300	#else
29301	return true;
29302	#endif
29303	}
29304	PRESERVE_NONE
29305	static bool Interp_IncBitfieldSint16(InterpState &S) {
29306	{
29307	CodePtr OpPC = S.PC;
29308	const auto V0 = ReadArg<bool>(S, S.PC);
29309	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29310	if (!IncBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
29311	}
29312	#if USE_TAILCALLS
29313	MUSTTAIL return InterpNext(S);
29314	#else
29315	return true;
29316	#endif
29317	}
29318	PRESERVE_NONE
29319	static bool Interp_IncBitfieldUint16(InterpState &S) {
29320	{
29321	CodePtr OpPC = S.PC;
29322	const auto V0 = ReadArg<bool>(S, S.PC);
29323	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29324	if (!IncBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
29325	}
29326	#if USE_TAILCALLS
29327	MUSTTAIL return InterpNext(S);
29328	#else
29329	return true;
29330	#endif
29331	}
29332	PRESERVE_NONE
29333	static bool Interp_IncBitfieldSint32(InterpState &S) {
29334	{
29335	CodePtr OpPC = S.PC;
29336	const auto V0 = ReadArg<bool>(S, S.PC);
29337	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29338	if (!IncBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
29339	}
29340	#if USE_TAILCALLS
29341	MUSTTAIL return InterpNext(S);
29342	#else
29343	return true;
29344	#endif
29345	}
29346	PRESERVE_NONE
29347	static bool Interp_IncBitfieldUint32(InterpState &S) {
29348	{
29349	CodePtr OpPC = S.PC;
29350	const auto V0 = ReadArg<bool>(S, S.PC);
29351	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29352	if (!IncBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
29353	}
29354	#if USE_TAILCALLS
29355	MUSTTAIL return InterpNext(S);
29356	#else
29357	return true;
29358	#endif
29359	}
29360	PRESERVE_NONE
29361	static bool Interp_IncBitfieldSint64(InterpState &S) {
29362	{
29363	CodePtr OpPC = S.PC;
29364	const auto V0 = ReadArg<bool>(S, S.PC);
29365	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29366	if (!IncBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
29367	}
29368	#if USE_TAILCALLS
29369	MUSTTAIL return InterpNext(S);
29370	#else
29371	return true;
29372	#endif
29373	}
29374	PRESERVE_NONE
29375	static bool Interp_IncBitfieldUint64(InterpState &S) {
29376	{
29377	CodePtr OpPC = S.PC;
29378	const auto V0 = ReadArg<bool>(S, S.PC);
29379	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29380	if (!IncBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
29381	}
29382	#if USE_TAILCALLS
29383	MUSTTAIL return InterpNext(S);
29384	#else
29385	return true;
29386	#endif
29387	}
29388	PRESERVE_NONE
29389	static bool Interp_IncBitfieldIntAP(InterpState &S) {
29390	{
29391	CodePtr OpPC = S.PC;
29392	const auto V0 = ReadArg<bool>(S, S.PC);
29393	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29394	if (!IncBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
29395	}
29396	#if USE_TAILCALLS
29397	MUSTTAIL return InterpNext(S);
29398	#else
29399	return true;
29400	#endif
29401	}
29402	PRESERVE_NONE
29403	static bool Interp_IncBitfieldIntAPS(InterpState &S) {
29404	{
29405	CodePtr OpPC = S.PC;
29406	const auto V0 = ReadArg<bool>(S, S.PC);
29407	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29408	if (!IncBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
29409	}
29410	#if USE_TAILCALLS
29411	MUSTTAIL return InterpNext(S);
29412	#else
29413	return true;
29414	#endif
29415	}
29416	PRESERVE_NONE
29417	static bool Interp_IncBitfieldBool(InterpState &S) {
29418	{
29419	CodePtr OpPC = S.PC;
29420	const auto V0 = ReadArg<bool>(S, S.PC);
29421	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29422	if (!IncBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
29423	}
29424	#if USE_TAILCALLS
29425	MUSTTAIL return InterpNext(S);
29426	#else
29427	return true;
29428	#endif
29429	}
29430	PRESERVE_NONE
29431	static bool Interp_IncBitfieldFixedPoint(InterpState &S) {
29432	{
29433	CodePtr OpPC = S.PC;
29434	const auto V0 = ReadArg<bool>(S, S.PC);
29435	const auto V1 = ReadArg<uint32_t>(S, S.PC);
29436	if (!IncBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
29437	}
29438	#if USE_TAILCALLS
29439	MUSTTAIL return InterpNext(S);
29440	#else
29441	return true;
29442	#endif
29443	}
29444	#endif
29445	#ifdef GET_DISASM
29446	case OP_IncBitfieldSint8:
29447	Text.Op = PrintName("IncBitfieldSint8");
29448	Text.Args.push_back(printArg<bool>(P, PC));
29449	Text.Args.push_back(printArg<uint32_t>(P, PC));
29450	break;
29451	case OP_IncBitfieldUint8:
29452	Text.Op = PrintName("IncBitfieldUint8");
29453	Text.Args.push_back(printArg<bool>(P, PC));
29454	Text.Args.push_back(printArg<uint32_t>(P, PC));
29455	break;
29456	case OP_IncBitfieldSint16:
29457	Text.Op = PrintName("IncBitfieldSint16");
29458	Text.Args.push_back(printArg<bool>(P, PC));
29459	Text.Args.push_back(printArg<uint32_t>(P, PC));
29460	break;
29461	case OP_IncBitfieldUint16:
29462	Text.Op = PrintName("IncBitfieldUint16");
29463	Text.Args.push_back(printArg<bool>(P, PC));
29464	Text.Args.push_back(printArg<uint32_t>(P, PC));
29465	break;
29466	case OP_IncBitfieldSint32:
29467	Text.Op = PrintName("IncBitfieldSint32");
29468	Text.Args.push_back(printArg<bool>(P, PC));
29469	Text.Args.push_back(printArg<uint32_t>(P, PC));
29470	break;
29471	case OP_IncBitfieldUint32:
29472	Text.Op = PrintName("IncBitfieldUint32");
29473	Text.Args.push_back(printArg<bool>(P, PC));
29474	Text.Args.push_back(printArg<uint32_t>(P, PC));
29475	break;
29476	case OP_IncBitfieldSint64:
29477	Text.Op = PrintName("IncBitfieldSint64");
29478	Text.Args.push_back(printArg<bool>(P, PC));
29479	Text.Args.push_back(printArg<uint32_t>(P, PC));
29480	break;
29481	case OP_IncBitfieldUint64:
29482	Text.Op = PrintName("IncBitfieldUint64");
29483	Text.Args.push_back(printArg<bool>(P, PC));
29484	Text.Args.push_back(printArg<uint32_t>(P, PC));
29485	break;
29486	case OP_IncBitfieldIntAP:
29487	Text.Op = PrintName("IncBitfieldIntAP");
29488	Text.Args.push_back(printArg<bool>(P, PC));
29489	Text.Args.push_back(printArg<uint32_t>(P, PC));
29490	break;
29491	case OP_IncBitfieldIntAPS:
29492	Text.Op = PrintName("IncBitfieldIntAPS");
29493	Text.Args.push_back(printArg<bool>(P, PC));
29494	Text.Args.push_back(printArg<uint32_t>(P, PC));
29495	break;
29496	case OP_IncBitfieldBool:
29497	Text.Op = PrintName("IncBitfieldBool");
29498	Text.Args.push_back(printArg<bool>(P, PC));
29499	Text.Args.push_back(printArg<uint32_t>(P, PC));
29500	break;
29501	case OP_IncBitfieldFixedPoint:
29502	Text.Op = PrintName("IncBitfieldFixedPoint");
29503	Text.Args.push_back(printArg<bool>(P, PC));
29504	Text.Args.push_back(printArg<uint32_t>(P, PC));
29505	break;
29506	#endif
29507	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29508	bool emitIncBitfieldSint8( bool , uint32_t , SourceInfo);
29509	bool emitIncBitfieldUint8( bool , uint32_t , SourceInfo);
29510	bool emitIncBitfieldSint16( bool , uint32_t , SourceInfo);
29511	bool emitIncBitfieldUint16( bool , uint32_t , SourceInfo);
29512	bool emitIncBitfieldSint32( bool , uint32_t , SourceInfo);
29513	bool emitIncBitfieldUint32( bool , uint32_t , SourceInfo);
29514	bool emitIncBitfieldSint64( bool , uint32_t , SourceInfo);
29515	bool emitIncBitfieldUint64( bool , uint32_t , SourceInfo);
29516	bool emitIncBitfieldIntAP( bool , uint32_t , SourceInfo);
29517	bool emitIncBitfieldIntAPS( bool , uint32_t , SourceInfo);
29518	bool emitIncBitfieldBool( bool , uint32_t , SourceInfo);
29519	bool emitIncBitfieldFixedPoint( bool , uint32_t , SourceInfo);
29520	#endif
29521	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29522	[[nodiscard]] bool emitIncBitfield(PrimType, bool, uint32_t, SourceInfo I);
29523	#endif
29524	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
29525	bool
29526	#if defined(GET_EVAL_IMPL)
29527	EvalEmitter
29528	#else
29529	ByteCodeEmitter
29530	#endif
29531	::emitIncBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
29532	switch (T0) {
29533	case PT_Sint8:
29534	return emitIncBitfieldSint8(A0, A1, I);
29535	case PT_Uint8:
29536	return emitIncBitfieldUint8(A0, A1, I);
29537	case PT_Sint16:
29538	return emitIncBitfieldSint16(A0, A1, I);
29539	case PT_Uint16:
29540	return emitIncBitfieldUint16(A0, A1, I);
29541	case PT_Sint32:
29542	return emitIncBitfieldSint32(A0, A1, I);
29543	case PT_Uint32:
29544	return emitIncBitfieldUint32(A0, A1, I);
29545	case PT_Sint64:
29546	return emitIncBitfieldSint64(A0, A1, I);
29547	case PT_Uint64:
29548	return emitIncBitfieldUint64(A0, A1, I);
29549	case PT_IntAP:
29550	return emitIncBitfieldIntAP(A0, A1, I);
29551	case PT_IntAPS:
29552	return emitIncBitfieldIntAPS(A0, A1, I);
29553	case PT_Bool:
29554	return emitIncBitfieldBool(A0, A1, I);
29555	case PT_FixedPoint:
29556	return emitIncBitfieldFixedPoint(A0, A1, I);
29557	default: llvm_unreachable("invalid type: emitIncBitfield");
29558	}
29559	llvm_unreachable("invalid enum value");
29560	}
29561	#endif
29562	#ifdef GET_LINK_IMPL
29563	bool ByteCodeEmitter::emitIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
29564	return emitOp<bool, uint32_t>(OP_IncBitfieldSint8, A0, A1, L);
29565	}
29566	bool ByteCodeEmitter::emitIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
29567	return emitOp<bool, uint32_t>(OP_IncBitfieldUint8, A0, A1, L);
29568	}
29569	bool ByteCodeEmitter::emitIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
29570	return emitOp<bool, uint32_t>(OP_IncBitfieldSint16, A0, A1, L);
29571	}
29572	bool ByteCodeEmitter::emitIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
29573	return emitOp<bool, uint32_t>(OP_IncBitfieldUint16, A0, A1, L);
29574	}
29575	bool ByteCodeEmitter::emitIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
29576	return emitOp<bool, uint32_t>(OP_IncBitfieldSint32, A0, A1, L);
29577	}
29578	bool ByteCodeEmitter::emitIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
29579	return emitOp<bool, uint32_t>(OP_IncBitfieldUint32, A0, A1, L);
29580	}
29581	bool ByteCodeEmitter::emitIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
29582	return emitOp<bool, uint32_t>(OP_IncBitfieldSint64, A0, A1, L);
29583	}
29584	bool ByteCodeEmitter::emitIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
29585	return emitOp<bool, uint32_t>(OP_IncBitfieldUint64, A0, A1, L);
29586	}
29587	bool ByteCodeEmitter::emitIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
29588	return emitOp<bool, uint32_t>(OP_IncBitfieldIntAP, A0, A1, L);
29589	}
29590	bool ByteCodeEmitter::emitIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
29591	return emitOp<bool, uint32_t>(OP_IncBitfieldIntAPS, A0, A1, L);
29592	}
29593	bool ByteCodeEmitter::emitIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
29594	return emitOp<bool, uint32_t>(OP_IncBitfieldBool, A0, A1, L);
29595	}
29596	bool ByteCodeEmitter::emitIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
29597	return emitOp<bool, uint32_t>(OP_IncBitfieldFixedPoint, A0, A1, L);
29598	}
29599	#endif
29600	#ifdef GET_EVAL_IMPL
29601	bool EvalEmitter::emitIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
29602	if (!isActive()) return true;
29603	CurrentSource = L;
29604	return IncBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
29605	}
29606	bool EvalEmitter::emitIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
29607	if (!isActive()) return true;
29608	CurrentSource = L;
29609	return IncBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
29610	}
29611	bool EvalEmitter::emitIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
29612	if (!isActive()) return true;
29613	CurrentSource = L;
29614	return IncBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
29615	}
29616	bool EvalEmitter::emitIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
29617	if (!isActive()) return true;
29618	CurrentSource = L;
29619	return IncBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
29620	}
29621	bool EvalEmitter::emitIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
29622	if (!isActive()) return true;
29623	CurrentSource = L;
29624	return IncBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
29625	}
29626	bool EvalEmitter::emitIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
29627	if (!isActive()) return true;
29628	CurrentSource = L;
29629	return IncBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
29630	}
29631	bool EvalEmitter::emitIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
29632	if (!isActive()) return true;
29633	CurrentSource = L;
29634	return IncBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
29635	}
29636	bool EvalEmitter::emitIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
29637	if (!isActive()) return true;
29638	CurrentSource = L;
29639	return IncBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
29640	}
29641	bool EvalEmitter::emitIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
29642	if (!isActive()) return true;
29643	CurrentSource = L;
29644	return IncBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
29645	}
29646	bool EvalEmitter::emitIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
29647	if (!isActive()) return true;
29648	CurrentSource = L;
29649	return IncBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
29650	}
29651	bool EvalEmitter::emitIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
29652	if (!isActive()) return true;
29653	CurrentSource = L;
29654	return IncBitfield<PT_Bool>(S, CodePtr(), A0, A1);
29655	}
29656	bool EvalEmitter::emitIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
29657	if (!isActive()) return true;
29658	CurrentSource = L;
29659	return IncBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
29660	}
29661	#endif
29662	#ifdef GET_OPCODE_NAMES
29663	OP_IncPopSint8,
29664	OP_IncPopUint8,
29665	OP_IncPopSint16,
29666	OP_IncPopUint16,
29667	OP_IncPopSint32,
29668	OP_IncPopUint32,
29669	OP_IncPopSint64,
29670	OP_IncPopUint64,
29671	OP_IncPopIntAP,
29672	OP_IncPopIntAPS,
29673	OP_IncPopBool,
29674	OP_IncPopFixedPoint,
29675	#endif
29676	#ifdef GET_INTERPFN_LIST
29677	&Interp_IncPopSint8,
29678	&Interp_IncPopUint8,
29679	&Interp_IncPopSint16,
29680	&Interp_IncPopUint16,
29681	&Interp_IncPopSint32,
29682	&Interp_IncPopUint32,
29683	&Interp_IncPopSint64,
29684	&Interp_IncPopUint64,
29685	&Interp_IncPopIntAP,
29686	&Interp_IncPopIntAPS,
29687	&Interp_IncPopBool,
29688	&Interp_IncPopFixedPoint,
29689	#endif
29690	#ifdef GET_INTERPFN_DISPATCHERS
29691	PRESERVE_NONE
29692	static bool Interp_IncPopSint8(InterpState &S) {
29693	{
29694	CodePtr OpPC = S.PC;
29695	const auto V0 = ReadArg<bool>(S, S.PC);
29696	if (!IncPop<PT_Sint8>(S, OpPC, V0)) return false;
29697	}
29698	#if USE_TAILCALLS
29699	MUSTTAIL return InterpNext(S);
29700	#else
29701	return true;
29702	#endif
29703	}
29704	PRESERVE_NONE
29705	static bool Interp_IncPopUint8(InterpState &S) {
29706	{
29707	CodePtr OpPC = S.PC;
29708	const auto V0 = ReadArg<bool>(S, S.PC);
29709	if (!IncPop<PT_Uint8>(S, OpPC, V0)) return false;
29710	}
29711	#if USE_TAILCALLS
29712	MUSTTAIL return InterpNext(S);
29713	#else
29714	return true;
29715	#endif
29716	}
29717	PRESERVE_NONE
29718	static bool Interp_IncPopSint16(InterpState &S) {
29719	{
29720	CodePtr OpPC = S.PC;
29721	const auto V0 = ReadArg<bool>(S, S.PC);
29722	if (!IncPop<PT_Sint16>(S, OpPC, V0)) return false;
29723	}
29724	#if USE_TAILCALLS
29725	MUSTTAIL return InterpNext(S);
29726	#else
29727	return true;
29728	#endif
29729	}
29730	PRESERVE_NONE
29731	static bool Interp_IncPopUint16(InterpState &S) {
29732	{
29733	CodePtr OpPC = S.PC;
29734	const auto V0 = ReadArg<bool>(S, S.PC);
29735	if (!IncPop<PT_Uint16>(S, OpPC, V0)) return false;
29736	}
29737	#if USE_TAILCALLS
29738	MUSTTAIL return InterpNext(S);
29739	#else
29740	return true;
29741	#endif
29742	}
29743	PRESERVE_NONE
29744	static bool Interp_IncPopSint32(InterpState &S) {
29745	{
29746	CodePtr OpPC = S.PC;
29747	const auto V0 = ReadArg<bool>(S, S.PC);
29748	if (!IncPop<PT_Sint32>(S, OpPC, V0)) return false;
29749	}
29750	#if USE_TAILCALLS
29751	MUSTTAIL return InterpNext(S);
29752	#else
29753	return true;
29754	#endif
29755	}
29756	PRESERVE_NONE
29757	static bool Interp_IncPopUint32(InterpState &S) {
29758	{
29759	CodePtr OpPC = S.PC;
29760	const auto V0 = ReadArg<bool>(S, S.PC);
29761	if (!IncPop<PT_Uint32>(S, OpPC, V0)) return false;
29762	}
29763	#if USE_TAILCALLS
29764	MUSTTAIL return InterpNext(S);
29765	#else
29766	return true;
29767	#endif
29768	}
29769	PRESERVE_NONE
29770	static bool Interp_IncPopSint64(InterpState &S) {
29771	{
29772	CodePtr OpPC = S.PC;
29773	const auto V0 = ReadArg<bool>(S, S.PC);
29774	if (!IncPop<PT_Sint64>(S, OpPC, V0)) return false;
29775	}
29776	#if USE_TAILCALLS
29777	MUSTTAIL return InterpNext(S);
29778	#else
29779	return true;
29780	#endif
29781	}
29782	PRESERVE_NONE
29783	static bool Interp_IncPopUint64(InterpState &S) {
29784	{
29785	CodePtr OpPC = S.PC;
29786	const auto V0 = ReadArg<bool>(S, S.PC);
29787	if (!IncPop<PT_Uint64>(S, OpPC, V0)) return false;
29788	}
29789	#if USE_TAILCALLS
29790	MUSTTAIL return InterpNext(S);
29791	#else
29792	return true;
29793	#endif
29794	}
29795	PRESERVE_NONE
29796	static bool Interp_IncPopIntAP(InterpState &S) {
29797	{
29798	CodePtr OpPC = S.PC;
29799	const auto V0 = ReadArg<bool>(S, S.PC);
29800	if (!IncPop<PT_IntAP>(S, OpPC, V0)) return false;
29801	}
29802	#if USE_TAILCALLS
29803	MUSTTAIL return InterpNext(S);
29804	#else
29805	return true;
29806	#endif
29807	}
29808	PRESERVE_NONE
29809	static bool Interp_IncPopIntAPS(InterpState &S) {
29810	{
29811	CodePtr OpPC = S.PC;
29812	const auto V0 = ReadArg<bool>(S, S.PC);
29813	if (!IncPop<PT_IntAPS>(S, OpPC, V0)) return false;
29814	}
29815	#if USE_TAILCALLS
29816	MUSTTAIL return InterpNext(S);
29817	#else
29818	return true;
29819	#endif
29820	}
29821	PRESERVE_NONE
29822	static bool Interp_IncPopBool(InterpState &S) {
29823	{
29824	CodePtr OpPC = S.PC;
29825	const auto V0 = ReadArg<bool>(S, S.PC);
29826	if (!IncPop<PT_Bool>(S, OpPC, V0)) return false;
29827	}
29828	#if USE_TAILCALLS
29829	MUSTTAIL return InterpNext(S);
29830	#else
29831	return true;
29832	#endif
29833	}
29834	PRESERVE_NONE
29835	static bool Interp_IncPopFixedPoint(InterpState &S) {
29836	{
29837	CodePtr OpPC = S.PC;
29838	const auto V0 = ReadArg<bool>(S, S.PC);
29839	if (!IncPop<PT_FixedPoint>(S, OpPC, V0)) return false;
29840	}
29841	#if USE_TAILCALLS
29842	MUSTTAIL return InterpNext(S);
29843	#else
29844	return true;
29845	#endif
29846	}
29847	#endif
29848	#ifdef GET_DISASM
29849	case OP_IncPopSint8:
29850	Text.Op = PrintName("IncPopSint8");
29851	Text.Args.push_back(printArg<bool>(P, PC));
29852	break;
29853	case OP_IncPopUint8:
29854	Text.Op = PrintName("IncPopUint8");
29855	Text.Args.push_back(printArg<bool>(P, PC));
29856	break;
29857	case OP_IncPopSint16:
29858	Text.Op = PrintName("IncPopSint16");
29859	Text.Args.push_back(printArg<bool>(P, PC));
29860	break;
29861	case OP_IncPopUint16:
29862	Text.Op = PrintName("IncPopUint16");
29863	Text.Args.push_back(printArg<bool>(P, PC));
29864	break;
29865	case OP_IncPopSint32:
29866	Text.Op = PrintName("IncPopSint32");
29867	Text.Args.push_back(printArg<bool>(P, PC));
29868	break;
29869	case OP_IncPopUint32:
29870	Text.Op = PrintName("IncPopUint32");
29871	Text.Args.push_back(printArg<bool>(P, PC));
29872	break;
29873	case OP_IncPopSint64:
29874	Text.Op = PrintName("IncPopSint64");
29875	Text.Args.push_back(printArg<bool>(P, PC));
29876	break;
29877	case OP_IncPopUint64:
29878	Text.Op = PrintName("IncPopUint64");
29879	Text.Args.push_back(printArg<bool>(P, PC));
29880	break;
29881	case OP_IncPopIntAP:
29882	Text.Op = PrintName("IncPopIntAP");
29883	Text.Args.push_back(printArg<bool>(P, PC));
29884	break;
29885	case OP_IncPopIntAPS:
29886	Text.Op = PrintName("IncPopIntAPS");
29887	Text.Args.push_back(printArg<bool>(P, PC));
29888	break;
29889	case OP_IncPopBool:
29890	Text.Op = PrintName("IncPopBool");
29891	Text.Args.push_back(printArg<bool>(P, PC));
29892	break;
29893	case OP_IncPopFixedPoint:
29894	Text.Op = PrintName("IncPopFixedPoint");
29895	Text.Args.push_back(printArg<bool>(P, PC));
29896	break;
29897	#endif
29898	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29899	bool emitIncPopSint8( bool , SourceInfo);
29900	bool emitIncPopUint8( bool , SourceInfo);
29901	bool emitIncPopSint16( bool , SourceInfo);
29902	bool emitIncPopUint16( bool , SourceInfo);
29903	bool emitIncPopSint32( bool , SourceInfo);
29904	bool emitIncPopUint32( bool , SourceInfo);
29905	bool emitIncPopSint64( bool , SourceInfo);
29906	bool emitIncPopUint64( bool , SourceInfo);
29907	bool emitIncPopIntAP( bool , SourceInfo);
29908	bool emitIncPopIntAPS( bool , SourceInfo);
29909	bool emitIncPopBool( bool , SourceInfo);
29910	bool emitIncPopFixedPoint( bool , SourceInfo);
29911	#endif
29912	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
29913	[[nodiscard]] bool emitIncPop(PrimType, bool, SourceInfo I);
29914	#endif
29915	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
29916	bool
29917	#if defined(GET_EVAL_IMPL)
29918	EvalEmitter
29919	#else
29920	ByteCodeEmitter
29921	#endif
29922	::emitIncPop(PrimType T0, bool A0, SourceInfo I) {
29923	switch (T0) {
29924	case PT_Sint8:
29925	return emitIncPopSint8(A0, I);
29926	case PT_Uint8:
29927	return emitIncPopUint8(A0, I);
29928	case PT_Sint16:
29929	return emitIncPopSint16(A0, I);
29930	case PT_Uint16:
29931	return emitIncPopUint16(A0, I);
29932	case PT_Sint32:
29933	return emitIncPopSint32(A0, I);
29934	case PT_Uint32:
29935	return emitIncPopUint32(A0, I);
29936	case PT_Sint64:
29937	return emitIncPopSint64(A0, I);
29938	case PT_Uint64:
29939	return emitIncPopUint64(A0, I);
29940	case PT_IntAP:
29941	return emitIncPopIntAP(A0, I);
29942	case PT_IntAPS:
29943	return emitIncPopIntAPS(A0, I);
29944	case PT_Bool:
29945	return emitIncPopBool(A0, I);
29946	case PT_FixedPoint:
29947	return emitIncPopFixedPoint(A0, I);
29948	default: llvm_unreachable("invalid type: emitIncPop");
29949	}
29950	llvm_unreachable("invalid enum value");
29951	}
29952	#endif
29953	#ifdef GET_LINK_IMPL
29954	bool ByteCodeEmitter::emitIncPopSint8( bool A0, SourceInfo L) {
29955	return emitOp<bool>(OP_IncPopSint8, A0, L);
29956	}
29957	bool ByteCodeEmitter::emitIncPopUint8( bool A0, SourceInfo L) {
29958	return emitOp<bool>(OP_IncPopUint8, A0, L);
29959	}
29960	bool ByteCodeEmitter::emitIncPopSint16( bool A0, SourceInfo L) {
29961	return emitOp<bool>(OP_IncPopSint16, A0, L);
29962	}
29963	bool ByteCodeEmitter::emitIncPopUint16( bool A0, SourceInfo L) {
29964	return emitOp<bool>(OP_IncPopUint16, A0, L);
29965	}
29966	bool ByteCodeEmitter::emitIncPopSint32( bool A0, SourceInfo L) {
29967	return emitOp<bool>(OP_IncPopSint32, A0, L);
29968	}
29969	bool ByteCodeEmitter::emitIncPopUint32( bool A0, SourceInfo L) {
29970	return emitOp<bool>(OP_IncPopUint32, A0, L);
29971	}
29972	bool ByteCodeEmitter::emitIncPopSint64( bool A0, SourceInfo L) {
29973	return emitOp<bool>(OP_IncPopSint64, A0, L);
29974	}
29975	bool ByteCodeEmitter::emitIncPopUint64( bool A0, SourceInfo L) {
29976	return emitOp<bool>(OP_IncPopUint64, A0, L);
29977	}
29978	bool ByteCodeEmitter::emitIncPopIntAP( bool A0, SourceInfo L) {
29979	return emitOp<bool>(OP_IncPopIntAP, A0, L);
29980	}
29981	bool ByteCodeEmitter::emitIncPopIntAPS( bool A0, SourceInfo L) {
29982	return emitOp<bool>(OP_IncPopIntAPS, A0, L);
29983	}
29984	bool ByteCodeEmitter::emitIncPopBool( bool A0, SourceInfo L) {
29985	return emitOp<bool>(OP_IncPopBool, A0, L);
29986	}
29987	bool ByteCodeEmitter::emitIncPopFixedPoint( bool A0, SourceInfo L) {
29988	return emitOp<bool>(OP_IncPopFixedPoint, A0, L);
29989	}
29990	#endif
29991	#ifdef GET_EVAL_IMPL
29992	bool EvalEmitter::emitIncPopSint8( bool A0, SourceInfo L) {
29993	if (!isActive()) return true;
29994	CurrentSource = L;
29995	return IncPop<PT_Sint8>(S, CodePtr(), A0);
29996	}
29997	bool EvalEmitter::emitIncPopUint8( bool A0, SourceInfo L) {
29998	if (!isActive()) return true;
29999	CurrentSource = L;
30000	return IncPop<PT_Uint8>(S, CodePtr(), A0);
30001	}
30002	bool EvalEmitter::emitIncPopSint16( bool A0, SourceInfo L) {
30003	if (!isActive()) return true;
30004	CurrentSource = L;
30005	return IncPop<PT_Sint16>(S, CodePtr(), A0);
30006	}
30007	bool EvalEmitter::emitIncPopUint16( bool A0, SourceInfo L) {
30008	if (!isActive()) return true;
30009	CurrentSource = L;
30010	return IncPop<PT_Uint16>(S, CodePtr(), A0);
30011	}
30012	bool EvalEmitter::emitIncPopSint32( bool A0, SourceInfo L) {
30013	if (!isActive()) return true;
30014	CurrentSource = L;
30015	return IncPop<PT_Sint32>(S, CodePtr(), A0);
30016	}
30017	bool EvalEmitter::emitIncPopUint32( bool A0, SourceInfo L) {
30018	if (!isActive()) return true;
30019	CurrentSource = L;
30020	return IncPop<PT_Uint32>(S, CodePtr(), A0);
30021	}
30022	bool EvalEmitter::emitIncPopSint64( bool A0, SourceInfo L) {
30023	if (!isActive()) return true;
30024	CurrentSource = L;
30025	return IncPop<PT_Sint64>(S, CodePtr(), A0);
30026	}
30027	bool EvalEmitter::emitIncPopUint64( bool A0, SourceInfo L) {
30028	if (!isActive()) return true;
30029	CurrentSource = L;
30030	return IncPop<PT_Uint64>(S, CodePtr(), A0);
30031	}
30032	bool EvalEmitter::emitIncPopIntAP( bool A0, SourceInfo L) {
30033	if (!isActive()) return true;
30034	CurrentSource = L;
30035	return IncPop<PT_IntAP>(S, CodePtr(), A0);
30036	}
30037	bool EvalEmitter::emitIncPopIntAPS( bool A0, SourceInfo L) {
30038	if (!isActive()) return true;
30039	CurrentSource = L;
30040	return IncPop<PT_IntAPS>(S, CodePtr(), A0);
30041	}
30042	bool EvalEmitter::emitIncPopBool( bool A0, SourceInfo L) {
30043	if (!isActive()) return true;
30044	CurrentSource = L;
30045	return IncPop<PT_Bool>(S, CodePtr(), A0);
30046	}
30047	bool EvalEmitter::emitIncPopFixedPoint( bool A0, SourceInfo L) {
30048	if (!isActive()) return true;
30049	CurrentSource = L;
30050	return IncPop<PT_FixedPoint>(S, CodePtr(), A0);
30051	}
30052	#endif
30053	#ifdef GET_OPCODE_NAMES
30054	OP_IncPopBitfieldSint8,
30055	OP_IncPopBitfieldUint8,
30056	OP_IncPopBitfieldSint16,
30057	OP_IncPopBitfieldUint16,
30058	OP_IncPopBitfieldSint32,
30059	OP_IncPopBitfieldUint32,
30060	OP_IncPopBitfieldSint64,
30061	OP_IncPopBitfieldUint64,
30062	OP_IncPopBitfieldIntAP,
30063	OP_IncPopBitfieldIntAPS,
30064	OP_IncPopBitfieldBool,
30065	OP_IncPopBitfieldFixedPoint,
30066	#endif
30067	#ifdef GET_INTERPFN_LIST
30068	&Interp_IncPopBitfieldSint8,
30069	&Interp_IncPopBitfieldUint8,
30070	&Interp_IncPopBitfieldSint16,
30071	&Interp_IncPopBitfieldUint16,
30072	&Interp_IncPopBitfieldSint32,
30073	&Interp_IncPopBitfieldUint32,
30074	&Interp_IncPopBitfieldSint64,
30075	&Interp_IncPopBitfieldUint64,
30076	&Interp_IncPopBitfieldIntAP,
30077	&Interp_IncPopBitfieldIntAPS,
30078	&Interp_IncPopBitfieldBool,
30079	&Interp_IncPopBitfieldFixedPoint,
30080	#endif
30081	#ifdef GET_INTERPFN_DISPATCHERS
30082	PRESERVE_NONE
30083	static bool Interp_IncPopBitfieldSint8(InterpState &S) {
30084	{
30085	CodePtr OpPC = S.PC;
30086	const auto V0 = ReadArg<bool>(S, S.PC);
30087	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30088	if (!IncPopBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
30089	}
30090	#if USE_TAILCALLS
30091	MUSTTAIL return InterpNext(S);
30092	#else
30093	return true;
30094	#endif
30095	}
30096	PRESERVE_NONE
30097	static bool Interp_IncPopBitfieldUint8(InterpState &S) {
30098	{
30099	CodePtr OpPC = S.PC;
30100	const auto V0 = ReadArg<bool>(S, S.PC);
30101	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30102	if (!IncPopBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
30103	}
30104	#if USE_TAILCALLS
30105	MUSTTAIL return InterpNext(S);
30106	#else
30107	return true;
30108	#endif
30109	}
30110	PRESERVE_NONE
30111	static bool Interp_IncPopBitfieldSint16(InterpState &S) {
30112	{
30113	CodePtr OpPC = S.PC;
30114	const auto V0 = ReadArg<bool>(S, S.PC);
30115	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30116	if (!IncPopBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
30117	}
30118	#if USE_TAILCALLS
30119	MUSTTAIL return InterpNext(S);
30120	#else
30121	return true;
30122	#endif
30123	}
30124	PRESERVE_NONE
30125	static bool Interp_IncPopBitfieldUint16(InterpState &S) {
30126	{
30127	CodePtr OpPC = S.PC;
30128	const auto V0 = ReadArg<bool>(S, S.PC);
30129	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30130	if (!IncPopBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
30131	}
30132	#if USE_TAILCALLS
30133	MUSTTAIL return InterpNext(S);
30134	#else
30135	return true;
30136	#endif
30137	}
30138	PRESERVE_NONE
30139	static bool Interp_IncPopBitfieldSint32(InterpState &S) {
30140	{
30141	CodePtr OpPC = S.PC;
30142	const auto V0 = ReadArg<bool>(S, S.PC);
30143	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30144	if (!IncPopBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
30145	}
30146	#if USE_TAILCALLS
30147	MUSTTAIL return InterpNext(S);
30148	#else
30149	return true;
30150	#endif
30151	}
30152	PRESERVE_NONE
30153	static bool Interp_IncPopBitfieldUint32(InterpState &S) {
30154	{
30155	CodePtr OpPC = S.PC;
30156	const auto V0 = ReadArg<bool>(S, S.PC);
30157	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30158	if (!IncPopBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
30159	}
30160	#if USE_TAILCALLS
30161	MUSTTAIL return InterpNext(S);
30162	#else
30163	return true;
30164	#endif
30165	}
30166	PRESERVE_NONE
30167	static bool Interp_IncPopBitfieldSint64(InterpState &S) {
30168	{
30169	CodePtr OpPC = S.PC;
30170	const auto V0 = ReadArg<bool>(S, S.PC);
30171	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30172	if (!IncPopBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
30173	}
30174	#if USE_TAILCALLS
30175	MUSTTAIL return InterpNext(S);
30176	#else
30177	return true;
30178	#endif
30179	}
30180	PRESERVE_NONE
30181	static bool Interp_IncPopBitfieldUint64(InterpState &S) {
30182	{
30183	CodePtr OpPC = S.PC;
30184	const auto V0 = ReadArg<bool>(S, S.PC);
30185	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30186	if (!IncPopBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
30187	}
30188	#if USE_TAILCALLS
30189	MUSTTAIL return InterpNext(S);
30190	#else
30191	return true;
30192	#endif
30193	}
30194	PRESERVE_NONE
30195	static bool Interp_IncPopBitfieldIntAP(InterpState &S) {
30196	{
30197	CodePtr OpPC = S.PC;
30198	const auto V0 = ReadArg<bool>(S, S.PC);
30199	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30200	if (!IncPopBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
30201	}
30202	#if USE_TAILCALLS
30203	MUSTTAIL return InterpNext(S);
30204	#else
30205	return true;
30206	#endif
30207	}
30208	PRESERVE_NONE
30209	static bool Interp_IncPopBitfieldIntAPS(InterpState &S) {
30210	{
30211	CodePtr OpPC = S.PC;
30212	const auto V0 = ReadArg<bool>(S, S.PC);
30213	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30214	if (!IncPopBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
30215	}
30216	#if USE_TAILCALLS
30217	MUSTTAIL return InterpNext(S);
30218	#else
30219	return true;
30220	#endif
30221	}
30222	PRESERVE_NONE
30223	static bool Interp_IncPopBitfieldBool(InterpState &S) {
30224	{
30225	CodePtr OpPC = S.PC;
30226	const auto V0 = ReadArg<bool>(S, S.PC);
30227	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30228	if (!IncPopBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
30229	}
30230	#if USE_TAILCALLS
30231	MUSTTAIL return InterpNext(S);
30232	#else
30233	return true;
30234	#endif
30235	}
30236	PRESERVE_NONE
30237	static bool Interp_IncPopBitfieldFixedPoint(InterpState &S) {
30238	{
30239	CodePtr OpPC = S.PC;
30240	const auto V0 = ReadArg<bool>(S, S.PC);
30241	const auto V1 = ReadArg<uint32_t>(S, S.PC);
30242	if (!IncPopBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
30243	}
30244	#if USE_TAILCALLS
30245	MUSTTAIL return InterpNext(S);
30246	#else
30247	return true;
30248	#endif
30249	}
30250	#endif
30251	#ifdef GET_DISASM
30252	case OP_IncPopBitfieldSint8:
30253	Text.Op = PrintName("IncPopBitfieldSint8");
30254	Text.Args.push_back(printArg<bool>(P, PC));
30255	Text.Args.push_back(printArg<uint32_t>(P, PC));
30256	break;
30257	case OP_IncPopBitfieldUint8:
30258	Text.Op = PrintName("IncPopBitfieldUint8");
30259	Text.Args.push_back(printArg<bool>(P, PC));
30260	Text.Args.push_back(printArg<uint32_t>(P, PC));
30261	break;
30262	case OP_IncPopBitfieldSint16:
30263	Text.Op = PrintName("IncPopBitfieldSint16");
30264	Text.Args.push_back(printArg<bool>(P, PC));
30265	Text.Args.push_back(printArg<uint32_t>(P, PC));
30266	break;
30267	case OP_IncPopBitfieldUint16:
30268	Text.Op = PrintName("IncPopBitfieldUint16");
30269	Text.Args.push_back(printArg<bool>(P, PC));
30270	Text.Args.push_back(printArg<uint32_t>(P, PC));
30271	break;
30272	case OP_IncPopBitfieldSint32:
30273	Text.Op = PrintName("IncPopBitfieldSint32");
30274	Text.Args.push_back(printArg<bool>(P, PC));
30275	Text.Args.push_back(printArg<uint32_t>(P, PC));
30276	break;
30277	case OP_IncPopBitfieldUint32:
30278	Text.Op = PrintName("IncPopBitfieldUint32");
30279	Text.Args.push_back(printArg<bool>(P, PC));
30280	Text.Args.push_back(printArg<uint32_t>(P, PC));
30281	break;
30282	case OP_IncPopBitfieldSint64:
30283	Text.Op = PrintName("IncPopBitfieldSint64");
30284	Text.Args.push_back(printArg<bool>(P, PC));
30285	Text.Args.push_back(printArg<uint32_t>(P, PC));
30286	break;
30287	case OP_IncPopBitfieldUint64:
30288	Text.Op = PrintName("IncPopBitfieldUint64");
30289	Text.Args.push_back(printArg<bool>(P, PC));
30290	Text.Args.push_back(printArg<uint32_t>(P, PC));
30291	break;
30292	case OP_IncPopBitfieldIntAP:
30293	Text.Op = PrintName("IncPopBitfieldIntAP");
30294	Text.Args.push_back(printArg<bool>(P, PC));
30295	Text.Args.push_back(printArg<uint32_t>(P, PC));
30296	break;
30297	case OP_IncPopBitfieldIntAPS:
30298	Text.Op = PrintName("IncPopBitfieldIntAPS");
30299	Text.Args.push_back(printArg<bool>(P, PC));
30300	Text.Args.push_back(printArg<uint32_t>(P, PC));
30301	break;
30302	case OP_IncPopBitfieldBool:
30303	Text.Op = PrintName("IncPopBitfieldBool");
30304	Text.Args.push_back(printArg<bool>(P, PC));
30305	Text.Args.push_back(printArg<uint32_t>(P, PC));
30306	break;
30307	case OP_IncPopBitfieldFixedPoint:
30308	Text.Op = PrintName("IncPopBitfieldFixedPoint");
30309	Text.Args.push_back(printArg<bool>(P, PC));
30310	Text.Args.push_back(printArg<uint32_t>(P, PC));
30311	break;
30312	#endif
30313	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30314	bool emitIncPopBitfieldSint8( bool , uint32_t , SourceInfo);
30315	bool emitIncPopBitfieldUint8( bool , uint32_t , SourceInfo);
30316	bool emitIncPopBitfieldSint16( bool , uint32_t , SourceInfo);
30317	bool emitIncPopBitfieldUint16( bool , uint32_t , SourceInfo);
30318	bool emitIncPopBitfieldSint32( bool , uint32_t , SourceInfo);
30319	bool emitIncPopBitfieldUint32( bool , uint32_t , SourceInfo);
30320	bool emitIncPopBitfieldSint64( bool , uint32_t , SourceInfo);
30321	bool emitIncPopBitfieldUint64( bool , uint32_t , SourceInfo);
30322	bool emitIncPopBitfieldIntAP( bool , uint32_t , SourceInfo);
30323	bool emitIncPopBitfieldIntAPS( bool , uint32_t , SourceInfo);
30324	bool emitIncPopBitfieldBool( bool , uint32_t , SourceInfo);
30325	bool emitIncPopBitfieldFixedPoint( bool , uint32_t , SourceInfo);
30326	#endif
30327	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30328	[[nodiscard]] bool emitIncPopBitfield(PrimType, bool, uint32_t, SourceInfo I);
30329	#endif
30330	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
30331	bool
30332	#if defined(GET_EVAL_IMPL)
30333	EvalEmitter
30334	#else
30335	ByteCodeEmitter
30336	#endif
30337	::emitIncPopBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
30338	switch (T0) {
30339	case PT_Sint8:
30340	return emitIncPopBitfieldSint8(A0, A1, I);
30341	case PT_Uint8:
30342	return emitIncPopBitfieldUint8(A0, A1, I);
30343	case PT_Sint16:
30344	return emitIncPopBitfieldSint16(A0, A1, I);
30345	case PT_Uint16:
30346	return emitIncPopBitfieldUint16(A0, A1, I);
30347	case PT_Sint32:
30348	return emitIncPopBitfieldSint32(A0, A1, I);
30349	case PT_Uint32:
30350	return emitIncPopBitfieldUint32(A0, A1, I);
30351	case PT_Sint64:
30352	return emitIncPopBitfieldSint64(A0, A1, I);
30353	case PT_Uint64:
30354	return emitIncPopBitfieldUint64(A0, A1, I);
30355	case PT_IntAP:
30356	return emitIncPopBitfieldIntAP(A0, A1, I);
30357	case PT_IntAPS:
30358	return emitIncPopBitfieldIntAPS(A0, A1, I);
30359	case PT_Bool:
30360	return emitIncPopBitfieldBool(A0, A1, I);
30361	case PT_FixedPoint:
30362	return emitIncPopBitfieldFixedPoint(A0, A1, I);
30363	default: llvm_unreachable("invalid type: emitIncPopBitfield");
30364	}
30365	llvm_unreachable("invalid enum value");
30366	}
30367	#endif
30368	#ifdef GET_LINK_IMPL
30369	bool ByteCodeEmitter::emitIncPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
30370	return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint8, A0, A1, L);
30371	}
30372	bool ByteCodeEmitter::emitIncPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
30373	return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint8, A0, A1, L);
30374	}
30375	bool ByteCodeEmitter::emitIncPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
30376	return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint16, A0, A1, L);
30377	}
30378	bool ByteCodeEmitter::emitIncPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
30379	return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint16, A0, A1, L);
30380	}
30381	bool ByteCodeEmitter::emitIncPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
30382	return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint32, A0, A1, L);
30383	}
30384	bool ByteCodeEmitter::emitIncPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
30385	return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint32, A0, A1, L);
30386	}
30387	bool ByteCodeEmitter::emitIncPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
30388	return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint64, A0, A1, L);
30389	}
30390	bool ByteCodeEmitter::emitIncPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
30391	return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint64, A0, A1, L);
30392	}
30393	bool ByteCodeEmitter::emitIncPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
30394	return emitOp<bool, uint32_t>(OP_IncPopBitfieldIntAP, A0, A1, L);
30395	}
30396	bool ByteCodeEmitter::emitIncPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
30397	return emitOp<bool, uint32_t>(OP_IncPopBitfieldIntAPS, A0, A1, L);
30398	}
30399	bool ByteCodeEmitter::emitIncPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
30400	return emitOp<bool, uint32_t>(OP_IncPopBitfieldBool, A0, A1, L);
30401	}
30402	bool ByteCodeEmitter::emitIncPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
30403	return emitOp<bool, uint32_t>(OP_IncPopBitfieldFixedPoint, A0, A1, L);
30404	}
30405	#endif
30406	#ifdef GET_EVAL_IMPL
30407	bool EvalEmitter::emitIncPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
30408	if (!isActive()) return true;
30409	CurrentSource = L;
30410	return IncPopBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
30411	}
30412	bool EvalEmitter::emitIncPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
30413	if (!isActive()) return true;
30414	CurrentSource = L;
30415	return IncPopBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
30416	}
30417	bool EvalEmitter::emitIncPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
30418	if (!isActive()) return true;
30419	CurrentSource = L;
30420	return IncPopBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
30421	}
30422	bool EvalEmitter::emitIncPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
30423	if (!isActive()) return true;
30424	CurrentSource = L;
30425	return IncPopBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
30426	}
30427	bool EvalEmitter::emitIncPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
30428	if (!isActive()) return true;
30429	CurrentSource = L;
30430	return IncPopBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
30431	}
30432	bool EvalEmitter::emitIncPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
30433	if (!isActive()) return true;
30434	CurrentSource = L;
30435	return IncPopBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
30436	}
30437	bool EvalEmitter::emitIncPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
30438	if (!isActive()) return true;
30439	CurrentSource = L;
30440	return IncPopBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
30441	}
30442	bool EvalEmitter::emitIncPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
30443	if (!isActive()) return true;
30444	CurrentSource = L;
30445	return IncPopBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
30446	}
30447	bool EvalEmitter::emitIncPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
30448	if (!isActive()) return true;
30449	CurrentSource = L;
30450	return IncPopBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
30451	}
30452	bool EvalEmitter::emitIncPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
30453	if (!isActive()) return true;
30454	CurrentSource = L;
30455	return IncPopBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
30456	}
30457	bool EvalEmitter::emitIncPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
30458	if (!isActive()) return true;
30459	CurrentSource = L;
30460	return IncPopBitfield<PT_Bool>(S, CodePtr(), A0, A1);
30461	}
30462	bool EvalEmitter::emitIncPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
30463	if (!isActive()) return true;
30464	CurrentSource = L;
30465	return IncPopBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
30466	}
30467	#endif
30468	#ifdef GET_OPCODE_NAMES
30469	OP_IncPtr,
30470	#endif
30471	#ifdef GET_INTERPFN_LIST
30472	&Interp_IncPtr,
30473	#endif
30474	#ifdef GET_INTERPFN_DISPATCHERS
30475	PRESERVE_NONE
30476	static bool Interp_IncPtr(InterpState &S) {
30477	if (!IncPtr(S, S.PC)) return false;
30478	#if USE_TAILCALLS
30479	MUSTTAIL return InterpNext(S);
30480	#else
30481	return true;
30482	#endif
30483	}
30484	#endif
30485	#ifdef GET_DISASM
30486	case OP_IncPtr:
30487	Text.Op = PrintName("IncPtr");
30488	break;
30489	#endif
30490	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30491	bool emitIncPtr(SourceInfo);
30492	#endif
30493	#ifdef GET_LINK_IMPL
30494	bool ByteCodeEmitter::emitIncPtr(SourceInfo L) {
30495	return emitOp<>(OP_IncPtr, L);
30496	}
30497	#endif
30498	#ifdef GET_EVAL_IMPL
30499	bool EvalEmitter::emitIncPtr(SourceInfo L) {
30500	if (!isActive()) return true;
30501	CurrentSource = L;
30502	return IncPtr(S, CodePtr());
30503	}
30504	#endif
30505	#ifdef GET_OPCODE_NAMES
30506	OP_Incf,
30507	#endif
30508	#ifdef GET_INTERPFN_LIST
30509	&Interp_Incf,
30510	#endif
30511	#ifdef GET_INTERPFN_DISPATCHERS
30512	PRESERVE_NONE
30513	static bool Interp_Incf(InterpState &S) {
30514	{
30515	CodePtr OpPC = S.PC;
30516	const auto V0 = ReadArg<uint32_t>(S, S.PC);
30517	if (!Incf(S, OpPC, V0)) return false;
30518	}
30519	#if USE_TAILCALLS
30520	MUSTTAIL return InterpNext(S);
30521	#else
30522	return true;
30523	#endif
30524	}
30525	#endif
30526	#ifdef GET_DISASM
30527	case OP_Incf:
30528	Text.Op = PrintName("Incf");
30529	Text.Args.push_back(printArg<uint32_t>(P, PC));
30530	break;
30531	#endif
30532	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30533	bool emitIncf( uint32_t , SourceInfo);
30534	#endif
30535	#ifdef GET_LINK_IMPL
30536	bool ByteCodeEmitter::emitIncf( uint32_t A0, SourceInfo L) {
30537	return emitOp<uint32_t>(OP_Incf, A0, L);
30538	}
30539	#endif
30540	#ifdef GET_EVAL_IMPL
30541	bool EvalEmitter::emitIncf( uint32_t A0, SourceInfo L) {
30542	if (!isActive()) return true;
30543	CurrentSource = L;
30544	return Incf(S, CodePtr(), A0);
30545	}
30546	#endif
30547	#ifdef GET_OPCODE_NAMES
30548	OP_IncfPop,
30549	#endif
30550	#ifdef GET_INTERPFN_LIST
30551	&Interp_IncfPop,
30552	#endif
30553	#ifdef GET_INTERPFN_DISPATCHERS
30554	PRESERVE_NONE
30555	static bool Interp_IncfPop(InterpState &S) {
30556	{
30557	CodePtr OpPC = S.PC;
30558	const auto V0 = ReadArg<uint32_t>(S, S.PC);
30559	if (!IncfPop(S, OpPC, V0)) return false;
30560	}
30561	#if USE_TAILCALLS
30562	MUSTTAIL return InterpNext(S);
30563	#else
30564	return true;
30565	#endif
30566	}
30567	#endif
30568	#ifdef GET_DISASM
30569	case OP_IncfPop:
30570	Text.Op = PrintName("IncfPop");
30571	Text.Args.push_back(printArg<uint32_t>(P, PC));
30572	break;
30573	#endif
30574	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30575	bool emitIncfPop( uint32_t , SourceInfo);
30576	#endif
30577	#ifdef GET_LINK_IMPL
30578	bool ByteCodeEmitter::emitIncfPop( uint32_t A0, SourceInfo L) {
30579	return emitOp<uint32_t>(OP_IncfPop, A0, L);
30580	}
30581	#endif
30582	#ifdef GET_EVAL_IMPL
30583	bool EvalEmitter::emitIncfPop( uint32_t A0, SourceInfo L) {
30584	if (!isActive()) return true;
30585	CurrentSource = L;
30586	return IncfPop(S, CodePtr(), A0);
30587	}
30588	#endif
30589	#ifdef GET_OPCODE_NAMES
30590	OP_InitSint8,
30591	OP_InitUint8,
30592	OP_InitSint16,
30593	OP_InitUint16,
30594	OP_InitSint32,
30595	OP_InitUint32,
30596	OP_InitSint64,
30597	OP_InitUint64,
30598	OP_InitIntAP,
30599	OP_InitIntAPS,
30600	OP_InitBool,
30601	OP_InitFixedPoint,
30602	OP_InitPtr,
30603	OP_InitMemberPtr,
30604	OP_InitFloat,
30605	#endif
30606	#ifdef GET_INTERPFN_LIST
30607	&Interp_InitSint8,
30608	&Interp_InitUint8,
30609	&Interp_InitSint16,
30610	&Interp_InitUint16,
30611	&Interp_InitSint32,
30612	&Interp_InitUint32,
30613	&Interp_InitSint64,
30614	&Interp_InitUint64,
30615	&Interp_InitIntAP,
30616	&Interp_InitIntAPS,
30617	&Interp_InitBool,
30618	&Interp_InitFixedPoint,
30619	&Interp_InitPtr,
30620	&Interp_InitMemberPtr,
30621	&Interp_InitFloat,
30622	#endif
30623	#ifdef GET_INTERPFN_DISPATCHERS
30624	PRESERVE_NONE
30625	static bool Interp_InitSint8(InterpState &S) {
30626	if (!Init<PT_Sint8>(S, S.PC)) return false;
30627	#if USE_TAILCALLS
30628	MUSTTAIL return InterpNext(S);
30629	#else
30630	return true;
30631	#endif
30632	}
30633	PRESERVE_NONE
30634	static bool Interp_InitUint8(InterpState &S) {
30635	if (!Init<PT_Uint8>(S, S.PC)) return false;
30636	#if USE_TAILCALLS
30637	MUSTTAIL return InterpNext(S);
30638	#else
30639	return true;
30640	#endif
30641	}
30642	PRESERVE_NONE
30643	static bool Interp_InitSint16(InterpState &S) {
30644	if (!Init<PT_Sint16>(S, S.PC)) return false;
30645	#if USE_TAILCALLS
30646	MUSTTAIL return InterpNext(S);
30647	#else
30648	return true;
30649	#endif
30650	}
30651	PRESERVE_NONE
30652	static bool Interp_InitUint16(InterpState &S) {
30653	if (!Init<PT_Uint16>(S, S.PC)) return false;
30654	#if USE_TAILCALLS
30655	MUSTTAIL return InterpNext(S);
30656	#else
30657	return true;
30658	#endif
30659	}
30660	PRESERVE_NONE
30661	static bool Interp_InitSint32(InterpState &S) {
30662	if (!Init<PT_Sint32>(S, S.PC)) return false;
30663	#if USE_TAILCALLS
30664	MUSTTAIL return InterpNext(S);
30665	#else
30666	return true;
30667	#endif
30668	}
30669	PRESERVE_NONE
30670	static bool Interp_InitUint32(InterpState &S) {
30671	if (!Init<PT_Uint32>(S, S.PC)) return false;
30672	#if USE_TAILCALLS
30673	MUSTTAIL return InterpNext(S);
30674	#else
30675	return true;
30676	#endif
30677	}
30678	PRESERVE_NONE
30679	static bool Interp_InitSint64(InterpState &S) {
30680	if (!Init<PT_Sint64>(S, S.PC)) return false;
30681	#if USE_TAILCALLS
30682	MUSTTAIL return InterpNext(S);
30683	#else
30684	return true;
30685	#endif
30686	}
30687	PRESERVE_NONE
30688	static bool Interp_InitUint64(InterpState &S) {
30689	if (!Init<PT_Uint64>(S, S.PC)) return false;
30690	#if USE_TAILCALLS
30691	MUSTTAIL return InterpNext(S);
30692	#else
30693	return true;
30694	#endif
30695	}
30696	PRESERVE_NONE
30697	static bool Interp_InitIntAP(InterpState &S) {
30698	if (!Init<PT_IntAP>(S, S.PC)) return false;
30699	#if USE_TAILCALLS
30700	MUSTTAIL return InterpNext(S);
30701	#else
30702	return true;
30703	#endif
30704	}
30705	PRESERVE_NONE
30706	static bool Interp_InitIntAPS(InterpState &S) {
30707	if (!Init<PT_IntAPS>(S, S.PC)) return false;
30708	#if USE_TAILCALLS
30709	MUSTTAIL return InterpNext(S);
30710	#else
30711	return true;
30712	#endif
30713	}
30714	PRESERVE_NONE
30715	static bool Interp_InitBool(InterpState &S) {
30716	if (!Init<PT_Bool>(S, S.PC)) return false;
30717	#if USE_TAILCALLS
30718	MUSTTAIL return InterpNext(S);
30719	#else
30720	return true;
30721	#endif
30722	}
30723	PRESERVE_NONE
30724	static bool Interp_InitFixedPoint(InterpState &S) {
30725	if (!Init<PT_FixedPoint>(S, S.PC)) return false;
30726	#if USE_TAILCALLS
30727	MUSTTAIL return InterpNext(S);
30728	#else
30729	return true;
30730	#endif
30731	}
30732	PRESERVE_NONE
30733	static bool Interp_InitPtr(InterpState &S) {
30734	if (!Init<PT_Ptr>(S, S.PC)) return false;
30735	#if USE_TAILCALLS
30736	MUSTTAIL return InterpNext(S);
30737	#else
30738	return true;
30739	#endif
30740	}
30741	PRESERVE_NONE
30742	static bool Interp_InitMemberPtr(InterpState &S) {
30743	if (!Init<PT_MemberPtr>(S, S.PC)) return false;
30744	#if USE_TAILCALLS
30745	MUSTTAIL return InterpNext(S);
30746	#else
30747	return true;
30748	#endif
30749	}
30750	PRESERVE_NONE
30751	static bool Interp_InitFloat(InterpState &S) {
30752	if (!Init<PT_Float>(S, S.PC)) return false;
30753	#if USE_TAILCALLS
30754	MUSTTAIL return InterpNext(S);
30755	#else
30756	return true;
30757	#endif
30758	}
30759	#endif
30760	#ifdef GET_DISASM
30761	case OP_InitSint8:
30762	Text.Op = PrintName("InitSint8");
30763	break;
30764	case OP_InitUint8:
30765	Text.Op = PrintName("InitUint8");
30766	break;
30767	case OP_InitSint16:
30768	Text.Op = PrintName("InitSint16");
30769	break;
30770	case OP_InitUint16:
30771	Text.Op = PrintName("InitUint16");
30772	break;
30773	case OP_InitSint32:
30774	Text.Op = PrintName("InitSint32");
30775	break;
30776	case OP_InitUint32:
30777	Text.Op = PrintName("InitUint32");
30778	break;
30779	case OP_InitSint64:
30780	Text.Op = PrintName("InitSint64");
30781	break;
30782	case OP_InitUint64:
30783	Text.Op = PrintName("InitUint64");
30784	break;
30785	case OP_InitIntAP:
30786	Text.Op = PrintName("InitIntAP");
30787	break;
30788	case OP_InitIntAPS:
30789	Text.Op = PrintName("InitIntAPS");
30790	break;
30791	case OP_InitBool:
30792	Text.Op = PrintName("InitBool");
30793	break;
30794	case OP_InitFixedPoint:
30795	Text.Op = PrintName("InitFixedPoint");
30796	break;
30797	case OP_InitPtr:
30798	Text.Op = PrintName("InitPtr");
30799	break;
30800	case OP_InitMemberPtr:
30801	Text.Op = PrintName("InitMemberPtr");
30802	break;
30803	case OP_InitFloat:
30804	Text.Op = PrintName("InitFloat");
30805	break;
30806	#endif
30807	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30808	bool emitInitSint8(SourceInfo);
30809	bool emitInitUint8(SourceInfo);
30810	bool emitInitSint16(SourceInfo);
30811	bool emitInitUint16(SourceInfo);
30812	bool emitInitSint32(SourceInfo);
30813	bool emitInitUint32(SourceInfo);
30814	bool emitInitSint64(SourceInfo);
30815	bool emitInitUint64(SourceInfo);
30816	bool emitInitIntAP(SourceInfo);
30817	bool emitInitIntAPS(SourceInfo);
30818	bool emitInitBool(SourceInfo);
30819	bool emitInitFixedPoint(SourceInfo);
30820	bool emitInitPtr(SourceInfo);
30821	bool emitInitMemberPtr(SourceInfo);
30822	bool emitInitFloat(SourceInfo);
30823	#endif
30824	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
30825	[[nodiscard]] bool emitInit(PrimType, SourceInfo I);
30826	#endif
30827	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
30828	bool
30829	#if defined(GET_EVAL_IMPL)
30830	EvalEmitter
30831	#else
30832	ByteCodeEmitter
30833	#endif
30834	::emitInit(PrimType T0, SourceInfo I) {
30835	switch (T0) {
30836	case PT_Sint8:
30837	return emitInitSint8(I);
30838	case PT_Uint8:
30839	return emitInitUint8(I);
30840	case PT_Sint16:
30841	return emitInitSint16(I);
30842	case PT_Uint16:
30843	return emitInitUint16(I);
30844	case PT_Sint32:
30845	return emitInitSint32(I);
30846	case PT_Uint32:
30847	return emitInitUint32(I);
30848	case PT_Sint64:
30849	return emitInitSint64(I);
30850	case PT_Uint64:
30851	return emitInitUint64(I);
30852	case PT_IntAP:
30853	return emitInitIntAP(I);
30854	case PT_IntAPS:
30855	return emitInitIntAPS(I);
30856	case PT_Bool:
30857	return emitInitBool(I);
30858	case PT_FixedPoint:
30859	return emitInitFixedPoint(I);
30860	case PT_Ptr:
30861	return emitInitPtr(I);
30862	case PT_MemberPtr:
30863	return emitInitMemberPtr(I);
30864	case PT_Float:
30865	return emitInitFloat(I);
30866	}
30867	llvm_unreachable("invalid enum value");
30868	}
30869	#endif
30870	#ifdef GET_LINK_IMPL
30871	bool ByteCodeEmitter::emitInitSint8(SourceInfo L) {
30872	return emitOp<>(OP_InitSint8, L);
30873	}
30874	bool ByteCodeEmitter::emitInitUint8(SourceInfo L) {
30875	return emitOp<>(OP_InitUint8, L);
30876	}
30877	bool ByteCodeEmitter::emitInitSint16(SourceInfo L) {
30878	return emitOp<>(OP_InitSint16, L);
30879	}
30880	bool ByteCodeEmitter::emitInitUint16(SourceInfo L) {
30881	return emitOp<>(OP_InitUint16, L);
30882	}
30883	bool ByteCodeEmitter::emitInitSint32(SourceInfo L) {
30884	return emitOp<>(OP_InitSint32, L);
30885	}
30886	bool ByteCodeEmitter::emitInitUint32(SourceInfo L) {
30887	return emitOp<>(OP_InitUint32, L);
30888	}
30889	bool ByteCodeEmitter::emitInitSint64(SourceInfo L) {
30890	return emitOp<>(OP_InitSint64, L);
30891	}
30892	bool ByteCodeEmitter::emitInitUint64(SourceInfo L) {
30893	return emitOp<>(OP_InitUint64, L);
30894	}
30895	bool ByteCodeEmitter::emitInitIntAP(SourceInfo L) {
30896	return emitOp<>(OP_InitIntAP, L);
30897	}
30898	bool ByteCodeEmitter::emitInitIntAPS(SourceInfo L) {
30899	return emitOp<>(OP_InitIntAPS, L);
30900	}
30901	bool ByteCodeEmitter::emitInitBool(SourceInfo L) {
30902	return emitOp<>(OP_InitBool, L);
30903	}
30904	bool ByteCodeEmitter::emitInitFixedPoint(SourceInfo L) {
30905	return emitOp<>(OP_InitFixedPoint, L);
30906	}
30907	bool ByteCodeEmitter::emitInitPtr(SourceInfo L) {
30908	return emitOp<>(OP_InitPtr, L);
30909	}
30910	bool ByteCodeEmitter::emitInitMemberPtr(SourceInfo L) {
30911	return emitOp<>(OP_InitMemberPtr, L);
30912	}
30913	bool ByteCodeEmitter::emitInitFloat(SourceInfo L) {
30914	return emitOp<>(OP_InitFloat, L);
30915	}
30916	#endif
30917	#ifdef GET_EVAL_IMPL
30918	bool EvalEmitter::emitInitSint8(SourceInfo L) {
30919	if (!isActive()) return true;
30920	CurrentSource = L;
30921	return Init<PT_Sint8>(S, CodePtr());
30922	}
30923	bool EvalEmitter::emitInitUint8(SourceInfo L) {
30924	if (!isActive()) return true;
30925	CurrentSource = L;
30926	return Init<PT_Uint8>(S, CodePtr());
30927	}
30928	bool EvalEmitter::emitInitSint16(SourceInfo L) {
30929	if (!isActive()) return true;
30930	CurrentSource = L;
30931	return Init<PT_Sint16>(S, CodePtr());
30932	}
30933	bool EvalEmitter::emitInitUint16(SourceInfo L) {
30934	if (!isActive()) return true;
30935	CurrentSource = L;
30936	return Init<PT_Uint16>(S, CodePtr());
30937	}
30938	bool EvalEmitter::emitInitSint32(SourceInfo L) {
30939	if (!isActive()) return true;
30940	CurrentSource = L;
30941	return Init<PT_Sint32>(S, CodePtr());
30942	}
30943	bool EvalEmitter::emitInitUint32(SourceInfo L) {
30944	if (!isActive()) return true;
30945	CurrentSource = L;
30946	return Init<PT_Uint32>(S, CodePtr());
30947	}
30948	bool EvalEmitter::emitInitSint64(SourceInfo L) {
30949	if (!isActive()) return true;
30950	CurrentSource = L;
30951	return Init<PT_Sint64>(S, CodePtr());
30952	}
30953	bool EvalEmitter::emitInitUint64(SourceInfo L) {
30954	if (!isActive()) return true;
30955	CurrentSource = L;
30956	return Init<PT_Uint64>(S, CodePtr());
30957	}
30958	bool EvalEmitter::emitInitIntAP(SourceInfo L) {
30959	if (!isActive()) return true;
30960	CurrentSource = L;
30961	return Init<PT_IntAP>(S, CodePtr());
30962	}
30963	bool EvalEmitter::emitInitIntAPS(SourceInfo L) {
30964	if (!isActive()) return true;
30965	CurrentSource = L;
30966	return Init<PT_IntAPS>(S, CodePtr());
30967	}
30968	bool EvalEmitter::emitInitBool(SourceInfo L) {
30969	if (!isActive()) return true;
30970	CurrentSource = L;
30971	return Init<PT_Bool>(S, CodePtr());
30972	}
30973	bool EvalEmitter::emitInitFixedPoint(SourceInfo L) {
30974	if (!isActive()) return true;
30975	CurrentSource = L;
30976	return Init<PT_FixedPoint>(S, CodePtr());
30977	}
30978	bool EvalEmitter::emitInitPtr(SourceInfo L) {
30979	if (!isActive()) return true;
30980	CurrentSource = L;
30981	return Init<PT_Ptr>(S, CodePtr());
30982	}
30983	bool EvalEmitter::emitInitMemberPtr(SourceInfo L) {
30984	if (!isActive()) return true;
30985	CurrentSource = L;
30986	return Init<PT_MemberPtr>(S, CodePtr());
30987	}
30988	bool EvalEmitter::emitInitFloat(SourceInfo L) {
30989	if (!isActive()) return true;
30990	CurrentSource = L;
30991	return Init<PT_Float>(S, CodePtr());
30992	}
30993	#endif
30994	#ifdef GET_OPCODE_NAMES
30995	OP_InitBitFieldSint8,
30996	OP_InitBitFieldUint8,
30997	OP_InitBitFieldSint16,
30998	OP_InitBitFieldUint16,
30999	OP_InitBitFieldSint32,
31000	OP_InitBitFieldUint32,
31001	OP_InitBitFieldSint64,
31002	OP_InitBitFieldUint64,
31003	OP_InitBitFieldIntAP,
31004	OP_InitBitFieldIntAPS,
31005	OP_InitBitFieldBool,
31006	#endif
31007	#ifdef GET_INTERPFN_LIST
31008	&Interp_InitBitFieldSint8,
31009	&Interp_InitBitFieldUint8,
31010	&Interp_InitBitFieldSint16,
31011	&Interp_InitBitFieldUint16,
31012	&Interp_InitBitFieldSint32,
31013	&Interp_InitBitFieldUint32,
31014	&Interp_InitBitFieldSint64,
31015	&Interp_InitBitFieldUint64,
31016	&Interp_InitBitFieldIntAP,
31017	&Interp_InitBitFieldIntAPS,
31018	&Interp_InitBitFieldBool,
31019	#endif
31020	#ifdef GET_INTERPFN_DISPATCHERS
31021	PRESERVE_NONE
31022	static bool Interp_InitBitFieldSint8(InterpState &S) {
31023	{
31024	CodePtr OpPC = S.PC;
31025	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31026	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31027	if (!InitBitField<PT_Sint8>(S, OpPC, V0, V1)) return false;
31028	}
31029	#if USE_TAILCALLS
31030	MUSTTAIL return InterpNext(S);
31031	#else
31032	return true;
31033	#endif
31034	}
31035	PRESERVE_NONE
31036	static bool Interp_InitBitFieldUint8(InterpState &S) {
31037	{
31038	CodePtr OpPC = S.PC;
31039	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31040	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31041	if (!InitBitField<PT_Uint8>(S, OpPC, V0, V1)) return false;
31042	}
31043	#if USE_TAILCALLS
31044	MUSTTAIL return InterpNext(S);
31045	#else
31046	return true;
31047	#endif
31048	}
31049	PRESERVE_NONE
31050	static bool Interp_InitBitFieldSint16(InterpState &S) {
31051	{
31052	CodePtr OpPC = S.PC;
31053	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31054	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31055	if (!InitBitField<PT_Sint16>(S, OpPC, V0, V1)) return false;
31056	}
31057	#if USE_TAILCALLS
31058	MUSTTAIL return InterpNext(S);
31059	#else
31060	return true;
31061	#endif
31062	}
31063	PRESERVE_NONE
31064	static bool Interp_InitBitFieldUint16(InterpState &S) {
31065	{
31066	CodePtr OpPC = S.PC;
31067	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31068	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31069	if (!InitBitField<PT_Uint16>(S, OpPC, V0, V1)) return false;
31070	}
31071	#if USE_TAILCALLS
31072	MUSTTAIL return InterpNext(S);
31073	#else
31074	return true;
31075	#endif
31076	}
31077	PRESERVE_NONE
31078	static bool Interp_InitBitFieldSint32(InterpState &S) {
31079	{
31080	CodePtr OpPC = S.PC;
31081	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31082	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31083	if (!InitBitField<PT_Sint32>(S, OpPC, V0, V1)) return false;
31084	}
31085	#if USE_TAILCALLS
31086	MUSTTAIL return InterpNext(S);
31087	#else
31088	return true;
31089	#endif
31090	}
31091	PRESERVE_NONE
31092	static bool Interp_InitBitFieldUint32(InterpState &S) {
31093	{
31094	CodePtr OpPC = S.PC;
31095	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31096	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31097	if (!InitBitField<PT_Uint32>(S, OpPC, V0, V1)) return false;
31098	}
31099	#if USE_TAILCALLS
31100	MUSTTAIL return InterpNext(S);
31101	#else
31102	return true;
31103	#endif
31104	}
31105	PRESERVE_NONE
31106	static bool Interp_InitBitFieldSint64(InterpState &S) {
31107	{
31108	CodePtr OpPC = S.PC;
31109	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31110	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31111	if (!InitBitField<PT_Sint64>(S, OpPC, V0, V1)) return false;
31112	}
31113	#if USE_TAILCALLS
31114	MUSTTAIL return InterpNext(S);
31115	#else
31116	return true;
31117	#endif
31118	}
31119	PRESERVE_NONE
31120	static bool Interp_InitBitFieldUint64(InterpState &S) {
31121	{
31122	CodePtr OpPC = S.PC;
31123	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31124	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31125	if (!InitBitField<PT_Uint64>(S, OpPC, V0, V1)) return false;
31126	}
31127	#if USE_TAILCALLS
31128	MUSTTAIL return InterpNext(S);
31129	#else
31130	return true;
31131	#endif
31132	}
31133	PRESERVE_NONE
31134	static bool Interp_InitBitFieldIntAP(InterpState &S) {
31135	{
31136	CodePtr OpPC = S.PC;
31137	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31138	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31139	if (!InitBitField<PT_IntAP>(S, OpPC, V0, V1)) return false;
31140	}
31141	#if USE_TAILCALLS
31142	MUSTTAIL return InterpNext(S);
31143	#else
31144	return true;
31145	#endif
31146	}
31147	PRESERVE_NONE
31148	static bool Interp_InitBitFieldIntAPS(InterpState &S) {
31149	{
31150	CodePtr OpPC = S.PC;
31151	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31152	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31153	if (!InitBitField<PT_IntAPS>(S, OpPC, V0, V1)) return false;
31154	}
31155	#if USE_TAILCALLS
31156	MUSTTAIL return InterpNext(S);
31157	#else
31158	return true;
31159	#endif
31160	}
31161	PRESERVE_NONE
31162	static bool Interp_InitBitFieldBool(InterpState &S) {
31163	{
31164	CodePtr OpPC = S.PC;
31165	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31166	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31167	if (!InitBitField<PT_Bool>(S, OpPC, V0, V1)) return false;
31168	}
31169	#if USE_TAILCALLS
31170	MUSTTAIL return InterpNext(S);
31171	#else
31172	return true;
31173	#endif
31174	}
31175	#endif
31176	#ifdef GET_DISASM
31177	case OP_InitBitFieldSint8:
31178	Text.Op = PrintName("InitBitFieldSint8");
31179	Text.Args.push_back(printArg<uint32_t>(P, PC));
31180	Text.Args.push_back(printArg<uint32_t>(P, PC));
31181	break;
31182	case OP_InitBitFieldUint8:
31183	Text.Op = PrintName("InitBitFieldUint8");
31184	Text.Args.push_back(printArg<uint32_t>(P, PC));
31185	Text.Args.push_back(printArg<uint32_t>(P, PC));
31186	break;
31187	case OP_InitBitFieldSint16:
31188	Text.Op = PrintName("InitBitFieldSint16");
31189	Text.Args.push_back(printArg<uint32_t>(P, PC));
31190	Text.Args.push_back(printArg<uint32_t>(P, PC));
31191	break;
31192	case OP_InitBitFieldUint16:
31193	Text.Op = PrintName("InitBitFieldUint16");
31194	Text.Args.push_back(printArg<uint32_t>(P, PC));
31195	Text.Args.push_back(printArg<uint32_t>(P, PC));
31196	break;
31197	case OP_InitBitFieldSint32:
31198	Text.Op = PrintName("InitBitFieldSint32");
31199	Text.Args.push_back(printArg<uint32_t>(P, PC));
31200	Text.Args.push_back(printArg<uint32_t>(P, PC));
31201	break;
31202	case OP_InitBitFieldUint32:
31203	Text.Op = PrintName("InitBitFieldUint32");
31204	Text.Args.push_back(printArg<uint32_t>(P, PC));
31205	Text.Args.push_back(printArg<uint32_t>(P, PC));
31206	break;
31207	case OP_InitBitFieldSint64:
31208	Text.Op = PrintName("InitBitFieldSint64");
31209	Text.Args.push_back(printArg<uint32_t>(P, PC));
31210	Text.Args.push_back(printArg<uint32_t>(P, PC));
31211	break;
31212	case OP_InitBitFieldUint64:
31213	Text.Op = PrintName("InitBitFieldUint64");
31214	Text.Args.push_back(printArg<uint32_t>(P, PC));
31215	Text.Args.push_back(printArg<uint32_t>(P, PC));
31216	break;
31217	case OP_InitBitFieldIntAP:
31218	Text.Op = PrintName("InitBitFieldIntAP");
31219	Text.Args.push_back(printArg<uint32_t>(P, PC));
31220	Text.Args.push_back(printArg<uint32_t>(P, PC));
31221	break;
31222	case OP_InitBitFieldIntAPS:
31223	Text.Op = PrintName("InitBitFieldIntAPS");
31224	Text.Args.push_back(printArg<uint32_t>(P, PC));
31225	Text.Args.push_back(printArg<uint32_t>(P, PC));
31226	break;
31227	case OP_InitBitFieldBool:
31228	Text.Op = PrintName("InitBitFieldBool");
31229	Text.Args.push_back(printArg<uint32_t>(P, PC));
31230	Text.Args.push_back(printArg<uint32_t>(P, PC));
31231	break;
31232	#endif
31233	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
31234	bool emitInitBitFieldSint8( uint32_t , uint32_t , SourceInfo);
31235	bool emitInitBitFieldUint8( uint32_t , uint32_t , SourceInfo);
31236	bool emitInitBitFieldSint16( uint32_t , uint32_t , SourceInfo);
31237	bool emitInitBitFieldUint16( uint32_t , uint32_t , SourceInfo);
31238	bool emitInitBitFieldSint32( uint32_t , uint32_t , SourceInfo);
31239	bool emitInitBitFieldUint32( uint32_t , uint32_t , SourceInfo);
31240	bool emitInitBitFieldSint64( uint32_t , uint32_t , SourceInfo);
31241	bool emitInitBitFieldUint64( uint32_t , uint32_t , SourceInfo);
31242	bool emitInitBitFieldIntAP( uint32_t , uint32_t , SourceInfo);
31243	bool emitInitBitFieldIntAPS( uint32_t , uint32_t , SourceInfo);
31244	bool emitInitBitFieldBool( uint32_t , uint32_t , SourceInfo);
31245	#endif
31246	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
31247	[[nodiscard]] bool emitInitBitField(PrimType, uint32_t, uint32_t, SourceInfo I);
31248	#endif
31249	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
31250	bool
31251	#if defined(GET_EVAL_IMPL)
31252	EvalEmitter
31253	#else
31254	ByteCodeEmitter
31255	#endif
31256	::emitInitBitField(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
31257	switch (T0) {
31258	case PT_Sint8:
31259	return emitInitBitFieldSint8(A0, A1, I);
31260	case PT_Uint8:
31261	return emitInitBitFieldUint8(A0, A1, I);
31262	case PT_Sint16:
31263	return emitInitBitFieldSint16(A0, A1, I);
31264	case PT_Uint16:
31265	return emitInitBitFieldUint16(A0, A1, I);
31266	case PT_Sint32:
31267	return emitInitBitFieldSint32(A0, A1, I);
31268	case PT_Uint32:
31269	return emitInitBitFieldUint32(A0, A1, I);
31270	case PT_Sint64:
31271	return emitInitBitFieldSint64(A0, A1, I);
31272	case PT_Uint64:
31273	return emitInitBitFieldUint64(A0, A1, I);
31274	case PT_IntAP:
31275	return emitInitBitFieldIntAP(A0, A1, I);
31276	case PT_IntAPS:
31277	return emitInitBitFieldIntAPS(A0, A1, I);
31278	case PT_Bool:
31279	return emitInitBitFieldBool(A0, A1, I);
31280	default: llvm_unreachable("invalid type: emitInitBitField");
31281	}
31282	llvm_unreachable("invalid enum value");
31283	}
31284	#endif
31285	#ifdef GET_LINK_IMPL
31286	bool ByteCodeEmitter::emitInitBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31287	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint8, A0, A1, L);
31288	}
31289	bool ByteCodeEmitter::emitInitBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31290	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint8, A0, A1, L);
31291	}
31292	bool ByteCodeEmitter::emitInitBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31293	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint16, A0, A1, L);
31294	}
31295	bool ByteCodeEmitter::emitInitBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31296	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint16, A0, A1, L);
31297	}
31298	bool ByteCodeEmitter::emitInitBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31299	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint32, A0, A1, L);
31300	}
31301	bool ByteCodeEmitter::emitInitBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31302	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint32, A0, A1, L);
31303	}
31304	bool ByteCodeEmitter::emitInitBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31305	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint64, A0, A1, L);
31306	}
31307	bool ByteCodeEmitter::emitInitBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31308	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint64, A0, A1, L);
31309	}
31310	bool ByteCodeEmitter::emitInitBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
31311	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldIntAP, A0, A1, L);
31312	}
31313	bool ByteCodeEmitter::emitInitBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
31314	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldIntAPS, A0, A1, L);
31315	}
31316	bool ByteCodeEmitter::emitInitBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
31317	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldBool, A0, A1, L);
31318	}
31319	#endif
31320	#ifdef GET_EVAL_IMPL
31321	bool EvalEmitter::emitInitBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31322	if (!isActive()) return true;
31323	CurrentSource = L;
31324	return InitBitField<PT_Sint8>(S, CodePtr(), A0, A1);
31325	}
31326	bool EvalEmitter::emitInitBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31327	if (!isActive()) return true;
31328	CurrentSource = L;
31329	return InitBitField<PT_Uint8>(S, CodePtr(), A0, A1);
31330	}
31331	bool EvalEmitter::emitInitBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31332	if (!isActive()) return true;
31333	CurrentSource = L;
31334	return InitBitField<PT_Sint16>(S, CodePtr(), A0, A1);
31335	}
31336	bool EvalEmitter::emitInitBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31337	if (!isActive()) return true;
31338	CurrentSource = L;
31339	return InitBitField<PT_Uint16>(S, CodePtr(), A0, A1);
31340	}
31341	bool EvalEmitter::emitInitBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31342	if (!isActive()) return true;
31343	CurrentSource = L;
31344	return InitBitField<PT_Sint32>(S, CodePtr(), A0, A1);
31345	}
31346	bool EvalEmitter::emitInitBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31347	if (!isActive()) return true;
31348	CurrentSource = L;
31349	return InitBitField<PT_Uint32>(S, CodePtr(), A0, A1);
31350	}
31351	bool EvalEmitter::emitInitBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31352	if (!isActive()) return true;
31353	CurrentSource = L;
31354	return InitBitField<PT_Sint64>(S, CodePtr(), A0, A1);
31355	}
31356	bool EvalEmitter::emitInitBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31357	if (!isActive()) return true;
31358	CurrentSource = L;
31359	return InitBitField<PT_Uint64>(S, CodePtr(), A0, A1);
31360	}
31361	bool EvalEmitter::emitInitBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
31362	if (!isActive()) return true;
31363	CurrentSource = L;
31364	return InitBitField<PT_IntAP>(S, CodePtr(), A0, A1);
31365	}
31366	bool EvalEmitter::emitInitBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
31367	if (!isActive()) return true;
31368	CurrentSource = L;
31369	return InitBitField<PT_IntAPS>(S, CodePtr(), A0, A1);
31370	}
31371	bool EvalEmitter::emitInitBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
31372	if (!isActive()) return true;
31373	CurrentSource = L;
31374	return InitBitField<PT_Bool>(S, CodePtr(), A0, A1);
31375	}
31376	#endif
31377	#ifdef GET_OPCODE_NAMES
31378	OP_InitBitFieldActivateSint8,
31379	OP_InitBitFieldActivateUint8,
31380	OP_InitBitFieldActivateSint16,
31381	OP_InitBitFieldActivateUint16,
31382	OP_InitBitFieldActivateSint32,
31383	OP_InitBitFieldActivateUint32,
31384	OP_InitBitFieldActivateSint64,
31385	OP_InitBitFieldActivateUint64,
31386	OP_InitBitFieldActivateIntAP,
31387	OP_InitBitFieldActivateIntAPS,
31388	OP_InitBitFieldActivateBool,
31389	#endif
31390	#ifdef GET_INTERPFN_LIST
31391	&Interp_InitBitFieldActivateSint8,
31392	&Interp_InitBitFieldActivateUint8,
31393	&Interp_InitBitFieldActivateSint16,
31394	&Interp_InitBitFieldActivateUint16,
31395	&Interp_InitBitFieldActivateSint32,
31396	&Interp_InitBitFieldActivateUint32,
31397	&Interp_InitBitFieldActivateSint64,
31398	&Interp_InitBitFieldActivateUint64,
31399	&Interp_InitBitFieldActivateIntAP,
31400	&Interp_InitBitFieldActivateIntAPS,
31401	&Interp_InitBitFieldActivateBool,
31402	#endif
31403	#ifdef GET_INTERPFN_DISPATCHERS
31404	PRESERVE_NONE
31405	static bool Interp_InitBitFieldActivateSint8(InterpState &S) {
31406	{
31407	CodePtr OpPC = S.PC;
31408	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31409	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31410	if (!InitBitFieldActivate<PT_Sint8>(S, OpPC, V0, V1)) return false;
31411	}
31412	#if USE_TAILCALLS
31413	MUSTTAIL return InterpNext(S);
31414	#else
31415	return true;
31416	#endif
31417	}
31418	PRESERVE_NONE
31419	static bool Interp_InitBitFieldActivateUint8(InterpState &S) {
31420	{
31421	CodePtr OpPC = S.PC;
31422	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31423	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31424	if (!InitBitFieldActivate<PT_Uint8>(S, OpPC, V0, V1)) return false;
31425	}
31426	#if USE_TAILCALLS
31427	MUSTTAIL return InterpNext(S);
31428	#else
31429	return true;
31430	#endif
31431	}
31432	PRESERVE_NONE
31433	static bool Interp_InitBitFieldActivateSint16(InterpState &S) {
31434	{
31435	CodePtr OpPC = S.PC;
31436	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31437	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31438	if (!InitBitFieldActivate<PT_Sint16>(S, OpPC, V0, V1)) return false;
31439	}
31440	#if USE_TAILCALLS
31441	MUSTTAIL return InterpNext(S);
31442	#else
31443	return true;
31444	#endif
31445	}
31446	PRESERVE_NONE
31447	static bool Interp_InitBitFieldActivateUint16(InterpState &S) {
31448	{
31449	CodePtr OpPC = S.PC;
31450	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31451	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31452	if (!InitBitFieldActivate<PT_Uint16>(S, OpPC, V0, V1)) return false;
31453	}
31454	#if USE_TAILCALLS
31455	MUSTTAIL return InterpNext(S);
31456	#else
31457	return true;
31458	#endif
31459	}
31460	PRESERVE_NONE
31461	static bool Interp_InitBitFieldActivateSint32(InterpState &S) {
31462	{
31463	CodePtr OpPC = S.PC;
31464	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31465	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31466	if (!InitBitFieldActivate<PT_Sint32>(S, OpPC, V0, V1)) return false;
31467	}
31468	#if USE_TAILCALLS
31469	MUSTTAIL return InterpNext(S);
31470	#else
31471	return true;
31472	#endif
31473	}
31474	PRESERVE_NONE
31475	static bool Interp_InitBitFieldActivateUint32(InterpState &S) {
31476	{
31477	CodePtr OpPC = S.PC;
31478	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31479	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31480	if (!InitBitFieldActivate<PT_Uint32>(S, OpPC, V0, V1)) return false;
31481	}
31482	#if USE_TAILCALLS
31483	MUSTTAIL return InterpNext(S);
31484	#else
31485	return true;
31486	#endif
31487	}
31488	PRESERVE_NONE
31489	static bool Interp_InitBitFieldActivateSint64(InterpState &S) {
31490	{
31491	CodePtr OpPC = S.PC;
31492	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31493	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31494	if (!InitBitFieldActivate<PT_Sint64>(S, OpPC, V0, V1)) return false;
31495	}
31496	#if USE_TAILCALLS
31497	MUSTTAIL return InterpNext(S);
31498	#else
31499	return true;
31500	#endif
31501	}
31502	PRESERVE_NONE
31503	static bool Interp_InitBitFieldActivateUint64(InterpState &S) {
31504	{
31505	CodePtr OpPC = S.PC;
31506	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31507	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31508	if (!InitBitFieldActivate<PT_Uint64>(S, OpPC, V0, V1)) return false;
31509	}
31510	#if USE_TAILCALLS
31511	MUSTTAIL return InterpNext(S);
31512	#else
31513	return true;
31514	#endif
31515	}
31516	PRESERVE_NONE
31517	static bool Interp_InitBitFieldActivateIntAP(InterpState &S) {
31518	{
31519	CodePtr OpPC = S.PC;
31520	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31521	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31522	if (!InitBitFieldActivate<PT_IntAP>(S, OpPC, V0, V1)) return false;
31523	}
31524	#if USE_TAILCALLS
31525	MUSTTAIL return InterpNext(S);
31526	#else
31527	return true;
31528	#endif
31529	}
31530	PRESERVE_NONE
31531	static bool Interp_InitBitFieldActivateIntAPS(InterpState &S) {
31532	{
31533	CodePtr OpPC = S.PC;
31534	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31535	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31536	if (!InitBitFieldActivate<PT_IntAPS>(S, OpPC, V0, V1)) return false;
31537	}
31538	#if USE_TAILCALLS
31539	MUSTTAIL return InterpNext(S);
31540	#else
31541	return true;
31542	#endif
31543	}
31544	PRESERVE_NONE
31545	static bool Interp_InitBitFieldActivateBool(InterpState &S) {
31546	{
31547	CodePtr OpPC = S.PC;
31548	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31549	const auto V1 = ReadArg<uint32_t>(S, S.PC);
31550	if (!InitBitFieldActivate<PT_Bool>(S, OpPC, V0, V1)) return false;
31551	}
31552	#if USE_TAILCALLS
31553	MUSTTAIL return InterpNext(S);
31554	#else
31555	return true;
31556	#endif
31557	}
31558	#endif
31559	#ifdef GET_DISASM
31560	case OP_InitBitFieldActivateSint8:
31561	Text.Op = PrintName("InitBitFieldActivateSint8");
31562	Text.Args.push_back(printArg<uint32_t>(P, PC));
31563	Text.Args.push_back(printArg<uint32_t>(P, PC));
31564	break;
31565	case OP_InitBitFieldActivateUint8:
31566	Text.Op = PrintName("InitBitFieldActivateUint8");
31567	Text.Args.push_back(printArg<uint32_t>(P, PC));
31568	Text.Args.push_back(printArg<uint32_t>(P, PC));
31569	break;
31570	case OP_InitBitFieldActivateSint16:
31571	Text.Op = PrintName("InitBitFieldActivateSint16");
31572	Text.Args.push_back(printArg<uint32_t>(P, PC));
31573	Text.Args.push_back(printArg<uint32_t>(P, PC));
31574	break;
31575	case OP_InitBitFieldActivateUint16:
31576	Text.Op = PrintName("InitBitFieldActivateUint16");
31577	Text.Args.push_back(printArg<uint32_t>(P, PC));
31578	Text.Args.push_back(printArg<uint32_t>(P, PC));
31579	break;
31580	case OP_InitBitFieldActivateSint32:
31581	Text.Op = PrintName("InitBitFieldActivateSint32");
31582	Text.Args.push_back(printArg<uint32_t>(P, PC));
31583	Text.Args.push_back(printArg<uint32_t>(P, PC));
31584	break;
31585	case OP_InitBitFieldActivateUint32:
31586	Text.Op = PrintName("InitBitFieldActivateUint32");
31587	Text.Args.push_back(printArg<uint32_t>(P, PC));
31588	Text.Args.push_back(printArg<uint32_t>(P, PC));
31589	break;
31590	case OP_InitBitFieldActivateSint64:
31591	Text.Op = PrintName("InitBitFieldActivateSint64");
31592	Text.Args.push_back(printArg<uint32_t>(P, PC));
31593	Text.Args.push_back(printArg<uint32_t>(P, PC));
31594	break;
31595	case OP_InitBitFieldActivateUint64:
31596	Text.Op = PrintName("InitBitFieldActivateUint64");
31597	Text.Args.push_back(printArg<uint32_t>(P, PC));
31598	Text.Args.push_back(printArg<uint32_t>(P, PC));
31599	break;
31600	case OP_InitBitFieldActivateIntAP:
31601	Text.Op = PrintName("InitBitFieldActivateIntAP");
31602	Text.Args.push_back(printArg<uint32_t>(P, PC));
31603	Text.Args.push_back(printArg<uint32_t>(P, PC));
31604	break;
31605	case OP_InitBitFieldActivateIntAPS:
31606	Text.Op = PrintName("InitBitFieldActivateIntAPS");
31607	Text.Args.push_back(printArg<uint32_t>(P, PC));
31608	Text.Args.push_back(printArg<uint32_t>(P, PC));
31609	break;
31610	case OP_InitBitFieldActivateBool:
31611	Text.Op = PrintName("InitBitFieldActivateBool");
31612	Text.Args.push_back(printArg<uint32_t>(P, PC));
31613	Text.Args.push_back(printArg<uint32_t>(P, PC));
31614	break;
31615	#endif
31616	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
31617	bool emitInitBitFieldActivateSint8( uint32_t , uint32_t , SourceInfo);
31618	bool emitInitBitFieldActivateUint8( uint32_t , uint32_t , SourceInfo);
31619	bool emitInitBitFieldActivateSint16( uint32_t , uint32_t , SourceInfo);
31620	bool emitInitBitFieldActivateUint16( uint32_t , uint32_t , SourceInfo);
31621	bool emitInitBitFieldActivateSint32( uint32_t , uint32_t , SourceInfo);
31622	bool emitInitBitFieldActivateUint32( uint32_t , uint32_t , SourceInfo);
31623	bool emitInitBitFieldActivateSint64( uint32_t , uint32_t , SourceInfo);
31624	bool emitInitBitFieldActivateUint64( uint32_t , uint32_t , SourceInfo);
31625	bool emitInitBitFieldActivateIntAP( uint32_t , uint32_t , SourceInfo);
31626	bool emitInitBitFieldActivateIntAPS( uint32_t , uint32_t , SourceInfo);
31627	bool emitInitBitFieldActivateBool( uint32_t , uint32_t , SourceInfo);
31628	#endif
31629	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
31630	[[nodiscard]] bool emitInitBitFieldActivate(PrimType, uint32_t, uint32_t, SourceInfo I);
31631	#endif
31632	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
31633	bool
31634	#if defined(GET_EVAL_IMPL)
31635	EvalEmitter
31636	#else
31637	ByteCodeEmitter
31638	#endif
31639	::emitInitBitFieldActivate(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
31640	switch (T0) {
31641	case PT_Sint8:
31642	return emitInitBitFieldActivateSint8(A0, A1, I);
31643	case PT_Uint8:
31644	return emitInitBitFieldActivateUint8(A0, A1, I);
31645	case PT_Sint16:
31646	return emitInitBitFieldActivateSint16(A0, A1, I);
31647	case PT_Uint16:
31648	return emitInitBitFieldActivateUint16(A0, A1, I);
31649	case PT_Sint32:
31650	return emitInitBitFieldActivateSint32(A0, A1, I);
31651	case PT_Uint32:
31652	return emitInitBitFieldActivateUint32(A0, A1, I);
31653	case PT_Sint64:
31654	return emitInitBitFieldActivateSint64(A0, A1, I);
31655	case PT_Uint64:
31656	return emitInitBitFieldActivateUint64(A0, A1, I);
31657	case PT_IntAP:
31658	return emitInitBitFieldActivateIntAP(A0, A1, I);
31659	case PT_IntAPS:
31660	return emitInitBitFieldActivateIntAPS(A0, A1, I);
31661	case PT_Bool:
31662	return emitInitBitFieldActivateBool(A0, A1, I);
31663	default: llvm_unreachable("invalid type: emitInitBitFieldActivate");
31664	}
31665	llvm_unreachable("invalid enum value");
31666	}
31667	#endif
31668	#ifdef GET_LINK_IMPL
31669	bool ByteCodeEmitter::emitInitBitFieldActivateSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31670	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint8, A0, A1, L);
31671	}
31672	bool ByteCodeEmitter::emitInitBitFieldActivateUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31673	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint8, A0, A1, L);
31674	}
31675	bool ByteCodeEmitter::emitInitBitFieldActivateSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31676	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint16, A0, A1, L);
31677	}
31678	bool ByteCodeEmitter::emitInitBitFieldActivateUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31679	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint16, A0, A1, L);
31680	}
31681	bool ByteCodeEmitter::emitInitBitFieldActivateSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31682	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint32, A0, A1, L);
31683	}
31684	bool ByteCodeEmitter::emitInitBitFieldActivateUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31685	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint32, A0, A1, L);
31686	}
31687	bool ByteCodeEmitter::emitInitBitFieldActivateSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31688	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint64, A0, A1, L);
31689	}
31690	bool ByteCodeEmitter::emitInitBitFieldActivateUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31691	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint64, A0, A1, L);
31692	}
31693	bool ByteCodeEmitter::emitInitBitFieldActivateIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
31694	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateIntAP, A0, A1, L);
31695	}
31696	bool ByteCodeEmitter::emitInitBitFieldActivateIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
31697	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateIntAPS, A0, A1, L);
31698	}
31699	bool ByteCodeEmitter::emitInitBitFieldActivateBool( uint32_t A0, uint32_t A1, SourceInfo L) {
31700	return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateBool, A0, A1, L);
31701	}
31702	#endif
31703	#ifdef GET_EVAL_IMPL
31704	bool EvalEmitter::emitInitBitFieldActivateSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31705	if (!isActive()) return true;
31706	CurrentSource = L;
31707	return InitBitFieldActivate<PT_Sint8>(S, CodePtr(), A0, A1);
31708	}
31709	bool EvalEmitter::emitInitBitFieldActivateUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
31710	if (!isActive()) return true;
31711	CurrentSource = L;
31712	return InitBitFieldActivate<PT_Uint8>(S, CodePtr(), A0, A1);
31713	}
31714	bool EvalEmitter::emitInitBitFieldActivateSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31715	if (!isActive()) return true;
31716	CurrentSource = L;
31717	return InitBitFieldActivate<PT_Sint16>(S, CodePtr(), A0, A1);
31718	}
31719	bool EvalEmitter::emitInitBitFieldActivateUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
31720	if (!isActive()) return true;
31721	CurrentSource = L;
31722	return InitBitFieldActivate<PT_Uint16>(S, CodePtr(), A0, A1);
31723	}
31724	bool EvalEmitter::emitInitBitFieldActivateSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31725	if (!isActive()) return true;
31726	CurrentSource = L;
31727	return InitBitFieldActivate<PT_Sint32>(S, CodePtr(), A0, A1);
31728	}
31729	bool EvalEmitter::emitInitBitFieldActivateUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
31730	if (!isActive()) return true;
31731	CurrentSource = L;
31732	return InitBitFieldActivate<PT_Uint32>(S, CodePtr(), A0, A1);
31733	}
31734	bool EvalEmitter::emitInitBitFieldActivateSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31735	if (!isActive()) return true;
31736	CurrentSource = L;
31737	return InitBitFieldActivate<PT_Sint64>(S, CodePtr(), A0, A1);
31738	}
31739	bool EvalEmitter::emitInitBitFieldActivateUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
31740	if (!isActive()) return true;
31741	CurrentSource = L;
31742	return InitBitFieldActivate<PT_Uint64>(S, CodePtr(), A0, A1);
31743	}
31744	bool EvalEmitter::emitInitBitFieldActivateIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
31745	if (!isActive()) return true;
31746	CurrentSource = L;
31747	return InitBitFieldActivate<PT_IntAP>(S, CodePtr(), A0, A1);
31748	}
31749	bool EvalEmitter::emitInitBitFieldActivateIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
31750	if (!isActive()) return true;
31751	CurrentSource = L;
31752	return InitBitFieldActivate<PT_IntAPS>(S, CodePtr(), A0, A1);
31753	}
31754	bool EvalEmitter::emitInitBitFieldActivateBool( uint32_t A0, uint32_t A1, SourceInfo L) {
31755	if (!isActive()) return true;
31756	CurrentSource = L;
31757	return InitBitFieldActivate<PT_Bool>(S, CodePtr(), A0, A1);
31758	}
31759	#endif
31760	#ifdef GET_OPCODE_NAMES
31761	OP_InitElemSint8,
31762	OP_InitElemUint8,
31763	OP_InitElemSint16,
31764	OP_InitElemUint16,
31765	OP_InitElemSint32,
31766	OP_InitElemUint32,
31767	OP_InitElemSint64,
31768	OP_InitElemUint64,
31769	OP_InitElemIntAP,
31770	OP_InitElemIntAPS,
31771	OP_InitElemBool,
31772	OP_InitElemFixedPoint,
31773	OP_InitElemPtr,
31774	OP_InitElemMemberPtr,
31775	OP_InitElemFloat,
31776	#endif
31777	#ifdef GET_INTERPFN_LIST
31778	&Interp_InitElemSint8,
31779	&Interp_InitElemUint8,
31780	&Interp_InitElemSint16,
31781	&Interp_InitElemUint16,
31782	&Interp_InitElemSint32,
31783	&Interp_InitElemUint32,
31784	&Interp_InitElemSint64,
31785	&Interp_InitElemUint64,
31786	&Interp_InitElemIntAP,
31787	&Interp_InitElemIntAPS,
31788	&Interp_InitElemBool,
31789	&Interp_InitElemFixedPoint,
31790	&Interp_InitElemPtr,
31791	&Interp_InitElemMemberPtr,
31792	&Interp_InitElemFloat,
31793	#endif
31794	#ifdef GET_INTERPFN_DISPATCHERS
31795	PRESERVE_NONE
31796	static bool Interp_InitElemSint8(InterpState &S) {
31797	{
31798	CodePtr OpPC = S.PC;
31799	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31800	if (!InitElem<PT_Sint8>(S, OpPC, V0)) return false;
31801	}
31802	#if USE_TAILCALLS
31803	MUSTTAIL return InterpNext(S);
31804	#else
31805	return true;
31806	#endif
31807	}
31808	PRESERVE_NONE
31809	static bool Interp_InitElemUint8(InterpState &S) {
31810	{
31811	CodePtr OpPC = S.PC;
31812	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31813	if (!InitElem<PT_Uint8>(S, OpPC, V0)) return false;
31814	}
31815	#if USE_TAILCALLS
31816	MUSTTAIL return InterpNext(S);
31817	#else
31818	return true;
31819	#endif
31820	}
31821	PRESERVE_NONE
31822	static bool Interp_InitElemSint16(InterpState &S) {
31823	{
31824	CodePtr OpPC = S.PC;
31825	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31826	if (!InitElem<PT_Sint16>(S, OpPC, V0)) return false;
31827	}
31828	#if USE_TAILCALLS
31829	MUSTTAIL return InterpNext(S);
31830	#else
31831	return true;
31832	#endif
31833	}
31834	PRESERVE_NONE
31835	static bool Interp_InitElemUint16(InterpState &S) {
31836	{
31837	CodePtr OpPC = S.PC;
31838	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31839	if (!InitElem<PT_Uint16>(S, OpPC, V0)) return false;
31840	}
31841	#if USE_TAILCALLS
31842	MUSTTAIL return InterpNext(S);
31843	#else
31844	return true;
31845	#endif
31846	}
31847	PRESERVE_NONE
31848	static bool Interp_InitElemSint32(InterpState &S) {
31849	{
31850	CodePtr OpPC = S.PC;
31851	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31852	if (!InitElem<PT_Sint32>(S, OpPC, V0)) return false;
31853	}
31854	#if USE_TAILCALLS
31855	MUSTTAIL return InterpNext(S);
31856	#else
31857	return true;
31858	#endif
31859	}
31860	PRESERVE_NONE
31861	static bool Interp_InitElemUint32(InterpState &S) {
31862	{
31863	CodePtr OpPC = S.PC;
31864	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31865	if (!InitElem<PT_Uint32>(S, OpPC, V0)) return false;
31866	}
31867	#if USE_TAILCALLS
31868	MUSTTAIL return InterpNext(S);
31869	#else
31870	return true;
31871	#endif
31872	}
31873	PRESERVE_NONE
31874	static bool Interp_InitElemSint64(InterpState &S) {
31875	{
31876	CodePtr OpPC = S.PC;
31877	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31878	if (!InitElem<PT_Sint64>(S, OpPC, V0)) return false;
31879	}
31880	#if USE_TAILCALLS
31881	MUSTTAIL return InterpNext(S);
31882	#else
31883	return true;
31884	#endif
31885	}
31886	PRESERVE_NONE
31887	static bool Interp_InitElemUint64(InterpState &S) {
31888	{
31889	CodePtr OpPC = S.PC;
31890	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31891	if (!InitElem<PT_Uint64>(S, OpPC, V0)) return false;
31892	}
31893	#if USE_TAILCALLS
31894	MUSTTAIL return InterpNext(S);
31895	#else
31896	return true;
31897	#endif
31898	}
31899	PRESERVE_NONE
31900	static bool Interp_InitElemIntAP(InterpState &S) {
31901	{
31902	CodePtr OpPC = S.PC;
31903	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31904	if (!InitElem<PT_IntAP>(S, OpPC, V0)) return false;
31905	}
31906	#if USE_TAILCALLS
31907	MUSTTAIL return InterpNext(S);
31908	#else
31909	return true;
31910	#endif
31911	}
31912	PRESERVE_NONE
31913	static bool Interp_InitElemIntAPS(InterpState &S) {
31914	{
31915	CodePtr OpPC = S.PC;
31916	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31917	if (!InitElem<PT_IntAPS>(S, OpPC, V0)) return false;
31918	}
31919	#if USE_TAILCALLS
31920	MUSTTAIL return InterpNext(S);
31921	#else
31922	return true;
31923	#endif
31924	}
31925	PRESERVE_NONE
31926	static bool Interp_InitElemBool(InterpState &S) {
31927	{
31928	CodePtr OpPC = S.PC;
31929	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31930	if (!InitElem<PT_Bool>(S, OpPC, V0)) return false;
31931	}
31932	#if USE_TAILCALLS
31933	MUSTTAIL return InterpNext(S);
31934	#else
31935	return true;
31936	#endif
31937	}
31938	PRESERVE_NONE
31939	static bool Interp_InitElemFixedPoint(InterpState &S) {
31940	{
31941	CodePtr OpPC = S.PC;
31942	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31943	if (!InitElem<PT_FixedPoint>(S, OpPC, V0)) return false;
31944	}
31945	#if USE_TAILCALLS
31946	MUSTTAIL return InterpNext(S);
31947	#else
31948	return true;
31949	#endif
31950	}
31951	PRESERVE_NONE
31952	static bool Interp_InitElemPtr(InterpState &S) {
31953	{
31954	CodePtr OpPC = S.PC;
31955	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31956	if (!InitElem<PT_Ptr>(S, OpPC, V0)) return false;
31957	}
31958	#if USE_TAILCALLS
31959	MUSTTAIL return InterpNext(S);
31960	#else
31961	return true;
31962	#endif
31963	}
31964	PRESERVE_NONE
31965	static bool Interp_InitElemMemberPtr(InterpState &S) {
31966	{
31967	CodePtr OpPC = S.PC;
31968	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31969	if (!InitElem<PT_MemberPtr>(S, OpPC, V0)) return false;
31970	}
31971	#if USE_TAILCALLS
31972	MUSTTAIL return InterpNext(S);
31973	#else
31974	return true;
31975	#endif
31976	}
31977	PRESERVE_NONE
31978	static bool Interp_InitElemFloat(InterpState &S) {
31979	{
31980	CodePtr OpPC = S.PC;
31981	const auto V0 = ReadArg<uint32_t>(S, S.PC);
31982	if (!InitElem<PT_Float>(S, OpPC, V0)) return false;
31983	}
31984	#if USE_TAILCALLS
31985	MUSTTAIL return InterpNext(S);
31986	#else
31987	return true;
31988	#endif
31989	}
31990	#endif
31991	#ifdef GET_DISASM
31992	case OP_InitElemSint8:
31993	Text.Op = PrintName("InitElemSint8");
31994	Text.Args.push_back(printArg<uint32_t>(P, PC));
31995	break;
31996	case OP_InitElemUint8:
31997	Text.Op = PrintName("InitElemUint8");
31998	Text.Args.push_back(printArg<uint32_t>(P, PC));
31999	break;
32000	case OP_InitElemSint16:
32001	Text.Op = PrintName("InitElemSint16");
32002	Text.Args.push_back(printArg<uint32_t>(P, PC));
32003	break;
32004	case OP_InitElemUint16:
32005	Text.Op = PrintName("InitElemUint16");
32006	Text.Args.push_back(printArg<uint32_t>(P, PC));
32007	break;
32008	case OP_InitElemSint32:
32009	Text.Op = PrintName("InitElemSint32");
32010	Text.Args.push_back(printArg<uint32_t>(P, PC));
32011	break;
32012	case OP_InitElemUint32:
32013	Text.Op = PrintName("InitElemUint32");
32014	Text.Args.push_back(printArg<uint32_t>(P, PC));
32015	break;
32016	case OP_InitElemSint64:
32017	Text.Op = PrintName("InitElemSint64");
32018	Text.Args.push_back(printArg<uint32_t>(P, PC));
32019	break;
32020	case OP_InitElemUint64:
32021	Text.Op = PrintName("InitElemUint64");
32022	Text.Args.push_back(printArg<uint32_t>(P, PC));
32023	break;
32024	case OP_InitElemIntAP:
32025	Text.Op = PrintName("InitElemIntAP");
32026	Text.Args.push_back(printArg<uint32_t>(P, PC));
32027	break;
32028	case OP_InitElemIntAPS:
32029	Text.Op = PrintName("InitElemIntAPS");
32030	Text.Args.push_back(printArg<uint32_t>(P, PC));
32031	break;
32032	case OP_InitElemBool:
32033	Text.Op = PrintName("InitElemBool");
32034	Text.Args.push_back(printArg<uint32_t>(P, PC));
32035	break;
32036	case OP_InitElemFixedPoint:
32037	Text.Op = PrintName("InitElemFixedPoint");
32038	Text.Args.push_back(printArg<uint32_t>(P, PC));
32039	break;
32040	case OP_InitElemPtr:
32041	Text.Op = PrintName("InitElemPtr");
32042	Text.Args.push_back(printArg<uint32_t>(P, PC));
32043	break;
32044	case OP_InitElemMemberPtr:
32045	Text.Op = PrintName("InitElemMemberPtr");
32046	Text.Args.push_back(printArg<uint32_t>(P, PC));
32047	break;
32048	case OP_InitElemFloat:
32049	Text.Op = PrintName("InitElemFloat");
32050	Text.Args.push_back(printArg<uint32_t>(P, PC));
32051	break;
32052	#endif
32053	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
32054	bool emitInitElemSint8( uint32_t , SourceInfo);
32055	bool emitInitElemUint8( uint32_t , SourceInfo);
32056	bool emitInitElemSint16( uint32_t , SourceInfo);
32057	bool emitInitElemUint16( uint32_t , SourceInfo);
32058	bool emitInitElemSint32( uint32_t , SourceInfo);
32059	bool emitInitElemUint32( uint32_t , SourceInfo);
32060	bool emitInitElemSint64( uint32_t , SourceInfo);
32061	bool emitInitElemUint64( uint32_t , SourceInfo);
32062	bool emitInitElemIntAP( uint32_t , SourceInfo);
32063	bool emitInitElemIntAPS( uint32_t , SourceInfo);
32064	bool emitInitElemBool( uint32_t , SourceInfo);
32065	bool emitInitElemFixedPoint( uint32_t , SourceInfo);
32066	bool emitInitElemPtr( uint32_t , SourceInfo);
32067	bool emitInitElemMemberPtr( uint32_t , SourceInfo);
32068	bool emitInitElemFloat( uint32_t , SourceInfo);
32069	#endif
32070	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
32071	[[nodiscard]] bool emitInitElem(PrimType, uint32_t, SourceInfo I);
32072	#endif
32073	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
32074	bool
32075	#if defined(GET_EVAL_IMPL)
32076	EvalEmitter
32077	#else
32078	ByteCodeEmitter
32079	#endif
32080	::emitInitElem(PrimType T0, uint32_t A0, SourceInfo I) {
32081	switch (T0) {
32082	case PT_Sint8:
32083	return emitInitElemSint8(A0, I);
32084	case PT_Uint8:
32085	return emitInitElemUint8(A0, I);
32086	case PT_Sint16:
32087	return emitInitElemSint16(A0, I);
32088	case PT_Uint16:
32089	return emitInitElemUint16(A0, I);
32090	case PT_Sint32:
32091	return emitInitElemSint32(A0, I);
32092	case PT_Uint32:
32093	return emitInitElemUint32(A0, I);
32094	case PT_Sint64:
32095	return emitInitElemSint64(A0, I);
32096	case PT_Uint64:
32097	return emitInitElemUint64(A0, I);
32098	case PT_IntAP:
32099	return emitInitElemIntAP(A0, I);
32100	case PT_IntAPS:
32101	return emitInitElemIntAPS(A0, I);
32102	case PT_Bool:
32103	return emitInitElemBool(A0, I);
32104	case PT_FixedPoint:
32105	return emitInitElemFixedPoint(A0, I);
32106	case PT_Ptr:
32107	return emitInitElemPtr(A0, I);
32108	case PT_MemberPtr:
32109	return emitInitElemMemberPtr(A0, I);
32110	case PT_Float:
32111	return emitInitElemFloat(A0, I);
32112	}
32113	llvm_unreachable("invalid enum value");
32114	}
32115	#endif
32116	#ifdef GET_LINK_IMPL
32117	bool ByteCodeEmitter::emitInitElemSint8( uint32_t A0, SourceInfo L) {
32118	return emitOp<uint32_t>(OP_InitElemSint8, A0, L);
32119	}
32120	bool ByteCodeEmitter::emitInitElemUint8( uint32_t A0, SourceInfo L) {
32121	return emitOp<uint32_t>(OP_InitElemUint8, A0, L);
32122	}
32123	bool ByteCodeEmitter::emitInitElemSint16( uint32_t A0, SourceInfo L) {
32124	return emitOp<uint32_t>(OP_InitElemSint16, A0, L);
32125	}
32126	bool ByteCodeEmitter::emitInitElemUint16( uint32_t A0, SourceInfo L) {
32127	return emitOp<uint32_t>(OP_InitElemUint16, A0, L);
32128	}
32129	bool ByteCodeEmitter::emitInitElemSint32( uint32_t A0, SourceInfo L) {
32130	return emitOp<uint32_t>(OP_InitElemSint32, A0, L);
32131	}
32132	bool ByteCodeEmitter::emitInitElemUint32( uint32_t A0, SourceInfo L) {
32133	return emitOp<uint32_t>(OP_InitElemUint32, A0, L);
32134	}
32135	bool ByteCodeEmitter::emitInitElemSint64( uint32_t A0, SourceInfo L) {
32136	return emitOp<uint32_t>(OP_InitElemSint64, A0, L);
32137	}
32138	bool ByteCodeEmitter::emitInitElemUint64( uint32_t A0, SourceInfo L) {
32139	return emitOp<uint32_t>(OP_InitElemUint64, A0, L);
32140	}
32141	bool ByteCodeEmitter::emitInitElemIntAP( uint32_t A0, SourceInfo L) {
32142	return emitOp<uint32_t>(OP_InitElemIntAP, A0, L);
32143	}
32144	bool ByteCodeEmitter::emitInitElemIntAPS( uint32_t A0, SourceInfo L) {
32145	return emitOp<uint32_t>(OP_InitElemIntAPS, A0, L);
32146	}
32147	bool ByteCodeEmitter::emitInitElemBool( uint32_t A0, SourceInfo L) {
32148	return emitOp<uint32_t>(OP_InitElemBool, A0, L);
32149	}
32150	bool ByteCodeEmitter::emitInitElemFixedPoint( uint32_t A0, SourceInfo L) {
32151	return emitOp<uint32_t>(OP_InitElemFixedPoint, A0, L);
32152	}
32153	bool ByteCodeEmitter::emitInitElemPtr( uint32_t A0, SourceInfo L) {
32154	return emitOp<uint32_t>(OP_InitElemPtr, A0, L);
32155	}
32156	bool ByteCodeEmitter::emitInitElemMemberPtr( uint32_t A0, SourceInfo L) {
32157	return emitOp<uint32_t>(OP_InitElemMemberPtr, A0, L);
32158	}
32159	bool ByteCodeEmitter::emitInitElemFloat( uint32_t A0, SourceInfo L) {
32160	return emitOp<uint32_t>(OP_InitElemFloat, A0, L);
32161	}
32162	#endif
32163	#ifdef GET_EVAL_IMPL
32164	bool EvalEmitter::emitInitElemSint8( uint32_t A0, SourceInfo L) {
32165	if (!isActive()) return true;
32166	CurrentSource = L;
32167	return InitElem<PT_Sint8>(S, CodePtr(), A0);
32168	}
32169	bool EvalEmitter::emitInitElemUint8( uint32_t A0, SourceInfo L) {
32170	if (!isActive()) return true;
32171	CurrentSource = L;
32172	return InitElem<PT_Uint8>(S, CodePtr(), A0);
32173	}
32174	bool EvalEmitter::emitInitElemSint16( uint32_t A0, SourceInfo L) {
32175	if (!isActive()) return true;
32176	CurrentSource = L;
32177	return InitElem<PT_Sint16>(S, CodePtr(), A0);
32178	}
32179	bool EvalEmitter::emitInitElemUint16( uint32_t A0, SourceInfo L) {
32180	if (!isActive()) return true;
32181	CurrentSource = L;
32182	return InitElem<PT_Uint16>(S, CodePtr(), A0);
32183	}
32184	bool EvalEmitter::emitInitElemSint32( uint32_t A0, SourceInfo L) {
32185	if (!isActive()) return true;
32186	CurrentSource = L;
32187	return InitElem<PT_Sint32>(S, CodePtr(), A0);
32188	}
32189	bool EvalEmitter::emitInitElemUint32( uint32_t A0, SourceInfo L) {
32190	if (!isActive()) return true;
32191	CurrentSource = L;
32192	return InitElem<PT_Uint32>(S, CodePtr(), A0);
32193	}
32194	bool EvalEmitter::emitInitElemSint64( uint32_t A0, SourceInfo L) {
32195	if (!isActive()) return true;
32196	CurrentSource = L;
32197	return InitElem<PT_Sint64>(S, CodePtr(), A0);
32198	}
32199	bool EvalEmitter::emitInitElemUint64( uint32_t A0, SourceInfo L) {
32200	if (!isActive()) return true;
32201	CurrentSource = L;
32202	return InitElem<PT_Uint64>(S, CodePtr(), A0);
32203	}
32204	bool EvalEmitter::emitInitElemIntAP( uint32_t A0, SourceInfo L) {
32205	if (!isActive()) return true;
32206	CurrentSource = L;
32207	return InitElem<PT_IntAP>(S, CodePtr(), A0);
32208	}
32209	bool EvalEmitter::emitInitElemIntAPS( uint32_t A0, SourceInfo L) {
32210	if (!isActive()) return true;
32211	CurrentSource = L;
32212	return InitElem<PT_IntAPS>(S, CodePtr(), A0);
32213	}
32214	bool EvalEmitter::emitInitElemBool( uint32_t A0, SourceInfo L) {
32215	if (!isActive()) return true;
32216	CurrentSource = L;
32217	return InitElem<PT_Bool>(S, CodePtr(), A0);
32218	}
32219	bool EvalEmitter::emitInitElemFixedPoint( uint32_t A0, SourceInfo L) {
32220	if (!isActive()) return true;
32221	CurrentSource = L;
32222	return InitElem<PT_FixedPoint>(S, CodePtr(), A0);
32223	}
32224	bool EvalEmitter::emitInitElemPtr( uint32_t A0, SourceInfo L) {
32225	if (!isActive()) return true;
32226	CurrentSource = L;
32227	return InitElem<PT_Ptr>(S, CodePtr(), A0);
32228	}
32229	bool EvalEmitter::emitInitElemMemberPtr( uint32_t A0, SourceInfo L) {
32230	if (!isActive()) return true;
32231	CurrentSource = L;
32232	return InitElem<PT_MemberPtr>(S, CodePtr(), A0);
32233	}
32234	bool EvalEmitter::emitInitElemFloat( uint32_t A0, SourceInfo L) {
32235	if (!isActive()) return true;
32236	CurrentSource = L;
32237	return InitElem<PT_Float>(S, CodePtr(), A0);
32238	}
32239	#endif
32240	#ifdef GET_OPCODE_NAMES
32241	OP_InitElemPopSint8,
32242	OP_InitElemPopUint8,
32243	OP_InitElemPopSint16,
32244	OP_InitElemPopUint16,
32245	OP_InitElemPopSint32,
32246	OP_InitElemPopUint32,
32247	OP_InitElemPopSint64,
32248	OP_InitElemPopUint64,
32249	OP_InitElemPopIntAP,
32250	OP_InitElemPopIntAPS,
32251	OP_InitElemPopBool,
32252	OP_InitElemPopFixedPoint,
32253	OP_InitElemPopPtr,
32254	OP_InitElemPopMemberPtr,
32255	OP_InitElemPopFloat,
32256	#endif
32257	#ifdef GET_INTERPFN_LIST
32258	&Interp_InitElemPopSint8,
32259	&Interp_InitElemPopUint8,
32260	&Interp_InitElemPopSint16,
32261	&Interp_InitElemPopUint16,
32262	&Interp_InitElemPopSint32,
32263	&Interp_InitElemPopUint32,
32264	&Interp_InitElemPopSint64,
32265	&Interp_InitElemPopUint64,
32266	&Interp_InitElemPopIntAP,
32267	&Interp_InitElemPopIntAPS,
32268	&Interp_InitElemPopBool,
32269	&Interp_InitElemPopFixedPoint,
32270	&Interp_InitElemPopPtr,
32271	&Interp_InitElemPopMemberPtr,
32272	&Interp_InitElemPopFloat,
32273	#endif
32274	#ifdef GET_INTERPFN_DISPATCHERS
32275	PRESERVE_NONE
32276	static bool Interp_InitElemPopSint8(InterpState &S) {
32277	{
32278	CodePtr OpPC = S.PC;
32279	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32280	if (!InitElemPop<PT_Sint8>(S, OpPC, V0)) return false;
32281	}
32282	#if USE_TAILCALLS
32283	MUSTTAIL return InterpNext(S);
32284	#else
32285	return true;
32286	#endif
32287	}
32288	PRESERVE_NONE
32289	static bool Interp_InitElemPopUint8(InterpState &S) {
32290	{
32291	CodePtr OpPC = S.PC;
32292	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32293	if (!InitElemPop<PT_Uint8>(S, OpPC, V0)) return false;
32294	}
32295	#if USE_TAILCALLS
32296	MUSTTAIL return InterpNext(S);
32297	#else
32298	return true;
32299	#endif
32300	}
32301	PRESERVE_NONE
32302	static bool Interp_InitElemPopSint16(InterpState &S) {
32303	{
32304	CodePtr OpPC = S.PC;
32305	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32306	if (!InitElemPop<PT_Sint16>(S, OpPC, V0)) return false;
32307	}
32308	#if USE_TAILCALLS
32309	MUSTTAIL return InterpNext(S);
32310	#else
32311	return true;
32312	#endif
32313	}
32314	PRESERVE_NONE
32315	static bool Interp_InitElemPopUint16(InterpState &S) {
32316	{
32317	CodePtr OpPC = S.PC;
32318	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32319	if (!InitElemPop<PT_Uint16>(S, OpPC, V0)) return false;
32320	}
32321	#if USE_TAILCALLS
32322	MUSTTAIL return InterpNext(S);
32323	#else
32324	return true;
32325	#endif
32326	}
32327	PRESERVE_NONE
32328	static bool Interp_InitElemPopSint32(InterpState &S) {
32329	{
32330	CodePtr OpPC = S.PC;
32331	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32332	if (!InitElemPop<PT_Sint32>(S, OpPC, V0)) return false;
32333	}
32334	#if USE_TAILCALLS
32335	MUSTTAIL return InterpNext(S);
32336	#else
32337	return true;
32338	#endif
32339	}
32340	PRESERVE_NONE
32341	static bool Interp_InitElemPopUint32(InterpState &S) {
32342	{
32343	CodePtr OpPC = S.PC;
32344	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32345	if (!InitElemPop<PT_Uint32>(S, OpPC, V0)) return false;
32346	}
32347	#if USE_TAILCALLS
32348	MUSTTAIL return InterpNext(S);
32349	#else
32350	return true;
32351	#endif
32352	}
32353	PRESERVE_NONE
32354	static bool Interp_InitElemPopSint64(InterpState &S) {
32355	{
32356	CodePtr OpPC = S.PC;
32357	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32358	if (!InitElemPop<PT_Sint64>(S, OpPC, V0)) return false;
32359	}
32360	#if USE_TAILCALLS
32361	MUSTTAIL return InterpNext(S);
32362	#else
32363	return true;
32364	#endif
32365	}
32366	PRESERVE_NONE
32367	static bool Interp_InitElemPopUint64(InterpState &S) {
32368	{
32369	CodePtr OpPC = S.PC;
32370	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32371	if (!InitElemPop<PT_Uint64>(S, OpPC, V0)) return false;
32372	}
32373	#if USE_TAILCALLS
32374	MUSTTAIL return InterpNext(S);
32375	#else
32376	return true;
32377	#endif
32378	}
32379	PRESERVE_NONE
32380	static bool Interp_InitElemPopIntAP(InterpState &S) {
32381	{
32382	CodePtr OpPC = S.PC;
32383	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32384	if (!InitElemPop<PT_IntAP>(S, OpPC, V0)) return false;
32385	}
32386	#if USE_TAILCALLS
32387	MUSTTAIL return InterpNext(S);
32388	#else
32389	return true;
32390	#endif
32391	}
32392	PRESERVE_NONE
32393	static bool Interp_InitElemPopIntAPS(InterpState &S) {
32394	{
32395	CodePtr OpPC = S.PC;
32396	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32397	if (!InitElemPop<PT_IntAPS>(S, OpPC, V0)) return false;
32398	}
32399	#if USE_TAILCALLS
32400	MUSTTAIL return InterpNext(S);
32401	#else
32402	return true;
32403	#endif
32404	}
32405	PRESERVE_NONE
32406	static bool Interp_InitElemPopBool(InterpState &S) {
32407	{
32408	CodePtr OpPC = S.PC;
32409	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32410	if (!InitElemPop<PT_Bool>(S, OpPC, V0)) return false;
32411	}
32412	#if USE_TAILCALLS
32413	MUSTTAIL return InterpNext(S);
32414	#else
32415	return true;
32416	#endif
32417	}
32418	PRESERVE_NONE
32419	static bool Interp_InitElemPopFixedPoint(InterpState &S) {
32420	{
32421	CodePtr OpPC = S.PC;
32422	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32423	if (!InitElemPop<PT_FixedPoint>(S, OpPC, V0)) return false;
32424	}
32425	#if USE_TAILCALLS
32426	MUSTTAIL return InterpNext(S);
32427	#else
32428	return true;
32429	#endif
32430	}
32431	PRESERVE_NONE
32432	static bool Interp_InitElemPopPtr(InterpState &S) {
32433	{
32434	CodePtr OpPC = S.PC;
32435	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32436	if (!InitElemPop<PT_Ptr>(S, OpPC, V0)) return false;
32437	}
32438	#if USE_TAILCALLS
32439	MUSTTAIL return InterpNext(S);
32440	#else
32441	return true;
32442	#endif
32443	}
32444	PRESERVE_NONE
32445	static bool Interp_InitElemPopMemberPtr(InterpState &S) {
32446	{
32447	CodePtr OpPC = S.PC;
32448	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32449	if (!InitElemPop<PT_MemberPtr>(S, OpPC, V0)) return false;
32450	}
32451	#if USE_TAILCALLS
32452	MUSTTAIL return InterpNext(S);
32453	#else
32454	return true;
32455	#endif
32456	}
32457	PRESERVE_NONE
32458	static bool Interp_InitElemPopFloat(InterpState &S) {
32459	{
32460	CodePtr OpPC = S.PC;
32461	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32462	if (!InitElemPop<PT_Float>(S, OpPC, V0)) return false;
32463	}
32464	#if USE_TAILCALLS
32465	MUSTTAIL return InterpNext(S);
32466	#else
32467	return true;
32468	#endif
32469	}
32470	#endif
32471	#ifdef GET_DISASM
32472	case OP_InitElemPopSint8:
32473	Text.Op = PrintName("InitElemPopSint8");
32474	Text.Args.push_back(printArg<uint32_t>(P, PC));
32475	break;
32476	case OP_InitElemPopUint8:
32477	Text.Op = PrintName("InitElemPopUint8");
32478	Text.Args.push_back(printArg<uint32_t>(P, PC));
32479	break;
32480	case OP_InitElemPopSint16:
32481	Text.Op = PrintName("InitElemPopSint16");
32482	Text.Args.push_back(printArg<uint32_t>(P, PC));
32483	break;
32484	case OP_InitElemPopUint16:
32485	Text.Op = PrintName("InitElemPopUint16");
32486	Text.Args.push_back(printArg<uint32_t>(P, PC));
32487	break;
32488	case OP_InitElemPopSint32:
32489	Text.Op = PrintName("InitElemPopSint32");
32490	Text.Args.push_back(printArg<uint32_t>(P, PC));
32491	break;
32492	case OP_InitElemPopUint32:
32493	Text.Op = PrintName("InitElemPopUint32");
32494	Text.Args.push_back(printArg<uint32_t>(P, PC));
32495	break;
32496	case OP_InitElemPopSint64:
32497	Text.Op = PrintName("InitElemPopSint64");
32498	Text.Args.push_back(printArg<uint32_t>(P, PC));
32499	break;
32500	case OP_InitElemPopUint64:
32501	Text.Op = PrintName("InitElemPopUint64");
32502	Text.Args.push_back(printArg<uint32_t>(P, PC));
32503	break;
32504	case OP_InitElemPopIntAP:
32505	Text.Op = PrintName("InitElemPopIntAP");
32506	Text.Args.push_back(printArg<uint32_t>(P, PC));
32507	break;
32508	case OP_InitElemPopIntAPS:
32509	Text.Op = PrintName("InitElemPopIntAPS");
32510	Text.Args.push_back(printArg<uint32_t>(P, PC));
32511	break;
32512	case OP_InitElemPopBool:
32513	Text.Op = PrintName("InitElemPopBool");
32514	Text.Args.push_back(printArg<uint32_t>(P, PC));
32515	break;
32516	case OP_InitElemPopFixedPoint:
32517	Text.Op = PrintName("InitElemPopFixedPoint");
32518	Text.Args.push_back(printArg<uint32_t>(P, PC));
32519	break;
32520	case OP_InitElemPopPtr:
32521	Text.Op = PrintName("InitElemPopPtr");
32522	Text.Args.push_back(printArg<uint32_t>(P, PC));
32523	break;
32524	case OP_InitElemPopMemberPtr:
32525	Text.Op = PrintName("InitElemPopMemberPtr");
32526	Text.Args.push_back(printArg<uint32_t>(P, PC));
32527	break;
32528	case OP_InitElemPopFloat:
32529	Text.Op = PrintName("InitElemPopFloat");
32530	Text.Args.push_back(printArg<uint32_t>(P, PC));
32531	break;
32532	#endif
32533	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
32534	bool emitInitElemPopSint8( uint32_t , SourceInfo);
32535	bool emitInitElemPopUint8( uint32_t , SourceInfo);
32536	bool emitInitElemPopSint16( uint32_t , SourceInfo);
32537	bool emitInitElemPopUint16( uint32_t , SourceInfo);
32538	bool emitInitElemPopSint32( uint32_t , SourceInfo);
32539	bool emitInitElemPopUint32( uint32_t , SourceInfo);
32540	bool emitInitElemPopSint64( uint32_t , SourceInfo);
32541	bool emitInitElemPopUint64( uint32_t , SourceInfo);
32542	bool emitInitElemPopIntAP( uint32_t , SourceInfo);
32543	bool emitInitElemPopIntAPS( uint32_t , SourceInfo);
32544	bool emitInitElemPopBool( uint32_t , SourceInfo);
32545	bool emitInitElemPopFixedPoint( uint32_t , SourceInfo);
32546	bool emitInitElemPopPtr( uint32_t , SourceInfo);
32547	bool emitInitElemPopMemberPtr( uint32_t , SourceInfo);
32548	bool emitInitElemPopFloat( uint32_t , SourceInfo);
32549	#endif
32550	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
32551	[[nodiscard]] bool emitInitElemPop(PrimType, uint32_t, SourceInfo I);
32552	#endif
32553	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
32554	bool
32555	#if defined(GET_EVAL_IMPL)
32556	EvalEmitter
32557	#else
32558	ByteCodeEmitter
32559	#endif
32560	::emitInitElemPop(PrimType T0, uint32_t A0, SourceInfo I) {
32561	switch (T0) {
32562	case PT_Sint8:
32563	return emitInitElemPopSint8(A0, I);
32564	case PT_Uint8:
32565	return emitInitElemPopUint8(A0, I);
32566	case PT_Sint16:
32567	return emitInitElemPopSint16(A0, I);
32568	case PT_Uint16:
32569	return emitInitElemPopUint16(A0, I);
32570	case PT_Sint32:
32571	return emitInitElemPopSint32(A0, I);
32572	case PT_Uint32:
32573	return emitInitElemPopUint32(A0, I);
32574	case PT_Sint64:
32575	return emitInitElemPopSint64(A0, I);
32576	case PT_Uint64:
32577	return emitInitElemPopUint64(A0, I);
32578	case PT_IntAP:
32579	return emitInitElemPopIntAP(A0, I);
32580	case PT_IntAPS:
32581	return emitInitElemPopIntAPS(A0, I);
32582	case PT_Bool:
32583	return emitInitElemPopBool(A0, I);
32584	case PT_FixedPoint:
32585	return emitInitElemPopFixedPoint(A0, I);
32586	case PT_Ptr:
32587	return emitInitElemPopPtr(A0, I);
32588	case PT_MemberPtr:
32589	return emitInitElemPopMemberPtr(A0, I);
32590	case PT_Float:
32591	return emitInitElemPopFloat(A0, I);
32592	}
32593	llvm_unreachable("invalid enum value");
32594	}
32595	#endif
32596	#ifdef GET_LINK_IMPL
32597	bool ByteCodeEmitter::emitInitElemPopSint8( uint32_t A0, SourceInfo L) {
32598	return emitOp<uint32_t>(OP_InitElemPopSint8, A0, L);
32599	}
32600	bool ByteCodeEmitter::emitInitElemPopUint8( uint32_t A0, SourceInfo L) {
32601	return emitOp<uint32_t>(OP_InitElemPopUint8, A0, L);
32602	}
32603	bool ByteCodeEmitter::emitInitElemPopSint16( uint32_t A0, SourceInfo L) {
32604	return emitOp<uint32_t>(OP_InitElemPopSint16, A0, L);
32605	}
32606	bool ByteCodeEmitter::emitInitElemPopUint16( uint32_t A0, SourceInfo L) {
32607	return emitOp<uint32_t>(OP_InitElemPopUint16, A0, L);
32608	}
32609	bool ByteCodeEmitter::emitInitElemPopSint32( uint32_t A0, SourceInfo L) {
32610	return emitOp<uint32_t>(OP_InitElemPopSint32, A0, L);
32611	}
32612	bool ByteCodeEmitter::emitInitElemPopUint32( uint32_t A0, SourceInfo L) {
32613	return emitOp<uint32_t>(OP_InitElemPopUint32, A0, L);
32614	}
32615	bool ByteCodeEmitter::emitInitElemPopSint64( uint32_t A0, SourceInfo L) {
32616	return emitOp<uint32_t>(OP_InitElemPopSint64, A0, L);
32617	}
32618	bool ByteCodeEmitter::emitInitElemPopUint64( uint32_t A0, SourceInfo L) {
32619	return emitOp<uint32_t>(OP_InitElemPopUint64, A0, L);
32620	}
32621	bool ByteCodeEmitter::emitInitElemPopIntAP( uint32_t A0, SourceInfo L) {
32622	return emitOp<uint32_t>(OP_InitElemPopIntAP, A0, L);
32623	}
32624	bool ByteCodeEmitter::emitInitElemPopIntAPS( uint32_t A0, SourceInfo L) {
32625	return emitOp<uint32_t>(OP_InitElemPopIntAPS, A0, L);
32626	}
32627	bool ByteCodeEmitter::emitInitElemPopBool( uint32_t A0, SourceInfo L) {
32628	return emitOp<uint32_t>(OP_InitElemPopBool, A0, L);
32629	}
32630	bool ByteCodeEmitter::emitInitElemPopFixedPoint( uint32_t A0, SourceInfo L) {
32631	return emitOp<uint32_t>(OP_InitElemPopFixedPoint, A0, L);
32632	}
32633	bool ByteCodeEmitter::emitInitElemPopPtr( uint32_t A0, SourceInfo L) {
32634	return emitOp<uint32_t>(OP_InitElemPopPtr, A0, L);
32635	}
32636	bool ByteCodeEmitter::emitInitElemPopMemberPtr( uint32_t A0, SourceInfo L) {
32637	return emitOp<uint32_t>(OP_InitElemPopMemberPtr, A0, L);
32638	}
32639	bool ByteCodeEmitter::emitInitElemPopFloat( uint32_t A0, SourceInfo L) {
32640	return emitOp<uint32_t>(OP_InitElemPopFloat, A0, L);
32641	}
32642	#endif
32643	#ifdef GET_EVAL_IMPL
32644	bool EvalEmitter::emitInitElemPopSint8( uint32_t A0, SourceInfo L) {
32645	if (!isActive()) return true;
32646	CurrentSource = L;
32647	return InitElemPop<PT_Sint8>(S, CodePtr(), A0);
32648	}
32649	bool EvalEmitter::emitInitElemPopUint8( uint32_t A0, SourceInfo L) {
32650	if (!isActive()) return true;
32651	CurrentSource = L;
32652	return InitElemPop<PT_Uint8>(S, CodePtr(), A0);
32653	}
32654	bool EvalEmitter::emitInitElemPopSint16( uint32_t A0, SourceInfo L) {
32655	if (!isActive()) return true;
32656	CurrentSource = L;
32657	return InitElemPop<PT_Sint16>(S, CodePtr(), A0);
32658	}
32659	bool EvalEmitter::emitInitElemPopUint16( uint32_t A0, SourceInfo L) {
32660	if (!isActive()) return true;
32661	CurrentSource = L;
32662	return InitElemPop<PT_Uint16>(S, CodePtr(), A0);
32663	}
32664	bool EvalEmitter::emitInitElemPopSint32( uint32_t A0, SourceInfo L) {
32665	if (!isActive()) return true;
32666	CurrentSource = L;
32667	return InitElemPop<PT_Sint32>(S, CodePtr(), A0);
32668	}
32669	bool EvalEmitter::emitInitElemPopUint32( uint32_t A0, SourceInfo L) {
32670	if (!isActive()) return true;
32671	CurrentSource = L;
32672	return InitElemPop<PT_Uint32>(S, CodePtr(), A0);
32673	}
32674	bool EvalEmitter::emitInitElemPopSint64( uint32_t A0, SourceInfo L) {
32675	if (!isActive()) return true;
32676	CurrentSource = L;
32677	return InitElemPop<PT_Sint64>(S, CodePtr(), A0);
32678	}
32679	bool EvalEmitter::emitInitElemPopUint64( uint32_t A0, SourceInfo L) {
32680	if (!isActive()) return true;
32681	CurrentSource = L;
32682	return InitElemPop<PT_Uint64>(S, CodePtr(), A0);
32683	}
32684	bool EvalEmitter::emitInitElemPopIntAP( uint32_t A0, SourceInfo L) {
32685	if (!isActive()) return true;
32686	CurrentSource = L;
32687	return InitElemPop<PT_IntAP>(S, CodePtr(), A0);
32688	}
32689	bool EvalEmitter::emitInitElemPopIntAPS( uint32_t A0, SourceInfo L) {
32690	if (!isActive()) return true;
32691	CurrentSource = L;
32692	return InitElemPop<PT_IntAPS>(S, CodePtr(), A0);
32693	}
32694	bool EvalEmitter::emitInitElemPopBool( uint32_t A0, SourceInfo L) {
32695	if (!isActive()) return true;
32696	CurrentSource = L;
32697	return InitElemPop<PT_Bool>(S, CodePtr(), A0);
32698	}
32699	bool EvalEmitter::emitInitElemPopFixedPoint( uint32_t A0, SourceInfo L) {
32700	if (!isActive()) return true;
32701	CurrentSource = L;
32702	return InitElemPop<PT_FixedPoint>(S, CodePtr(), A0);
32703	}
32704	bool EvalEmitter::emitInitElemPopPtr( uint32_t A0, SourceInfo L) {
32705	if (!isActive()) return true;
32706	CurrentSource = L;
32707	return InitElemPop<PT_Ptr>(S, CodePtr(), A0);
32708	}
32709	bool EvalEmitter::emitInitElemPopMemberPtr( uint32_t A0, SourceInfo L) {
32710	if (!isActive()) return true;
32711	CurrentSource = L;
32712	return InitElemPop<PT_MemberPtr>(S, CodePtr(), A0);
32713	}
32714	bool EvalEmitter::emitInitElemPopFloat( uint32_t A0, SourceInfo L) {
32715	if (!isActive()) return true;
32716	CurrentSource = L;
32717	return InitElemPop<PT_Float>(S, CodePtr(), A0);
32718	}
32719	#endif
32720	#ifdef GET_OPCODE_NAMES
32721	OP_InitFieldSint8,
32722	OP_InitFieldUint8,
32723	OP_InitFieldSint16,
32724	OP_InitFieldUint16,
32725	OP_InitFieldSint32,
32726	OP_InitFieldUint32,
32727	OP_InitFieldSint64,
32728	OP_InitFieldUint64,
32729	OP_InitFieldIntAP,
32730	OP_InitFieldIntAPS,
32731	OP_InitFieldBool,
32732	OP_InitFieldFixedPoint,
32733	OP_InitFieldPtr,
32734	OP_InitFieldMemberPtr,
32735	OP_InitFieldFloat,
32736	#endif
32737	#ifdef GET_INTERPFN_LIST
32738	&Interp_InitFieldSint8,
32739	&Interp_InitFieldUint8,
32740	&Interp_InitFieldSint16,
32741	&Interp_InitFieldUint16,
32742	&Interp_InitFieldSint32,
32743	&Interp_InitFieldUint32,
32744	&Interp_InitFieldSint64,
32745	&Interp_InitFieldUint64,
32746	&Interp_InitFieldIntAP,
32747	&Interp_InitFieldIntAPS,
32748	&Interp_InitFieldBool,
32749	&Interp_InitFieldFixedPoint,
32750	&Interp_InitFieldPtr,
32751	&Interp_InitFieldMemberPtr,
32752	&Interp_InitFieldFloat,
32753	#endif
32754	#ifdef GET_INTERPFN_DISPATCHERS
32755	PRESERVE_NONE
32756	static bool Interp_InitFieldSint8(InterpState &S) {
32757	{
32758	CodePtr OpPC = S.PC;
32759	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32760	if (!InitField<PT_Sint8>(S, OpPC, V0)) return false;
32761	}
32762	#if USE_TAILCALLS
32763	MUSTTAIL return InterpNext(S);
32764	#else
32765	return true;
32766	#endif
32767	}
32768	PRESERVE_NONE
32769	static bool Interp_InitFieldUint8(InterpState &S) {
32770	{
32771	CodePtr OpPC = S.PC;
32772	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32773	if (!InitField<PT_Uint8>(S, OpPC, V0)) return false;
32774	}
32775	#if USE_TAILCALLS
32776	MUSTTAIL return InterpNext(S);
32777	#else
32778	return true;
32779	#endif
32780	}
32781	PRESERVE_NONE
32782	static bool Interp_InitFieldSint16(InterpState &S) {
32783	{
32784	CodePtr OpPC = S.PC;
32785	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32786	if (!InitField<PT_Sint16>(S, OpPC, V0)) return false;
32787	}
32788	#if USE_TAILCALLS
32789	MUSTTAIL return InterpNext(S);
32790	#else
32791	return true;
32792	#endif
32793	}
32794	PRESERVE_NONE
32795	static bool Interp_InitFieldUint16(InterpState &S) {
32796	{
32797	CodePtr OpPC = S.PC;
32798	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32799	if (!InitField<PT_Uint16>(S, OpPC, V0)) return false;
32800	}
32801	#if USE_TAILCALLS
32802	MUSTTAIL return InterpNext(S);
32803	#else
32804	return true;
32805	#endif
32806	}
32807	PRESERVE_NONE
32808	static bool Interp_InitFieldSint32(InterpState &S) {
32809	{
32810	CodePtr OpPC = S.PC;
32811	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32812	if (!InitField<PT_Sint32>(S, OpPC, V0)) return false;
32813	}
32814	#if USE_TAILCALLS
32815	MUSTTAIL return InterpNext(S);
32816	#else
32817	return true;
32818	#endif
32819	}
32820	PRESERVE_NONE
32821	static bool Interp_InitFieldUint32(InterpState &S) {
32822	{
32823	CodePtr OpPC = S.PC;
32824	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32825	if (!InitField<PT_Uint32>(S, OpPC, V0)) return false;
32826	}
32827	#if USE_TAILCALLS
32828	MUSTTAIL return InterpNext(S);
32829	#else
32830	return true;
32831	#endif
32832	}
32833	PRESERVE_NONE
32834	static bool Interp_InitFieldSint64(InterpState &S) {
32835	{
32836	CodePtr OpPC = S.PC;
32837	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32838	if (!InitField<PT_Sint64>(S, OpPC, V0)) return false;
32839	}
32840	#if USE_TAILCALLS
32841	MUSTTAIL return InterpNext(S);
32842	#else
32843	return true;
32844	#endif
32845	}
32846	PRESERVE_NONE
32847	static bool Interp_InitFieldUint64(InterpState &S) {
32848	{
32849	CodePtr OpPC = S.PC;
32850	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32851	if (!InitField<PT_Uint64>(S, OpPC, V0)) return false;
32852	}
32853	#if USE_TAILCALLS
32854	MUSTTAIL return InterpNext(S);
32855	#else
32856	return true;
32857	#endif
32858	}
32859	PRESERVE_NONE
32860	static bool Interp_InitFieldIntAP(InterpState &S) {
32861	{
32862	CodePtr OpPC = S.PC;
32863	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32864	if (!InitField<PT_IntAP>(S, OpPC, V0)) return false;
32865	}
32866	#if USE_TAILCALLS
32867	MUSTTAIL return InterpNext(S);
32868	#else
32869	return true;
32870	#endif
32871	}
32872	PRESERVE_NONE
32873	static bool Interp_InitFieldIntAPS(InterpState &S) {
32874	{
32875	CodePtr OpPC = S.PC;
32876	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32877	if (!InitField<PT_IntAPS>(S, OpPC, V0)) return false;
32878	}
32879	#if USE_TAILCALLS
32880	MUSTTAIL return InterpNext(S);
32881	#else
32882	return true;
32883	#endif
32884	}
32885	PRESERVE_NONE
32886	static bool Interp_InitFieldBool(InterpState &S) {
32887	{
32888	CodePtr OpPC = S.PC;
32889	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32890	if (!InitField<PT_Bool>(S, OpPC, V0)) return false;
32891	}
32892	#if USE_TAILCALLS
32893	MUSTTAIL return InterpNext(S);
32894	#else
32895	return true;
32896	#endif
32897	}
32898	PRESERVE_NONE
32899	static bool Interp_InitFieldFixedPoint(InterpState &S) {
32900	{
32901	CodePtr OpPC = S.PC;
32902	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32903	if (!InitField<PT_FixedPoint>(S, OpPC, V0)) return false;
32904	}
32905	#if USE_TAILCALLS
32906	MUSTTAIL return InterpNext(S);
32907	#else
32908	return true;
32909	#endif
32910	}
32911	PRESERVE_NONE
32912	static bool Interp_InitFieldPtr(InterpState &S) {
32913	{
32914	CodePtr OpPC = S.PC;
32915	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32916	if (!InitField<PT_Ptr>(S, OpPC, V0)) return false;
32917	}
32918	#if USE_TAILCALLS
32919	MUSTTAIL return InterpNext(S);
32920	#else
32921	return true;
32922	#endif
32923	}
32924	PRESERVE_NONE
32925	static bool Interp_InitFieldMemberPtr(InterpState &S) {
32926	{
32927	CodePtr OpPC = S.PC;
32928	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32929	if (!InitField<PT_MemberPtr>(S, OpPC, V0)) return false;
32930	}
32931	#if USE_TAILCALLS
32932	MUSTTAIL return InterpNext(S);
32933	#else
32934	return true;
32935	#endif
32936	}
32937	PRESERVE_NONE
32938	static bool Interp_InitFieldFloat(InterpState &S) {
32939	{
32940	CodePtr OpPC = S.PC;
32941	const auto V0 = ReadArg<uint32_t>(S, S.PC);
32942	if (!InitField<PT_Float>(S, OpPC, V0)) return false;
32943	}
32944	#if USE_TAILCALLS
32945	MUSTTAIL return InterpNext(S);
32946	#else
32947	return true;
32948	#endif
32949	}
32950	#endif
32951	#ifdef GET_DISASM
32952	case OP_InitFieldSint8:
32953	Text.Op = PrintName("InitFieldSint8");
32954	Text.Args.push_back(printArg<uint32_t>(P, PC));
32955	break;
32956	case OP_InitFieldUint8:
32957	Text.Op = PrintName("InitFieldUint8");
32958	Text.Args.push_back(printArg<uint32_t>(P, PC));
32959	break;
32960	case OP_InitFieldSint16:
32961	Text.Op = PrintName("InitFieldSint16");
32962	Text.Args.push_back(printArg<uint32_t>(P, PC));
32963	break;
32964	case OP_InitFieldUint16:
32965	Text.Op = PrintName("InitFieldUint16");
32966	Text.Args.push_back(printArg<uint32_t>(P, PC));
32967	break;
32968	case OP_InitFieldSint32:
32969	Text.Op = PrintName("InitFieldSint32");
32970	Text.Args.push_back(printArg<uint32_t>(P, PC));
32971	break;
32972	case OP_InitFieldUint32:
32973	Text.Op = PrintName("InitFieldUint32");
32974	Text.Args.push_back(printArg<uint32_t>(P, PC));
32975	break;
32976	case OP_InitFieldSint64:
32977	Text.Op = PrintName("InitFieldSint64");
32978	Text.Args.push_back(printArg<uint32_t>(P, PC));
32979	break;
32980	case OP_InitFieldUint64:
32981	Text.Op = PrintName("InitFieldUint64");
32982	Text.Args.push_back(printArg<uint32_t>(P, PC));
32983	break;
32984	case OP_InitFieldIntAP:
32985	Text.Op = PrintName("InitFieldIntAP");
32986	Text.Args.push_back(printArg<uint32_t>(P, PC));
32987	break;
32988	case OP_InitFieldIntAPS:
32989	Text.Op = PrintName("InitFieldIntAPS");
32990	Text.Args.push_back(printArg<uint32_t>(P, PC));
32991	break;
32992	case OP_InitFieldBool:
32993	Text.Op = PrintName("InitFieldBool");
32994	Text.Args.push_back(printArg<uint32_t>(P, PC));
32995	break;
32996	case OP_InitFieldFixedPoint:
32997	Text.Op = PrintName("InitFieldFixedPoint");
32998	Text.Args.push_back(printArg<uint32_t>(P, PC));
32999	break;
33000	case OP_InitFieldPtr:
33001	Text.Op = PrintName("InitFieldPtr");
33002	Text.Args.push_back(printArg<uint32_t>(P, PC));
33003	break;
33004	case OP_InitFieldMemberPtr:
33005	Text.Op = PrintName("InitFieldMemberPtr");
33006	Text.Args.push_back(printArg<uint32_t>(P, PC));
33007	break;
33008	case OP_InitFieldFloat:
33009	Text.Op = PrintName("InitFieldFloat");
33010	Text.Args.push_back(printArg<uint32_t>(P, PC));
33011	break;
33012	#endif
33013	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33014	bool emitInitFieldSint8( uint32_t , SourceInfo);
33015	bool emitInitFieldUint8( uint32_t , SourceInfo);
33016	bool emitInitFieldSint16( uint32_t , SourceInfo);
33017	bool emitInitFieldUint16( uint32_t , SourceInfo);
33018	bool emitInitFieldSint32( uint32_t , SourceInfo);
33019	bool emitInitFieldUint32( uint32_t , SourceInfo);
33020	bool emitInitFieldSint64( uint32_t , SourceInfo);
33021	bool emitInitFieldUint64( uint32_t , SourceInfo);
33022	bool emitInitFieldIntAP( uint32_t , SourceInfo);
33023	bool emitInitFieldIntAPS( uint32_t , SourceInfo);
33024	bool emitInitFieldBool( uint32_t , SourceInfo);
33025	bool emitInitFieldFixedPoint( uint32_t , SourceInfo);
33026	bool emitInitFieldPtr( uint32_t , SourceInfo);
33027	bool emitInitFieldMemberPtr( uint32_t , SourceInfo);
33028	bool emitInitFieldFloat( uint32_t , SourceInfo);
33029	#endif
33030	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33031	[[nodiscard]] bool emitInitField(PrimType, uint32_t, SourceInfo I);
33032	#endif
33033	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
33034	bool
33035	#if defined(GET_EVAL_IMPL)
33036	EvalEmitter
33037	#else
33038	ByteCodeEmitter
33039	#endif
33040	::emitInitField(PrimType T0, uint32_t A0, SourceInfo I) {
33041	switch (T0) {
33042	case PT_Sint8:
33043	return emitInitFieldSint8(A0, I);
33044	case PT_Uint8:
33045	return emitInitFieldUint8(A0, I);
33046	case PT_Sint16:
33047	return emitInitFieldSint16(A0, I);
33048	case PT_Uint16:
33049	return emitInitFieldUint16(A0, I);
33050	case PT_Sint32:
33051	return emitInitFieldSint32(A0, I);
33052	case PT_Uint32:
33053	return emitInitFieldUint32(A0, I);
33054	case PT_Sint64:
33055	return emitInitFieldSint64(A0, I);
33056	case PT_Uint64:
33057	return emitInitFieldUint64(A0, I);
33058	case PT_IntAP:
33059	return emitInitFieldIntAP(A0, I);
33060	case PT_IntAPS:
33061	return emitInitFieldIntAPS(A0, I);
33062	case PT_Bool:
33063	return emitInitFieldBool(A0, I);
33064	case PT_FixedPoint:
33065	return emitInitFieldFixedPoint(A0, I);
33066	case PT_Ptr:
33067	return emitInitFieldPtr(A0, I);
33068	case PT_MemberPtr:
33069	return emitInitFieldMemberPtr(A0, I);
33070	case PT_Float:
33071	return emitInitFieldFloat(A0, I);
33072	}
33073	llvm_unreachable("invalid enum value");
33074	}
33075	#endif
33076	#ifdef GET_LINK_IMPL
33077	bool ByteCodeEmitter::emitInitFieldSint8( uint32_t A0, SourceInfo L) {
33078	return emitOp<uint32_t>(OP_InitFieldSint8, A0, L);
33079	}
33080	bool ByteCodeEmitter::emitInitFieldUint8( uint32_t A0, SourceInfo L) {
33081	return emitOp<uint32_t>(OP_InitFieldUint8, A0, L);
33082	}
33083	bool ByteCodeEmitter::emitInitFieldSint16( uint32_t A0, SourceInfo L) {
33084	return emitOp<uint32_t>(OP_InitFieldSint16, A0, L);
33085	}
33086	bool ByteCodeEmitter::emitInitFieldUint16( uint32_t A0, SourceInfo L) {
33087	return emitOp<uint32_t>(OP_InitFieldUint16, A0, L);
33088	}
33089	bool ByteCodeEmitter::emitInitFieldSint32( uint32_t A0, SourceInfo L) {
33090	return emitOp<uint32_t>(OP_InitFieldSint32, A0, L);
33091	}
33092	bool ByteCodeEmitter::emitInitFieldUint32( uint32_t A0, SourceInfo L) {
33093	return emitOp<uint32_t>(OP_InitFieldUint32, A0, L);
33094	}
33095	bool ByteCodeEmitter::emitInitFieldSint64( uint32_t A0, SourceInfo L) {
33096	return emitOp<uint32_t>(OP_InitFieldSint64, A0, L);
33097	}
33098	bool ByteCodeEmitter::emitInitFieldUint64( uint32_t A0, SourceInfo L) {
33099	return emitOp<uint32_t>(OP_InitFieldUint64, A0, L);
33100	}
33101	bool ByteCodeEmitter::emitInitFieldIntAP( uint32_t A0, SourceInfo L) {
33102	return emitOp<uint32_t>(OP_InitFieldIntAP, A0, L);
33103	}
33104	bool ByteCodeEmitter::emitInitFieldIntAPS( uint32_t A0, SourceInfo L) {
33105	return emitOp<uint32_t>(OP_InitFieldIntAPS, A0, L);
33106	}
33107	bool ByteCodeEmitter::emitInitFieldBool( uint32_t A0, SourceInfo L) {
33108	return emitOp<uint32_t>(OP_InitFieldBool, A0, L);
33109	}
33110	bool ByteCodeEmitter::emitInitFieldFixedPoint( uint32_t A0, SourceInfo L) {
33111	return emitOp<uint32_t>(OP_InitFieldFixedPoint, A0, L);
33112	}
33113	bool ByteCodeEmitter::emitInitFieldPtr( uint32_t A0, SourceInfo L) {
33114	return emitOp<uint32_t>(OP_InitFieldPtr, A0, L);
33115	}
33116	bool ByteCodeEmitter::emitInitFieldMemberPtr( uint32_t A0, SourceInfo L) {
33117	return emitOp<uint32_t>(OP_InitFieldMemberPtr, A0, L);
33118	}
33119	bool ByteCodeEmitter::emitInitFieldFloat( uint32_t A0, SourceInfo L) {
33120	return emitOp<uint32_t>(OP_InitFieldFloat, A0, L);
33121	}
33122	#endif
33123	#ifdef GET_EVAL_IMPL
33124	bool EvalEmitter::emitInitFieldSint8( uint32_t A0, SourceInfo L) {
33125	if (!isActive()) return true;
33126	CurrentSource = L;
33127	return InitField<PT_Sint8>(S, CodePtr(), A0);
33128	}
33129	bool EvalEmitter::emitInitFieldUint8( uint32_t A0, SourceInfo L) {
33130	if (!isActive()) return true;
33131	CurrentSource = L;
33132	return InitField<PT_Uint8>(S, CodePtr(), A0);
33133	}
33134	bool EvalEmitter::emitInitFieldSint16( uint32_t A0, SourceInfo L) {
33135	if (!isActive()) return true;
33136	CurrentSource = L;
33137	return InitField<PT_Sint16>(S, CodePtr(), A0);
33138	}
33139	bool EvalEmitter::emitInitFieldUint16( uint32_t A0, SourceInfo L) {
33140	if (!isActive()) return true;
33141	CurrentSource = L;
33142	return InitField<PT_Uint16>(S, CodePtr(), A0);
33143	}
33144	bool EvalEmitter::emitInitFieldSint32( uint32_t A0, SourceInfo L) {
33145	if (!isActive()) return true;
33146	CurrentSource = L;
33147	return InitField<PT_Sint32>(S, CodePtr(), A0);
33148	}
33149	bool EvalEmitter::emitInitFieldUint32( uint32_t A0, SourceInfo L) {
33150	if (!isActive()) return true;
33151	CurrentSource = L;
33152	return InitField<PT_Uint32>(S, CodePtr(), A0);
33153	}
33154	bool EvalEmitter::emitInitFieldSint64( uint32_t A0, SourceInfo L) {
33155	if (!isActive()) return true;
33156	CurrentSource = L;
33157	return InitField<PT_Sint64>(S, CodePtr(), A0);
33158	}
33159	bool EvalEmitter::emitInitFieldUint64( uint32_t A0, SourceInfo L) {
33160	if (!isActive()) return true;
33161	CurrentSource = L;
33162	return InitField<PT_Uint64>(S, CodePtr(), A0);
33163	}
33164	bool EvalEmitter::emitInitFieldIntAP( uint32_t A0, SourceInfo L) {
33165	if (!isActive()) return true;
33166	CurrentSource = L;
33167	return InitField<PT_IntAP>(S, CodePtr(), A0);
33168	}
33169	bool EvalEmitter::emitInitFieldIntAPS( uint32_t A0, SourceInfo L) {
33170	if (!isActive()) return true;
33171	CurrentSource = L;
33172	return InitField<PT_IntAPS>(S, CodePtr(), A0);
33173	}
33174	bool EvalEmitter::emitInitFieldBool( uint32_t A0, SourceInfo L) {
33175	if (!isActive()) return true;
33176	CurrentSource = L;
33177	return InitField<PT_Bool>(S, CodePtr(), A0);
33178	}
33179	bool EvalEmitter::emitInitFieldFixedPoint( uint32_t A0, SourceInfo L) {
33180	if (!isActive()) return true;
33181	CurrentSource = L;
33182	return InitField<PT_FixedPoint>(S, CodePtr(), A0);
33183	}
33184	bool EvalEmitter::emitInitFieldPtr( uint32_t A0, SourceInfo L) {
33185	if (!isActive()) return true;
33186	CurrentSource = L;
33187	return InitField<PT_Ptr>(S, CodePtr(), A0);
33188	}
33189	bool EvalEmitter::emitInitFieldMemberPtr( uint32_t A0, SourceInfo L) {
33190	if (!isActive()) return true;
33191	CurrentSource = L;
33192	return InitField<PT_MemberPtr>(S, CodePtr(), A0);
33193	}
33194	bool EvalEmitter::emitInitFieldFloat( uint32_t A0, SourceInfo L) {
33195	if (!isActive()) return true;
33196	CurrentSource = L;
33197	return InitField<PT_Float>(S, CodePtr(), A0);
33198	}
33199	#endif
33200	#ifdef GET_OPCODE_NAMES
33201	OP_InitFieldActivateSint8,
33202	OP_InitFieldActivateUint8,
33203	OP_InitFieldActivateSint16,
33204	OP_InitFieldActivateUint16,
33205	OP_InitFieldActivateSint32,
33206	OP_InitFieldActivateUint32,
33207	OP_InitFieldActivateSint64,
33208	OP_InitFieldActivateUint64,
33209	OP_InitFieldActivateIntAP,
33210	OP_InitFieldActivateIntAPS,
33211	OP_InitFieldActivateBool,
33212	OP_InitFieldActivateFixedPoint,
33213	OP_InitFieldActivatePtr,
33214	OP_InitFieldActivateMemberPtr,
33215	OP_InitFieldActivateFloat,
33216	#endif
33217	#ifdef GET_INTERPFN_LIST
33218	&Interp_InitFieldActivateSint8,
33219	&Interp_InitFieldActivateUint8,
33220	&Interp_InitFieldActivateSint16,
33221	&Interp_InitFieldActivateUint16,
33222	&Interp_InitFieldActivateSint32,
33223	&Interp_InitFieldActivateUint32,
33224	&Interp_InitFieldActivateSint64,
33225	&Interp_InitFieldActivateUint64,
33226	&Interp_InitFieldActivateIntAP,
33227	&Interp_InitFieldActivateIntAPS,
33228	&Interp_InitFieldActivateBool,
33229	&Interp_InitFieldActivateFixedPoint,
33230	&Interp_InitFieldActivatePtr,
33231	&Interp_InitFieldActivateMemberPtr,
33232	&Interp_InitFieldActivateFloat,
33233	#endif
33234	#ifdef GET_INTERPFN_DISPATCHERS
33235	PRESERVE_NONE
33236	static bool Interp_InitFieldActivateSint8(InterpState &S) {
33237	{
33238	CodePtr OpPC = S.PC;
33239	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33240	if (!InitFieldActivate<PT_Sint8>(S, OpPC, V0)) return false;
33241	}
33242	#if USE_TAILCALLS
33243	MUSTTAIL return InterpNext(S);
33244	#else
33245	return true;
33246	#endif
33247	}
33248	PRESERVE_NONE
33249	static bool Interp_InitFieldActivateUint8(InterpState &S) {
33250	{
33251	CodePtr OpPC = S.PC;
33252	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33253	if (!InitFieldActivate<PT_Uint8>(S, OpPC, V0)) return false;
33254	}
33255	#if USE_TAILCALLS
33256	MUSTTAIL return InterpNext(S);
33257	#else
33258	return true;
33259	#endif
33260	}
33261	PRESERVE_NONE
33262	static bool Interp_InitFieldActivateSint16(InterpState &S) {
33263	{
33264	CodePtr OpPC = S.PC;
33265	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33266	if (!InitFieldActivate<PT_Sint16>(S, OpPC, V0)) return false;
33267	}
33268	#if USE_TAILCALLS
33269	MUSTTAIL return InterpNext(S);
33270	#else
33271	return true;
33272	#endif
33273	}
33274	PRESERVE_NONE
33275	static bool Interp_InitFieldActivateUint16(InterpState &S) {
33276	{
33277	CodePtr OpPC = S.PC;
33278	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33279	if (!InitFieldActivate<PT_Uint16>(S, OpPC, V0)) return false;
33280	}
33281	#if USE_TAILCALLS
33282	MUSTTAIL return InterpNext(S);
33283	#else
33284	return true;
33285	#endif
33286	}
33287	PRESERVE_NONE
33288	static bool Interp_InitFieldActivateSint32(InterpState &S) {
33289	{
33290	CodePtr OpPC = S.PC;
33291	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33292	if (!InitFieldActivate<PT_Sint32>(S, OpPC, V0)) return false;
33293	}
33294	#if USE_TAILCALLS
33295	MUSTTAIL return InterpNext(S);
33296	#else
33297	return true;
33298	#endif
33299	}
33300	PRESERVE_NONE
33301	static bool Interp_InitFieldActivateUint32(InterpState &S) {
33302	{
33303	CodePtr OpPC = S.PC;
33304	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33305	if (!InitFieldActivate<PT_Uint32>(S, OpPC, V0)) return false;
33306	}
33307	#if USE_TAILCALLS
33308	MUSTTAIL return InterpNext(S);
33309	#else
33310	return true;
33311	#endif
33312	}
33313	PRESERVE_NONE
33314	static bool Interp_InitFieldActivateSint64(InterpState &S) {
33315	{
33316	CodePtr OpPC = S.PC;
33317	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33318	if (!InitFieldActivate<PT_Sint64>(S, OpPC, V0)) return false;
33319	}
33320	#if USE_TAILCALLS
33321	MUSTTAIL return InterpNext(S);
33322	#else
33323	return true;
33324	#endif
33325	}
33326	PRESERVE_NONE
33327	static bool Interp_InitFieldActivateUint64(InterpState &S) {
33328	{
33329	CodePtr OpPC = S.PC;
33330	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33331	if (!InitFieldActivate<PT_Uint64>(S, OpPC, V0)) return false;
33332	}
33333	#if USE_TAILCALLS
33334	MUSTTAIL return InterpNext(S);
33335	#else
33336	return true;
33337	#endif
33338	}
33339	PRESERVE_NONE
33340	static bool Interp_InitFieldActivateIntAP(InterpState &S) {
33341	{
33342	CodePtr OpPC = S.PC;
33343	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33344	if (!InitFieldActivate<PT_IntAP>(S, OpPC, V0)) return false;
33345	}
33346	#if USE_TAILCALLS
33347	MUSTTAIL return InterpNext(S);
33348	#else
33349	return true;
33350	#endif
33351	}
33352	PRESERVE_NONE
33353	static bool Interp_InitFieldActivateIntAPS(InterpState &S) {
33354	{
33355	CodePtr OpPC = S.PC;
33356	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33357	if (!InitFieldActivate<PT_IntAPS>(S, OpPC, V0)) return false;
33358	}
33359	#if USE_TAILCALLS
33360	MUSTTAIL return InterpNext(S);
33361	#else
33362	return true;
33363	#endif
33364	}
33365	PRESERVE_NONE
33366	static bool Interp_InitFieldActivateBool(InterpState &S) {
33367	{
33368	CodePtr OpPC = S.PC;
33369	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33370	if (!InitFieldActivate<PT_Bool>(S, OpPC, V0)) return false;
33371	}
33372	#if USE_TAILCALLS
33373	MUSTTAIL return InterpNext(S);
33374	#else
33375	return true;
33376	#endif
33377	}
33378	PRESERVE_NONE
33379	static bool Interp_InitFieldActivateFixedPoint(InterpState &S) {
33380	{
33381	CodePtr OpPC = S.PC;
33382	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33383	if (!InitFieldActivate<PT_FixedPoint>(S, OpPC, V0)) return false;
33384	}
33385	#if USE_TAILCALLS
33386	MUSTTAIL return InterpNext(S);
33387	#else
33388	return true;
33389	#endif
33390	}
33391	PRESERVE_NONE
33392	static bool Interp_InitFieldActivatePtr(InterpState &S) {
33393	{
33394	CodePtr OpPC = S.PC;
33395	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33396	if (!InitFieldActivate<PT_Ptr>(S, OpPC, V0)) return false;
33397	}
33398	#if USE_TAILCALLS
33399	MUSTTAIL return InterpNext(S);
33400	#else
33401	return true;
33402	#endif
33403	}
33404	PRESERVE_NONE
33405	static bool Interp_InitFieldActivateMemberPtr(InterpState &S) {
33406	{
33407	CodePtr OpPC = S.PC;
33408	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33409	if (!InitFieldActivate<PT_MemberPtr>(S, OpPC, V0)) return false;
33410	}
33411	#if USE_TAILCALLS
33412	MUSTTAIL return InterpNext(S);
33413	#else
33414	return true;
33415	#endif
33416	}
33417	PRESERVE_NONE
33418	static bool Interp_InitFieldActivateFloat(InterpState &S) {
33419	{
33420	CodePtr OpPC = S.PC;
33421	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33422	if (!InitFieldActivate<PT_Float>(S, OpPC, V0)) return false;
33423	}
33424	#if USE_TAILCALLS
33425	MUSTTAIL return InterpNext(S);
33426	#else
33427	return true;
33428	#endif
33429	}
33430	#endif
33431	#ifdef GET_DISASM
33432	case OP_InitFieldActivateSint8:
33433	Text.Op = PrintName("InitFieldActivateSint8");
33434	Text.Args.push_back(printArg<uint32_t>(P, PC));
33435	break;
33436	case OP_InitFieldActivateUint8:
33437	Text.Op = PrintName("InitFieldActivateUint8");
33438	Text.Args.push_back(printArg<uint32_t>(P, PC));
33439	break;
33440	case OP_InitFieldActivateSint16:
33441	Text.Op = PrintName("InitFieldActivateSint16");
33442	Text.Args.push_back(printArg<uint32_t>(P, PC));
33443	break;
33444	case OP_InitFieldActivateUint16:
33445	Text.Op = PrintName("InitFieldActivateUint16");
33446	Text.Args.push_back(printArg<uint32_t>(P, PC));
33447	break;
33448	case OP_InitFieldActivateSint32:
33449	Text.Op = PrintName("InitFieldActivateSint32");
33450	Text.Args.push_back(printArg<uint32_t>(P, PC));
33451	break;
33452	case OP_InitFieldActivateUint32:
33453	Text.Op = PrintName("InitFieldActivateUint32");
33454	Text.Args.push_back(printArg<uint32_t>(P, PC));
33455	break;
33456	case OP_InitFieldActivateSint64:
33457	Text.Op = PrintName("InitFieldActivateSint64");
33458	Text.Args.push_back(printArg<uint32_t>(P, PC));
33459	break;
33460	case OP_InitFieldActivateUint64:
33461	Text.Op = PrintName("InitFieldActivateUint64");
33462	Text.Args.push_back(printArg<uint32_t>(P, PC));
33463	break;
33464	case OP_InitFieldActivateIntAP:
33465	Text.Op = PrintName("InitFieldActivateIntAP");
33466	Text.Args.push_back(printArg<uint32_t>(P, PC));
33467	break;
33468	case OP_InitFieldActivateIntAPS:
33469	Text.Op = PrintName("InitFieldActivateIntAPS");
33470	Text.Args.push_back(printArg<uint32_t>(P, PC));
33471	break;
33472	case OP_InitFieldActivateBool:
33473	Text.Op = PrintName("InitFieldActivateBool");
33474	Text.Args.push_back(printArg<uint32_t>(P, PC));
33475	break;
33476	case OP_InitFieldActivateFixedPoint:
33477	Text.Op = PrintName("InitFieldActivateFixedPoint");
33478	Text.Args.push_back(printArg<uint32_t>(P, PC));
33479	break;
33480	case OP_InitFieldActivatePtr:
33481	Text.Op = PrintName("InitFieldActivatePtr");
33482	Text.Args.push_back(printArg<uint32_t>(P, PC));
33483	break;
33484	case OP_InitFieldActivateMemberPtr:
33485	Text.Op = PrintName("InitFieldActivateMemberPtr");
33486	Text.Args.push_back(printArg<uint32_t>(P, PC));
33487	break;
33488	case OP_InitFieldActivateFloat:
33489	Text.Op = PrintName("InitFieldActivateFloat");
33490	Text.Args.push_back(printArg<uint32_t>(P, PC));
33491	break;
33492	#endif
33493	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33494	bool emitInitFieldActivateSint8( uint32_t , SourceInfo);
33495	bool emitInitFieldActivateUint8( uint32_t , SourceInfo);
33496	bool emitInitFieldActivateSint16( uint32_t , SourceInfo);
33497	bool emitInitFieldActivateUint16( uint32_t , SourceInfo);
33498	bool emitInitFieldActivateSint32( uint32_t , SourceInfo);
33499	bool emitInitFieldActivateUint32( uint32_t , SourceInfo);
33500	bool emitInitFieldActivateSint64( uint32_t , SourceInfo);
33501	bool emitInitFieldActivateUint64( uint32_t , SourceInfo);
33502	bool emitInitFieldActivateIntAP( uint32_t , SourceInfo);
33503	bool emitInitFieldActivateIntAPS( uint32_t , SourceInfo);
33504	bool emitInitFieldActivateBool( uint32_t , SourceInfo);
33505	bool emitInitFieldActivateFixedPoint( uint32_t , SourceInfo);
33506	bool emitInitFieldActivatePtr( uint32_t , SourceInfo);
33507	bool emitInitFieldActivateMemberPtr( uint32_t , SourceInfo);
33508	bool emitInitFieldActivateFloat( uint32_t , SourceInfo);
33509	#endif
33510	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33511	[[nodiscard]] bool emitInitFieldActivate(PrimType, uint32_t, SourceInfo I);
33512	#endif
33513	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
33514	bool
33515	#if defined(GET_EVAL_IMPL)
33516	EvalEmitter
33517	#else
33518	ByteCodeEmitter
33519	#endif
33520	::emitInitFieldActivate(PrimType T0, uint32_t A0, SourceInfo I) {
33521	switch (T0) {
33522	case PT_Sint8:
33523	return emitInitFieldActivateSint8(A0, I);
33524	case PT_Uint8:
33525	return emitInitFieldActivateUint8(A0, I);
33526	case PT_Sint16:
33527	return emitInitFieldActivateSint16(A0, I);
33528	case PT_Uint16:
33529	return emitInitFieldActivateUint16(A0, I);
33530	case PT_Sint32:
33531	return emitInitFieldActivateSint32(A0, I);
33532	case PT_Uint32:
33533	return emitInitFieldActivateUint32(A0, I);
33534	case PT_Sint64:
33535	return emitInitFieldActivateSint64(A0, I);
33536	case PT_Uint64:
33537	return emitInitFieldActivateUint64(A0, I);
33538	case PT_IntAP:
33539	return emitInitFieldActivateIntAP(A0, I);
33540	case PT_IntAPS:
33541	return emitInitFieldActivateIntAPS(A0, I);
33542	case PT_Bool:
33543	return emitInitFieldActivateBool(A0, I);
33544	case PT_FixedPoint:
33545	return emitInitFieldActivateFixedPoint(A0, I);
33546	case PT_Ptr:
33547	return emitInitFieldActivatePtr(A0, I);
33548	case PT_MemberPtr:
33549	return emitInitFieldActivateMemberPtr(A0, I);
33550	case PT_Float:
33551	return emitInitFieldActivateFloat(A0, I);
33552	}
33553	llvm_unreachable("invalid enum value");
33554	}
33555	#endif
33556	#ifdef GET_LINK_IMPL
33557	bool ByteCodeEmitter::emitInitFieldActivateSint8( uint32_t A0, SourceInfo L) {
33558	return emitOp<uint32_t>(OP_InitFieldActivateSint8, A0, L);
33559	}
33560	bool ByteCodeEmitter::emitInitFieldActivateUint8( uint32_t A0, SourceInfo L) {
33561	return emitOp<uint32_t>(OP_InitFieldActivateUint8, A0, L);
33562	}
33563	bool ByteCodeEmitter::emitInitFieldActivateSint16( uint32_t A0, SourceInfo L) {
33564	return emitOp<uint32_t>(OP_InitFieldActivateSint16, A0, L);
33565	}
33566	bool ByteCodeEmitter::emitInitFieldActivateUint16( uint32_t A0, SourceInfo L) {
33567	return emitOp<uint32_t>(OP_InitFieldActivateUint16, A0, L);
33568	}
33569	bool ByteCodeEmitter::emitInitFieldActivateSint32( uint32_t A0, SourceInfo L) {
33570	return emitOp<uint32_t>(OP_InitFieldActivateSint32, A0, L);
33571	}
33572	bool ByteCodeEmitter::emitInitFieldActivateUint32( uint32_t A0, SourceInfo L) {
33573	return emitOp<uint32_t>(OP_InitFieldActivateUint32, A0, L);
33574	}
33575	bool ByteCodeEmitter::emitInitFieldActivateSint64( uint32_t A0, SourceInfo L) {
33576	return emitOp<uint32_t>(OP_InitFieldActivateSint64, A0, L);
33577	}
33578	bool ByteCodeEmitter::emitInitFieldActivateUint64( uint32_t A0, SourceInfo L) {
33579	return emitOp<uint32_t>(OP_InitFieldActivateUint64, A0, L);
33580	}
33581	bool ByteCodeEmitter::emitInitFieldActivateIntAP( uint32_t A0, SourceInfo L) {
33582	return emitOp<uint32_t>(OP_InitFieldActivateIntAP, A0, L);
33583	}
33584	bool ByteCodeEmitter::emitInitFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
33585	return emitOp<uint32_t>(OP_InitFieldActivateIntAPS, A0, L);
33586	}
33587	bool ByteCodeEmitter::emitInitFieldActivateBool( uint32_t A0, SourceInfo L) {
33588	return emitOp<uint32_t>(OP_InitFieldActivateBool, A0, L);
33589	}
33590	bool ByteCodeEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
33591	return emitOp<uint32_t>(OP_InitFieldActivateFixedPoint, A0, L);
33592	}
33593	bool ByteCodeEmitter::emitInitFieldActivatePtr( uint32_t A0, SourceInfo L) {
33594	return emitOp<uint32_t>(OP_InitFieldActivatePtr, A0, L);
33595	}
33596	bool ByteCodeEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
33597	return emitOp<uint32_t>(OP_InitFieldActivateMemberPtr, A0, L);
33598	}
33599	bool ByteCodeEmitter::emitInitFieldActivateFloat( uint32_t A0, SourceInfo L) {
33600	return emitOp<uint32_t>(OP_InitFieldActivateFloat, A0, L);
33601	}
33602	#endif
33603	#ifdef GET_EVAL_IMPL
33604	bool EvalEmitter::emitInitFieldActivateSint8( uint32_t A0, SourceInfo L) {
33605	if (!isActive()) return true;
33606	CurrentSource = L;
33607	return InitFieldActivate<PT_Sint8>(S, CodePtr(), A0);
33608	}
33609	bool EvalEmitter::emitInitFieldActivateUint8( uint32_t A0, SourceInfo L) {
33610	if (!isActive()) return true;
33611	CurrentSource = L;
33612	return InitFieldActivate<PT_Uint8>(S, CodePtr(), A0);
33613	}
33614	bool EvalEmitter::emitInitFieldActivateSint16( uint32_t A0, SourceInfo L) {
33615	if (!isActive()) return true;
33616	CurrentSource = L;
33617	return InitFieldActivate<PT_Sint16>(S, CodePtr(), A0);
33618	}
33619	bool EvalEmitter::emitInitFieldActivateUint16( uint32_t A0, SourceInfo L) {
33620	if (!isActive()) return true;
33621	CurrentSource = L;
33622	return InitFieldActivate<PT_Uint16>(S, CodePtr(), A0);
33623	}
33624	bool EvalEmitter::emitInitFieldActivateSint32( uint32_t A0, SourceInfo L) {
33625	if (!isActive()) return true;
33626	CurrentSource = L;
33627	return InitFieldActivate<PT_Sint32>(S, CodePtr(), A0);
33628	}
33629	bool EvalEmitter::emitInitFieldActivateUint32( uint32_t A0, SourceInfo L) {
33630	if (!isActive()) return true;
33631	CurrentSource = L;
33632	return InitFieldActivate<PT_Uint32>(S, CodePtr(), A0);
33633	}
33634	bool EvalEmitter::emitInitFieldActivateSint64( uint32_t A0, SourceInfo L) {
33635	if (!isActive()) return true;
33636	CurrentSource = L;
33637	return InitFieldActivate<PT_Sint64>(S, CodePtr(), A0);
33638	}
33639	bool EvalEmitter::emitInitFieldActivateUint64( uint32_t A0, SourceInfo L) {
33640	if (!isActive()) return true;
33641	CurrentSource = L;
33642	return InitFieldActivate<PT_Uint64>(S, CodePtr(), A0);
33643	}
33644	bool EvalEmitter::emitInitFieldActivateIntAP( uint32_t A0, SourceInfo L) {
33645	if (!isActive()) return true;
33646	CurrentSource = L;
33647	return InitFieldActivate<PT_IntAP>(S, CodePtr(), A0);
33648	}
33649	bool EvalEmitter::emitInitFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
33650	if (!isActive()) return true;
33651	CurrentSource = L;
33652	return InitFieldActivate<PT_IntAPS>(S, CodePtr(), A0);
33653	}
33654	bool EvalEmitter::emitInitFieldActivateBool( uint32_t A0, SourceInfo L) {
33655	if (!isActive()) return true;
33656	CurrentSource = L;
33657	return InitFieldActivate<PT_Bool>(S, CodePtr(), A0);
33658	}
33659	bool EvalEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
33660	if (!isActive()) return true;
33661	CurrentSource = L;
33662	return InitFieldActivate<PT_FixedPoint>(S, CodePtr(), A0);
33663	}
33664	bool EvalEmitter::emitInitFieldActivatePtr( uint32_t A0, SourceInfo L) {
33665	if (!isActive()) return true;
33666	CurrentSource = L;
33667	return InitFieldActivate<PT_Ptr>(S, CodePtr(), A0);
33668	}
33669	bool EvalEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
33670	if (!isActive()) return true;
33671	CurrentSource = L;
33672	return InitFieldActivate<PT_MemberPtr>(S, CodePtr(), A0);
33673	}
33674	bool EvalEmitter::emitInitFieldActivateFloat( uint32_t A0, SourceInfo L) {
33675	if (!isActive()) return true;
33676	CurrentSource = L;
33677	return InitFieldActivate<PT_Float>(S, CodePtr(), A0);
33678	}
33679	#endif
33680	#ifdef GET_OPCODE_NAMES
33681	OP_InitGlobalSint8,
33682	OP_InitGlobalUint8,
33683	OP_InitGlobalSint16,
33684	OP_InitGlobalUint16,
33685	OP_InitGlobalSint32,
33686	OP_InitGlobalUint32,
33687	OP_InitGlobalSint64,
33688	OP_InitGlobalUint64,
33689	OP_InitGlobalIntAP,
33690	OP_InitGlobalIntAPS,
33691	OP_InitGlobalBool,
33692	OP_InitGlobalFixedPoint,
33693	OP_InitGlobalPtr,
33694	OP_InitGlobalMemberPtr,
33695	OP_InitGlobalFloat,
33696	#endif
33697	#ifdef GET_INTERPFN_LIST
33698	&Interp_InitGlobalSint8,
33699	&Interp_InitGlobalUint8,
33700	&Interp_InitGlobalSint16,
33701	&Interp_InitGlobalUint16,
33702	&Interp_InitGlobalSint32,
33703	&Interp_InitGlobalUint32,
33704	&Interp_InitGlobalSint64,
33705	&Interp_InitGlobalUint64,
33706	&Interp_InitGlobalIntAP,
33707	&Interp_InitGlobalIntAPS,
33708	&Interp_InitGlobalBool,
33709	&Interp_InitGlobalFixedPoint,
33710	&Interp_InitGlobalPtr,
33711	&Interp_InitGlobalMemberPtr,
33712	&Interp_InitGlobalFloat,
33713	#endif
33714	#ifdef GET_INTERPFN_DISPATCHERS
33715	PRESERVE_NONE
33716	static bool Interp_InitGlobalSint8(InterpState &S) {
33717	{
33718	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33719	InitGlobal<PT_Sint8>(S, V0);
33720	}
33721	#if USE_TAILCALLS
33722	MUSTTAIL return InterpNext(S);
33723	#else
33724	return true;
33725	#endif
33726	}
33727	PRESERVE_NONE
33728	static bool Interp_InitGlobalUint8(InterpState &S) {
33729	{
33730	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33731	InitGlobal<PT_Uint8>(S, V0);
33732	}
33733	#if USE_TAILCALLS
33734	MUSTTAIL return InterpNext(S);
33735	#else
33736	return true;
33737	#endif
33738	}
33739	PRESERVE_NONE
33740	static bool Interp_InitGlobalSint16(InterpState &S) {
33741	{
33742	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33743	InitGlobal<PT_Sint16>(S, V0);
33744	}
33745	#if USE_TAILCALLS
33746	MUSTTAIL return InterpNext(S);
33747	#else
33748	return true;
33749	#endif
33750	}
33751	PRESERVE_NONE
33752	static bool Interp_InitGlobalUint16(InterpState &S) {
33753	{
33754	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33755	InitGlobal<PT_Uint16>(S, V0);
33756	}
33757	#if USE_TAILCALLS
33758	MUSTTAIL return InterpNext(S);
33759	#else
33760	return true;
33761	#endif
33762	}
33763	PRESERVE_NONE
33764	static bool Interp_InitGlobalSint32(InterpState &S) {
33765	{
33766	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33767	InitGlobal<PT_Sint32>(S, V0);
33768	}
33769	#if USE_TAILCALLS
33770	MUSTTAIL return InterpNext(S);
33771	#else
33772	return true;
33773	#endif
33774	}
33775	PRESERVE_NONE
33776	static bool Interp_InitGlobalUint32(InterpState &S) {
33777	{
33778	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33779	InitGlobal<PT_Uint32>(S, V0);
33780	}
33781	#if USE_TAILCALLS
33782	MUSTTAIL return InterpNext(S);
33783	#else
33784	return true;
33785	#endif
33786	}
33787	PRESERVE_NONE
33788	static bool Interp_InitGlobalSint64(InterpState &S) {
33789	{
33790	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33791	InitGlobal<PT_Sint64>(S, V0);
33792	}
33793	#if USE_TAILCALLS
33794	MUSTTAIL return InterpNext(S);
33795	#else
33796	return true;
33797	#endif
33798	}
33799	PRESERVE_NONE
33800	static bool Interp_InitGlobalUint64(InterpState &S) {
33801	{
33802	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33803	InitGlobal<PT_Uint64>(S, V0);
33804	}
33805	#if USE_TAILCALLS
33806	MUSTTAIL return InterpNext(S);
33807	#else
33808	return true;
33809	#endif
33810	}
33811	PRESERVE_NONE
33812	static bool Interp_InitGlobalIntAP(InterpState &S) {
33813	{
33814	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33815	InitGlobal<PT_IntAP>(S, V0);
33816	}
33817	#if USE_TAILCALLS
33818	MUSTTAIL return InterpNext(S);
33819	#else
33820	return true;
33821	#endif
33822	}
33823	PRESERVE_NONE
33824	static bool Interp_InitGlobalIntAPS(InterpState &S) {
33825	{
33826	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33827	InitGlobal<PT_IntAPS>(S, V0);
33828	}
33829	#if USE_TAILCALLS
33830	MUSTTAIL return InterpNext(S);
33831	#else
33832	return true;
33833	#endif
33834	}
33835	PRESERVE_NONE
33836	static bool Interp_InitGlobalBool(InterpState &S) {
33837	{
33838	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33839	InitGlobal<PT_Bool>(S, V0);
33840	}
33841	#if USE_TAILCALLS
33842	MUSTTAIL return InterpNext(S);
33843	#else
33844	return true;
33845	#endif
33846	}
33847	PRESERVE_NONE
33848	static bool Interp_InitGlobalFixedPoint(InterpState &S) {
33849	{
33850	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33851	InitGlobal<PT_FixedPoint>(S, V0);
33852	}
33853	#if USE_TAILCALLS
33854	MUSTTAIL return InterpNext(S);
33855	#else
33856	return true;
33857	#endif
33858	}
33859	PRESERVE_NONE
33860	static bool Interp_InitGlobalPtr(InterpState &S) {
33861	{
33862	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33863	InitGlobal<PT_Ptr>(S, V0);
33864	}
33865	#if USE_TAILCALLS
33866	MUSTTAIL return InterpNext(S);
33867	#else
33868	return true;
33869	#endif
33870	}
33871	PRESERVE_NONE
33872	static bool Interp_InitGlobalMemberPtr(InterpState &S) {
33873	{
33874	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33875	InitGlobal<PT_MemberPtr>(S, V0);
33876	}
33877	#if USE_TAILCALLS
33878	MUSTTAIL return InterpNext(S);
33879	#else
33880	return true;
33881	#endif
33882	}
33883	PRESERVE_NONE
33884	static bool Interp_InitGlobalFloat(InterpState &S) {
33885	{
33886	const auto V0 = ReadArg<uint32_t>(S, S.PC);
33887	InitGlobal<PT_Float>(S, V0);
33888	}
33889	#if USE_TAILCALLS
33890	MUSTTAIL return InterpNext(S);
33891	#else
33892	return true;
33893	#endif
33894	}
33895	#endif
33896	#ifdef GET_DISASM
33897	case OP_InitGlobalSint8:
33898	Text.Op = PrintName("InitGlobalSint8");
33899	Text.Args.push_back(printArg<uint32_t>(P, PC));
33900	break;
33901	case OP_InitGlobalUint8:
33902	Text.Op = PrintName("InitGlobalUint8");
33903	Text.Args.push_back(printArg<uint32_t>(P, PC));
33904	break;
33905	case OP_InitGlobalSint16:
33906	Text.Op = PrintName("InitGlobalSint16");
33907	Text.Args.push_back(printArg<uint32_t>(P, PC));
33908	break;
33909	case OP_InitGlobalUint16:
33910	Text.Op = PrintName("InitGlobalUint16");
33911	Text.Args.push_back(printArg<uint32_t>(P, PC));
33912	break;
33913	case OP_InitGlobalSint32:
33914	Text.Op = PrintName("InitGlobalSint32");
33915	Text.Args.push_back(printArg<uint32_t>(P, PC));
33916	break;
33917	case OP_InitGlobalUint32:
33918	Text.Op = PrintName("InitGlobalUint32");
33919	Text.Args.push_back(printArg<uint32_t>(P, PC));
33920	break;
33921	case OP_InitGlobalSint64:
33922	Text.Op = PrintName("InitGlobalSint64");
33923	Text.Args.push_back(printArg<uint32_t>(P, PC));
33924	break;
33925	case OP_InitGlobalUint64:
33926	Text.Op = PrintName("InitGlobalUint64");
33927	Text.Args.push_back(printArg<uint32_t>(P, PC));
33928	break;
33929	case OP_InitGlobalIntAP:
33930	Text.Op = PrintName("InitGlobalIntAP");
33931	Text.Args.push_back(printArg<uint32_t>(P, PC));
33932	break;
33933	case OP_InitGlobalIntAPS:
33934	Text.Op = PrintName("InitGlobalIntAPS");
33935	Text.Args.push_back(printArg<uint32_t>(P, PC));
33936	break;
33937	case OP_InitGlobalBool:
33938	Text.Op = PrintName("InitGlobalBool");
33939	Text.Args.push_back(printArg<uint32_t>(P, PC));
33940	break;
33941	case OP_InitGlobalFixedPoint:
33942	Text.Op = PrintName("InitGlobalFixedPoint");
33943	Text.Args.push_back(printArg<uint32_t>(P, PC));
33944	break;
33945	case OP_InitGlobalPtr:
33946	Text.Op = PrintName("InitGlobalPtr");
33947	Text.Args.push_back(printArg<uint32_t>(P, PC));
33948	break;
33949	case OP_InitGlobalMemberPtr:
33950	Text.Op = PrintName("InitGlobalMemberPtr");
33951	Text.Args.push_back(printArg<uint32_t>(P, PC));
33952	break;
33953	case OP_InitGlobalFloat:
33954	Text.Op = PrintName("InitGlobalFloat");
33955	Text.Args.push_back(printArg<uint32_t>(P, PC));
33956	break;
33957	#endif
33958	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33959	bool emitInitGlobalSint8( uint32_t , SourceInfo);
33960	bool emitInitGlobalUint8( uint32_t , SourceInfo);
33961	bool emitInitGlobalSint16( uint32_t , SourceInfo);
33962	bool emitInitGlobalUint16( uint32_t , SourceInfo);
33963	bool emitInitGlobalSint32( uint32_t , SourceInfo);
33964	bool emitInitGlobalUint32( uint32_t , SourceInfo);
33965	bool emitInitGlobalSint64( uint32_t , SourceInfo);
33966	bool emitInitGlobalUint64( uint32_t , SourceInfo);
33967	bool emitInitGlobalIntAP( uint32_t , SourceInfo);
33968	bool emitInitGlobalIntAPS( uint32_t , SourceInfo);
33969	bool emitInitGlobalBool( uint32_t , SourceInfo);
33970	bool emitInitGlobalFixedPoint( uint32_t , SourceInfo);
33971	bool emitInitGlobalPtr( uint32_t , SourceInfo);
33972	bool emitInitGlobalMemberPtr( uint32_t , SourceInfo);
33973	bool emitInitGlobalFloat( uint32_t , SourceInfo);
33974	#endif
33975	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
33976	[[nodiscard]] bool emitInitGlobal(PrimType, uint32_t, SourceInfo I);
33977	#endif
33978	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
33979	bool
33980	#if defined(GET_EVAL_IMPL)
33981	EvalEmitter
33982	#else
33983	ByteCodeEmitter
33984	#endif
33985	::emitInitGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
33986	switch (T0) {
33987	case PT_Sint8:
33988	return emitInitGlobalSint8(A0, I);
33989	case PT_Uint8:
33990	return emitInitGlobalUint8(A0, I);
33991	case PT_Sint16:
33992	return emitInitGlobalSint16(A0, I);
33993	case PT_Uint16:
33994	return emitInitGlobalUint16(A0, I);
33995	case PT_Sint32:
33996	return emitInitGlobalSint32(A0, I);
33997	case PT_Uint32:
33998	return emitInitGlobalUint32(A0, I);
33999	case PT_Sint64:
34000	return emitInitGlobalSint64(A0, I);
34001	case PT_Uint64:
34002	return emitInitGlobalUint64(A0, I);
34003	case PT_IntAP:
34004	return emitInitGlobalIntAP(A0, I);
34005	case PT_IntAPS:
34006	return emitInitGlobalIntAPS(A0, I);
34007	case PT_Bool:
34008	return emitInitGlobalBool(A0, I);
34009	case PT_FixedPoint:
34010	return emitInitGlobalFixedPoint(A0, I);
34011	case PT_Ptr:
34012	return emitInitGlobalPtr(A0, I);
34013	case PT_MemberPtr:
34014	return emitInitGlobalMemberPtr(A0, I);
34015	case PT_Float:
34016	return emitInitGlobalFloat(A0, I);
34017	}
34018	llvm_unreachable("invalid enum value");
34019	}
34020	#endif
34021	#ifdef GET_LINK_IMPL
34022	bool ByteCodeEmitter::emitInitGlobalSint8( uint32_t A0, SourceInfo L) {
34023	return emitOp<uint32_t>(OP_InitGlobalSint8, A0, L);
34024	}
34025	bool ByteCodeEmitter::emitInitGlobalUint8( uint32_t A0, SourceInfo L) {
34026	return emitOp<uint32_t>(OP_InitGlobalUint8, A0, L);
34027	}
34028	bool ByteCodeEmitter::emitInitGlobalSint16( uint32_t A0, SourceInfo L) {
34029	return emitOp<uint32_t>(OP_InitGlobalSint16, A0, L);
34030	}
34031	bool ByteCodeEmitter::emitInitGlobalUint16( uint32_t A0, SourceInfo L) {
34032	return emitOp<uint32_t>(OP_InitGlobalUint16, A0, L);
34033	}
34034	bool ByteCodeEmitter::emitInitGlobalSint32( uint32_t A0, SourceInfo L) {
34035	return emitOp<uint32_t>(OP_InitGlobalSint32, A0, L);
34036	}
34037	bool ByteCodeEmitter::emitInitGlobalUint32( uint32_t A0, SourceInfo L) {
34038	return emitOp<uint32_t>(OP_InitGlobalUint32, A0, L);
34039	}
34040	bool ByteCodeEmitter::emitInitGlobalSint64( uint32_t A0, SourceInfo L) {
34041	return emitOp<uint32_t>(OP_InitGlobalSint64, A0, L);
34042	}
34043	bool ByteCodeEmitter::emitInitGlobalUint64( uint32_t A0, SourceInfo L) {
34044	return emitOp<uint32_t>(OP_InitGlobalUint64, A0, L);
34045	}
34046	bool ByteCodeEmitter::emitInitGlobalIntAP( uint32_t A0, SourceInfo L) {
34047	return emitOp<uint32_t>(OP_InitGlobalIntAP, A0, L);
34048	}
34049	bool ByteCodeEmitter::emitInitGlobalIntAPS( uint32_t A0, SourceInfo L) {
34050	return emitOp<uint32_t>(OP_InitGlobalIntAPS, A0, L);
34051	}
34052	bool ByteCodeEmitter::emitInitGlobalBool( uint32_t A0, SourceInfo L) {
34053	return emitOp<uint32_t>(OP_InitGlobalBool, A0, L);
34054	}
34055	bool ByteCodeEmitter::emitInitGlobalFixedPoint( uint32_t A0, SourceInfo L) {
34056	return emitOp<uint32_t>(OP_InitGlobalFixedPoint, A0, L);
34057	}
34058	bool ByteCodeEmitter::emitInitGlobalPtr( uint32_t A0, SourceInfo L) {
34059	return emitOp<uint32_t>(OP_InitGlobalPtr, A0, L);
34060	}
34061	bool ByteCodeEmitter::emitInitGlobalMemberPtr( uint32_t A0, SourceInfo L) {
34062	return emitOp<uint32_t>(OP_InitGlobalMemberPtr, A0, L);
34063	}
34064	bool ByteCodeEmitter::emitInitGlobalFloat( uint32_t A0, SourceInfo L) {
34065	return emitOp<uint32_t>(OP_InitGlobalFloat, A0, L);
34066	}
34067	#endif
34068	#ifdef GET_EVAL_IMPL
34069	bool EvalEmitter::emitInitGlobalSint8( uint32_t A0, SourceInfo L) {
34070	if (!isActive()) return true;
34071	CurrentSource = L;
34072	return InitGlobal<PT_Sint8>(S, A0);
34073	}
34074	bool EvalEmitter::emitInitGlobalUint8( uint32_t A0, SourceInfo L) {
34075	if (!isActive()) return true;
34076	CurrentSource = L;
34077	return InitGlobal<PT_Uint8>(S, A0);
34078	}
34079	bool EvalEmitter::emitInitGlobalSint16( uint32_t A0, SourceInfo L) {
34080	if (!isActive()) return true;
34081	CurrentSource = L;
34082	return InitGlobal<PT_Sint16>(S, A0);
34083	}
34084	bool EvalEmitter::emitInitGlobalUint16( uint32_t A0, SourceInfo L) {
34085	if (!isActive()) return true;
34086	CurrentSource = L;
34087	return InitGlobal<PT_Uint16>(S, A0);
34088	}
34089	bool EvalEmitter::emitInitGlobalSint32( uint32_t A0, SourceInfo L) {
34090	if (!isActive()) return true;
34091	CurrentSource = L;
34092	return InitGlobal<PT_Sint32>(S, A0);
34093	}
34094	bool EvalEmitter::emitInitGlobalUint32( uint32_t A0, SourceInfo L) {
34095	if (!isActive()) return true;
34096	CurrentSource = L;
34097	return InitGlobal<PT_Uint32>(S, A0);
34098	}
34099	bool EvalEmitter::emitInitGlobalSint64( uint32_t A0, SourceInfo L) {
34100	if (!isActive()) return true;
34101	CurrentSource = L;
34102	return InitGlobal<PT_Sint64>(S, A0);
34103	}
34104	bool EvalEmitter::emitInitGlobalUint64( uint32_t A0, SourceInfo L) {
34105	if (!isActive()) return true;
34106	CurrentSource = L;
34107	return InitGlobal<PT_Uint64>(S, A0);
34108	}
34109	bool EvalEmitter::emitInitGlobalIntAP( uint32_t A0, SourceInfo L) {
34110	if (!isActive()) return true;
34111	CurrentSource = L;
34112	return InitGlobal<PT_IntAP>(S, A0);
34113	}
34114	bool EvalEmitter::emitInitGlobalIntAPS( uint32_t A0, SourceInfo L) {
34115	if (!isActive()) return true;
34116	CurrentSource = L;
34117	return InitGlobal<PT_IntAPS>(S, A0);
34118	}
34119	bool EvalEmitter::emitInitGlobalBool( uint32_t A0, SourceInfo L) {
34120	if (!isActive()) return true;
34121	CurrentSource = L;
34122	return InitGlobal<PT_Bool>(S, A0);
34123	}
34124	bool EvalEmitter::emitInitGlobalFixedPoint( uint32_t A0, SourceInfo L) {
34125	if (!isActive()) return true;
34126	CurrentSource = L;
34127	return InitGlobal<PT_FixedPoint>(S, A0);
34128	}
34129	bool EvalEmitter::emitInitGlobalPtr( uint32_t A0, SourceInfo L) {
34130	if (!isActive()) return true;
34131	CurrentSource = L;
34132	return InitGlobal<PT_Ptr>(S, A0);
34133	}
34134	bool EvalEmitter::emitInitGlobalMemberPtr( uint32_t A0, SourceInfo L) {
34135	if (!isActive()) return true;
34136	CurrentSource = L;
34137	return InitGlobal<PT_MemberPtr>(S, A0);
34138	}
34139	bool EvalEmitter::emitInitGlobalFloat( uint32_t A0, SourceInfo L) {
34140	if (!isActive()) return true;
34141	CurrentSource = L;
34142	return InitGlobal<PT_Float>(S, A0);
34143	}
34144	#endif
34145	#ifdef GET_OPCODE_NAMES
34146	OP_InitGlobalTempSint8,
34147	OP_InitGlobalTempUint8,
34148	OP_InitGlobalTempSint16,
34149	OP_InitGlobalTempUint16,
34150	OP_InitGlobalTempSint32,
34151	OP_InitGlobalTempUint32,
34152	OP_InitGlobalTempSint64,
34153	OP_InitGlobalTempUint64,
34154	OP_InitGlobalTempIntAP,
34155	OP_InitGlobalTempIntAPS,
34156	OP_InitGlobalTempBool,
34157	OP_InitGlobalTempFixedPoint,
34158	OP_InitGlobalTempPtr,
34159	OP_InitGlobalTempMemberPtr,
34160	OP_InitGlobalTempFloat,
34161	#endif
34162	#ifdef GET_INTERPFN_LIST
34163	&Interp_InitGlobalTempSint8,
34164	&Interp_InitGlobalTempUint8,
34165	&Interp_InitGlobalTempSint16,
34166	&Interp_InitGlobalTempUint16,
34167	&Interp_InitGlobalTempSint32,
34168	&Interp_InitGlobalTempUint32,
34169	&Interp_InitGlobalTempSint64,
34170	&Interp_InitGlobalTempUint64,
34171	&Interp_InitGlobalTempIntAP,
34172	&Interp_InitGlobalTempIntAPS,
34173	&Interp_InitGlobalTempBool,
34174	&Interp_InitGlobalTempFixedPoint,
34175	&Interp_InitGlobalTempPtr,
34176	&Interp_InitGlobalTempMemberPtr,
34177	&Interp_InitGlobalTempFloat,
34178	#endif
34179	#ifdef GET_INTERPFN_DISPATCHERS
34180	PRESERVE_NONE
34181	static bool Interp_InitGlobalTempSint8(InterpState &S) {
34182	{
34183	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34184	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34185	if (!InitGlobalTemp<PT_Sint8>(S, V0, V1)) return false;
34186	}
34187	#if USE_TAILCALLS
34188	MUSTTAIL return InterpNext(S);
34189	#else
34190	return true;
34191	#endif
34192	}
34193	PRESERVE_NONE
34194	static bool Interp_InitGlobalTempUint8(InterpState &S) {
34195	{
34196	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34197	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34198	if (!InitGlobalTemp<PT_Uint8>(S, V0, V1)) return false;
34199	}
34200	#if USE_TAILCALLS
34201	MUSTTAIL return InterpNext(S);
34202	#else
34203	return true;
34204	#endif
34205	}
34206	PRESERVE_NONE
34207	static bool Interp_InitGlobalTempSint16(InterpState &S) {
34208	{
34209	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34210	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34211	if (!InitGlobalTemp<PT_Sint16>(S, V0, V1)) return false;
34212	}
34213	#if USE_TAILCALLS
34214	MUSTTAIL return InterpNext(S);
34215	#else
34216	return true;
34217	#endif
34218	}
34219	PRESERVE_NONE
34220	static bool Interp_InitGlobalTempUint16(InterpState &S) {
34221	{
34222	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34223	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34224	if (!InitGlobalTemp<PT_Uint16>(S, V0, V1)) return false;
34225	}
34226	#if USE_TAILCALLS
34227	MUSTTAIL return InterpNext(S);
34228	#else
34229	return true;
34230	#endif
34231	}
34232	PRESERVE_NONE
34233	static bool Interp_InitGlobalTempSint32(InterpState &S) {
34234	{
34235	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34236	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34237	if (!InitGlobalTemp<PT_Sint32>(S, V0, V1)) return false;
34238	}
34239	#if USE_TAILCALLS
34240	MUSTTAIL return InterpNext(S);
34241	#else
34242	return true;
34243	#endif
34244	}
34245	PRESERVE_NONE
34246	static bool Interp_InitGlobalTempUint32(InterpState &S) {
34247	{
34248	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34249	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34250	if (!InitGlobalTemp<PT_Uint32>(S, V0, V1)) return false;
34251	}
34252	#if USE_TAILCALLS
34253	MUSTTAIL return InterpNext(S);
34254	#else
34255	return true;
34256	#endif
34257	}
34258	PRESERVE_NONE
34259	static bool Interp_InitGlobalTempSint64(InterpState &S) {
34260	{
34261	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34262	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34263	if (!InitGlobalTemp<PT_Sint64>(S, V0, V1)) return false;
34264	}
34265	#if USE_TAILCALLS
34266	MUSTTAIL return InterpNext(S);
34267	#else
34268	return true;
34269	#endif
34270	}
34271	PRESERVE_NONE
34272	static bool Interp_InitGlobalTempUint64(InterpState &S) {
34273	{
34274	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34275	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34276	if (!InitGlobalTemp<PT_Uint64>(S, V0, V1)) return false;
34277	}
34278	#if USE_TAILCALLS
34279	MUSTTAIL return InterpNext(S);
34280	#else
34281	return true;
34282	#endif
34283	}
34284	PRESERVE_NONE
34285	static bool Interp_InitGlobalTempIntAP(InterpState &S) {
34286	{
34287	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34288	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34289	if (!InitGlobalTemp<PT_IntAP>(S, V0, V1)) return false;
34290	}
34291	#if USE_TAILCALLS
34292	MUSTTAIL return InterpNext(S);
34293	#else
34294	return true;
34295	#endif
34296	}
34297	PRESERVE_NONE
34298	static bool Interp_InitGlobalTempIntAPS(InterpState &S) {
34299	{
34300	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34301	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34302	if (!InitGlobalTemp<PT_IntAPS>(S, V0, V1)) return false;
34303	}
34304	#if USE_TAILCALLS
34305	MUSTTAIL return InterpNext(S);
34306	#else
34307	return true;
34308	#endif
34309	}
34310	PRESERVE_NONE
34311	static bool Interp_InitGlobalTempBool(InterpState &S) {
34312	{
34313	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34314	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34315	if (!InitGlobalTemp<PT_Bool>(S, V0, V1)) return false;
34316	}
34317	#if USE_TAILCALLS
34318	MUSTTAIL return InterpNext(S);
34319	#else
34320	return true;
34321	#endif
34322	}
34323	PRESERVE_NONE
34324	static bool Interp_InitGlobalTempFixedPoint(InterpState &S) {
34325	{
34326	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34327	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34328	if (!InitGlobalTemp<PT_FixedPoint>(S, V0, V1)) return false;
34329	}
34330	#if USE_TAILCALLS
34331	MUSTTAIL return InterpNext(S);
34332	#else
34333	return true;
34334	#endif
34335	}
34336	PRESERVE_NONE
34337	static bool Interp_InitGlobalTempPtr(InterpState &S) {
34338	{
34339	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34340	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34341	if (!InitGlobalTemp<PT_Ptr>(S, V0, V1)) return false;
34342	}
34343	#if USE_TAILCALLS
34344	MUSTTAIL return InterpNext(S);
34345	#else
34346	return true;
34347	#endif
34348	}
34349	PRESERVE_NONE
34350	static bool Interp_InitGlobalTempMemberPtr(InterpState &S) {
34351	{
34352	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34353	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34354	if (!InitGlobalTemp<PT_MemberPtr>(S, V0, V1)) return false;
34355	}
34356	#if USE_TAILCALLS
34357	MUSTTAIL return InterpNext(S);
34358	#else
34359	return true;
34360	#endif
34361	}
34362	PRESERVE_NONE
34363	static bool Interp_InitGlobalTempFloat(InterpState &S) {
34364	{
34365	const auto V0 = ReadArg<uint32_t>(S, S.PC);
34366	const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34367	if (!InitGlobalTemp<PT_Float>(S, V0, V1)) return false;
34368	}
34369	#if USE_TAILCALLS
34370	MUSTTAIL return InterpNext(S);
34371	#else
34372	return true;
34373	#endif
34374	}
34375	#endif
34376	#ifdef GET_DISASM
34377	case OP_InitGlobalTempSint8:
34378	Text.Op = PrintName("InitGlobalTempSint8");
34379	Text.Args.push_back(printArg<uint32_t>(P, PC));
34380	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34381	break;
34382	case OP_InitGlobalTempUint8:
34383	Text.Op = PrintName("InitGlobalTempUint8");
34384	Text.Args.push_back(printArg<uint32_t>(P, PC));
34385	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34386	break;
34387	case OP_InitGlobalTempSint16:
34388	Text.Op = PrintName("InitGlobalTempSint16");
34389	Text.Args.push_back(printArg<uint32_t>(P, PC));
34390	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34391	break;
34392	case OP_InitGlobalTempUint16:
34393	Text.Op = PrintName("InitGlobalTempUint16");
34394	Text.Args.push_back(printArg<uint32_t>(P, PC));
34395	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34396	break;
34397	case OP_InitGlobalTempSint32:
34398	Text.Op = PrintName("InitGlobalTempSint32");
34399	Text.Args.push_back(printArg<uint32_t>(P, PC));
34400	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34401	break;
34402	case OP_InitGlobalTempUint32:
34403	Text.Op = PrintName("InitGlobalTempUint32");
34404	Text.Args.push_back(printArg<uint32_t>(P, PC));
34405	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34406	break;
34407	case OP_InitGlobalTempSint64:
34408	Text.Op = PrintName("InitGlobalTempSint64");
34409	Text.Args.push_back(printArg<uint32_t>(P, PC));
34410	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34411	break;
34412	case OP_InitGlobalTempUint64:
34413	Text.Op = PrintName("InitGlobalTempUint64");
34414	Text.Args.push_back(printArg<uint32_t>(P, PC));
34415	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34416	break;
34417	case OP_InitGlobalTempIntAP:
34418	Text.Op = PrintName("InitGlobalTempIntAP");
34419	Text.Args.push_back(printArg<uint32_t>(P, PC));
34420	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34421	break;
34422	case OP_InitGlobalTempIntAPS:
34423	Text.Op = PrintName("InitGlobalTempIntAPS");
34424	Text.Args.push_back(printArg<uint32_t>(P, PC));
34425	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34426	break;
34427	case OP_InitGlobalTempBool:
34428	Text.Op = PrintName("InitGlobalTempBool");
34429	Text.Args.push_back(printArg<uint32_t>(P, PC));
34430	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34431	break;
34432	case OP_InitGlobalTempFixedPoint:
34433	Text.Op = PrintName("InitGlobalTempFixedPoint");
34434	Text.Args.push_back(printArg<uint32_t>(P, PC));
34435	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34436	break;
34437	case OP_InitGlobalTempPtr:
34438	Text.Op = PrintName("InitGlobalTempPtr");
34439	Text.Args.push_back(printArg<uint32_t>(P, PC));
34440	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34441	break;
34442	case OP_InitGlobalTempMemberPtr:
34443	Text.Op = PrintName("InitGlobalTempMemberPtr");
34444	Text.Args.push_back(printArg<uint32_t>(P, PC));
34445	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34446	break;
34447	case OP_InitGlobalTempFloat:
34448	Text.Op = PrintName("InitGlobalTempFloat");
34449	Text.Args.push_back(printArg<uint32_t>(P, PC));
34450	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34451	break;
34452	#endif
34453	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
34454	bool emitInitGlobalTempSint8( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34455	bool emitInitGlobalTempUint8( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34456	bool emitInitGlobalTempSint16( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34457	bool emitInitGlobalTempUint16( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34458	bool emitInitGlobalTempSint32( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34459	bool emitInitGlobalTempUint32( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34460	bool emitInitGlobalTempSint64( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34461	bool emitInitGlobalTempUint64( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34462	bool emitInitGlobalTempIntAP( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34463	bool emitInitGlobalTempIntAPS( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34464	bool emitInitGlobalTempBool( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34465	bool emitInitGlobalTempFixedPoint( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34466	bool emitInitGlobalTempPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34467	bool emitInitGlobalTempMemberPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34468	bool emitInitGlobalTempFloat( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
34469	#endif
34470	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
34471	[[nodiscard]] bool emitInitGlobalTemp(PrimType, uint32_t, const LifetimeExtendedTemporaryDecl *, SourceInfo I);
34472	#endif
34473	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
34474	bool
34475	#if defined(GET_EVAL_IMPL)
34476	EvalEmitter
34477	#else
34478	ByteCodeEmitter
34479	#endif
34480	::emitInitGlobalTemp(PrimType T0, uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo I) {
34481	switch (T0) {
34482	case PT_Sint8:
34483	return emitInitGlobalTempSint8(A0, A1, I);
34484	case PT_Uint8:
34485	return emitInitGlobalTempUint8(A0, A1, I);
34486	case PT_Sint16:
34487	return emitInitGlobalTempSint16(A0, A1, I);
34488	case PT_Uint16:
34489	return emitInitGlobalTempUint16(A0, A1, I);
34490	case PT_Sint32:
34491	return emitInitGlobalTempSint32(A0, A1, I);
34492	case PT_Uint32:
34493	return emitInitGlobalTempUint32(A0, A1, I);
34494	case PT_Sint64:
34495	return emitInitGlobalTempSint64(A0, A1, I);
34496	case PT_Uint64:
34497	return emitInitGlobalTempUint64(A0, A1, I);
34498	case PT_IntAP:
34499	return emitInitGlobalTempIntAP(A0, A1, I);
34500	case PT_IntAPS:
34501	return emitInitGlobalTempIntAPS(A0, A1, I);
34502	case PT_Bool:
34503	return emitInitGlobalTempBool(A0, A1, I);
34504	case PT_FixedPoint:
34505	return emitInitGlobalTempFixedPoint(A0, A1, I);
34506	case PT_Ptr:
34507	return emitInitGlobalTempPtr(A0, A1, I);
34508	case PT_MemberPtr:
34509	return emitInitGlobalTempMemberPtr(A0, A1, I);
34510	case PT_Float:
34511	return emitInitGlobalTempFloat(A0, A1, I);
34512	}
34513	llvm_unreachable("invalid enum value");
34514	}
34515	#endif
34516	#ifdef GET_LINK_IMPL
34517	bool ByteCodeEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34518	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint8, A0, A1, L);
34519	}
34520	bool ByteCodeEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34521	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint8, A0, A1, L);
34522	}
34523	bool ByteCodeEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34524	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint16, A0, A1, L);
34525	}
34526	bool ByteCodeEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34527	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint16, A0, A1, L);
34528	}
34529	bool ByteCodeEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34530	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint32, A0, A1, L);
34531	}
34532	bool ByteCodeEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34533	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint32, A0, A1, L);
34534	}
34535	bool ByteCodeEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34536	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint64, A0, A1, L);
34537	}
34538	bool ByteCodeEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34539	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint64, A0, A1, L);
34540	}
34541	bool ByteCodeEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34542	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAP, A0, A1, L);
34543	}
34544	bool ByteCodeEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34545	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAPS, A0, A1, L);
34546	}
34547	bool ByteCodeEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34548	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempBool, A0, A1, L);
34549	}
34550	bool ByteCodeEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34551	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFixedPoint, A0, A1, L);
34552	}
34553	bool ByteCodeEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34554	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempPtr, A0, A1, L);
34555	}
34556	bool ByteCodeEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34557	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempMemberPtr, A0, A1, L);
34558	}
34559	bool ByteCodeEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34560	return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFloat, A0, A1, L);
34561	}
34562	#endif
34563	#ifdef GET_EVAL_IMPL
34564	bool EvalEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34565	if (!isActive()) return true;
34566	CurrentSource = L;
34567	return InitGlobalTemp<PT_Sint8>(S, A0, A1);
34568	}
34569	bool EvalEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34570	if (!isActive()) return true;
34571	CurrentSource = L;
34572	return InitGlobalTemp<PT_Uint8>(S, A0, A1);
34573	}
34574	bool EvalEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34575	if (!isActive()) return true;
34576	CurrentSource = L;
34577	return InitGlobalTemp<PT_Sint16>(S, A0, A1);
34578	}
34579	bool EvalEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34580	if (!isActive()) return true;
34581	CurrentSource = L;
34582	return InitGlobalTemp<PT_Uint16>(S, A0, A1);
34583	}
34584	bool EvalEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34585	if (!isActive()) return true;
34586	CurrentSource = L;
34587	return InitGlobalTemp<PT_Sint32>(S, A0, A1);
34588	}
34589	bool EvalEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34590	if (!isActive()) return true;
34591	CurrentSource = L;
34592	return InitGlobalTemp<PT_Uint32>(S, A0, A1);
34593	}
34594	bool EvalEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34595	if (!isActive()) return true;
34596	CurrentSource = L;
34597	return InitGlobalTemp<PT_Sint64>(S, A0, A1);
34598	}
34599	bool EvalEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34600	if (!isActive()) return true;
34601	CurrentSource = L;
34602	return InitGlobalTemp<PT_Uint64>(S, A0, A1);
34603	}
34604	bool EvalEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34605	if (!isActive()) return true;
34606	CurrentSource = L;
34607	return InitGlobalTemp<PT_IntAP>(S, A0, A1);
34608	}
34609	bool EvalEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34610	if (!isActive()) return true;
34611	CurrentSource = L;
34612	return InitGlobalTemp<PT_IntAPS>(S, A0, A1);
34613	}
34614	bool EvalEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34615	if (!isActive()) return true;
34616	CurrentSource = L;
34617	return InitGlobalTemp<PT_Bool>(S, A0, A1);
34618	}
34619	bool EvalEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34620	if (!isActive()) return true;
34621	CurrentSource = L;
34622	return InitGlobalTemp<PT_FixedPoint>(S, A0, A1);
34623	}
34624	bool EvalEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34625	if (!isActive()) return true;
34626	CurrentSource = L;
34627	return InitGlobalTemp<PT_Ptr>(S, A0, A1);
34628	}
34629	bool EvalEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34630	if (!isActive()) return true;
34631	CurrentSource = L;
34632	return InitGlobalTemp<PT_MemberPtr>(S, A0, A1);
34633	}
34634	bool EvalEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
34635	if (!isActive()) return true;
34636	CurrentSource = L;
34637	return InitGlobalTemp<PT_Float>(S, A0, A1);
34638	}
34639	#endif
34640	#ifdef GET_OPCODE_NAMES
34641	OP_InitGlobalTempComp,
34642	#endif
34643	#ifdef GET_INTERPFN_LIST
34644	&Interp_InitGlobalTempComp,
34645	#endif
34646	#ifdef GET_INTERPFN_DISPATCHERS
34647	PRESERVE_NONE
34648	static bool Interp_InitGlobalTempComp(InterpState &S) {
34649	{
34650	const auto V0 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
34651	if (!InitGlobalTempComp(S, V0)) return false;
34652	}
34653	#if USE_TAILCALLS
34654	MUSTTAIL return InterpNext(S);
34655	#else
34656	return true;
34657	#endif
34658	}
34659	#endif
34660	#ifdef GET_DISASM
34661	case OP_InitGlobalTempComp:
34662	Text.Op = PrintName("InitGlobalTempComp");
34663	Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(P, PC));
34664	break;
34665	#endif
34666	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
34667	bool emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * , SourceInfo);
34668	#endif
34669	#ifdef GET_LINK_IMPL
34670	bool ByteCodeEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, SourceInfo L) {
34671	return emitOp<const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempComp, A0, L);
34672	}
34673	#endif
34674	#ifdef GET_EVAL_IMPL
34675	bool EvalEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, SourceInfo L) {
34676	if (!isActive()) return true;
34677	CurrentSource = L;
34678	return InitGlobalTempComp(S, A0);
34679	}
34680	#endif
34681	#ifdef GET_OPCODE_NAMES
34682	OP_InitPopSint8,
34683	OP_InitPopUint8,
34684	OP_InitPopSint16,
34685	OP_InitPopUint16,
34686	OP_InitPopSint32,
34687	OP_InitPopUint32,
34688	OP_InitPopSint64,
34689	OP_InitPopUint64,
34690	OP_InitPopIntAP,
34691	OP_InitPopIntAPS,
34692	OP_InitPopBool,
34693	OP_InitPopFixedPoint,
34694	OP_InitPopPtr,
34695	OP_InitPopMemberPtr,
34696	OP_InitPopFloat,
34697	#endif
34698	#ifdef GET_INTERPFN_LIST
34699	&Interp_InitPopSint8,
34700	&Interp_InitPopUint8,
34701	&Interp_InitPopSint16,
34702	&Interp_InitPopUint16,
34703	&Interp_InitPopSint32,
34704	&Interp_InitPopUint32,
34705	&Interp_InitPopSint64,
34706	&Interp_InitPopUint64,
34707	&Interp_InitPopIntAP,
34708	&Interp_InitPopIntAPS,
34709	&Interp_InitPopBool,
34710	&Interp_InitPopFixedPoint,
34711	&Interp_InitPopPtr,
34712	&Interp_InitPopMemberPtr,
34713	&Interp_InitPopFloat,
34714	#endif
34715	#ifdef GET_INTERPFN_DISPATCHERS
34716	PRESERVE_NONE
34717	static bool Interp_InitPopSint8(InterpState &S) {
34718	if (!InitPop<PT_Sint8>(S, S.PC)) return false;
34719	#if USE_TAILCALLS
34720	MUSTTAIL return InterpNext(S);
34721	#else
34722	return true;
34723	#endif
34724	}
34725	PRESERVE_NONE
34726	static bool Interp_InitPopUint8(InterpState &S) {
34727	if (!InitPop<PT_Uint8>(S, S.PC)) return false;
34728	#if USE_TAILCALLS
34729	MUSTTAIL return InterpNext(S);
34730	#else
34731	return true;
34732	#endif
34733	}
34734	PRESERVE_NONE
34735	static bool Interp_InitPopSint16(InterpState &S) {
34736	if (!InitPop<PT_Sint16>(S, S.PC)) return false;
34737	#if USE_TAILCALLS
34738	MUSTTAIL return InterpNext(S);
34739	#else
34740	return true;
34741	#endif
34742	}
34743	PRESERVE_NONE
34744	static bool Interp_InitPopUint16(InterpState &S) {
34745	if (!InitPop<PT_Uint16>(S, S.PC)) return false;
34746	#if USE_TAILCALLS
34747	MUSTTAIL return InterpNext(S);
34748	#else
34749	return true;
34750	#endif
34751	}
34752	PRESERVE_NONE
34753	static bool Interp_InitPopSint32(InterpState &S) {
34754	if (!InitPop<PT_Sint32>(S, S.PC)) return false;
34755	#if USE_TAILCALLS
34756	MUSTTAIL return InterpNext(S);
34757	#else
34758	return true;
34759	#endif
34760	}
34761	PRESERVE_NONE
34762	static bool Interp_InitPopUint32(InterpState &S) {
34763	if (!InitPop<PT_Uint32>(S, S.PC)) return false;
34764	#if USE_TAILCALLS
34765	MUSTTAIL return InterpNext(S);
34766	#else
34767	return true;
34768	#endif
34769	}
34770	PRESERVE_NONE
34771	static bool Interp_InitPopSint64(InterpState &S) {
34772	if (!InitPop<PT_Sint64>(S, S.PC)) return false;
34773	#if USE_TAILCALLS
34774	MUSTTAIL return InterpNext(S);
34775	#else
34776	return true;
34777	#endif
34778	}
34779	PRESERVE_NONE
34780	static bool Interp_InitPopUint64(InterpState &S) {
34781	if (!InitPop<PT_Uint64>(S, S.PC)) return false;
34782	#if USE_TAILCALLS
34783	MUSTTAIL return InterpNext(S);
34784	#else
34785	return true;
34786	#endif
34787	}
34788	PRESERVE_NONE
34789	static bool Interp_InitPopIntAP(InterpState &S) {
34790	if (!InitPop<PT_IntAP>(S, S.PC)) return false;
34791	#if USE_TAILCALLS
34792	MUSTTAIL return InterpNext(S);
34793	#else
34794	return true;
34795	#endif
34796	}
34797	PRESERVE_NONE
34798	static bool Interp_InitPopIntAPS(InterpState &S) {
34799	if (!InitPop<PT_IntAPS>(S, S.PC)) return false;
34800	#if USE_TAILCALLS
34801	MUSTTAIL return InterpNext(S);
34802	#else
34803	return true;
34804	#endif
34805	}
34806	PRESERVE_NONE
34807	static bool Interp_InitPopBool(InterpState &S) {
34808	if (!InitPop<PT_Bool>(S, S.PC)) return false;
34809	#if USE_TAILCALLS
34810	MUSTTAIL return InterpNext(S);
34811	#else
34812	return true;
34813	#endif
34814	}
34815	PRESERVE_NONE
34816	static bool Interp_InitPopFixedPoint(InterpState &S) {
34817	if (!InitPop<PT_FixedPoint>(S, S.PC)) return false;
34818	#if USE_TAILCALLS
34819	MUSTTAIL return InterpNext(S);
34820	#else
34821	return true;
34822	#endif
34823	}
34824	PRESERVE_NONE
34825	static bool Interp_InitPopPtr(InterpState &S) {
34826	if (!InitPop<PT_Ptr>(S, S.PC)) return false;
34827	#if USE_TAILCALLS
34828	MUSTTAIL return InterpNext(S);
34829	#else
34830	return true;
34831	#endif
34832	}
34833	PRESERVE_NONE
34834	static bool Interp_InitPopMemberPtr(InterpState &S) {
34835	if (!InitPop<PT_MemberPtr>(S, S.PC)) return false;
34836	#if USE_TAILCALLS
34837	MUSTTAIL return InterpNext(S);
34838	#else
34839	return true;
34840	#endif
34841	}
34842	PRESERVE_NONE
34843	static bool Interp_InitPopFloat(InterpState &S) {
34844	if (!InitPop<PT_Float>(S, S.PC)) return false;
34845	#if USE_TAILCALLS
34846	MUSTTAIL return InterpNext(S);
34847	#else
34848	return true;
34849	#endif
34850	}
34851	#endif
34852	#ifdef GET_DISASM
34853	case OP_InitPopSint8:
34854	Text.Op = PrintName("InitPopSint8");
34855	break;
34856	case OP_InitPopUint8:
34857	Text.Op = PrintName("InitPopUint8");
34858	break;
34859	case OP_InitPopSint16:
34860	Text.Op = PrintName("InitPopSint16");
34861	break;
34862	case OP_InitPopUint16:
34863	Text.Op = PrintName("InitPopUint16");
34864	break;
34865	case OP_InitPopSint32:
34866	Text.Op = PrintName("InitPopSint32");
34867	break;
34868	case OP_InitPopUint32:
34869	Text.Op = PrintName("InitPopUint32");
34870	break;
34871	case OP_InitPopSint64:
34872	Text.Op = PrintName("InitPopSint64");
34873	break;
34874	case OP_InitPopUint64:
34875	Text.Op = PrintName("InitPopUint64");
34876	break;
34877	case OP_InitPopIntAP:
34878	Text.Op = PrintName("InitPopIntAP");
34879	break;
34880	case OP_InitPopIntAPS:
34881	Text.Op = PrintName("InitPopIntAPS");
34882	break;
34883	case OP_InitPopBool:
34884	Text.Op = PrintName("InitPopBool");
34885	break;
34886	case OP_InitPopFixedPoint:
34887	Text.Op = PrintName("InitPopFixedPoint");
34888	break;
34889	case OP_InitPopPtr:
34890	Text.Op = PrintName("InitPopPtr");
34891	break;
34892	case OP_InitPopMemberPtr:
34893	Text.Op = PrintName("InitPopMemberPtr");
34894	break;
34895	case OP_InitPopFloat:
34896	Text.Op = PrintName("InitPopFloat");
34897	break;
34898	#endif
34899	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
34900	bool emitInitPopSint8(SourceInfo);
34901	bool emitInitPopUint8(SourceInfo);
34902	bool emitInitPopSint16(SourceInfo);
34903	bool emitInitPopUint16(SourceInfo);
34904	bool emitInitPopSint32(SourceInfo);
34905	bool emitInitPopUint32(SourceInfo);
34906	bool emitInitPopSint64(SourceInfo);
34907	bool emitInitPopUint64(SourceInfo);
34908	bool emitInitPopIntAP(SourceInfo);
34909	bool emitInitPopIntAPS(SourceInfo);
34910	bool emitInitPopBool(SourceInfo);
34911	bool emitInitPopFixedPoint(SourceInfo);
34912	bool emitInitPopPtr(SourceInfo);
34913	bool emitInitPopMemberPtr(SourceInfo);
34914	bool emitInitPopFloat(SourceInfo);
34915	#endif
34916	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
34917	[[nodiscard]] bool emitInitPop(PrimType, SourceInfo I);
34918	#endif
34919	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
34920	bool
34921	#if defined(GET_EVAL_IMPL)
34922	EvalEmitter
34923	#else
34924	ByteCodeEmitter
34925	#endif
34926	::emitInitPop(PrimType T0, SourceInfo I) {
34927	switch (T0) {
34928	case PT_Sint8:
34929	return emitInitPopSint8(I);
34930	case PT_Uint8:
34931	return emitInitPopUint8(I);
34932	case PT_Sint16:
34933	return emitInitPopSint16(I);
34934	case PT_Uint16:
34935	return emitInitPopUint16(I);
34936	case PT_Sint32:
34937	return emitInitPopSint32(I);
34938	case PT_Uint32:
34939	return emitInitPopUint32(I);
34940	case PT_Sint64:
34941	return emitInitPopSint64(I);
34942	case PT_Uint64:
34943	return emitInitPopUint64(I);
34944	case PT_IntAP:
34945	return emitInitPopIntAP(I);
34946	case PT_IntAPS:
34947	return emitInitPopIntAPS(I);
34948	case PT_Bool:
34949	return emitInitPopBool(I);
34950	case PT_FixedPoint:
34951	return emitInitPopFixedPoint(I);
34952	case PT_Ptr:
34953	return emitInitPopPtr(I);
34954	case PT_MemberPtr:
34955	return emitInitPopMemberPtr(I);
34956	case PT_Float:
34957	return emitInitPopFloat(I);
34958	}
34959	llvm_unreachable("invalid enum value");
34960	}
34961	#endif
34962	#ifdef GET_LINK_IMPL
34963	bool ByteCodeEmitter::emitInitPopSint8(SourceInfo L) {
34964	return emitOp<>(OP_InitPopSint8, L);
34965	}
34966	bool ByteCodeEmitter::emitInitPopUint8(SourceInfo L) {
34967	return emitOp<>(OP_InitPopUint8, L);
34968	}
34969	bool ByteCodeEmitter::emitInitPopSint16(SourceInfo L) {
34970	return emitOp<>(OP_InitPopSint16, L);
34971	}
34972	bool ByteCodeEmitter::emitInitPopUint16(SourceInfo L) {
34973	return emitOp<>(OP_InitPopUint16, L);
34974	}
34975	bool ByteCodeEmitter::emitInitPopSint32(SourceInfo L) {
34976	return emitOp<>(OP_InitPopSint32, L);
34977	}
34978	bool ByteCodeEmitter::emitInitPopUint32(SourceInfo L) {
34979	return emitOp<>(OP_InitPopUint32, L);
34980	}
34981	bool ByteCodeEmitter::emitInitPopSint64(SourceInfo L) {
34982	return emitOp<>(OP_InitPopSint64, L);
34983	}
34984	bool ByteCodeEmitter::emitInitPopUint64(SourceInfo L) {
34985	return emitOp<>(OP_InitPopUint64, L);
34986	}
34987	bool ByteCodeEmitter::emitInitPopIntAP(SourceInfo L) {
34988	return emitOp<>(OP_InitPopIntAP, L);
34989	}
34990	bool ByteCodeEmitter::emitInitPopIntAPS(SourceInfo L) {
34991	return emitOp<>(OP_InitPopIntAPS, L);
34992	}
34993	bool ByteCodeEmitter::emitInitPopBool(SourceInfo L) {
34994	return emitOp<>(OP_InitPopBool, L);
34995	}
34996	bool ByteCodeEmitter::emitInitPopFixedPoint(SourceInfo L) {
34997	return emitOp<>(OP_InitPopFixedPoint, L);
34998	}
34999	bool ByteCodeEmitter::emitInitPopPtr(SourceInfo L) {
35000	return emitOp<>(OP_InitPopPtr, L);
35001	}
35002	bool ByteCodeEmitter::emitInitPopMemberPtr(SourceInfo L) {
35003	return emitOp<>(OP_InitPopMemberPtr, L);
35004	}
35005	bool ByteCodeEmitter::emitInitPopFloat(SourceInfo L) {
35006	return emitOp<>(OP_InitPopFloat, L);
35007	}
35008	#endif
35009	#ifdef GET_EVAL_IMPL
35010	bool EvalEmitter::emitInitPopSint8(SourceInfo L) {
35011	if (!isActive()) return true;
35012	CurrentSource = L;
35013	return InitPop<PT_Sint8>(S, CodePtr());
35014	}
35015	bool EvalEmitter::emitInitPopUint8(SourceInfo L) {
35016	if (!isActive()) return true;
35017	CurrentSource = L;
35018	return InitPop<PT_Uint8>(S, CodePtr());
35019	}
35020	bool EvalEmitter::emitInitPopSint16(SourceInfo L) {
35021	if (!isActive()) return true;
35022	CurrentSource = L;
35023	return InitPop<PT_Sint16>(S, CodePtr());
35024	}
35025	bool EvalEmitter::emitInitPopUint16(SourceInfo L) {
35026	if (!isActive()) return true;
35027	CurrentSource = L;
35028	return InitPop<PT_Uint16>(S, CodePtr());
35029	}
35030	bool EvalEmitter::emitInitPopSint32(SourceInfo L) {
35031	if (!isActive()) return true;
35032	CurrentSource = L;
35033	return InitPop<PT_Sint32>(S, CodePtr());
35034	}
35035	bool EvalEmitter::emitInitPopUint32(SourceInfo L) {
35036	if (!isActive()) return true;
35037	CurrentSource = L;
35038	return InitPop<PT_Uint32>(S, CodePtr());
35039	}
35040	bool EvalEmitter::emitInitPopSint64(SourceInfo L) {
35041	if (!isActive()) return true;
35042	CurrentSource = L;
35043	return InitPop<PT_Sint64>(S, CodePtr());
35044	}
35045	bool EvalEmitter::emitInitPopUint64(SourceInfo L) {
35046	if (!isActive()) return true;
35047	CurrentSource = L;
35048	return InitPop<PT_Uint64>(S, CodePtr());
35049	}
35050	bool EvalEmitter::emitInitPopIntAP(SourceInfo L) {
35051	if (!isActive()) return true;
35052	CurrentSource = L;
35053	return InitPop<PT_IntAP>(S, CodePtr());
35054	}
35055	bool EvalEmitter::emitInitPopIntAPS(SourceInfo L) {
35056	if (!isActive()) return true;
35057	CurrentSource = L;
35058	return InitPop<PT_IntAPS>(S, CodePtr());
35059	}
35060	bool EvalEmitter::emitInitPopBool(SourceInfo L) {
35061	if (!isActive()) return true;
35062	CurrentSource = L;
35063	return InitPop<PT_Bool>(S, CodePtr());
35064	}
35065	bool EvalEmitter::emitInitPopFixedPoint(SourceInfo L) {
35066	if (!isActive()) return true;
35067	CurrentSource = L;
35068	return InitPop<PT_FixedPoint>(S, CodePtr());
35069	}
35070	bool EvalEmitter::emitInitPopPtr(SourceInfo L) {
35071	if (!isActive()) return true;
35072	CurrentSource = L;
35073	return InitPop<PT_Ptr>(S, CodePtr());
35074	}
35075	bool EvalEmitter::emitInitPopMemberPtr(SourceInfo L) {
35076	if (!isActive()) return true;
35077	CurrentSource = L;
35078	return InitPop<PT_MemberPtr>(S, CodePtr());
35079	}
35080	bool EvalEmitter::emitInitPopFloat(SourceInfo L) {
35081	if (!isActive()) return true;
35082	CurrentSource = L;
35083	return InitPop<PT_Float>(S, CodePtr());
35084	}
35085	#endif
35086	#ifdef GET_OPCODE_NAMES
35087	OP_InitScope,
35088	#endif
35089	#ifdef GET_INTERPFN_LIST
35090	&Interp_InitScope,
35091	#endif
35092	#ifdef GET_INTERPFN_DISPATCHERS
35093	PRESERVE_NONE
35094	static bool Interp_InitScope(InterpState &S) {
35095	{
35096	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35097	InitScope(S, V0);
35098	}
35099	#if USE_TAILCALLS
35100	MUSTTAIL return InterpNext(S);
35101	#else
35102	return true;
35103	#endif
35104	}
35105	#endif
35106	#ifdef GET_DISASM
35107	case OP_InitScope:
35108	Text.Op = PrintName("InitScope");
35109	Text.Args.push_back(printArg<uint32_t>(P, PC));
35110	break;
35111	#endif
35112	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
35113	bool emitInitScope( uint32_t , SourceInfo);
35114	#endif
35115	#ifdef GET_LINK_IMPL
35116	bool ByteCodeEmitter::emitInitScope( uint32_t A0, SourceInfo L) {
35117	return emitOp<uint32_t>(OP_InitScope, A0, L);
35118	}
35119	#endif
35120	#ifdef GET_EVAL_IMPL
35121	bool EvalEmitter::emitInitScope( uint32_t A0, SourceInfo L) {
35122	if (!isActive()) return true;
35123	CurrentSource = L;
35124	return InitScope(S, A0);
35125	}
35126	#endif
35127	#ifdef GET_OPCODE_NAMES
35128	OP_InitThisBitFieldSint8,
35129	OP_InitThisBitFieldUint8,
35130	OP_InitThisBitFieldSint16,
35131	OP_InitThisBitFieldUint16,
35132	OP_InitThisBitFieldSint32,
35133	OP_InitThisBitFieldUint32,
35134	OP_InitThisBitFieldSint64,
35135	OP_InitThisBitFieldUint64,
35136	OP_InitThisBitFieldIntAP,
35137	OP_InitThisBitFieldIntAPS,
35138	OP_InitThisBitFieldBool,
35139	#endif
35140	#ifdef GET_INTERPFN_LIST
35141	&Interp_InitThisBitFieldSint8,
35142	&Interp_InitThisBitFieldUint8,
35143	&Interp_InitThisBitFieldSint16,
35144	&Interp_InitThisBitFieldUint16,
35145	&Interp_InitThisBitFieldSint32,
35146	&Interp_InitThisBitFieldUint32,
35147	&Interp_InitThisBitFieldSint64,
35148	&Interp_InitThisBitFieldUint64,
35149	&Interp_InitThisBitFieldIntAP,
35150	&Interp_InitThisBitFieldIntAPS,
35151	&Interp_InitThisBitFieldBool,
35152	#endif
35153	#ifdef GET_INTERPFN_DISPATCHERS
35154	PRESERVE_NONE
35155	static bool Interp_InitThisBitFieldSint8(InterpState &S) {
35156	{
35157	CodePtr OpPC = S.PC;
35158	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35159	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35160	if (!InitThisBitField<PT_Sint8>(S, OpPC, V0, V1)) return false;
35161	}
35162	#if USE_TAILCALLS
35163	MUSTTAIL return InterpNext(S);
35164	#else
35165	return true;
35166	#endif
35167	}
35168	PRESERVE_NONE
35169	static bool Interp_InitThisBitFieldUint8(InterpState &S) {
35170	{
35171	CodePtr OpPC = S.PC;
35172	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35173	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35174	if (!InitThisBitField<PT_Uint8>(S, OpPC, V0, V1)) return false;
35175	}
35176	#if USE_TAILCALLS
35177	MUSTTAIL return InterpNext(S);
35178	#else
35179	return true;
35180	#endif
35181	}
35182	PRESERVE_NONE
35183	static bool Interp_InitThisBitFieldSint16(InterpState &S) {
35184	{
35185	CodePtr OpPC = S.PC;
35186	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35187	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35188	if (!InitThisBitField<PT_Sint16>(S, OpPC, V0, V1)) return false;
35189	}
35190	#if USE_TAILCALLS
35191	MUSTTAIL return InterpNext(S);
35192	#else
35193	return true;
35194	#endif
35195	}
35196	PRESERVE_NONE
35197	static bool Interp_InitThisBitFieldUint16(InterpState &S) {
35198	{
35199	CodePtr OpPC = S.PC;
35200	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35201	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35202	if (!InitThisBitField<PT_Uint16>(S, OpPC, V0, V1)) return false;
35203	}
35204	#if USE_TAILCALLS
35205	MUSTTAIL return InterpNext(S);
35206	#else
35207	return true;
35208	#endif
35209	}
35210	PRESERVE_NONE
35211	static bool Interp_InitThisBitFieldSint32(InterpState &S) {
35212	{
35213	CodePtr OpPC = S.PC;
35214	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35215	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35216	if (!InitThisBitField<PT_Sint32>(S, OpPC, V0, V1)) return false;
35217	}
35218	#if USE_TAILCALLS
35219	MUSTTAIL return InterpNext(S);
35220	#else
35221	return true;
35222	#endif
35223	}
35224	PRESERVE_NONE
35225	static bool Interp_InitThisBitFieldUint32(InterpState &S) {
35226	{
35227	CodePtr OpPC = S.PC;
35228	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35229	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35230	if (!InitThisBitField<PT_Uint32>(S, OpPC, V0, V1)) return false;
35231	}
35232	#if USE_TAILCALLS
35233	MUSTTAIL return InterpNext(S);
35234	#else
35235	return true;
35236	#endif
35237	}
35238	PRESERVE_NONE
35239	static bool Interp_InitThisBitFieldSint64(InterpState &S) {
35240	{
35241	CodePtr OpPC = S.PC;
35242	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35243	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35244	if (!InitThisBitField<PT_Sint64>(S, OpPC, V0, V1)) return false;
35245	}
35246	#if USE_TAILCALLS
35247	MUSTTAIL return InterpNext(S);
35248	#else
35249	return true;
35250	#endif
35251	}
35252	PRESERVE_NONE
35253	static bool Interp_InitThisBitFieldUint64(InterpState &S) {
35254	{
35255	CodePtr OpPC = S.PC;
35256	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35257	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35258	if (!InitThisBitField<PT_Uint64>(S, OpPC, V0, V1)) return false;
35259	}
35260	#if USE_TAILCALLS
35261	MUSTTAIL return InterpNext(S);
35262	#else
35263	return true;
35264	#endif
35265	}
35266	PRESERVE_NONE
35267	static bool Interp_InitThisBitFieldIntAP(InterpState &S) {
35268	{
35269	CodePtr OpPC = S.PC;
35270	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35271	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35272	if (!InitThisBitField<PT_IntAP>(S, OpPC, V0, V1)) return false;
35273	}
35274	#if USE_TAILCALLS
35275	MUSTTAIL return InterpNext(S);
35276	#else
35277	return true;
35278	#endif
35279	}
35280	PRESERVE_NONE
35281	static bool Interp_InitThisBitFieldIntAPS(InterpState &S) {
35282	{
35283	CodePtr OpPC = S.PC;
35284	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35285	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35286	if (!InitThisBitField<PT_IntAPS>(S, OpPC, V0, V1)) return false;
35287	}
35288	#if USE_TAILCALLS
35289	MUSTTAIL return InterpNext(S);
35290	#else
35291	return true;
35292	#endif
35293	}
35294	PRESERVE_NONE
35295	static bool Interp_InitThisBitFieldBool(InterpState &S) {
35296	{
35297	CodePtr OpPC = S.PC;
35298	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35299	const auto V1 = ReadArg<uint32_t>(S, S.PC);
35300	if (!InitThisBitField<PT_Bool>(S, OpPC, V0, V1)) return false;
35301	}
35302	#if USE_TAILCALLS
35303	MUSTTAIL return InterpNext(S);
35304	#else
35305	return true;
35306	#endif
35307	}
35308	#endif
35309	#ifdef GET_DISASM
35310	case OP_InitThisBitFieldSint8:
35311	Text.Op = PrintName("InitThisBitFieldSint8");
35312	Text.Args.push_back(printArg<uint32_t>(P, PC));
35313	Text.Args.push_back(printArg<uint32_t>(P, PC));
35314	break;
35315	case OP_InitThisBitFieldUint8:
35316	Text.Op = PrintName("InitThisBitFieldUint8");
35317	Text.Args.push_back(printArg<uint32_t>(P, PC));
35318	Text.Args.push_back(printArg<uint32_t>(P, PC));
35319	break;
35320	case OP_InitThisBitFieldSint16:
35321	Text.Op = PrintName("InitThisBitFieldSint16");
35322	Text.Args.push_back(printArg<uint32_t>(P, PC));
35323	Text.Args.push_back(printArg<uint32_t>(P, PC));
35324	break;
35325	case OP_InitThisBitFieldUint16:
35326	Text.Op = PrintName("InitThisBitFieldUint16");
35327	Text.Args.push_back(printArg<uint32_t>(P, PC));
35328	Text.Args.push_back(printArg<uint32_t>(P, PC));
35329	break;
35330	case OP_InitThisBitFieldSint32:
35331	Text.Op = PrintName("InitThisBitFieldSint32");
35332	Text.Args.push_back(printArg<uint32_t>(P, PC));
35333	Text.Args.push_back(printArg<uint32_t>(P, PC));
35334	break;
35335	case OP_InitThisBitFieldUint32:
35336	Text.Op = PrintName("InitThisBitFieldUint32");
35337	Text.Args.push_back(printArg<uint32_t>(P, PC));
35338	Text.Args.push_back(printArg<uint32_t>(P, PC));
35339	break;
35340	case OP_InitThisBitFieldSint64:
35341	Text.Op = PrintName("InitThisBitFieldSint64");
35342	Text.Args.push_back(printArg<uint32_t>(P, PC));
35343	Text.Args.push_back(printArg<uint32_t>(P, PC));
35344	break;
35345	case OP_InitThisBitFieldUint64:
35346	Text.Op = PrintName("InitThisBitFieldUint64");
35347	Text.Args.push_back(printArg<uint32_t>(P, PC));
35348	Text.Args.push_back(printArg<uint32_t>(P, PC));
35349	break;
35350	case OP_InitThisBitFieldIntAP:
35351	Text.Op = PrintName("InitThisBitFieldIntAP");
35352	Text.Args.push_back(printArg<uint32_t>(P, PC));
35353	Text.Args.push_back(printArg<uint32_t>(P, PC));
35354	break;
35355	case OP_InitThisBitFieldIntAPS:
35356	Text.Op = PrintName("InitThisBitFieldIntAPS");
35357	Text.Args.push_back(printArg<uint32_t>(P, PC));
35358	Text.Args.push_back(printArg<uint32_t>(P, PC));
35359	break;
35360	case OP_InitThisBitFieldBool:
35361	Text.Op = PrintName("InitThisBitFieldBool");
35362	Text.Args.push_back(printArg<uint32_t>(P, PC));
35363	Text.Args.push_back(printArg<uint32_t>(P, PC));
35364	break;
35365	#endif
35366	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
35367	bool emitInitThisBitFieldSint8( uint32_t , uint32_t , SourceInfo);
35368	bool emitInitThisBitFieldUint8( uint32_t , uint32_t , SourceInfo);
35369	bool emitInitThisBitFieldSint16( uint32_t , uint32_t , SourceInfo);
35370	bool emitInitThisBitFieldUint16( uint32_t , uint32_t , SourceInfo);
35371	bool emitInitThisBitFieldSint32( uint32_t , uint32_t , SourceInfo);
35372	bool emitInitThisBitFieldUint32( uint32_t , uint32_t , SourceInfo);
35373	bool emitInitThisBitFieldSint64( uint32_t , uint32_t , SourceInfo);
35374	bool emitInitThisBitFieldUint64( uint32_t , uint32_t , SourceInfo);
35375	bool emitInitThisBitFieldIntAP( uint32_t , uint32_t , SourceInfo);
35376	bool emitInitThisBitFieldIntAPS( uint32_t , uint32_t , SourceInfo);
35377	bool emitInitThisBitFieldBool( uint32_t , uint32_t , SourceInfo);
35378	#endif
35379	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
35380	[[nodiscard]] bool emitInitThisBitField(PrimType, uint32_t, uint32_t, SourceInfo I);
35381	#endif
35382	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
35383	bool
35384	#if defined(GET_EVAL_IMPL)
35385	EvalEmitter
35386	#else
35387	ByteCodeEmitter
35388	#endif
35389	::emitInitThisBitField(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
35390	switch (T0) {
35391	case PT_Sint8:
35392	return emitInitThisBitFieldSint8(A0, A1, I);
35393	case PT_Uint8:
35394	return emitInitThisBitFieldUint8(A0, A1, I);
35395	case PT_Sint16:
35396	return emitInitThisBitFieldSint16(A0, A1, I);
35397	case PT_Uint16:
35398	return emitInitThisBitFieldUint16(A0, A1, I);
35399	case PT_Sint32:
35400	return emitInitThisBitFieldSint32(A0, A1, I);
35401	case PT_Uint32:
35402	return emitInitThisBitFieldUint32(A0, A1, I);
35403	case PT_Sint64:
35404	return emitInitThisBitFieldSint64(A0, A1, I);
35405	case PT_Uint64:
35406	return emitInitThisBitFieldUint64(A0, A1, I);
35407	case PT_IntAP:
35408	return emitInitThisBitFieldIntAP(A0, A1, I);
35409	case PT_IntAPS:
35410	return emitInitThisBitFieldIntAPS(A0, A1, I);
35411	case PT_Bool:
35412	return emitInitThisBitFieldBool(A0, A1, I);
35413	default: llvm_unreachable("invalid type: emitInitThisBitField");
35414	}
35415	llvm_unreachable("invalid enum value");
35416	}
35417	#endif
35418	#ifdef GET_LINK_IMPL
35419	bool ByteCodeEmitter::emitInitThisBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
35420	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint8, A0, A1, L);
35421	}
35422	bool ByteCodeEmitter::emitInitThisBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
35423	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint8, A0, A1, L);
35424	}
35425	bool ByteCodeEmitter::emitInitThisBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
35426	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint16, A0, A1, L);
35427	}
35428	bool ByteCodeEmitter::emitInitThisBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
35429	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint16, A0, A1, L);
35430	}
35431	bool ByteCodeEmitter::emitInitThisBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
35432	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint32, A0, A1, L);
35433	}
35434	bool ByteCodeEmitter::emitInitThisBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
35435	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint32, A0, A1, L);
35436	}
35437	bool ByteCodeEmitter::emitInitThisBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
35438	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint64, A0, A1, L);
35439	}
35440	bool ByteCodeEmitter::emitInitThisBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
35441	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint64, A0, A1, L);
35442	}
35443	bool ByteCodeEmitter::emitInitThisBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
35444	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldIntAP, A0, A1, L);
35445	}
35446	bool ByteCodeEmitter::emitInitThisBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
35447	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldIntAPS, A0, A1, L);
35448	}
35449	bool ByteCodeEmitter::emitInitThisBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
35450	return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldBool, A0, A1, L);
35451	}
35452	#endif
35453	#ifdef GET_EVAL_IMPL
35454	bool EvalEmitter::emitInitThisBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
35455	if (!isActive()) return true;
35456	CurrentSource = L;
35457	return InitThisBitField<PT_Sint8>(S, CodePtr(), A0, A1);
35458	}
35459	bool EvalEmitter::emitInitThisBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
35460	if (!isActive()) return true;
35461	CurrentSource = L;
35462	return InitThisBitField<PT_Uint8>(S, CodePtr(), A0, A1);
35463	}
35464	bool EvalEmitter::emitInitThisBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
35465	if (!isActive()) return true;
35466	CurrentSource = L;
35467	return InitThisBitField<PT_Sint16>(S, CodePtr(), A0, A1);
35468	}
35469	bool EvalEmitter::emitInitThisBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
35470	if (!isActive()) return true;
35471	CurrentSource = L;
35472	return InitThisBitField<PT_Uint16>(S, CodePtr(), A0, A1);
35473	}
35474	bool EvalEmitter::emitInitThisBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
35475	if (!isActive()) return true;
35476	CurrentSource = L;
35477	return InitThisBitField<PT_Sint32>(S, CodePtr(), A0, A1);
35478	}
35479	bool EvalEmitter::emitInitThisBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
35480	if (!isActive()) return true;
35481	CurrentSource = L;
35482	return InitThisBitField<PT_Uint32>(S, CodePtr(), A0, A1);
35483	}
35484	bool EvalEmitter::emitInitThisBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
35485	if (!isActive()) return true;
35486	CurrentSource = L;
35487	return InitThisBitField<PT_Sint64>(S, CodePtr(), A0, A1);
35488	}
35489	bool EvalEmitter::emitInitThisBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
35490	if (!isActive()) return true;
35491	CurrentSource = L;
35492	return InitThisBitField<PT_Uint64>(S, CodePtr(), A0, A1);
35493	}
35494	bool EvalEmitter::emitInitThisBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
35495	if (!isActive()) return true;
35496	CurrentSource = L;
35497	return InitThisBitField<PT_IntAP>(S, CodePtr(), A0, A1);
35498	}
35499	bool EvalEmitter::emitInitThisBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
35500	if (!isActive()) return true;
35501	CurrentSource = L;
35502	return InitThisBitField<PT_IntAPS>(S, CodePtr(), A0, A1);
35503	}
35504	bool EvalEmitter::emitInitThisBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
35505	if (!isActive()) return true;
35506	CurrentSource = L;
35507	return InitThisBitField<PT_Bool>(S, CodePtr(), A0, A1);
35508	}
35509	#endif
35510	#ifdef GET_OPCODE_NAMES
35511	OP_InitThisFieldSint8,
35512	OP_InitThisFieldUint8,
35513	OP_InitThisFieldSint16,
35514	OP_InitThisFieldUint16,
35515	OP_InitThisFieldSint32,
35516	OP_InitThisFieldUint32,
35517	OP_InitThisFieldSint64,
35518	OP_InitThisFieldUint64,
35519	OP_InitThisFieldIntAP,
35520	OP_InitThisFieldIntAPS,
35521	OP_InitThisFieldBool,
35522	OP_InitThisFieldFixedPoint,
35523	OP_InitThisFieldPtr,
35524	OP_InitThisFieldMemberPtr,
35525	OP_InitThisFieldFloat,
35526	#endif
35527	#ifdef GET_INTERPFN_LIST
35528	&Interp_InitThisFieldSint8,
35529	&Interp_InitThisFieldUint8,
35530	&Interp_InitThisFieldSint16,
35531	&Interp_InitThisFieldUint16,
35532	&Interp_InitThisFieldSint32,
35533	&Interp_InitThisFieldUint32,
35534	&Interp_InitThisFieldSint64,
35535	&Interp_InitThisFieldUint64,
35536	&Interp_InitThisFieldIntAP,
35537	&Interp_InitThisFieldIntAPS,
35538	&Interp_InitThisFieldBool,
35539	&Interp_InitThisFieldFixedPoint,
35540	&Interp_InitThisFieldPtr,
35541	&Interp_InitThisFieldMemberPtr,
35542	&Interp_InitThisFieldFloat,
35543	#endif
35544	#ifdef GET_INTERPFN_DISPATCHERS
35545	PRESERVE_NONE
35546	static bool Interp_InitThisFieldSint8(InterpState &S) {
35547	{
35548	CodePtr OpPC = S.PC;
35549	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35550	if (!InitThisField<PT_Sint8>(S, OpPC, V0)) return false;
35551	}
35552	#if USE_TAILCALLS
35553	MUSTTAIL return InterpNext(S);
35554	#else
35555	return true;
35556	#endif
35557	}
35558	PRESERVE_NONE
35559	static bool Interp_InitThisFieldUint8(InterpState &S) {
35560	{
35561	CodePtr OpPC = S.PC;
35562	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35563	if (!InitThisField<PT_Uint8>(S, OpPC, V0)) return false;
35564	}
35565	#if USE_TAILCALLS
35566	MUSTTAIL return InterpNext(S);
35567	#else
35568	return true;
35569	#endif
35570	}
35571	PRESERVE_NONE
35572	static bool Interp_InitThisFieldSint16(InterpState &S) {
35573	{
35574	CodePtr OpPC = S.PC;
35575	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35576	if (!InitThisField<PT_Sint16>(S, OpPC, V0)) return false;
35577	}
35578	#if USE_TAILCALLS
35579	MUSTTAIL return InterpNext(S);
35580	#else
35581	return true;
35582	#endif
35583	}
35584	PRESERVE_NONE
35585	static bool Interp_InitThisFieldUint16(InterpState &S) {
35586	{
35587	CodePtr OpPC = S.PC;
35588	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35589	if (!InitThisField<PT_Uint16>(S, OpPC, V0)) return false;
35590	}
35591	#if USE_TAILCALLS
35592	MUSTTAIL return InterpNext(S);
35593	#else
35594	return true;
35595	#endif
35596	}
35597	PRESERVE_NONE
35598	static bool Interp_InitThisFieldSint32(InterpState &S) {
35599	{
35600	CodePtr OpPC = S.PC;
35601	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35602	if (!InitThisField<PT_Sint32>(S, OpPC, V0)) return false;
35603	}
35604	#if USE_TAILCALLS
35605	MUSTTAIL return InterpNext(S);
35606	#else
35607	return true;
35608	#endif
35609	}
35610	PRESERVE_NONE
35611	static bool Interp_InitThisFieldUint32(InterpState &S) {
35612	{
35613	CodePtr OpPC = S.PC;
35614	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35615	if (!InitThisField<PT_Uint32>(S, OpPC, V0)) return false;
35616	}
35617	#if USE_TAILCALLS
35618	MUSTTAIL return InterpNext(S);
35619	#else
35620	return true;
35621	#endif
35622	}
35623	PRESERVE_NONE
35624	static bool Interp_InitThisFieldSint64(InterpState &S) {
35625	{
35626	CodePtr OpPC = S.PC;
35627	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35628	if (!InitThisField<PT_Sint64>(S, OpPC, V0)) return false;
35629	}
35630	#if USE_TAILCALLS
35631	MUSTTAIL return InterpNext(S);
35632	#else
35633	return true;
35634	#endif
35635	}
35636	PRESERVE_NONE
35637	static bool Interp_InitThisFieldUint64(InterpState &S) {
35638	{
35639	CodePtr OpPC = S.PC;
35640	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35641	if (!InitThisField<PT_Uint64>(S, OpPC, V0)) return false;
35642	}
35643	#if USE_TAILCALLS
35644	MUSTTAIL return InterpNext(S);
35645	#else
35646	return true;
35647	#endif
35648	}
35649	PRESERVE_NONE
35650	static bool Interp_InitThisFieldIntAP(InterpState &S) {
35651	{
35652	CodePtr OpPC = S.PC;
35653	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35654	if (!InitThisField<PT_IntAP>(S, OpPC, V0)) return false;
35655	}
35656	#if USE_TAILCALLS
35657	MUSTTAIL return InterpNext(S);
35658	#else
35659	return true;
35660	#endif
35661	}
35662	PRESERVE_NONE
35663	static bool Interp_InitThisFieldIntAPS(InterpState &S) {
35664	{
35665	CodePtr OpPC = S.PC;
35666	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35667	if (!InitThisField<PT_IntAPS>(S, OpPC, V0)) return false;
35668	}
35669	#if USE_TAILCALLS
35670	MUSTTAIL return InterpNext(S);
35671	#else
35672	return true;
35673	#endif
35674	}
35675	PRESERVE_NONE
35676	static bool Interp_InitThisFieldBool(InterpState &S) {
35677	{
35678	CodePtr OpPC = S.PC;
35679	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35680	if (!InitThisField<PT_Bool>(S, OpPC, V0)) return false;
35681	}
35682	#if USE_TAILCALLS
35683	MUSTTAIL return InterpNext(S);
35684	#else
35685	return true;
35686	#endif
35687	}
35688	PRESERVE_NONE
35689	static bool Interp_InitThisFieldFixedPoint(InterpState &S) {
35690	{
35691	CodePtr OpPC = S.PC;
35692	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35693	if (!InitThisField<PT_FixedPoint>(S, OpPC, V0)) return false;
35694	}
35695	#if USE_TAILCALLS
35696	MUSTTAIL return InterpNext(S);
35697	#else
35698	return true;
35699	#endif
35700	}
35701	PRESERVE_NONE
35702	static bool Interp_InitThisFieldPtr(InterpState &S) {
35703	{
35704	CodePtr OpPC = S.PC;
35705	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35706	if (!InitThisField<PT_Ptr>(S, OpPC, V0)) return false;
35707	}
35708	#if USE_TAILCALLS
35709	MUSTTAIL return InterpNext(S);
35710	#else
35711	return true;
35712	#endif
35713	}
35714	PRESERVE_NONE
35715	static bool Interp_InitThisFieldMemberPtr(InterpState &S) {
35716	{
35717	CodePtr OpPC = S.PC;
35718	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35719	if (!InitThisField<PT_MemberPtr>(S, OpPC, V0)) return false;
35720	}
35721	#if USE_TAILCALLS
35722	MUSTTAIL return InterpNext(S);
35723	#else
35724	return true;
35725	#endif
35726	}
35727	PRESERVE_NONE
35728	static bool Interp_InitThisFieldFloat(InterpState &S) {
35729	{
35730	CodePtr OpPC = S.PC;
35731	const auto V0 = ReadArg<uint32_t>(S, S.PC);
35732	if (!InitThisField<PT_Float>(S, OpPC, V0)) return false;
35733	}
35734	#if USE_TAILCALLS
35735	MUSTTAIL return InterpNext(S);
35736	#else
35737	return true;
35738	#endif
35739	}
35740	#endif
35741	#ifdef GET_DISASM
35742	case OP_InitThisFieldSint8:
35743	Text.Op = PrintName("InitThisFieldSint8");
35744	Text.Args.push_back(printArg<uint32_t>(P, PC));
35745	break;
35746	case OP_InitThisFieldUint8:
35747	Text.Op = PrintName("InitThisFieldUint8");
35748	Text.Args.push_back(printArg<uint32_t>(P, PC));
35749	break;
35750	case OP_InitThisFieldSint16:
35751	Text.Op = PrintName("InitThisFieldSint16");
35752	Text.Args.push_back(printArg<uint32_t>(P, PC));
35753	break;
35754	case OP_InitThisFieldUint16:
35755	Text.Op = PrintName("InitThisFieldUint16");
35756	Text.Args.push_back(printArg<uint32_t>(P, PC));
35757	break;
35758	case OP_InitThisFieldSint32:
35759	Text.Op = PrintName("InitThisFieldSint32");
35760	Text.Args.push_back(printArg<uint32_t>(P, PC));
35761	break;
35762	case OP_InitThisFieldUint32:
35763	Text.Op = PrintName("InitThisFieldUint32");
35764	Text.Args.push_back(printArg<uint32_t>(P, PC));
35765	break;
35766	case OP_InitThisFieldSint64:
35767	Text.Op = PrintName("InitThisFieldSint64");
35768	Text.Args.push_back(printArg<uint32_t>(P, PC));
35769	break;
35770	case OP_InitThisFieldUint64:
35771	Text.Op = PrintName("InitThisFieldUint64");
35772	Text.Args.push_back(printArg<uint32_t>(P, PC));
35773	break;
35774	case OP_InitThisFieldIntAP:
35775	Text.Op = PrintName("InitThisFieldIntAP");
35776	Text.Args.push_back(printArg<uint32_t>(P, PC));
35777	break;
35778	case OP_InitThisFieldIntAPS:
35779	Text.Op = PrintName("InitThisFieldIntAPS");
35780	Text.Args.push_back(printArg<uint32_t>(P, PC));
35781	break;
35782	case OP_InitThisFieldBool:
35783	Text.Op = PrintName("InitThisFieldBool");
35784	Text.Args.push_back(printArg<uint32_t>(P, PC));
35785	break;
35786	case OP_InitThisFieldFixedPoint:
35787	Text.Op = PrintName("InitThisFieldFixedPoint");
35788	Text.Args.push_back(printArg<uint32_t>(P, PC));
35789	break;
35790	case OP_InitThisFieldPtr:
35791	Text.Op = PrintName("InitThisFieldPtr");
35792	Text.Args.push_back(printArg<uint32_t>(P, PC));
35793	break;
35794	case OP_InitThisFieldMemberPtr:
35795	Text.Op = PrintName("InitThisFieldMemberPtr");
35796	Text.Args.push_back(printArg<uint32_t>(P, PC));
35797	break;
35798	case OP_InitThisFieldFloat:
35799	Text.Op = PrintName("InitThisFieldFloat");
35800	Text.Args.push_back(printArg<uint32_t>(P, PC));
35801	break;
35802	#endif
35803	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
35804	bool emitInitThisFieldSint8( uint32_t , SourceInfo);
35805	bool emitInitThisFieldUint8( uint32_t , SourceInfo);
35806	bool emitInitThisFieldSint16( uint32_t , SourceInfo);
35807	bool emitInitThisFieldUint16( uint32_t , SourceInfo);
35808	bool emitInitThisFieldSint32( uint32_t , SourceInfo);
35809	bool emitInitThisFieldUint32( uint32_t , SourceInfo);
35810	bool emitInitThisFieldSint64( uint32_t , SourceInfo);
35811	bool emitInitThisFieldUint64( uint32_t , SourceInfo);
35812	bool emitInitThisFieldIntAP( uint32_t , SourceInfo);
35813	bool emitInitThisFieldIntAPS( uint32_t , SourceInfo);
35814	bool emitInitThisFieldBool( uint32_t , SourceInfo);
35815	bool emitInitThisFieldFixedPoint( uint32_t , SourceInfo);
35816	bool emitInitThisFieldPtr( uint32_t , SourceInfo);
35817	bool emitInitThisFieldMemberPtr( uint32_t , SourceInfo);
35818	bool emitInitThisFieldFloat( uint32_t , SourceInfo);
35819	#endif
35820	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
35821	[[nodiscard]] bool emitInitThisField(PrimType, uint32_t, SourceInfo I);
35822	#endif
35823	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
35824	bool
35825	#if defined(GET_EVAL_IMPL)
35826	EvalEmitter
35827	#else
35828	ByteCodeEmitter
35829	#endif
35830	::emitInitThisField(PrimType T0, uint32_t A0, SourceInfo I) {
35831	switch (T0) {
35832	case PT_Sint8:
35833	return emitInitThisFieldSint8(A0, I);
35834	case PT_Uint8:
35835	return emitInitThisFieldUint8(A0, I);
35836	case PT_Sint16:
35837	return emitInitThisFieldSint16(A0, I);
35838	case PT_Uint16:
35839	return emitInitThisFieldUint16(A0, I);
35840	case PT_Sint32:
35841	return emitInitThisFieldSint32(A0, I);
35842	case PT_Uint32:
35843	return emitInitThisFieldUint32(A0, I);
35844	case PT_Sint64:
35845	return emitInitThisFieldSint64(A0, I);
35846	case PT_Uint64:
35847	return emitInitThisFieldUint64(A0, I);
35848	case PT_IntAP:
35849	return emitInitThisFieldIntAP(A0, I);
35850	case PT_IntAPS:
35851	return emitInitThisFieldIntAPS(A0, I);
35852	case PT_Bool:
35853	return emitInitThisFieldBool(A0, I);
35854	case PT_FixedPoint:
35855	return emitInitThisFieldFixedPoint(A0, I);
35856	case PT_Ptr:
35857	return emitInitThisFieldPtr(A0, I);
35858	case PT_MemberPtr:
35859	return emitInitThisFieldMemberPtr(A0, I);
35860	case PT_Float:
35861	return emitInitThisFieldFloat(A0, I);
35862	}
35863	llvm_unreachable("invalid enum value");
35864	}
35865	#endif
35866	#ifdef GET_LINK_IMPL
35867	bool ByteCodeEmitter::emitInitThisFieldSint8( uint32_t A0, SourceInfo L) {
35868	return emitOp<uint32_t>(OP_InitThisFieldSint8, A0, L);
35869	}
35870	bool ByteCodeEmitter::emitInitThisFieldUint8( uint32_t A0, SourceInfo L) {
35871	return emitOp<uint32_t>(OP_InitThisFieldUint8, A0, L);
35872	}
35873	bool ByteCodeEmitter::emitInitThisFieldSint16( uint32_t A0, SourceInfo L) {
35874	return emitOp<uint32_t>(OP_InitThisFieldSint16, A0, L);
35875	}
35876	bool ByteCodeEmitter::emitInitThisFieldUint16( uint32_t A0, SourceInfo L) {
35877	return emitOp<uint32_t>(OP_InitThisFieldUint16, A0, L);
35878	}
35879	bool ByteCodeEmitter::emitInitThisFieldSint32( uint32_t A0, SourceInfo L) {
35880	return emitOp<uint32_t>(OP_InitThisFieldSint32, A0, L);
35881	}
35882	bool ByteCodeEmitter::emitInitThisFieldUint32( uint32_t A0, SourceInfo L) {
35883	return emitOp<uint32_t>(OP_InitThisFieldUint32, A0, L);
35884	}
35885	bool ByteCodeEmitter::emitInitThisFieldSint64( uint32_t A0, SourceInfo L) {
35886	return emitOp<uint32_t>(OP_InitThisFieldSint64, A0, L);
35887	}
35888	bool ByteCodeEmitter::emitInitThisFieldUint64( uint32_t A0, SourceInfo L) {
35889	return emitOp<uint32_t>(OP_InitThisFieldUint64, A0, L);
35890	}
35891	bool ByteCodeEmitter::emitInitThisFieldIntAP( uint32_t A0, SourceInfo L) {
35892	return emitOp<uint32_t>(OP_InitThisFieldIntAP, A0, L);
35893	}
35894	bool ByteCodeEmitter::emitInitThisFieldIntAPS( uint32_t A0, SourceInfo L) {
35895	return emitOp<uint32_t>(OP_InitThisFieldIntAPS, A0, L);
35896	}
35897	bool ByteCodeEmitter::emitInitThisFieldBool( uint32_t A0, SourceInfo L) {
35898	return emitOp<uint32_t>(OP_InitThisFieldBool, A0, L);
35899	}
35900	bool ByteCodeEmitter::emitInitThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
35901	return emitOp<uint32_t>(OP_InitThisFieldFixedPoint, A0, L);
35902	}
35903	bool ByteCodeEmitter::emitInitThisFieldPtr( uint32_t A0, SourceInfo L) {
35904	return emitOp<uint32_t>(OP_InitThisFieldPtr, A0, L);
35905	}
35906	bool ByteCodeEmitter::emitInitThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
35907	return emitOp<uint32_t>(OP_InitThisFieldMemberPtr, A0, L);
35908	}
35909	bool ByteCodeEmitter::emitInitThisFieldFloat( uint32_t A0, SourceInfo L) {
35910	return emitOp<uint32_t>(OP_InitThisFieldFloat, A0, L);
35911	}
35912	#endif
35913	#ifdef GET_EVAL_IMPL
35914	bool EvalEmitter::emitInitThisFieldSint8( uint32_t A0, SourceInfo L) {
35915	if (!isActive()) return true;
35916	CurrentSource = L;
35917	return InitThisField<PT_Sint8>(S, CodePtr(), A0);
35918	}
35919	bool EvalEmitter::emitInitThisFieldUint8( uint32_t A0, SourceInfo L) {
35920	if (!isActive()) return true;
35921	CurrentSource = L;
35922	return InitThisField<PT_Uint8>(S, CodePtr(), A0);
35923	}
35924	bool EvalEmitter::emitInitThisFieldSint16( uint32_t A0, SourceInfo L) {
35925	if (!isActive()) return true;
35926	CurrentSource = L;
35927	return InitThisField<PT_Sint16>(S, CodePtr(), A0);
35928	}
35929	bool EvalEmitter::emitInitThisFieldUint16( uint32_t A0, SourceInfo L) {
35930	if (!isActive()) return true;
35931	CurrentSource = L;
35932	return InitThisField<PT_Uint16>(S, CodePtr(), A0);
35933	}
35934	bool EvalEmitter::emitInitThisFieldSint32( uint32_t A0, SourceInfo L) {
35935	if (!isActive()) return true;
35936	CurrentSource = L;
35937	return InitThisField<PT_Sint32>(S, CodePtr(), A0);
35938	}
35939	bool EvalEmitter::emitInitThisFieldUint32( uint32_t A0, SourceInfo L) {
35940	if (!isActive()) return true;
35941	CurrentSource = L;
35942	return InitThisField<PT_Uint32>(S, CodePtr(), A0);
35943	}
35944	bool EvalEmitter::emitInitThisFieldSint64( uint32_t A0, SourceInfo L) {
35945	if (!isActive()) return true;
35946	CurrentSource = L;
35947	return InitThisField<PT_Sint64>(S, CodePtr(), A0);
35948	}
35949	bool EvalEmitter::emitInitThisFieldUint64( uint32_t A0, SourceInfo L) {
35950	if (!isActive()) return true;
35951	CurrentSource = L;
35952	return InitThisField<PT_Uint64>(S, CodePtr(), A0);
35953	}
35954	bool EvalEmitter::emitInitThisFieldIntAP( uint32_t A0, SourceInfo L) {
35955	if (!isActive()) return true;
35956	CurrentSource = L;
35957	return InitThisField<PT_IntAP>(S, CodePtr(), A0);
35958	}
35959	bool EvalEmitter::emitInitThisFieldIntAPS( uint32_t A0, SourceInfo L) {
35960	if (!isActive()) return true;
35961	CurrentSource = L;
35962	return InitThisField<PT_IntAPS>(S, CodePtr(), A0);
35963	}
35964	bool EvalEmitter::emitInitThisFieldBool( uint32_t A0, SourceInfo L) {
35965	if (!isActive()) return true;
35966	CurrentSource = L;
35967	return InitThisField<PT_Bool>(S, CodePtr(), A0);
35968	}
35969	bool EvalEmitter::emitInitThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
35970	if (!isActive()) return true;
35971	CurrentSource = L;
35972	return InitThisField<PT_FixedPoint>(S, CodePtr(), A0);
35973	}
35974	bool EvalEmitter::emitInitThisFieldPtr( uint32_t A0, SourceInfo L) {
35975	if (!isActive()) return true;
35976	CurrentSource = L;
35977	return InitThisField<PT_Ptr>(S, CodePtr(), A0);
35978	}
35979	bool EvalEmitter::emitInitThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
35980	if (!isActive()) return true;
35981	CurrentSource = L;
35982	return InitThisField<PT_MemberPtr>(S, CodePtr(), A0);
35983	}
35984	bool EvalEmitter::emitInitThisFieldFloat( uint32_t A0, SourceInfo L) {
35985	if (!isActive()) return true;
35986	CurrentSource = L;
35987	return InitThisField<PT_Float>(S, CodePtr(), A0);
35988	}
35989	#endif
35990	#ifdef GET_OPCODE_NAMES
35991	OP_InitThisFieldActivateSint8,
35992	OP_InitThisFieldActivateUint8,
35993	OP_InitThisFieldActivateSint16,
35994	OP_InitThisFieldActivateUint16,
35995	OP_InitThisFieldActivateSint32,
35996	OP_InitThisFieldActivateUint32,
35997	OP_InitThisFieldActivateSint64,
35998	OP_InitThisFieldActivateUint64,
35999	OP_InitThisFieldActivateIntAP,
36000	OP_InitThisFieldActivateIntAPS,
36001	OP_InitThisFieldActivateBool,
36002	OP_InitThisFieldActivateFixedPoint,
36003	OP_InitThisFieldActivatePtr,
36004	OP_InitThisFieldActivateMemberPtr,
36005	OP_InitThisFieldActivateFloat,
36006	#endif
36007	#ifdef GET_INTERPFN_LIST
36008	&Interp_InitThisFieldActivateSint8,
36009	&Interp_InitThisFieldActivateUint8,
36010	&Interp_InitThisFieldActivateSint16,
36011	&Interp_InitThisFieldActivateUint16,
36012	&Interp_InitThisFieldActivateSint32,
36013	&Interp_InitThisFieldActivateUint32,
36014	&Interp_InitThisFieldActivateSint64,
36015	&Interp_InitThisFieldActivateUint64,
36016	&Interp_InitThisFieldActivateIntAP,
36017	&Interp_InitThisFieldActivateIntAPS,
36018	&Interp_InitThisFieldActivateBool,
36019	&Interp_InitThisFieldActivateFixedPoint,
36020	&Interp_InitThisFieldActivatePtr,
36021	&Interp_InitThisFieldActivateMemberPtr,
36022	&Interp_InitThisFieldActivateFloat,
36023	#endif
36024	#ifdef GET_INTERPFN_DISPATCHERS
36025	PRESERVE_NONE
36026	static bool Interp_InitThisFieldActivateSint8(InterpState &S) {
36027	{
36028	CodePtr OpPC = S.PC;
36029	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36030	if (!InitThisFieldActivate<PT_Sint8>(S, OpPC, V0)) return false;
36031	}
36032	#if USE_TAILCALLS
36033	MUSTTAIL return InterpNext(S);
36034	#else
36035	return true;
36036	#endif
36037	}
36038	PRESERVE_NONE
36039	static bool Interp_InitThisFieldActivateUint8(InterpState &S) {
36040	{
36041	CodePtr OpPC = S.PC;
36042	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36043	if (!InitThisFieldActivate<PT_Uint8>(S, OpPC, V0)) return false;
36044	}
36045	#if USE_TAILCALLS
36046	MUSTTAIL return InterpNext(S);
36047	#else
36048	return true;
36049	#endif
36050	}
36051	PRESERVE_NONE
36052	static bool Interp_InitThisFieldActivateSint16(InterpState &S) {
36053	{
36054	CodePtr OpPC = S.PC;
36055	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36056	if (!InitThisFieldActivate<PT_Sint16>(S, OpPC, V0)) return false;
36057	}
36058	#if USE_TAILCALLS
36059	MUSTTAIL return InterpNext(S);
36060	#else
36061	return true;
36062	#endif
36063	}
36064	PRESERVE_NONE
36065	static bool Interp_InitThisFieldActivateUint16(InterpState &S) {
36066	{
36067	CodePtr OpPC = S.PC;
36068	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36069	if (!InitThisFieldActivate<PT_Uint16>(S, OpPC, V0)) return false;
36070	}
36071	#if USE_TAILCALLS
36072	MUSTTAIL return InterpNext(S);
36073	#else
36074	return true;
36075	#endif
36076	}
36077	PRESERVE_NONE
36078	static bool Interp_InitThisFieldActivateSint32(InterpState &S) {
36079	{
36080	CodePtr OpPC = S.PC;
36081	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36082	if (!InitThisFieldActivate<PT_Sint32>(S, OpPC, V0)) return false;
36083	}
36084	#if USE_TAILCALLS
36085	MUSTTAIL return InterpNext(S);
36086	#else
36087	return true;
36088	#endif
36089	}
36090	PRESERVE_NONE
36091	static bool Interp_InitThisFieldActivateUint32(InterpState &S) {
36092	{
36093	CodePtr OpPC = S.PC;
36094	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36095	if (!InitThisFieldActivate<PT_Uint32>(S, OpPC, V0)) return false;
36096	}
36097	#if USE_TAILCALLS
36098	MUSTTAIL return InterpNext(S);
36099	#else
36100	return true;
36101	#endif
36102	}
36103	PRESERVE_NONE
36104	static bool Interp_InitThisFieldActivateSint64(InterpState &S) {
36105	{
36106	CodePtr OpPC = S.PC;
36107	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36108	if (!InitThisFieldActivate<PT_Sint64>(S, OpPC, V0)) return false;
36109	}
36110	#if USE_TAILCALLS
36111	MUSTTAIL return InterpNext(S);
36112	#else
36113	return true;
36114	#endif
36115	}
36116	PRESERVE_NONE
36117	static bool Interp_InitThisFieldActivateUint64(InterpState &S) {
36118	{
36119	CodePtr OpPC = S.PC;
36120	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36121	if (!InitThisFieldActivate<PT_Uint64>(S, OpPC, V0)) return false;
36122	}
36123	#if USE_TAILCALLS
36124	MUSTTAIL return InterpNext(S);
36125	#else
36126	return true;
36127	#endif
36128	}
36129	PRESERVE_NONE
36130	static bool Interp_InitThisFieldActivateIntAP(InterpState &S) {
36131	{
36132	CodePtr OpPC = S.PC;
36133	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36134	if (!InitThisFieldActivate<PT_IntAP>(S, OpPC, V0)) return false;
36135	}
36136	#if USE_TAILCALLS
36137	MUSTTAIL return InterpNext(S);
36138	#else
36139	return true;
36140	#endif
36141	}
36142	PRESERVE_NONE
36143	static bool Interp_InitThisFieldActivateIntAPS(InterpState &S) {
36144	{
36145	CodePtr OpPC = S.PC;
36146	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36147	if (!InitThisFieldActivate<PT_IntAPS>(S, OpPC, V0)) return false;
36148	}
36149	#if USE_TAILCALLS
36150	MUSTTAIL return InterpNext(S);
36151	#else
36152	return true;
36153	#endif
36154	}
36155	PRESERVE_NONE
36156	static bool Interp_InitThisFieldActivateBool(InterpState &S) {
36157	{
36158	CodePtr OpPC = S.PC;
36159	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36160	if (!InitThisFieldActivate<PT_Bool>(S, OpPC, V0)) return false;
36161	}
36162	#if USE_TAILCALLS
36163	MUSTTAIL return InterpNext(S);
36164	#else
36165	return true;
36166	#endif
36167	}
36168	PRESERVE_NONE
36169	static bool Interp_InitThisFieldActivateFixedPoint(InterpState &S) {
36170	{
36171	CodePtr OpPC = S.PC;
36172	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36173	if (!InitThisFieldActivate<PT_FixedPoint>(S, OpPC, V0)) return false;
36174	}
36175	#if USE_TAILCALLS
36176	MUSTTAIL return InterpNext(S);
36177	#else
36178	return true;
36179	#endif
36180	}
36181	PRESERVE_NONE
36182	static bool Interp_InitThisFieldActivatePtr(InterpState &S) {
36183	{
36184	CodePtr OpPC = S.PC;
36185	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36186	if (!InitThisFieldActivate<PT_Ptr>(S, OpPC, V0)) return false;
36187	}
36188	#if USE_TAILCALLS
36189	MUSTTAIL return InterpNext(S);
36190	#else
36191	return true;
36192	#endif
36193	}
36194	PRESERVE_NONE
36195	static bool Interp_InitThisFieldActivateMemberPtr(InterpState &S) {
36196	{
36197	CodePtr OpPC = S.PC;
36198	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36199	if (!InitThisFieldActivate<PT_MemberPtr>(S, OpPC, V0)) return false;
36200	}
36201	#if USE_TAILCALLS
36202	MUSTTAIL return InterpNext(S);
36203	#else
36204	return true;
36205	#endif
36206	}
36207	PRESERVE_NONE
36208	static bool Interp_InitThisFieldActivateFloat(InterpState &S) {
36209	{
36210	CodePtr OpPC = S.PC;
36211	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36212	if (!InitThisFieldActivate<PT_Float>(S, OpPC, V0)) return false;
36213	}
36214	#if USE_TAILCALLS
36215	MUSTTAIL return InterpNext(S);
36216	#else
36217	return true;
36218	#endif
36219	}
36220	#endif
36221	#ifdef GET_DISASM
36222	case OP_InitThisFieldActivateSint8:
36223	Text.Op = PrintName("InitThisFieldActivateSint8");
36224	Text.Args.push_back(printArg<uint32_t>(P, PC));
36225	break;
36226	case OP_InitThisFieldActivateUint8:
36227	Text.Op = PrintName("InitThisFieldActivateUint8");
36228	Text.Args.push_back(printArg<uint32_t>(P, PC));
36229	break;
36230	case OP_InitThisFieldActivateSint16:
36231	Text.Op = PrintName("InitThisFieldActivateSint16");
36232	Text.Args.push_back(printArg<uint32_t>(P, PC));
36233	break;
36234	case OP_InitThisFieldActivateUint16:
36235	Text.Op = PrintName("InitThisFieldActivateUint16");
36236	Text.Args.push_back(printArg<uint32_t>(P, PC));
36237	break;
36238	case OP_InitThisFieldActivateSint32:
36239	Text.Op = PrintName("InitThisFieldActivateSint32");
36240	Text.Args.push_back(printArg<uint32_t>(P, PC));
36241	break;
36242	case OP_InitThisFieldActivateUint32:
36243	Text.Op = PrintName("InitThisFieldActivateUint32");
36244	Text.Args.push_back(printArg<uint32_t>(P, PC));
36245	break;
36246	case OP_InitThisFieldActivateSint64:
36247	Text.Op = PrintName("InitThisFieldActivateSint64");
36248	Text.Args.push_back(printArg<uint32_t>(P, PC));
36249	break;
36250	case OP_InitThisFieldActivateUint64:
36251	Text.Op = PrintName("InitThisFieldActivateUint64");
36252	Text.Args.push_back(printArg<uint32_t>(P, PC));
36253	break;
36254	case OP_InitThisFieldActivateIntAP:
36255	Text.Op = PrintName("InitThisFieldActivateIntAP");
36256	Text.Args.push_back(printArg<uint32_t>(P, PC));
36257	break;
36258	case OP_InitThisFieldActivateIntAPS:
36259	Text.Op = PrintName("InitThisFieldActivateIntAPS");
36260	Text.Args.push_back(printArg<uint32_t>(P, PC));
36261	break;
36262	case OP_InitThisFieldActivateBool:
36263	Text.Op = PrintName("InitThisFieldActivateBool");
36264	Text.Args.push_back(printArg<uint32_t>(P, PC));
36265	break;
36266	case OP_InitThisFieldActivateFixedPoint:
36267	Text.Op = PrintName("InitThisFieldActivateFixedPoint");
36268	Text.Args.push_back(printArg<uint32_t>(P, PC));
36269	break;
36270	case OP_InitThisFieldActivatePtr:
36271	Text.Op = PrintName("InitThisFieldActivatePtr");
36272	Text.Args.push_back(printArg<uint32_t>(P, PC));
36273	break;
36274	case OP_InitThisFieldActivateMemberPtr:
36275	Text.Op = PrintName("InitThisFieldActivateMemberPtr");
36276	Text.Args.push_back(printArg<uint32_t>(P, PC));
36277	break;
36278	case OP_InitThisFieldActivateFloat:
36279	Text.Op = PrintName("InitThisFieldActivateFloat");
36280	Text.Args.push_back(printArg<uint32_t>(P, PC));
36281	break;
36282	#endif
36283	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36284	bool emitInitThisFieldActivateSint8( uint32_t , SourceInfo);
36285	bool emitInitThisFieldActivateUint8( uint32_t , SourceInfo);
36286	bool emitInitThisFieldActivateSint16( uint32_t , SourceInfo);
36287	bool emitInitThisFieldActivateUint16( uint32_t , SourceInfo);
36288	bool emitInitThisFieldActivateSint32( uint32_t , SourceInfo);
36289	bool emitInitThisFieldActivateUint32( uint32_t , SourceInfo);
36290	bool emitInitThisFieldActivateSint64( uint32_t , SourceInfo);
36291	bool emitInitThisFieldActivateUint64( uint32_t , SourceInfo);
36292	bool emitInitThisFieldActivateIntAP( uint32_t , SourceInfo);
36293	bool emitInitThisFieldActivateIntAPS( uint32_t , SourceInfo);
36294	bool emitInitThisFieldActivateBool( uint32_t , SourceInfo);
36295	bool emitInitThisFieldActivateFixedPoint( uint32_t , SourceInfo);
36296	bool emitInitThisFieldActivatePtr( uint32_t , SourceInfo);
36297	bool emitInitThisFieldActivateMemberPtr( uint32_t , SourceInfo);
36298	bool emitInitThisFieldActivateFloat( uint32_t , SourceInfo);
36299	#endif
36300	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36301	[[nodiscard]] bool emitInitThisFieldActivate(PrimType, uint32_t, SourceInfo I);
36302	#endif
36303	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
36304	bool
36305	#if defined(GET_EVAL_IMPL)
36306	EvalEmitter
36307	#else
36308	ByteCodeEmitter
36309	#endif
36310	::emitInitThisFieldActivate(PrimType T0, uint32_t A0, SourceInfo I) {
36311	switch (T0) {
36312	case PT_Sint8:
36313	return emitInitThisFieldActivateSint8(A0, I);
36314	case PT_Uint8:
36315	return emitInitThisFieldActivateUint8(A0, I);
36316	case PT_Sint16:
36317	return emitInitThisFieldActivateSint16(A0, I);
36318	case PT_Uint16:
36319	return emitInitThisFieldActivateUint16(A0, I);
36320	case PT_Sint32:
36321	return emitInitThisFieldActivateSint32(A0, I);
36322	case PT_Uint32:
36323	return emitInitThisFieldActivateUint32(A0, I);
36324	case PT_Sint64:
36325	return emitInitThisFieldActivateSint64(A0, I);
36326	case PT_Uint64:
36327	return emitInitThisFieldActivateUint64(A0, I);
36328	case PT_IntAP:
36329	return emitInitThisFieldActivateIntAP(A0, I);
36330	case PT_IntAPS:
36331	return emitInitThisFieldActivateIntAPS(A0, I);
36332	case PT_Bool:
36333	return emitInitThisFieldActivateBool(A0, I);
36334	case PT_FixedPoint:
36335	return emitInitThisFieldActivateFixedPoint(A0, I);
36336	case PT_Ptr:
36337	return emitInitThisFieldActivatePtr(A0, I);
36338	case PT_MemberPtr:
36339	return emitInitThisFieldActivateMemberPtr(A0, I);
36340	case PT_Float:
36341	return emitInitThisFieldActivateFloat(A0, I);
36342	}
36343	llvm_unreachable("invalid enum value");
36344	}
36345	#endif
36346	#ifdef GET_LINK_IMPL
36347	bool ByteCodeEmitter::emitInitThisFieldActivateSint8( uint32_t A0, SourceInfo L) {
36348	return emitOp<uint32_t>(OP_InitThisFieldActivateSint8, A0, L);
36349	}
36350	bool ByteCodeEmitter::emitInitThisFieldActivateUint8( uint32_t A0, SourceInfo L) {
36351	return emitOp<uint32_t>(OP_InitThisFieldActivateUint8, A0, L);
36352	}
36353	bool ByteCodeEmitter::emitInitThisFieldActivateSint16( uint32_t A0, SourceInfo L) {
36354	return emitOp<uint32_t>(OP_InitThisFieldActivateSint16, A0, L);
36355	}
36356	bool ByteCodeEmitter::emitInitThisFieldActivateUint16( uint32_t A0, SourceInfo L) {
36357	return emitOp<uint32_t>(OP_InitThisFieldActivateUint16, A0, L);
36358	}
36359	bool ByteCodeEmitter::emitInitThisFieldActivateSint32( uint32_t A0, SourceInfo L) {
36360	return emitOp<uint32_t>(OP_InitThisFieldActivateSint32, A0, L);
36361	}
36362	bool ByteCodeEmitter::emitInitThisFieldActivateUint32( uint32_t A0, SourceInfo L) {
36363	return emitOp<uint32_t>(OP_InitThisFieldActivateUint32, A0, L);
36364	}
36365	bool ByteCodeEmitter::emitInitThisFieldActivateSint64( uint32_t A0, SourceInfo L) {
36366	return emitOp<uint32_t>(OP_InitThisFieldActivateSint64, A0, L);
36367	}
36368	bool ByteCodeEmitter::emitInitThisFieldActivateUint64( uint32_t A0, SourceInfo L) {
36369	return emitOp<uint32_t>(OP_InitThisFieldActivateUint64, A0, L);
36370	}
36371	bool ByteCodeEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, SourceInfo L) {
36372	return emitOp<uint32_t>(OP_InitThisFieldActivateIntAP, A0, L);
36373	}
36374	bool ByteCodeEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
36375	return emitOp<uint32_t>(OP_InitThisFieldActivateIntAPS, A0, L);
36376	}
36377	bool ByteCodeEmitter::emitInitThisFieldActivateBool( uint32_t A0, SourceInfo L) {
36378	return emitOp<uint32_t>(OP_InitThisFieldActivateBool, A0, L);
36379	}
36380	bool ByteCodeEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
36381	return emitOp<uint32_t>(OP_InitThisFieldActivateFixedPoint, A0, L);
36382	}
36383	bool ByteCodeEmitter::emitInitThisFieldActivatePtr( uint32_t A0, SourceInfo L) {
36384	return emitOp<uint32_t>(OP_InitThisFieldActivatePtr, A0, L);
36385	}
36386	bool ByteCodeEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
36387	return emitOp<uint32_t>(OP_InitThisFieldActivateMemberPtr, A0, L);
36388	}
36389	bool ByteCodeEmitter::emitInitThisFieldActivateFloat( uint32_t A0, SourceInfo L) {
36390	return emitOp<uint32_t>(OP_InitThisFieldActivateFloat, A0, L);
36391	}
36392	#endif
36393	#ifdef GET_EVAL_IMPL
36394	bool EvalEmitter::emitInitThisFieldActivateSint8( uint32_t A0, SourceInfo L) {
36395	if (!isActive()) return true;
36396	CurrentSource = L;
36397	return InitThisFieldActivate<PT_Sint8>(S, CodePtr(), A0);
36398	}
36399	bool EvalEmitter::emitInitThisFieldActivateUint8( uint32_t A0, SourceInfo L) {
36400	if (!isActive()) return true;
36401	CurrentSource = L;
36402	return InitThisFieldActivate<PT_Uint8>(S, CodePtr(), A0);
36403	}
36404	bool EvalEmitter::emitInitThisFieldActivateSint16( uint32_t A0, SourceInfo L) {
36405	if (!isActive()) return true;
36406	CurrentSource = L;
36407	return InitThisFieldActivate<PT_Sint16>(S, CodePtr(), A0);
36408	}
36409	bool EvalEmitter::emitInitThisFieldActivateUint16( uint32_t A0, SourceInfo L) {
36410	if (!isActive()) return true;
36411	CurrentSource = L;
36412	return InitThisFieldActivate<PT_Uint16>(S, CodePtr(), A0);
36413	}
36414	bool EvalEmitter::emitInitThisFieldActivateSint32( uint32_t A0, SourceInfo L) {
36415	if (!isActive()) return true;
36416	CurrentSource = L;
36417	return InitThisFieldActivate<PT_Sint32>(S, CodePtr(), A0);
36418	}
36419	bool EvalEmitter::emitInitThisFieldActivateUint32( uint32_t A0, SourceInfo L) {
36420	if (!isActive()) return true;
36421	CurrentSource = L;
36422	return InitThisFieldActivate<PT_Uint32>(S, CodePtr(), A0);
36423	}
36424	bool EvalEmitter::emitInitThisFieldActivateSint64( uint32_t A0, SourceInfo L) {
36425	if (!isActive()) return true;
36426	CurrentSource = L;
36427	return InitThisFieldActivate<PT_Sint64>(S, CodePtr(), A0);
36428	}
36429	bool EvalEmitter::emitInitThisFieldActivateUint64( uint32_t A0, SourceInfo L) {
36430	if (!isActive()) return true;
36431	CurrentSource = L;
36432	return InitThisFieldActivate<PT_Uint64>(S, CodePtr(), A0);
36433	}
36434	bool EvalEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, SourceInfo L) {
36435	if (!isActive()) return true;
36436	CurrentSource = L;
36437	return InitThisFieldActivate<PT_IntAP>(S, CodePtr(), A0);
36438	}
36439	bool EvalEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
36440	if (!isActive()) return true;
36441	CurrentSource = L;
36442	return InitThisFieldActivate<PT_IntAPS>(S, CodePtr(), A0);
36443	}
36444	bool EvalEmitter::emitInitThisFieldActivateBool( uint32_t A0, SourceInfo L) {
36445	if (!isActive()) return true;
36446	CurrentSource = L;
36447	return InitThisFieldActivate<PT_Bool>(S, CodePtr(), A0);
36448	}
36449	bool EvalEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
36450	if (!isActive()) return true;
36451	CurrentSource = L;
36452	return InitThisFieldActivate<PT_FixedPoint>(S, CodePtr(), A0);
36453	}
36454	bool EvalEmitter::emitInitThisFieldActivatePtr( uint32_t A0, SourceInfo L) {
36455	if (!isActive()) return true;
36456	CurrentSource = L;
36457	return InitThisFieldActivate<PT_Ptr>(S, CodePtr(), A0);
36458	}
36459	bool EvalEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
36460	if (!isActive()) return true;
36461	CurrentSource = L;
36462	return InitThisFieldActivate<PT_MemberPtr>(S, CodePtr(), A0);
36463	}
36464	bool EvalEmitter::emitInitThisFieldActivateFloat( uint32_t A0, SourceInfo L) {
36465	if (!isActive()) return true;
36466	CurrentSource = L;
36467	return InitThisFieldActivate<PT_Float>(S, CodePtr(), A0);
36468	}
36469	#endif
36470	#ifdef GET_OPCODE_NAMES
36471	OP_Inv,
36472	#endif
36473	#ifdef GET_INTERPFN_LIST
36474	&Interp_Inv,
36475	#endif
36476	#ifdef GET_INTERPFN_DISPATCHERS
36477	PRESERVE_NONE
36478	static bool Interp_Inv(InterpState &S) {
36479	Inv(S);
36480	#if USE_TAILCALLS
36481	MUSTTAIL return InterpNext(S);
36482	#else
36483	return true;
36484	#endif
36485	}
36486	#endif
36487	#ifdef GET_DISASM
36488	case OP_Inv:
36489	Text.Op = PrintName("Inv");
36490	break;
36491	#endif
36492	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36493	bool emitInv(SourceInfo);
36494	#endif
36495	#ifdef GET_LINK_IMPL
36496	bool ByteCodeEmitter::emitInv(SourceInfo L) {
36497	return emitOp<>(OP_Inv, L);
36498	}
36499	#endif
36500	#ifdef GET_EVAL_IMPL
36501	bool EvalEmitter::emitInv(SourceInfo L) {
36502	if (!isActive()) return true;
36503	CurrentSource = L;
36504	return Inv(S);
36505	}
36506	#endif
36507	#ifdef GET_OPCODE_NAMES
36508	OP_Invalid,
36509	#endif
36510	#ifdef GET_INTERPFN_LIST
36511	&Interp_Invalid,
36512	#endif
36513	#ifdef GET_INTERPFN_DISPATCHERS
36514	PRESERVE_NONE
36515	static bool Interp_Invalid(InterpState &S) {
36516	if (!Invalid(S, S.PC)) return false;
36517	#if USE_TAILCALLS
36518	MUSTTAIL return InterpNext(S);
36519	#else
36520	return true;
36521	#endif
36522	}
36523	#endif
36524	#ifdef GET_DISASM
36525	case OP_Invalid:
36526	Text.Op = PrintName("Invalid");
36527	break;
36528	#endif
36529	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36530	bool emitInvalid(SourceInfo);
36531	#endif
36532	#ifdef GET_LINK_IMPL
36533	bool ByteCodeEmitter::emitInvalid(SourceInfo L) {
36534	return emitOp<>(OP_Invalid, L);
36535	}
36536	#endif
36537	#ifdef GET_EVAL_IMPL
36538	bool EvalEmitter::emitInvalid(SourceInfo L) {
36539	if (!isActive()) return true;
36540	CurrentSource = L;
36541	return Invalid(S, CodePtr());
36542	}
36543	#endif
36544	#ifdef GET_OPCODE_NAMES
36545	OP_InvalidCast,
36546	#endif
36547	#ifdef GET_INTERPFN_LIST
36548	&Interp_InvalidCast,
36549	#endif
36550	#ifdef GET_INTERPFN_DISPATCHERS
36551	PRESERVE_NONE
36552	static bool Interp_InvalidCast(InterpState &S) {
36553	{
36554	CodePtr OpPC = S.PC;
36555	const auto V0 = ReadArg<interp::CastKind>(S, S.PC);
36556	const auto V1 = ReadArg<bool>(S, S.PC);
36557	if (!InvalidCast(S, OpPC, V0, V1)) return false;
36558	}
36559	#if USE_TAILCALLS
36560	MUSTTAIL return InterpNext(S);
36561	#else
36562	return true;
36563	#endif
36564	}
36565	#endif
36566	#ifdef GET_DISASM
36567	case OP_InvalidCast:
36568	Text.Op = PrintName("InvalidCast");
36569	Text.Args.push_back(printArg<interp::CastKind>(P, PC));
36570	Text.Args.push_back(printArg<bool>(P, PC));
36571	break;
36572	#endif
36573	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36574	bool emitInvalidCast( interp::CastKind , bool , SourceInfo);
36575	#endif
36576	#ifdef GET_LINK_IMPL
36577	bool ByteCodeEmitter::emitInvalidCast( interp::CastKind A0, bool A1, SourceInfo L) {
36578	return emitOp<interp::CastKind, bool>(OP_InvalidCast, A0, A1, L);
36579	}
36580	#endif
36581	#ifdef GET_EVAL_IMPL
36582	bool EvalEmitter::emitInvalidCast( interp::CastKind A0, bool A1, SourceInfo L) {
36583	if (!isActive()) return true;
36584	CurrentSource = L;
36585	return InvalidCast(S, CodePtr(), A0, A1);
36586	}
36587	#endif
36588	#ifdef GET_OPCODE_NAMES
36589	OP_InvalidDeclRef,
36590	#endif
36591	#ifdef GET_INTERPFN_LIST
36592	&Interp_InvalidDeclRef,
36593	#endif
36594	#ifdef GET_INTERPFN_DISPATCHERS
36595	PRESERVE_NONE
36596	static bool Interp_InvalidDeclRef(InterpState &S) {
36597	{
36598	CodePtr OpPC = S.PC;
36599	const auto V0 = ReadArg<const DeclRefExpr *>(S, S.PC);
36600	const auto V1 = ReadArg<bool>(S, S.PC);
36601	if (!InvalidDeclRef(S, OpPC, V0, V1)) return false;
36602	}
36603	#if USE_TAILCALLS
36604	MUSTTAIL return InterpNext(S);
36605	#else
36606	return true;
36607	#endif
36608	}
36609	#endif
36610	#ifdef GET_DISASM
36611	case OP_InvalidDeclRef:
36612	Text.Op = PrintName("InvalidDeclRef");
36613	Text.Args.push_back(printArg<const DeclRefExpr *>(P, PC));
36614	Text.Args.push_back(printArg<bool>(P, PC));
36615	break;
36616	#endif
36617	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36618	bool emitInvalidDeclRef( const DeclRefExpr * , bool , SourceInfo);
36619	#endif
36620	#ifdef GET_LINK_IMPL
36621	bool ByteCodeEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, SourceInfo L) {
36622	return emitOp<const DeclRefExpr , bool*>(OP_InvalidDeclRef, A0, A1, L);
36623	}
36624	#endif
36625	#ifdef GET_EVAL_IMPL
36626	bool EvalEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, SourceInfo L) {
36627	if (!isActive()) return true;
36628	CurrentSource = L;
36629	return InvalidDeclRef(S, CodePtr(), A0, A1);
36630	}
36631	#endif
36632	#ifdef GET_OPCODE_NAMES
36633	OP_InvalidNewDeleteExpr,
36634	#endif
36635	#ifdef GET_INTERPFN_LIST
36636	&Interp_InvalidNewDeleteExpr,
36637	#endif
36638	#ifdef GET_INTERPFN_DISPATCHERS
36639	PRESERVE_NONE
36640	static bool Interp_InvalidNewDeleteExpr(InterpState &S) {
36641	{
36642	CodePtr OpPC = S.PC;
36643	const auto V0 = ReadArg<const Expr *>(S, S.PC);
36644	if (!InvalidNewDeleteExpr(S, OpPC, V0)) return false;
36645	}
36646	#if USE_TAILCALLS
36647	MUSTTAIL return InterpNext(S);
36648	#else
36649	return true;
36650	#endif
36651	}
36652	#endif
36653	#ifdef GET_DISASM
36654	case OP_InvalidNewDeleteExpr:
36655	Text.Op = PrintName("InvalidNewDeleteExpr");
36656	Text.Args.push_back(printArg<const Expr *>(P, PC));
36657	break;
36658	#endif
36659	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36660	bool emitInvalidNewDeleteExpr( const Expr * , SourceInfo);
36661	#endif
36662	#ifdef GET_LINK_IMPL
36663	bool ByteCodeEmitter::emitInvalidNewDeleteExpr( const Expr * A0, SourceInfo L) {
36664	return emitOp<const Expr *>(OP_InvalidNewDeleteExpr, A0, L);
36665	}
36666	#endif
36667	#ifdef GET_EVAL_IMPL
36668	bool EvalEmitter::emitInvalidNewDeleteExpr( const Expr * A0, SourceInfo L) {
36669	if (!isActive()) return true;
36670	CurrentSource = L;
36671	return InvalidNewDeleteExpr(S, CodePtr(), A0);
36672	}
36673	#endif
36674	#ifdef GET_OPCODE_NAMES
36675	OP_InvalidShuffleVectorIndex,
36676	#endif
36677	#ifdef GET_INTERPFN_LIST
36678	&Interp_InvalidShuffleVectorIndex,
36679	#endif
36680	#ifdef GET_INTERPFN_DISPATCHERS
36681	PRESERVE_NONE
36682	static bool Interp_InvalidShuffleVectorIndex(InterpState &S) {
36683	{
36684	CodePtr OpPC = S.PC;
36685	const auto V0 = ReadArg<uint32_t>(S, S.PC);
36686	if (!InvalidShuffleVectorIndex(S, OpPC, V0)) return false;
36687	}
36688	#if USE_TAILCALLS
36689	MUSTTAIL return InterpNext(S);
36690	#else
36691	return true;
36692	#endif
36693	}
36694	#endif
36695	#ifdef GET_DISASM
36696	case OP_InvalidShuffleVectorIndex:
36697	Text.Op = PrintName("InvalidShuffleVectorIndex");
36698	Text.Args.push_back(printArg<uint32_t>(P, PC));
36699	break;
36700	#endif
36701	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36702	bool emitInvalidShuffleVectorIndex( uint32_t , SourceInfo);
36703	#endif
36704	#ifdef GET_LINK_IMPL
36705	bool ByteCodeEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, SourceInfo L) {
36706	return emitOp<uint32_t>(OP_InvalidShuffleVectorIndex, A0, L);
36707	}
36708	#endif
36709	#ifdef GET_EVAL_IMPL
36710	bool EvalEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, SourceInfo L) {
36711	if (!isActive()) return true;
36712	CurrentSource = L;
36713	return InvalidShuffleVectorIndex(S, CodePtr(), A0);
36714	}
36715	#endif
36716	#ifdef GET_OPCODE_NAMES
36717	OP_InvalidStore,
36718	#endif
36719	#ifdef GET_INTERPFN_LIST
36720	&Interp_InvalidStore,
36721	#endif
36722	#ifdef GET_INTERPFN_DISPATCHERS
36723	PRESERVE_NONE
36724	static bool Interp_InvalidStore(InterpState &S) {
36725	{
36726	CodePtr OpPC = S.PC;
36727	const auto V0 = ReadArg<const Type *>(S, S.PC);
36728	if (!InvalidStore(S, OpPC, V0)) return false;
36729	}
36730	#if USE_TAILCALLS
36731	MUSTTAIL return InterpNext(S);
36732	#else
36733	return true;
36734	#endif
36735	}
36736	#endif
36737	#ifdef GET_DISASM
36738	case OP_InvalidStore:
36739	Text.Op = PrintName("InvalidStore");
36740	Text.Args.push_back(printArg<const Type *>(P, PC));
36741	break;
36742	#endif
36743	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36744	bool emitInvalidStore( const Type * , SourceInfo);
36745	#endif
36746	#ifdef GET_LINK_IMPL
36747	bool ByteCodeEmitter::emitInvalidStore( const Type * A0, SourceInfo L) {
36748	return emitOp<const Type *>(OP_InvalidStore, A0, L);
36749	}
36750	#endif
36751	#ifdef GET_EVAL_IMPL
36752	bool EvalEmitter::emitInvalidStore( const Type * A0, SourceInfo L) {
36753	if (!isActive()) return true;
36754	CurrentSource = L;
36755	return InvalidStore(S, CodePtr(), A0);
36756	}
36757	#endif
36758	#ifdef GET_OPCODE_NAMES
36759	OP_IsBaseClass,
36760	#endif
36761	#ifdef GET_INTERPFN_LIST
36762	&Interp_IsBaseClass,
36763	#endif
36764	#ifdef GET_INTERPFN_DISPATCHERS
36765	PRESERVE_NONE
36766	static bool Interp_IsBaseClass(InterpState &S) {
36767	IsBaseClass(S);
36768	#if USE_TAILCALLS
36769	MUSTTAIL return InterpNext(S);
36770	#else
36771	return true;
36772	#endif
36773	}
36774	#endif
36775	#ifdef GET_DISASM
36776	case OP_IsBaseClass:
36777	Text.Op = PrintName("IsBaseClass");
36778	break;
36779	#endif
36780	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36781	bool emitIsBaseClass(SourceInfo);
36782	#endif
36783	#ifdef GET_LINK_IMPL
36784	bool ByteCodeEmitter::emitIsBaseClass(SourceInfo L) {
36785	return emitOp<>(OP_IsBaseClass, L);
36786	}
36787	#endif
36788	#ifdef GET_EVAL_IMPL
36789	bool EvalEmitter::emitIsBaseClass(SourceInfo L) {
36790	if (!isActive()) return true;
36791	CurrentSource = L;
36792	return IsBaseClass(S);
36793	}
36794	#endif
36795	#ifdef GET_OPCODE_NAMES
36796	OP_IsConstantContext,
36797	#endif
36798	#ifdef GET_INTERPFN_LIST
36799	&Interp_IsConstantContext,
36800	#endif
36801	#ifdef GET_INTERPFN_DISPATCHERS
36802	PRESERVE_NONE
36803	static bool Interp_IsConstantContext(InterpState &S) {
36804	IsConstantContext(S);
36805	#if USE_TAILCALLS
36806	MUSTTAIL return InterpNext(S);
36807	#else
36808	return true;
36809	#endif
36810	}
36811	#endif
36812	#ifdef GET_DISASM
36813	case OP_IsConstantContext:
36814	Text.Op = PrintName("IsConstantContext");
36815	break;
36816	#endif
36817	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36818	bool emitIsConstantContext(SourceInfo);
36819	#endif
36820	#ifdef GET_LINK_IMPL
36821	bool ByteCodeEmitter::emitIsConstantContext(SourceInfo L) {
36822	return emitOp<>(OP_IsConstantContext, L);
36823	}
36824	#endif
36825	#ifdef GET_EVAL_IMPL
36826	bool EvalEmitter::emitIsConstantContext(SourceInfo L) {
36827	if (!isActive()) return true;
36828	CurrentSource = L;
36829	return IsConstantContext(S);
36830	}
36831	#endif
36832	#ifdef GET_OPCODE_NAMES
36833	OP_IsNonNullPtr,
36834	OP_IsNonNullMemberPtr,
36835	#endif
36836	#ifdef GET_INTERPFN_LIST
36837	&Interp_IsNonNullPtr,
36838	&Interp_IsNonNullMemberPtr,
36839	#endif
36840	#ifdef GET_INTERPFN_DISPATCHERS
36841	PRESERVE_NONE
36842	static bool Interp_IsNonNullPtr(InterpState &S) {
36843	if (!IsNonNull<PT_Ptr>(S)) return false;
36844	#if USE_TAILCALLS
36845	MUSTTAIL return InterpNext(S);
36846	#else
36847	return true;
36848	#endif
36849	}
36850	PRESERVE_NONE
36851	static bool Interp_IsNonNullMemberPtr(InterpState &S) {
36852	if (!IsNonNull<PT_MemberPtr>(S)) return false;
36853	#if USE_TAILCALLS
36854	MUSTTAIL return InterpNext(S);
36855	#else
36856	return true;
36857	#endif
36858	}
36859	#endif
36860	#ifdef GET_DISASM
36861	case OP_IsNonNullPtr:
36862	Text.Op = PrintName("IsNonNullPtr");
36863	break;
36864	case OP_IsNonNullMemberPtr:
36865	Text.Op = PrintName("IsNonNullMemberPtr");
36866	break;
36867	#endif
36868	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36869	bool emitIsNonNullPtr(SourceInfo);
36870	bool emitIsNonNullMemberPtr(SourceInfo);
36871	#endif
36872	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36873	[[nodiscard]] bool emitIsNonNull(PrimType, SourceInfo I);
36874	#endif
36875	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
36876	bool
36877	#if defined(GET_EVAL_IMPL)
36878	EvalEmitter
36879	#else
36880	ByteCodeEmitter
36881	#endif
36882	::emitIsNonNull(PrimType T0, SourceInfo I) {
36883	switch (T0) {
36884	case PT_Ptr:
36885	return emitIsNonNullPtr(I);
36886	case PT_MemberPtr:
36887	return emitIsNonNullMemberPtr(I);
36888	default: llvm_unreachable("invalid type: emitIsNonNull");
36889	}
36890	llvm_unreachable("invalid enum value");
36891	}
36892	#endif
36893	#ifdef GET_LINK_IMPL
36894	bool ByteCodeEmitter::emitIsNonNullPtr(SourceInfo L) {
36895	return emitOp<>(OP_IsNonNullPtr, L);
36896	}
36897	bool ByteCodeEmitter::emitIsNonNullMemberPtr(SourceInfo L) {
36898	return emitOp<>(OP_IsNonNullMemberPtr, L);
36899	}
36900	#endif
36901	#ifdef GET_EVAL_IMPL
36902	bool EvalEmitter::emitIsNonNullPtr(SourceInfo L) {
36903	if (!isActive()) return true;
36904	CurrentSource = L;
36905	return IsNonNull<PT_Ptr>(S);
36906	}
36907	bool EvalEmitter::emitIsNonNullMemberPtr(SourceInfo L) {
36908	if (!isActive()) return true;
36909	CurrentSource = L;
36910	return IsNonNull<PT_MemberPtr>(S);
36911	}
36912	#endif
36913	#ifdef GET_OPCODE_NAMES
36914	OP_Jf,
36915	#endif
36916	#ifdef GET_INTERPFN_LIST
36917	&Interp_Jf,
36918	#endif
36919	#ifdef GET_INTERPFN_DISPATCHERS
36920	PRESERVE_NONE
36921	static bool Interp_Jf(InterpState &S) {
36922	{
36923	CodePtr OpPC = S.PC;
36924	const auto V0 = ReadArg<int32_t>(S, S.PC);
36925	if (!Jf(S, OpPC, V0)) return false;
36926	}
36927	#if USE_TAILCALLS
36928	MUSTTAIL return InterpNext(S);
36929	#else
36930	return true;
36931	#endif
36932	}
36933	#endif
36934	#ifdef GET_DISASM
36935	case OP_Jf:
36936	Text.Op = PrintName("Jf");
36937	Text.Args.push_back(printArg<int32_t>(P, PC));
36938	break;
36939	#endif
36940	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36941	bool emitJf( int32_t , SourceInfo);
36942	#endif
36943	#ifdef GET_LINK_IMPL
36944	bool ByteCodeEmitter::emitJf( int32_t A0, SourceInfo L) {
36945	return emitOp<int32_t>(OP_Jf, A0, L);
36946	}
36947	#endif
36948	#ifdef GET_OPCODE_NAMES
36949	OP_Jmp,
36950	#endif
36951	#ifdef GET_INTERPFN_LIST
36952	&Interp_Jmp,
36953	#endif
36954	#ifdef GET_INTERPFN_DISPATCHERS
36955	PRESERVE_NONE
36956	static bool Interp_Jmp(InterpState &S) {
36957	{
36958	CodePtr OpPC = S.PC;
36959	const auto V0 = ReadArg<int32_t>(S, S.PC);
36960	if (!Jmp(S, OpPC, V0)) return false;
36961	}
36962	#if USE_TAILCALLS
36963	MUSTTAIL return InterpNext(S);
36964	#else
36965	return true;
36966	#endif
36967	}
36968	#endif
36969	#ifdef GET_DISASM
36970	case OP_Jmp:
36971	Text.Op = PrintName("Jmp");
36972	Text.Args.push_back(printArg<int32_t>(P, PC));
36973	break;
36974	#endif
36975	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
36976	bool emitJmp( int32_t , SourceInfo);
36977	#endif
36978	#ifdef GET_LINK_IMPL
36979	bool ByteCodeEmitter::emitJmp( int32_t A0, SourceInfo L) {
36980	return emitOp<int32_t>(OP_Jmp, A0, L);
36981	}
36982	#endif
36983	#ifdef GET_OPCODE_NAMES
36984	OP_Jt,
36985	#endif
36986	#ifdef GET_INTERPFN_LIST
36987	&Interp_Jt,
36988	#endif
36989	#ifdef GET_INTERPFN_DISPATCHERS
36990	PRESERVE_NONE
36991	static bool Interp_Jt(InterpState &S) {
36992	{
36993	CodePtr OpPC = S.PC;
36994	const auto V0 = ReadArg<int32_t>(S, S.PC);
36995	if (!Jt(S, OpPC, V0)) return false;
36996	}
36997	#if USE_TAILCALLS
36998	MUSTTAIL return InterpNext(S);
36999	#else
37000	return true;
37001	#endif
37002	}
37003	#endif
37004	#ifdef GET_DISASM
37005	case OP_Jt:
37006	Text.Op = PrintName("Jt");
37007	Text.Args.push_back(printArg<int32_t>(P, PC));
37008	break;
37009	#endif
37010	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37011	bool emitJt( int32_t , SourceInfo);
37012	#endif
37013	#ifdef GET_LINK_IMPL
37014	bool ByteCodeEmitter::emitJt( int32_t A0, SourceInfo L) {
37015	return emitOp<int32_t>(OP_Jt, A0, L);
37016	}
37017	#endif
37018	#ifdef GET_OPCODE_NAMES
37019	OP_LESint8,
37020	OP_LEUint8,
37021	OP_LESint16,
37022	OP_LEUint16,
37023	OP_LESint32,
37024	OP_LEUint32,
37025	OP_LESint64,
37026	OP_LEUint64,
37027	OP_LEIntAP,
37028	OP_LEIntAPS,
37029	OP_LEBool,
37030	OP_LEFixedPoint,
37031	OP_LEPtr,
37032	OP_LEFloat,
37033	#endif
37034	#ifdef GET_INTERPFN_LIST
37035	&Interp_LESint8,
37036	&Interp_LEUint8,
37037	&Interp_LESint16,
37038	&Interp_LEUint16,
37039	&Interp_LESint32,
37040	&Interp_LEUint32,
37041	&Interp_LESint64,
37042	&Interp_LEUint64,
37043	&Interp_LEIntAP,
37044	&Interp_LEIntAPS,
37045	&Interp_LEBool,
37046	&Interp_LEFixedPoint,
37047	&Interp_LEPtr,
37048	&Interp_LEFloat,
37049	#endif
37050	#ifdef GET_INTERPFN_DISPATCHERS
37051	PRESERVE_NONE
37052	static bool Interp_LESint8(InterpState &S) {
37053	if (!LE<PT_Sint8>(S, S.PC)) return false;
37054	#if USE_TAILCALLS
37055	MUSTTAIL return InterpNext(S);
37056	#else
37057	return true;
37058	#endif
37059	}
37060	PRESERVE_NONE
37061	static bool Interp_LEUint8(InterpState &S) {
37062	if (!LE<PT_Uint8>(S, S.PC)) return false;
37063	#if USE_TAILCALLS
37064	MUSTTAIL return InterpNext(S);
37065	#else
37066	return true;
37067	#endif
37068	}
37069	PRESERVE_NONE
37070	static bool Interp_LESint16(InterpState &S) {
37071	if (!LE<PT_Sint16>(S, S.PC)) return false;
37072	#if USE_TAILCALLS
37073	MUSTTAIL return InterpNext(S);
37074	#else
37075	return true;
37076	#endif
37077	}
37078	PRESERVE_NONE
37079	static bool Interp_LEUint16(InterpState &S) {
37080	if (!LE<PT_Uint16>(S, S.PC)) return false;
37081	#if USE_TAILCALLS
37082	MUSTTAIL return InterpNext(S);
37083	#else
37084	return true;
37085	#endif
37086	}
37087	PRESERVE_NONE
37088	static bool Interp_LESint32(InterpState &S) {
37089	if (!LE<PT_Sint32>(S, S.PC)) return false;
37090	#if USE_TAILCALLS
37091	MUSTTAIL return InterpNext(S);
37092	#else
37093	return true;
37094	#endif
37095	}
37096	PRESERVE_NONE
37097	static bool Interp_LEUint32(InterpState &S) {
37098	if (!LE<PT_Uint32>(S, S.PC)) return false;
37099	#if USE_TAILCALLS
37100	MUSTTAIL return InterpNext(S);
37101	#else
37102	return true;
37103	#endif
37104	}
37105	PRESERVE_NONE
37106	static bool Interp_LESint64(InterpState &S) {
37107	if (!LE<PT_Sint64>(S, S.PC)) return false;
37108	#if USE_TAILCALLS
37109	MUSTTAIL return InterpNext(S);
37110	#else
37111	return true;
37112	#endif
37113	}
37114	PRESERVE_NONE
37115	static bool Interp_LEUint64(InterpState &S) {
37116	if (!LE<PT_Uint64>(S, S.PC)) return false;
37117	#if USE_TAILCALLS
37118	MUSTTAIL return InterpNext(S);
37119	#else
37120	return true;
37121	#endif
37122	}
37123	PRESERVE_NONE
37124	static bool Interp_LEIntAP(InterpState &S) {
37125	if (!LE<PT_IntAP>(S, S.PC)) return false;
37126	#if USE_TAILCALLS
37127	MUSTTAIL return InterpNext(S);
37128	#else
37129	return true;
37130	#endif
37131	}
37132	PRESERVE_NONE
37133	static bool Interp_LEIntAPS(InterpState &S) {
37134	if (!LE<PT_IntAPS>(S, S.PC)) return false;
37135	#if USE_TAILCALLS
37136	MUSTTAIL return InterpNext(S);
37137	#else
37138	return true;
37139	#endif
37140	}
37141	PRESERVE_NONE
37142	static bool Interp_LEBool(InterpState &S) {
37143	if (!LE<PT_Bool>(S, S.PC)) return false;
37144	#if USE_TAILCALLS
37145	MUSTTAIL return InterpNext(S);
37146	#else
37147	return true;
37148	#endif
37149	}
37150	PRESERVE_NONE
37151	static bool Interp_LEFixedPoint(InterpState &S) {
37152	if (!LE<PT_FixedPoint>(S, S.PC)) return false;
37153	#if USE_TAILCALLS
37154	MUSTTAIL return InterpNext(S);
37155	#else
37156	return true;
37157	#endif
37158	}
37159	PRESERVE_NONE
37160	static bool Interp_LEPtr(InterpState &S) {
37161	if (!LE<PT_Ptr>(S, S.PC)) return false;
37162	#if USE_TAILCALLS
37163	MUSTTAIL return InterpNext(S);
37164	#else
37165	return true;
37166	#endif
37167	}
37168	PRESERVE_NONE
37169	static bool Interp_LEFloat(InterpState &S) {
37170	if (!LE<PT_Float>(S, S.PC)) return false;
37171	#if USE_TAILCALLS
37172	MUSTTAIL return InterpNext(S);
37173	#else
37174	return true;
37175	#endif
37176	}
37177	#endif
37178	#ifdef GET_DISASM
37179	case OP_LESint8:
37180	Text.Op = PrintName("LESint8");
37181	break;
37182	case OP_LEUint8:
37183	Text.Op = PrintName("LEUint8");
37184	break;
37185	case OP_LESint16:
37186	Text.Op = PrintName("LESint16");
37187	break;
37188	case OP_LEUint16:
37189	Text.Op = PrintName("LEUint16");
37190	break;
37191	case OP_LESint32:
37192	Text.Op = PrintName("LESint32");
37193	break;
37194	case OP_LEUint32:
37195	Text.Op = PrintName("LEUint32");
37196	break;
37197	case OP_LESint64:
37198	Text.Op = PrintName("LESint64");
37199	break;
37200	case OP_LEUint64:
37201	Text.Op = PrintName("LEUint64");
37202	break;
37203	case OP_LEIntAP:
37204	Text.Op = PrintName("LEIntAP");
37205	break;
37206	case OP_LEIntAPS:
37207	Text.Op = PrintName("LEIntAPS");
37208	break;
37209	case OP_LEBool:
37210	Text.Op = PrintName("LEBool");
37211	break;
37212	case OP_LEFixedPoint:
37213	Text.Op = PrintName("LEFixedPoint");
37214	break;
37215	case OP_LEPtr:
37216	Text.Op = PrintName("LEPtr");
37217	break;
37218	case OP_LEFloat:
37219	Text.Op = PrintName("LEFloat");
37220	break;
37221	#endif
37222	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37223	bool emitLESint8(SourceInfo);
37224	bool emitLEUint8(SourceInfo);
37225	bool emitLESint16(SourceInfo);
37226	bool emitLEUint16(SourceInfo);
37227	bool emitLESint32(SourceInfo);
37228	bool emitLEUint32(SourceInfo);
37229	bool emitLESint64(SourceInfo);
37230	bool emitLEUint64(SourceInfo);
37231	bool emitLEIntAP(SourceInfo);
37232	bool emitLEIntAPS(SourceInfo);
37233	bool emitLEBool(SourceInfo);
37234	bool emitLEFixedPoint(SourceInfo);
37235	bool emitLEPtr(SourceInfo);
37236	bool emitLEFloat(SourceInfo);
37237	#endif
37238	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37239	[[nodiscard]] bool emitLE(PrimType, SourceInfo I);
37240	#endif
37241	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
37242	bool
37243	#if defined(GET_EVAL_IMPL)
37244	EvalEmitter
37245	#else
37246	ByteCodeEmitter
37247	#endif
37248	::emitLE(PrimType T0, SourceInfo I) {
37249	switch (T0) {
37250	case PT_Sint8:
37251	return emitLESint8(I);
37252	case PT_Uint8:
37253	return emitLEUint8(I);
37254	case PT_Sint16:
37255	return emitLESint16(I);
37256	case PT_Uint16:
37257	return emitLEUint16(I);
37258	case PT_Sint32:
37259	return emitLESint32(I);
37260	case PT_Uint32:
37261	return emitLEUint32(I);
37262	case PT_Sint64:
37263	return emitLESint64(I);
37264	case PT_Uint64:
37265	return emitLEUint64(I);
37266	case PT_IntAP:
37267	return emitLEIntAP(I);
37268	case PT_IntAPS:
37269	return emitLEIntAPS(I);
37270	case PT_Bool:
37271	return emitLEBool(I);
37272	case PT_FixedPoint:
37273	return emitLEFixedPoint(I);
37274	case PT_Ptr:
37275	return emitLEPtr(I);
37276	case PT_Float:
37277	return emitLEFloat(I);
37278	default: llvm_unreachable("invalid type: emitLE");
37279	}
37280	llvm_unreachable("invalid enum value");
37281	}
37282	#endif
37283	#ifdef GET_LINK_IMPL
37284	bool ByteCodeEmitter::emitLESint8(SourceInfo L) {
37285	return emitOp<>(OP_LESint8, L);
37286	}
37287	bool ByteCodeEmitter::emitLEUint8(SourceInfo L) {
37288	return emitOp<>(OP_LEUint8, L);
37289	}
37290	bool ByteCodeEmitter::emitLESint16(SourceInfo L) {
37291	return emitOp<>(OP_LESint16, L);
37292	}
37293	bool ByteCodeEmitter::emitLEUint16(SourceInfo L) {
37294	return emitOp<>(OP_LEUint16, L);
37295	}
37296	bool ByteCodeEmitter::emitLESint32(SourceInfo L) {
37297	return emitOp<>(OP_LESint32, L);
37298	}
37299	bool ByteCodeEmitter::emitLEUint32(SourceInfo L) {
37300	return emitOp<>(OP_LEUint32, L);
37301	}
37302	bool ByteCodeEmitter::emitLESint64(SourceInfo L) {
37303	return emitOp<>(OP_LESint64, L);
37304	}
37305	bool ByteCodeEmitter::emitLEUint64(SourceInfo L) {
37306	return emitOp<>(OP_LEUint64, L);
37307	}
37308	bool ByteCodeEmitter::emitLEIntAP(SourceInfo L) {
37309	return emitOp<>(OP_LEIntAP, L);
37310	}
37311	bool ByteCodeEmitter::emitLEIntAPS(SourceInfo L) {
37312	return emitOp<>(OP_LEIntAPS, L);
37313	}
37314	bool ByteCodeEmitter::emitLEBool(SourceInfo L) {
37315	return emitOp<>(OP_LEBool, L);
37316	}
37317	bool ByteCodeEmitter::emitLEFixedPoint(SourceInfo L) {
37318	return emitOp<>(OP_LEFixedPoint, L);
37319	}
37320	bool ByteCodeEmitter::emitLEPtr(SourceInfo L) {
37321	return emitOp<>(OP_LEPtr, L);
37322	}
37323	bool ByteCodeEmitter::emitLEFloat(SourceInfo L) {
37324	return emitOp<>(OP_LEFloat, L);
37325	}
37326	#endif
37327	#ifdef GET_EVAL_IMPL
37328	bool EvalEmitter::emitLESint8(SourceInfo L) {
37329	if (!isActive()) return true;
37330	CurrentSource = L;
37331	return LE<PT_Sint8>(S, CodePtr());
37332	}
37333	bool EvalEmitter::emitLEUint8(SourceInfo L) {
37334	if (!isActive()) return true;
37335	CurrentSource = L;
37336	return LE<PT_Uint8>(S, CodePtr());
37337	}
37338	bool EvalEmitter::emitLESint16(SourceInfo L) {
37339	if (!isActive()) return true;
37340	CurrentSource = L;
37341	return LE<PT_Sint16>(S, CodePtr());
37342	}
37343	bool EvalEmitter::emitLEUint16(SourceInfo L) {
37344	if (!isActive()) return true;
37345	CurrentSource = L;
37346	return LE<PT_Uint16>(S, CodePtr());
37347	}
37348	bool EvalEmitter::emitLESint32(SourceInfo L) {
37349	if (!isActive()) return true;
37350	CurrentSource = L;
37351	return LE<PT_Sint32>(S, CodePtr());
37352	}
37353	bool EvalEmitter::emitLEUint32(SourceInfo L) {
37354	if (!isActive()) return true;
37355	CurrentSource = L;
37356	return LE<PT_Uint32>(S, CodePtr());
37357	}
37358	bool EvalEmitter::emitLESint64(SourceInfo L) {
37359	if (!isActive()) return true;
37360	CurrentSource = L;
37361	return LE<PT_Sint64>(S, CodePtr());
37362	}
37363	bool EvalEmitter::emitLEUint64(SourceInfo L) {
37364	if (!isActive()) return true;
37365	CurrentSource = L;
37366	return LE<PT_Uint64>(S, CodePtr());
37367	}
37368	bool EvalEmitter::emitLEIntAP(SourceInfo L) {
37369	if (!isActive()) return true;
37370	CurrentSource = L;
37371	return LE<PT_IntAP>(S, CodePtr());
37372	}
37373	bool EvalEmitter::emitLEIntAPS(SourceInfo L) {
37374	if (!isActive()) return true;
37375	CurrentSource = L;
37376	return LE<PT_IntAPS>(S, CodePtr());
37377	}
37378	bool EvalEmitter::emitLEBool(SourceInfo L) {
37379	if (!isActive()) return true;
37380	CurrentSource = L;
37381	return LE<PT_Bool>(S, CodePtr());
37382	}
37383	bool EvalEmitter::emitLEFixedPoint(SourceInfo L) {
37384	if (!isActive()) return true;
37385	CurrentSource = L;
37386	return LE<PT_FixedPoint>(S, CodePtr());
37387	}
37388	bool EvalEmitter::emitLEPtr(SourceInfo L) {
37389	if (!isActive()) return true;
37390	CurrentSource = L;
37391	return LE<PT_Ptr>(S, CodePtr());
37392	}
37393	bool EvalEmitter::emitLEFloat(SourceInfo L) {
37394	if (!isActive()) return true;
37395	CurrentSource = L;
37396	return LE<PT_Float>(S, CodePtr());
37397	}
37398	#endif
37399	#ifdef GET_OPCODE_NAMES
37400	OP_LTSint8,
37401	OP_LTUint8,
37402	OP_LTSint16,
37403	OP_LTUint16,
37404	OP_LTSint32,
37405	OP_LTUint32,
37406	OP_LTSint64,
37407	OP_LTUint64,
37408	OP_LTIntAP,
37409	OP_LTIntAPS,
37410	OP_LTBool,
37411	OP_LTFixedPoint,
37412	OP_LTPtr,
37413	OP_LTFloat,
37414	#endif
37415	#ifdef GET_INTERPFN_LIST
37416	&Interp_LTSint8,
37417	&Interp_LTUint8,
37418	&Interp_LTSint16,
37419	&Interp_LTUint16,
37420	&Interp_LTSint32,
37421	&Interp_LTUint32,
37422	&Interp_LTSint64,
37423	&Interp_LTUint64,
37424	&Interp_LTIntAP,
37425	&Interp_LTIntAPS,
37426	&Interp_LTBool,
37427	&Interp_LTFixedPoint,
37428	&Interp_LTPtr,
37429	&Interp_LTFloat,
37430	#endif
37431	#ifdef GET_INTERPFN_DISPATCHERS
37432	PRESERVE_NONE
37433	static bool Interp_LTSint8(InterpState &S) {
37434	if (!LT<PT_Sint8>(S, S.PC)) return false;
37435	#if USE_TAILCALLS
37436	MUSTTAIL return InterpNext(S);
37437	#else
37438	return true;
37439	#endif
37440	}
37441	PRESERVE_NONE
37442	static bool Interp_LTUint8(InterpState &S) {
37443	if (!LT<PT_Uint8>(S, S.PC)) return false;
37444	#if USE_TAILCALLS
37445	MUSTTAIL return InterpNext(S);
37446	#else
37447	return true;
37448	#endif
37449	}
37450	PRESERVE_NONE
37451	static bool Interp_LTSint16(InterpState &S) {
37452	if (!LT<PT_Sint16>(S, S.PC)) return false;
37453	#if USE_TAILCALLS
37454	MUSTTAIL return InterpNext(S);
37455	#else
37456	return true;
37457	#endif
37458	}
37459	PRESERVE_NONE
37460	static bool Interp_LTUint16(InterpState &S) {
37461	if (!LT<PT_Uint16>(S, S.PC)) return false;
37462	#if USE_TAILCALLS
37463	MUSTTAIL return InterpNext(S);
37464	#else
37465	return true;
37466	#endif
37467	}
37468	PRESERVE_NONE
37469	static bool Interp_LTSint32(InterpState &S) {
37470	if (!LT<PT_Sint32>(S, S.PC)) return false;
37471	#if USE_TAILCALLS
37472	MUSTTAIL return InterpNext(S);
37473	#else
37474	return true;
37475	#endif
37476	}
37477	PRESERVE_NONE
37478	static bool Interp_LTUint32(InterpState &S) {
37479	if (!LT<PT_Uint32>(S, S.PC)) return false;
37480	#if USE_TAILCALLS
37481	MUSTTAIL return InterpNext(S);
37482	#else
37483	return true;
37484	#endif
37485	}
37486	PRESERVE_NONE
37487	static bool Interp_LTSint64(InterpState &S) {
37488	if (!LT<PT_Sint64>(S, S.PC)) return false;
37489	#if USE_TAILCALLS
37490	MUSTTAIL return InterpNext(S);
37491	#else
37492	return true;
37493	#endif
37494	}
37495	PRESERVE_NONE
37496	static bool Interp_LTUint64(InterpState &S) {
37497	if (!LT<PT_Uint64>(S, S.PC)) return false;
37498	#if USE_TAILCALLS
37499	MUSTTAIL return InterpNext(S);
37500	#else
37501	return true;
37502	#endif
37503	}
37504	PRESERVE_NONE
37505	static bool Interp_LTIntAP(InterpState &S) {
37506	if (!LT<PT_IntAP>(S, S.PC)) return false;
37507	#if USE_TAILCALLS
37508	MUSTTAIL return InterpNext(S);
37509	#else
37510	return true;
37511	#endif
37512	}
37513	PRESERVE_NONE
37514	static bool Interp_LTIntAPS(InterpState &S) {
37515	if (!LT<PT_IntAPS>(S, S.PC)) return false;
37516	#if USE_TAILCALLS
37517	MUSTTAIL return InterpNext(S);
37518	#else
37519	return true;
37520	#endif
37521	}
37522	PRESERVE_NONE
37523	static bool Interp_LTBool(InterpState &S) {
37524	if (!LT<PT_Bool>(S, S.PC)) return false;
37525	#if USE_TAILCALLS
37526	MUSTTAIL return InterpNext(S);
37527	#else
37528	return true;
37529	#endif
37530	}
37531	PRESERVE_NONE
37532	static bool Interp_LTFixedPoint(InterpState &S) {
37533	if (!LT<PT_FixedPoint>(S, S.PC)) return false;
37534	#if USE_TAILCALLS
37535	MUSTTAIL return InterpNext(S);
37536	#else
37537	return true;
37538	#endif
37539	}
37540	PRESERVE_NONE
37541	static bool Interp_LTPtr(InterpState &S) {
37542	if (!LT<PT_Ptr>(S, S.PC)) return false;
37543	#if USE_TAILCALLS
37544	MUSTTAIL return InterpNext(S);
37545	#else
37546	return true;
37547	#endif
37548	}
37549	PRESERVE_NONE
37550	static bool Interp_LTFloat(InterpState &S) {
37551	if (!LT<PT_Float>(S, S.PC)) return false;
37552	#if USE_TAILCALLS
37553	MUSTTAIL return InterpNext(S);
37554	#else
37555	return true;
37556	#endif
37557	}
37558	#endif
37559	#ifdef GET_DISASM
37560	case OP_LTSint8:
37561	Text.Op = PrintName("LTSint8");
37562	break;
37563	case OP_LTUint8:
37564	Text.Op = PrintName("LTUint8");
37565	break;
37566	case OP_LTSint16:
37567	Text.Op = PrintName("LTSint16");
37568	break;
37569	case OP_LTUint16:
37570	Text.Op = PrintName("LTUint16");
37571	break;
37572	case OP_LTSint32:
37573	Text.Op = PrintName("LTSint32");
37574	break;
37575	case OP_LTUint32:
37576	Text.Op = PrintName("LTUint32");
37577	break;
37578	case OP_LTSint64:
37579	Text.Op = PrintName("LTSint64");
37580	break;
37581	case OP_LTUint64:
37582	Text.Op = PrintName("LTUint64");
37583	break;
37584	case OP_LTIntAP:
37585	Text.Op = PrintName("LTIntAP");
37586	break;
37587	case OP_LTIntAPS:
37588	Text.Op = PrintName("LTIntAPS");
37589	break;
37590	case OP_LTBool:
37591	Text.Op = PrintName("LTBool");
37592	break;
37593	case OP_LTFixedPoint:
37594	Text.Op = PrintName("LTFixedPoint");
37595	break;
37596	case OP_LTPtr:
37597	Text.Op = PrintName("LTPtr");
37598	break;
37599	case OP_LTFloat:
37600	Text.Op = PrintName("LTFloat");
37601	break;
37602	#endif
37603	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37604	bool emitLTSint8(SourceInfo);
37605	bool emitLTUint8(SourceInfo);
37606	bool emitLTSint16(SourceInfo);
37607	bool emitLTUint16(SourceInfo);
37608	bool emitLTSint32(SourceInfo);
37609	bool emitLTUint32(SourceInfo);
37610	bool emitLTSint64(SourceInfo);
37611	bool emitLTUint64(SourceInfo);
37612	bool emitLTIntAP(SourceInfo);
37613	bool emitLTIntAPS(SourceInfo);
37614	bool emitLTBool(SourceInfo);
37615	bool emitLTFixedPoint(SourceInfo);
37616	bool emitLTPtr(SourceInfo);
37617	bool emitLTFloat(SourceInfo);
37618	#endif
37619	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37620	[[nodiscard]] bool emitLT(PrimType, SourceInfo I);
37621	#endif
37622	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
37623	bool
37624	#if defined(GET_EVAL_IMPL)
37625	EvalEmitter
37626	#else
37627	ByteCodeEmitter
37628	#endif
37629	::emitLT(PrimType T0, SourceInfo I) {
37630	switch (T0) {
37631	case PT_Sint8:
37632	return emitLTSint8(I);
37633	case PT_Uint8:
37634	return emitLTUint8(I);
37635	case PT_Sint16:
37636	return emitLTSint16(I);
37637	case PT_Uint16:
37638	return emitLTUint16(I);
37639	case PT_Sint32:
37640	return emitLTSint32(I);
37641	case PT_Uint32:
37642	return emitLTUint32(I);
37643	case PT_Sint64:
37644	return emitLTSint64(I);
37645	case PT_Uint64:
37646	return emitLTUint64(I);
37647	case PT_IntAP:
37648	return emitLTIntAP(I);
37649	case PT_IntAPS:
37650	return emitLTIntAPS(I);
37651	case PT_Bool:
37652	return emitLTBool(I);
37653	case PT_FixedPoint:
37654	return emitLTFixedPoint(I);
37655	case PT_Ptr:
37656	return emitLTPtr(I);
37657	case PT_Float:
37658	return emitLTFloat(I);
37659	default: llvm_unreachable("invalid type: emitLT");
37660	}
37661	llvm_unreachable("invalid enum value");
37662	}
37663	#endif
37664	#ifdef GET_LINK_IMPL
37665	bool ByteCodeEmitter::emitLTSint8(SourceInfo L) {
37666	return emitOp<>(OP_LTSint8, L);
37667	}
37668	bool ByteCodeEmitter::emitLTUint8(SourceInfo L) {
37669	return emitOp<>(OP_LTUint8, L);
37670	}
37671	bool ByteCodeEmitter::emitLTSint16(SourceInfo L) {
37672	return emitOp<>(OP_LTSint16, L);
37673	}
37674	bool ByteCodeEmitter::emitLTUint16(SourceInfo L) {
37675	return emitOp<>(OP_LTUint16, L);
37676	}
37677	bool ByteCodeEmitter::emitLTSint32(SourceInfo L) {
37678	return emitOp<>(OP_LTSint32, L);
37679	}
37680	bool ByteCodeEmitter::emitLTUint32(SourceInfo L) {
37681	return emitOp<>(OP_LTUint32, L);
37682	}
37683	bool ByteCodeEmitter::emitLTSint64(SourceInfo L) {
37684	return emitOp<>(OP_LTSint64, L);
37685	}
37686	bool ByteCodeEmitter::emitLTUint64(SourceInfo L) {
37687	return emitOp<>(OP_LTUint64, L);
37688	}
37689	bool ByteCodeEmitter::emitLTIntAP(SourceInfo L) {
37690	return emitOp<>(OP_LTIntAP, L);
37691	}
37692	bool ByteCodeEmitter::emitLTIntAPS(SourceInfo L) {
37693	return emitOp<>(OP_LTIntAPS, L);
37694	}
37695	bool ByteCodeEmitter::emitLTBool(SourceInfo L) {
37696	return emitOp<>(OP_LTBool, L);
37697	}
37698	bool ByteCodeEmitter::emitLTFixedPoint(SourceInfo L) {
37699	return emitOp<>(OP_LTFixedPoint, L);
37700	}
37701	bool ByteCodeEmitter::emitLTPtr(SourceInfo L) {
37702	return emitOp<>(OP_LTPtr, L);
37703	}
37704	bool ByteCodeEmitter::emitLTFloat(SourceInfo L) {
37705	return emitOp<>(OP_LTFloat, L);
37706	}
37707	#endif
37708	#ifdef GET_EVAL_IMPL
37709	bool EvalEmitter::emitLTSint8(SourceInfo L) {
37710	if (!isActive()) return true;
37711	CurrentSource = L;
37712	return LT<PT_Sint8>(S, CodePtr());
37713	}
37714	bool EvalEmitter::emitLTUint8(SourceInfo L) {
37715	if (!isActive()) return true;
37716	CurrentSource = L;
37717	return LT<PT_Uint8>(S, CodePtr());
37718	}
37719	bool EvalEmitter::emitLTSint16(SourceInfo L) {
37720	if (!isActive()) return true;
37721	CurrentSource = L;
37722	return LT<PT_Sint16>(S, CodePtr());
37723	}
37724	bool EvalEmitter::emitLTUint16(SourceInfo L) {
37725	if (!isActive()) return true;
37726	CurrentSource = L;
37727	return LT<PT_Uint16>(S, CodePtr());
37728	}
37729	bool EvalEmitter::emitLTSint32(SourceInfo L) {
37730	if (!isActive()) return true;
37731	CurrentSource = L;
37732	return LT<PT_Sint32>(S, CodePtr());
37733	}
37734	bool EvalEmitter::emitLTUint32(SourceInfo L) {
37735	if (!isActive()) return true;
37736	CurrentSource = L;
37737	return LT<PT_Uint32>(S, CodePtr());
37738	}
37739	bool EvalEmitter::emitLTSint64(SourceInfo L) {
37740	if (!isActive()) return true;
37741	CurrentSource = L;
37742	return LT<PT_Sint64>(S, CodePtr());
37743	}
37744	bool EvalEmitter::emitLTUint64(SourceInfo L) {
37745	if (!isActive()) return true;
37746	CurrentSource = L;
37747	return LT<PT_Uint64>(S, CodePtr());
37748	}
37749	bool EvalEmitter::emitLTIntAP(SourceInfo L) {
37750	if (!isActive()) return true;
37751	CurrentSource = L;
37752	return LT<PT_IntAP>(S, CodePtr());
37753	}
37754	bool EvalEmitter::emitLTIntAPS(SourceInfo L) {
37755	if (!isActive()) return true;
37756	CurrentSource = L;
37757	return LT<PT_IntAPS>(S, CodePtr());
37758	}
37759	bool EvalEmitter::emitLTBool(SourceInfo L) {
37760	if (!isActive()) return true;
37761	CurrentSource = L;
37762	return LT<PT_Bool>(S, CodePtr());
37763	}
37764	bool EvalEmitter::emitLTFixedPoint(SourceInfo L) {
37765	if (!isActive()) return true;
37766	CurrentSource = L;
37767	return LT<PT_FixedPoint>(S, CodePtr());
37768	}
37769	bool EvalEmitter::emitLTPtr(SourceInfo L) {
37770	if (!isActive()) return true;
37771	CurrentSource = L;
37772	return LT<PT_Ptr>(S, CodePtr());
37773	}
37774	bool EvalEmitter::emitLTFloat(SourceInfo L) {
37775	if (!isActive()) return true;
37776	CurrentSource = L;
37777	return LT<PT_Float>(S, CodePtr());
37778	}
37779	#endif
37780	#ifdef GET_OPCODE_NAMES
37781	OP_LoadSint8,
37782	OP_LoadUint8,
37783	OP_LoadSint16,
37784	OP_LoadUint16,
37785	OP_LoadSint32,
37786	OP_LoadUint32,
37787	OP_LoadSint64,
37788	OP_LoadUint64,
37789	OP_LoadIntAP,
37790	OP_LoadIntAPS,
37791	OP_LoadBool,
37792	OP_LoadFixedPoint,
37793	OP_LoadPtr,
37794	OP_LoadMemberPtr,
37795	OP_LoadFloat,
37796	#endif
37797	#ifdef GET_INTERPFN_LIST
37798	&Interp_LoadSint8,
37799	&Interp_LoadUint8,
37800	&Interp_LoadSint16,
37801	&Interp_LoadUint16,
37802	&Interp_LoadSint32,
37803	&Interp_LoadUint32,
37804	&Interp_LoadSint64,
37805	&Interp_LoadUint64,
37806	&Interp_LoadIntAP,
37807	&Interp_LoadIntAPS,
37808	&Interp_LoadBool,
37809	&Interp_LoadFixedPoint,
37810	&Interp_LoadPtr,
37811	&Interp_LoadMemberPtr,
37812	&Interp_LoadFloat,
37813	#endif
37814	#ifdef GET_INTERPFN_DISPATCHERS
37815	PRESERVE_NONE
37816	static bool Interp_LoadSint8(InterpState &S) {
37817	if (!Load<PT_Sint8>(S, S.PC)) return false;
37818	#if USE_TAILCALLS
37819	MUSTTAIL return InterpNext(S);
37820	#else
37821	return true;
37822	#endif
37823	}
37824	PRESERVE_NONE
37825	static bool Interp_LoadUint8(InterpState &S) {
37826	if (!Load<PT_Uint8>(S, S.PC)) return false;
37827	#if USE_TAILCALLS
37828	MUSTTAIL return InterpNext(S);
37829	#else
37830	return true;
37831	#endif
37832	}
37833	PRESERVE_NONE
37834	static bool Interp_LoadSint16(InterpState &S) {
37835	if (!Load<PT_Sint16>(S, S.PC)) return false;
37836	#if USE_TAILCALLS
37837	MUSTTAIL return InterpNext(S);
37838	#else
37839	return true;
37840	#endif
37841	}
37842	PRESERVE_NONE
37843	static bool Interp_LoadUint16(InterpState &S) {
37844	if (!Load<PT_Uint16>(S, S.PC)) return false;
37845	#if USE_TAILCALLS
37846	MUSTTAIL return InterpNext(S);
37847	#else
37848	return true;
37849	#endif
37850	}
37851	PRESERVE_NONE
37852	static bool Interp_LoadSint32(InterpState &S) {
37853	if (!Load<PT_Sint32>(S, S.PC)) return false;
37854	#if USE_TAILCALLS
37855	MUSTTAIL return InterpNext(S);
37856	#else
37857	return true;
37858	#endif
37859	}
37860	PRESERVE_NONE
37861	static bool Interp_LoadUint32(InterpState &S) {
37862	if (!Load<PT_Uint32>(S, S.PC)) return false;
37863	#if USE_TAILCALLS
37864	MUSTTAIL return InterpNext(S);
37865	#else
37866	return true;
37867	#endif
37868	}
37869	PRESERVE_NONE
37870	static bool Interp_LoadSint64(InterpState &S) {
37871	if (!Load<PT_Sint64>(S, S.PC)) return false;
37872	#if USE_TAILCALLS
37873	MUSTTAIL return InterpNext(S);
37874	#else
37875	return true;
37876	#endif
37877	}
37878	PRESERVE_NONE
37879	static bool Interp_LoadUint64(InterpState &S) {
37880	if (!Load<PT_Uint64>(S, S.PC)) return false;
37881	#if USE_TAILCALLS
37882	MUSTTAIL return InterpNext(S);
37883	#else
37884	return true;
37885	#endif
37886	}
37887	PRESERVE_NONE
37888	static bool Interp_LoadIntAP(InterpState &S) {
37889	if (!Load<PT_IntAP>(S, S.PC)) return false;
37890	#if USE_TAILCALLS
37891	MUSTTAIL return InterpNext(S);
37892	#else
37893	return true;
37894	#endif
37895	}
37896	PRESERVE_NONE
37897	static bool Interp_LoadIntAPS(InterpState &S) {
37898	if (!Load<PT_IntAPS>(S, S.PC)) return false;
37899	#if USE_TAILCALLS
37900	MUSTTAIL return InterpNext(S);
37901	#else
37902	return true;
37903	#endif
37904	}
37905	PRESERVE_NONE
37906	static bool Interp_LoadBool(InterpState &S) {
37907	if (!Load<PT_Bool>(S, S.PC)) return false;
37908	#if USE_TAILCALLS
37909	MUSTTAIL return InterpNext(S);
37910	#else
37911	return true;
37912	#endif
37913	}
37914	PRESERVE_NONE
37915	static bool Interp_LoadFixedPoint(InterpState &S) {
37916	if (!Load<PT_FixedPoint>(S, S.PC)) return false;
37917	#if USE_TAILCALLS
37918	MUSTTAIL return InterpNext(S);
37919	#else
37920	return true;
37921	#endif
37922	}
37923	PRESERVE_NONE
37924	static bool Interp_LoadPtr(InterpState &S) {
37925	if (!Load<PT_Ptr>(S, S.PC)) return false;
37926	#if USE_TAILCALLS
37927	MUSTTAIL return InterpNext(S);
37928	#else
37929	return true;
37930	#endif
37931	}
37932	PRESERVE_NONE
37933	static bool Interp_LoadMemberPtr(InterpState &S) {
37934	if (!Load<PT_MemberPtr>(S, S.PC)) return false;
37935	#if USE_TAILCALLS
37936	MUSTTAIL return InterpNext(S);
37937	#else
37938	return true;
37939	#endif
37940	}
37941	PRESERVE_NONE
37942	static bool Interp_LoadFloat(InterpState &S) {
37943	if (!Load<PT_Float>(S, S.PC)) return false;
37944	#if USE_TAILCALLS
37945	MUSTTAIL return InterpNext(S);
37946	#else
37947	return true;
37948	#endif
37949	}
37950	#endif
37951	#ifdef GET_DISASM
37952	case OP_LoadSint8:
37953	Text.Op = PrintName("LoadSint8");
37954	break;
37955	case OP_LoadUint8:
37956	Text.Op = PrintName("LoadUint8");
37957	break;
37958	case OP_LoadSint16:
37959	Text.Op = PrintName("LoadSint16");
37960	break;
37961	case OP_LoadUint16:
37962	Text.Op = PrintName("LoadUint16");
37963	break;
37964	case OP_LoadSint32:
37965	Text.Op = PrintName("LoadSint32");
37966	break;
37967	case OP_LoadUint32:
37968	Text.Op = PrintName("LoadUint32");
37969	break;
37970	case OP_LoadSint64:
37971	Text.Op = PrintName("LoadSint64");
37972	break;
37973	case OP_LoadUint64:
37974	Text.Op = PrintName("LoadUint64");
37975	break;
37976	case OP_LoadIntAP:
37977	Text.Op = PrintName("LoadIntAP");
37978	break;
37979	case OP_LoadIntAPS:
37980	Text.Op = PrintName("LoadIntAPS");
37981	break;
37982	case OP_LoadBool:
37983	Text.Op = PrintName("LoadBool");
37984	break;
37985	case OP_LoadFixedPoint:
37986	Text.Op = PrintName("LoadFixedPoint");
37987	break;
37988	case OP_LoadPtr:
37989	Text.Op = PrintName("LoadPtr");
37990	break;
37991	case OP_LoadMemberPtr:
37992	Text.Op = PrintName("LoadMemberPtr");
37993	break;
37994	case OP_LoadFloat:
37995	Text.Op = PrintName("LoadFloat");
37996	break;
37997	#endif
37998	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
37999	bool emitLoadSint8(SourceInfo);
38000	bool emitLoadUint8(SourceInfo);
38001	bool emitLoadSint16(SourceInfo);
38002	bool emitLoadUint16(SourceInfo);
38003	bool emitLoadSint32(SourceInfo);
38004	bool emitLoadUint32(SourceInfo);
38005	bool emitLoadSint64(SourceInfo);
38006	bool emitLoadUint64(SourceInfo);
38007	bool emitLoadIntAP(SourceInfo);
38008	bool emitLoadIntAPS(SourceInfo);
38009	bool emitLoadBool(SourceInfo);
38010	bool emitLoadFixedPoint(SourceInfo);
38011	bool emitLoadPtr(SourceInfo);
38012	bool emitLoadMemberPtr(SourceInfo);
38013	bool emitLoadFloat(SourceInfo);
38014	#endif
38015	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38016	[[nodiscard]] bool emitLoad(PrimType, SourceInfo I);
38017	#endif
38018	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
38019	bool
38020	#if defined(GET_EVAL_IMPL)
38021	EvalEmitter
38022	#else
38023	ByteCodeEmitter
38024	#endif
38025	::emitLoad(PrimType T0, SourceInfo I) {
38026	switch (T0) {
38027	case PT_Sint8:
38028	return emitLoadSint8(I);
38029	case PT_Uint8:
38030	return emitLoadUint8(I);
38031	case PT_Sint16:
38032	return emitLoadSint16(I);
38033	case PT_Uint16:
38034	return emitLoadUint16(I);
38035	case PT_Sint32:
38036	return emitLoadSint32(I);
38037	case PT_Uint32:
38038	return emitLoadUint32(I);
38039	case PT_Sint64:
38040	return emitLoadSint64(I);
38041	case PT_Uint64:
38042	return emitLoadUint64(I);
38043	case PT_IntAP:
38044	return emitLoadIntAP(I);
38045	case PT_IntAPS:
38046	return emitLoadIntAPS(I);
38047	case PT_Bool:
38048	return emitLoadBool(I);
38049	case PT_FixedPoint:
38050	return emitLoadFixedPoint(I);
38051	case PT_Ptr:
38052	return emitLoadPtr(I);
38053	case PT_MemberPtr:
38054	return emitLoadMemberPtr(I);
38055	case PT_Float:
38056	return emitLoadFloat(I);
38057	}
38058	llvm_unreachable("invalid enum value");
38059	}
38060	#endif
38061	#ifdef GET_LINK_IMPL
38062	bool ByteCodeEmitter::emitLoadSint8(SourceInfo L) {
38063	return emitOp<>(OP_LoadSint8, L);
38064	}
38065	bool ByteCodeEmitter::emitLoadUint8(SourceInfo L) {
38066	return emitOp<>(OP_LoadUint8, L);
38067	}
38068	bool ByteCodeEmitter::emitLoadSint16(SourceInfo L) {
38069	return emitOp<>(OP_LoadSint16, L);
38070	}
38071	bool ByteCodeEmitter::emitLoadUint16(SourceInfo L) {
38072	return emitOp<>(OP_LoadUint16, L);
38073	}
38074	bool ByteCodeEmitter::emitLoadSint32(SourceInfo L) {
38075	return emitOp<>(OP_LoadSint32, L);
38076	}
38077	bool ByteCodeEmitter::emitLoadUint32(SourceInfo L) {
38078	return emitOp<>(OP_LoadUint32, L);
38079	}
38080	bool ByteCodeEmitter::emitLoadSint64(SourceInfo L) {
38081	return emitOp<>(OP_LoadSint64, L);
38082	}
38083	bool ByteCodeEmitter::emitLoadUint64(SourceInfo L) {
38084	return emitOp<>(OP_LoadUint64, L);
38085	}
38086	bool ByteCodeEmitter::emitLoadIntAP(SourceInfo L) {
38087	return emitOp<>(OP_LoadIntAP, L);
38088	}
38089	bool ByteCodeEmitter::emitLoadIntAPS(SourceInfo L) {
38090	return emitOp<>(OP_LoadIntAPS, L);
38091	}
38092	bool ByteCodeEmitter::emitLoadBool(SourceInfo L) {
38093	return emitOp<>(OP_LoadBool, L);
38094	}
38095	bool ByteCodeEmitter::emitLoadFixedPoint(SourceInfo L) {
38096	return emitOp<>(OP_LoadFixedPoint, L);
38097	}
38098	bool ByteCodeEmitter::emitLoadPtr(SourceInfo L) {
38099	return emitOp<>(OP_LoadPtr, L);
38100	}
38101	bool ByteCodeEmitter::emitLoadMemberPtr(SourceInfo L) {
38102	return emitOp<>(OP_LoadMemberPtr, L);
38103	}
38104	bool ByteCodeEmitter::emitLoadFloat(SourceInfo L) {
38105	return emitOp<>(OP_LoadFloat, L);
38106	}
38107	#endif
38108	#ifdef GET_EVAL_IMPL
38109	bool EvalEmitter::emitLoadSint8(SourceInfo L) {
38110	if (!isActive()) return true;
38111	CurrentSource = L;
38112	return Load<PT_Sint8>(S, CodePtr());
38113	}
38114	bool EvalEmitter::emitLoadUint8(SourceInfo L) {
38115	if (!isActive()) return true;
38116	CurrentSource = L;
38117	return Load<PT_Uint8>(S, CodePtr());
38118	}
38119	bool EvalEmitter::emitLoadSint16(SourceInfo L) {
38120	if (!isActive()) return true;
38121	CurrentSource = L;
38122	return Load<PT_Sint16>(S, CodePtr());
38123	}
38124	bool EvalEmitter::emitLoadUint16(SourceInfo L) {
38125	if (!isActive()) return true;
38126	CurrentSource = L;
38127	return Load<PT_Uint16>(S, CodePtr());
38128	}
38129	bool EvalEmitter::emitLoadSint32(SourceInfo L) {
38130	if (!isActive()) return true;
38131	CurrentSource = L;
38132	return Load<PT_Sint32>(S, CodePtr());
38133	}
38134	bool EvalEmitter::emitLoadUint32(SourceInfo L) {
38135	if (!isActive()) return true;
38136	CurrentSource = L;
38137	return Load<PT_Uint32>(S, CodePtr());
38138	}
38139	bool EvalEmitter::emitLoadSint64(SourceInfo L) {
38140	if (!isActive()) return true;
38141	CurrentSource = L;
38142	return Load<PT_Sint64>(S, CodePtr());
38143	}
38144	bool EvalEmitter::emitLoadUint64(SourceInfo L) {
38145	if (!isActive()) return true;
38146	CurrentSource = L;
38147	return Load<PT_Uint64>(S, CodePtr());
38148	}
38149	bool EvalEmitter::emitLoadIntAP(SourceInfo L) {
38150	if (!isActive()) return true;
38151	CurrentSource = L;
38152	return Load<PT_IntAP>(S, CodePtr());
38153	}
38154	bool EvalEmitter::emitLoadIntAPS(SourceInfo L) {
38155	if (!isActive()) return true;
38156	CurrentSource = L;
38157	return Load<PT_IntAPS>(S, CodePtr());
38158	}
38159	bool EvalEmitter::emitLoadBool(SourceInfo L) {
38160	if (!isActive()) return true;
38161	CurrentSource = L;
38162	return Load<PT_Bool>(S, CodePtr());
38163	}
38164	bool EvalEmitter::emitLoadFixedPoint(SourceInfo L) {
38165	if (!isActive()) return true;
38166	CurrentSource = L;
38167	return Load<PT_FixedPoint>(S, CodePtr());
38168	}
38169	bool EvalEmitter::emitLoadPtr(SourceInfo L) {
38170	if (!isActive()) return true;
38171	CurrentSource = L;
38172	return Load<PT_Ptr>(S, CodePtr());
38173	}
38174	bool EvalEmitter::emitLoadMemberPtr(SourceInfo L) {
38175	if (!isActive()) return true;
38176	CurrentSource = L;
38177	return Load<PT_MemberPtr>(S, CodePtr());
38178	}
38179	bool EvalEmitter::emitLoadFloat(SourceInfo L) {
38180	if (!isActive()) return true;
38181	CurrentSource = L;
38182	return Load<PT_Float>(S, CodePtr());
38183	}
38184	#endif
38185	#ifdef GET_OPCODE_NAMES
38186	OP_LoadPopSint8,
38187	OP_LoadPopUint8,
38188	OP_LoadPopSint16,
38189	OP_LoadPopUint16,
38190	OP_LoadPopSint32,
38191	OP_LoadPopUint32,
38192	OP_LoadPopSint64,
38193	OP_LoadPopUint64,
38194	OP_LoadPopIntAP,
38195	OP_LoadPopIntAPS,
38196	OP_LoadPopBool,
38197	OP_LoadPopFixedPoint,
38198	OP_LoadPopPtr,
38199	OP_LoadPopMemberPtr,
38200	OP_LoadPopFloat,
38201	#endif
38202	#ifdef GET_INTERPFN_LIST
38203	&Interp_LoadPopSint8,
38204	&Interp_LoadPopUint8,
38205	&Interp_LoadPopSint16,
38206	&Interp_LoadPopUint16,
38207	&Interp_LoadPopSint32,
38208	&Interp_LoadPopUint32,
38209	&Interp_LoadPopSint64,
38210	&Interp_LoadPopUint64,
38211	&Interp_LoadPopIntAP,
38212	&Interp_LoadPopIntAPS,
38213	&Interp_LoadPopBool,
38214	&Interp_LoadPopFixedPoint,
38215	&Interp_LoadPopPtr,
38216	&Interp_LoadPopMemberPtr,
38217	&Interp_LoadPopFloat,
38218	#endif
38219	#ifdef GET_INTERPFN_DISPATCHERS
38220	PRESERVE_NONE
38221	static bool Interp_LoadPopSint8(InterpState &S) {
38222	if (!LoadPop<PT_Sint8>(S, S.PC)) return false;
38223	#if USE_TAILCALLS
38224	MUSTTAIL return InterpNext(S);
38225	#else
38226	return true;
38227	#endif
38228	}
38229	PRESERVE_NONE
38230	static bool Interp_LoadPopUint8(InterpState &S) {
38231	if (!LoadPop<PT_Uint8>(S, S.PC)) return false;
38232	#if USE_TAILCALLS
38233	MUSTTAIL return InterpNext(S);
38234	#else
38235	return true;
38236	#endif
38237	}
38238	PRESERVE_NONE
38239	static bool Interp_LoadPopSint16(InterpState &S) {
38240	if (!LoadPop<PT_Sint16>(S, S.PC)) return false;
38241	#if USE_TAILCALLS
38242	MUSTTAIL return InterpNext(S);
38243	#else
38244	return true;
38245	#endif
38246	}
38247	PRESERVE_NONE
38248	static bool Interp_LoadPopUint16(InterpState &S) {
38249	if (!LoadPop<PT_Uint16>(S, S.PC)) return false;
38250	#if USE_TAILCALLS
38251	MUSTTAIL return InterpNext(S);
38252	#else
38253	return true;
38254	#endif
38255	}
38256	PRESERVE_NONE
38257	static bool Interp_LoadPopSint32(InterpState &S) {
38258	if (!LoadPop<PT_Sint32>(S, S.PC)) return false;
38259	#if USE_TAILCALLS
38260	MUSTTAIL return InterpNext(S);
38261	#else
38262	return true;
38263	#endif
38264	}
38265	PRESERVE_NONE
38266	static bool Interp_LoadPopUint32(InterpState &S) {
38267	if (!LoadPop<PT_Uint32>(S, S.PC)) return false;
38268	#if USE_TAILCALLS
38269	MUSTTAIL return InterpNext(S);
38270	#else
38271	return true;
38272	#endif
38273	}
38274	PRESERVE_NONE
38275	static bool Interp_LoadPopSint64(InterpState &S) {
38276	if (!LoadPop<PT_Sint64>(S, S.PC)) return false;
38277	#if USE_TAILCALLS
38278	MUSTTAIL return InterpNext(S);
38279	#else
38280	return true;
38281	#endif
38282	}
38283	PRESERVE_NONE
38284	static bool Interp_LoadPopUint64(InterpState &S) {
38285	if (!LoadPop<PT_Uint64>(S, S.PC)) return false;
38286	#if USE_TAILCALLS
38287	MUSTTAIL return InterpNext(S);
38288	#else
38289	return true;
38290	#endif
38291	}
38292	PRESERVE_NONE
38293	static bool Interp_LoadPopIntAP(InterpState &S) {
38294	if (!LoadPop<PT_IntAP>(S, S.PC)) return false;
38295	#if USE_TAILCALLS
38296	MUSTTAIL return InterpNext(S);
38297	#else
38298	return true;
38299	#endif
38300	}
38301	PRESERVE_NONE
38302	static bool Interp_LoadPopIntAPS(InterpState &S) {
38303	if (!LoadPop<PT_IntAPS>(S, S.PC)) return false;
38304	#if USE_TAILCALLS
38305	MUSTTAIL return InterpNext(S);
38306	#else
38307	return true;
38308	#endif
38309	}
38310	PRESERVE_NONE
38311	static bool Interp_LoadPopBool(InterpState &S) {
38312	if (!LoadPop<PT_Bool>(S, S.PC)) return false;
38313	#if USE_TAILCALLS
38314	MUSTTAIL return InterpNext(S);
38315	#else
38316	return true;
38317	#endif
38318	}
38319	PRESERVE_NONE
38320	static bool Interp_LoadPopFixedPoint(InterpState &S) {
38321	if (!LoadPop<PT_FixedPoint>(S, S.PC)) return false;
38322	#if USE_TAILCALLS
38323	MUSTTAIL return InterpNext(S);
38324	#else
38325	return true;
38326	#endif
38327	}
38328	PRESERVE_NONE
38329	static bool Interp_LoadPopPtr(InterpState &S) {
38330	if (!LoadPop<PT_Ptr>(S, S.PC)) return false;
38331	#if USE_TAILCALLS
38332	MUSTTAIL return InterpNext(S);
38333	#else
38334	return true;
38335	#endif
38336	}
38337	PRESERVE_NONE
38338	static bool Interp_LoadPopMemberPtr(InterpState &S) {
38339	if (!LoadPop<PT_MemberPtr>(S, S.PC)) return false;
38340	#if USE_TAILCALLS
38341	MUSTTAIL return InterpNext(S);
38342	#else
38343	return true;
38344	#endif
38345	}
38346	PRESERVE_NONE
38347	static bool Interp_LoadPopFloat(InterpState &S) {
38348	if (!LoadPop<PT_Float>(S, S.PC)) return false;
38349	#if USE_TAILCALLS
38350	MUSTTAIL return InterpNext(S);
38351	#else
38352	return true;
38353	#endif
38354	}
38355	#endif
38356	#ifdef GET_DISASM
38357	case OP_LoadPopSint8:
38358	Text.Op = PrintName("LoadPopSint8");
38359	break;
38360	case OP_LoadPopUint8:
38361	Text.Op = PrintName("LoadPopUint8");
38362	break;
38363	case OP_LoadPopSint16:
38364	Text.Op = PrintName("LoadPopSint16");
38365	break;
38366	case OP_LoadPopUint16:
38367	Text.Op = PrintName("LoadPopUint16");
38368	break;
38369	case OP_LoadPopSint32:
38370	Text.Op = PrintName("LoadPopSint32");
38371	break;
38372	case OP_LoadPopUint32:
38373	Text.Op = PrintName("LoadPopUint32");
38374	break;
38375	case OP_LoadPopSint64:
38376	Text.Op = PrintName("LoadPopSint64");
38377	break;
38378	case OP_LoadPopUint64:
38379	Text.Op = PrintName("LoadPopUint64");
38380	break;
38381	case OP_LoadPopIntAP:
38382	Text.Op = PrintName("LoadPopIntAP");
38383	break;
38384	case OP_LoadPopIntAPS:
38385	Text.Op = PrintName("LoadPopIntAPS");
38386	break;
38387	case OP_LoadPopBool:
38388	Text.Op = PrintName("LoadPopBool");
38389	break;
38390	case OP_LoadPopFixedPoint:
38391	Text.Op = PrintName("LoadPopFixedPoint");
38392	break;
38393	case OP_LoadPopPtr:
38394	Text.Op = PrintName("LoadPopPtr");
38395	break;
38396	case OP_LoadPopMemberPtr:
38397	Text.Op = PrintName("LoadPopMemberPtr");
38398	break;
38399	case OP_LoadPopFloat:
38400	Text.Op = PrintName("LoadPopFloat");
38401	break;
38402	#endif
38403	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38404	bool emitLoadPopSint8(SourceInfo);
38405	bool emitLoadPopUint8(SourceInfo);
38406	bool emitLoadPopSint16(SourceInfo);
38407	bool emitLoadPopUint16(SourceInfo);
38408	bool emitLoadPopSint32(SourceInfo);
38409	bool emitLoadPopUint32(SourceInfo);
38410	bool emitLoadPopSint64(SourceInfo);
38411	bool emitLoadPopUint64(SourceInfo);
38412	bool emitLoadPopIntAP(SourceInfo);
38413	bool emitLoadPopIntAPS(SourceInfo);
38414	bool emitLoadPopBool(SourceInfo);
38415	bool emitLoadPopFixedPoint(SourceInfo);
38416	bool emitLoadPopPtr(SourceInfo);
38417	bool emitLoadPopMemberPtr(SourceInfo);
38418	bool emitLoadPopFloat(SourceInfo);
38419	#endif
38420	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38421	[[nodiscard]] bool emitLoadPop(PrimType, SourceInfo I);
38422	#endif
38423	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
38424	bool
38425	#if defined(GET_EVAL_IMPL)
38426	EvalEmitter
38427	#else
38428	ByteCodeEmitter
38429	#endif
38430	::emitLoadPop(PrimType T0, SourceInfo I) {
38431	switch (T0) {
38432	case PT_Sint8:
38433	return emitLoadPopSint8(I);
38434	case PT_Uint8:
38435	return emitLoadPopUint8(I);
38436	case PT_Sint16:
38437	return emitLoadPopSint16(I);
38438	case PT_Uint16:
38439	return emitLoadPopUint16(I);
38440	case PT_Sint32:
38441	return emitLoadPopSint32(I);
38442	case PT_Uint32:
38443	return emitLoadPopUint32(I);
38444	case PT_Sint64:
38445	return emitLoadPopSint64(I);
38446	case PT_Uint64:
38447	return emitLoadPopUint64(I);
38448	case PT_IntAP:
38449	return emitLoadPopIntAP(I);
38450	case PT_IntAPS:
38451	return emitLoadPopIntAPS(I);
38452	case PT_Bool:
38453	return emitLoadPopBool(I);
38454	case PT_FixedPoint:
38455	return emitLoadPopFixedPoint(I);
38456	case PT_Ptr:
38457	return emitLoadPopPtr(I);
38458	case PT_MemberPtr:
38459	return emitLoadPopMemberPtr(I);
38460	case PT_Float:
38461	return emitLoadPopFloat(I);
38462	}
38463	llvm_unreachable("invalid enum value");
38464	}
38465	#endif
38466	#ifdef GET_LINK_IMPL
38467	bool ByteCodeEmitter::emitLoadPopSint8(SourceInfo L) {
38468	return emitOp<>(OP_LoadPopSint8, L);
38469	}
38470	bool ByteCodeEmitter::emitLoadPopUint8(SourceInfo L) {
38471	return emitOp<>(OP_LoadPopUint8, L);
38472	}
38473	bool ByteCodeEmitter::emitLoadPopSint16(SourceInfo L) {
38474	return emitOp<>(OP_LoadPopSint16, L);
38475	}
38476	bool ByteCodeEmitter::emitLoadPopUint16(SourceInfo L) {
38477	return emitOp<>(OP_LoadPopUint16, L);
38478	}
38479	bool ByteCodeEmitter::emitLoadPopSint32(SourceInfo L) {
38480	return emitOp<>(OP_LoadPopSint32, L);
38481	}
38482	bool ByteCodeEmitter::emitLoadPopUint32(SourceInfo L) {
38483	return emitOp<>(OP_LoadPopUint32, L);
38484	}
38485	bool ByteCodeEmitter::emitLoadPopSint64(SourceInfo L) {
38486	return emitOp<>(OP_LoadPopSint64, L);
38487	}
38488	bool ByteCodeEmitter::emitLoadPopUint64(SourceInfo L) {
38489	return emitOp<>(OP_LoadPopUint64, L);
38490	}
38491	bool ByteCodeEmitter::emitLoadPopIntAP(SourceInfo L) {
38492	return emitOp<>(OP_LoadPopIntAP, L);
38493	}
38494	bool ByteCodeEmitter::emitLoadPopIntAPS(SourceInfo L) {
38495	return emitOp<>(OP_LoadPopIntAPS, L);
38496	}
38497	bool ByteCodeEmitter::emitLoadPopBool(SourceInfo L) {
38498	return emitOp<>(OP_LoadPopBool, L);
38499	}
38500	bool ByteCodeEmitter::emitLoadPopFixedPoint(SourceInfo L) {
38501	return emitOp<>(OP_LoadPopFixedPoint, L);
38502	}
38503	bool ByteCodeEmitter::emitLoadPopPtr(SourceInfo L) {
38504	return emitOp<>(OP_LoadPopPtr, L);
38505	}
38506	bool ByteCodeEmitter::emitLoadPopMemberPtr(SourceInfo L) {
38507	return emitOp<>(OP_LoadPopMemberPtr, L);
38508	}
38509	bool ByteCodeEmitter::emitLoadPopFloat(SourceInfo L) {
38510	return emitOp<>(OP_LoadPopFloat, L);
38511	}
38512	#endif
38513	#ifdef GET_EVAL_IMPL
38514	bool EvalEmitter::emitLoadPopSint8(SourceInfo L) {
38515	if (!isActive()) return true;
38516	CurrentSource = L;
38517	return LoadPop<PT_Sint8>(S, CodePtr());
38518	}
38519	bool EvalEmitter::emitLoadPopUint8(SourceInfo L) {
38520	if (!isActive()) return true;
38521	CurrentSource = L;
38522	return LoadPop<PT_Uint8>(S, CodePtr());
38523	}
38524	bool EvalEmitter::emitLoadPopSint16(SourceInfo L) {
38525	if (!isActive()) return true;
38526	CurrentSource = L;
38527	return LoadPop<PT_Sint16>(S, CodePtr());
38528	}
38529	bool EvalEmitter::emitLoadPopUint16(SourceInfo L) {
38530	if (!isActive()) return true;
38531	CurrentSource = L;
38532	return LoadPop<PT_Uint16>(S, CodePtr());
38533	}
38534	bool EvalEmitter::emitLoadPopSint32(SourceInfo L) {
38535	if (!isActive()) return true;
38536	CurrentSource = L;
38537	return LoadPop<PT_Sint32>(S, CodePtr());
38538	}
38539	bool EvalEmitter::emitLoadPopUint32(SourceInfo L) {
38540	if (!isActive()) return true;
38541	CurrentSource = L;
38542	return LoadPop<PT_Uint32>(S, CodePtr());
38543	}
38544	bool EvalEmitter::emitLoadPopSint64(SourceInfo L) {
38545	if (!isActive()) return true;
38546	CurrentSource = L;
38547	return LoadPop<PT_Sint64>(S, CodePtr());
38548	}
38549	bool EvalEmitter::emitLoadPopUint64(SourceInfo L) {
38550	if (!isActive()) return true;
38551	CurrentSource = L;
38552	return LoadPop<PT_Uint64>(S, CodePtr());
38553	}
38554	bool EvalEmitter::emitLoadPopIntAP(SourceInfo L) {
38555	if (!isActive()) return true;
38556	CurrentSource = L;
38557	return LoadPop<PT_IntAP>(S, CodePtr());
38558	}
38559	bool EvalEmitter::emitLoadPopIntAPS(SourceInfo L) {
38560	if (!isActive()) return true;
38561	CurrentSource = L;
38562	return LoadPop<PT_IntAPS>(S, CodePtr());
38563	}
38564	bool EvalEmitter::emitLoadPopBool(SourceInfo L) {
38565	if (!isActive()) return true;
38566	CurrentSource = L;
38567	return LoadPop<PT_Bool>(S, CodePtr());
38568	}
38569	bool EvalEmitter::emitLoadPopFixedPoint(SourceInfo L) {
38570	if (!isActive()) return true;
38571	CurrentSource = L;
38572	return LoadPop<PT_FixedPoint>(S, CodePtr());
38573	}
38574	bool EvalEmitter::emitLoadPopPtr(SourceInfo L) {
38575	if (!isActive()) return true;
38576	CurrentSource = L;
38577	return LoadPop<PT_Ptr>(S, CodePtr());
38578	}
38579	bool EvalEmitter::emitLoadPopMemberPtr(SourceInfo L) {
38580	if (!isActive()) return true;
38581	CurrentSource = L;
38582	return LoadPop<PT_MemberPtr>(S, CodePtr());
38583	}
38584	bool EvalEmitter::emitLoadPopFloat(SourceInfo L) {
38585	if (!isActive()) return true;
38586	CurrentSource = L;
38587	return LoadPop<PT_Float>(S, CodePtr());
38588	}
38589	#endif
38590	#ifdef GET_OPCODE_NAMES
38591	OP_MarkDestroyed,
38592	#endif
38593	#ifdef GET_INTERPFN_LIST
38594	&Interp_MarkDestroyed,
38595	#endif
38596	#ifdef GET_INTERPFN_DISPATCHERS
38597	PRESERVE_NONE
38598	static bool Interp_MarkDestroyed(InterpState &S) {
38599	if (!MarkDestroyed(S, S.PC)) return false;
38600	#if USE_TAILCALLS
38601	MUSTTAIL return InterpNext(S);
38602	#else
38603	return true;
38604	#endif
38605	}
38606	#endif
38607	#ifdef GET_DISASM
38608	case OP_MarkDestroyed:
38609	Text.Op = PrintName("MarkDestroyed");
38610	break;
38611	#endif
38612	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38613	bool emitMarkDestroyed(SourceInfo);
38614	#endif
38615	#ifdef GET_LINK_IMPL
38616	bool ByteCodeEmitter::emitMarkDestroyed(SourceInfo L) {
38617	return emitOp<>(OP_MarkDestroyed, L);
38618	}
38619	#endif
38620	#ifdef GET_EVAL_IMPL
38621	bool EvalEmitter::emitMarkDestroyed(SourceInfo L) {
38622	if (!isActive()) return true;
38623	CurrentSource = L;
38624	return MarkDestroyed(S, CodePtr());
38625	}
38626	#endif
38627	#ifdef GET_OPCODE_NAMES
38628	OP_Memcpy,
38629	#endif
38630	#ifdef GET_INTERPFN_LIST
38631	&Interp_Memcpy,
38632	#endif
38633	#ifdef GET_INTERPFN_DISPATCHERS
38634	PRESERVE_NONE
38635	static bool Interp_Memcpy(InterpState &S) {
38636	if (!Memcpy(S, S.PC)) return false;
38637	#if USE_TAILCALLS
38638	MUSTTAIL return InterpNext(S);
38639	#else
38640	return true;
38641	#endif
38642	}
38643	#endif
38644	#ifdef GET_DISASM
38645	case OP_Memcpy:
38646	Text.Op = PrintName("Memcpy");
38647	break;
38648	#endif
38649	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38650	bool emitMemcpy(SourceInfo);
38651	#endif
38652	#ifdef GET_LINK_IMPL
38653	bool ByteCodeEmitter::emitMemcpy(SourceInfo L) {
38654	return emitOp<>(OP_Memcpy, L);
38655	}
38656	#endif
38657	#ifdef GET_EVAL_IMPL
38658	bool EvalEmitter::emitMemcpy(SourceInfo L) {
38659	if (!isActive()) return true;
38660	CurrentSource = L;
38661	return Memcpy(S, CodePtr());
38662	}
38663	#endif
38664	#ifdef GET_OPCODE_NAMES
38665	OP_MulSint8,
38666	OP_MulUint8,
38667	OP_MulSint16,
38668	OP_MulUint16,
38669	OP_MulSint32,
38670	OP_MulUint32,
38671	OP_MulSint64,
38672	OP_MulUint64,
38673	OP_MulIntAP,
38674	OP_MulIntAPS,
38675	OP_MulBool,
38676	OP_MulFixedPoint,
38677	#endif
38678	#ifdef GET_INTERPFN_LIST
38679	&Interp_MulSint8,
38680	&Interp_MulUint8,
38681	&Interp_MulSint16,
38682	&Interp_MulUint16,
38683	&Interp_MulSint32,
38684	&Interp_MulUint32,
38685	&Interp_MulSint64,
38686	&Interp_MulUint64,
38687	&Interp_MulIntAP,
38688	&Interp_MulIntAPS,
38689	&Interp_MulBool,
38690	&Interp_MulFixedPoint,
38691	#endif
38692	#ifdef GET_INTERPFN_DISPATCHERS
38693	PRESERVE_NONE
38694	static bool Interp_MulSint8(InterpState &S) {
38695	if (!Mul<PT_Sint8>(S, S.PC)) return false;
38696	#if USE_TAILCALLS
38697	MUSTTAIL return InterpNext(S);
38698	#else
38699	return true;
38700	#endif
38701	}
38702	PRESERVE_NONE
38703	static bool Interp_MulUint8(InterpState &S) {
38704	if (!Mul<PT_Uint8>(S, S.PC)) return false;
38705	#if USE_TAILCALLS
38706	MUSTTAIL return InterpNext(S);
38707	#else
38708	return true;
38709	#endif
38710	}
38711	PRESERVE_NONE
38712	static bool Interp_MulSint16(InterpState &S) {
38713	if (!Mul<PT_Sint16>(S, S.PC)) return false;
38714	#if USE_TAILCALLS
38715	MUSTTAIL return InterpNext(S);
38716	#else
38717	return true;
38718	#endif
38719	}
38720	PRESERVE_NONE
38721	static bool Interp_MulUint16(InterpState &S) {
38722	if (!Mul<PT_Uint16>(S, S.PC)) return false;
38723	#if USE_TAILCALLS
38724	MUSTTAIL return InterpNext(S);
38725	#else
38726	return true;
38727	#endif
38728	}
38729	PRESERVE_NONE
38730	static bool Interp_MulSint32(InterpState &S) {
38731	if (!Mul<PT_Sint32>(S, S.PC)) return false;
38732	#if USE_TAILCALLS
38733	MUSTTAIL return InterpNext(S);
38734	#else
38735	return true;
38736	#endif
38737	}
38738	PRESERVE_NONE
38739	static bool Interp_MulUint32(InterpState &S) {
38740	if (!Mul<PT_Uint32>(S, S.PC)) return false;
38741	#if USE_TAILCALLS
38742	MUSTTAIL return InterpNext(S);
38743	#else
38744	return true;
38745	#endif
38746	}
38747	PRESERVE_NONE
38748	static bool Interp_MulSint64(InterpState &S) {
38749	if (!Mul<PT_Sint64>(S, S.PC)) return false;
38750	#if USE_TAILCALLS
38751	MUSTTAIL return InterpNext(S);
38752	#else
38753	return true;
38754	#endif
38755	}
38756	PRESERVE_NONE
38757	static bool Interp_MulUint64(InterpState &S) {
38758	if (!Mul<PT_Uint64>(S, S.PC)) return false;
38759	#if USE_TAILCALLS
38760	MUSTTAIL return InterpNext(S);
38761	#else
38762	return true;
38763	#endif
38764	}
38765	PRESERVE_NONE
38766	static bool Interp_MulIntAP(InterpState &S) {
38767	if (!Mul<PT_IntAP>(S, S.PC)) return false;
38768	#if USE_TAILCALLS
38769	MUSTTAIL return InterpNext(S);
38770	#else
38771	return true;
38772	#endif
38773	}
38774	PRESERVE_NONE
38775	static bool Interp_MulIntAPS(InterpState &S) {
38776	if (!Mul<PT_IntAPS>(S, S.PC)) return false;
38777	#if USE_TAILCALLS
38778	MUSTTAIL return InterpNext(S);
38779	#else
38780	return true;
38781	#endif
38782	}
38783	PRESERVE_NONE
38784	static bool Interp_MulBool(InterpState &S) {
38785	if (!Mul<PT_Bool>(S, S.PC)) return false;
38786	#if USE_TAILCALLS
38787	MUSTTAIL return InterpNext(S);
38788	#else
38789	return true;
38790	#endif
38791	}
38792	PRESERVE_NONE
38793	static bool Interp_MulFixedPoint(InterpState &S) {
38794	if (!Mul<PT_FixedPoint>(S, S.PC)) return false;
38795	#if USE_TAILCALLS
38796	MUSTTAIL return InterpNext(S);
38797	#else
38798	return true;
38799	#endif
38800	}
38801	#endif
38802	#ifdef GET_DISASM
38803	case OP_MulSint8:
38804	Text.Op = PrintName("MulSint8");
38805	break;
38806	case OP_MulUint8:
38807	Text.Op = PrintName("MulUint8");
38808	break;
38809	case OP_MulSint16:
38810	Text.Op = PrintName("MulSint16");
38811	break;
38812	case OP_MulUint16:
38813	Text.Op = PrintName("MulUint16");
38814	break;
38815	case OP_MulSint32:
38816	Text.Op = PrintName("MulSint32");
38817	break;
38818	case OP_MulUint32:
38819	Text.Op = PrintName("MulUint32");
38820	break;
38821	case OP_MulSint64:
38822	Text.Op = PrintName("MulSint64");
38823	break;
38824	case OP_MulUint64:
38825	Text.Op = PrintName("MulUint64");
38826	break;
38827	case OP_MulIntAP:
38828	Text.Op = PrintName("MulIntAP");
38829	break;
38830	case OP_MulIntAPS:
38831	Text.Op = PrintName("MulIntAPS");
38832	break;
38833	case OP_MulBool:
38834	Text.Op = PrintName("MulBool");
38835	break;
38836	case OP_MulFixedPoint:
38837	Text.Op = PrintName("MulFixedPoint");
38838	break;
38839	#endif
38840	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38841	bool emitMulSint8(SourceInfo);
38842	bool emitMulUint8(SourceInfo);
38843	bool emitMulSint16(SourceInfo);
38844	bool emitMulUint16(SourceInfo);
38845	bool emitMulSint32(SourceInfo);
38846	bool emitMulUint32(SourceInfo);
38847	bool emitMulSint64(SourceInfo);
38848	bool emitMulUint64(SourceInfo);
38849	bool emitMulIntAP(SourceInfo);
38850	bool emitMulIntAPS(SourceInfo);
38851	bool emitMulBool(SourceInfo);
38852	bool emitMulFixedPoint(SourceInfo);
38853	#endif
38854	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
38855	[[nodiscard]] bool emitMul(PrimType, SourceInfo I);
38856	#endif
38857	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
38858	bool
38859	#if defined(GET_EVAL_IMPL)
38860	EvalEmitter
38861	#else
38862	ByteCodeEmitter
38863	#endif
38864	::emitMul(PrimType T0, SourceInfo I) {
38865	switch (T0) {
38866	case PT_Sint8:
38867	return emitMulSint8(I);
38868	case PT_Uint8:
38869	return emitMulUint8(I);
38870	case PT_Sint16:
38871	return emitMulSint16(I);
38872	case PT_Uint16:
38873	return emitMulUint16(I);
38874	case PT_Sint32:
38875	return emitMulSint32(I);
38876	case PT_Uint32:
38877	return emitMulUint32(I);
38878	case PT_Sint64:
38879	return emitMulSint64(I);
38880	case PT_Uint64:
38881	return emitMulUint64(I);
38882	case PT_IntAP:
38883	return emitMulIntAP(I);
38884	case PT_IntAPS:
38885	return emitMulIntAPS(I);
38886	case PT_Bool:
38887	return emitMulBool(I);
38888	case PT_FixedPoint:
38889	return emitMulFixedPoint(I);
38890	default: llvm_unreachable("invalid type: emitMul");
38891	}
38892	llvm_unreachable("invalid enum value");
38893	}
38894	#endif
38895	#ifdef GET_LINK_IMPL
38896	bool ByteCodeEmitter::emitMulSint8(SourceInfo L) {
38897	return emitOp<>(OP_MulSint8, L);
38898	}
38899	bool ByteCodeEmitter::emitMulUint8(SourceInfo L) {
38900	return emitOp<>(OP_MulUint8, L);
38901	}
38902	bool ByteCodeEmitter::emitMulSint16(SourceInfo L) {
38903	return emitOp<>(OP_MulSint16, L);
38904	}
38905	bool ByteCodeEmitter::emitMulUint16(SourceInfo L) {
38906	return emitOp<>(OP_MulUint16, L);
38907	}
38908	bool ByteCodeEmitter::emitMulSint32(SourceInfo L) {
38909	return emitOp<>(OP_MulSint32, L);
38910	}
38911	bool ByteCodeEmitter::emitMulUint32(SourceInfo L) {
38912	return emitOp<>(OP_MulUint32, L);
38913	}
38914	bool ByteCodeEmitter::emitMulSint64(SourceInfo L) {
38915	return emitOp<>(OP_MulSint64, L);
38916	}
38917	bool ByteCodeEmitter::emitMulUint64(SourceInfo L) {
38918	return emitOp<>(OP_MulUint64, L);
38919	}
38920	bool ByteCodeEmitter::emitMulIntAP(SourceInfo L) {
38921	return emitOp<>(OP_MulIntAP, L);
38922	}
38923	bool ByteCodeEmitter::emitMulIntAPS(SourceInfo L) {
38924	return emitOp<>(OP_MulIntAPS, L);
38925	}
38926	bool ByteCodeEmitter::emitMulBool(SourceInfo L) {
38927	return emitOp<>(OP_MulBool, L);
38928	}
38929	bool ByteCodeEmitter::emitMulFixedPoint(SourceInfo L) {
38930	return emitOp<>(OP_MulFixedPoint, L);
38931	}
38932	#endif
38933	#ifdef GET_EVAL_IMPL
38934	bool EvalEmitter::emitMulSint8(SourceInfo L) {
38935	if (!isActive()) return true;
38936	CurrentSource = L;
38937	return Mul<PT_Sint8>(S, CodePtr());
38938	}
38939	bool EvalEmitter::emitMulUint8(SourceInfo L) {
38940	if (!isActive()) return true;
38941	CurrentSource = L;
38942	return Mul<PT_Uint8>(S, CodePtr());
38943	}
38944	bool EvalEmitter::emitMulSint16(SourceInfo L) {
38945	if (!isActive()) return true;
38946	CurrentSource = L;
38947	return Mul<PT_Sint16>(S, CodePtr());
38948	}
38949	bool EvalEmitter::emitMulUint16(SourceInfo L) {
38950	if (!isActive()) return true;
38951	CurrentSource = L;
38952	return Mul<PT_Uint16>(S, CodePtr());
38953	}
38954	bool EvalEmitter::emitMulSint32(SourceInfo L) {
38955	if (!isActive()) return true;
38956	CurrentSource = L;
38957	return Mul<PT_Sint32>(S, CodePtr());
38958	}
38959	bool EvalEmitter::emitMulUint32(SourceInfo L) {
38960	if (!isActive()) return true;
38961	CurrentSource = L;
38962	return Mul<PT_Uint32>(S, CodePtr());
38963	}
38964	bool EvalEmitter::emitMulSint64(SourceInfo L) {
38965	if (!isActive()) return true;
38966	CurrentSource = L;
38967	return Mul<PT_Sint64>(S, CodePtr());
38968	}
38969	bool EvalEmitter::emitMulUint64(SourceInfo L) {
38970	if (!isActive()) return true;
38971	CurrentSource = L;
38972	return Mul<PT_Uint64>(S, CodePtr());
38973	}
38974	bool EvalEmitter::emitMulIntAP(SourceInfo L) {
38975	if (!isActive()) return true;
38976	CurrentSource = L;
38977	return Mul<PT_IntAP>(S, CodePtr());
38978	}
38979	bool EvalEmitter::emitMulIntAPS(SourceInfo L) {
38980	if (!isActive()) return true;
38981	CurrentSource = L;
38982	return Mul<PT_IntAPS>(S, CodePtr());
38983	}
38984	bool EvalEmitter::emitMulBool(SourceInfo L) {
38985	if (!isActive()) return true;
38986	CurrentSource = L;
38987	return Mul<PT_Bool>(S, CodePtr());
38988	}
38989	bool EvalEmitter::emitMulFixedPoint(SourceInfo L) {
38990	if (!isActive()) return true;
38991	CurrentSource = L;
38992	return Mul<PT_FixedPoint>(S, CodePtr());
38993	}
38994	#endif
38995	#ifdef GET_OPCODE_NAMES
38996	OP_MulcSint8,
38997	OP_MulcUint8,
38998	OP_MulcSint16,
38999	OP_MulcUint16,
39000	OP_MulcSint32,
39001	OP_MulcUint32,
39002	OP_MulcSint64,
39003	OP_MulcUint64,
39004	OP_MulcIntAP,
39005	OP_MulcIntAPS,
39006	OP_MulcFloat,
39007	#endif
39008	#ifdef GET_INTERPFN_LIST
39009	&Interp_MulcSint8,
39010	&Interp_MulcUint8,
39011	&Interp_MulcSint16,
39012	&Interp_MulcUint16,
39013	&Interp_MulcSint32,
39014	&Interp_MulcUint32,
39015	&Interp_MulcSint64,
39016	&Interp_MulcUint64,
39017	&Interp_MulcIntAP,
39018	&Interp_MulcIntAPS,
39019	&Interp_MulcFloat,
39020	#endif
39021	#ifdef GET_INTERPFN_DISPATCHERS
39022	PRESERVE_NONE
39023	static bool Interp_MulcSint8(InterpState &S) {
39024	if (!Mulc<PT_Sint8>(S)) return false;
39025	#if USE_TAILCALLS
39026	MUSTTAIL return InterpNext(S);
39027	#else
39028	return true;
39029	#endif
39030	}
39031	PRESERVE_NONE
39032	static bool Interp_MulcUint8(InterpState &S) {
39033	if (!Mulc<PT_Uint8>(S)) return false;
39034	#if USE_TAILCALLS
39035	MUSTTAIL return InterpNext(S);
39036	#else
39037	return true;
39038	#endif
39039	}
39040	PRESERVE_NONE
39041	static bool Interp_MulcSint16(InterpState &S) {
39042	if (!Mulc<PT_Sint16>(S)) return false;
39043	#if USE_TAILCALLS
39044	MUSTTAIL return InterpNext(S);
39045	#else
39046	return true;
39047	#endif
39048	}
39049	PRESERVE_NONE
39050	static bool Interp_MulcUint16(InterpState &S) {
39051	if (!Mulc<PT_Uint16>(S)) return false;
39052	#if USE_TAILCALLS
39053	MUSTTAIL return InterpNext(S);
39054	#else
39055	return true;
39056	#endif
39057	}
39058	PRESERVE_NONE
39059	static bool Interp_MulcSint32(InterpState &S) {
39060	if (!Mulc<PT_Sint32>(S)) return false;
39061	#if USE_TAILCALLS
39062	MUSTTAIL return InterpNext(S);
39063	#else
39064	return true;
39065	#endif
39066	}
39067	PRESERVE_NONE
39068	static bool Interp_MulcUint32(InterpState &S) {
39069	if (!Mulc<PT_Uint32>(S)) return false;
39070	#if USE_TAILCALLS
39071	MUSTTAIL return InterpNext(S);
39072	#else
39073	return true;
39074	#endif
39075	}
39076	PRESERVE_NONE
39077	static bool Interp_MulcSint64(InterpState &S) {
39078	if (!Mulc<PT_Sint64>(S)) return false;
39079	#if USE_TAILCALLS
39080	MUSTTAIL return InterpNext(S);
39081	#else
39082	return true;
39083	#endif
39084	}
39085	PRESERVE_NONE
39086	static bool Interp_MulcUint64(InterpState &S) {
39087	if (!Mulc<PT_Uint64>(S)) return false;
39088	#if USE_TAILCALLS
39089	MUSTTAIL return InterpNext(S);
39090	#else
39091	return true;
39092	#endif
39093	}
39094	PRESERVE_NONE
39095	static bool Interp_MulcIntAP(InterpState &S) {
39096	if (!Mulc<PT_IntAP>(S)) return false;
39097	#if USE_TAILCALLS
39098	MUSTTAIL return InterpNext(S);
39099	#else
39100	return true;
39101	#endif
39102	}
39103	PRESERVE_NONE
39104	static bool Interp_MulcIntAPS(InterpState &S) {
39105	if (!Mulc<PT_IntAPS>(S)) return false;
39106	#if USE_TAILCALLS
39107	MUSTTAIL return InterpNext(S);
39108	#else
39109	return true;
39110	#endif
39111	}
39112	PRESERVE_NONE
39113	static bool Interp_MulcFloat(InterpState &S) {
39114	if (!Mulc<PT_Float>(S)) return false;
39115	#if USE_TAILCALLS
39116	MUSTTAIL return InterpNext(S);
39117	#else
39118	return true;
39119	#endif
39120	}
39121	#endif
39122	#ifdef GET_DISASM
39123	case OP_MulcSint8:
39124	Text.Op = PrintName("MulcSint8");
39125	break;
39126	case OP_MulcUint8:
39127	Text.Op = PrintName("MulcUint8");
39128	break;
39129	case OP_MulcSint16:
39130	Text.Op = PrintName("MulcSint16");
39131	break;
39132	case OP_MulcUint16:
39133	Text.Op = PrintName("MulcUint16");
39134	break;
39135	case OP_MulcSint32:
39136	Text.Op = PrintName("MulcSint32");
39137	break;
39138	case OP_MulcUint32:
39139	Text.Op = PrintName("MulcUint32");
39140	break;
39141	case OP_MulcSint64:
39142	Text.Op = PrintName("MulcSint64");
39143	break;
39144	case OP_MulcUint64:
39145	Text.Op = PrintName("MulcUint64");
39146	break;
39147	case OP_MulcIntAP:
39148	Text.Op = PrintName("MulcIntAP");
39149	break;
39150	case OP_MulcIntAPS:
39151	Text.Op = PrintName("MulcIntAPS");
39152	break;
39153	case OP_MulcFloat:
39154	Text.Op = PrintName("MulcFloat");
39155	break;
39156	#endif
39157	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39158	bool emitMulcSint8(SourceInfo);
39159	bool emitMulcUint8(SourceInfo);
39160	bool emitMulcSint16(SourceInfo);
39161	bool emitMulcUint16(SourceInfo);
39162	bool emitMulcSint32(SourceInfo);
39163	bool emitMulcUint32(SourceInfo);
39164	bool emitMulcSint64(SourceInfo);
39165	bool emitMulcUint64(SourceInfo);
39166	bool emitMulcIntAP(SourceInfo);
39167	bool emitMulcIntAPS(SourceInfo);
39168	bool emitMulcFloat(SourceInfo);
39169	#endif
39170	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39171	[[nodiscard]] bool emitMulc(PrimType, SourceInfo I);
39172	#endif
39173	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
39174	bool
39175	#if defined(GET_EVAL_IMPL)
39176	EvalEmitter
39177	#else
39178	ByteCodeEmitter
39179	#endif
39180	::emitMulc(PrimType T0, SourceInfo I) {
39181	switch (T0) {
39182	case PT_Sint8:
39183	return emitMulcSint8(I);
39184	case PT_Uint8:
39185	return emitMulcUint8(I);
39186	case PT_Sint16:
39187	return emitMulcSint16(I);
39188	case PT_Uint16:
39189	return emitMulcUint16(I);
39190	case PT_Sint32:
39191	return emitMulcSint32(I);
39192	case PT_Uint32:
39193	return emitMulcUint32(I);
39194	case PT_Sint64:
39195	return emitMulcSint64(I);
39196	case PT_Uint64:
39197	return emitMulcUint64(I);
39198	case PT_IntAP:
39199	return emitMulcIntAP(I);
39200	case PT_IntAPS:
39201	return emitMulcIntAPS(I);
39202	case PT_Float:
39203	return emitMulcFloat(I);
39204	default: llvm_unreachable("invalid type: emitMulc");
39205	}
39206	llvm_unreachable("invalid enum value");
39207	}
39208	#endif
39209	#ifdef GET_LINK_IMPL
39210	bool ByteCodeEmitter::emitMulcSint8(SourceInfo L) {
39211	return emitOp<>(OP_MulcSint8, L);
39212	}
39213	bool ByteCodeEmitter::emitMulcUint8(SourceInfo L) {
39214	return emitOp<>(OP_MulcUint8, L);
39215	}
39216	bool ByteCodeEmitter::emitMulcSint16(SourceInfo L) {
39217	return emitOp<>(OP_MulcSint16, L);
39218	}
39219	bool ByteCodeEmitter::emitMulcUint16(SourceInfo L) {
39220	return emitOp<>(OP_MulcUint16, L);
39221	}
39222	bool ByteCodeEmitter::emitMulcSint32(SourceInfo L) {
39223	return emitOp<>(OP_MulcSint32, L);
39224	}
39225	bool ByteCodeEmitter::emitMulcUint32(SourceInfo L) {
39226	return emitOp<>(OP_MulcUint32, L);
39227	}
39228	bool ByteCodeEmitter::emitMulcSint64(SourceInfo L) {
39229	return emitOp<>(OP_MulcSint64, L);
39230	}
39231	bool ByteCodeEmitter::emitMulcUint64(SourceInfo L) {
39232	return emitOp<>(OP_MulcUint64, L);
39233	}
39234	bool ByteCodeEmitter::emitMulcIntAP(SourceInfo L) {
39235	return emitOp<>(OP_MulcIntAP, L);
39236	}
39237	bool ByteCodeEmitter::emitMulcIntAPS(SourceInfo L) {
39238	return emitOp<>(OP_MulcIntAPS, L);
39239	}
39240	bool ByteCodeEmitter::emitMulcFloat(SourceInfo L) {
39241	return emitOp<>(OP_MulcFloat, L);
39242	}
39243	#endif
39244	#ifdef GET_EVAL_IMPL
39245	bool EvalEmitter::emitMulcSint8(SourceInfo L) {
39246	if (!isActive()) return true;
39247	CurrentSource = L;
39248	return Mulc<PT_Sint8>(S);
39249	}
39250	bool EvalEmitter::emitMulcUint8(SourceInfo L) {
39251	if (!isActive()) return true;
39252	CurrentSource = L;
39253	return Mulc<PT_Uint8>(S);
39254	}
39255	bool EvalEmitter::emitMulcSint16(SourceInfo L) {
39256	if (!isActive()) return true;
39257	CurrentSource = L;
39258	return Mulc<PT_Sint16>(S);
39259	}
39260	bool EvalEmitter::emitMulcUint16(SourceInfo L) {
39261	if (!isActive()) return true;
39262	CurrentSource = L;
39263	return Mulc<PT_Uint16>(S);
39264	}
39265	bool EvalEmitter::emitMulcSint32(SourceInfo L) {
39266	if (!isActive()) return true;
39267	CurrentSource = L;
39268	return Mulc<PT_Sint32>(S);
39269	}
39270	bool EvalEmitter::emitMulcUint32(SourceInfo L) {
39271	if (!isActive()) return true;
39272	CurrentSource = L;
39273	return Mulc<PT_Uint32>(S);
39274	}
39275	bool EvalEmitter::emitMulcSint64(SourceInfo L) {
39276	if (!isActive()) return true;
39277	CurrentSource = L;
39278	return Mulc<PT_Sint64>(S);
39279	}
39280	bool EvalEmitter::emitMulcUint64(SourceInfo L) {
39281	if (!isActive()) return true;
39282	CurrentSource = L;
39283	return Mulc<PT_Uint64>(S);
39284	}
39285	bool EvalEmitter::emitMulcIntAP(SourceInfo L) {
39286	if (!isActive()) return true;
39287	CurrentSource = L;
39288	return Mulc<PT_IntAP>(S);
39289	}
39290	bool EvalEmitter::emitMulcIntAPS(SourceInfo L) {
39291	if (!isActive()) return true;
39292	CurrentSource = L;
39293	return Mulc<PT_IntAPS>(S);
39294	}
39295	bool EvalEmitter::emitMulcFloat(SourceInfo L) {
39296	if (!isActive()) return true;
39297	CurrentSource = L;
39298	return Mulc<PT_Float>(S);
39299	}
39300	#endif
39301	#ifdef GET_OPCODE_NAMES
39302	OP_Mulf,
39303	#endif
39304	#ifdef GET_INTERPFN_LIST
39305	&Interp_Mulf,
39306	#endif
39307	#ifdef GET_INTERPFN_DISPATCHERS
39308	PRESERVE_NONE
39309	static bool Interp_Mulf(InterpState &S) {
39310	{
39311	CodePtr OpPC = S.PC;
39312	const auto V0 = ReadArg<uint32_t>(S, S.PC);
39313	if (!Mulf(S, OpPC, V0)) return false;
39314	}
39315	#if USE_TAILCALLS
39316	MUSTTAIL return InterpNext(S);
39317	#else
39318	return true;
39319	#endif
39320	}
39321	#endif
39322	#ifdef GET_DISASM
39323	case OP_Mulf:
39324	Text.Op = PrintName("Mulf");
39325	Text.Args.push_back(printArg<uint32_t>(P, PC));
39326	break;
39327	#endif
39328	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39329	bool emitMulf( uint32_t , SourceInfo);
39330	#endif
39331	#ifdef GET_LINK_IMPL
39332	bool ByteCodeEmitter::emitMulf( uint32_t A0, SourceInfo L) {
39333	return emitOp<uint32_t>(OP_Mulf, A0, L);
39334	}
39335	#endif
39336	#ifdef GET_EVAL_IMPL
39337	bool EvalEmitter::emitMulf( uint32_t A0, SourceInfo L) {
39338	if (!isActive()) return true;
39339	CurrentSource = L;
39340	return Mulf(S, CodePtr(), A0);
39341	}
39342	#endif
39343	#ifdef GET_OPCODE_NAMES
39344	OP_NESint8,
39345	OP_NEUint8,
39346	OP_NESint16,
39347	OP_NEUint16,
39348	OP_NESint32,
39349	OP_NEUint32,
39350	OP_NESint64,
39351	OP_NEUint64,
39352	OP_NEIntAP,
39353	OP_NEIntAPS,
39354	OP_NEBool,
39355	OP_NEFixedPoint,
39356	OP_NEPtr,
39357	OP_NEMemberPtr,
39358	OP_NEFloat,
39359	#endif
39360	#ifdef GET_INTERPFN_LIST
39361	&Interp_NESint8,
39362	&Interp_NEUint8,
39363	&Interp_NESint16,
39364	&Interp_NEUint16,
39365	&Interp_NESint32,
39366	&Interp_NEUint32,
39367	&Interp_NESint64,
39368	&Interp_NEUint64,
39369	&Interp_NEIntAP,
39370	&Interp_NEIntAPS,
39371	&Interp_NEBool,
39372	&Interp_NEFixedPoint,
39373	&Interp_NEPtr,
39374	&Interp_NEMemberPtr,
39375	&Interp_NEFloat,
39376	#endif
39377	#ifdef GET_INTERPFN_DISPATCHERS
39378	PRESERVE_NONE
39379	static bool Interp_NESint8(InterpState &S) {
39380	if (!NE<PT_Sint8>(S, S.PC)) return false;
39381	#if USE_TAILCALLS
39382	MUSTTAIL return InterpNext(S);
39383	#else
39384	return true;
39385	#endif
39386	}
39387	PRESERVE_NONE
39388	static bool Interp_NEUint8(InterpState &S) {
39389	if (!NE<PT_Uint8>(S, S.PC)) return false;
39390	#if USE_TAILCALLS
39391	MUSTTAIL return InterpNext(S);
39392	#else
39393	return true;
39394	#endif
39395	}
39396	PRESERVE_NONE
39397	static bool Interp_NESint16(InterpState &S) {
39398	if (!NE<PT_Sint16>(S, S.PC)) return false;
39399	#if USE_TAILCALLS
39400	MUSTTAIL return InterpNext(S);
39401	#else
39402	return true;
39403	#endif
39404	}
39405	PRESERVE_NONE
39406	static bool Interp_NEUint16(InterpState &S) {
39407	if (!NE<PT_Uint16>(S, S.PC)) return false;
39408	#if USE_TAILCALLS
39409	MUSTTAIL return InterpNext(S);
39410	#else
39411	return true;
39412	#endif
39413	}
39414	PRESERVE_NONE
39415	static bool Interp_NESint32(InterpState &S) {
39416	if (!NE<PT_Sint32>(S, S.PC)) return false;
39417	#if USE_TAILCALLS
39418	MUSTTAIL return InterpNext(S);
39419	#else
39420	return true;
39421	#endif
39422	}
39423	PRESERVE_NONE
39424	static bool Interp_NEUint32(InterpState &S) {
39425	if (!NE<PT_Uint32>(S, S.PC)) return false;
39426	#if USE_TAILCALLS
39427	MUSTTAIL return InterpNext(S);
39428	#else
39429	return true;
39430	#endif
39431	}
39432	PRESERVE_NONE
39433	static bool Interp_NESint64(InterpState &S) {
39434	if (!NE<PT_Sint64>(S, S.PC)) return false;
39435	#if USE_TAILCALLS
39436	MUSTTAIL return InterpNext(S);
39437	#else
39438	return true;
39439	#endif
39440	}
39441	PRESERVE_NONE
39442	static bool Interp_NEUint64(InterpState &S) {
39443	if (!NE<PT_Uint64>(S, S.PC)) return false;
39444	#if USE_TAILCALLS
39445	MUSTTAIL return InterpNext(S);
39446	#else
39447	return true;
39448	#endif
39449	}
39450	PRESERVE_NONE
39451	static bool Interp_NEIntAP(InterpState &S) {
39452	if (!NE<PT_IntAP>(S, S.PC)) return false;
39453	#if USE_TAILCALLS
39454	MUSTTAIL return InterpNext(S);
39455	#else
39456	return true;
39457	#endif
39458	}
39459	PRESERVE_NONE
39460	static bool Interp_NEIntAPS(InterpState &S) {
39461	if (!NE<PT_IntAPS>(S, S.PC)) return false;
39462	#if USE_TAILCALLS
39463	MUSTTAIL return InterpNext(S);
39464	#else
39465	return true;
39466	#endif
39467	}
39468	PRESERVE_NONE
39469	static bool Interp_NEBool(InterpState &S) {
39470	if (!NE<PT_Bool>(S, S.PC)) return false;
39471	#if USE_TAILCALLS
39472	MUSTTAIL return InterpNext(S);
39473	#else
39474	return true;
39475	#endif
39476	}
39477	PRESERVE_NONE
39478	static bool Interp_NEFixedPoint(InterpState &S) {
39479	if (!NE<PT_FixedPoint>(S, S.PC)) return false;
39480	#if USE_TAILCALLS
39481	MUSTTAIL return InterpNext(S);
39482	#else
39483	return true;
39484	#endif
39485	}
39486	PRESERVE_NONE
39487	static bool Interp_NEPtr(InterpState &S) {
39488	if (!NE<PT_Ptr>(S, S.PC)) return false;
39489	#if USE_TAILCALLS
39490	MUSTTAIL return InterpNext(S);
39491	#else
39492	return true;
39493	#endif
39494	}
39495	PRESERVE_NONE
39496	static bool Interp_NEMemberPtr(InterpState &S) {
39497	if (!NE<PT_MemberPtr>(S, S.PC)) return false;
39498	#if USE_TAILCALLS
39499	MUSTTAIL return InterpNext(S);
39500	#else
39501	return true;
39502	#endif
39503	}
39504	PRESERVE_NONE
39505	static bool Interp_NEFloat(InterpState &S) {
39506	if (!NE<PT_Float>(S, S.PC)) return false;
39507	#if USE_TAILCALLS
39508	MUSTTAIL return InterpNext(S);
39509	#else
39510	return true;
39511	#endif
39512	}
39513	#endif
39514	#ifdef GET_DISASM
39515	case OP_NESint8:
39516	Text.Op = PrintName("NESint8");
39517	break;
39518	case OP_NEUint8:
39519	Text.Op = PrintName("NEUint8");
39520	break;
39521	case OP_NESint16:
39522	Text.Op = PrintName("NESint16");
39523	break;
39524	case OP_NEUint16:
39525	Text.Op = PrintName("NEUint16");
39526	break;
39527	case OP_NESint32:
39528	Text.Op = PrintName("NESint32");
39529	break;
39530	case OP_NEUint32:
39531	Text.Op = PrintName("NEUint32");
39532	break;
39533	case OP_NESint64:
39534	Text.Op = PrintName("NESint64");
39535	break;
39536	case OP_NEUint64:
39537	Text.Op = PrintName("NEUint64");
39538	break;
39539	case OP_NEIntAP:
39540	Text.Op = PrintName("NEIntAP");
39541	break;
39542	case OP_NEIntAPS:
39543	Text.Op = PrintName("NEIntAPS");
39544	break;
39545	case OP_NEBool:
39546	Text.Op = PrintName("NEBool");
39547	break;
39548	case OP_NEFixedPoint:
39549	Text.Op = PrintName("NEFixedPoint");
39550	break;
39551	case OP_NEPtr:
39552	Text.Op = PrintName("NEPtr");
39553	break;
39554	case OP_NEMemberPtr:
39555	Text.Op = PrintName("NEMemberPtr");
39556	break;
39557	case OP_NEFloat:
39558	Text.Op = PrintName("NEFloat");
39559	break;
39560	#endif
39561	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39562	bool emitNESint8(SourceInfo);
39563	bool emitNEUint8(SourceInfo);
39564	bool emitNESint16(SourceInfo);
39565	bool emitNEUint16(SourceInfo);
39566	bool emitNESint32(SourceInfo);
39567	bool emitNEUint32(SourceInfo);
39568	bool emitNESint64(SourceInfo);
39569	bool emitNEUint64(SourceInfo);
39570	bool emitNEIntAP(SourceInfo);
39571	bool emitNEIntAPS(SourceInfo);
39572	bool emitNEBool(SourceInfo);
39573	bool emitNEFixedPoint(SourceInfo);
39574	bool emitNEPtr(SourceInfo);
39575	bool emitNEMemberPtr(SourceInfo);
39576	bool emitNEFloat(SourceInfo);
39577	#endif
39578	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39579	[[nodiscard]] bool emitNE(PrimType, SourceInfo I);
39580	#endif
39581	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
39582	bool
39583	#if defined(GET_EVAL_IMPL)
39584	EvalEmitter
39585	#else
39586	ByteCodeEmitter
39587	#endif
39588	::emitNE(PrimType T0, SourceInfo I) {
39589	switch (T0) {
39590	case PT_Sint8:
39591	return emitNESint8(I);
39592	case PT_Uint8:
39593	return emitNEUint8(I);
39594	case PT_Sint16:
39595	return emitNESint16(I);
39596	case PT_Uint16:
39597	return emitNEUint16(I);
39598	case PT_Sint32:
39599	return emitNESint32(I);
39600	case PT_Uint32:
39601	return emitNEUint32(I);
39602	case PT_Sint64:
39603	return emitNESint64(I);
39604	case PT_Uint64:
39605	return emitNEUint64(I);
39606	case PT_IntAP:
39607	return emitNEIntAP(I);
39608	case PT_IntAPS:
39609	return emitNEIntAPS(I);
39610	case PT_Bool:
39611	return emitNEBool(I);
39612	case PT_FixedPoint:
39613	return emitNEFixedPoint(I);
39614	case PT_Ptr:
39615	return emitNEPtr(I);
39616	case PT_MemberPtr:
39617	return emitNEMemberPtr(I);
39618	case PT_Float:
39619	return emitNEFloat(I);
39620	}
39621	llvm_unreachable("invalid enum value");
39622	}
39623	#endif
39624	#ifdef GET_LINK_IMPL
39625	bool ByteCodeEmitter::emitNESint8(SourceInfo L) {
39626	return emitOp<>(OP_NESint8, L);
39627	}
39628	bool ByteCodeEmitter::emitNEUint8(SourceInfo L) {
39629	return emitOp<>(OP_NEUint8, L);
39630	}
39631	bool ByteCodeEmitter::emitNESint16(SourceInfo L) {
39632	return emitOp<>(OP_NESint16, L);
39633	}
39634	bool ByteCodeEmitter::emitNEUint16(SourceInfo L) {
39635	return emitOp<>(OP_NEUint16, L);
39636	}
39637	bool ByteCodeEmitter::emitNESint32(SourceInfo L) {
39638	return emitOp<>(OP_NESint32, L);
39639	}
39640	bool ByteCodeEmitter::emitNEUint32(SourceInfo L) {
39641	return emitOp<>(OP_NEUint32, L);
39642	}
39643	bool ByteCodeEmitter::emitNESint64(SourceInfo L) {
39644	return emitOp<>(OP_NESint64, L);
39645	}
39646	bool ByteCodeEmitter::emitNEUint64(SourceInfo L) {
39647	return emitOp<>(OP_NEUint64, L);
39648	}
39649	bool ByteCodeEmitter::emitNEIntAP(SourceInfo L) {
39650	return emitOp<>(OP_NEIntAP, L);
39651	}
39652	bool ByteCodeEmitter::emitNEIntAPS(SourceInfo L) {
39653	return emitOp<>(OP_NEIntAPS, L);
39654	}
39655	bool ByteCodeEmitter::emitNEBool(SourceInfo L) {
39656	return emitOp<>(OP_NEBool, L);
39657	}
39658	bool ByteCodeEmitter::emitNEFixedPoint(SourceInfo L) {
39659	return emitOp<>(OP_NEFixedPoint, L);
39660	}
39661	bool ByteCodeEmitter::emitNEPtr(SourceInfo L) {
39662	return emitOp<>(OP_NEPtr, L);
39663	}
39664	bool ByteCodeEmitter::emitNEMemberPtr(SourceInfo L) {
39665	return emitOp<>(OP_NEMemberPtr, L);
39666	}
39667	bool ByteCodeEmitter::emitNEFloat(SourceInfo L) {
39668	return emitOp<>(OP_NEFloat, L);
39669	}
39670	#endif
39671	#ifdef GET_EVAL_IMPL
39672	bool EvalEmitter::emitNESint8(SourceInfo L) {
39673	if (!isActive()) return true;
39674	CurrentSource = L;
39675	return NE<PT_Sint8>(S, CodePtr());
39676	}
39677	bool EvalEmitter::emitNEUint8(SourceInfo L) {
39678	if (!isActive()) return true;
39679	CurrentSource = L;
39680	return NE<PT_Uint8>(S, CodePtr());
39681	}
39682	bool EvalEmitter::emitNESint16(SourceInfo L) {
39683	if (!isActive()) return true;
39684	CurrentSource = L;
39685	return NE<PT_Sint16>(S, CodePtr());
39686	}
39687	bool EvalEmitter::emitNEUint16(SourceInfo L) {
39688	if (!isActive()) return true;
39689	CurrentSource = L;
39690	return NE<PT_Uint16>(S, CodePtr());
39691	}
39692	bool EvalEmitter::emitNESint32(SourceInfo L) {
39693	if (!isActive()) return true;
39694	CurrentSource = L;
39695	return NE<PT_Sint32>(S, CodePtr());
39696	}
39697	bool EvalEmitter::emitNEUint32(SourceInfo L) {
39698	if (!isActive()) return true;
39699	CurrentSource = L;
39700	return NE<PT_Uint32>(S, CodePtr());
39701	}
39702	bool EvalEmitter::emitNESint64(SourceInfo L) {
39703	if (!isActive()) return true;
39704	CurrentSource = L;
39705	return NE<PT_Sint64>(S, CodePtr());
39706	}
39707	bool EvalEmitter::emitNEUint64(SourceInfo L) {
39708	if (!isActive()) return true;
39709	CurrentSource = L;
39710	return NE<PT_Uint64>(S, CodePtr());
39711	}
39712	bool EvalEmitter::emitNEIntAP(SourceInfo L) {
39713	if (!isActive()) return true;
39714	CurrentSource = L;
39715	return NE<PT_IntAP>(S, CodePtr());
39716	}
39717	bool EvalEmitter::emitNEIntAPS(SourceInfo L) {
39718	if (!isActive()) return true;
39719	CurrentSource = L;
39720	return NE<PT_IntAPS>(S, CodePtr());
39721	}
39722	bool EvalEmitter::emitNEBool(SourceInfo L) {
39723	if (!isActive()) return true;
39724	CurrentSource = L;
39725	return NE<PT_Bool>(S, CodePtr());
39726	}
39727	bool EvalEmitter::emitNEFixedPoint(SourceInfo L) {
39728	if (!isActive()) return true;
39729	CurrentSource = L;
39730	return NE<PT_FixedPoint>(S, CodePtr());
39731	}
39732	bool EvalEmitter::emitNEPtr(SourceInfo L) {
39733	if (!isActive()) return true;
39734	CurrentSource = L;
39735	return NE<PT_Ptr>(S, CodePtr());
39736	}
39737	bool EvalEmitter::emitNEMemberPtr(SourceInfo L) {
39738	if (!isActive()) return true;
39739	CurrentSource = L;
39740	return NE<PT_MemberPtr>(S, CodePtr());
39741	}
39742	bool EvalEmitter::emitNEFloat(SourceInfo L) {
39743	if (!isActive()) return true;
39744	CurrentSource = L;
39745	return NE<PT_Float>(S, CodePtr());
39746	}
39747	#endif
39748	#ifdef GET_OPCODE_NAMES
39749	OP_NarrowPtr,
39750	#endif
39751	#ifdef GET_INTERPFN_LIST
39752	&Interp_NarrowPtr,
39753	#endif
39754	#ifdef GET_INTERPFN_DISPATCHERS
39755	PRESERVE_NONE
39756	static bool Interp_NarrowPtr(InterpState &S) {
39757	NarrowPtr(S);
39758	#if USE_TAILCALLS
39759	MUSTTAIL return InterpNext(S);
39760	#else
39761	return true;
39762	#endif
39763	}
39764	#endif
39765	#ifdef GET_DISASM
39766	case OP_NarrowPtr:
39767	Text.Op = PrintName("NarrowPtr");
39768	break;
39769	#endif
39770	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39771	bool emitNarrowPtr(SourceInfo);
39772	#endif
39773	#ifdef GET_LINK_IMPL
39774	bool ByteCodeEmitter::emitNarrowPtr(SourceInfo L) {
39775	return emitOp<>(OP_NarrowPtr, L);
39776	}
39777	#endif
39778	#ifdef GET_EVAL_IMPL
39779	bool EvalEmitter::emitNarrowPtr(SourceInfo L) {
39780	if (!isActive()) return true;
39781	CurrentSource = L;
39782	return NarrowPtr(S);
39783	}
39784	#endif
39785	#ifdef GET_OPCODE_NAMES
39786	OP_NegSint8,
39787	OP_NegUint8,
39788	OP_NegSint16,
39789	OP_NegUint16,
39790	OP_NegSint32,
39791	OP_NegUint32,
39792	OP_NegSint64,
39793	OP_NegUint64,
39794	OP_NegIntAP,
39795	OP_NegIntAPS,
39796	OP_NegBool,
39797	OP_NegFloat,
39798	OP_NegFixedPoint,
39799	#endif
39800	#ifdef GET_INTERPFN_LIST
39801	&Interp_NegSint8,
39802	&Interp_NegUint8,
39803	&Interp_NegSint16,
39804	&Interp_NegUint16,
39805	&Interp_NegSint32,
39806	&Interp_NegUint32,
39807	&Interp_NegSint64,
39808	&Interp_NegUint64,
39809	&Interp_NegIntAP,
39810	&Interp_NegIntAPS,
39811	&Interp_NegBool,
39812	&Interp_NegFloat,
39813	&Interp_NegFixedPoint,
39814	#endif
39815	#ifdef GET_INTERPFN_DISPATCHERS
39816	PRESERVE_NONE
39817	static bool Interp_NegSint8(InterpState &S) {
39818	if (!Neg<PT_Sint8>(S, S.PC)) return false;
39819	#if USE_TAILCALLS
39820	MUSTTAIL return InterpNext(S);
39821	#else
39822	return true;
39823	#endif
39824	}
39825	PRESERVE_NONE
39826	static bool Interp_NegUint8(InterpState &S) {
39827	if (!Neg<PT_Uint8>(S, S.PC)) return false;
39828	#if USE_TAILCALLS
39829	MUSTTAIL return InterpNext(S);
39830	#else
39831	return true;
39832	#endif
39833	}
39834	PRESERVE_NONE
39835	static bool Interp_NegSint16(InterpState &S) {
39836	if (!Neg<PT_Sint16>(S, S.PC)) return false;
39837	#if USE_TAILCALLS
39838	MUSTTAIL return InterpNext(S);
39839	#else
39840	return true;
39841	#endif
39842	}
39843	PRESERVE_NONE
39844	static bool Interp_NegUint16(InterpState &S) {
39845	if (!Neg<PT_Uint16>(S, S.PC)) return false;
39846	#if USE_TAILCALLS
39847	MUSTTAIL return InterpNext(S);
39848	#else
39849	return true;
39850	#endif
39851	}
39852	PRESERVE_NONE
39853	static bool Interp_NegSint32(InterpState &S) {
39854	if (!Neg<PT_Sint32>(S, S.PC)) return false;
39855	#if USE_TAILCALLS
39856	MUSTTAIL return InterpNext(S);
39857	#else
39858	return true;
39859	#endif
39860	}
39861	PRESERVE_NONE
39862	static bool Interp_NegUint32(InterpState &S) {
39863	if (!Neg<PT_Uint32>(S, S.PC)) return false;
39864	#if USE_TAILCALLS
39865	MUSTTAIL return InterpNext(S);
39866	#else
39867	return true;
39868	#endif
39869	}
39870	PRESERVE_NONE
39871	static bool Interp_NegSint64(InterpState &S) {
39872	if (!Neg<PT_Sint64>(S, S.PC)) return false;
39873	#if USE_TAILCALLS
39874	MUSTTAIL return InterpNext(S);
39875	#else
39876	return true;
39877	#endif
39878	}
39879	PRESERVE_NONE
39880	static bool Interp_NegUint64(InterpState &S) {
39881	if (!Neg<PT_Uint64>(S, S.PC)) return false;
39882	#if USE_TAILCALLS
39883	MUSTTAIL return InterpNext(S);
39884	#else
39885	return true;
39886	#endif
39887	}
39888	PRESERVE_NONE
39889	static bool Interp_NegIntAP(InterpState &S) {
39890	if (!Neg<PT_IntAP>(S, S.PC)) return false;
39891	#if USE_TAILCALLS
39892	MUSTTAIL return InterpNext(S);
39893	#else
39894	return true;
39895	#endif
39896	}
39897	PRESERVE_NONE
39898	static bool Interp_NegIntAPS(InterpState &S) {
39899	if (!Neg<PT_IntAPS>(S, S.PC)) return false;
39900	#if USE_TAILCALLS
39901	MUSTTAIL return InterpNext(S);
39902	#else
39903	return true;
39904	#endif
39905	}
39906	PRESERVE_NONE
39907	static bool Interp_NegBool(InterpState &S) {
39908	if (!Neg<PT_Bool>(S, S.PC)) return false;
39909	#if USE_TAILCALLS
39910	MUSTTAIL return InterpNext(S);
39911	#else
39912	return true;
39913	#endif
39914	}
39915	PRESERVE_NONE
39916	static bool Interp_NegFloat(InterpState &S) {
39917	if (!Neg<PT_Float>(S, S.PC)) return false;
39918	#if USE_TAILCALLS
39919	MUSTTAIL return InterpNext(S);
39920	#else
39921	return true;
39922	#endif
39923	}
39924	PRESERVE_NONE
39925	static bool Interp_NegFixedPoint(InterpState &S) {
39926	if (!Neg<PT_FixedPoint>(S, S.PC)) return false;
39927	#if USE_TAILCALLS
39928	MUSTTAIL return InterpNext(S);
39929	#else
39930	return true;
39931	#endif
39932	}
39933	#endif
39934	#ifdef GET_DISASM
39935	case OP_NegSint8:
39936	Text.Op = PrintName("NegSint8");
39937	break;
39938	case OP_NegUint8:
39939	Text.Op = PrintName("NegUint8");
39940	break;
39941	case OP_NegSint16:
39942	Text.Op = PrintName("NegSint16");
39943	break;
39944	case OP_NegUint16:
39945	Text.Op = PrintName("NegUint16");
39946	break;
39947	case OP_NegSint32:
39948	Text.Op = PrintName("NegSint32");
39949	break;
39950	case OP_NegUint32:
39951	Text.Op = PrintName("NegUint32");
39952	break;
39953	case OP_NegSint64:
39954	Text.Op = PrintName("NegSint64");
39955	break;
39956	case OP_NegUint64:
39957	Text.Op = PrintName("NegUint64");
39958	break;
39959	case OP_NegIntAP:
39960	Text.Op = PrintName("NegIntAP");
39961	break;
39962	case OP_NegIntAPS:
39963	Text.Op = PrintName("NegIntAPS");
39964	break;
39965	case OP_NegBool:
39966	Text.Op = PrintName("NegBool");
39967	break;
39968	case OP_NegFloat:
39969	Text.Op = PrintName("NegFloat");
39970	break;
39971	case OP_NegFixedPoint:
39972	Text.Op = PrintName("NegFixedPoint");
39973	break;
39974	#endif
39975	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39976	bool emitNegSint8(SourceInfo);
39977	bool emitNegUint8(SourceInfo);
39978	bool emitNegSint16(SourceInfo);
39979	bool emitNegUint16(SourceInfo);
39980	bool emitNegSint32(SourceInfo);
39981	bool emitNegUint32(SourceInfo);
39982	bool emitNegSint64(SourceInfo);
39983	bool emitNegUint64(SourceInfo);
39984	bool emitNegIntAP(SourceInfo);
39985	bool emitNegIntAPS(SourceInfo);
39986	bool emitNegBool(SourceInfo);
39987	bool emitNegFloat(SourceInfo);
39988	bool emitNegFixedPoint(SourceInfo);
39989	#endif
39990	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
39991	[[nodiscard]] bool emitNeg(PrimType, SourceInfo I);
39992	#endif
39993	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
39994	bool
39995	#if defined(GET_EVAL_IMPL)
39996	EvalEmitter
39997	#else
39998	ByteCodeEmitter
39999	#endif
40000	::emitNeg(PrimType T0, SourceInfo I) {
40001	switch (T0) {
40002	case PT_Sint8:
40003	return emitNegSint8(I);
40004	case PT_Uint8:
40005	return emitNegUint8(I);
40006	case PT_Sint16:
40007	return emitNegSint16(I);
40008	case PT_Uint16:
40009	return emitNegUint16(I);
40010	case PT_Sint32:
40011	return emitNegSint32(I);
40012	case PT_Uint32:
40013	return emitNegUint32(I);
40014	case PT_Sint64:
40015	return emitNegSint64(I);
40016	case PT_Uint64:
40017	return emitNegUint64(I);
40018	case PT_IntAP:
40019	return emitNegIntAP(I);
40020	case PT_IntAPS:
40021	return emitNegIntAPS(I);
40022	case PT_Bool:
40023	return emitNegBool(I);
40024	case PT_Float:
40025	return emitNegFloat(I);
40026	case PT_FixedPoint:
40027	return emitNegFixedPoint(I);
40028	default: llvm_unreachable("invalid type: emitNeg");
40029	}
40030	llvm_unreachable("invalid enum value");
40031	}
40032	#endif
40033	#ifdef GET_LINK_IMPL
40034	bool ByteCodeEmitter::emitNegSint8(SourceInfo L) {
40035	return emitOp<>(OP_NegSint8, L);
40036	}
40037	bool ByteCodeEmitter::emitNegUint8(SourceInfo L) {
40038	return emitOp<>(OP_NegUint8, L);
40039	}
40040	bool ByteCodeEmitter::emitNegSint16(SourceInfo L) {
40041	return emitOp<>(OP_NegSint16, L);
40042	}
40043	bool ByteCodeEmitter::emitNegUint16(SourceInfo L) {
40044	return emitOp<>(OP_NegUint16, L);
40045	}
40046	bool ByteCodeEmitter::emitNegSint32(SourceInfo L) {
40047	return emitOp<>(OP_NegSint32, L);
40048	}
40049	bool ByteCodeEmitter::emitNegUint32(SourceInfo L) {
40050	return emitOp<>(OP_NegUint32, L);
40051	}
40052	bool ByteCodeEmitter::emitNegSint64(SourceInfo L) {
40053	return emitOp<>(OP_NegSint64, L);
40054	}
40055	bool ByteCodeEmitter::emitNegUint64(SourceInfo L) {
40056	return emitOp<>(OP_NegUint64, L);
40057	}
40058	bool ByteCodeEmitter::emitNegIntAP(SourceInfo L) {
40059	return emitOp<>(OP_NegIntAP, L);
40060	}
40061	bool ByteCodeEmitter::emitNegIntAPS(SourceInfo L) {
40062	return emitOp<>(OP_NegIntAPS, L);
40063	}
40064	bool ByteCodeEmitter::emitNegBool(SourceInfo L) {
40065	return emitOp<>(OP_NegBool, L);
40066	}
40067	bool ByteCodeEmitter::emitNegFloat(SourceInfo L) {
40068	return emitOp<>(OP_NegFloat, L);
40069	}
40070	bool ByteCodeEmitter::emitNegFixedPoint(SourceInfo L) {
40071	return emitOp<>(OP_NegFixedPoint, L);
40072	}
40073	#endif
40074	#ifdef GET_EVAL_IMPL
40075	bool EvalEmitter::emitNegSint8(SourceInfo L) {
40076	if (!isActive()) return true;
40077	CurrentSource = L;
40078	return Neg<PT_Sint8>(S, CodePtr());
40079	}
40080	bool EvalEmitter::emitNegUint8(SourceInfo L) {
40081	if (!isActive()) return true;
40082	CurrentSource = L;
40083	return Neg<PT_Uint8>(S, CodePtr());
40084	}
40085	bool EvalEmitter::emitNegSint16(SourceInfo L) {
40086	if (!isActive()) return true;
40087	CurrentSource = L;
40088	return Neg<PT_Sint16>(S, CodePtr());
40089	}
40090	bool EvalEmitter::emitNegUint16(SourceInfo L) {
40091	if (!isActive()) return true;
40092	CurrentSource = L;
40093	return Neg<PT_Uint16>(S, CodePtr());
40094	}
40095	bool EvalEmitter::emitNegSint32(SourceInfo L) {
40096	if (!isActive()) return true;
40097	CurrentSource = L;
40098	return Neg<PT_Sint32>(S, CodePtr());
40099	}
40100	bool EvalEmitter::emitNegUint32(SourceInfo L) {
40101	if (!isActive()) return true;
40102	CurrentSource = L;
40103	return Neg<PT_Uint32>(S, CodePtr());
40104	}
40105	bool EvalEmitter::emitNegSint64(SourceInfo L) {
40106	if (!isActive()) return true;
40107	CurrentSource = L;
40108	return Neg<PT_Sint64>(S, CodePtr());
40109	}
40110	bool EvalEmitter::emitNegUint64(SourceInfo L) {
40111	if (!isActive()) return true;
40112	CurrentSource = L;
40113	return Neg<PT_Uint64>(S, CodePtr());
40114	}
40115	bool EvalEmitter::emitNegIntAP(SourceInfo L) {
40116	if (!isActive()) return true;
40117	CurrentSource = L;
40118	return Neg<PT_IntAP>(S, CodePtr());
40119	}
40120	bool EvalEmitter::emitNegIntAPS(SourceInfo L) {
40121	if (!isActive()) return true;
40122	CurrentSource = L;
40123	return Neg<PT_IntAPS>(S, CodePtr());
40124	}
40125	bool EvalEmitter::emitNegBool(SourceInfo L) {
40126	if (!isActive()) return true;
40127	CurrentSource = L;
40128	return Neg<PT_Bool>(S, CodePtr());
40129	}
40130	bool EvalEmitter::emitNegFloat(SourceInfo L) {
40131	if (!isActive()) return true;
40132	CurrentSource = L;
40133	return Neg<PT_Float>(S, CodePtr());
40134	}
40135	bool EvalEmitter::emitNegFixedPoint(SourceInfo L) {
40136	if (!isActive()) return true;
40137	CurrentSource = L;
40138	return Neg<PT_FixedPoint>(S, CodePtr());
40139	}
40140	#endif
40141	#ifdef GET_OPCODE_NAMES
40142	OP_NoRet,
40143	#endif
40144	#ifdef GET_INTERPFN_LIST
40145	&Interp_NoRet,
40146	#endif
40147	#ifdef GET_INTERPFN_DISPATCHERS
40148	PRESERVE_NONE
40149	static bool Interp_NoRet(InterpState &S) {
40150	if (!NoRet(S)) return false;
40151	#if USE_TAILCALLS
40152	MUSTTAIL return InterpNext(S);
40153	#else
40154	return true;
40155	#endif
40156	}
40157	#endif
40158	#ifdef GET_DISASM
40159	case OP_NoRet:
40160	Text.Op = PrintName("NoRet");
40161	break;
40162	#endif
40163	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40164	bool emitNoRet(SourceInfo);
40165	#endif
40166	#ifdef GET_LINK_IMPL
40167	bool ByteCodeEmitter::emitNoRet(SourceInfo L) {
40168	return emitOp<>(OP_NoRet, L);
40169	}
40170	#endif
40171	#ifdef GET_EVAL_IMPL
40172	bool EvalEmitter::emitNoRet(SourceInfo L) {
40173	if (!isActive()) return true;
40174	CurrentSource = L;
40175	return NoRet(S);
40176	}
40177	#endif
40178	#ifdef GET_OPCODE_NAMES
40179	OP_NullPtr,
40180	OP_NullMemberPtr,
40181	#endif
40182	#ifdef GET_INTERPFN_LIST
40183	&Interp_NullPtr,
40184	&Interp_NullMemberPtr,
40185	#endif
40186	#ifdef GET_INTERPFN_DISPATCHERS
40187	PRESERVE_NONE
40188	static bool Interp_NullPtr(InterpState &S) {
40189	{
40190	const auto V0 = ReadArg<uint64_t>(S, S.PC);
40191	const auto V1 = ReadArg<const Type *>(S, S.PC);
40192	Null<PT_Ptr>(S, V0, V1);
40193	}
40194	#if USE_TAILCALLS
40195	MUSTTAIL return InterpNext(S);
40196	#else
40197	return true;
40198	#endif
40199	}
40200	PRESERVE_NONE
40201	static bool Interp_NullMemberPtr(InterpState &S) {
40202	{
40203	const auto V0 = ReadArg<uint64_t>(S, S.PC);
40204	const auto V1 = ReadArg<const Type *>(S, S.PC);
40205	Null<PT_MemberPtr>(S, V0, V1);
40206	}
40207	#if USE_TAILCALLS
40208	MUSTTAIL return InterpNext(S);
40209	#else
40210	return true;
40211	#endif
40212	}
40213	#endif
40214	#ifdef GET_DISASM
40215	case OP_NullPtr:
40216	Text.Op = PrintName("NullPtr");
40217	Text.Args.push_back(printArg<uint64_t>(P, PC));
40218	Text.Args.push_back(printArg<const Type *>(P, PC));
40219	break;
40220	case OP_NullMemberPtr:
40221	Text.Op = PrintName("NullMemberPtr");
40222	Text.Args.push_back(printArg<uint64_t>(P, PC));
40223	Text.Args.push_back(printArg<const Type *>(P, PC));
40224	break;
40225	#endif
40226	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40227	bool emitNullPtr( uint64_t , const Type * , SourceInfo);
40228	bool emitNullMemberPtr( uint64_t , const Type * , SourceInfo);
40229	#endif
40230	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40231	[[nodiscard]] bool emitNull(PrimType, uint64_t, const Type *, SourceInfo I);
40232	#endif
40233	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
40234	bool
40235	#if defined(GET_EVAL_IMPL)
40236	EvalEmitter
40237	#else
40238	ByteCodeEmitter
40239	#endif
40240	::emitNull(PrimType T0, uint64_t A0, const Type * A1, SourceInfo I) {
40241	switch (T0) {
40242	case PT_Ptr:
40243	return emitNullPtr(A0, A1, I);
40244	case PT_MemberPtr:
40245	return emitNullMemberPtr(A0, A1, I);
40246	default: llvm_unreachable("invalid type: emitNull");
40247	}
40248	llvm_unreachable("invalid enum value");
40249	}
40250	#endif
40251	#ifdef GET_LINK_IMPL
40252	bool ByteCodeEmitter::emitNullPtr( uint64_t A0, const Type * A1, SourceInfo L) {
40253	return emitOp<uint64_t, const Type *>(OP_NullPtr, A0, A1, L);
40254	}
40255	bool ByteCodeEmitter::emitNullMemberPtr( uint64_t A0, const Type * A1, SourceInfo L) {
40256	return emitOp<uint64_t, const Type *>(OP_NullMemberPtr, A0, A1, L);
40257	}
40258	#endif
40259	#ifdef GET_EVAL_IMPL
40260	bool EvalEmitter::emitNullPtr( uint64_t A0, const Type * A1, SourceInfo L) {
40261	if (!isActive()) return true;
40262	CurrentSource = L;
40263	return Null<PT_Ptr>(S, A0, A1);
40264	}
40265	bool EvalEmitter::emitNullMemberPtr( uint64_t A0, const Type * A1, SourceInfo L) {
40266	if (!isActive()) return true;
40267	CurrentSource = L;
40268	return Null<PT_MemberPtr>(S, A0, A1);
40269	}
40270	#endif
40271	#ifdef GET_OPCODE_NAMES
40272	OP_OffsetOfSint8,
40273	OP_OffsetOfUint8,
40274	OP_OffsetOfSint16,
40275	OP_OffsetOfUint16,
40276	OP_OffsetOfSint32,
40277	OP_OffsetOfUint32,
40278	OP_OffsetOfSint64,
40279	OP_OffsetOfUint64,
40280	OP_OffsetOfIntAP,
40281	OP_OffsetOfIntAPS,
40282	#endif
40283	#ifdef GET_INTERPFN_LIST
40284	&Interp_OffsetOfSint8,
40285	&Interp_OffsetOfUint8,
40286	&Interp_OffsetOfSint16,
40287	&Interp_OffsetOfUint16,
40288	&Interp_OffsetOfSint32,
40289	&Interp_OffsetOfUint32,
40290	&Interp_OffsetOfSint64,
40291	&Interp_OffsetOfUint64,
40292	&Interp_OffsetOfIntAP,
40293	&Interp_OffsetOfIntAPS,
40294	#endif
40295	#ifdef GET_INTERPFN_DISPATCHERS
40296	PRESERVE_NONE
40297	static bool Interp_OffsetOfSint8(InterpState &S) {
40298	{
40299	CodePtr OpPC = S.PC;
40300	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40301	if (!OffsetOf<PT_Sint8>(S, OpPC, V0)) return false;
40302	}
40303	#if USE_TAILCALLS
40304	MUSTTAIL return InterpNext(S);
40305	#else
40306	return true;
40307	#endif
40308	}
40309	PRESERVE_NONE
40310	static bool Interp_OffsetOfUint8(InterpState &S) {
40311	{
40312	CodePtr OpPC = S.PC;
40313	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40314	if (!OffsetOf<PT_Uint8>(S, OpPC, V0)) return false;
40315	}
40316	#if USE_TAILCALLS
40317	MUSTTAIL return InterpNext(S);
40318	#else
40319	return true;
40320	#endif
40321	}
40322	PRESERVE_NONE
40323	static bool Interp_OffsetOfSint16(InterpState &S) {
40324	{
40325	CodePtr OpPC = S.PC;
40326	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40327	if (!OffsetOf<PT_Sint16>(S, OpPC, V0)) return false;
40328	}
40329	#if USE_TAILCALLS
40330	MUSTTAIL return InterpNext(S);
40331	#else
40332	return true;
40333	#endif
40334	}
40335	PRESERVE_NONE
40336	static bool Interp_OffsetOfUint16(InterpState &S) {
40337	{
40338	CodePtr OpPC = S.PC;
40339	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40340	if (!OffsetOf<PT_Uint16>(S, OpPC, V0)) return false;
40341	}
40342	#if USE_TAILCALLS
40343	MUSTTAIL return InterpNext(S);
40344	#else
40345	return true;
40346	#endif
40347	}
40348	PRESERVE_NONE
40349	static bool Interp_OffsetOfSint32(InterpState &S) {
40350	{
40351	CodePtr OpPC = S.PC;
40352	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40353	if (!OffsetOf<PT_Sint32>(S, OpPC, V0)) return false;
40354	}
40355	#if USE_TAILCALLS
40356	MUSTTAIL return InterpNext(S);
40357	#else
40358	return true;
40359	#endif
40360	}
40361	PRESERVE_NONE
40362	static bool Interp_OffsetOfUint32(InterpState &S) {
40363	{
40364	CodePtr OpPC = S.PC;
40365	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40366	if (!OffsetOf<PT_Uint32>(S, OpPC, V0)) return false;
40367	}
40368	#if USE_TAILCALLS
40369	MUSTTAIL return InterpNext(S);
40370	#else
40371	return true;
40372	#endif
40373	}
40374	PRESERVE_NONE
40375	static bool Interp_OffsetOfSint64(InterpState &S) {
40376	{
40377	CodePtr OpPC = S.PC;
40378	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40379	if (!OffsetOf<PT_Sint64>(S, OpPC, V0)) return false;
40380	}
40381	#if USE_TAILCALLS
40382	MUSTTAIL return InterpNext(S);
40383	#else
40384	return true;
40385	#endif
40386	}
40387	PRESERVE_NONE
40388	static bool Interp_OffsetOfUint64(InterpState &S) {
40389	{
40390	CodePtr OpPC = S.PC;
40391	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40392	if (!OffsetOf<PT_Uint64>(S, OpPC, V0)) return false;
40393	}
40394	#if USE_TAILCALLS
40395	MUSTTAIL return InterpNext(S);
40396	#else
40397	return true;
40398	#endif
40399	}
40400	PRESERVE_NONE
40401	static bool Interp_OffsetOfIntAP(InterpState &S) {
40402	{
40403	CodePtr OpPC = S.PC;
40404	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40405	if (!OffsetOf<PT_IntAP>(S, OpPC, V0)) return false;
40406	}
40407	#if USE_TAILCALLS
40408	MUSTTAIL return InterpNext(S);
40409	#else
40410	return true;
40411	#endif
40412	}
40413	PRESERVE_NONE
40414	static bool Interp_OffsetOfIntAPS(InterpState &S) {
40415	{
40416	CodePtr OpPC = S.PC;
40417	const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
40418	if (!OffsetOf<PT_IntAPS>(S, OpPC, V0)) return false;
40419	}
40420	#if USE_TAILCALLS
40421	MUSTTAIL return InterpNext(S);
40422	#else
40423	return true;
40424	#endif
40425	}
40426	#endif
40427	#ifdef GET_DISASM
40428	case OP_OffsetOfSint8:
40429	Text.Op = PrintName("OffsetOfSint8");
40430	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40431	break;
40432	case OP_OffsetOfUint8:
40433	Text.Op = PrintName("OffsetOfUint8");
40434	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40435	break;
40436	case OP_OffsetOfSint16:
40437	Text.Op = PrintName("OffsetOfSint16");
40438	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40439	break;
40440	case OP_OffsetOfUint16:
40441	Text.Op = PrintName("OffsetOfUint16");
40442	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40443	break;
40444	case OP_OffsetOfSint32:
40445	Text.Op = PrintName("OffsetOfSint32");
40446	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40447	break;
40448	case OP_OffsetOfUint32:
40449	Text.Op = PrintName("OffsetOfUint32");
40450	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40451	break;
40452	case OP_OffsetOfSint64:
40453	Text.Op = PrintName("OffsetOfSint64");
40454	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40455	break;
40456	case OP_OffsetOfUint64:
40457	Text.Op = PrintName("OffsetOfUint64");
40458	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40459	break;
40460	case OP_OffsetOfIntAP:
40461	Text.Op = PrintName("OffsetOfIntAP");
40462	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40463	break;
40464	case OP_OffsetOfIntAPS:
40465	Text.Op = PrintName("OffsetOfIntAPS");
40466	Text.Args.push_back(printArg<const OffsetOfExpr *>(P, PC));
40467	break;
40468	#endif
40469	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40470	bool emitOffsetOfSint8( const OffsetOfExpr * , SourceInfo);
40471	bool emitOffsetOfUint8( const OffsetOfExpr * , SourceInfo);
40472	bool emitOffsetOfSint16( const OffsetOfExpr * , SourceInfo);
40473	bool emitOffsetOfUint16( const OffsetOfExpr * , SourceInfo);
40474	bool emitOffsetOfSint32( const OffsetOfExpr * , SourceInfo);
40475	bool emitOffsetOfUint32( const OffsetOfExpr * , SourceInfo);
40476	bool emitOffsetOfSint64( const OffsetOfExpr * , SourceInfo);
40477	bool emitOffsetOfUint64( const OffsetOfExpr * , SourceInfo);
40478	bool emitOffsetOfIntAP( const OffsetOfExpr * , SourceInfo);
40479	bool emitOffsetOfIntAPS( const OffsetOfExpr * , SourceInfo);
40480	#endif
40481	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40482	[[nodiscard]] bool emitOffsetOf(PrimType, const OffsetOfExpr *, SourceInfo I);
40483	#endif
40484	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
40485	bool
40486	#if defined(GET_EVAL_IMPL)
40487	EvalEmitter
40488	#else
40489	ByteCodeEmitter
40490	#endif
40491	::emitOffsetOf(PrimType T0, const OffsetOfExpr * A0, SourceInfo I) {
40492	switch (T0) {
40493	case PT_Sint8:
40494	return emitOffsetOfSint8(A0, I);
40495	case PT_Uint8:
40496	return emitOffsetOfUint8(A0, I);
40497	case PT_Sint16:
40498	return emitOffsetOfSint16(A0, I);
40499	case PT_Uint16:
40500	return emitOffsetOfUint16(A0, I);
40501	case PT_Sint32:
40502	return emitOffsetOfSint32(A0, I);
40503	case PT_Uint32:
40504	return emitOffsetOfUint32(A0, I);
40505	case PT_Sint64:
40506	return emitOffsetOfSint64(A0, I);
40507	case PT_Uint64:
40508	return emitOffsetOfUint64(A0, I);
40509	case PT_IntAP:
40510	return emitOffsetOfIntAP(A0, I);
40511	case PT_IntAPS:
40512	return emitOffsetOfIntAPS(A0, I);
40513	default: llvm_unreachable("invalid type: emitOffsetOf");
40514	}
40515	llvm_unreachable("invalid enum value");
40516	}
40517	#endif
40518	#ifdef GET_LINK_IMPL
40519	bool ByteCodeEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, SourceInfo L) {
40520	return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint8, A0, L);
40521	}
40522	bool ByteCodeEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, SourceInfo L) {
40523	return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint8, A0, L);
40524	}
40525	bool ByteCodeEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, SourceInfo L) {
40526	return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint16, A0, L);
40527	}
40528	bool ByteCodeEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, SourceInfo L) {
40529	return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint16, A0, L);
40530	}
40531	bool ByteCodeEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, SourceInfo L) {
40532	return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint32, A0, L);
40533	}
40534	bool ByteCodeEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, SourceInfo L) {
40535	return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint32, A0, L);
40536	}
40537	bool ByteCodeEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, SourceInfo L) {
40538	return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint64, A0, L);
40539	}
40540	bool ByteCodeEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, SourceInfo L) {
40541	return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint64, A0, L);
40542	}
40543	bool ByteCodeEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, SourceInfo L) {
40544	return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAP, A0, L);
40545	}
40546	bool ByteCodeEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, SourceInfo L) {
40547	return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAPS, A0, L);
40548	}
40549	#endif
40550	#ifdef GET_EVAL_IMPL
40551	bool EvalEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, SourceInfo L) {
40552	if (!isActive()) return true;
40553	CurrentSource = L;
40554	return OffsetOf<PT_Sint8>(S, CodePtr(), A0);
40555	}
40556	bool EvalEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, SourceInfo L) {
40557	if (!isActive()) return true;
40558	CurrentSource = L;
40559	return OffsetOf<PT_Uint8>(S, CodePtr(), A0);
40560	}
40561	bool EvalEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, SourceInfo L) {
40562	if (!isActive()) return true;
40563	CurrentSource = L;
40564	return OffsetOf<PT_Sint16>(S, CodePtr(), A0);
40565	}
40566	bool EvalEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, SourceInfo L) {
40567	if (!isActive()) return true;
40568	CurrentSource = L;
40569	return OffsetOf<PT_Uint16>(S, CodePtr(), A0);
40570	}
40571	bool EvalEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, SourceInfo L) {
40572	if (!isActive()) return true;
40573	CurrentSource = L;
40574	return OffsetOf<PT_Sint32>(S, CodePtr(), A0);
40575	}
40576	bool EvalEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, SourceInfo L) {
40577	if (!isActive()) return true;
40578	CurrentSource = L;
40579	return OffsetOf<PT_Uint32>(S, CodePtr(), A0);
40580	}
40581	bool EvalEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, SourceInfo L) {
40582	if (!isActive()) return true;
40583	CurrentSource = L;
40584	return OffsetOf<PT_Sint64>(S, CodePtr(), A0);
40585	}
40586	bool EvalEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, SourceInfo L) {
40587	if (!isActive()) return true;
40588	CurrentSource = L;
40589	return OffsetOf<PT_Uint64>(S, CodePtr(), A0);
40590	}
40591	bool EvalEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, SourceInfo L) {
40592	if (!isActive()) return true;
40593	CurrentSource = L;
40594	return OffsetOf<PT_IntAP>(S, CodePtr(), A0);
40595	}
40596	bool EvalEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, SourceInfo L) {
40597	if (!isActive()) return true;
40598	CurrentSource = L;
40599	return OffsetOf<PT_IntAPS>(S, CodePtr(), A0);
40600	}
40601	#endif
40602	#ifdef GET_OPCODE_NAMES
40603	OP_PopSint8,
40604	OP_PopUint8,
40605	OP_PopSint16,
40606	OP_PopUint16,
40607	OP_PopSint32,
40608	OP_PopUint32,
40609	OP_PopSint64,
40610	OP_PopUint64,
40611	OP_PopIntAP,
40612	OP_PopIntAPS,
40613	OP_PopBool,
40614	OP_PopFixedPoint,
40615	OP_PopPtr,
40616	OP_PopMemberPtr,
40617	OP_PopFloat,
40618	#endif
40619	#ifdef GET_INTERPFN_LIST
40620	&Interp_PopSint8,
40621	&Interp_PopUint8,
40622	&Interp_PopSint16,
40623	&Interp_PopUint16,
40624	&Interp_PopSint32,
40625	&Interp_PopUint32,
40626	&Interp_PopSint64,
40627	&Interp_PopUint64,
40628	&Interp_PopIntAP,
40629	&Interp_PopIntAPS,
40630	&Interp_PopBool,
40631	&Interp_PopFixedPoint,
40632	&Interp_PopPtr,
40633	&Interp_PopMemberPtr,
40634	&Interp_PopFloat,
40635	#endif
40636	#ifdef GET_INTERPFN_DISPATCHERS
40637	PRESERVE_NONE
40638	static bool Interp_PopSint8(InterpState &S) {
40639	Pop<PT_Sint8>(S);
40640	#if USE_TAILCALLS
40641	MUSTTAIL return InterpNext(S);
40642	#else
40643	return true;
40644	#endif
40645	}
40646	PRESERVE_NONE
40647	static bool Interp_PopUint8(InterpState &S) {
40648	Pop<PT_Uint8>(S);
40649	#if USE_TAILCALLS
40650	MUSTTAIL return InterpNext(S);
40651	#else
40652	return true;
40653	#endif
40654	}
40655	PRESERVE_NONE
40656	static bool Interp_PopSint16(InterpState &S) {
40657	Pop<PT_Sint16>(S);
40658	#if USE_TAILCALLS
40659	MUSTTAIL return InterpNext(S);
40660	#else
40661	return true;
40662	#endif
40663	}
40664	PRESERVE_NONE
40665	static bool Interp_PopUint16(InterpState &S) {
40666	Pop<PT_Uint16>(S);
40667	#if USE_TAILCALLS
40668	MUSTTAIL return InterpNext(S);
40669	#else
40670	return true;
40671	#endif
40672	}
40673	PRESERVE_NONE
40674	static bool Interp_PopSint32(InterpState &S) {
40675	Pop<PT_Sint32>(S);
40676	#if USE_TAILCALLS
40677	MUSTTAIL return InterpNext(S);
40678	#else
40679	return true;
40680	#endif
40681	}
40682	PRESERVE_NONE
40683	static bool Interp_PopUint32(InterpState &S) {
40684	Pop<PT_Uint32>(S);
40685	#if USE_TAILCALLS
40686	MUSTTAIL return InterpNext(S);
40687	#else
40688	return true;
40689	#endif
40690	}
40691	PRESERVE_NONE
40692	static bool Interp_PopSint64(InterpState &S) {
40693	Pop<PT_Sint64>(S);
40694	#if USE_TAILCALLS
40695	MUSTTAIL return InterpNext(S);
40696	#else
40697	return true;
40698	#endif
40699	}
40700	PRESERVE_NONE
40701	static bool Interp_PopUint64(InterpState &S) {
40702	Pop<PT_Uint64>(S);
40703	#if USE_TAILCALLS
40704	MUSTTAIL return InterpNext(S);
40705	#else
40706	return true;
40707	#endif
40708	}
40709	PRESERVE_NONE
40710	static bool Interp_PopIntAP(InterpState &S) {
40711	Pop<PT_IntAP>(S);
40712	#if USE_TAILCALLS
40713	MUSTTAIL return InterpNext(S);
40714	#else
40715	return true;
40716	#endif
40717	}
40718	PRESERVE_NONE
40719	static bool Interp_PopIntAPS(InterpState &S) {
40720	Pop<PT_IntAPS>(S);
40721	#if USE_TAILCALLS
40722	MUSTTAIL return InterpNext(S);
40723	#else
40724	return true;
40725	#endif
40726	}
40727	PRESERVE_NONE
40728	static bool Interp_PopBool(InterpState &S) {
40729	Pop<PT_Bool>(S);
40730	#if USE_TAILCALLS
40731	MUSTTAIL return InterpNext(S);
40732	#else
40733	return true;
40734	#endif
40735	}
40736	PRESERVE_NONE
40737	static bool Interp_PopFixedPoint(InterpState &S) {
40738	Pop<PT_FixedPoint>(S);
40739	#if USE_TAILCALLS
40740	MUSTTAIL return InterpNext(S);
40741	#else
40742	return true;
40743	#endif
40744	}
40745	PRESERVE_NONE
40746	static bool Interp_PopPtr(InterpState &S) {
40747	Pop<PT_Ptr>(S);
40748	#if USE_TAILCALLS
40749	MUSTTAIL return InterpNext(S);
40750	#else
40751	return true;
40752	#endif
40753	}
40754	PRESERVE_NONE
40755	static bool Interp_PopMemberPtr(InterpState &S) {
40756	Pop<PT_MemberPtr>(S);
40757	#if USE_TAILCALLS
40758	MUSTTAIL return InterpNext(S);
40759	#else
40760	return true;
40761	#endif
40762	}
40763	PRESERVE_NONE
40764	static bool Interp_PopFloat(InterpState &S) {
40765	Pop<PT_Float>(S);
40766	#if USE_TAILCALLS
40767	MUSTTAIL return InterpNext(S);
40768	#else
40769	return true;
40770	#endif
40771	}
40772	#endif
40773	#ifdef GET_DISASM
40774	case OP_PopSint8:
40775	Text.Op = PrintName("PopSint8");
40776	break;
40777	case OP_PopUint8:
40778	Text.Op = PrintName("PopUint8");
40779	break;
40780	case OP_PopSint16:
40781	Text.Op = PrintName("PopSint16");
40782	break;
40783	case OP_PopUint16:
40784	Text.Op = PrintName("PopUint16");
40785	break;
40786	case OP_PopSint32:
40787	Text.Op = PrintName("PopSint32");
40788	break;
40789	case OP_PopUint32:
40790	Text.Op = PrintName("PopUint32");
40791	break;
40792	case OP_PopSint64:
40793	Text.Op = PrintName("PopSint64");
40794	break;
40795	case OP_PopUint64:
40796	Text.Op = PrintName("PopUint64");
40797	break;
40798	case OP_PopIntAP:
40799	Text.Op = PrintName("PopIntAP");
40800	break;
40801	case OP_PopIntAPS:
40802	Text.Op = PrintName("PopIntAPS");
40803	break;
40804	case OP_PopBool:
40805	Text.Op = PrintName("PopBool");
40806	break;
40807	case OP_PopFixedPoint:
40808	Text.Op = PrintName("PopFixedPoint");
40809	break;
40810	case OP_PopPtr:
40811	Text.Op = PrintName("PopPtr");
40812	break;
40813	case OP_PopMemberPtr:
40814	Text.Op = PrintName("PopMemberPtr");
40815	break;
40816	case OP_PopFloat:
40817	Text.Op = PrintName("PopFloat");
40818	break;
40819	#endif
40820	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40821	bool emitPopSint8(SourceInfo);
40822	bool emitPopUint8(SourceInfo);
40823	bool emitPopSint16(SourceInfo);
40824	bool emitPopUint16(SourceInfo);
40825	bool emitPopSint32(SourceInfo);
40826	bool emitPopUint32(SourceInfo);
40827	bool emitPopSint64(SourceInfo);
40828	bool emitPopUint64(SourceInfo);
40829	bool emitPopIntAP(SourceInfo);
40830	bool emitPopIntAPS(SourceInfo);
40831	bool emitPopBool(SourceInfo);
40832	bool emitPopFixedPoint(SourceInfo);
40833	bool emitPopPtr(SourceInfo);
40834	bool emitPopMemberPtr(SourceInfo);
40835	bool emitPopFloat(SourceInfo);
40836	#endif
40837	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
40838	[[nodiscard]] bool emitPop(PrimType, SourceInfo I);
40839	#endif
40840	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
40841	bool
40842	#if defined(GET_EVAL_IMPL)
40843	EvalEmitter
40844	#else
40845	ByteCodeEmitter
40846	#endif
40847	::emitPop(PrimType T0, SourceInfo I) {
40848	switch (T0) {
40849	case PT_Sint8:
40850	return emitPopSint8(I);
40851	case PT_Uint8:
40852	return emitPopUint8(I);
40853	case PT_Sint16:
40854	return emitPopSint16(I);
40855	case PT_Uint16:
40856	return emitPopUint16(I);
40857	case PT_Sint32:
40858	return emitPopSint32(I);
40859	case PT_Uint32:
40860	return emitPopUint32(I);
40861	case PT_Sint64:
40862	return emitPopSint64(I);
40863	case PT_Uint64:
40864	return emitPopUint64(I);
40865	case PT_IntAP:
40866	return emitPopIntAP(I);
40867	case PT_IntAPS:
40868	return emitPopIntAPS(I);
40869	case PT_Bool:
40870	return emitPopBool(I);
40871	case PT_FixedPoint:
40872	return emitPopFixedPoint(I);
40873	case PT_Ptr:
40874	return emitPopPtr(I);
40875	case PT_MemberPtr:
40876	return emitPopMemberPtr(I);
40877	case PT_Float:
40878	return emitPopFloat(I);
40879	}
40880	llvm_unreachable("invalid enum value");
40881	}
40882	#endif
40883	#ifdef GET_LINK_IMPL
40884	bool ByteCodeEmitter::emitPopSint8(SourceInfo L) {
40885	return emitOp<>(OP_PopSint8, L);
40886	}
40887	bool ByteCodeEmitter::emitPopUint8(SourceInfo L) {
40888	return emitOp<>(OP_PopUint8, L);
40889	}
40890	bool ByteCodeEmitter::emitPopSint16(SourceInfo L) {
40891	return emitOp<>(OP_PopSint16, L);
40892	}
40893	bool ByteCodeEmitter::emitPopUint16(SourceInfo L) {
40894	return emitOp<>(OP_PopUint16, L);
40895	}
40896	bool ByteCodeEmitter::emitPopSint32(SourceInfo L) {
40897	return emitOp<>(OP_PopSint32, L);
40898	}
40899	bool ByteCodeEmitter::emitPopUint32(SourceInfo L) {
40900	return emitOp<>(OP_PopUint32, L);
40901	}
40902	bool ByteCodeEmitter::emitPopSint64(SourceInfo L) {
40903	return emitOp<>(OP_PopSint64, L);
40904	}
40905	bool ByteCodeEmitter::emitPopUint64(SourceInfo L) {
40906	return emitOp<>(OP_PopUint64, L);
40907	}
40908	bool ByteCodeEmitter::emitPopIntAP(SourceInfo L) {
40909	return emitOp<>(OP_PopIntAP, L);
40910	}
40911	bool ByteCodeEmitter::emitPopIntAPS(SourceInfo L) {
40912	return emitOp<>(OP_PopIntAPS, L);
40913	}
40914	bool ByteCodeEmitter::emitPopBool(SourceInfo L) {
40915	return emitOp<>(OP_PopBool, L);
40916	}
40917	bool ByteCodeEmitter::emitPopFixedPoint(SourceInfo L) {
40918	return emitOp<>(OP_PopFixedPoint, L);
40919	}
40920	bool ByteCodeEmitter::emitPopPtr(SourceInfo L) {
40921	return emitOp<>(OP_PopPtr, L);
40922	}
40923	bool ByteCodeEmitter::emitPopMemberPtr(SourceInfo L) {
40924	return emitOp<>(OP_PopMemberPtr, L);
40925	}
40926	bool ByteCodeEmitter::emitPopFloat(SourceInfo L) {
40927	return emitOp<>(OP_PopFloat, L);
40928	}
40929	#endif
40930	#ifdef GET_EVAL_IMPL
40931	bool EvalEmitter::emitPopSint8(SourceInfo L) {
40932	if (!isActive()) return true;
40933	CurrentSource = L;
40934	return Pop<PT_Sint8>(S);
40935	}
40936	bool EvalEmitter::emitPopUint8(SourceInfo L) {
40937	if (!isActive()) return true;
40938	CurrentSource = L;
40939	return Pop<PT_Uint8>(S);
40940	}
40941	bool EvalEmitter::emitPopSint16(SourceInfo L) {
40942	if (!isActive()) return true;
40943	CurrentSource = L;
40944	return Pop<PT_Sint16>(S);
40945	}
40946	bool EvalEmitter::emitPopUint16(SourceInfo L) {
40947	if (!isActive()) return true;
40948	CurrentSource = L;
40949	return Pop<PT_Uint16>(S);
40950	}
40951	bool EvalEmitter::emitPopSint32(SourceInfo L) {
40952	if (!isActive()) return true;
40953	CurrentSource = L;
40954	return Pop<PT_Sint32>(S);
40955	}
40956	bool EvalEmitter::emitPopUint32(SourceInfo L) {
40957	if (!isActive()) return true;
40958	CurrentSource = L;
40959	return Pop<PT_Uint32>(S);
40960	}
40961	bool EvalEmitter::emitPopSint64(SourceInfo L) {
40962	if (!isActive()) return true;
40963	CurrentSource = L;
40964	return Pop<PT_Sint64>(S);
40965	}
40966	bool EvalEmitter::emitPopUint64(SourceInfo L) {
40967	if (!isActive()) return true;
40968	CurrentSource = L;
40969	return Pop<PT_Uint64>(S);
40970	}
40971	bool EvalEmitter::emitPopIntAP(SourceInfo L) {
40972	if (!isActive()) return true;
40973	CurrentSource = L;
40974	return Pop<PT_IntAP>(S);
40975	}
40976	bool EvalEmitter::emitPopIntAPS(SourceInfo L) {
40977	if (!isActive()) return true;
40978	CurrentSource = L;
40979	return Pop<PT_IntAPS>(S);
40980	}
40981	bool EvalEmitter::emitPopBool(SourceInfo L) {
40982	if (!isActive()) return true;
40983	CurrentSource = L;
40984	return Pop<PT_Bool>(S);
40985	}
40986	bool EvalEmitter::emitPopFixedPoint(SourceInfo L) {
40987	if (!isActive()) return true;
40988	CurrentSource = L;
40989	return Pop<PT_FixedPoint>(S);
40990	}
40991	bool EvalEmitter::emitPopPtr(SourceInfo L) {
40992	if (!isActive()) return true;
40993	CurrentSource = L;
40994	return Pop<PT_Ptr>(S);
40995	}
40996	bool EvalEmitter::emitPopMemberPtr(SourceInfo L) {
40997	if (!isActive()) return true;
40998	CurrentSource = L;
40999	return Pop<PT_MemberPtr>(S);
41000	}
41001	bool EvalEmitter::emitPopFloat(SourceInfo L) {
41002	if (!isActive()) return true;
41003	CurrentSource = L;
41004	return Pop<PT_Float>(S);
41005	}
41006	#endif
41007	#ifdef GET_OPCODE_NAMES
41008	OP_PopCC,
41009	#endif
41010	#ifdef GET_INTERPFN_LIST
41011	&Interp_PopCC,
41012	#endif
41013	#ifdef GET_INTERPFN_DISPATCHERS
41014	PRESERVE_NONE
41015	static bool Interp_PopCC(InterpState &S) {
41016	PopCC(S);
41017	#if USE_TAILCALLS
41018	MUSTTAIL return InterpNext(S);
41019	#else
41020	return true;
41021	#endif
41022	}
41023	#endif
41024	#ifdef GET_DISASM
41025	case OP_PopCC:
41026	Text.Op = PrintName("PopCC");
41027	break;
41028	#endif
41029	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41030	bool emitPopCC(SourceInfo);
41031	#endif
41032	#ifdef GET_LINK_IMPL
41033	bool ByteCodeEmitter::emitPopCC(SourceInfo L) {
41034	return emitOp<>(OP_PopCC, L);
41035	}
41036	#endif
41037	#ifdef GET_EVAL_IMPL
41038	bool EvalEmitter::emitPopCC(SourceInfo L) {
41039	if (!isActive()) return true;
41040	CurrentSource = L;
41041	return PopCC(S);
41042	}
41043	#endif
41044	#ifdef GET_OPCODE_NAMES
41045	OP_PopIgnoreDiags,
41046	#endif
41047	#ifdef GET_INTERPFN_LIST
41048	&Interp_PopIgnoreDiags,
41049	#endif
41050	#ifdef GET_INTERPFN_DISPATCHERS
41051	PRESERVE_NONE
41052	static bool Interp_PopIgnoreDiags(InterpState &S) {
41053	PopIgnoreDiags(S);
41054	#if USE_TAILCALLS
41055	MUSTTAIL return InterpNext(S);
41056	#else
41057	return true;
41058	#endif
41059	}
41060	#endif
41061	#ifdef GET_DISASM
41062	case OP_PopIgnoreDiags:
41063	Text.Op = PrintName("PopIgnoreDiags");
41064	break;
41065	#endif
41066	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41067	bool emitPopIgnoreDiags(SourceInfo);
41068	#endif
41069	#ifdef GET_LINK_IMPL
41070	bool ByteCodeEmitter::emitPopIgnoreDiags(SourceInfo L) {
41071	return emitOp<>(OP_PopIgnoreDiags, L);
41072	}
41073	#endif
41074	#ifdef GET_EVAL_IMPL
41075	bool EvalEmitter::emitPopIgnoreDiags(SourceInfo L) {
41076	if (!isActive()) return true;
41077	CurrentSource = L;
41078	return PopIgnoreDiags(S);
41079	}
41080	#endif
41081	#ifdef GET_OPCODE_NAMES
41082	OP_PopMSVCCE,
41083	#endif
41084	#ifdef GET_INTERPFN_LIST
41085	&Interp_PopMSVCCE,
41086	#endif
41087	#ifdef GET_INTERPFN_DISPATCHERS
41088	PRESERVE_NONE
41089	static bool Interp_PopMSVCCE(InterpState &S) {
41090	PopMSVCCE(S);
41091	#if USE_TAILCALLS
41092	MUSTTAIL return InterpNext(S);
41093	#else
41094	return true;
41095	#endif
41096	}
41097	#endif
41098	#ifdef GET_DISASM
41099	case OP_PopMSVCCE:
41100	Text.Op = PrintName("PopMSVCCE");
41101	break;
41102	#endif
41103	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41104	bool emitPopMSVCCE(SourceInfo);
41105	#endif
41106	#ifdef GET_LINK_IMPL
41107	bool ByteCodeEmitter::emitPopMSVCCE(SourceInfo L) {
41108	return emitOp<>(OP_PopMSVCCE, L);
41109	}
41110	#endif
41111	#ifdef GET_EVAL_IMPL
41112	bool EvalEmitter::emitPopMSVCCE(SourceInfo L) {
41113	if (!isActive()) return true;
41114	CurrentSource = L;
41115	return PopMSVCCE(S);
41116	}
41117	#endif
41118	#ifdef GET_OPCODE_NAMES
41119	OP_PreDecSint8,
41120	OP_PreDecUint8,
41121	OP_PreDecSint16,
41122	OP_PreDecUint16,
41123	OP_PreDecSint32,
41124	OP_PreDecUint32,
41125	OP_PreDecSint64,
41126	OP_PreDecUint64,
41127	OP_PreDecIntAP,
41128	OP_PreDecIntAPS,
41129	OP_PreDecBool,
41130	OP_PreDecFixedPoint,
41131	#endif
41132	#ifdef GET_INTERPFN_LIST
41133	&Interp_PreDecSint8,
41134	&Interp_PreDecUint8,
41135	&Interp_PreDecSint16,
41136	&Interp_PreDecUint16,
41137	&Interp_PreDecSint32,
41138	&Interp_PreDecUint32,
41139	&Interp_PreDecSint64,
41140	&Interp_PreDecUint64,
41141	&Interp_PreDecIntAP,
41142	&Interp_PreDecIntAPS,
41143	&Interp_PreDecBool,
41144	&Interp_PreDecFixedPoint,
41145	#endif
41146	#ifdef GET_INTERPFN_DISPATCHERS
41147	PRESERVE_NONE
41148	static bool Interp_PreDecSint8(InterpState &S) {
41149	{
41150	CodePtr OpPC = S.PC;
41151	const auto V0 = ReadArg<bool>(S, S.PC);
41152	if (!PreDec<PT_Sint8>(S, OpPC, V0)) return false;
41153	}
41154	#if USE_TAILCALLS
41155	MUSTTAIL return InterpNext(S);
41156	#else
41157	return true;
41158	#endif
41159	}
41160	PRESERVE_NONE
41161	static bool Interp_PreDecUint8(InterpState &S) {
41162	{
41163	CodePtr OpPC = S.PC;
41164	const auto V0 = ReadArg<bool>(S, S.PC);
41165	if (!PreDec<PT_Uint8>(S, OpPC, V0)) return false;
41166	}
41167	#if USE_TAILCALLS
41168	MUSTTAIL return InterpNext(S);
41169	#else
41170	return true;
41171	#endif
41172	}
41173	PRESERVE_NONE
41174	static bool Interp_PreDecSint16(InterpState &S) {
41175	{
41176	CodePtr OpPC = S.PC;
41177	const auto V0 = ReadArg<bool>(S, S.PC);
41178	if (!PreDec<PT_Sint16>(S, OpPC, V0)) return false;
41179	}
41180	#if USE_TAILCALLS
41181	MUSTTAIL return InterpNext(S);
41182	#else
41183	return true;
41184	#endif
41185	}
41186	PRESERVE_NONE
41187	static bool Interp_PreDecUint16(InterpState &S) {
41188	{
41189	CodePtr OpPC = S.PC;
41190	const auto V0 = ReadArg<bool>(S, S.PC);
41191	if (!PreDec<PT_Uint16>(S, OpPC, V0)) return false;
41192	}
41193	#if USE_TAILCALLS
41194	MUSTTAIL return InterpNext(S);
41195	#else
41196	return true;
41197	#endif
41198	}
41199	PRESERVE_NONE
41200	static bool Interp_PreDecSint32(InterpState &S) {
41201	{
41202	CodePtr OpPC = S.PC;
41203	const auto V0 = ReadArg<bool>(S, S.PC);
41204	if (!PreDec<PT_Sint32>(S, OpPC, V0)) return false;
41205	}
41206	#if USE_TAILCALLS
41207	MUSTTAIL return InterpNext(S);
41208	#else
41209	return true;
41210	#endif
41211	}
41212	PRESERVE_NONE
41213	static bool Interp_PreDecUint32(InterpState &S) {
41214	{
41215	CodePtr OpPC = S.PC;
41216	const auto V0 = ReadArg<bool>(S, S.PC);
41217	if (!PreDec<PT_Uint32>(S, OpPC, V0)) return false;
41218	}
41219	#if USE_TAILCALLS
41220	MUSTTAIL return InterpNext(S);
41221	#else
41222	return true;
41223	#endif
41224	}
41225	PRESERVE_NONE
41226	static bool Interp_PreDecSint64(InterpState &S) {
41227	{
41228	CodePtr OpPC = S.PC;
41229	const auto V0 = ReadArg<bool>(S, S.PC);
41230	if (!PreDec<PT_Sint64>(S, OpPC, V0)) return false;
41231	}
41232	#if USE_TAILCALLS
41233	MUSTTAIL return InterpNext(S);
41234	#else
41235	return true;
41236	#endif
41237	}
41238	PRESERVE_NONE
41239	static bool Interp_PreDecUint64(InterpState &S) {
41240	{
41241	CodePtr OpPC = S.PC;
41242	const auto V0 = ReadArg<bool>(S, S.PC);
41243	if (!PreDec<PT_Uint64>(S, OpPC, V0)) return false;
41244	}
41245	#if USE_TAILCALLS
41246	MUSTTAIL return InterpNext(S);
41247	#else
41248	return true;
41249	#endif
41250	}
41251	PRESERVE_NONE
41252	static bool Interp_PreDecIntAP(InterpState &S) {
41253	{
41254	CodePtr OpPC = S.PC;
41255	const auto V0 = ReadArg<bool>(S, S.PC);
41256	if (!PreDec<PT_IntAP>(S, OpPC, V0)) return false;
41257	}
41258	#if USE_TAILCALLS
41259	MUSTTAIL return InterpNext(S);
41260	#else
41261	return true;
41262	#endif
41263	}
41264	PRESERVE_NONE
41265	static bool Interp_PreDecIntAPS(InterpState &S) {
41266	{
41267	CodePtr OpPC = S.PC;
41268	const auto V0 = ReadArg<bool>(S, S.PC);
41269	if (!PreDec<PT_IntAPS>(S, OpPC, V0)) return false;
41270	}
41271	#if USE_TAILCALLS
41272	MUSTTAIL return InterpNext(S);
41273	#else
41274	return true;
41275	#endif
41276	}
41277	PRESERVE_NONE
41278	static bool Interp_PreDecBool(InterpState &S) {
41279	{
41280	CodePtr OpPC = S.PC;
41281	const auto V0 = ReadArg<bool>(S, S.PC);
41282	if (!PreDec<PT_Bool>(S, OpPC, V0)) return false;
41283	}
41284	#if USE_TAILCALLS
41285	MUSTTAIL return InterpNext(S);
41286	#else
41287	return true;
41288	#endif
41289	}
41290	PRESERVE_NONE
41291	static bool Interp_PreDecFixedPoint(InterpState &S) {
41292	{
41293	CodePtr OpPC = S.PC;
41294	const auto V0 = ReadArg<bool>(S, S.PC);
41295	if (!PreDec<PT_FixedPoint>(S, OpPC, V0)) return false;
41296	}
41297	#if USE_TAILCALLS
41298	MUSTTAIL return InterpNext(S);
41299	#else
41300	return true;
41301	#endif
41302	}
41303	#endif
41304	#ifdef GET_DISASM
41305	case OP_PreDecSint8:
41306	Text.Op = PrintName("PreDecSint8");
41307	Text.Args.push_back(printArg<bool>(P, PC));
41308	break;
41309	case OP_PreDecUint8:
41310	Text.Op = PrintName("PreDecUint8");
41311	Text.Args.push_back(printArg<bool>(P, PC));
41312	break;
41313	case OP_PreDecSint16:
41314	Text.Op = PrintName("PreDecSint16");
41315	Text.Args.push_back(printArg<bool>(P, PC));
41316	break;
41317	case OP_PreDecUint16:
41318	Text.Op = PrintName("PreDecUint16");
41319	Text.Args.push_back(printArg<bool>(P, PC));
41320	break;
41321	case OP_PreDecSint32:
41322	Text.Op = PrintName("PreDecSint32");
41323	Text.Args.push_back(printArg<bool>(P, PC));
41324	break;
41325	case OP_PreDecUint32:
41326	Text.Op = PrintName("PreDecUint32");
41327	Text.Args.push_back(printArg<bool>(P, PC));
41328	break;
41329	case OP_PreDecSint64:
41330	Text.Op = PrintName("PreDecSint64");
41331	Text.Args.push_back(printArg<bool>(P, PC));
41332	break;
41333	case OP_PreDecUint64:
41334	Text.Op = PrintName("PreDecUint64");
41335	Text.Args.push_back(printArg<bool>(P, PC));
41336	break;
41337	case OP_PreDecIntAP:
41338	Text.Op = PrintName("PreDecIntAP");
41339	Text.Args.push_back(printArg<bool>(P, PC));
41340	break;
41341	case OP_PreDecIntAPS:
41342	Text.Op = PrintName("PreDecIntAPS");
41343	Text.Args.push_back(printArg<bool>(P, PC));
41344	break;
41345	case OP_PreDecBool:
41346	Text.Op = PrintName("PreDecBool");
41347	Text.Args.push_back(printArg<bool>(P, PC));
41348	break;
41349	case OP_PreDecFixedPoint:
41350	Text.Op = PrintName("PreDecFixedPoint");
41351	Text.Args.push_back(printArg<bool>(P, PC));
41352	break;
41353	#endif
41354	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41355	bool emitPreDecSint8( bool , SourceInfo);
41356	bool emitPreDecUint8( bool , SourceInfo);
41357	bool emitPreDecSint16( bool , SourceInfo);
41358	bool emitPreDecUint16( bool , SourceInfo);
41359	bool emitPreDecSint32( bool , SourceInfo);
41360	bool emitPreDecUint32( bool , SourceInfo);
41361	bool emitPreDecSint64( bool , SourceInfo);
41362	bool emitPreDecUint64( bool , SourceInfo);
41363	bool emitPreDecIntAP( bool , SourceInfo);
41364	bool emitPreDecIntAPS( bool , SourceInfo);
41365	bool emitPreDecBool( bool , SourceInfo);
41366	bool emitPreDecFixedPoint( bool , SourceInfo);
41367	#endif
41368	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41369	[[nodiscard]] bool emitPreDec(PrimType, bool, SourceInfo I);
41370	#endif
41371	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
41372	bool
41373	#if defined(GET_EVAL_IMPL)
41374	EvalEmitter
41375	#else
41376	ByteCodeEmitter
41377	#endif
41378	::emitPreDec(PrimType T0, bool A0, SourceInfo I) {
41379	switch (T0) {
41380	case PT_Sint8:
41381	return emitPreDecSint8(A0, I);
41382	case PT_Uint8:
41383	return emitPreDecUint8(A0, I);
41384	case PT_Sint16:
41385	return emitPreDecSint16(A0, I);
41386	case PT_Uint16:
41387	return emitPreDecUint16(A0, I);
41388	case PT_Sint32:
41389	return emitPreDecSint32(A0, I);
41390	case PT_Uint32:
41391	return emitPreDecUint32(A0, I);
41392	case PT_Sint64:
41393	return emitPreDecSint64(A0, I);
41394	case PT_Uint64:
41395	return emitPreDecUint64(A0, I);
41396	case PT_IntAP:
41397	return emitPreDecIntAP(A0, I);
41398	case PT_IntAPS:
41399	return emitPreDecIntAPS(A0, I);
41400	case PT_Bool:
41401	return emitPreDecBool(A0, I);
41402	case PT_FixedPoint:
41403	return emitPreDecFixedPoint(A0, I);
41404	default: llvm_unreachable("invalid type: emitPreDec");
41405	}
41406	llvm_unreachable("invalid enum value");
41407	}
41408	#endif
41409	#ifdef GET_LINK_IMPL
41410	bool ByteCodeEmitter::emitPreDecSint8( bool A0, SourceInfo L) {
41411	return emitOp<bool>(OP_PreDecSint8, A0, L);
41412	}
41413	bool ByteCodeEmitter::emitPreDecUint8( bool A0, SourceInfo L) {
41414	return emitOp<bool>(OP_PreDecUint8, A0, L);
41415	}
41416	bool ByteCodeEmitter::emitPreDecSint16( bool A0, SourceInfo L) {
41417	return emitOp<bool>(OP_PreDecSint16, A0, L);
41418	}
41419	bool ByteCodeEmitter::emitPreDecUint16( bool A0, SourceInfo L) {
41420	return emitOp<bool>(OP_PreDecUint16, A0, L);
41421	}
41422	bool ByteCodeEmitter::emitPreDecSint32( bool A0, SourceInfo L) {
41423	return emitOp<bool>(OP_PreDecSint32, A0, L);
41424	}
41425	bool ByteCodeEmitter::emitPreDecUint32( bool A0, SourceInfo L) {
41426	return emitOp<bool>(OP_PreDecUint32, A0, L);
41427	}
41428	bool ByteCodeEmitter::emitPreDecSint64( bool A0, SourceInfo L) {
41429	return emitOp<bool>(OP_PreDecSint64, A0, L);
41430	}
41431	bool ByteCodeEmitter::emitPreDecUint64( bool A0, SourceInfo L) {
41432	return emitOp<bool>(OP_PreDecUint64, A0, L);
41433	}
41434	bool ByteCodeEmitter::emitPreDecIntAP( bool A0, SourceInfo L) {
41435	return emitOp<bool>(OP_PreDecIntAP, A0, L);
41436	}
41437	bool ByteCodeEmitter::emitPreDecIntAPS( bool A0, SourceInfo L) {
41438	return emitOp<bool>(OP_PreDecIntAPS, A0, L);
41439	}
41440	bool ByteCodeEmitter::emitPreDecBool( bool A0, SourceInfo L) {
41441	return emitOp<bool>(OP_PreDecBool, A0, L);
41442	}
41443	bool ByteCodeEmitter::emitPreDecFixedPoint( bool A0, SourceInfo L) {
41444	return emitOp<bool>(OP_PreDecFixedPoint, A0, L);
41445	}
41446	#endif
41447	#ifdef GET_EVAL_IMPL
41448	bool EvalEmitter::emitPreDecSint8( bool A0, SourceInfo L) {
41449	if (!isActive()) return true;
41450	CurrentSource = L;
41451	return PreDec<PT_Sint8>(S, CodePtr(), A0);
41452	}
41453	bool EvalEmitter::emitPreDecUint8( bool A0, SourceInfo L) {
41454	if (!isActive()) return true;
41455	CurrentSource = L;
41456	return PreDec<PT_Uint8>(S, CodePtr(), A0);
41457	}
41458	bool EvalEmitter::emitPreDecSint16( bool A0, SourceInfo L) {
41459	if (!isActive()) return true;
41460	CurrentSource = L;
41461	return PreDec<PT_Sint16>(S, CodePtr(), A0);
41462	}
41463	bool EvalEmitter::emitPreDecUint16( bool A0, SourceInfo L) {
41464	if (!isActive()) return true;
41465	CurrentSource = L;
41466	return PreDec<PT_Uint16>(S, CodePtr(), A0);
41467	}
41468	bool EvalEmitter::emitPreDecSint32( bool A0, SourceInfo L) {
41469	if (!isActive()) return true;
41470	CurrentSource = L;
41471	return PreDec<PT_Sint32>(S, CodePtr(), A0);
41472	}
41473	bool EvalEmitter::emitPreDecUint32( bool A0, SourceInfo L) {
41474	if (!isActive()) return true;
41475	CurrentSource = L;
41476	return PreDec<PT_Uint32>(S, CodePtr(), A0);
41477	}
41478	bool EvalEmitter::emitPreDecSint64( bool A0, SourceInfo L) {
41479	if (!isActive()) return true;
41480	CurrentSource = L;
41481	return PreDec<PT_Sint64>(S, CodePtr(), A0);
41482	}
41483	bool EvalEmitter::emitPreDecUint64( bool A0, SourceInfo L) {
41484	if (!isActive()) return true;
41485	CurrentSource = L;
41486	return PreDec<PT_Uint64>(S, CodePtr(), A0);
41487	}
41488	bool EvalEmitter::emitPreDecIntAP( bool A0, SourceInfo L) {
41489	if (!isActive()) return true;
41490	CurrentSource = L;
41491	return PreDec<PT_IntAP>(S, CodePtr(), A0);
41492	}
41493	bool EvalEmitter::emitPreDecIntAPS( bool A0, SourceInfo L) {
41494	if (!isActive()) return true;
41495	CurrentSource = L;
41496	return PreDec<PT_IntAPS>(S, CodePtr(), A0);
41497	}
41498	bool EvalEmitter::emitPreDecBool( bool A0, SourceInfo L) {
41499	if (!isActive()) return true;
41500	CurrentSource = L;
41501	return PreDec<PT_Bool>(S, CodePtr(), A0);
41502	}
41503	bool EvalEmitter::emitPreDecFixedPoint( bool A0, SourceInfo L) {
41504	if (!isActive()) return true;
41505	CurrentSource = L;
41506	return PreDec<PT_FixedPoint>(S, CodePtr(), A0);
41507	}
41508	#endif
41509	#ifdef GET_OPCODE_NAMES
41510	OP_PreDecBitfieldSint8,
41511	OP_PreDecBitfieldUint8,
41512	OP_PreDecBitfieldSint16,
41513	OP_PreDecBitfieldUint16,
41514	OP_PreDecBitfieldSint32,
41515	OP_PreDecBitfieldUint32,
41516	OP_PreDecBitfieldSint64,
41517	OP_PreDecBitfieldUint64,
41518	OP_PreDecBitfieldIntAP,
41519	OP_PreDecBitfieldIntAPS,
41520	OP_PreDecBitfieldBool,
41521	OP_PreDecBitfieldFixedPoint,
41522	#endif
41523	#ifdef GET_INTERPFN_LIST
41524	&Interp_PreDecBitfieldSint8,
41525	&Interp_PreDecBitfieldUint8,
41526	&Interp_PreDecBitfieldSint16,
41527	&Interp_PreDecBitfieldUint16,
41528	&Interp_PreDecBitfieldSint32,
41529	&Interp_PreDecBitfieldUint32,
41530	&Interp_PreDecBitfieldSint64,
41531	&Interp_PreDecBitfieldUint64,
41532	&Interp_PreDecBitfieldIntAP,
41533	&Interp_PreDecBitfieldIntAPS,
41534	&Interp_PreDecBitfieldBool,
41535	&Interp_PreDecBitfieldFixedPoint,
41536	#endif
41537	#ifdef GET_INTERPFN_DISPATCHERS
41538	PRESERVE_NONE
41539	static bool Interp_PreDecBitfieldSint8(InterpState &S) {
41540	{
41541	CodePtr OpPC = S.PC;
41542	const auto V0 = ReadArg<bool>(S, S.PC);
41543	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41544	if (!PreDecBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
41545	}
41546	#if USE_TAILCALLS
41547	MUSTTAIL return InterpNext(S);
41548	#else
41549	return true;
41550	#endif
41551	}
41552	PRESERVE_NONE
41553	static bool Interp_PreDecBitfieldUint8(InterpState &S) {
41554	{
41555	CodePtr OpPC = S.PC;
41556	const auto V0 = ReadArg<bool>(S, S.PC);
41557	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41558	if (!PreDecBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
41559	}
41560	#if USE_TAILCALLS
41561	MUSTTAIL return InterpNext(S);
41562	#else
41563	return true;
41564	#endif
41565	}
41566	PRESERVE_NONE
41567	static bool Interp_PreDecBitfieldSint16(InterpState &S) {
41568	{
41569	CodePtr OpPC = S.PC;
41570	const auto V0 = ReadArg<bool>(S, S.PC);
41571	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41572	if (!PreDecBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
41573	}
41574	#if USE_TAILCALLS
41575	MUSTTAIL return InterpNext(S);
41576	#else
41577	return true;
41578	#endif
41579	}
41580	PRESERVE_NONE
41581	static bool Interp_PreDecBitfieldUint16(InterpState &S) {
41582	{
41583	CodePtr OpPC = S.PC;
41584	const auto V0 = ReadArg<bool>(S, S.PC);
41585	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41586	if (!PreDecBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
41587	}
41588	#if USE_TAILCALLS
41589	MUSTTAIL return InterpNext(S);
41590	#else
41591	return true;
41592	#endif
41593	}
41594	PRESERVE_NONE
41595	static bool Interp_PreDecBitfieldSint32(InterpState &S) {
41596	{
41597	CodePtr OpPC = S.PC;
41598	const auto V0 = ReadArg<bool>(S, S.PC);
41599	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41600	if (!PreDecBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
41601	}
41602	#if USE_TAILCALLS
41603	MUSTTAIL return InterpNext(S);
41604	#else
41605	return true;
41606	#endif
41607	}
41608	PRESERVE_NONE
41609	static bool Interp_PreDecBitfieldUint32(InterpState &S) {
41610	{
41611	CodePtr OpPC = S.PC;
41612	const auto V0 = ReadArg<bool>(S, S.PC);
41613	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41614	if (!PreDecBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
41615	}
41616	#if USE_TAILCALLS
41617	MUSTTAIL return InterpNext(S);
41618	#else
41619	return true;
41620	#endif
41621	}
41622	PRESERVE_NONE
41623	static bool Interp_PreDecBitfieldSint64(InterpState &S) {
41624	{
41625	CodePtr OpPC = S.PC;
41626	const auto V0 = ReadArg<bool>(S, S.PC);
41627	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41628	if (!PreDecBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
41629	}
41630	#if USE_TAILCALLS
41631	MUSTTAIL return InterpNext(S);
41632	#else
41633	return true;
41634	#endif
41635	}
41636	PRESERVE_NONE
41637	static bool Interp_PreDecBitfieldUint64(InterpState &S) {
41638	{
41639	CodePtr OpPC = S.PC;
41640	const auto V0 = ReadArg<bool>(S, S.PC);
41641	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41642	if (!PreDecBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
41643	}
41644	#if USE_TAILCALLS
41645	MUSTTAIL return InterpNext(S);
41646	#else
41647	return true;
41648	#endif
41649	}
41650	PRESERVE_NONE
41651	static bool Interp_PreDecBitfieldIntAP(InterpState &S) {
41652	{
41653	CodePtr OpPC = S.PC;
41654	const auto V0 = ReadArg<bool>(S, S.PC);
41655	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41656	if (!PreDecBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
41657	}
41658	#if USE_TAILCALLS
41659	MUSTTAIL return InterpNext(S);
41660	#else
41661	return true;
41662	#endif
41663	}
41664	PRESERVE_NONE
41665	static bool Interp_PreDecBitfieldIntAPS(InterpState &S) {
41666	{
41667	CodePtr OpPC = S.PC;
41668	const auto V0 = ReadArg<bool>(S, S.PC);
41669	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41670	if (!PreDecBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
41671	}
41672	#if USE_TAILCALLS
41673	MUSTTAIL return InterpNext(S);
41674	#else
41675	return true;
41676	#endif
41677	}
41678	PRESERVE_NONE
41679	static bool Interp_PreDecBitfieldBool(InterpState &S) {
41680	{
41681	CodePtr OpPC = S.PC;
41682	const auto V0 = ReadArg<bool>(S, S.PC);
41683	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41684	if (!PreDecBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
41685	}
41686	#if USE_TAILCALLS
41687	MUSTTAIL return InterpNext(S);
41688	#else
41689	return true;
41690	#endif
41691	}
41692	PRESERVE_NONE
41693	static bool Interp_PreDecBitfieldFixedPoint(InterpState &S) {
41694	{
41695	CodePtr OpPC = S.PC;
41696	const auto V0 = ReadArg<bool>(S, S.PC);
41697	const auto V1 = ReadArg<uint32_t>(S, S.PC);
41698	if (!PreDecBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
41699	}
41700	#if USE_TAILCALLS
41701	MUSTTAIL return InterpNext(S);
41702	#else
41703	return true;
41704	#endif
41705	}
41706	#endif
41707	#ifdef GET_DISASM
41708	case OP_PreDecBitfieldSint8:
41709	Text.Op = PrintName("PreDecBitfieldSint8");
41710	Text.Args.push_back(printArg<bool>(P, PC));
41711	Text.Args.push_back(printArg<uint32_t>(P, PC));
41712	break;
41713	case OP_PreDecBitfieldUint8:
41714	Text.Op = PrintName("PreDecBitfieldUint8");
41715	Text.Args.push_back(printArg<bool>(P, PC));
41716	Text.Args.push_back(printArg<uint32_t>(P, PC));
41717	break;
41718	case OP_PreDecBitfieldSint16:
41719	Text.Op = PrintName("PreDecBitfieldSint16");
41720	Text.Args.push_back(printArg<bool>(P, PC));
41721	Text.Args.push_back(printArg<uint32_t>(P, PC));
41722	break;
41723	case OP_PreDecBitfieldUint16:
41724	Text.Op = PrintName("PreDecBitfieldUint16");
41725	Text.Args.push_back(printArg<bool>(P, PC));
41726	Text.Args.push_back(printArg<uint32_t>(P, PC));
41727	break;
41728	case OP_PreDecBitfieldSint32:
41729	Text.Op = PrintName("PreDecBitfieldSint32");
41730	Text.Args.push_back(printArg<bool>(P, PC));
41731	Text.Args.push_back(printArg<uint32_t>(P, PC));
41732	break;
41733	case OP_PreDecBitfieldUint32:
41734	Text.Op = PrintName("PreDecBitfieldUint32");
41735	Text.Args.push_back(printArg<bool>(P, PC));
41736	Text.Args.push_back(printArg<uint32_t>(P, PC));
41737	break;
41738	case OP_PreDecBitfieldSint64:
41739	Text.Op = PrintName("PreDecBitfieldSint64");
41740	Text.Args.push_back(printArg<bool>(P, PC));
41741	Text.Args.push_back(printArg<uint32_t>(P, PC));
41742	break;
41743	case OP_PreDecBitfieldUint64:
41744	Text.Op = PrintName("PreDecBitfieldUint64");
41745	Text.Args.push_back(printArg<bool>(P, PC));
41746	Text.Args.push_back(printArg<uint32_t>(P, PC));
41747	break;
41748	case OP_PreDecBitfieldIntAP:
41749	Text.Op = PrintName("PreDecBitfieldIntAP");
41750	Text.Args.push_back(printArg<bool>(P, PC));
41751	Text.Args.push_back(printArg<uint32_t>(P, PC));
41752	break;
41753	case OP_PreDecBitfieldIntAPS:
41754	Text.Op = PrintName("PreDecBitfieldIntAPS");
41755	Text.Args.push_back(printArg<bool>(P, PC));
41756	Text.Args.push_back(printArg<uint32_t>(P, PC));
41757	break;
41758	case OP_PreDecBitfieldBool:
41759	Text.Op = PrintName("PreDecBitfieldBool");
41760	Text.Args.push_back(printArg<bool>(P, PC));
41761	Text.Args.push_back(printArg<uint32_t>(P, PC));
41762	break;
41763	case OP_PreDecBitfieldFixedPoint:
41764	Text.Op = PrintName("PreDecBitfieldFixedPoint");
41765	Text.Args.push_back(printArg<bool>(P, PC));
41766	Text.Args.push_back(printArg<uint32_t>(P, PC));
41767	break;
41768	#endif
41769	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41770	bool emitPreDecBitfieldSint8( bool , uint32_t , SourceInfo);
41771	bool emitPreDecBitfieldUint8( bool , uint32_t , SourceInfo);
41772	bool emitPreDecBitfieldSint16( bool , uint32_t , SourceInfo);
41773	bool emitPreDecBitfieldUint16( bool , uint32_t , SourceInfo);
41774	bool emitPreDecBitfieldSint32( bool , uint32_t , SourceInfo);
41775	bool emitPreDecBitfieldUint32( bool , uint32_t , SourceInfo);
41776	bool emitPreDecBitfieldSint64( bool , uint32_t , SourceInfo);
41777	bool emitPreDecBitfieldUint64( bool , uint32_t , SourceInfo);
41778	bool emitPreDecBitfieldIntAP( bool , uint32_t , SourceInfo);
41779	bool emitPreDecBitfieldIntAPS( bool , uint32_t , SourceInfo);
41780	bool emitPreDecBitfieldBool( bool , uint32_t , SourceInfo);
41781	bool emitPreDecBitfieldFixedPoint( bool , uint32_t , SourceInfo);
41782	#endif
41783	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
41784	[[nodiscard]] bool emitPreDecBitfield(PrimType, bool, uint32_t, SourceInfo I);
41785	#endif
41786	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
41787	bool
41788	#if defined(GET_EVAL_IMPL)
41789	EvalEmitter
41790	#else
41791	ByteCodeEmitter
41792	#endif
41793	::emitPreDecBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
41794	switch (T0) {
41795	case PT_Sint8:
41796	return emitPreDecBitfieldSint8(A0, A1, I);
41797	case PT_Uint8:
41798	return emitPreDecBitfieldUint8(A0, A1, I);
41799	case PT_Sint16:
41800	return emitPreDecBitfieldSint16(A0, A1, I);
41801	case PT_Uint16:
41802	return emitPreDecBitfieldUint16(A0, A1, I);
41803	case PT_Sint32:
41804	return emitPreDecBitfieldSint32(A0, A1, I);
41805	case PT_Uint32:
41806	return emitPreDecBitfieldUint32(A0, A1, I);
41807	case PT_Sint64:
41808	return emitPreDecBitfieldSint64(A0, A1, I);
41809	case PT_Uint64:
41810	return emitPreDecBitfieldUint64(A0, A1, I);
41811	case PT_IntAP:
41812	return emitPreDecBitfieldIntAP(A0, A1, I);
41813	case PT_IntAPS:
41814	return emitPreDecBitfieldIntAPS(A0, A1, I);
41815	case PT_Bool:
41816	return emitPreDecBitfieldBool(A0, A1, I);
41817	case PT_FixedPoint:
41818	return emitPreDecBitfieldFixedPoint(A0, A1, I);
41819	default: llvm_unreachable("invalid type: emitPreDecBitfield");
41820	}
41821	llvm_unreachable("invalid enum value");
41822	}
41823	#endif
41824	#ifdef GET_LINK_IMPL
41825	bool ByteCodeEmitter::emitPreDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
41826	return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint8, A0, A1, L);
41827	}
41828	bool ByteCodeEmitter::emitPreDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
41829	return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint8, A0, A1, L);
41830	}
41831	bool ByteCodeEmitter::emitPreDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
41832	return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint16, A0, A1, L);
41833	}
41834	bool ByteCodeEmitter::emitPreDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
41835	return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint16, A0, A1, L);
41836	}
41837	bool ByteCodeEmitter::emitPreDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
41838	return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint32, A0, A1, L);
41839	}
41840	bool ByteCodeEmitter::emitPreDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
41841	return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint32, A0, A1, L);
41842	}
41843	bool ByteCodeEmitter::emitPreDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
41844	return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint64, A0, A1, L);
41845	}
41846	bool ByteCodeEmitter::emitPreDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
41847	return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint64, A0, A1, L);
41848	}
41849	bool ByteCodeEmitter::emitPreDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
41850	return emitOp<bool, uint32_t>(OP_PreDecBitfieldIntAP, A0, A1, L);
41851	}
41852	bool ByteCodeEmitter::emitPreDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
41853	return emitOp<bool, uint32_t>(OP_PreDecBitfieldIntAPS, A0, A1, L);
41854	}
41855	bool ByteCodeEmitter::emitPreDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
41856	return emitOp<bool, uint32_t>(OP_PreDecBitfieldBool, A0, A1, L);
41857	}
41858	bool ByteCodeEmitter::emitPreDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
41859	return emitOp<bool, uint32_t>(OP_PreDecBitfieldFixedPoint, A0, A1, L);
41860	}
41861	#endif
41862	#ifdef GET_EVAL_IMPL
41863	bool EvalEmitter::emitPreDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
41864	if (!isActive()) return true;
41865	CurrentSource = L;
41866	return PreDecBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
41867	}
41868	bool EvalEmitter::emitPreDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
41869	if (!isActive()) return true;
41870	CurrentSource = L;
41871	return PreDecBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
41872	}
41873	bool EvalEmitter::emitPreDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
41874	if (!isActive()) return true;
41875	CurrentSource = L;
41876	return PreDecBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
41877	}
41878	bool EvalEmitter::emitPreDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
41879	if (!isActive()) return true;
41880	CurrentSource = L;
41881	return PreDecBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
41882	}
41883	bool EvalEmitter::emitPreDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
41884	if (!isActive()) return true;
41885	CurrentSource = L;
41886	return PreDecBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
41887	}
41888	bool EvalEmitter::emitPreDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
41889	if (!isActive()) return true;
41890	CurrentSource = L;
41891	return PreDecBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
41892	}
41893	bool EvalEmitter::emitPreDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
41894	if (!isActive()) return true;
41895	CurrentSource = L;
41896	return PreDecBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
41897	}
41898	bool EvalEmitter::emitPreDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
41899	if (!isActive()) return true;
41900	CurrentSource = L;
41901	return PreDecBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
41902	}
41903	bool EvalEmitter::emitPreDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
41904	if (!isActive()) return true;
41905	CurrentSource = L;
41906	return PreDecBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
41907	}
41908	bool EvalEmitter::emitPreDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
41909	if (!isActive()) return true;
41910	CurrentSource = L;
41911	return PreDecBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
41912	}
41913	bool EvalEmitter::emitPreDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
41914	if (!isActive()) return true;
41915	CurrentSource = L;
41916	return PreDecBitfield<PT_Bool>(S, CodePtr(), A0, A1);
41917	}
41918	bool EvalEmitter::emitPreDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
41919	if (!isActive()) return true;
41920	CurrentSource = L;
41921	return PreDecBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
41922	}
41923	#endif
41924	#ifdef GET_OPCODE_NAMES
41925	OP_PreIncSint8,
41926	OP_PreIncUint8,
41927	OP_PreIncSint16,
41928	OP_PreIncUint16,
41929	OP_PreIncSint32,
41930	OP_PreIncUint32,
41931	OP_PreIncSint64,
41932	OP_PreIncUint64,
41933	OP_PreIncIntAP,
41934	OP_PreIncIntAPS,
41935	OP_PreIncBool,
41936	OP_PreIncFixedPoint,
41937	#endif
41938	#ifdef GET_INTERPFN_LIST
41939	&Interp_PreIncSint8,
41940	&Interp_PreIncUint8,
41941	&Interp_PreIncSint16,
41942	&Interp_PreIncUint16,
41943	&Interp_PreIncSint32,
41944	&Interp_PreIncUint32,
41945	&Interp_PreIncSint64,
41946	&Interp_PreIncUint64,
41947	&Interp_PreIncIntAP,
41948	&Interp_PreIncIntAPS,
41949	&Interp_PreIncBool,
41950	&Interp_PreIncFixedPoint,
41951	#endif
41952	#ifdef GET_INTERPFN_DISPATCHERS
41953	PRESERVE_NONE
41954	static bool Interp_PreIncSint8(InterpState &S) {
41955	{
41956	CodePtr OpPC = S.PC;
41957	const auto V0 = ReadArg<bool>(S, S.PC);
41958	if (!PreInc<PT_Sint8>(S, OpPC, V0)) return false;
41959	}
41960	#if USE_TAILCALLS
41961	MUSTTAIL return InterpNext(S);
41962	#else
41963	return true;
41964	#endif
41965	}
41966	PRESERVE_NONE
41967	static bool Interp_PreIncUint8(InterpState &S) {
41968	{
41969	CodePtr OpPC = S.PC;
41970	const auto V0 = ReadArg<bool>(S, S.PC);
41971	if (!PreInc<PT_Uint8>(S, OpPC, V0)) return false;
41972	}
41973	#if USE_TAILCALLS
41974	MUSTTAIL return InterpNext(S);
41975	#else
41976	return true;
41977	#endif
41978	}
41979	PRESERVE_NONE
41980	static bool Interp_PreIncSint16(InterpState &S) {
41981	{
41982	CodePtr OpPC = S.PC;
41983	const auto V0 = ReadArg<bool>(S, S.PC);
41984	if (!PreInc<PT_Sint16>(S, OpPC, V0)) return false;
41985	}
41986	#if USE_TAILCALLS
41987	MUSTTAIL return InterpNext(S);
41988	#else
41989	return true;
41990	#endif
41991	}
41992	PRESERVE_NONE
41993	static bool Interp_PreIncUint16(InterpState &S) {
41994	{
41995	CodePtr OpPC = S.PC;
41996	const auto V0 = ReadArg<bool>(S, S.PC);
41997	if (!PreInc<PT_Uint16>(S, OpPC, V0)) return false;
41998	}
41999	#if USE_TAILCALLS
42000	MUSTTAIL return InterpNext(S);
42001	#else
42002	return true;
42003	#endif
42004	}
42005	PRESERVE_NONE
42006	static bool Interp_PreIncSint32(InterpState &S) {
42007	{
42008	CodePtr OpPC = S.PC;
42009	const auto V0 = ReadArg<bool>(S, S.PC);
42010	if (!PreInc<PT_Sint32>(S, OpPC, V0)) return false;
42011	}
42012	#if USE_TAILCALLS
42013	MUSTTAIL return InterpNext(S);
42014	#else
42015	return true;
42016	#endif
42017	}
42018	PRESERVE_NONE
42019	static bool Interp_PreIncUint32(InterpState &S) {
42020	{
42021	CodePtr OpPC = S.PC;
42022	const auto V0 = ReadArg<bool>(S, S.PC);
42023	if (!PreInc<PT_Uint32>(S, OpPC, V0)) return false;
42024	}
42025	#if USE_TAILCALLS
42026	MUSTTAIL return InterpNext(S);
42027	#else
42028	return true;
42029	#endif
42030	}
42031	PRESERVE_NONE
42032	static bool Interp_PreIncSint64(InterpState &S) {
42033	{
42034	CodePtr OpPC = S.PC;
42035	const auto V0 = ReadArg<bool>(S, S.PC);
42036	if (!PreInc<PT_Sint64>(S, OpPC, V0)) return false;
42037	}
42038	#if USE_TAILCALLS
42039	MUSTTAIL return InterpNext(S);
42040	#else
42041	return true;
42042	#endif
42043	}
42044	PRESERVE_NONE
42045	static bool Interp_PreIncUint64(InterpState &S) {
42046	{
42047	CodePtr OpPC = S.PC;
42048	const auto V0 = ReadArg<bool>(S, S.PC);
42049	if (!PreInc<PT_Uint64>(S, OpPC, V0)) return false;
42050	}
42051	#if USE_TAILCALLS
42052	MUSTTAIL return InterpNext(S);
42053	#else
42054	return true;
42055	#endif
42056	}
42057	PRESERVE_NONE
42058	static bool Interp_PreIncIntAP(InterpState &S) {
42059	{
42060	CodePtr OpPC = S.PC;
42061	const auto V0 = ReadArg<bool>(S, S.PC);
42062	if (!PreInc<PT_IntAP>(S, OpPC, V0)) return false;
42063	}
42064	#if USE_TAILCALLS
42065	MUSTTAIL return InterpNext(S);
42066	#else
42067	return true;
42068	#endif
42069	}
42070	PRESERVE_NONE
42071	static bool Interp_PreIncIntAPS(InterpState &S) {
42072	{
42073	CodePtr OpPC = S.PC;
42074	const auto V0 = ReadArg<bool>(S, S.PC);
42075	if (!PreInc<PT_IntAPS>(S, OpPC, V0)) return false;
42076	}
42077	#if USE_TAILCALLS
42078	MUSTTAIL return InterpNext(S);
42079	#else
42080	return true;
42081	#endif
42082	}
42083	PRESERVE_NONE
42084	static bool Interp_PreIncBool(InterpState &S) {
42085	{
42086	CodePtr OpPC = S.PC;
42087	const auto V0 = ReadArg<bool>(S, S.PC);
42088	if (!PreInc<PT_Bool>(S, OpPC, V0)) return false;
42089	}
42090	#if USE_TAILCALLS
42091	MUSTTAIL return InterpNext(S);
42092	#else
42093	return true;
42094	#endif
42095	}
42096	PRESERVE_NONE
42097	static bool Interp_PreIncFixedPoint(InterpState &S) {
42098	{
42099	CodePtr OpPC = S.PC;
42100	const auto V0 = ReadArg<bool>(S, S.PC);
42101	if (!PreInc<PT_FixedPoint>(S, OpPC, V0)) return false;
42102	}
42103	#if USE_TAILCALLS
42104	MUSTTAIL return InterpNext(S);
42105	#else
42106	return true;
42107	#endif
42108	}
42109	#endif
42110	#ifdef GET_DISASM
42111	case OP_PreIncSint8:
42112	Text.Op = PrintName("PreIncSint8");
42113	Text.Args.push_back(printArg<bool>(P, PC));
42114	break;
42115	case OP_PreIncUint8:
42116	Text.Op = PrintName("PreIncUint8");
42117	Text.Args.push_back(printArg<bool>(P, PC));
42118	break;
42119	case OP_PreIncSint16:
42120	Text.Op = PrintName("PreIncSint16");
42121	Text.Args.push_back(printArg<bool>(P, PC));
42122	break;
42123	case OP_PreIncUint16:
42124	Text.Op = PrintName("PreIncUint16");
42125	Text.Args.push_back(printArg<bool>(P, PC));
42126	break;
42127	case OP_PreIncSint32:
42128	Text.Op = PrintName("PreIncSint32");
42129	Text.Args.push_back(printArg<bool>(P, PC));
42130	break;
42131	case OP_PreIncUint32:
42132	Text.Op = PrintName("PreIncUint32");
42133	Text.Args.push_back(printArg<bool>(P, PC));
42134	break;
42135	case OP_PreIncSint64:
42136	Text.Op = PrintName("PreIncSint64");
42137	Text.Args.push_back(printArg<bool>(P, PC));
42138	break;
42139	case OP_PreIncUint64:
42140	Text.Op = PrintName("PreIncUint64");
42141	Text.Args.push_back(printArg<bool>(P, PC));
42142	break;
42143	case OP_PreIncIntAP:
42144	Text.Op = PrintName("PreIncIntAP");
42145	Text.Args.push_back(printArg<bool>(P, PC));
42146	break;
42147	case OP_PreIncIntAPS:
42148	Text.Op = PrintName("PreIncIntAPS");
42149	Text.Args.push_back(printArg<bool>(P, PC));
42150	break;
42151	case OP_PreIncBool:
42152	Text.Op = PrintName("PreIncBool");
42153	Text.Args.push_back(printArg<bool>(P, PC));
42154	break;
42155	case OP_PreIncFixedPoint:
42156	Text.Op = PrintName("PreIncFixedPoint");
42157	Text.Args.push_back(printArg<bool>(P, PC));
42158	break;
42159	#endif
42160	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42161	bool emitPreIncSint8( bool , SourceInfo);
42162	bool emitPreIncUint8( bool , SourceInfo);
42163	bool emitPreIncSint16( bool , SourceInfo);
42164	bool emitPreIncUint16( bool , SourceInfo);
42165	bool emitPreIncSint32( bool , SourceInfo);
42166	bool emitPreIncUint32( bool , SourceInfo);
42167	bool emitPreIncSint64( bool , SourceInfo);
42168	bool emitPreIncUint64( bool , SourceInfo);
42169	bool emitPreIncIntAP( bool , SourceInfo);
42170	bool emitPreIncIntAPS( bool , SourceInfo);
42171	bool emitPreIncBool( bool , SourceInfo);
42172	bool emitPreIncFixedPoint( bool , SourceInfo);
42173	#endif
42174	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42175	[[nodiscard]] bool emitPreInc(PrimType, bool, SourceInfo I);
42176	#endif
42177	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
42178	bool
42179	#if defined(GET_EVAL_IMPL)
42180	EvalEmitter
42181	#else
42182	ByteCodeEmitter
42183	#endif
42184	::emitPreInc(PrimType T0, bool A0, SourceInfo I) {
42185	switch (T0) {
42186	case PT_Sint8:
42187	return emitPreIncSint8(A0, I);
42188	case PT_Uint8:
42189	return emitPreIncUint8(A0, I);
42190	case PT_Sint16:
42191	return emitPreIncSint16(A0, I);
42192	case PT_Uint16:
42193	return emitPreIncUint16(A0, I);
42194	case PT_Sint32:
42195	return emitPreIncSint32(A0, I);
42196	case PT_Uint32:
42197	return emitPreIncUint32(A0, I);
42198	case PT_Sint64:
42199	return emitPreIncSint64(A0, I);
42200	case PT_Uint64:
42201	return emitPreIncUint64(A0, I);
42202	case PT_IntAP:
42203	return emitPreIncIntAP(A0, I);
42204	case PT_IntAPS:
42205	return emitPreIncIntAPS(A0, I);
42206	case PT_Bool:
42207	return emitPreIncBool(A0, I);
42208	case PT_FixedPoint:
42209	return emitPreIncFixedPoint(A0, I);
42210	default: llvm_unreachable("invalid type: emitPreInc");
42211	}
42212	llvm_unreachable("invalid enum value");
42213	}
42214	#endif
42215	#ifdef GET_LINK_IMPL
42216	bool ByteCodeEmitter::emitPreIncSint8( bool A0, SourceInfo L) {
42217	return emitOp<bool>(OP_PreIncSint8, A0, L);
42218	}
42219	bool ByteCodeEmitter::emitPreIncUint8( bool A0, SourceInfo L) {
42220	return emitOp<bool>(OP_PreIncUint8, A0, L);
42221	}
42222	bool ByteCodeEmitter::emitPreIncSint16( bool A0, SourceInfo L) {
42223	return emitOp<bool>(OP_PreIncSint16, A0, L);
42224	}
42225	bool ByteCodeEmitter::emitPreIncUint16( bool A0, SourceInfo L) {
42226	return emitOp<bool>(OP_PreIncUint16, A0, L);
42227	}
42228	bool ByteCodeEmitter::emitPreIncSint32( bool A0, SourceInfo L) {
42229	return emitOp<bool>(OP_PreIncSint32, A0, L);
42230	}
42231	bool ByteCodeEmitter::emitPreIncUint32( bool A0, SourceInfo L) {
42232	return emitOp<bool>(OP_PreIncUint32, A0, L);
42233	}
42234	bool ByteCodeEmitter::emitPreIncSint64( bool A0, SourceInfo L) {
42235	return emitOp<bool>(OP_PreIncSint64, A0, L);
42236	}
42237	bool ByteCodeEmitter::emitPreIncUint64( bool A0, SourceInfo L) {
42238	return emitOp<bool>(OP_PreIncUint64, A0, L);
42239	}
42240	bool ByteCodeEmitter::emitPreIncIntAP( bool A0, SourceInfo L) {
42241	return emitOp<bool>(OP_PreIncIntAP, A0, L);
42242	}
42243	bool ByteCodeEmitter::emitPreIncIntAPS( bool A0, SourceInfo L) {
42244	return emitOp<bool>(OP_PreIncIntAPS, A0, L);
42245	}
42246	bool ByteCodeEmitter::emitPreIncBool( bool A0, SourceInfo L) {
42247	return emitOp<bool>(OP_PreIncBool, A0, L);
42248	}
42249	bool ByteCodeEmitter::emitPreIncFixedPoint( bool A0, SourceInfo L) {
42250	return emitOp<bool>(OP_PreIncFixedPoint, A0, L);
42251	}
42252	#endif
42253	#ifdef GET_EVAL_IMPL
42254	bool EvalEmitter::emitPreIncSint8( bool A0, SourceInfo L) {
42255	if (!isActive()) return true;
42256	CurrentSource = L;
42257	return PreInc<PT_Sint8>(S, CodePtr(), A0);
42258	}
42259	bool EvalEmitter::emitPreIncUint8( bool A0, SourceInfo L) {
42260	if (!isActive()) return true;
42261	CurrentSource = L;
42262	return PreInc<PT_Uint8>(S, CodePtr(), A0);
42263	}
42264	bool EvalEmitter::emitPreIncSint16( bool A0, SourceInfo L) {
42265	if (!isActive()) return true;
42266	CurrentSource = L;
42267	return PreInc<PT_Sint16>(S, CodePtr(), A0);
42268	}
42269	bool EvalEmitter::emitPreIncUint16( bool A0, SourceInfo L) {
42270	if (!isActive()) return true;
42271	CurrentSource = L;
42272	return PreInc<PT_Uint16>(S, CodePtr(), A0);
42273	}
42274	bool EvalEmitter::emitPreIncSint32( bool A0, SourceInfo L) {
42275	if (!isActive()) return true;
42276	CurrentSource = L;
42277	return PreInc<PT_Sint32>(S, CodePtr(), A0);
42278	}
42279	bool EvalEmitter::emitPreIncUint32( bool A0, SourceInfo L) {
42280	if (!isActive()) return true;
42281	CurrentSource = L;
42282	return PreInc<PT_Uint32>(S, CodePtr(), A0);
42283	}
42284	bool EvalEmitter::emitPreIncSint64( bool A0, SourceInfo L) {
42285	if (!isActive()) return true;
42286	CurrentSource = L;
42287	return PreInc<PT_Sint64>(S, CodePtr(), A0);
42288	}
42289	bool EvalEmitter::emitPreIncUint64( bool A0, SourceInfo L) {
42290	if (!isActive()) return true;
42291	CurrentSource = L;
42292	return PreInc<PT_Uint64>(S, CodePtr(), A0);
42293	}
42294	bool EvalEmitter::emitPreIncIntAP( bool A0, SourceInfo L) {
42295	if (!isActive()) return true;
42296	CurrentSource = L;
42297	return PreInc<PT_IntAP>(S, CodePtr(), A0);
42298	}
42299	bool EvalEmitter::emitPreIncIntAPS( bool A0, SourceInfo L) {
42300	if (!isActive()) return true;
42301	CurrentSource = L;
42302	return PreInc<PT_IntAPS>(S, CodePtr(), A0);
42303	}
42304	bool EvalEmitter::emitPreIncBool( bool A0, SourceInfo L) {
42305	if (!isActive()) return true;
42306	CurrentSource = L;
42307	return PreInc<PT_Bool>(S, CodePtr(), A0);
42308	}
42309	bool EvalEmitter::emitPreIncFixedPoint( bool A0, SourceInfo L) {
42310	if (!isActive()) return true;
42311	CurrentSource = L;
42312	return PreInc<PT_FixedPoint>(S, CodePtr(), A0);
42313	}
42314	#endif
42315	#ifdef GET_OPCODE_NAMES
42316	OP_PreIncBitfieldSint8,
42317	OP_PreIncBitfieldUint8,
42318	OP_PreIncBitfieldSint16,
42319	OP_PreIncBitfieldUint16,
42320	OP_PreIncBitfieldSint32,
42321	OP_PreIncBitfieldUint32,
42322	OP_PreIncBitfieldSint64,
42323	OP_PreIncBitfieldUint64,
42324	OP_PreIncBitfieldIntAP,
42325	OP_PreIncBitfieldIntAPS,
42326	OP_PreIncBitfieldBool,
42327	OP_PreIncBitfieldFixedPoint,
42328	#endif
42329	#ifdef GET_INTERPFN_LIST
42330	&Interp_PreIncBitfieldSint8,
42331	&Interp_PreIncBitfieldUint8,
42332	&Interp_PreIncBitfieldSint16,
42333	&Interp_PreIncBitfieldUint16,
42334	&Interp_PreIncBitfieldSint32,
42335	&Interp_PreIncBitfieldUint32,
42336	&Interp_PreIncBitfieldSint64,
42337	&Interp_PreIncBitfieldUint64,
42338	&Interp_PreIncBitfieldIntAP,
42339	&Interp_PreIncBitfieldIntAPS,
42340	&Interp_PreIncBitfieldBool,
42341	&Interp_PreIncBitfieldFixedPoint,
42342	#endif
42343	#ifdef GET_INTERPFN_DISPATCHERS
42344	PRESERVE_NONE
42345	static bool Interp_PreIncBitfieldSint8(InterpState &S) {
42346	{
42347	CodePtr OpPC = S.PC;
42348	const auto V0 = ReadArg<bool>(S, S.PC);
42349	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42350	if (!PreIncBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
42351	}
42352	#if USE_TAILCALLS
42353	MUSTTAIL return InterpNext(S);
42354	#else
42355	return true;
42356	#endif
42357	}
42358	PRESERVE_NONE
42359	static bool Interp_PreIncBitfieldUint8(InterpState &S) {
42360	{
42361	CodePtr OpPC = S.PC;
42362	const auto V0 = ReadArg<bool>(S, S.PC);
42363	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42364	if (!PreIncBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
42365	}
42366	#if USE_TAILCALLS
42367	MUSTTAIL return InterpNext(S);
42368	#else
42369	return true;
42370	#endif
42371	}
42372	PRESERVE_NONE
42373	static bool Interp_PreIncBitfieldSint16(InterpState &S) {
42374	{
42375	CodePtr OpPC = S.PC;
42376	const auto V0 = ReadArg<bool>(S, S.PC);
42377	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42378	if (!PreIncBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
42379	}
42380	#if USE_TAILCALLS
42381	MUSTTAIL return InterpNext(S);
42382	#else
42383	return true;
42384	#endif
42385	}
42386	PRESERVE_NONE
42387	static bool Interp_PreIncBitfieldUint16(InterpState &S) {
42388	{
42389	CodePtr OpPC = S.PC;
42390	const auto V0 = ReadArg<bool>(S, S.PC);
42391	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42392	if (!PreIncBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
42393	}
42394	#if USE_TAILCALLS
42395	MUSTTAIL return InterpNext(S);
42396	#else
42397	return true;
42398	#endif
42399	}
42400	PRESERVE_NONE
42401	static bool Interp_PreIncBitfieldSint32(InterpState &S) {
42402	{
42403	CodePtr OpPC = S.PC;
42404	const auto V0 = ReadArg<bool>(S, S.PC);
42405	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42406	if (!PreIncBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
42407	}
42408	#if USE_TAILCALLS
42409	MUSTTAIL return InterpNext(S);
42410	#else
42411	return true;
42412	#endif
42413	}
42414	PRESERVE_NONE
42415	static bool Interp_PreIncBitfieldUint32(InterpState &S) {
42416	{
42417	CodePtr OpPC = S.PC;
42418	const auto V0 = ReadArg<bool>(S, S.PC);
42419	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42420	if (!PreIncBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
42421	}
42422	#if USE_TAILCALLS
42423	MUSTTAIL return InterpNext(S);
42424	#else
42425	return true;
42426	#endif
42427	}
42428	PRESERVE_NONE
42429	static bool Interp_PreIncBitfieldSint64(InterpState &S) {
42430	{
42431	CodePtr OpPC = S.PC;
42432	const auto V0 = ReadArg<bool>(S, S.PC);
42433	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42434	if (!PreIncBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
42435	}
42436	#if USE_TAILCALLS
42437	MUSTTAIL return InterpNext(S);
42438	#else
42439	return true;
42440	#endif
42441	}
42442	PRESERVE_NONE
42443	static bool Interp_PreIncBitfieldUint64(InterpState &S) {
42444	{
42445	CodePtr OpPC = S.PC;
42446	const auto V0 = ReadArg<bool>(S, S.PC);
42447	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42448	if (!PreIncBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
42449	}
42450	#if USE_TAILCALLS
42451	MUSTTAIL return InterpNext(S);
42452	#else
42453	return true;
42454	#endif
42455	}
42456	PRESERVE_NONE
42457	static bool Interp_PreIncBitfieldIntAP(InterpState &S) {
42458	{
42459	CodePtr OpPC = S.PC;
42460	const auto V0 = ReadArg<bool>(S, S.PC);
42461	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42462	if (!PreIncBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
42463	}
42464	#if USE_TAILCALLS
42465	MUSTTAIL return InterpNext(S);
42466	#else
42467	return true;
42468	#endif
42469	}
42470	PRESERVE_NONE
42471	static bool Interp_PreIncBitfieldIntAPS(InterpState &S) {
42472	{
42473	CodePtr OpPC = S.PC;
42474	const auto V0 = ReadArg<bool>(S, S.PC);
42475	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42476	if (!PreIncBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
42477	}
42478	#if USE_TAILCALLS
42479	MUSTTAIL return InterpNext(S);
42480	#else
42481	return true;
42482	#endif
42483	}
42484	PRESERVE_NONE
42485	static bool Interp_PreIncBitfieldBool(InterpState &S) {
42486	{
42487	CodePtr OpPC = S.PC;
42488	const auto V0 = ReadArg<bool>(S, S.PC);
42489	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42490	if (!PreIncBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
42491	}
42492	#if USE_TAILCALLS
42493	MUSTTAIL return InterpNext(S);
42494	#else
42495	return true;
42496	#endif
42497	}
42498	PRESERVE_NONE
42499	static bool Interp_PreIncBitfieldFixedPoint(InterpState &S) {
42500	{
42501	CodePtr OpPC = S.PC;
42502	const auto V0 = ReadArg<bool>(S, S.PC);
42503	const auto V1 = ReadArg<uint32_t>(S, S.PC);
42504	if (!PreIncBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
42505	}
42506	#if USE_TAILCALLS
42507	MUSTTAIL return InterpNext(S);
42508	#else
42509	return true;
42510	#endif
42511	}
42512	#endif
42513	#ifdef GET_DISASM
42514	case OP_PreIncBitfieldSint8:
42515	Text.Op = PrintName("PreIncBitfieldSint8");
42516	Text.Args.push_back(printArg<bool>(P, PC));
42517	Text.Args.push_back(printArg<uint32_t>(P, PC));
42518	break;
42519	case OP_PreIncBitfieldUint8:
42520	Text.Op = PrintName("PreIncBitfieldUint8");
42521	Text.Args.push_back(printArg<bool>(P, PC));
42522	Text.Args.push_back(printArg<uint32_t>(P, PC));
42523	break;
42524	case OP_PreIncBitfieldSint16:
42525	Text.Op = PrintName("PreIncBitfieldSint16");
42526	Text.Args.push_back(printArg<bool>(P, PC));
42527	Text.Args.push_back(printArg<uint32_t>(P, PC));
42528	break;
42529	case OP_PreIncBitfieldUint16:
42530	Text.Op = PrintName("PreIncBitfieldUint16");
42531	Text.Args.push_back(printArg<bool>(P, PC));
42532	Text.Args.push_back(printArg<uint32_t>(P, PC));
42533	break;
42534	case OP_PreIncBitfieldSint32:
42535	Text.Op = PrintName("PreIncBitfieldSint32");
42536	Text.Args.push_back(printArg<bool>(P, PC));
42537	Text.Args.push_back(printArg<uint32_t>(P, PC));
42538	break;
42539	case OP_PreIncBitfieldUint32:
42540	Text.Op = PrintName("PreIncBitfieldUint32");
42541	Text.Args.push_back(printArg<bool>(P, PC));
42542	Text.Args.push_back(printArg<uint32_t>(P, PC));
42543	break;
42544	case OP_PreIncBitfieldSint64:
42545	Text.Op = PrintName("PreIncBitfieldSint64");
42546	Text.Args.push_back(printArg<bool>(P, PC));
42547	Text.Args.push_back(printArg<uint32_t>(P, PC));
42548	break;
42549	case OP_PreIncBitfieldUint64:
42550	Text.Op = PrintName("PreIncBitfieldUint64");
42551	Text.Args.push_back(printArg<bool>(P, PC));
42552	Text.Args.push_back(printArg<uint32_t>(P, PC));
42553	break;
42554	case OP_PreIncBitfieldIntAP:
42555	Text.Op = PrintName("PreIncBitfieldIntAP");
42556	Text.Args.push_back(printArg<bool>(P, PC));
42557	Text.Args.push_back(printArg<uint32_t>(P, PC));
42558	break;
42559	case OP_PreIncBitfieldIntAPS:
42560	Text.Op = PrintName("PreIncBitfieldIntAPS");
42561	Text.Args.push_back(printArg<bool>(P, PC));
42562	Text.Args.push_back(printArg<uint32_t>(P, PC));
42563	break;
42564	case OP_PreIncBitfieldBool:
42565	Text.Op = PrintName("PreIncBitfieldBool");
42566	Text.Args.push_back(printArg<bool>(P, PC));
42567	Text.Args.push_back(printArg<uint32_t>(P, PC));
42568	break;
42569	case OP_PreIncBitfieldFixedPoint:
42570	Text.Op = PrintName("PreIncBitfieldFixedPoint");
42571	Text.Args.push_back(printArg<bool>(P, PC));
42572	Text.Args.push_back(printArg<uint32_t>(P, PC));
42573	break;
42574	#endif
42575	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42576	bool emitPreIncBitfieldSint8( bool , uint32_t , SourceInfo);
42577	bool emitPreIncBitfieldUint8( bool , uint32_t , SourceInfo);
42578	bool emitPreIncBitfieldSint16( bool , uint32_t , SourceInfo);
42579	bool emitPreIncBitfieldUint16( bool , uint32_t , SourceInfo);
42580	bool emitPreIncBitfieldSint32( bool , uint32_t , SourceInfo);
42581	bool emitPreIncBitfieldUint32( bool , uint32_t , SourceInfo);
42582	bool emitPreIncBitfieldSint64( bool , uint32_t , SourceInfo);
42583	bool emitPreIncBitfieldUint64( bool , uint32_t , SourceInfo);
42584	bool emitPreIncBitfieldIntAP( bool , uint32_t , SourceInfo);
42585	bool emitPreIncBitfieldIntAPS( bool , uint32_t , SourceInfo);
42586	bool emitPreIncBitfieldBool( bool , uint32_t , SourceInfo);
42587	bool emitPreIncBitfieldFixedPoint( bool , uint32_t , SourceInfo);
42588	#endif
42589	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42590	[[nodiscard]] bool emitPreIncBitfield(PrimType, bool, uint32_t, SourceInfo I);
42591	#endif
42592	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
42593	bool
42594	#if defined(GET_EVAL_IMPL)
42595	EvalEmitter
42596	#else
42597	ByteCodeEmitter
42598	#endif
42599	::emitPreIncBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
42600	switch (T0) {
42601	case PT_Sint8:
42602	return emitPreIncBitfieldSint8(A0, A1, I);
42603	case PT_Uint8:
42604	return emitPreIncBitfieldUint8(A0, A1, I);
42605	case PT_Sint16:
42606	return emitPreIncBitfieldSint16(A0, A1, I);
42607	case PT_Uint16:
42608	return emitPreIncBitfieldUint16(A0, A1, I);
42609	case PT_Sint32:
42610	return emitPreIncBitfieldSint32(A0, A1, I);
42611	case PT_Uint32:
42612	return emitPreIncBitfieldUint32(A0, A1, I);
42613	case PT_Sint64:
42614	return emitPreIncBitfieldSint64(A0, A1, I);
42615	case PT_Uint64:
42616	return emitPreIncBitfieldUint64(A0, A1, I);
42617	case PT_IntAP:
42618	return emitPreIncBitfieldIntAP(A0, A1, I);
42619	case PT_IntAPS:
42620	return emitPreIncBitfieldIntAPS(A0, A1, I);
42621	case PT_Bool:
42622	return emitPreIncBitfieldBool(A0, A1, I);
42623	case PT_FixedPoint:
42624	return emitPreIncBitfieldFixedPoint(A0, A1, I);
42625	default: llvm_unreachable("invalid type: emitPreIncBitfield");
42626	}
42627	llvm_unreachable("invalid enum value");
42628	}
42629	#endif
42630	#ifdef GET_LINK_IMPL
42631	bool ByteCodeEmitter::emitPreIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
42632	return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint8, A0, A1, L);
42633	}
42634	bool ByteCodeEmitter::emitPreIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
42635	return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint8, A0, A1, L);
42636	}
42637	bool ByteCodeEmitter::emitPreIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
42638	return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint16, A0, A1, L);
42639	}
42640	bool ByteCodeEmitter::emitPreIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
42641	return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint16, A0, A1, L);
42642	}
42643	bool ByteCodeEmitter::emitPreIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
42644	return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint32, A0, A1, L);
42645	}
42646	bool ByteCodeEmitter::emitPreIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
42647	return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint32, A0, A1, L);
42648	}
42649	bool ByteCodeEmitter::emitPreIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
42650	return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint64, A0, A1, L);
42651	}
42652	bool ByteCodeEmitter::emitPreIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
42653	return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint64, A0, A1, L);
42654	}
42655	bool ByteCodeEmitter::emitPreIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
42656	return emitOp<bool, uint32_t>(OP_PreIncBitfieldIntAP, A0, A1, L);
42657	}
42658	bool ByteCodeEmitter::emitPreIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
42659	return emitOp<bool, uint32_t>(OP_PreIncBitfieldIntAPS, A0, A1, L);
42660	}
42661	bool ByteCodeEmitter::emitPreIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
42662	return emitOp<bool, uint32_t>(OP_PreIncBitfieldBool, A0, A1, L);
42663	}
42664	bool ByteCodeEmitter::emitPreIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
42665	return emitOp<bool, uint32_t>(OP_PreIncBitfieldFixedPoint, A0, A1, L);
42666	}
42667	#endif
42668	#ifdef GET_EVAL_IMPL
42669	bool EvalEmitter::emitPreIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
42670	if (!isActive()) return true;
42671	CurrentSource = L;
42672	return PreIncBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
42673	}
42674	bool EvalEmitter::emitPreIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
42675	if (!isActive()) return true;
42676	CurrentSource = L;
42677	return PreIncBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
42678	}
42679	bool EvalEmitter::emitPreIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
42680	if (!isActive()) return true;
42681	CurrentSource = L;
42682	return PreIncBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
42683	}
42684	bool EvalEmitter::emitPreIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
42685	if (!isActive()) return true;
42686	CurrentSource = L;
42687	return PreIncBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
42688	}
42689	bool EvalEmitter::emitPreIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
42690	if (!isActive()) return true;
42691	CurrentSource = L;
42692	return PreIncBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
42693	}
42694	bool EvalEmitter::emitPreIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
42695	if (!isActive()) return true;
42696	CurrentSource = L;
42697	return PreIncBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
42698	}
42699	bool EvalEmitter::emitPreIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
42700	if (!isActive()) return true;
42701	CurrentSource = L;
42702	return PreIncBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
42703	}
42704	bool EvalEmitter::emitPreIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
42705	if (!isActive()) return true;
42706	CurrentSource = L;
42707	return PreIncBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
42708	}
42709	bool EvalEmitter::emitPreIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
42710	if (!isActive()) return true;
42711	CurrentSource = L;
42712	return PreIncBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
42713	}
42714	bool EvalEmitter::emitPreIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
42715	if (!isActive()) return true;
42716	CurrentSource = L;
42717	return PreIncBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
42718	}
42719	bool EvalEmitter::emitPreIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
42720	if (!isActive()) return true;
42721	CurrentSource = L;
42722	return PreIncBitfield<PT_Bool>(S, CodePtr(), A0, A1);
42723	}
42724	bool EvalEmitter::emitPreIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
42725	if (!isActive()) return true;
42726	CurrentSource = L;
42727	return PreIncBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
42728	}
42729	#endif
42730	#ifdef GET_OPCODE_NAMES
42731	OP_PseudoDtor,
42732	#endif
42733	#ifdef GET_INTERPFN_LIST
42734	&Interp_PseudoDtor,
42735	#endif
42736	#ifdef GET_INTERPFN_DISPATCHERS
42737	PRESERVE_NONE
42738	static bool Interp_PseudoDtor(InterpState &S) {
42739	if (!PseudoDtor(S, S.PC)) return false;
42740	#if USE_TAILCALLS
42741	MUSTTAIL return InterpNext(S);
42742	#else
42743	return true;
42744	#endif
42745	}
42746	#endif
42747	#ifdef GET_DISASM
42748	case OP_PseudoDtor:
42749	Text.Op = PrintName("PseudoDtor");
42750	break;
42751	#endif
42752	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42753	bool emitPseudoDtor(SourceInfo);
42754	#endif
42755	#ifdef GET_LINK_IMPL
42756	bool ByteCodeEmitter::emitPseudoDtor(SourceInfo L) {
42757	return emitOp<>(OP_PseudoDtor, L);
42758	}
42759	#endif
42760	#ifdef GET_EVAL_IMPL
42761	bool EvalEmitter::emitPseudoDtor(SourceInfo L) {
42762	if (!isActive()) return true;
42763	CurrentSource = L;
42764	return PseudoDtor(S, CodePtr());
42765	}
42766	#endif
42767	#ifdef GET_OPCODE_NAMES
42768	OP_PtrPtrCast,
42769	#endif
42770	#ifdef GET_INTERPFN_LIST
42771	&Interp_PtrPtrCast,
42772	#endif
42773	#ifdef GET_INTERPFN_DISPATCHERS
42774	PRESERVE_NONE
42775	static bool Interp_PtrPtrCast(InterpState &S) {
42776	{
42777	CodePtr OpPC = S.PC;
42778	const auto V0 = ReadArg<bool>(S, S.PC);
42779	if (!PtrPtrCast(S, OpPC, V0)) return false;
42780	}
42781	#if USE_TAILCALLS
42782	MUSTTAIL return InterpNext(S);
42783	#else
42784	return true;
42785	#endif
42786	}
42787	#endif
42788	#ifdef GET_DISASM
42789	case OP_PtrPtrCast:
42790	Text.Op = PrintName("PtrPtrCast");
42791	Text.Args.push_back(printArg<bool>(P, PC));
42792	break;
42793	#endif
42794	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42795	bool emitPtrPtrCast( bool , SourceInfo);
42796	#endif
42797	#ifdef GET_LINK_IMPL
42798	bool ByteCodeEmitter::emitPtrPtrCast( bool A0, SourceInfo L) {
42799	return emitOp<bool>(OP_PtrPtrCast, A0, L);
42800	}
42801	#endif
42802	#ifdef GET_EVAL_IMPL
42803	bool EvalEmitter::emitPtrPtrCast( bool A0, SourceInfo L) {
42804	if (!isActive()) return true;
42805	CurrentSource = L;
42806	return PtrPtrCast(S, CodePtr(), A0);
42807	}
42808	#endif
42809	#ifdef GET_OPCODE_NAMES
42810	OP_PushCC,
42811	#endif
42812	#ifdef GET_INTERPFN_LIST
42813	&Interp_PushCC,
42814	#endif
42815	#ifdef GET_INTERPFN_DISPATCHERS
42816	PRESERVE_NONE
42817	static bool Interp_PushCC(InterpState &S) {
42818	{
42819	const auto V0 = ReadArg<bool>(S, S.PC);
42820	PushCC(S, V0);
42821	}
42822	#if USE_TAILCALLS
42823	MUSTTAIL return InterpNext(S);
42824	#else
42825	return true;
42826	#endif
42827	}
42828	#endif
42829	#ifdef GET_DISASM
42830	case OP_PushCC:
42831	Text.Op = PrintName("PushCC");
42832	Text.Args.push_back(printArg<bool>(P, PC));
42833	break;
42834	#endif
42835	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42836	bool emitPushCC( bool , SourceInfo);
42837	#endif
42838	#ifdef GET_LINK_IMPL
42839	bool ByteCodeEmitter::emitPushCC( bool A0, SourceInfo L) {
42840	return emitOp<bool>(OP_PushCC, A0, L);
42841	}
42842	#endif
42843	#ifdef GET_EVAL_IMPL
42844	bool EvalEmitter::emitPushCC( bool A0, SourceInfo L) {
42845	if (!isActive()) return true;
42846	CurrentSource = L;
42847	return PushCC(S, A0);
42848	}
42849	#endif
42850	#ifdef GET_OPCODE_NAMES
42851	OP_PushIgnoreDiags,
42852	#endif
42853	#ifdef GET_INTERPFN_LIST
42854	&Interp_PushIgnoreDiags,
42855	#endif
42856	#ifdef GET_INTERPFN_DISPATCHERS
42857	PRESERVE_NONE
42858	static bool Interp_PushIgnoreDiags(InterpState &S) {
42859	PushIgnoreDiags(S);
42860	#if USE_TAILCALLS
42861	MUSTTAIL return InterpNext(S);
42862	#else
42863	return true;
42864	#endif
42865	}
42866	#endif
42867	#ifdef GET_DISASM
42868	case OP_PushIgnoreDiags:
42869	Text.Op = PrintName("PushIgnoreDiags");
42870	break;
42871	#endif
42872	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42873	bool emitPushIgnoreDiags(SourceInfo);
42874	#endif
42875	#ifdef GET_LINK_IMPL
42876	bool ByteCodeEmitter::emitPushIgnoreDiags(SourceInfo L) {
42877	return emitOp<>(OP_PushIgnoreDiags, L);
42878	}
42879	#endif
42880	#ifdef GET_EVAL_IMPL
42881	bool EvalEmitter::emitPushIgnoreDiags(SourceInfo L) {
42882	if (!isActive()) return true;
42883	CurrentSource = L;
42884	return PushIgnoreDiags(S);
42885	}
42886	#endif
42887	#ifdef GET_OPCODE_NAMES
42888	OP_PushMSVCCE,
42889	#endif
42890	#ifdef GET_INTERPFN_LIST
42891	&Interp_PushMSVCCE,
42892	#endif
42893	#ifdef GET_INTERPFN_DISPATCHERS
42894	PRESERVE_NONE
42895	static bool Interp_PushMSVCCE(InterpState &S) {
42896	PushMSVCCE(S);
42897	#if USE_TAILCALLS
42898	MUSTTAIL return InterpNext(S);
42899	#else
42900	return true;
42901	#endif
42902	}
42903	#endif
42904	#ifdef GET_DISASM
42905	case OP_PushMSVCCE:
42906	Text.Op = PrintName("PushMSVCCE");
42907	break;
42908	#endif
42909	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42910	bool emitPushMSVCCE(SourceInfo);
42911	#endif
42912	#ifdef GET_LINK_IMPL
42913	bool ByteCodeEmitter::emitPushMSVCCE(SourceInfo L) {
42914	return emitOp<>(OP_PushMSVCCE, L);
42915	}
42916	#endif
42917	#ifdef GET_EVAL_IMPL
42918	bool EvalEmitter::emitPushMSVCCE(SourceInfo L) {
42919	if (!isActive()) return true;
42920	CurrentSource = L;
42921	return PushMSVCCE(S);
42922	}
42923	#endif
42924	#ifdef GET_OPCODE_NAMES
42925	OP_RVOPtr,
42926	#endif
42927	#ifdef GET_INTERPFN_LIST
42928	&Interp_RVOPtr,
42929	#endif
42930	#ifdef GET_INTERPFN_DISPATCHERS
42931	PRESERVE_NONE
42932	static bool Interp_RVOPtr(InterpState &S) {
42933	if (!RVOPtr(S)) return false;
42934	#if USE_TAILCALLS
42935	MUSTTAIL return InterpNext(S);
42936	#else
42937	return true;
42938	#endif
42939	}
42940	#endif
42941	#ifdef GET_DISASM
42942	case OP_RVOPtr:
42943	Text.Op = PrintName("RVOPtr");
42944	break;
42945	#endif
42946	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
42947	bool emitRVOPtr(SourceInfo);
42948	#endif
42949	#ifdef GET_LINK_IMPL
42950	bool ByteCodeEmitter::emitRVOPtr(SourceInfo L) {
42951	return emitOp<>(OP_RVOPtr, L);
42952	}
42953	#endif
42954	#ifdef GET_EVAL_IMPL
42955	bool EvalEmitter::emitRVOPtr(SourceInfo L) {
42956	if (!isActive()) return true;
42957	CurrentSource = L;
42958	return RVOPtr(S);
42959	}
42960	#endif
42961	#ifdef GET_OPCODE_NAMES
42962	OP_RemSint8,
42963	OP_RemUint8,
42964	OP_RemSint16,
42965	OP_RemUint16,
42966	OP_RemSint32,
42967	OP_RemUint32,
42968	OP_RemSint64,
42969	OP_RemUint64,
42970	OP_RemIntAP,
42971	OP_RemIntAPS,
42972	OP_RemFixedPoint,
42973	#endif
42974	#ifdef GET_INTERPFN_LIST
42975	&Interp_RemSint8,
42976	&Interp_RemUint8,
42977	&Interp_RemSint16,
42978	&Interp_RemUint16,
42979	&Interp_RemSint32,
42980	&Interp_RemUint32,
42981	&Interp_RemSint64,
42982	&Interp_RemUint64,
42983	&Interp_RemIntAP,
42984	&Interp_RemIntAPS,
42985	&Interp_RemFixedPoint,
42986	#endif
42987	#ifdef GET_INTERPFN_DISPATCHERS
42988	PRESERVE_NONE
42989	static bool Interp_RemSint8(InterpState &S) {
42990	if (!Rem<PT_Sint8>(S, S.PC)) return false;
42991	#if USE_TAILCALLS
42992	MUSTTAIL return InterpNext(S);
42993	#else
42994	return true;
42995	#endif
42996	}
42997	PRESERVE_NONE
42998	static bool Interp_RemUint8(InterpState &S) {
42999	if (!Rem<PT_Uint8>(S, S.PC)) return false;
43000	#if USE_TAILCALLS
43001	MUSTTAIL return InterpNext(S);
43002	#else
43003	return true;
43004	#endif
43005	}
43006	PRESERVE_NONE
43007	static bool Interp_RemSint16(InterpState &S) {
43008	if (!Rem<PT_Sint16>(S, S.PC)) return false;
43009	#if USE_TAILCALLS
43010	MUSTTAIL return InterpNext(S);
43011	#else
43012	return true;
43013	#endif
43014	}
43015	PRESERVE_NONE
43016	static bool Interp_RemUint16(InterpState &S) {
43017	if (!Rem<PT_Uint16>(S, S.PC)) return false;
43018	#if USE_TAILCALLS
43019	MUSTTAIL return InterpNext(S);
43020	#else
43021	return true;
43022	#endif
43023	}
43024	PRESERVE_NONE
43025	static bool Interp_RemSint32(InterpState &S) {
43026	if (!Rem<PT_Sint32>(S, S.PC)) return false;
43027	#if USE_TAILCALLS
43028	MUSTTAIL return InterpNext(S);
43029	#else
43030	return true;
43031	#endif
43032	}
43033	PRESERVE_NONE
43034	static bool Interp_RemUint32(InterpState &S) {
43035	if (!Rem<PT_Uint32>(S, S.PC)) return false;
43036	#if USE_TAILCALLS
43037	MUSTTAIL return InterpNext(S);
43038	#else
43039	return true;
43040	#endif
43041	}
43042	PRESERVE_NONE
43043	static bool Interp_RemSint64(InterpState &S) {
43044	if (!Rem<PT_Sint64>(S, S.PC)) return false;
43045	#if USE_TAILCALLS
43046	MUSTTAIL return InterpNext(S);
43047	#else
43048	return true;
43049	#endif
43050	}
43051	PRESERVE_NONE
43052	static bool Interp_RemUint64(InterpState &S) {
43053	if (!Rem<PT_Uint64>(S, S.PC)) return false;
43054	#if USE_TAILCALLS
43055	MUSTTAIL return InterpNext(S);
43056	#else
43057	return true;
43058	#endif
43059	}
43060	PRESERVE_NONE
43061	static bool Interp_RemIntAP(InterpState &S) {
43062	if (!Rem<PT_IntAP>(S, S.PC)) return false;
43063	#if USE_TAILCALLS
43064	MUSTTAIL return InterpNext(S);
43065	#else
43066	return true;
43067	#endif
43068	}
43069	PRESERVE_NONE
43070	static bool Interp_RemIntAPS(InterpState &S) {
43071	if (!Rem<PT_IntAPS>(S, S.PC)) return false;
43072	#if USE_TAILCALLS
43073	MUSTTAIL return InterpNext(S);
43074	#else
43075	return true;
43076	#endif
43077	}
43078	PRESERVE_NONE
43079	static bool Interp_RemFixedPoint(InterpState &S) {
43080	if (!Rem<PT_FixedPoint>(S, S.PC)) return false;
43081	#if USE_TAILCALLS
43082	MUSTTAIL return InterpNext(S);
43083	#else
43084	return true;
43085	#endif
43086	}
43087	#endif
43088	#ifdef GET_DISASM
43089	case OP_RemSint8:
43090	Text.Op = PrintName("RemSint8");
43091	break;
43092	case OP_RemUint8:
43093	Text.Op = PrintName("RemUint8");
43094	break;
43095	case OP_RemSint16:
43096	Text.Op = PrintName("RemSint16");
43097	break;
43098	case OP_RemUint16:
43099	Text.Op = PrintName("RemUint16");
43100	break;
43101	case OP_RemSint32:
43102	Text.Op = PrintName("RemSint32");
43103	break;
43104	case OP_RemUint32:
43105	Text.Op = PrintName("RemUint32");
43106	break;
43107	case OP_RemSint64:
43108	Text.Op = PrintName("RemSint64");
43109	break;
43110	case OP_RemUint64:
43111	Text.Op = PrintName("RemUint64");
43112	break;
43113	case OP_RemIntAP:
43114	Text.Op = PrintName("RemIntAP");
43115	break;
43116	case OP_RemIntAPS:
43117	Text.Op = PrintName("RemIntAPS");
43118	break;
43119	case OP_RemFixedPoint:
43120	Text.Op = PrintName("RemFixedPoint");
43121	break;
43122	#endif
43123	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43124	bool emitRemSint8(SourceInfo);
43125	bool emitRemUint8(SourceInfo);
43126	bool emitRemSint16(SourceInfo);
43127	bool emitRemUint16(SourceInfo);
43128	bool emitRemSint32(SourceInfo);
43129	bool emitRemUint32(SourceInfo);
43130	bool emitRemSint64(SourceInfo);
43131	bool emitRemUint64(SourceInfo);
43132	bool emitRemIntAP(SourceInfo);
43133	bool emitRemIntAPS(SourceInfo);
43134	bool emitRemFixedPoint(SourceInfo);
43135	#endif
43136	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43137	[[nodiscard]] bool emitRem(PrimType, SourceInfo I);
43138	#endif
43139	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
43140	bool
43141	#if defined(GET_EVAL_IMPL)
43142	EvalEmitter
43143	#else
43144	ByteCodeEmitter
43145	#endif
43146	::emitRem(PrimType T0, SourceInfo I) {
43147	switch (T0) {
43148	case PT_Sint8:
43149	return emitRemSint8(I);
43150	case PT_Uint8:
43151	return emitRemUint8(I);
43152	case PT_Sint16:
43153	return emitRemSint16(I);
43154	case PT_Uint16:
43155	return emitRemUint16(I);
43156	case PT_Sint32:
43157	return emitRemSint32(I);
43158	case PT_Uint32:
43159	return emitRemUint32(I);
43160	case PT_Sint64:
43161	return emitRemSint64(I);
43162	case PT_Uint64:
43163	return emitRemUint64(I);
43164	case PT_IntAP:
43165	return emitRemIntAP(I);
43166	case PT_IntAPS:
43167	return emitRemIntAPS(I);
43168	case PT_FixedPoint:
43169	return emitRemFixedPoint(I);
43170	default: llvm_unreachable("invalid type: emitRem");
43171	}
43172	llvm_unreachable("invalid enum value");
43173	}
43174	#endif
43175	#ifdef GET_LINK_IMPL
43176	bool ByteCodeEmitter::emitRemSint8(SourceInfo L) {
43177	return emitOp<>(OP_RemSint8, L);
43178	}
43179	bool ByteCodeEmitter::emitRemUint8(SourceInfo L) {
43180	return emitOp<>(OP_RemUint8, L);
43181	}
43182	bool ByteCodeEmitter::emitRemSint16(SourceInfo L) {
43183	return emitOp<>(OP_RemSint16, L);
43184	}
43185	bool ByteCodeEmitter::emitRemUint16(SourceInfo L) {
43186	return emitOp<>(OP_RemUint16, L);
43187	}
43188	bool ByteCodeEmitter::emitRemSint32(SourceInfo L) {
43189	return emitOp<>(OP_RemSint32, L);
43190	}
43191	bool ByteCodeEmitter::emitRemUint32(SourceInfo L) {
43192	return emitOp<>(OP_RemUint32, L);
43193	}
43194	bool ByteCodeEmitter::emitRemSint64(SourceInfo L) {
43195	return emitOp<>(OP_RemSint64, L);
43196	}
43197	bool ByteCodeEmitter::emitRemUint64(SourceInfo L) {
43198	return emitOp<>(OP_RemUint64, L);
43199	}
43200	bool ByteCodeEmitter::emitRemIntAP(SourceInfo L) {
43201	return emitOp<>(OP_RemIntAP, L);
43202	}
43203	bool ByteCodeEmitter::emitRemIntAPS(SourceInfo L) {
43204	return emitOp<>(OP_RemIntAPS, L);
43205	}
43206	bool ByteCodeEmitter::emitRemFixedPoint(SourceInfo L) {
43207	return emitOp<>(OP_RemFixedPoint, L);
43208	}
43209	#endif
43210	#ifdef GET_EVAL_IMPL
43211	bool EvalEmitter::emitRemSint8(SourceInfo L) {
43212	if (!isActive()) return true;
43213	CurrentSource = L;
43214	return Rem<PT_Sint8>(S, CodePtr());
43215	}
43216	bool EvalEmitter::emitRemUint8(SourceInfo L) {
43217	if (!isActive()) return true;
43218	CurrentSource = L;
43219	return Rem<PT_Uint8>(S, CodePtr());
43220	}
43221	bool EvalEmitter::emitRemSint16(SourceInfo L) {
43222	if (!isActive()) return true;
43223	CurrentSource = L;
43224	return Rem<PT_Sint16>(S, CodePtr());
43225	}
43226	bool EvalEmitter::emitRemUint16(SourceInfo L) {
43227	if (!isActive()) return true;
43228	CurrentSource = L;
43229	return Rem<PT_Uint16>(S, CodePtr());
43230	}
43231	bool EvalEmitter::emitRemSint32(SourceInfo L) {
43232	if (!isActive()) return true;
43233	CurrentSource = L;
43234	return Rem<PT_Sint32>(S, CodePtr());
43235	}
43236	bool EvalEmitter::emitRemUint32(SourceInfo L) {
43237	if (!isActive()) return true;
43238	CurrentSource = L;
43239	return Rem<PT_Uint32>(S, CodePtr());
43240	}
43241	bool EvalEmitter::emitRemSint64(SourceInfo L) {
43242	if (!isActive()) return true;
43243	CurrentSource = L;
43244	return Rem<PT_Sint64>(S, CodePtr());
43245	}
43246	bool EvalEmitter::emitRemUint64(SourceInfo L) {
43247	if (!isActive()) return true;
43248	CurrentSource = L;
43249	return Rem<PT_Uint64>(S, CodePtr());
43250	}
43251	bool EvalEmitter::emitRemIntAP(SourceInfo L) {
43252	if (!isActive()) return true;
43253	CurrentSource = L;
43254	return Rem<PT_IntAP>(S, CodePtr());
43255	}
43256	bool EvalEmitter::emitRemIntAPS(SourceInfo L) {
43257	if (!isActive()) return true;
43258	CurrentSource = L;
43259	return Rem<PT_IntAPS>(S, CodePtr());
43260	}
43261	bool EvalEmitter::emitRemFixedPoint(SourceInfo L) {
43262	if (!isActive()) return true;
43263	CurrentSource = L;
43264	return Rem<PT_FixedPoint>(S, CodePtr());
43265	}
43266	#endif
43267	#ifdef GET_OPCODE_NAMES
43268	OP_RetSint8,
43269	OP_RetUint8,
43270	OP_RetSint16,
43271	OP_RetUint16,
43272	OP_RetSint32,
43273	OP_RetUint32,
43274	OP_RetSint64,
43275	OP_RetUint64,
43276	OP_RetIntAP,
43277	OP_RetIntAPS,
43278	OP_RetBool,
43279	OP_RetFixedPoint,
43280	OP_RetPtr,
43281	OP_RetMemberPtr,
43282	OP_RetFloat,
43283	#endif
43284	#ifdef GET_INTERPFN_LIST
43285	&Interp_RetSint8,
43286	&Interp_RetUint8,
43287	&Interp_RetSint16,
43288	&Interp_RetUint16,
43289	&Interp_RetSint32,
43290	&Interp_RetUint32,
43291	&Interp_RetSint64,
43292	&Interp_RetUint64,
43293	&Interp_RetIntAP,
43294	&Interp_RetIntAPS,
43295	&Interp_RetBool,
43296	&Interp_RetFixedPoint,
43297	&Interp_RetPtr,
43298	&Interp_RetMemberPtr,
43299	&Interp_RetFloat,
43300	#endif
43301	#ifdef GET_INTERPFN_DISPATCHERS
43302	PRESERVE_NONE
43303	static bool Interp_RetSint8(InterpState &S) {
43304	MUSTTAIL return Ret<PT_Sint8>(S);
43305	}
43306	PRESERVE_NONE
43307	static bool Interp_RetUint8(InterpState &S) {
43308	MUSTTAIL return Ret<PT_Uint8>(S);
43309	}
43310	PRESERVE_NONE
43311	static bool Interp_RetSint16(InterpState &S) {
43312	MUSTTAIL return Ret<PT_Sint16>(S);
43313	}
43314	PRESERVE_NONE
43315	static bool Interp_RetUint16(InterpState &S) {
43316	MUSTTAIL return Ret<PT_Uint16>(S);
43317	}
43318	PRESERVE_NONE
43319	static bool Interp_RetSint32(InterpState &S) {
43320	MUSTTAIL return Ret<PT_Sint32>(S);
43321	}
43322	PRESERVE_NONE
43323	static bool Interp_RetUint32(InterpState &S) {
43324	MUSTTAIL return Ret<PT_Uint32>(S);
43325	}
43326	PRESERVE_NONE
43327	static bool Interp_RetSint64(InterpState &S) {
43328	MUSTTAIL return Ret<PT_Sint64>(S);
43329	}
43330	PRESERVE_NONE
43331	static bool Interp_RetUint64(InterpState &S) {
43332	MUSTTAIL return Ret<PT_Uint64>(S);
43333	}
43334	PRESERVE_NONE
43335	static bool Interp_RetIntAP(InterpState &S) {
43336	MUSTTAIL return Ret<PT_IntAP>(S);
43337	}
43338	PRESERVE_NONE
43339	static bool Interp_RetIntAPS(InterpState &S) {
43340	MUSTTAIL return Ret<PT_IntAPS>(S);
43341	}
43342	PRESERVE_NONE
43343	static bool Interp_RetBool(InterpState &S) {
43344	MUSTTAIL return Ret<PT_Bool>(S);
43345	}
43346	PRESERVE_NONE
43347	static bool Interp_RetFixedPoint(InterpState &S) {
43348	MUSTTAIL return Ret<PT_FixedPoint>(S);
43349	}
43350	PRESERVE_NONE
43351	static bool Interp_RetPtr(InterpState &S) {
43352	MUSTTAIL return Ret<PT_Ptr>(S);
43353	}
43354	PRESERVE_NONE
43355	static bool Interp_RetMemberPtr(InterpState &S) {
43356	MUSTTAIL return Ret<PT_MemberPtr>(S);
43357	}
43358	PRESERVE_NONE
43359	static bool Interp_RetFloat(InterpState &S) {
43360	MUSTTAIL return Ret<PT_Float>(S);
43361	}
43362	#endif
43363	#ifdef GET_DISASM
43364	case OP_RetSint8:
43365	Text.Op = PrintName("RetSint8");
43366	break;
43367	case OP_RetUint8:
43368	Text.Op = PrintName("RetUint8");
43369	break;
43370	case OP_RetSint16:
43371	Text.Op = PrintName("RetSint16");
43372	break;
43373	case OP_RetUint16:
43374	Text.Op = PrintName("RetUint16");
43375	break;
43376	case OP_RetSint32:
43377	Text.Op = PrintName("RetSint32");
43378	break;
43379	case OP_RetUint32:
43380	Text.Op = PrintName("RetUint32");
43381	break;
43382	case OP_RetSint64:
43383	Text.Op = PrintName("RetSint64");
43384	break;
43385	case OP_RetUint64:
43386	Text.Op = PrintName("RetUint64");
43387	break;
43388	case OP_RetIntAP:
43389	Text.Op = PrintName("RetIntAP");
43390	break;
43391	case OP_RetIntAPS:
43392	Text.Op = PrintName("RetIntAPS");
43393	break;
43394	case OP_RetBool:
43395	Text.Op = PrintName("RetBool");
43396	break;
43397	case OP_RetFixedPoint:
43398	Text.Op = PrintName("RetFixedPoint");
43399	break;
43400	case OP_RetPtr:
43401	Text.Op = PrintName("RetPtr");
43402	break;
43403	case OP_RetMemberPtr:
43404	Text.Op = PrintName("RetMemberPtr");
43405	break;
43406	case OP_RetFloat:
43407	Text.Op = PrintName("RetFloat");
43408	break;
43409	#endif
43410	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43411	bool emitRetSint8(SourceInfo);
43412	bool emitRetUint8(SourceInfo);
43413	bool emitRetSint16(SourceInfo);
43414	bool emitRetUint16(SourceInfo);
43415	bool emitRetSint32(SourceInfo);
43416	bool emitRetUint32(SourceInfo);
43417	bool emitRetSint64(SourceInfo);
43418	bool emitRetUint64(SourceInfo);
43419	bool emitRetIntAP(SourceInfo);
43420	bool emitRetIntAPS(SourceInfo);
43421	bool emitRetBool(SourceInfo);
43422	bool emitRetFixedPoint(SourceInfo);
43423	bool emitRetPtr(SourceInfo);
43424	bool emitRetMemberPtr(SourceInfo);
43425	bool emitRetFloat(SourceInfo);
43426	#if defined(GET_EVAL_PROTO)
43427	template<PrimType>
43428	bool emitRet(SourceInfo);
43429	#endif
43430	#endif
43431	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43432	[[nodiscard]] bool emitRet(PrimType, SourceInfo I);
43433	#endif
43434	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
43435	bool
43436	#if defined(GET_EVAL_IMPL)
43437	EvalEmitter
43438	#else
43439	ByteCodeEmitter
43440	#endif
43441	::emitRet(PrimType T0, SourceInfo I) {
43442	switch (T0) {
43443	case PT_Sint8:
43444	#ifdef GET_LINK_IMPL
43445	return emitRetSint8
43446	#else
43447	return emitRet<PT_Sint8>
43448	#endif
43449	(I);
43450	case PT_Uint8:
43451	#ifdef GET_LINK_IMPL
43452	return emitRetUint8
43453	#else
43454	return emitRet<PT_Uint8>
43455	#endif
43456	(I);
43457	case PT_Sint16:
43458	#ifdef GET_LINK_IMPL
43459	return emitRetSint16
43460	#else
43461	return emitRet<PT_Sint16>
43462	#endif
43463	(I);
43464	case PT_Uint16:
43465	#ifdef GET_LINK_IMPL
43466	return emitRetUint16
43467	#else
43468	return emitRet<PT_Uint16>
43469	#endif
43470	(I);
43471	case PT_Sint32:
43472	#ifdef GET_LINK_IMPL
43473	return emitRetSint32
43474	#else
43475	return emitRet<PT_Sint32>
43476	#endif
43477	(I);
43478	case PT_Uint32:
43479	#ifdef GET_LINK_IMPL
43480	return emitRetUint32
43481	#else
43482	return emitRet<PT_Uint32>
43483	#endif
43484	(I);
43485	case PT_Sint64:
43486	#ifdef GET_LINK_IMPL
43487	return emitRetSint64
43488	#else
43489	return emitRet<PT_Sint64>
43490	#endif
43491	(I);
43492	case PT_Uint64:
43493	#ifdef GET_LINK_IMPL
43494	return emitRetUint64
43495	#else
43496	return emitRet<PT_Uint64>
43497	#endif
43498	(I);
43499	case PT_IntAP:
43500	#ifdef GET_LINK_IMPL
43501	return emitRetIntAP
43502	#else
43503	return emitRet<PT_IntAP>
43504	#endif
43505	(I);
43506	case PT_IntAPS:
43507	#ifdef GET_LINK_IMPL
43508	return emitRetIntAPS
43509	#else
43510	return emitRet<PT_IntAPS>
43511	#endif
43512	(I);
43513	case PT_Bool:
43514	#ifdef GET_LINK_IMPL
43515	return emitRetBool
43516	#else
43517	return emitRet<PT_Bool>
43518	#endif
43519	(I);
43520	case PT_FixedPoint:
43521	#ifdef GET_LINK_IMPL
43522	return emitRetFixedPoint
43523	#else
43524	return emitRet<PT_FixedPoint>
43525	#endif
43526	(I);
43527	case PT_Ptr:
43528	#ifdef GET_LINK_IMPL
43529	return emitRetPtr
43530	#else
43531	return emitRet<PT_Ptr>
43532	#endif
43533	(I);
43534	case PT_MemberPtr:
43535	#ifdef GET_LINK_IMPL
43536	return emitRetMemberPtr
43537	#else
43538	return emitRet<PT_MemberPtr>
43539	#endif
43540	(I);
43541	case PT_Float:
43542	#ifdef GET_LINK_IMPL
43543	return emitRetFloat
43544	#else
43545	return emitRet<PT_Float>
43546	#endif
43547	(I);
43548	}
43549	llvm_unreachable("invalid enum value");
43550	}
43551	#endif
43552	#ifdef GET_LINK_IMPL
43553	bool ByteCodeEmitter::emitRetSint8(SourceInfo L) {
43554	return emitOp<>(OP_RetSint8, L);
43555	}
43556	bool ByteCodeEmitter::emitRetUint8(SourceInfo L) {
43557	return emitOp<>(OP_RetUint8, L);
43558	}
43559	bool ByteCodeEmitter::emitRetSint16(SourceInfo L) {
43560	return emitOp<>(OP_RetSint16, L);
43561	}
43562	bool ByteCodeEmitter::emitRetUint16(SourceInfo L) {
43563	return emitOp<>(OP_RetUint16, L);
43564	}
43565	bool ByteCodeEmitter::emitRetSint32(SourceInfo L) {
43566	return emitOp<>(OP_RetSint32, L);
43567	}
43568	bool ByteCodeEmitter::emitRetUint32(SourceInfo L) {
43569	return emitOp<>(OP_RetUint32, L);
43570	}
43571	bool ByteCodeEmitter::emitRetSint64(SourceInfo L) {
43572	return emitOp<>(OP_RetSint64, L);
43573	}
43574	bool ByteCodeEmitter::emitRetUint64(SourceInfo L) {
43575	return emitOp<>(OP_RetUint64, L);
43576	}
43577	bool ByteCodeEmitter::emitRetIntAP(SourceInfo L) {
43578	return emitOp<>(OP_RetIntAP, L);
43579	}
43580	bool ByteCodeEmitter::emitRetIntAPS(SourceInfo L) {
43581	return emitOp<>(OP_RetIntAPS, L);
43582	}
43583	bool ByteCodeEmitter::emitRetBool(SourceInfo L) {
43584	return emitOp<>(OP_RetBool, L);
43585	}
43586	bool ByteCodeEmitter::emitRetFixedPoint(SourceInfo L) {
43587	return emitOp<>(OP_RetFixedPoint, L);
43588	}
43589	bool ByteCodeEmitter::emitRetPtr(SourceInfo L) {
43590	return emitOp<>(OP_RetPtr, L);
43591	}
43592	bool ByteCodeEmitter::emitRetMemberPtr(SourceInfo L) {
43593	return emitOp<>(OP_RetMemberPtr, L);
43594	}
43595	bool ByteCodeEmitter::emitRetFloat(SourceInfo L) {
43596	return emitOp<>(OP_RetFloat, L);
43597	}
43598	#endif
43599	#ifdef GET_OPCODE_NAMES
43600	OP_RetValue,
43601	#endif
43602	#ifdef GET_INTERPFN_LIST
43603	&Interp_RetValue,
43604	#endif
43605	#ifdef GET_INTERPFN_DISPATCHERS
43606	PRESERVE_NONE
43607	static bool Interp_RetValue(InterpState &S) {
43608	MUSTTAIL return RetValue(S);
43609	}
43610	#endif
43611	#ifdef GET_DISASM
43612	case OP_RetValue:
43613	Text.Op = PrintName("RetValue");
43614	break;
43615	#endif
43616	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43617	bool emitRetValue(SourceInfo);
43618	#endif
43619	#ifdef GET_LINK_IMPL
43620	bool ByteCodeEmitter::emitRetValue(SourceInfo L) {
43621	return emitOp<>(OP_RetValue, L);
43622	}
43623	#endif
43624	#ifdef GET_OPCODE_NAMES
43625	OP_RetVoid,
43626	#endif
43627	#ifdef GET_INTERPFN_LIST
43628	&Interp_RetVoid,
43629	#endif
43630	#ifdef GET_INTERPFN_DISPATCHERS
43631	PRESERVE_NONE
43632	static bool Interp_RetVoid(InterpState &S) {
43633	MUSTTAIL return RetVoid(S);
43634	}
43635	#endif
43636	#ifdef GET_DISASM
43637	case OP_RetVoid:
43638	Text.Op = PrintName("RetVoid");
43639	break;
43640	#endif
43641	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43642	bool emitRetVoid(SourceInfo);
43643	#endif
43644	#ifdef GET_LINK_IMPL
43645	bool ByteCodeEmitter::emitRetVoid(SourceInfo L) {
43646	return emitOp<>(OP_RetVoid, L);
43647	}
43648	#endif
43649	#ifdef GET_OPCODE_NAMES
43650	OP_SetFieldSint8,
43651	OP_SetFieldUint8,
43652	OP_SetFieldSint16,
43653	OP_SetFieldUint16,
43654	OP_SetFieldSint32,
43655	OP_SetFieldUint32,
43656	OP_SetFieldSint64,
43657	OP_SetFieldUint64,
43658	OP_SetFieldIntAP,
43659	OP_SetFieldIntAPS,
43660	OP_SetFieldBool,
43661	OP_SetFieldFixedPoint,
43662	OP_SetFieldPtr,
43663	OP_SetFieldMemberPtr,
43664	OP_SetFieldFloat,
43665	#endif
43666	#ifdef GET_INTERPFN_LIST
43667	&Interp_SetFieldSint8,
43668	&Interp_SetFieldUint8,
43669	&Interp_SetFieldSint16,
43670	&Interp_SetFieldUint16,
43671	&Interp_SetFieldSint32,
43672	&Interp_SetFieldUint32,
43673	&Interp_SetFieldSint64,
43674	&Interp_SetFieldUint64,
43675	&Interp_SetFieldIntAP,
43676	&Interp_SetFieldIntAPS,
43677	&Interp_SetFieldBool,
43678	&Interp_SetFieldFixedPoint,
43679	&Interp_SetFieldPtr,
43680	&Interp_SetFieldMemberPtr,
43681	&Interp_SetFieldFloat,
43682	#endif
43683	#ifdef GET_INTERPFN_DISPATCHERS
43684	PRESERVE_NONE
43685	static bool Interp_SetFieldSint8(InterpState &S) {
43686	{
43687	CodePtr OpPC = S.PC;
43688	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43689	if (!SetField<PT_Sint8>(S, OpPC, V0)) return false;
43690	}
43691	#if USE_TAILCALLS
43692	MUSTTAIL return InterpNext(S);
43693	#else
43694	return true;
43695	#endif
43696	}
43697	PRESERVE_NONE
43698	static bool Interp_SetFieldUint8(InterpState &S) {
43699	{
43700	CodePtr OpPC = S.PC;
43701	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43702	if (!SetField<PT_Uint8>(S, OpPC, V0)) return false;
43703	}
43704	#if USE_TAILCALLS
43705	MUSTTAIL return InterpNext(S);
43706	#else
43707	return true;
43708	#endif
43709	}
43710	PRESERVE_NONE
43711	static bool Interp_SetFieldSint16(InterpState &S) {
43712	{
43713	CodePtr OpPC = S.PC;
43714	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43715	if (!SetField<PT_Sint16>(S, OpPC, V0)) return false;
43716	}
43717	#if USE_TAILCALLS
43718	MUSTTAIL return InterpNext(S);
43719	#else
43720	return true;
43721	#endif
43722	}
43723	PRESERVE_NONE
43724	static bool Interp_SetFieldUint16(InterpState &S) {
43725	{
43726	CodePtr OpPC = S.PC;
43727	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43728	if (!SetField<PT_Uint16>(S, OpPC, V0)) return false;
43729	}
43730	#if USE_TAILCALLS
43731	MUSTTAIL return InterpNext(S);
43732	#else
43733	return true;
43734	#endif
43735	}
43736	PRESERVE_NONE
43737	static bool Interp_SetFieldSint32(InterpState &S) {
43738	{
43739	CodePtr OpPC = S.PC;
43740	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43741	if (!SetField<PT_Sint32>(S, OpPC, V0)) return false;
43742	}
43743	#if USE_TAILCALLS
43744	MUSTTAIL return InterpNext(S);
43745	#else
43746	return true;
43747	#endif
43748	}
43749	PRESERVE_NONE
43750	static bool Interp_SetFieldUint32(InterpState &S) {
43751	{
43752	CodePtr OpPC = S.PC;
43753	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43754	if (!SetField<PT_Uint32>(S, OpPC, V0)) return false;
43755	}
43756	#if USE_TAILCALLS
43757	MUSTTAIL return InterpNext(S);
43758	#else
43759	return true;
43760	#endif
43761	}
43762	PRESERVE_NONE
43763	static bool Interp_SetFieldSint64(InterpState &S) {
43764	{
43765	CodePtr OpPC = S.PC;
43766	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43767	if (!SetField<PT_Sint64>(S, OpPC, V0)) return false;
43768	}
43769	#if USE_TAILCALLS
43770	MUSTTAIL return InterpNext(S);
43771	#else
43772	return true;
43773	#endif
43774	}
43775	PRESERVE_NONE
43776	static bool Interp_SetFieldUint64(InterpState &S) {
43777	{
43778	CodePtr OpPC = S.PC;
43779	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43780	if (!SetField<PT_Uint64>(S, OpPC, V0)) return false;
43781	}
43782	#if USE_TAILCALLS
43783	MUSTTAIL return InterpNext(S);
43784	#else
43785	return true;
43786	#endif
43787	}
43788	PRESERVE_NONE
43789	static bool Interp_SetFieldIntAP(InterpState &S) {
43790	{
43791	CodePtr OpPC = S.PC;
43792	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43793	if (!SetField<PT_IntAP>(S, OpPC, V0)) return false;
43794	}
43795	#if USE_TAILCALLS
43796	MUSTTAIL return InterpNext(S);
43797	#else
43798	return true;
43799	#endif
43800	}
43801	PRESERVE_NONE
43802	static bool Interp_SetFieldIntAPS(InterpState &S) {
43803	{
43804	CodePtr OpPC = S.PC;
43805	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43806	if (!SetField<PT_IntAPS>(S, OpPC, V0)) return false;
43807	}
43808	#if USE_TAILCALLS
43809	MUSTTAIL return InterpNext(S);
43810	#else
43811	return true;
43812	#endif
43813	}
43814	PRESERVE_NONE
43815	static bool Interp_SetFieldBool(InterpState &S) {
43816	{
43817	CodePtr OpPC = S.PC;
43818	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43819	if (!SetField<PT_Bool>(S, OpPC, V0)) return false;
43820	}
43821	#if USE_TAILCALLS
43822	MUSTTAIL return InterpNext(S);
43823	#else
43824	return true;
43825	#endif
43826	}
43827	PRESERVE_NONE
43828	static bool Interp_SetFieldFixedPoint(InterpState &S) {
43829	{
43830	CodePtr OpPC = S.PC;
43831	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43832	if (!SetField<PT_FixedPoint>(S, OpPC, V0)) return false;
43833	}
43834	#if USE_TAILCALLS
43835	MUSTTAIL return InterpNext(S);
43836	#else
43837	return true;
43838	#endif
43839	}
43840	PRESERVE_NONE
43841	static bool Interp_SetFieldPtr(InterpState &S) {
43842	{
43843	CodePtr OpPC = S.PC;
43844	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43845	if (!SetField<PT_Ptr>(S, OpPC, V0)) return false;
43846	}
43847	#if USE_TAILCALLS
43848	MUSTTAIL return InterpNext(S);
43849	#else
43850	return true;
43851	#endif
43852	}
43853	PRESERVE_NONE
43854	static bool Interp_SetFieldMemberPtr(InterpState &S) {
43855	{
43856	CodePtr OpPC = S.PC;
43857	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43858	if (!SetField<PT_MemberPtr>(S, OpPC, V0)) return false;
43859	}
43860	#if USE_TAILCALLS
43861	MUSTTAIL return InterpNext(S);
43862	#else
43863	return true;
43864	#endif
43865	}
43866	PRESERVE_NONE
43867	static bool Interp_SetFieldFloat(InterpState &S) {
43868	{
43869	CodePtr OpPC = S.PC;
43870	const auto V0 = ReadArg<uint32_t>(S, S.PC);
43871	if (!SetField<PT_Float>(S, OpPC, V0)) return false;
43872	}
43873	#if USE_TAILCALLS
43874	MUSTTAIL return InterpNext(S);
43875	#else
43876	return true;
43877	#endif
43878	}
43879	#endif
43880	#ifdef GET_DISASM
43881	case OP_SetFieldSint8:
43882	Text.Op = PrintName("SetFieldSint8");
43883	Text.Args.push_back(printArg<uint32_t>(P, PC));
43884	break;
43885	case OP_SetFieldUint8:
43886	Text.Op = PrintName("SetFieldUint8");
43887	Text.Args.push_back(printArg<uint32_t>(P, PC));
43888	break;
43889	case OP_SetFieldSint16:
43890	Text.Op = PrintName("SetFieldSint16");
43891	Text.Args.push_back(printArg<uint32_t>(P, PC));
43892	break;
43893	case OP_SetFieldUint16:
43894	Text.Op = PrintName("SetFieldUint16");
43895	Text.Args.push_back(printArg<uint32_t>(P, PC));
43896	break;
43897	case OP_SetFieldSint32:
43898	Text.Op = PrintName("SetFieldSint32");
43899	Text.Args.push_back(printArg<uint32_t>(P, PC));
43900	break;
43901	case OP_SetFieldUint32:
43902	Text.Op = PrintName("SetFieldUint32");
43903	Text.Args.push_back(printArg<uint32_t>(P, PC));
43904	break;
43905	case OP_SetFieldSint64:
43906	Text.Op = PrintName("SetFieldSint64");
43907	Text.Args.push_back(printArg<uint32_t>(P, PC));
43908	break;
43909	case OP_SetFieldUint64:
43910	Text.Op = PrintName("SetFieldUint64");
43911	Text.Args.push_back(printArg<uint32_t>(P, PC));
43912	break;
43913	case OP_SetFieldIntAP:
43914	Text.Op = PrintName("SetFieldIntAP");
43915	Text.Args.push_back(printArg<uint32_t>(P, PC));
43916	break;
43917	case OP_SetFieldIntAPS:
43918	Text.Op = PrintName("SetFieldIntAPS");
43919	Text.Args.push_back(printArg<uint32_t>(P, PC));
43920	break;
43921	case OP_SetFieldBool:
43922	Text.Op = PrintName("SetFieldBool");
43923	Text.Args.push_back(printArg<uint32_t>(P, PC));
43924	break;
43925	case OP_SetFieldFixedPoint:
43926	Text.Op = PrintName("SetFieldFixedPoint");
43927	Text.Args.push_back(printArg<uint32_t>(P, PC));
43928	break;
43929	case OP_SetFieldPtr:
43930	Text.Op = PrintName("SetFieldPtr");
43931	Text.Args.push_back(printArg<uint32_t>(P, PC));
43932	break;
43933	case OP_SetFieldMemberPtr:
43934	Text.Op = PrintName("SetFieldMemberPtr");
43935	Text.Args.push_back(printArg<uint32_t>(P, PC));
43936	break;
43937	case OP_SetFieldFloat:
43938	Text.Op = PrintName("SetFieldFloat");
43939	Text.Args.push_back(printArg<uint32_t>(P, PC));
43940	break;
43941	#endif
43942	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43943	bool emitSetFieldSint8( uint32_t , SourceInfo);
43944	bool emitSetFieldUint8( uint32_t , SourceInfo);
43945	bool emitSetFieldSint16( uint32_t , SourceInfo);
43946	bool emitSetFieldUint16( uint32_t , SourceInfo);
43947	bool emitSetFieldSint32( uint32_t , SourceInfo);
43948	bool emitSetFieldUint32( uint32_t , SourceInfo);
43949	bool emitSetFieldSint64( uint32_t , SourceInfo);
43950	bool emitSetFieldUint64( uint32_t , SourceInfo);
43951	bool emitSetFieldIntAP( uint32_t , SourceInfo);
43952	bool emitSetFieldIntAPS( uint32_t , SourceInfo);
43953	bool emitSetFieldBool( uint32_t , SourceInfo);
43954	bool emitSetFieldFixedPoint( uint32_t , SourceInfo);
43955	bool emitSetFieldPtr( uint32_t , SourceInfo);
43956	bool emitSetFieldMemberPtr( uint32_t , SourceInfo);
43957	bool emitSetFieldFloat( uint32_t , SourceInfo);
43958	#endif
43959	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
43960	[[nodiscard]] bool emitSetField(PrimType, uint32_t, SourceInfo I);
43961	#endif
43962	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
43963	bool
43964	#if defined(GET_EVAL_IMPL)
43965	EvalEmitter
43966	#else
43967	ByteCodeEmitter
43968	#endif
43969	::emitSetField(PrimType T0, uint32_t A0, SourceInfo I) {
43970	switch (T0) {
43971	case PT_Sint8:
43972	return emitSetFieldSint8(A0, I);
43973	case PT_Uint8:
43974	return emitSetFieldUint8(A0, I);
43975	case PT_Sint16:
43976	return emitSetFieldSint16(A0, I);
43977	case PT_Uint16:
43978	return emitSetFieldUint16(A0, I);
43979	case PT_Sint32:
43980	return emitSetFieldSint32(A0, I);
43981	case PT_Uint32:
43982	return emitSetFieldUint32(A0, I);
43983	case PT_Sint64:
43984	return emitSetFieldSint64(A0, I);
43985	case PT_Uint64:
43986	return emitSetFieldUint64(A0, I);
43987	case PT_IntAP:
43988	return emitSetFieldIntAP(A0, I);
43989	case PT_IntAPS:
43990	return emitSetFieldIntAPS(A0, I);
43991	case PT_Bool:
43992	return emitSetFieldBool(A0, I);
43993	case PT_FixedPoint:
43994	return emitSetFieldFixedPoint(A0, I);
43995	case PT_Ptr:
43996	return emitSetFieldPtr(A0, I);
43997	case PT_MemberPtr:
43998	return emitSetFieldMemberPtr(A0, I);
43999	case PT_Float:
44000	return emitSetFieldFloat(A0, I);
44001	}
44002	llvm_unreachable("invalid enum value");
44003	}
44004	#endif
44005	#ifdef GET_LINK_IMPL
44006	bool ByteCodeEmitter::emitSetFieldSint8( uint32_t A0, SourceInfo L) {
44007	return emitOp<uint32_t>(OP_SetFieldSint8, A0, L);
44008	}
44009	bool ByteCodeEmitter::emitSetFieldUint8( uint32_t A0, SourceInfo L) {
44010	return emitOp<uint32_t>(OP_SetFieldUint8, A0, L);
44011	}
44012	bool ByteCodeEmitter::emitSetFieldSint16( uint32_t A0, SourceInfo L) {
44013	return emitOp<uint32_t>(OP_SetFieldSint16, A0, L);
44014	}
44015	bool ByteCodeEmitter::emitSetFieldUint16( uint32_t A0, SourceInfo L) {
44016	return emitOp<uint32_t>(OP_SetFieldUint16, A0, L);
44017	}
44018	bool ByteCodeEmitter::emitSetFieldSint32( uint32_t A0, SourceInfo L) {
44019	return emitOp<uint32_t>(OP_SetFieldSint32, A0, L);
44020	}
44021	bool ByteCodeEmitter::emitSetFieldUint32( uint32_t A0, SourceInfo L) {
44022	return emitOp<uint32_t>(OP_SetFieldUint32, A0, L);
44023	}
44024	bool ByteCodeEmitter::emitSetFieldSint64( uint32_t A0, SourceInfo L) {
44025	return emitOp<uint32_t>(OP_SetFieldSint64, A0, L);
44026	}
44027	bool ByteCodeEmitter::emitSetFieldUint64( uint32_t A0, SourceInfo L) {
44028	return emitOp<uint32_t>(OP_SetFieldUint64, A0, L);
44029	}
44030	bool ByteCodeEmitter::emitSetFieldIntAP( uint32_t A0, SourceInfo L) {
44031	return emitOp<uint32_t>(OP_SetFieldIntAP, A0, L);
44032	}
44033	bool ByteCodeEmitter::emitSetFieldIntAPS( uint32_t A0, SourceInfo L) {
44034	return emitOp<uint32_t>(OP_SetFieldIntAPS, A0, L);
44035	}
44036	bool ByteCodeEmitter::emitSetFieldBool( uint32_t A0, SourceInfo L) {
44037	return emitOp<uint32_t>(OP_SetFieldBool, A0, L);
44038	}
44039	bool ByteCodeEmitter::emitSetFieldFixedPoint( uint32_t A0, SourceInfo L) {
44040	return emitOp<uint32_t>(OP_SetFieldFixedPoint, A0, L);
44041	}
44042	bool ByteCodeEmitter::emitSetFieldPtr( uint32_t A0, SourceInfo L) {
44043	return emitOp<uint32_t>(OP_SetFieldPtr, A0, L);
44044	}
44045	bool ByteCodeEmitter::emitSetFieldMemberPtr( uint32_t A0, SourceInfo L) {
44046	return emitOp<uint32_t>(OP_SetFieldMemberPtr, A0, L);
44047	}
44048	bool ByteCodeEmitter::emitSetFieldFloat( uint32_t A0, SourceInfo L) {
44049	return emitOp<uint32_t>(OP_SetFieldFloat, A0, L);
44050	}
44051	#endif
44052	#ifdef GET_EVAL_IMPL
44053	bool EvalEmitter::emitSetFieldSint8( uint32_t A0, SourceInfo L) {
44054	if (!isActive()) return true;
44055	CurrentSource = L;
44056	return SetField<PT_Sint8>(S, CodePtr(), A0);
44057	}
44058	bool EvalEmitter::emitSetFieldUint8( uint32_t A0, SourceInfo L) {
44059	if (!isActive()) return true;
44060	CurrentSource = L;
44061	return SetField<PT_Uint8>(S, CodePtr(), A0);
44062	}
44063	bool EvalEmitter::emitSetFieldSint16( uint32_t A0, SourceInfo L) {
44064	if (!isActive()) return true;
44065	CurrentSource = L;
44066	return SetField<PT_Sint16>(S, CodePtr(), A0);
44067	}
44068	bool EvalEmitter::emitSetFieldUint16( uint32_t A0, SourceInfo L) {
44069	if (!isActive()) return true;
44070	CurrentSource = L;
44071	return SetField<PT_Uint16>(S, CodePtr(), A0);
44072	}
44073	bool EvalEmitter::emitSetFieldSint32( uint32_t A0, SourceInfo L) {
44074	if (!isActive()) return true;
44075	CurrentSource = L;
44076	return SetField<PT_Sint32>(S, CodePtr(), A0);
44077	}
44078	bool EvalEmitter::emitSetFieldUint32( uint32_t A0, SourceInfo L) {
44079	if (!isActive()) return true;
44080	CurrentSource = L;
44081	return SetField<PT_Uint32>(S, CodePtr(), A0);
44082	}
44083	bool EvalEmitter::emitSetFieldSint64( uint32_t A0, SourceInfo L) {
44084	if (!isActive()) return true;
44085	CurrentSource = L;
44086	return SetField<PT_Sint64>(S, CodePtr(), A0);
44087	}
44088	bool EvalEmitter::emitSetFieldUint64( uint32_t A0, SourceInfo L) {
44089	if (!isActive()) return true;
44090	CurrentSource = L;
44091	return SetField<PT_Uint64>(S, CodePtr(), A0);
44092	}
44093	bool EvalEmitter::emitSetFieldIntAP( uint32_t A0, SourceInfo L) {
44094	if (!isActive()) return true;
44095	CurrentSource = L;
44096	return SetField<PT_IntAP>(S, CodePtr(), A0);
44097	}
44098	bool EvalEmitter::emitSetFieldIntAPS( uint32_t A0, SourceInfo L) {
44099	if (!isActive()) return true;
44100	CurrentSource = L;
44101	return SetField<PT_IntAPS>(S, CodePtr(), A0);
44102	}
44103	bool EvalEmitter::emitSetFieldBool( uint32_t A0, SourceInfo L) {
44104	if (!isActive()) return true;
44105	CurrentSource = L;
44106	return SetField<PT_Bool>(S, CodePtr(), A0);
44107	}
44108	bool EvalEmitter::emitSetFieldFixedPoint( uint32_t A0, SourceInfo L) {
44109	if (!isActive()) return true;
44110	CurrentSource = L;
44111	return SetField<PT_FixedPoint>(S, CodePtr(), A0);
44112	}
44113	bool EvalEmitter::emitSetFieldPtr( uint32_t A0, SourceInfo L) {
44114	if (!isActive()) return true;
44115	CurrentSource = L;
44116	return SetField<PT_Ptr>(S, CodePtr(), A0);
44117	}
44118	bool EvalEmitter::emitSetFieldMemberPtr( uint32_t A0, SourceInfo L) {
44119	if (!isActive()) return true;
44120	CurrentSource = L;
44121	return SetField<PT_MemberPtr>(S, CodePtr(), A0);
44122	}
44123	bool EvalEmitter::emitSetFieldFloat( uint32_t A0, SourceInfo L) {
44124	if (!isActive()) return true;
44125	CurrentSource = L;
44126	return SetField<PT_Float>(S, CodePtr(), A0);
44127	}
44128	#endif
44129	#ifdef GET_OPCODE_NAMES
44130	OP_SetGlobalSint8,
44131	OP_SetGlobalUint8,
44132	OP_SetGlobalSint16,
44133	OP_SetGlobalUint16,
44134	OP_SetGlobalSint32,
44135	OP_SetGlobalUint32,
44136	OP_SetGlobalSint64,
44137	OP_SetGlobalUint64,
44138	OP_SetGlobalIntAP,
44139	OP_SetGlobalIntAPS,
44140	OP_SetGlobalBool,
44141	OP_SetGlobalFixedPoint,
44142	OP_SetGlobalPtr,
44143	OP_SetGlobalMemberPtr,
44144	OP_SetGlobalFloat,
44145	#endif
44146	#ifdef GET_INTERPFN_LIST
44147	&Interp_SetGlobalSint8,
44148	&Interp_SetGlobalUint8,
44149	&Interp_SetGlobalSint16,
44150	&Interp_SetGlobalUint16,
44151	&Interp_SetGlobalSint32,
44152	&Interp_SetGlobalUint32,
44153	&Interp_SetGlobalSint64,
44154	&Interp_SetGlobalUint64,
44155	&Interp_SetGlobalIntAP,
44156	&Interp_SetGlobalIntAPS,
44157	&Interp_SetGlobalBool,
44158	&Interp_SetGlobalFixedPoint,
44159	&Interp_SetGlobalPtr,
44160	&Interp_SetGlobalMemberPtr,
44161	&Interp_SetGlobalFloat,
44162	#endif
44163	#ifdef GET_INTERPFN_DISPATCHERS
44164	PRESERVE_NONE
44165	static bool Interp_SetGlobalSint8(InterpState &S) {
44166	{
44167	CodePtr OpPC = S.PC;
44168	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44169	if (!SetGlobal<PT_Sint8>(S, OpPC, V0)) return false;
44170	}
44171	#if USE_TAILCALLS
44172	MUSTTAIL return InterpNext(S);
44173	#else
44174	return true;
44175	#endif
44176	}
44177	PRESERVE_NONE
44178	static bool Interp_SetGlobalUint8(InterpState &S) {
44179	{
44180	CodePtr OpPC = S.PC;
44181	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44182	if (!SetGlobal<PT_Uint8>(S, OpPC, V0)) return false;
44183	}
44184	#if USE_TAILCALLS
44185	MUSTTAIL return InterpNext(S);
44186	#else
44187	return true;
44188	#endif
44189	}
44190	PRESERVE_NONE
44191	static bool Interp_SetGlobalSint16(InterpState &S) {
44192	{
44193	CodePtr OpPC = S.PC;
44194	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44195	if (!SetGlobal<PT_Sint16>(S, OpPC, V0)) return false;
44196	}
44197	#if USE_TAILCALLS
44198	MUSTTAIL return InterpNext(S);
44199	#else
44200	return true;
44201	#endif
44202	}
44203	PRESERVE_NONE
44204	static bool Interp_SetGlobalUint16(InterpState &S) {
44205	{
44206	CodePtr OpPC = S.PC;
44207	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44208	if (!SetGlobal<PT_Uint16>(S, OpPC, V0)) return false;
44209	}
44210	#if USE_TAILCALLS
44211	MUSTTAIL return InterpNext(S);
44212	#else
44213	return true;
44214	#endif
44215	}
44216	PRESERVE_NONE
44217	static bool Interp_SetGlobalSint32(InterpState &S) {
44218	{
44219	CodePtr OpPC = S.PC;
44220	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44221	if (!SetGlobal<PT_Sint32>(S, OpPC, V0)) return false;
44222	}
44223	#if USE_TAILCALLS
44224	MUSTTAIL return InterpNext(S);
44225	#else
44226	return true;
44227	#endif
44228	}
44229	PRESERVE_NONE
44230	static bool Interp_SetGlobalUint32(InterpState &S) {
44231	{
44232	CodePtr OpPC = S.PC;
44233	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44234	if (!SetGlobal<PT_Uint32>(S, OpPC, V0)) return false;
44235	}
44236	#if USE_TAILCALLS
44237	MUSTTAIL return InterpNext(S);
44238	#else
44239	return true;
44240	#endif
44241	}
44242	PRESERVE_NONE
44243	static bool Interp_SetGlobalSint64(InterpState &S) {
44244	{
44245	CodePtr OpPC = S.PC;
44246	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44247	if (!SetGlobal<PT_Sint64>(S, OpPC, V0)) return false;
44248	}
44249	#if USE_TAILCALLS
44250	MUSTTAIL return InterpNext(S);
44251	#else
44252	return true;
44253	#endif
44254	}
44255	PRESERVE_NONE
44256	static bool Interp_SetGlobalUint64(InterpState &S) {
44257	{
44258	CodePtr OpPC = S.PC;
44259	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44260	if (!SetGlobal<PT_Uint64>(S, OpPC, V0)) return false;
44261	}
44262	#if USE_TAILCALLS
44263	MUSTTAIL return InterpNext(S);
44264	#else
44265	return true;
44266	#endif
44267	}
44268	PRESERVE_NONE
44269	static bool Interp_SetGlobalIntAP(InterpState &S) {
44270	{
44271	CodePtr OpPC = S.PC;
44272	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44273	if (!SetGlobal<PT_IntAP>(S, OpPC, V0)) return false;
44274	}
44275	#if USE_TAILCALLS
44276	MUSTTAIL return InterpNext(S);
44277	#else
44278	return true;
44279	#endif
44280	}
44281	PRESERVE_NONE
44282	static bool Interp_SetGlobalIntAPS(InterpState &S) {
44283	{
44284	CodePtr OpPC = S.PC;
44285	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44286	if (!SetGlobal<PT_IntAPS>(S, OpPC, V0)) return false;
44287	}
44288	#if USE_TAILCALLS
44289	MUSTTAIL return InterpNext(S);
44290	#else
44291	return true;
44292	#endif
44293	}
44294	PRESERVE_NONE
44295	static bool Interp_SetGlobalBool(InterpState &S) {
44296	{
44297	CodePtr OpPC = S.PC;
44298	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44299	if (!SetGlobal<PT_Bool>(S, OpPC, V0)) return false;
44300	}
44301	#if USE_TAILCALLS
44302	MUSTTAIL return InterpNext(S);
44303	#else
44304	return true;
44305	#endif
44306	}
44307	PRESERVE_NONE
44308	static bool Interp_SetGlobalFixedPoint(InterpState &S) {
44309	{
44310	CodePtr OpPC = S.PC;
44311	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44312	if (!SetGlobal<PT_FixedPoint>(S, OpPC, V0)) return false;
44313	}
44314	#if USE_TAILCALLS
44315	MUSTTAIL return InterpNext(S);
44316	#else
44317	return true;
44318	#endif
44319	}
44320	PRESERVE_NONE
44321	static bool Interp_SetGlobalPtr(InterpState &S) {
44322	{
44323	CodePtr OpPC = S.PC;
44324	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44325	if (!SetGlobal<PT_Ptr>(S, OpPC, V0)) return false;
44326	}
44327	#if USE_TAILCALLS
44328	MUSTTAIL return InterpNext(S);
44329	#else
44330	return true;
44331	#endif
44332	}
44333	PRESERVE_NONE
44334	static bool Interp_SetGlobalMemberPtr(InterpState &S) {
44335	{
44336	CodePtr OpPC = S.PC;
44337	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44338	if (!SetGlobal<PT_MemberPtr>(S, OpPC, V0)) return false;
44339	}
44340	#if USE_TAILCALLS
44341	MUSTTAIL return InterpNext(S);
44342	#else
44343	return true;
44344	#endif
44345	}
44346	PRESERVE_NONE
44347	static bool Interp_SetGlobalFloat(InterpState &S) {
44348	{
44349	CodePtr OpPC = S.PC;
44350	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44351	if (!SetGlobal<PT_Float>(S, OpPC, V0)) return false;
44352	}
44353	#if USE_TAILCALLS
44354	MUSTTAIL return InterpNext(S);
44355	#else
44356	return true;
44357	#endif
44358	}
44359	#endif
44360	#ifdef GET_DISASM
44361	case OP_SetGlobalSint8:
44362	Text.Op = PrintName("SetGlobalSint8");
44363	Text.Args.push_back(printArg<uint32_t>(P, PC));
44364	break;
44365	case OP_SetGlobalUint8:
44366	Text.Op = PrintName("SetGlobalUint8");
44367	Text.Args.push_back(printArg<uint32_t>(P, PC));
44368	break;
44369	case OP_SetGlobalSint16:
44370	Text.Op = PrintName("SetGlobalSint16");
44371	Text.Args.push_back(printArg<uint32_t>(P, PC));
44372	break;
44373	case OP_SetGlobalUint16:
44374	Text.Op = PrintName("SetGlobalUint16");
44375	Text.Args.push_back(printArg<uint32_t>(P, PC));
44376	break;
44377	case OP_SetGlobalSint32:
44378	Text.Op = PrintName("SetGlobalSint32");
44379	Text.Args.push_back(printArg<uint32_t>(P, PC));
44380	break;
44381	case OP_SetGlobalUint32:
44382	Text.Op = PrintName("SetGlobalUint32");
44383	Text.Args.push_back(printArg<uint32_t>(P, PC));
44384	break;
44385	case OP_SetGlobalSint64:
44386	Text.Op = PrintName("SetGlobalSint64");
44387	Text.Args.push_back(printArg<uint32_t>(P, PC));
44388	break;
44389	case OP_SetGlobalUint64:
44390	Text.Op = PrintName("SetGlobalUint64");
44391	Text.Args.push_back(printArg<uint32_t>(P, PC));
44392	break;
44393	case OP_SetGlobalIntAP:
44394	Text.Op = PrintName("SetGlobalIntAP");
44395	Text.Args.push_back(printArg<uint32_t>(P, PC));
44396	break;
44397	case OP_SetGlobalIntAPS:
44398	Text.Op = PrintName("SetGlobalIntAPS");
44399	Text.Args.push_back(printArg<uint32_t>(P, PC));
44400	break;
44401	case OP_SetGlobalBool:
44402	Text.Op = PrintName("SetGlobalBool");
44403	Text.Args.push_back(printArg<uint32_t>(P, PC));
44404	break;
44405	case OP_SetGlobalFixedPoint:
44406	Text.Op = PrintName("SetGlobalFixedPoint");
44407	Text.Args.push_back(printArg<uint32_t>(P, PC));
44408	break;
44409	case OP_SetGlobalPtr:
44410	Text.Op = PrintName("SetGlobalPtr");
44411	Text.Args.push_back(printArg<uint32_t>(P, PC));
44412	break;
44413	case OP_SetGlobalMemberPtr:
44414	Text.Op = PrintName("SetGlobalMemberPtr");
44415	Text.Args.push_back(printArg<uint32_t>(P, PC));
44416	break;
44417	case OP_SetGlobalFloat:
44418	Text.Op = PrintName("SetGlobalFloat");
44419	Text.Args.push_back(printArg<uint32_t>(P, PC));
44420	break;
44421	#endif
44422	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
44423	bool emitSetGlobalSint8( uint32_t , SourceInfo);
44424	bool emitSetGlobalUint8( uint32_t , SourceInfo);
44425	bool emitSetGlobalSint16( uint32_t , SourceInfo);
44426	bool emitSetGlobalUint16( uint32_t , SourceInfo);
44427	bool emitSetGlobalSint32( uint32_t , SourceInfo);
44428	bool emitSetGlobalUint32( uint32_t , SourceInfo);
44429	bool emitSetGlobalSint64( uint32_t , SourceInfo);
44430	bool emitSetGlobalUint64( uint32_t , SourceInfo);
44431	bool emitSetGlobalIntAP( uint32_t , SourceInfo);
44432	bool emitSetGlobalIntAPS( uint32_t , SourceInfo);
44433	bool emitSetGlobalBool( uint32_t , SourceInfo);
44434	bool emitSetGlobalFixedPoint( uint32_t , SourceInfo);
44435	bool emitSetGlobalPtr( uint32_t , SourceInfo);
44436	bool emitSetGlobalMemberPtr( uint32_t , SourceInfo);
44437	bool emitSetGlobalFloat( uint32_t , SourceInfo);
44438	#endif
44439	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
44440	[[nodiscard]] bool emitSetGlobal(PrimType, uint32_t, SourceInfo I);
44441	#endif
44442	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
44443	bool
44444	#if defined(GET_EVAL_IMPL)
44445	EvalEmitter
44446	#else
44447	ByteCodeEmitter
44448	#endif
44449	::emitSetGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
44450	switch (T0) {
44451	case PT_Sint8:
44452	return emitSetGlobalSint8(A0, I);
44453	case PT_Uint8:
44454	return emitSetGlobalUint8(A0, I);
44455	case PT_Sint16:
44456	return emitSetGlobalSint16(A0, I);
44457	case PT_Uint16:
44458	return emitSetGlobalUint16(A0, I);
44459	case PT_Sint32:
44460	return emitSetGlobalSint32(A0, I);
44461	case PT_Uint32:
44462	return emitSetGlobalUint32(A0, I);
44463	case PT_Sint64:
44464	return emitSetGlobalSint64(A0, I);
44465	case PT_Uint64:
44466	return emitSetGlobalUint64(A0, I);
44467	case PT_IntAP:
44468	return emitSetGlobalIntAP(A0, I);
44469	case PT_IntAPS:
44470	return emitSetGlobalIntAPS(A0, I);
44471	case PT_Bool:
44472	return emitSetGlobalBool(A0, I);
44473	case PT_FixedPoint:
44474	return emitSetGlobalFixedPoint(A0, I);
44475	case PT_Ptr:
44476	return emitSetGlobalPtr(A0, I);
44477	case PT_MemberPtr:
44478	return emitSetGlobalMemberPtr(A0, I);
44479	case PT_Float:
44480	return emitSetGlobalFloat(A0, I);
44481	}
44482	llvm_unreachable("invalid enum value");
44483	}
44484	#endif
44485	#ifdef GET_LINK_IMPL
44486	bool ByteCodeEmitter::emitSetGlobalSint8( uint32_t A0, SourceInfo L) {
44487	return emitOp<uint32_t>(OP_SetGlobalSint8, A0, L);
44488	}
44489	bool ByteCodeEmitter::emitSetGlobalUint8( uint32_t A0, SourceInfo L) {
44490	return emitOp<uint32_t>(OP_SetGlobalUint8, A0, L);
44491	}
44492	bool ByteCodeEmitter::emitSetGlobalSint16( uint32_t A0, SourceInfo L) {
44493	return emitOp<uint32_t>(OP_SetGlobalSint16, A0, L);
44494	}
44495	bool ByteCodeEmitter::emitSetGlobalUint16( uint32_t A0, SourceInfo L) {
44496	return emitOp<uint32_t>(OP_SetGlobalUint16, A0, L);
44497	}
44498	bool ByteCodeEmitter::emitSetGlobalSint32( uint32_t A0, SourceInfo L) {
44499	return emitOp<uint32_t>(OP_SetGlobalSint32, A0, L);
44500	}
44501	bool ByteCodeEmitter::emitSetGlobalUint32( uint32_t A0, SourceInfo L) {
44502	return emitOp<uint32_t>(OP_SetGlobalUint32, A0, L);
44503	}
44504	bool ByteCodeEmitter::emitSetGlobalSint64( uint32_t A0, SourceInfo L) {
44505	return emitOp<uint32_t>(OP_SetGlobalSint64, A0, L);
44506	}
44507	bool ByteCodeEmitter::emitSetGlobalUint64( uint32_t A0, SourceInfo L) {
44508	return emitOp<uint32_t>(OP_SetGlobalUint64, A0, L);
44509	}
44510	bool ByteCodeEmitter::emitSetGlobalIntAP( uint32_t A0, SourceInfo L) {
44511	return emitOp<uint32_t>(OP_SetGlobalIntAP, A0, L);
44512	}
44513	bool ByteCodeEmitter::emitSetGlobalIntAPS( uint32_t A0, SourceInfo L) {
44514	return emitOp<uint32_t>(OP_SetGlobalIntAPS, A0, L);
44515	}
44516	bool ByteCodeEmitter::emitSetGlobalBool( uint32_t A0, SourceInfo L) {
44517	return emitOp<uint32_t>(OP_SetGlobalBool, A0, L);
44518	}
44519	bool ByteCodeEmitter::emitSetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
44520	return emitOp<uint32_t>(OP_SetGlobalFixedPoint, A0, L);
44521	}
44522	bool ByteCodeEmitter::emitSetGlobalPtr( uint32_t A0, SourceInfo L) {
44523	return emitOp<uint32_t>(OP_SetGlobalPtr, A0, L);
44524	}
44525	bool ByteCodeEmitter::emitSetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
44526	return emitOp<uint32_t>(OP_SetGlobalMemberPtr, A0, L);
44527	}
44528	bool ByteCodeEmitter::emitSetGlobalFloat( uint32_t A0, SourceInfo L) {
44529	return emitOp<uint32_t>(OP_SetGlobalFloat, A0, L);
44530	}
44531	#endif
44532	#ifdef GET_EVAL_IMPL
44533	bool EvalEmitter::emitSetGlobalSint8( uint32_t A0, SourceInfo L) {
44534	if (!isActive()) return true;
44535	CurrentSource = L;
44536	return SetGlobal<PT_Sint8>(S, CodePtr(), A0);
44537	}
44538	bool EvalEmitter::emitSetGlobalUint8( uint32_t A0, SourceInfo L) {
44539	if (!isActive()) return true;
44540	CurrentSource = L;
44541	return SetGlobal<PT_Uint8>(S, CodePtr(), A0);
44542	}
44543	bool EvalEmitter::emitSetGlobalSint16( uint32_t A0, SourceInfo L) {
44544	if (!isActive()) return true;
44545	CurrentSource = L;
44546	return SetGlobal<PT_Sint16>(S, CodePtr(), A0);
44547	}
44548	bool EvalEmitter::emitSetGlobalUint16( uint32_t A0, SourceInfo L) {
44549	if (!isActive()) return true;
44550	CurrentSource = L;
44551	return SetGlobal<PT_Uint16>(S, CodePtr(), A0);
44552	}
44553	bool EvalEmitter::emitSetGlobalSint32( uint32_t A0, SourceInfo L) {
44554	if (!isActive()) return true;
44555	CurrentSource = L;
44556	return SetGlobal<PT_Sint32>(S, CodePtr(), A0);
44557	}
44558	bool EvalEmitter::emitSetGlobalUint32( uint32_t A0, SourceInfo L) {
44559	if (!isActive()) return true;
44560	CurrentSource = L;
44561	return SetGlobal<PT_Uint32>(S, CodePtr(), A0);
44562	}
44563	bool EvalEmitter::emitSetGlobalSint64( uint32_t A0, SourceInfo L) {
44564	if (!isActive()) return true;
44565	CurrentSource = L;
44566	return SetGlobal<PT_Sint64>(S, CodePtr(), A0);
44567	}
44568	bool EvalEmitter::emitSetGlobalUint64( uint32_t A0, SourceInfo L) {
44569	if (!isActive()) return true;
44570	CurrentSource = L;
44571	return SetGlobal<PT_Uint64>(S, CodePtr(), A0);
44572	}
44573	bool EvalEmitter::emitSetGlobalIntAP( uint32_t A0, SourceInfo L) {
44574	if (!isActive()) return true;
44575	CurrentSource = L;
44576	return SetGlobal<PT_IntAP>(S, CodePtr(), A0);
44577	}
44578	bool EvalEmitter::emitSetGlobalIntAPS( uint32_t A0, SourceInfo L) {
44579	if (!isActive()) return true;
44580	CurrentSource = L;
44581	return SetGlobal<PT_IntAPS>(S, CodePtr(), A0);
44582	}
44583	bool EvalEmitter::emitSetGlobalBool( uint32_t A0, SourceInfo L) {
44584	if (!isActive()) return true;
44585	CurrentSource = L;
44586	return SetGlobal<PT_Bool>(S, CodePtr(), A0);
44587	}
44588	bool EvalEmitter::emitSetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
44589	if (!isActive()) return true;
44590	CurrentSource = L;
44591	return SetGlobal<PT_FixedPoint>(S, CodePtr(), A0);
44592	}
44593	bool EvalEmitter::emitSetGlobalPtr( uint32_t A0, SourceInfo L) {
44594	if (!isActive()) return true;
44595	CurrentSource = L;
44596	return SetGlobal<PT_Ptr>(S, CodePtr(), A0);
44597	}
44598	bool EvalEmitter::emitSetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
44599	if (!isActive()) return true;
44600	CurrentSource = L;
44601	return SetGlobal<PT_MemberPtr>(S, CodePtr(), A0);
44602	}
44603	bool EvalEmitter::emitSetGlobalFloat( uint32_t A0, SourceInfo L) {
44604	if (!isActive()) return true;
44605	CurrentSource = L;
44606	return SetGlobal<PT_Float>(S, CodePtr(), A0);
44607	}
44608	#endif
44609	#ifdef GET_OPCODE_NAMES
44610	OP_SetLocalSint8,
44611	OP_SetLocalUint8,
44612	OP_SetLocalSint16,
44613	OP_SetLocalUint16,
44614	OP_SetLocalSint32,
44615	OP_SetLocalUint32,
44616	OP_SetLocalSint64,
44617	OP_SetLocalUint64,
44618	OP_SetLocalIntAP,
44619	OP_SetLocalIntAPS,
44620	OP_SetLocalBool,
44621	OP_SetLocalFixedPoint,
44622	OP_SetLocalPtr,
44623	OP_SetLocalMemberPtr,
44624	OP_SetLocalFloat,
44625	#endif
44626	#ifdef GET_INTERPFN_LIST
44627	&Interp_SetLocalSint8,
44628	&Interp_SetLocalUint8,
44629	&Interp_SetLocalSint16,
44630	&Interp_SetLocalUint16,
44631	&Interp_SetLocalSint32,
44632	&Interp_SetLocalUint32,
44633	&Interp_SetLocalSint64,
44634	&Interp_SetLocalUint64,
44635	&Interp_SetLocalIntAP,
44636	&Interp_SetLocalIntAPS,
44637	&Interp_SetLocalBool,
44638	&Interp_SetLocalFixedPoint,
44639	&Interp_SetLocalPtr,
44640	&Interp_SetLocalMemberPtr,
44641	&Interp_SetLocalFloat,
44642	#endif
44643	#ifdef GET_INTERPFN_DISPATCHERS
44644	PRESERVE_NONE
44645	static bool Interp_SetLocalSint8(InterpState &S) {
44646	{
44647	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44648	SetLocal<PT_Sint8>(S, V0);
44649	}
44650	#if USE_TAILCALLS
44651	MUSTTAIL return InterpNext(S);
44652	#else
44653	return true;
44654	#endif
44655	}
44656	PRESERVE_NONE
44657	static bool Interp_SetLocalUint8(InterpState &S) {
44658	{
44659	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44660	SetLocal<PT_Uint8>(S, V0);
44661	}
44662	#if USE_TAILCALLS
44663	MUSTTAIL return InterpNext(S);
44664	#else
44665	return true;
44666	#endif
44667	}
44668	PRESERVE_NONE
44669	static bool Interp_SetLocalSint16(InterpState &S) {
44670	{
44671	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44672	SetLocal<PT_Sint16>(S, V0);
44673	}
44674	#if USE_TAILCALLS
44675	MUSTTAIL return InterpNext(S);
44676	#else
44677	return true;
44678	#endif
44679	}
44680	PRESERVE_NONE
44681	static bool Interp_SetLocalUint16(InterpState &S) {
44682	{
44683	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44684	SetLocal<PT_Uint16>(S, V0);
44685	}
44686	#if USE_TAILCALLS
44687	MUSTTAIL return InterpNext(S);
44688	#else
44689	return true;
44690	#endif
44691	}
44692	PRESERVE_NONE
44693	static bool Interp_SetLocalSint32(InterpState &S) {
44694	{
44695	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44696	SetLocal<PT_Sint32>(S, V0);
44697	}
44698	#if USE_TAILCALLS
44699	MUSTTAIL return InterpNext(S);
44700	#else
44701	return true;
44702	#endif
44703	}
44704	PRESERVE_NONE
44705	static bool Interp_SetLocalUint32(InterpState &S) {
44706	{
44707	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44708	SetLocal<PT_Uint32>(S, V0);
44709	}
44710	#if USE_TAILCALLS
44711	MUSTTAIL return InterpNext(S);
44712	#else
44713	return true;
44714	#endif
44715	}
44716	PRESERVE_NONE
44717	static bool Interp_SetLocalSint64(InterpState &S) {
44718	{
44719	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44720	SetLocal<PT_Sint64>(S, V0);
44721	}
44722	#if USE_TAILCALLS
44723	MUSTTAIL return InterpNext(S);
44724	#else
44725	return true;
44726	#endif
44727	}
44728	PRESERVE_NONE
44729	static bool Interp_SetLocalUint64(InterpState &S) {
44730	{
44731	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44732	SetLocal<PT_Uint64>(S, V0);
44733	}
44734	#if USE_TAILCALLS
44735	MUSTTAIL return InterpNext(S);
44736	#else
44737	return true;
44738	#endif
44739	}
44740	PRESERVE_NONE
44741	static bool Interp_SetLocalIntAP(InterpState &S) {
44742	{
44743	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44744	SetLocal<PT_IntAP>(S, V0);
44745	}
44746	#if USE_TAILCALLS
44747	MUSTTAIL return InterpNext(S);
44748	#else
44749	return true;
44750	#endif
44751	}
44752	PRESERVE_NONE
44753	static bool Interp_SetLocalIntAPS(InterpState &S) {
44754	{
44755	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44756	SetLocal<PT_IntAPS>(S, V0);
44757	}
44758	#if USE_TAILCALLS
44759	MUSTTAIL return InterpNext(S);
44760	#else
44761	return true;
44762	#endif
44763	}
44764	PRESERVE_NONE
44765	static bool Interp_SetLocalBool(InterpState &S) {
44766	{
44767	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44768	SetLocal<PT_Bool>(S, V0);
44769	}
44770	#if USE_TAILCALLS
44771	MUSTTAIL return InterpNext(S);
44772	#else
44773	return true;
44774	#endif
44775	}
44776	PRESERVE_NONE
44777	static bool Interp_SetLocalFixedPoint(InterpState &S) {
44778	{
44779	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44780	SetLocal<PT_FixedPoint>(S, V0);
44781	}
44782	#if USE_TAILCALLS
44783	MUSTTAIL return InterpNext(S);
44784	#else
44785	return true;
44786	#endif
44787	}
44788	PRESERVE_NONE
44789	static bool Interp_SetLocalPtr(InterpState &S) {
44790	{
44791	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44792	SetLocal<PT_Ptr>(S, V0);
44793	}
44794	#if USE_TAILCALLS
44795	MUSTTAIL return InterpNext(S);
44796	#else
44797	return true;
44798	#endif
44799	}
44800	PRESERVE_NONE
44801	static bool Interp_SetLocalMemberPtr(InterpState &S) {
44802	{
44803	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44804	SetLocal<PT_MemberPtr>(S, V0);
44805	}
44806	#if USE_TAILCALLS
44807	MUSTTAIL return InterpNext(S);
44808	#else
44809	return true;
44810	#endif
44811	}
44812	PRESERVE_NONE
44813	static bool Interp_SetLocalFloat(InterpState &S) {
44814	{
44815	const auto V0 = ReadArg<uint32_t>(S, S.PC);
44816	SetLocal<PT_Float>(S, V0);
44817	}
44818	#if USE_TAILCALLS
44819	MUSTTAIL return InterpNext(S);
44820	#else
44821	return true;
44822	#endif
44823	}
44824	#endif
44825	#ifdef GET_DISASM
44826	case OP_SetLocalSint8:
44827	Text.Op = PrintName("SetLocalSint8");
44828	Text.Args.push_back(printArg<uint32_t>(P, PC));
44829	break;
44830	case OP_SetLocalUint8:
44831	Text.Op = PrintName("SetLocalUint8");
44832	Text.Args.push_back(printArg<uint32_t>(P, PC));
44833	break;
44834	case OP_SetLocalSint16:
44835	Text.Op = PrintName("SetLocalSint16");
44836	Text.Args.push_back(printArg<uint32_t>(P, PC));
44837	break;
44838	case OP_SetLocalUint16:
44839	Text.Op = PrintName("SetLocalUint16");
44840	Text.Args.push_back(printArg<uint32_t>(P, PC));
44841	break;
44842	case OP_SetLocalSint32:
44843	Text.Op = PrintName("SetLocalSint32");
44844	Text.Args.push_back(printArg<uint32_t>(P, PC));
44845	break;
44846	case OP_SetLocalUint32:
44847	Text.Op = PrintName("SetLocalUint32");
44848	Text.Args.push_back(printArg<uint32_t>(P, PC));
44849	break;
44850	case OP_SetLocalSint64:
44851	Text.Op = PrintName("SetLocalSint64");
44852	Text.Args.push_back(printArg<uint32_t>(P, PC));
44853	break;
44854	case OP_SetLocalUint64:
44855	Text.Op = PrintName("SetLocalUint64");
44856	Text.Args.push_back(printArg<uint32_t>(P, PC));
44857	break;
44858	case OP_SetLocalIntAP:
44859	Text.Op = PrintName("SetLocalIntAP");
44860	Text.Args.push_back(printArg<uint32_t>(P, PC));
44861	break;
44862	case OP_SetLocalIntAPS:
44863	Text.Op = PrintName("SetLocalIntAPS");
44864	Text.Args.push_back(printArg<uint32_t>(P, PC));
44865	break;
44866	case OP_SetLocalBool:
44867	Text.Op = PrintName("SetLocalBool");
44868	Text.Args.push_back(printArg<uint32_t>(P, PC));
44869	break;
44870	case OP_SetLocalFixedPoint:
44871	Text.Op = PrintName("SetLocalFixedPoint");
44872	Text.Args.push_back(printArg<uint32_t>(P, PC));
44873	break;
44874	case OP_SetLocalPtr:
44875	Text.Op = PrintName("SetLocalPtr");
44876	Text.Args.push_back(printArg<uint32_t>(P, PC));
44877	break;
44878	case OP_SetLocalMemberPtr:
44879	Text.Op = PrintName("SetLocalMemberPtr");
44880	Text.Args.push_back(printArg<uint32_t>(P, PC));
44881	break;
44882	case OP_SetLocalFloat:
44883	Text.Op = PrintName("SetLocalFloat");
44884	Text.Args.push_back(printArg<uint32_t>(P, PC));
44885	break;
44886	#endif
44887	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
44888	bool emitSetLocalSint8( uint32_t , SourceInfo);
44889	bool emitSetLocalUint8( uint32_t , SourceInfo);
44890	bool emitSetLocalSint16( uint32_t , SourceInfo);
44891	bool emitSetLocalUint16( uint32_t , SourceInfo);
44892	bool emitSetLocalSint32( uint32_t , SourceInfo);
44893	bool emitSetLocalUint32( uint32_t , SourceInfo);
44894	bool emitSetLocalSint64( uint32_t , SourceInfo);
44895	bool emitSetLocalUint64( uint32_t , SourceInfo);
44896	bool emitSetLocalIntAP( uint32_t , SourceInfo);
44897	bool emitSetLocalIntAPS( uint32_t , SourceInfo);
44898	bool emitSetLocalBool( uint32_t , SourceInfo);
44899	bool emitSetLocalFixedPoint( uint32_t , SourceInfo);
44900	bool emitSetLocalPtr( uint32_t , SourceInfo);
44901	bool emitSetLocalMemberPtr( uint32_t , SourceInfo);
44902	bool emitSetLocalFloat( uint32_t , SourceInfo);
44903	#if defined(GET_EVAL_PROTO)
44904	template<PrimType>
44905	bool emitSetLocal(uint32_t, SourceInfo);
44906	#endif
44907	#endif
44908	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
44909	[[nodiscard]] bool emitSetLocal(PrimType, uint32_t, SourceInfo I);
44910	#endif
44911	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
44912	bool
44913	#if defined(GET_EVAL_IMPL)
44914	EvalEmitter
44915	#else
44916	ByteCodeEmitter
44917	#endif
44918	::emitSetLocal(PrimType T0, uint32_t A0, SourceInfo I) {
44919	switch (T0) {
44920	case PT_Sint8:
44921	#ifdef GET_LINK_IMPL
44922	return emitSetLocalSint8
44923	#else
44924	return emitSetLocal<PT_Sint8>
44925	#endif
44926	(A0, I);
44927	case PT_Uint8:
44928	#ifdef GET_LINK_IMPL
44929	return emitSetLocalUint8
44930	#else
44931	return emitSetLocal<PT_Uint8>
44932	#endif
44933	(A0, I);
44934	case PT_Sint16:
44935	#ifdef GET_LINK_IMPL
44936	return emitSetLocalSint16
44937	#else
44938	return emitSetLocal<PT_Sint16>
44939	#endif
44940	(A0, I);
44941	case PT_Uint16:
44942	#ifdef GET_LINK_IMPL
44943	return emitSetLocalUint16
44944	#else
44945	return emitSetLocal<PT_Uint16>
44946	#endif
44947	(A0, I);
44948	case PT_Sint32:
44949	#ifdef GET_LINK_IMPL
44950	return emitSetLocalSint32
44951	#else
44952	return emitSetLocal<PT_Sint32>
44953	#endif
44954	(A0, I);
44955	case PT_Uint32:
44956	#ifdef GET_LINK_IMPL
44957	return emitSetLocalUint32
44958	#else
44959	return emitSetLocal<PT_Uint32>
44960	#endif
44961	(A0, I);
44962	case PT_Sint64:
44963	#ifdef GET_LINK_IMPL
44964	return emitSetLocalSint64
44965	#else
44966	return emitSetLocal<PT_Sint64>
44967	#endif
44968	(A0, I);
44969	case PT_Uint64:
44970	#ifdef GET_LINK_IMPL
44971	return emitSetLocalUint64
44972	#else
44973	return emitSetLocal<PT_Uint64>
44974	#endif
44975	(A0, I);
44976	case PT_IntAP:
44977	#ifdef GET_LINK_IMPL
44978	return emitSetLocalIntAP
44979	#else
44980	return emitSetLocal<PT_IntAP>
44981	#endif
44982	(A0, I);
44983	case PT_IntAPS:
44984	#ifdef GET_LINK_IMPL
44985	return emitSetLocalIntAPS
44986	#else
44987	return emitSetLocal<PT_IntAPS>
44988	#endif
44989	(A0, I);
44990	case PT_Bool:
44991	#ifdef GET_LINK_IMPL
44992	return emitSetLocalBool
44993	#else
44994	return emitSetLocal<PT_Bool>
44995	#endif
44996	(A0, I);
44997	case PT_FixedPoint:
44998	#ifdef GET_LINK_IMPL
44999	return emitSetLocalFixedPoint
45000	#else
45001	return emitSetLocal<PT_FixedPoint>
45002	#endif
45003	(A0, I);
45004	case PT_Ptr:
45005	#ifdef GET_LINK_IMPL
45006	return emitSetLocalPtr
45007	#else
45008	return emitSetLocal<PT_Ptr>
45009	#endif
45010	(A0, I);
45011	case PT_MemberPtr:
45012	#ifdef GET_LINK_IMPL
45013	return emitSetLocalMemberPtr
45014	#else
45015	return emitSetLocal<PT_MemberPtr>
45016	#endif
45017	(A0, I);
45018	case PT_Float:
45019	#ifdef GET_LINK_IMPL
45020	return emitSetLocalFloat
45021	#else
45022	return emitSetLocal<PT_Float>
45023	#endif
45024	(A0, I);
45025	}
45026	llvm_unreachable("invalid enum value");
45027	}
45028	#endif
45029	#ifdef GET_LINK_IMPL
45030	bool ByteCodeEmitter::emitSetLocalSint8( uint32_t A0, SourceInfo L) {
45031	return emitOp<uint32_t>(OP_SetLocalSint8, A0, L);
45032	}
45033	bool ByteCodeEmitter::emitSetLocalUint8( uint32_t A0, SourceInfo L) {
45034	return emitOp<uint32_t>(OP_SetLocalUint8, A0, L);
45035	}
45036	bool ByteCodeEmitter::emitSetLocalSint16( uint32_t A0, SourceInfo L) {
45037	return emitOp<uint32_t>(OP_SetLocalSint16, A0, L);
45038	}
45039	bool ByteCodeEmitter::emitSetLocalUint16( uint32_t A0, SourceInfo L) {
45040	return emitOp<uint32_t>(OP_SetLocalUint16, A0, L);
45041	}
45042	bool ByteCodeEmitter::emitSetLocalSint32( uint32_t A0, SourceInfo L) {
45043	return emitOp<uint32_t>(OP_SetLocalSint32, A0, L);
45044	}
45045	bool ByteCodeEmitter::emitSetLocalUint32( uint32_t A0, SourceInfo L) {
45046	return emitOp<uint32_t>(OP_SetLocalUint32, A0, L);
45047	}
45048	bool ByteCodeEmitter::emitSetLocalSint64( uint32_t A0, SourceInfo L) {
45049	return emitOp<uint32_t>(OP_SetLocalSint64, A0, L);
45050	}
45051	bool ByteCodeEmitter::emitSetLocalUint64( uint32_t A0, SourceInfo L) {
45052	return emitOp<uint32_t>(OP_SetLocalUint64, A0, L);
45053	}
45054	bool ByteCodeEmitter::emitSetLocalIntAP( uint32_t A0, SourceInfo L) {
45055	return emitOp<uint32_t>(OP_SetLocalIntAP, A0, L);
45056	}
45057	bool ByteCodeEmitter::emitSetLocalIntAPS( uint32_t A0, SourceInfo L) {
45058	return emitOp<uint32_t>(OP_SetLocalIntAPS, A0, L);
45059	}
45060	bool ByteCodeEmitter::emitSetLocalBool( uint32_t A0, SourceInfo L) {
45061	return emitOp<uint32_t>(OP_SetLocalBool, A0, L);
45062	}
45063	bool ByteCodeEmitter::emitSetLocalFixedPoint( uint32_t A0, SourceInfo L) {
45064	return emitOp<uint32_t>(OP_SetLocalFixedPoint, A0, L);
45065	}
45066	bool ByteCodeEmitter::emitSetLocalPtr( uint32_t A0, SourceInfo L) {
45067	return emitOp<uint32_t>(OP_SetLocalPtr, A0, L);
45068	}
45069	bool ByteCodeEmitter::emitSetLocalMemberPtr( uint32_t A0, SourceInfo L) {
45070	return emitOp<uint32_t>(OP_SetLocalMemberPtr, A0, L);
45071	}
45072	bool ByteCodeEmitter::emitSetLocalFloat( uint32_t A0, SourceInfo L) {
45073	return emitOp<uint32_t>(OP_SetLocalFloat, A0, L);
45074	}
45075	#endif
45076	#ifdef GET_OPCODE_NAMES
45077	OP_SetParamSint8,
45078	OP_SetParamUint8,
45079	OP_SetParamSint16,
45080	OP_SetParamUint16,
45081	OP_SetParamSint32,
45082	OP_SetParamUint32,
45083	OP_SetParamSint64,
45084	OP_SetParamUint64,
45085	OP_SetParamIntAP,
45086	OP_SetParamIntAPS,
45087	OP_SetParamBool,
45088	OP_SetParamFixedPoint,
45089	OP_SetParamPtr,
45090	OP_SetParamMemberPtr,
45091	OP_SetParamFloat,
45092	#endif
45093	#ifdef GET_INTERPFN_LIST
45094	&Interp_SetParamSint8,
45095	&Interp_SetParamUint8,
45096	&Interp_SetParamSint16,
45097	&Interp_SetParamUint16,
45098	&Interp_SetParamSint32,
45099	&Interp_SetParamUint32,
45100	&Interp_SetParamSint64,
45101	&Interp_SetParamUint64,
45102	&Interp_SetParamIntAP,
45103	&Interp_SetParamIntAPS,
45104	&Interp_SetParamBool,
45105	&Interp_SetParamFixedPoint,
45106	&Interp_SetParamPtr,
45107	&Interp_SetParamMemberPtr,
45108	&Interp_SetParamFloat,
45109	#endif
45110	#ifdef GET_INTERPFN_DISPATCHERS
45111	PRESERVE_NONE
45112	static bool Interp_SetParamSint8(InterpState &S) {
45113	{
45114	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45115	SetParam<PT_Sint8>(S, V0);
45116	}
45117	#if USE_TAILCALLS
45118	MUSTTAIL return InterpNext(S);
45119	#else
45120	return true;
45121	#endif
45122	}
45123	PRESERVE_NONE
45124	static bool Interp_SetParamUint8(InterpState &S) {
45125	{
45126	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45127	SetParam<PT_Uint8>(S, V0);
45128	}
45129	#if USE_TAILCALLS
45130	MUSTTAIL return InterpNext(S);
45131	#else
45132	return true;
45133	#endif
45134	}
45135	PRESERVE_NONE
45136	static bool Interp_SetParamSint16(InterpState &S) {
45137	{
45138	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45139	SetParam<PT_Sint16>(S, V0);
45140	}
45141	#if USE_TAILCALLS
45142	MUSTTAIL return InterpNext(S);
45143	#else
45144	return true;
45145	#endif
45146	}
45147	PRESERVE_NONE
45148	static bool Interp_SetParamUint16(InterpState &S) {
45149	{
45150	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45151	SetParam<PT_Uint16>(S, V0);
45152	}
45153	#if USE_TAILCALLS
45154	MUSTTAIL return InterpNext(S);
45155	#else
45156	return true;
45157	#endif
45158	}
45159	PRESERVE_NONE
45160	static bool Interp_SetParamSint32(InterpState &S) {
45161	{
45162	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45163	SetParam<PT_Sint32>(S, V0);
45164	}
45165	#if USE_TAILCALLS
45166	MUSTTAIL return InterpNext(S);
45167	#else
45168	return true;
45169	#endif
45170	}
45171	PRESERVE_NONE
45172	static bool Interp_SetParamUint32(InterpState &S) {
45173	{
45174	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45175	SetParam<PT_Uint32>(S, V0);
45176	}
45177	#if USE_TAILCALLS
45178	MUSTTAIL return InterpNext(S);
45179	#else
45180	return true;
45181	#endif
45182	}
45183	PRESERVE_NONE
45184	static bool Interp_SetParamSint64(InterpState &S) {
45185	{
45186	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45187	SetParam<PT_Sint64>(S, V0);
45188	}
45189	#if USE_TAILCALLS
45190	MUSTTAIL return InterpNext(S);
45191	#else
45192	return true;
45193	#endif
45194	}
45195	PRESERVE_NONE
45196	static bool Interp_SetParamUint64(InterpState &S) {
45197	{
45198	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45199	SetParam<PT_Uint64>(S, V0);
45200	}
45201	#if USE_TAILCALLS
45202	MUSTTAIL return InterpNext(S);
45203	#else
45204	return true;
45205	#endif
45206	}
45207	PRESERVE_NONE
45208	static bool Interp_SetParamIntAP(InterpState &S) {
45209	{
45210	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45211	SetParam<PT_IntAP>(S, V0);
45212	}
45213	#if USE_TAILCALLS
45214	MUSTTAIL return InterpNext(S);
45215	#else
45216	return true;
45217	#endif
45218	}
45219	PRESERVE_NONE
45220	static bool Interp_SetParamIntAPS(InterpState &S) {
45221	{
45222	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45223	SetParam<PT_IntAPS>(S, V0);
45224	}
45225	#if USE_TAILCALLS
45226	MUSTTAIL return InterpNext(S);
45227	#else
45228	return true;
45229	#endif
45230	}
45231	PRESERVE_NONE
45232	static bool Interp_SetParamBool(InterpState &S) {
45233	{
45234	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45235	SetParam<PT_Bool>(S, V0);
45236	}
45237	#if USE_TAILCALLS
45238	MUSTTAIL return InterpNext(S);
45239	#else
45240	return true;
45241	#endif
45242	}
45243	PRESERVE_NONE
45244	static bool Interp_SetParamFixedPoint(InterpState &S) {
45245	{
45246	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45247	SetParam<PT_FixedPoint>(S, V0);
45248	}
45249	#if USE_TAILCALLS
45250	MUSTTAIL return InterpNext(S);
45251	#else
45252	return true;
45253	#endif
45254	}
45255	PRESERVE_NONE
45256	static bool Interp_SetParamPtr(InterpState &S) {
45257	{
45258	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45259	SetParam<PT_Ptr>(S, V0);
45260	}
45261	#if USE_TAILCALLS
45262	MUSTTAIL return InterpNext(S);
45263	#else
45264	return true;
45265	#endif
45266	}
45267	PRESERVE_NONE
45268	static bool Interp_SetParamMemberPtr(InterpState &S) {
45269	{
45270	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45271	SetParam<PT_MemberPtr>(S, V0);
45272	}
45273	#if USE_TAILCALLS
45274	MUSTTAIL return InterpNext(S);
45275	#else
45276	return true;
45277	#endif
45278	}
45279	PRESERVE_NONE
45280	static bool Interp_SetParamFloat(InterpState &S) {
45281	{
45282	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45283	SetParam<PT_Float>(S, V0);
45284	}
45285	#if USE_TAILCALLS
45286	MUSTTAIL return InterpNext(S);
45287	#else
45288	return true;
45289	#endif
45290	}
45291	#endif
45292	#ifdef GET_DISASM
45293	case OP_SetParamSint8:
45294	Text.Op = PrintName("SetParamSint8");
45295	Text.Args.push_back(printArg<uint32_t>(P, PC));
45296	break;
45297	case OP_SetParamUint8:
45298	Text.Op = PrintName("SetParamUint8");
45299	Text.Args.push_back(printArg<uint32_t>(P, PC));
45300	break;
45301	case OP_SetParamSint16:
45302	Text.Op = PrintName("SetParamSint16");
45303	Text.Args.push_back(printArg<uint32_t>(P, PC));
45304	break;
45305	case OP_SetParamUint16:
45306	Text.Op = PrintName("SetParamUint16");
45307	Text.Args.push_back(printArg<uint32_t>(P, PC));
45308	break;
45309	case OP_SetParamSint32:
45310	Text.Op = PrintName("SetParamSint32");
45311	Text.Args.push_back(printArg<uint32_t>(P, PC));
45312	break;
45313	case OP_SetParamUint32:
45314	Text.Op = PrintName("SetParamUint32");
45315	Text.Args.push_back(printArg<uint32_t>(P, PC));
45316	break;
45317	case OP_SetParamSint64:
45318	Text.Op = PrintName("SetParamSint64");
45319	Text.Args.push_back(printArg<uint32_t>(P, PC));
45320	break;
45321	case OP_SetParamUint64:
45322	Text.Op = PrintName("SetParamUint64");
45323	Text.Args.push_back(printArg<uint32_t>(P, PC));
45324	break;
45325	case OP_SetParamIntAP:
45326	Text.Op = PrintName("SetParamIntAP");
45327	Text.Args.push_back(printArg<uint32_t>(P, PC));
45328	break;
45329	case OP_SetParamIntAPS:
45330	Text.Op = PrintName("SetParamIntAPS");
45331	Text.Args.push_back(printArg<uint32_t>(P, PC));
45332	break;
45333	case OP_SetParamBool:
45334	Text.Op = PrintName("SetParamBool");
45335	Text.Args.push_back(printArg<uint32_t>(P, PC));
45336	break;
45337	case OP_SetParamFixedPoint:
45338	Text.Op = PrintName("SetParamFixedPoint");
45339	Text.Args.push_back(printArg<uint32_t>(P, PC));
45340	break;
45341	case OP_SetParamPtr:
45342	Text.Op = PrintName("SetParamPtr");
45343	Text.Args.push_back(printArg<uint32_t>(P, PC));
45344	break;
45345	case OP_SetParamMemberPtr:
45346	Text.Op = PrintName("SetParamMemberPtr");
45347	Text.Args.push_back(printArg<uint32_t>(P, PC));
45348	break;
45349	case OP_SetParamFloat:
45350	Text.Op = PrintName("SetParamFloat");
45351	Text.Args.push_back(printArg<uint32_t>(P, PC));
45352	break;
45353	#endif
45354	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
45355	bool emitSetParamSint8( uint32_t , SourceInfo);
45356	bool emitSetParamUint8( uint32_t , SourceInfo);
45357	bool emitSetParamSint16( uint32_t , SourceInfo);
45358	bool emitSetParamUint16( uint32_t , SourceInfo);
45359	bool emitSetParamSint32( uint32_t , SourceInfo);
45360	bool emitSetParamUint32( uint32_t , SourceInfo);
45361	bool emitSetParamSint64( uint32_t , SourceInfo);
45362	bool emitSetParamUint64( uint32_t , SourceInfo);
45363	bool emitSetParamIntAP( uint32_t , SourceInfo);
45364	bool emitSetParamIntAPS( uint32_t , SourceInfo);
45365	bool emitSetParamBool( uint32_t , SourceInfo);
45366	bool emitSetParamFixedPoint( uint32_t , SourceInfo);
45367	bool emitSetParamPtr( uint32_t , SourceInfo);
45368	bool emitSetParamMemberPtr( uint32_t , SourceInfo);
45369	bool emitSetParamFloat( uint32_t , SourceInfo);
45370	#endif
45371	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
45372	[[nodiscard]] bool emitSetParam(PrimType, uint32_t, SourceInfo I);
45373	#endif
45374	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
45375	bool
45376	#if defined(GET_EVAL_IMPL)
45377	EvalEmitter
45378	#else
45379	ByteCodeEmitter
45380	#endif
45381	::emitSetParam(PrimType T0, uint32_t A0, SourceInfo I) {
45382	switch (T0) {
45383	case PT_Sint8:
45384	return emitSetParamSint8(A0, I);
45385	case PT_Uint8:
45386	return emitSetParamUint8(A0, I);
45387	case PT_Sint16:
45388	return emitSetParamSint16(A0, I);
45389	case PT_Uint16:
45390	return emitSetParamUint16(A0, I);
45391	case PT_Sint32:
45392	return emitSetParamSint32(A0, I);
45393	case PT_Uint32:
45394	return emitSetParamUint32(A0, I);
45395	case PT_Sint64:
45396	return emitSetParamSint64(A0, I);
45397	case PT_Uint64:
45398	return emitSetParamUint64(A0, I);
45399	case PT_IntAP:
45400	return emitSetParamIntAP(A0, I);
45401	case PT_IntAPS:
45402	return emitSetParamIntAPS(A0, I);
45403	case PT_Bool:
45404	return emitSetParamBool(A0, I);
45405	case PT_FixedPoint:
45406	return emitSetParamFixedPoint(A0, I);
45407	case PT_Ptr:
45408	return emitSetParamPtr(A0, I);
45409	case PT_MemberPtr:
45410	return emitSetParamMemberPtr(A0, I);
45411	case PT_Float:
45412	return emitSetParamFloat(A0, I);
45413	}
45414	llvm_unreachable("invalid enum value");
45415	}
45416	#endif
45417	#ifdef GET_LINK_IMPL
45418	bool ByteCodeEmitter::emitSetParamSint8( uint32_t A0, SourceInfo L) {
45419	return emitOp<uint32_t>(OP_SetParamSint8, A0, L);
45420	}
45421	bool ByteCodeEmitter::emitSetParamUint8( uint32_t A0, SourceInfo L) {
45422	return emitOp<uint32_t>(OP_SetParamUint8, A0, L);
45423	}
45424	bool ByteCodeEmitter::emitSetParamSint16( uint32_t A0, SourceInfo L) {
45425	return emitOp<uint32_t>(OP_SetParamSint16, A0, L);
45426	}
45427	bool ByteCodeEmitter::emitSetParamUint16( uint32_t A0, SourceInfo L) {
45428	return emitOp<uint32_t>(OP_SetParamUint16, A0, L);
45429	}
45430	bool ByteCodeEmitter::emitSetParamSint32( uint32_t A0, SourceInfo L) {
45431	return emitOp<uint32_t>(OP_SetParamSint32, A0, L);
45432	}
45433	bool ByteCodeEmitter::emitSetParamUint32( uint32_t A0, SourceInfo L) {
45434	return emitOp<uint32_t>(OP_SetParamUint32, A0, L);
45435	}
45436	bool ByteCodeEmitter::emitSetParamSint64( uint32_t A0, SourceInfo L) {
45437	return emitOp<uint32_t>(OP_SetParamSint64, A0, L);
45438	}
45439	bool ByteCodeEmitter::emitSetParamUint64( uint32_t A0, SourceInfo L) {
45440	return emitOp<uint32_t>(OP_SetParamUint64, A0, L);
45441	}
45442	bool ByteCodeEmitter::emitSetParamIntAP( uint32_t A0, SourceInfo L) {
45443	return emitOp<uint32_t>(OP_SetParamIntAP, A0, L);
45444	}
45445	bool ByteCodeEmitter::emitSetParamIntAPS( uint32_t A0, SourceInfo L) {
45446	return emitOp<uint32_t>(OP_SetParamIntAPS, A0, L);
45447	}
45448	bool ByteCodeEmitter::emitSetParamBool( uint32_t A0, SourceInfo L) {
45449	return emitOp<uint32_t>(OP_SetParamBool, A0, L);
45450	}
45451	bool ByteCodeEmitter::emitSetParamFixedPoint( uint32_t A0, SourceInfo L) {
45452	return emitOp<uint32_t>(OP_SetParamFixedPoint, A0, L);
45453	}
45454	bool ByteCodeEmitter::emitSetParamPtr( uint32_t A0, SourceInfo L) {
45455	return emitOp<uint32_t>(OP_SetParamPtr, A0, L);
45456	}
45457	bool ByteCodeEmitter::emitSetParamMemberPtr( uint32_t A0, SourceInfo L) {
45458	return emitOp<uint32_t>(OP_SetParamMemberPtr, A0, L);
45459	}
45460	bool ByteCodeEmitter::emitSetParamFloat( uint32_t A0, SourceInfo L) {
45461	return emitOp<uint32_t>(OP_SetParamFloat, A0, L);
45462	}
45463	#endif
45464	#ifdef GET_EVAL_IMPL
45465	bool EvalEmitter::emitSetParamSint8( uint32_t A0, SourceInfo L) {
45466	if (!isActive()) return true;
45467	CurrentSource = L;
45468	return SetParam<PT_Sint8>(S, A0);
45469	}
45470	bool EvalEmitter::emitSetParamUint8( uint32_t A0, SourceInfo L) {
45471	if (!isActive()) return true;
45472	CurrentSource = L;
45473	return SetParam<PT_Uint8>(S, A0);
45474	}
45475	bool EvalEmitter::emitSetParamSint16( uint32_t A0, SourceInfo L) {
45476	if (!isActive()) return true;
45477	CurrentSource = L;
45478	return SetParam<PT_Sint16>(S, A0);
45479	}
45480	bool EvalEmitter::emitSetParamUint16( uint32_t A0, SourceInfo L) {
45481	if (!isActive()) return true;
45482	CurrentSource = L;
45483	return SetParam<PT_Uint16>(S, A0);
45484	}
45485	bool EvalEmitter::emitSetParamSint32( uint32_t A0, SourceInfo L) {
45486	if (!isActive()) return true;
45487	CurrentSource = L;
45488	return SetParam<PT_Sint32>(S, A0);
45489	}
45490	bool EvalEmitter::emitSetParamUint32( uint32_t A0, SourceInfo L) {
45491	if (!isActive()) return true;
45492	CurrentSource = L;
45493	return SetParam<PT_Uint32>(S, A0);
45494	}
45495	bool EvalEmitter::emitSetParamSint64( uint32_t A0, SourceInfo L) {
45496	if (!isActive()) return true;
45497	CurrentSource = L;
45498	return SetParam<PT_Sint64>(S, A0);
45499	}
45500	bool EvalEmitter::emitSetParamUint64( uint32_t A0, SourceInfo L) {
45501	if (!isActive()) return true;
45502	CurrentSource = L;
45503	return SetParam<PT_Uint64>(S, A0);
45504	}
45505	bool EvalEmitter::emitSetParamIntAP( uint32_t A0, SourceInfo L) {
45506	if (!isActive()) return true;
45507	CurrentSource = L;
45508	return SetParam<PT_IntAP>(S, A0);
45509	}
45510	bool EvalEmitter::emitSetParamIntAPS( uint32_t A0, SourceInfo L) {
45511	if (!isActive()) return true;
45512	CurrentSource = L;
45513	return SetParam<PT_IntAPS>(S, A0);
45514	}
45515	bool EvalEmitter::emitSetParamBool( uint32_t A0, SourceInfo L) {
45516	if (!isActive()) return true;
45517	CurrentSource = L;
45518	return SetParam<PT_Bool>(S, A0);
45519	}
45520	bool EvalEmitter::emitSetParamFixedPoint( uint32_t A0, SourceInfo L) {
45521	if (!isActive()) return true;
45522	CurrentSource = L;
45523	return SetParam<PT_FixedPoint>(S, A0);
45524	}
45525	bool EvalEmitter::emitSetParamPtr( uint32_t A0, SourceInfo L) {
45526	if (!isActive()) return true;
45527	CurrentSource = L;
45528	return SetParam<PT_Ptr>(S, A0);
45529	}
45530	bool EvalEmitter::emitSetParamMemberPtr( uint32_t A0, SourceInfo L) {
45531	if (!isActive()) return true;
45532	CurrentSource = L;
45533	return SetParam<PT_MemberPtr>(S, A0);
45534	}
45535	bool EvalEmitter::emitSetParamFloat( uint32_t A0, SourceInfo L) {
45536	if (!isActive()) return true;
45537	CurrentSource = L;
45538	return SetParam<PT_Float>(S, A0);
45539	}
45540	#endif
45541	#ifdef GET_OPCODE_NAMES
45542	OP_SetThisFieldSint8,
45543	OP_SetThisFieldUint8,
45544	OP_SetThisFieldSint16,
45545	OP_SetThisFieldUint16,
45546	OP_SetThisFieldSint32,
45547	OP_SetThisFieldUint32,
45548	OP_SetThisFieldSint64,
45549	OP_SetThisFieldUint64,
45550	OP_SetThisFieldIntAP,
45551	OP_SetThisFieldIntAPS,
45552	OP_SetThisFieldBool,
45553	OP_SetThisFieldFixedPoint,
45554	OP_SetThisFieldPtr,
45555	OP_SetThisFieldMemberPtr,
45556	OP_SetThisFieldFloat,
45557	#endif
45558	#ifdef GET_INTERPFN_LIST
45559	&Interp_SetThisFieldSint8,
45560	&Interp_SetThisFieldUint8,
45561	&Interp_SetThisFieldSint16,
45562	&Interp_SetThisFieldUint16,
45563	&Interp_SetThisFieldSint32,
45564	&Interp_SetThisFieldUint32,
45565	&Interp_SetThisFieldSint64,
45566	&Interp_SetThisFieldUint64,
45567	&Interp_SetThisFieldIntAP,
45568	&Interp_SetThisFieldIntAPS,
45569	&Interp_SetThisFieldBool,
45570	&Interp_SetThisFieldFixedPoint,
45571	&Interp_SetThisFieldPtr,
45572	&Interp_SetThisFieldMemberPtr,
45573	&Interp_SetThisFieldFloat,
45574	#endif
45575	#ifdef GET_INTERPFN_DISPATCHERS
45576	PRESERVE_NONE
45577	static bool Interp_SetThisFieldSint8(InterpState &S) {
45578	{
45579	CodePtr OpPC = S.PC;
45580	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45581	if (!SetThisField<PT_Sint8>(S, OpPC, V0)) return false;
45582	}
45583	#if USE_TAILCALLS
45584	MUSTTAIL return InterpNext(S);
45585	#else
45586	return true;
45587	#endif
45588	}
45589	PRESERVE_NONE
45590	static bool Interp_SetThisFieldUint8(InterpState &S) {
45591	{
45592	CodePtr OpPC = S.PC;
45593	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45594	if (!SetThisField<PT_Uint8>(S, OpPC, V0)) return false;
45595	}
45596	#if USE_TAILCALLS
45597	MUSTTAIL return InterpNext(S);
45598	#else
45599	return true;
45600	#endif
45601	}
45602	PRESERVE_NONE
45603	static bool Interp_SetThisFieldSint16(InterpState &S) {
45604	{
45605	CodePtr OpPC = S.PC;
45606	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45607	if (!SetThisField<PT_Sint16>(S, OpPC, V0)) return false;
45608	}
45609	#if USE_TAILCALLS
45610	MUSTTAIL return InterpNext(S);
45611	#else
45612	return true;
45613	#endif
45614	}
45615	PRESERVE_NONE
45616	static bool Interp_SetThisFieldUint16(InterpState &S) {
45617	{
45618	CodePtr OpPC = S.PC;
45619	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45620	if (!SetThisField<PT_Uint16>(S, OpPC, V0)) return false;
45621	}
45622	#if USE_TAILCALLS
45623	MUSTTAIL return InterpNext(S);
45624	#else
45625	return true;
45626	#endif
45627	}
45628	PRESERVE_NONE
45629	static bool Interp_SetThisFieldSint32(InterpState &S) {
45630	{
45631	CodePtr OpPC = S.PC;
45632	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45633	if (!SetThisField<PT_Sint32>(S, OpPC, V0)) return false;
45634	}
45635	#if USE_TAILCALLS
45636	MUSTTAIL return InterpNext(S);
45637	#else
45638	return true;
45639	#endif
45640	}
45641	PRESERVE_NONE
45642	static bool Interp_SetThisFieldUint32(InterpState &S) {
45643	{
45644	CodePtr OpPC = S.PC;
45645	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45646	if (!SetThisField<PT_Uint32>(S, OpPC, V0)) return false;
45647	}
45648	#if USE_TAILCALLS
45649	MUSTTAIL return InterpNext(S);
45650	#else
45651	return true;
45652	#endif
45653	}
45654	PRESERVE_NONE
45655	static bool Interp_SetThisFieldSint64(InterpState &S) {
45656	{
45657	CodePtr OpPC = S.PC;
45658	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45659	if (!SetThisField<PT_Sint64>(S, OpPC, V0)) return false;
45660	}
45661	#if USE_TAILCALLS
45662	MUSTTAIL return InterpNext(S);
45663	#else
45664	return true;
45665	#endif
45666	}
45667	PRESERVE_NONE
45668	static bool Interp_SetThisFieldUint64(InterpState &S) {
45669	{
45670	CodePtr OpPC = S.PC;
45671	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45672	if (!SetThisField<PT_Uint64>(S, OpPC, V0)) return false;
45673	}
45674	#if USE_TAILCALLS
45675	MUSTTAIL return InterpNext(S);
45676	#else
45677	return true;
45678	#endif
45679	}
45680	PRESERVE_NONE
45681	static bool Interp_SetThisFieldIntAP(InterpState &S) {
45682	{
45683	CodePtr OpPC = S.PC;
45684	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45685	if (!SetThisField<PT_IntAP>(S, OpPC, V0)) return false;
45686	}
45687	#if USE_TAILCALLS
45688	MUSTTAIL return InterpNext(S);
45689	#else
45690	return true;
45691	#endif
45692	}
45693	PRESERVE_NONE
45694	static bool Interp_SetThisFieldIntAPS(InterpState &S) {
45695	{
45696	CodePtr OpPC = S.PC;
45697	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45698	if (!SetThisField<PT_IntAPS>(S, OpPC, V0)) return false;
45699	}
45700	#if USE_TAILCALLS
45701	MUSTTAIL return InterpNext(S);
45702	#else
45703	return true;
45704	#endif
45705	}
45706	PRESERVE_NONE
45707	static bool Interp_SetThisFieldBool(InterpState &S) {
45708	{
45709	CodePtr OpPC = S.PC;
45710	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45711	if (!SetThisField<PT_Bool>(S, OpPC, V0)) return false;
45712	}
45713	#if USE_TAILCALLS
45714	MUSTTAIL return InterpNext(S);
45715	#else
45716	return true;
45717	#endif
45718	}
45719	PRESERVE_NONE
45720	static bool Interp_SetThisFieldFixedPoint(InterpState &S) {
45721	{
45722	CodePtr OpPC = S.PC;
45723	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45724	if (!SetThisField<PT_FixedPoint>(S, OpPC, V0)) return false;
45725	}
45726	#if USE_TAILCALLS
45727	MUSTTAIL return InterpNext(S);
45728	#else
45729	return true;
45730	#endif
45731	}
45732	PRESERVE_NONE
45733	static bool Interp_SetThisFieldPtr(InterpState &S) {
45734	{
45735	CodePtr OpPC = S.PC;
45736	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45737	if (!SetThisField<PT_Ptr>(S, OpPC, V0)) return false;
45738	}
45739	#if USE_TAILCALLS
45740	MUSTTAIL return InterpNext(S);
45741	#else
45742	return true;
45743	#endif
45744	}
45745	PRESERVE_NONE
45746	static bool Interp_SetThisFieldMemberPtr(InterpState &S) {
45747	{
45748	CodePtr OpPC = S.PC;
45749	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45750	if (!SetThisField<PT_MemberPtr>(S, OpPC, V0)) return false;
45751	}
45752	#if USE_TAILCALLS
45753	MUSTTAIL return InterpNext(S);
45754	#else
45755	return true;
45756	#endif
45757	}
45758	PRESERVE_NONE
45759	static bool Interp_SetThisFieldFloat(InterpState &S) {
45760	{
45761	CodePtr OpPC = S.PC;
45762	const auto V0 = ReadArg<uint32_t>(S, S.PC);
45763	if (!SetThisField<PT_Float>(S, OpPC, V0)) return false;
45764	}
45765	#if USE_TAILCALLS
45766	MUSTTAIL return InterpNext(S);
45767	#else
45768	return true;
45769	#endif
45770	}
45771	#endif
45772	#ifdef GET_DISASM
45773	case OP_SetThisFieldSint8:
45774	Text.Op = PrintName("SetThisFieldSint8");
45775	Text.Args.push_back(printArg<uint32_t>(P, PC));
45776	break;
45777	case OP_SetThisFieldUint8:
45778	Text.Op = PrintName("SetThisFieldUint8");
45779	Text.Args.push_back(printArg<uint32_t>(P, PC));
45780	break;
45781	case OP_SetThisFieldSint16:
45782	Text.Op = PrintName("SetThisFieldSint16");
45783	Text.Args.push_back(printArg<uint32_t>(P, PC));
45784	break;
45785	case OP_SetThisFieldUint16:
45786	Text.Op = PrintName("SetThisFieldUint16");
45787	Text.Args.push_back(printArg<uint32_t>(P, PC));
45788	break;
45789	case OP_SetThisFieldSint32:
45790	Text.Op = PrintName("SetThisFieldSint32");
45791	Text.Args.push_back(printArg<uint32_t>(P, PC));
45792	break;
45793	case OP_SetThisFieldUint32:
45794	Text.Op = PrintName("SetThisFieldUint32");
45795	Text.Args.push_back(printArg<uint32_t>(P, PC));
45796	break;
45797	case OP_SetThisFieldSint64:
45798	Text.Op = PrintName("SetThisFieldSint64");
45799	Text.Args.push_back(printArg<uint32_t>(P, PC));
45800	break;
45801	case OP_SetThisFieldUint64:
45802	Text.Op = PrintName("SetThisFieldUint64");
45803	Text.Args.push_back(printArg<uint32_t>(P, PC));
45804	break;
45805	case OP_SetThisFieldIntAP:
45806	Text.Op = PrintName("SetThisFieldIntAP");
45807	Text.Args.push_back(printArg<uint32_t>(P, PC));
45808	break;
45809	case OP_SetThisFieldIntAPS:
45810	Text.Op = PrintName("SetThisFieldIntAPS");
45811	Text.Args.push_back(printArg<uint32_t>(P, PC));
45812	break;
45813	case OP_SetThisFieldBool:
45814	Text.Op = PrintName("SetThisFieldBool");
45815	Text.Args.push_back(printArg<uint32_t>(P, PC));
45816	break;
45817	case OP_SetThisFieldFixedPoint:
45818	Text.Op = PrintName("SetThisFieldFixedPoint");
45819	Text.Args.push_back(printArg<uint32_t>(P, PC));
45820	break;
45821	case OP_SetThisFieldPtr:
45822	Text.Op = PrintName("SetThisFieldPtr");
45823	Text.Args.push_back(printArg<uint32_t>(P, PC));
45824	break;
45825	case OP_SetThisFieldMemberPtr:
45826	Text.Op = PrintName("SetThisFieldMemberPtr");
45827	Text.Args.push_back(printArg<uint32_t>(P, PC));
45828	break;
45829	case OP_SetThisFieldFloat:
45830	Text.Op = PrintName("SetThisFieldFloat");
45831	Text.Args.push_back(printArg<uint32_t>(P, PC));
45832	break;
45833	#endif
45834	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
45835	bool emitSetThisFieldSint8( uint32_t , SourceInfo);
45836	bool emitSetThisFieldUint8( uint32_t , SourceInfo);
45837	bool emitSetThisFieldSint16( uint32_t , SourceInfo);
45838	bool emitSetThisFieldUint16( uint32_t , SourceInfo);
45839	bool emitSetThisFieldSint32( uint32_t , SourceInfo);
45840	bool emitSetThisFieldUint32( uint32_t , SourceInfo);
45841	bool emitSetThisFieldSint64( uint32_t , SourceInfo);
45842	bool emitSetThisFieldUint64( uint32_t , SourceInfo);
45843	bool emitSetThisFieldIntAP( uint32_t , SourceInfo);
45844	bool emitSetThisFieldIntAPS( uint32_t , SourceInfo);
45845	bool emitSetThisFieldBool( uint32_t , SourceInfo);
45846	bool emitSetThisFieldFixedPoint( uint32_t , SourceInfo);
45847	bool emitSetThisFieldPtr( uint32_t , SourceInfo);
45848	bool emitSetThisFieldMemberPtr( uint32_t , SourceInfo);
45849	bool emitSetThisFieldFloat( uint32_t , SourceInfo);
45850	#endif
45851	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
45852	[[nodiscard]] bool emitSetThisField(PrimType, uint32_t, SourceInfo I);
45853	#endif
45854	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
45855	bool
45856	#if defined(GET_EVAL_IMPL)
45857	EvalEmitter
45858	#else
45859	ByteCodeEmitter
45860	#endif
45861	::emitSetThisField(PrimType T0, uint32_t A0, SourceInfo I) {
45862	switch (T0) {
45863	case PT_Sint8:
45864	return emitSetThisFieldSint8(A0, I);
45865	case PT_Uint8:
45866	return emitSetThisFieldUint8(A0, I);
45867	case PT_Sint16:
45868	return emitSetThisFieldSint16(A0, I);
45869	case PT_Uint16:
45870	return emitSetThisFieldUint16(A0, I);
45871	case PT_Sint32:
45872	return emitSetThisFieldSint32(A0, I);
45873	case PT_Uint32:
45874	return emitSetThisFieldUint32(A0, I);
45875	case PT_Sint64:
45876	return emitSetThisFieldSint64(A0, I);
45877	case PT_Uint64:
45878	return emitSetThisFieldUint64(A0, I);
45879	case PT_IntAP:
45880	return emitSetThisFieldIntAP(A0, I);
45881	case PT_IntAPS:
45882	return emitSetThisFieldIntAPS(A0, I);
45883	case PT_Bool:
45884	return emitSetThisFieldBool(A0, I);
45885	case PT_FixedPoint:
45886	return emitSetThisFieldFixedPoint(A0, I);
45887	case PT_Ptr:
45888	return emitSetThisFieldPtr(A0, I);
45889	case PT_MemberPtr:
45890	return emitSetThisFieldMemberPtr(A0, I);
45891	case PT_Float:
45892	return emitSetThisFieldFloat(A0, I);
45893	}
45894	llvm_unreachable("invalid enum value");
45895	}
45896	#endif
45897	#ifdef GET_LINK_IMPL
45898	bool ByteCodeEmitter::emitSetThisFieldSint8( uint32_t A0, SourceInfo L) {
45899	return emitOp<uint32_t>(OP_SetThisFieldSint8, A0, L);
45900	}
45901	bool ByteCodeEmitter::emitSetThisFieldUint8( uint32_t A0, SourceInfo L) {
45902	return emitOp<uint32_t>(OP_SetThisFieldUint8, A0, L);
45903	}
45904	bool ByteCodeEmitter::emitSetThisFieldSint16( uint32_t A0, SourceInfo L) {
45905	return emitOp<uint32_t>(OP_SetThisFieldSint16, A0, L);
45906	}
45907	bool ByteCodeEmitter::emitSetThisFieldUint16( uint32_t A0, SourceInfo L) {
45908	return emitOp<uint32_t>(OP_SetThisFieldUint16, A0, L);
45909	}
45910	bool ByteCodeEmitter::emitSetThisFieldSint32( uint32_t A0, SourceInfo L) {
45911	return emitOp<uint32_t>(OP_SetThisFieldSint32, A0, L);
45912	}
45913	bool ByteCodeEmitter::emitSetThisFieldUint32( uint32_t A0, SourceInfo L) {
45914	return emitOp<uint32_t>(OP_SetThisFieldUint32, A0, L);
45915	}
45916	bool ByteCodeEmitter::emitSetThisFieldSint64( uint32_t A0, SourceInfo L) {
45917	return emitOp<uint32_t>(OP_SetThisFieldSint64, A0, L);
45918	}
45919	bool ByteCodeEmitter::emitSetThisFieldUint64( uint32_t A0, SourceInfo L) {
45920	return emitOp<uint32_t>(OP_SetThisFieldUint64, A0, L);
45921	}
45922	bool ByteCodeEmitter::emitSetThisFieldIntAP( uint32_t A0, SourceInfo L) {
45923	return emitOp<uint32_t>(OP_SetThisFieldIntAP, A0, L);
45924	}
45925	bool ByteCodeEmitter::emitSetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
45926	return emitOp<uint32_t>(OP_SetThisFieldIntAPS, A0, L);
45927	}
45928	bool ByteCodeEmitter::emitSetThisFieldBool( uint32_t A0, SourceInfo L) {
45929	return emitOp<uint32_t>(OP_SetThisFieldBool, A0, L);
45930	}
45931	bool ByteCodeEmitter::emitSetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
45932	return emitOp<uint32_t>(OP_SetThisFieldFixedPoint, A0, L);
45933	}
45934	bool ByteCodeEmitter::emitSetThisFieldPtr( uint32_t A0, SourceInfo L) {
45935	return emitOp<uint32_t>(OP_SetThisFieldPtr, A0, L);
45936	}
45937	bool ByteCodeEmitter::emitSetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
45938	return emitOp<uint32_t>(OP_SetThisFieldMemberPtr, A0, L);
45939	}
45940	bool ByteCodeEmitter::emitSetThisFieldFloat( uint32_t A0, SourceInfo L) {
45941	return emitOp<uint32_t>(OP_SetThisFieldFloat, A0, L);
45942	}
45943	#endif
45944	#ifdef GET_EVAL_IMPL
45945	bool EvalEmitter::emitSetThisFieldSint8( uint32_t A0, SourceInfo L) {
45946	if (!isActive()) return true;
45947	CurrentSource = L;
45948	return SetThisField<PT_Sint8>(S, CodePtr(), A0);
45949	}
45950	bool EvalEmitter::emitSetThisFieldUint8( uint32_t A0, SourceInfo L) {
45951	if (!isActive()) return true;
45952	CurrentSource = L;
45953	return SetThisField<PT_Uint8>(S, CodePtr(), A0);
45954	}
45955	bool EvalEmitter::emitSetThisFieldSint16( uint32_t A0, SourceInfo L) {
45956	if (!isActive()) return true;
45957	CurrentSource = L;
45958	return SetThisField<PT_Sint16>(S, CodePtr(), A0);
45959	}
45960	bool EvalEmitter::emitSetThisFieldUint16( uint32_t A0, SourceInfo L) {
45961	if (!isActive()) return true;
45962	CurrentSource = L;
45963	return SetThisField<PT_Uint16>(S, CodePtr(), A0);
45964	}
45965	bool EvalEmitter::emitSetThisFieldSint32( uint32_t A0, SourceInfo L) {
45966	if (!isActive()) return true;
45967	CurrentSource = L;
45968	return SetThisField<PT_Sint32>(S, CodePtr(), A0);
45969	}
45970	bool EvalEmitter::emitSetThisFieldUint32( uint32_t A0, SourceInfo L) {
45971	if (!isActive()) return true;
45972	CurrentSource = L;
45973	return SetThisField<PT_Uint32>(S, CodePtr(), A0);
45974	}
45975	bool EvalEmitter::emitSetThisFieldSint64( uint32_t A0, SourceInfo L) {
45976	if (!isActive()) return true;
45977	CurrentSource = L;
45978	return SetThisField<PT_Sint64>(S, CodePtr(), A0);
45979	}
45980	bool EvalEmitter::emitSetThisFieldUint64( uint32_t A0, SourceInfo L) {
45981	if (!isActive()) return true;
45982	CurrentSource = L;
45983	return SetThisField<PT_Uint64>(S, CodePtr(), A0);
45984	}
45985	bool EvalEmitter::emitSetThisFieldIntAP( uint32_t A0, SourceInfo L) {
45986	if (!isActive()) return true;
45987	CurrentSource = L;
45988	return SetThisField<PT_IntAP>(S, CodePtr(), A0);
45989	}
45990	bool EvalEmitter::emitSetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
45991	if (!isActive()) return true;
45992	CurrentSource = L;
45993	return SetThisField<PT_IntAPS>(S, CodePtr(), A0);
45994	}
45995	bool EvalEmitter::emitSetThisFieldBool( uint32_t A0, SourceInfo L) {
45996	if (!isActive()) return true;
45997	CurrentSource = L;
45998	return SetThisField<PT_Bool>(S, CodePtr(), A0);
45999	}
46000	bool EvalEmitter::emitSetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
46001	if (!isActive()) return true;
46002	CurrentSource = L;
46003	return SetThisField<PT_FixedPoint>(S, CodePtr(), A0);
46004	}
46005	bool EvalEmitter::emitSetThisFieldPtr( uint32_t A0, SourceInfo L) {
46006	if (!isActive()) return true;
46007	CurrentSource = L;
46008	return SetThisField<PT_Ptr>(S, CodePtr(), A0);
46009	}
46010	bool EvalEmitter::emitSetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
46011	if (!isActive()) return true;
46012	CurrentSource = L;
46013	return SetThisField<PT_MemberPtr>(S, CodePtr(), A0);
46014	}
46015	bool EvalEmitter::emitSetThisFieldFloat( uint32_t A0, SourceInfo L) {
46016	if (!isActive()) return true;
46017	CurrentSource = L;
46018	return SetThisField<PT_Float>(S, CodePtr(), A0);
46019	}
46020	#endif
46021	#ifdef GET_OPCODE_NAMES
46022	OP_ShiftFixedPoint,
46023	#endif
46024	#ifdef GET_INTERPFN_LIST
46025	&Interp_ShiftFixedPoint,
46026	#endif
46027	#ifdef GET_INTERPFN_DISPATCHERS
46028	PRESERVE_NONE
46029	static bool Interp_ShiftFixedPoint(InterpState &S) {
46030	{
46031	CodePtr OpPC = S.PC;
46032	const auto V0 = ReadArg<bool>(S, S.PC);
46033	if (!ShiftFixedPoint(S, OpPC, V0)) return false;
46034	}
46035	#if USE_TAILCALLS
46036	MUSTTAIL return InterpNext(S);
46037	#else
46038	return true;
46039	#endif
46040	}
46041	#endif
46042	#ifdef GET_DISASM
46043	case OP_ShiftFixedPoint:
46044	Text.Op = PrintName("ShiftFixedPoint");
46045	Text.Args.push_back(printArg<bool>(P, PC));
46046	break;
46047	#endif
46048	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
46049	bool emitShiftFixedPoint( bool , SourceInfo);
46050	#endif
46051	#ifdef GET_LINK_IMPL
46052	bool ByteCodeEmitter::emitShiftFixedPoint( bool A0, SourceInfo L) {
46053	return emitOp<bool>(OP_ShiftFixedPoint, A0, L);
46054	}
46055	#endif
46056	#ifdef GET_EVAL_IMPL
46057	bool EvalEmitter::emitShiftFixedPoint( bool A0, SourceInfo L) {
46058	if (!isActive()) return true;
46059	CurrentSource = L;
46060	return ShiftFixedPoint(S, CodePtr(), A0);
46061	}
46062	#endif
46063	#ifdef GET_OPCODE_NAMES
46064	OP_ShlSint8Sint8,
46065	OP_ShlSint8Uint8,
46066	OP_ShlSint8Sint16,
46067	OP_ShlSint8Uint16,
46068	OP_ShlSint8Sint32,
46069	OP_ShlSint8Uint32,
46070	OP_ShlSint8Sint64,
46071	OP_ShlSint8Uint64,
46072	OP_ShlSint8IntAP,
46073	OP_ShlSint8IntAPS,
46074	OP_ShlUint8Sint8,
46075	OP_ShlUint8Uint8,
46076	OP_ShlUint8Sint16,
46077	OP_ShlUint8Uint16,
46078	OP_ShlUint8Sint32,
46079	OP_ShlUint8Uint32,
46080	OP_ShlUint8Sint64,
46081	OP_ShlUint8Uint64,
46082	OP_ShlUint8IntAP,
46083	OP_ShlUint8IntAPS,
46084	OP_ShlSint16Sint8,
46085	OP_ShlSint16Uint8,
46086	OP_ShlSint16Sint16,
46087	OP_ShlSint16Uint16,
46088	OP_ShlSint16Sint32,
46089	OP_ShlSint16Uint32,
46090	OP_ShlSint16Sint64,
46091	OP_ShlSint16Uint64,
46092	OP_ShlSint16IntAP,
46093	OP_ShlSint16IntAPS,
46094	OP_ShlUint16Sint8,
46095	OP_ShlUint16Uint8,
46096	OP_ShlUint16Sint16,
46097	OP_ShlUint16Uint16,
46098	OP_ShlUint16Sint32,
46099	OP_ShlUint16Uint32,
46100	OP_ShlUint16Sint64,
46101	OP_ShlUint16Uint64,
46102	OP_ShlUint16IntAP,
46103	OP_ShlUint16IntAPS,
46104	OP_ShlSint32Sint8,
46105	OP_ShlSint32Uint8,
46106	OP_ShlSint32Sint16,
46107	OP_ShlSint32Uint16,
46108	OP_ShlSint32Sint32,
46109	OP_ShlSint32Uint32,
46110	OP_ShlSint32Sint64,
46111	OP_ShlSint32Uint64,
46112	OP_ShlSint32IntAP,
46113	OP_ShlSint32IntAPS,
46114	OP_ShlUint32Sint8,
46115	OP_ShlUint32Uint8,
46116	OP_ShlUint32Sint16,
46117	OP_ShlUint32Uint16,
46118	OP_ShlUint32Sint32,
46119	OP_ShlUint32Uint32,
46120	OP_ShlUint32Sint64,
46121	OP_ShlUint32Uint64,
46122	OP_ShlUint32IntAP,
46123	OP_ShlUint32IntAPS,
46124	OP_ShlSint64Sint8,
46125	OP_ShlSint64Uint8,
46126	OP_ShlSint64Sint16,
46127	OP_ShlSint64Uint16,
46128	OP_ShlSint64Sint32,
46129	OP_ShlSint64Uint32,
46130	OP_ShlSint64Sint64,
46131	OP_ShlSint64Uint64,
46132	OP_ShlSint64IntAP,
46133	OP_ShlSint64IntAPS,
46134	OP_ShlUint64Sint8,
46135	OP_ShlUint64Uint8,
46136	OP_ShlUint64Sint16,
46137	OP_ShlUint64Uint16,
46138	OP_ShlUint64Sint32,
46139	OP_ShlUint64Uint32,
46140	OP_ShlUint64Sint64,
46141	OP_ShlUint64Uint64,
46142	OP_ShlUint64IntAP,
46143	OP_ShlUint64IntAPS,
46144	OP_ShlIntAPSint8,
46145	OP_ShlIntAPUint8,
46146	OP_ShlIntAPSint16,
46147	OP_ShlIntAPUint16,
46148	OP_ShlIntAPSint32,
46149	OP_ShlIntAPUint32,
46150	OP_ShlIntAPSint64,
46151	OP_ShlIntAPUint64,
46152	OP_ShlIntAPIntAP,
46153	OP_ShlIntAPIntAPS,
46154	OP_ShlIntAPSSint8,
46155	OP_ShlIntAPSUint8,
46156	OP_ShlIntAPSSint16,
46157	OP_ShlIntAPSUint16,
46158	OP_ShlIntAPSSint32,
46159	OP_ShlIntAPSUint32,
46160	OP_ShlIntAPSSint64,
46161	OP_ShlIntAPSUint64,
46162	OP_ShlIntAPSIntAP,
46163	OP_ShlIntAPSIntAPS,
46164	#endif
46165	#ifdef GET_INTERPFN_LIST
46166	&Interp_ShlSint8Sint8,
46167	&Interp_ShlSint8Uint8,
46168	&Interp_ShlSint8Sint16,
46169	&Interp_ShlSint8Uint16,
46170	&Interp_ShlSint8Sint32,
46171	&Interp_ShlSint8Uint32,
46172	&Interp_ShlSint8Sint64,
46173	&Interp_ShlSint8Uint64,
46174	&Interp_ShlSint8IntAP,
46175	&Interp_ShlSint8IntAPS,
46176	&Interp_ShlUint8Sint8,
46177	&Interp_ShlUint8Uint8,
46178	&Interp_ShlUint8Sint16,
46179	&Interp_ShlUint8Uint16,
46180	&Interp_ShlUint8Sint32,
46181	&Interp_ShlUint8Uint32,
46182	&Interp_ShlUint8Sint64,
46183	&Interp_ShlUint8Uint64,
46184	&Interp_ShlUint8IntAP,
46185	&Interp_ShlUint8IntAPS,
46186	&Interp_ShlSint16Sint8,
46187	&Interp_ShlSint16Uint8,
46188	&Interp_ShlSint16Sint16,
46189	&Interp_ShlSint16Uint16,
46190	&Interp_ShlSint16Sint32,
46191	&Interp_ShlSint16Uint32,
46192	&Interp_ShlSint16Sint64,
46193	&Interp_ShlSint16Uint64,
46194	&Interp_ShlSint16IntAP,
46195	&Interp_ShlSint16IntAPS,
46196	&Interp_ShlUint16Sint8,
46197	&Interp_ShlUint16Uint8,
46198	&Interp_ShlUint16Sint16,
46199	&Interp_ShlUint16Uint16,
46200	&Interp_ShlUint16Sint32,
46201	&Interp_ShlUint16Uint32,
46202	&Interp_ShlUint16Sint64,
46203	&Interp_ShlUint16Uint64,
46204	&Interp_ShlUint16IntAP,
46205	&Interp_ShlUint16IntAPS,
46206	&Interp_ShlSint32Sint8,
46207	&Interp_ShlSint32Uint8,
46208	&Interp_ShlSint32Sint16,
46209	&Interp_ShlSint32Uint16,
46210	&Interp_ShlSint32Sint32,
46211	&Interp_ShlSint32Uint32,
46212	&Interp_ShlSint32Sint64,
46213	&Interp_ShlSint32Uint64,
46214	&Interp_ShlSint32IntAP,
46215	&Interp_ShlSint32IntAPS,
46216	&Interp_ShlUint32Sint8,
46217	&Interp_ShlUint32Uint8,
46218	&Interp_ShlUint32Sint16,
46219	&Interp_ShlUint32Uint16,
46220	&Interp_ShlUint32Sint32,
46221	&Interp_ShlUint32Uint32,
46222	&Interp_ShlUint32Sint64,
46223	&Interp_ShlUint32Uint64,
46224	&Interp_ShlUint32IntAP,
46225	&Interp_ShlUint32IntAPS,
46226	&Interp_ShlSint64Sint8,
46227	&Interp_ShlSint64Uint8,
46228	&Interp_ShlSint64Sint16,
46229	&Interp_ShlSint64Uint16,
46230	&Interp_ShlSint64Sint32,
46231	&Interp_ShlSint64Uint32,
46232	&Interp_ShlSint64Sint64,
46233	&Interp_ShlSint64Uint64,
46234	&Interp_ShlSint64IntAP,
46235	&Interp_ShlSint64IntAPS,
46236	&Interp_ShlUint64Sint8,
46237	&Interp_ShlUint64Uint8,
46238	&Interp_ShlUint64Sint16,
46239	&Interp_ShlUint64Uint16,
46240	&Interp_ShlUint64Sint32,
46241	&Interp_ShlUint64Uint32,
46242	&Interp_ShlUint64Sint64,
46243	&Interp_ShlUint64Uint64,
46244	&Interp_ShlUint64IntAP,
46245	&Interp_ShlUint64IntAPS,
46246	&Interp_ShlIntAPSint8,
46247	&Interp_ShlIntAPUint8,
46248	&Interp_ShlIntAPSint16,
46249	&Interp_ShlIntAPUint16,
46250	&Interp_ShlIntAPSint32,
46251	&Interp_ShlIntAPUint32,
46252	&Interp_ShlIntAPSint64,
46253	&Interp_ShlIntAPUint64,
46254	&Interp_ShlIntAPIntAP,
46255	&Interp_ShlIntAPIntAPS,
46256	&Interp_ShlIntAPSSint8,
46257	&Interp_ShlIntAPSUint8,
46258	&Interp_ShlIntAPSSint16,
46259	&Interp_ShlIntAPSUint16,
46260	&Interp_ShlIntAPSSint32,
46261	&Interp_ShlIntAPSUint32,
46262	&Interp_ShlIntAPSSint64,
46263	&Interp_ShlIntAPSUint64,
46264	&Interp_ShlIntAPSIntAP,
46265	&Interp_ShlIntAPSIntAPS,
46266	#endif
46267	#ifdef GET_INTERPFN_DISPATCHERS
46268	PRESERVE_NONE
46269	static bool Interp_ShlSint8Sint8(InterpState &S) {
46270	if (!Shl<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
46271	#if USE_TAILCALLS
46272	MUSTTAIL return InterpNext(S);
46273	#else
46274	return true;
46275	#endif
46276	}
46277	PRESERVE_NONE
46278	static bool Interp_ShlSint8Uint8(InterpState &S) {
46279	if (!Shl<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
46280	#if USE_TAILCALLS
46281	MUSTTAIL return InterpNext(S);
46282	#else
46283	return true;
46284	#endif
46285	}
46286	PRESERVE_NONE
46287	static bool Interp_ShlSint8Sint16(InterpState &S) {
46288	if (!Shl<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
46289	#if USE_TAILCALLS
46290	MUSTTAIL return InterpNext(S);
46291	#else
46292	return true;
46293	#endif
46294	}
46295	PRESERVE_NONE
46296	static bool Interp_ShlSint8Uint16(InterpState &S) {
46297	if (!Shl<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
46298	#if USE_TAILCALLS
46299	MUSTTAIL return InterpNext(S);
46300	#else
46301	return true;
46302	#endif
46303	}
46304	PRESERVE_NONE
46305	static bool Interp_ShlSint8Sint32(InterpState &S) {
46306	if (!Shl<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
46307	#if USE_TAILCALLS
46308	MUSTTAIL return InterpNext(S);
46309	#else
46310	return true;
46311	#endif
46312	}
46313	PRESERVE_NONE
46314	static bool Interp_ShlSint8Uint32(InterpState &S) {
46315	if (!Shl<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
46316	#if USE_TAILCALLS
46317	MUSTTAIL return InterpNext(S);
46318	#else
46319	return true;
46320	#endif
46321	}
46322	PRESERVE_NONE
46323	static bool Interp_ShlSint8Sint64(InterpState &S) {
46324	if (!Shl<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
46325	#if USE_TAILCALLS
46326	MUSTTAIL return InterpNext(S);
46327	#else
46328	return true;
46329	#endif
46330	}
46331	PRESERVE_NONE
46332	static bool Interp_ShlSint8Uint64(InterpState &S) {
46333	if (!Shl<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
46334	#if USE_TAILCALLS
46335	MUSTTAIL return InterpNext(S);
46336	#else
46337	return true;
46338	#endif
46339	}
46340	PRESERVE_NONE
46341	static bool Interp_ShlSint8IntAP(InterpState &S) {
46342	if (!Shl<PT_Sint8, PT_IntAP>(S, S.PC)) return false;
46343	#if USE_TAILCALLS
46344	MUSTTAIL return InterpNext(S);
46345	#else
46346	return true;
46347	#endif
46348	}
46349	PRESERVE_NONE
46350	static bool Interp_ShlSint8IntAPS(InterpState &S) {
46351	if (!Shl<PT_Sint8, PT_IntAPS>(S, S.PC)) return false;
46352	#if USE_TAILCALLS
46353	MUSTTAIL return InterpNext(S);
46354	#else
46355	return true;
46356	#endif
46357	}
46358	PRESERVE_NONE
46359	static bool Interp_ShlUint8Sint8(InterpState &S) {
46360	if (!Shl<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
46361	#if USE_TAILCALLS
46362	MUSTTAIL return InterpNext(S);
46363	#else
46364	return true;
46365	#endif
46366	}
46367	PRESERVE_NONE
46368	static bool Interp_ShlUint8Uint8(InterpState &S) {
46369	if (!Shl<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
46370	#if USE_TAILCALLS
46371	MUSTTAIL return InterpNext(S);
46372	#else
46373	return true;
46374	#endif
46375	}
46376	PRESERVE_NONE
46377	static bool Interp_ShlUint8Sint16(InterpState &S) {
46378	if (!Shl<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
46379	#if USE_TAILCALLS
46380	MUSTTAIL return InterpNext(S);
46381	#else
46382	return true;
46383	#endif
46384	}
46385	PRESERVE_NONE
46386	static bool Interp_ShlUint8Uint16(InterpState &S) {
46387	if (!Shl<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
46388	#if USE_TAILCALLS
46389	MUSTTAIL return InterpNext(S);
46390	#else
46391	return true;
46392	#endif
46393	}
46394	PRESERVE_NONE
46395	static bool Interp_ShlUint8Sint32(InterpState &S) {
46396	if (!Shl<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
46397	#if USE_TAILCALLS
46398	MUSTTAIL return InterpNext(S);
46399	#else
46400	return true;
46401	#endif
46402	}
46403	PRESERVE_NONE
46404	static bool Interp_ShlUint8Uint32(InterpState &S) {
46405	if (!Shl<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
46406	#if USE_TAILCALLS
46407	MUSTTAIL return InterpNext(S);
46408	#else
46409	return true;
46410	#endif
46411	}
46412	PRESERVE_NONE
46413	static bool Interp_ShlUint8Sint64(InterpState &S) {
46414	if (!Shl<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
46415	#if USE_TAILCALLS
46416	MUSTTAIL return InterpNext(S);
46417	#else
46418	return true;
46419	#endif
46420	}
46421	PRESERVE_NONE
46422	static bool Interp_ShlUint8Uint64(InterpState &S) {
46423	if (!Shl<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
46424	#if USE_TAILCALLS
46425	MUSTTAIL return InterpNext(S);
46426	#else
46427	return true;
46428	#endif
46429	}
46430	PRESERVE_NONE
46431	static bool Interp_ShlUint8IntAP(InterpState &S) {
46432	if (!Shl<PT_Uint8, PT_IntAP>(S, S.PC)) return false;
46433	#if USE_TAILCALLS
46434	MUSTTAIL return InterpNext(S);
46435	#else
46436	return true;
46437	#endif
46438	}
46439	PRESERVE_NONE
46440	static bool Interp_ShlUint8IntAPS(InterpState &S) {
46441	if (!Shl<PT_Uint8, PT_IntAPS>(S, S.PC)) return false;
46442	#if USE_TAILCALLS
46443	MUSTTAIL return InterpNext(S);
46444	#else
46445	return true;
46446	#endif
46447	}
46448	PRESERVE_NONE
46449	static bool Interp_ShlSint16Sint8(InterpState &S) {
46450	if (!Shl<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
46451	#if USE_TAILCALLS
46452	MUSTTAIL return InterpNext(S);
46453	#else
46454	return true;
46455	#endif
46456	}
46457	PRESERVE_NONE
46458	static bool Interp_ShlSint16Uint8(InterpState &S) {
46459	if (!Shl<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
46460	#if USE_TAILCALLS
46461	MUSTTAIL return InterpNext(S);
46462	#else
46463	return true;
46464	#endif
46465	}
46466	PRESERVE_NONE
46467	static bool Interp_ShlSint16Sint16(InterpState &S) {
46468	if (!Shl<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
46469	#if USE_TAILCALLS
46470	MUSTTAIL return InterpNext(S);
46471	#else
46472	return true;
46473	#endif
46474	}
46475	PRESERVE_NONE
46476	static bool Interp_ShlSint16Uint16(InterpState &S) {
46477	if (!Shl<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
46478	#if USE_TAILCALLS
46479	MUSTTAIL return InterpNext(S);
46480	#else
46481	return true;
46482	#endif
46483	}
46484	PRESERVE_NONE
46485	static bool Interp_ShlSint16Sint32(InterpState &S) {
46486	if (!Shl<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
46487	#if USE_TAILCALLS
46488	MUSTTAIL return InterpNext(S);
46489	#else
46490	return true;
46491	#endif
46492	}
46493	PRESERVE_NONE
46494	static bool Interp_ShlSint16Uint32(InterpState &S) {
46495	if (!Shl<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
46496	#if USE_TAILCALLS
46497	MUSTTAIL return InterpNext(S);
46498	#else
46499	return true;
46500	#endif
46501	}
46502	PRESERVE_NONE
46503	static bool Interp_ShlSint16Sint64(InterpState &S) {
46504	if (!Shl<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
46505	#if USE_TAILCALLS
46506	MUSTTAIL return InterpNext(S);
46507	#else
46508	return true;
46509	#endif
46510	}
46511	PRESERVE_NONE
46512	static bool Interp_ShlSint16Uint64(InterpState &S) {
46513	if (!Shl<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
46514	#if USE_TAILCALLS
46515	MUSTTAIL return InterpNext(S);
46516	#else
46517	return true;
46518	#endif
46519	}
46520	PRESERVE_NONE
46521	static bool Interp_ShlSint16IntAP(InterpState &S) {
46522	if (!Shl<PT_Sint16, PT_IntAP>(S, S.PC)) return false;
46523	#if USE_TAILCALLS
46524	MUSTTAIL return InterpNext(S);
46525	#else
46526	return true;
46527	#endif
46528	}
46529	PRESERVE_NONE
46530	static bool Interp_ShlSint16IntAPS(InterpState &S) {
46531	if (!Shl<PT_Sint16, PT_IntAPS>(S, S.PC)) return false;
46532	#if USE_TAILCALLS
46533	MUSTTAIL return InterpNext(S);
46534	#else
46535	return true;
46536	#endif
46537	}
46538	PRESERVE_NONE
46539	static bool Interp_ShlUint16Sint8(InterpState &S) {
46540	if (!Shl<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
46541	#if USE_TAILCALLS
46542	MUSTTAIL return InterpNext(S);
46543	#else
46544	return true;
46545	#endif
46546	}
46547	PRESERVE_NONE
46548	static bool Interp_ShlUint16Uint8(InterpState &S) {
46549	if (!Shl<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
46550	#if USE_TAILCALLS
46551	MUSTTAIL return InterpNext(S);
46552	#else
46553	return true;
46554	#endif
46555	}
46556	PRESERVE_NONE
46557	static bool Interp_ShlUint16Sint16(InterpState &S) {
46558	if (!Shl<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
46559	#if USE_TAILCALLS
46560	MUSTTAIL return InterpNext(S);
46561	#else
46562	return true;
46563	#endif
46564	}
46565	PRESERVE_NONE
46566	static bool Interp_ShlUint16Uint16(InterpState &S) {
46567	if (!Shl<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
46568	#if USE_TAILCALLS
46569	MUSTTAIL return InterpNext(S);
46570	#else
46571	return true;
46572	#endif
46573	}
46574	PRESERVE_NONE
46575	static bool Interp_ShlUint16Sint32(InterpState &S) {
46576	if (!Shl<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
46577	#if USE_TAILCALLS
46578	MUSTTAIL return InterpNext(S);
46579	#else
46580	return true;
46581	#endif
46582	}
46583	PRESERVE_NONE
46584	static bool Interp_ShlUint16Uint32(InterpState &S) {
46585	if (!Shl<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
46586	#if USE_TAILCALLS
46587	MUSTTAIL return InterpNext(S);
46588	#else
46589	return true;
46590	#endif
46591	}
46592	PRESERVE_NONE
46593	static bool Interp_ShlUint16Sint64(InterpState &S) {
46594	if (!Shl<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
46595	#if USE_TAILCALLS
46596	MUSTTAIL return InterpNext(S);
46597	#else
46598	return true;
46599	#endif
46600	}
46601	PRESERVE_NONE
46602	static bool Interp_ShlUint16Uint64(InterpState &S) {
46603	if (!Shl<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
46604	#if USE_TAILCALLS
46605	MUSTTAIL return InterpNext(S);
46606	#else
46607	return true;
46608	#endif
46609	}
46610	PRESERVE_NONE
46611	static bool Interp_ShlUint16IntAP(InterpState &S) {
46612	if (!Shl<PT_Uint16, PT_IntAP>(S, S.PC)) return false;
46613	#if USE_TAILCALLS
46614	MUSTTAIL return InterpNext(S);
46615	#else
46616	return true;
46617	#endif
46618	}
46619	PRESERVE_NONE
46620	static bool Interp_ShlUint16IntAPS(InterpState &S) {
46621	if (!Shl<PT_Uint16, PT_IntAPS>(S, S.PC)) return false;
46622	#if USE_TAILCALLS
46623	MUSTTAIL return InterpNext(S);
46624	#else
46625	return true;
46626	#endif
46627	}
46628	PRESERVE_NONE
46629	static bool Interp_ShlSint32Sint8(InterpState &S) {
46630	if (!Shl<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
46631	#if USE_TAILCALLS
46632	MUSTTAIL return InterpNext(S);
46633	#else
46634	return true;
46635	#endif
46636	}
46637	PRESERVE_NONE
46638	static bool Interp_ShlSint32Uint8(InterpState &S) {
46639	if (!Shl<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
46640	#if USE_TAILCALLS
46641	MUSTTAIL return InterpNext(S);
46642	#else
46643	return true;
46644	#endif
46645	}
46646	PRESERVE_NONE
46647	static bool Interp_ShlSint32Sint16(InterpState &S) {
46648	if (!Shl<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
46649	#if USE_TAILCALLS
46650	MUSTTAIL return InterpNext(S);
46651	#else
46652	return true;
46653	#endif
46654	}
46655	PRESERVE_NONE
46656	static bool Interp_ShlSint32Uint16(InterpState &S) {
46657	if (!Shl<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
46658	#if USE_TAILCALLS
46659	MUSTTAIL return InterpNext(S);
46660	#else
46661	return true;
46662	#endif
46663	}
46664	PRESERVE_NONE
46665	static bool Interp_ShlSint32Sint32(InterpState &S) {
46666	if (!Shl<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
46667	#if USE_TAILCALLS
46668	MUSTTAIL return InterpNext(S);
46669	#else
46670	return true;
46671	#endif
46672	}
46673	PRESERVE_NONE
46674	static bool Interp_ShlSint32Uint32(InterpState &S) {
46675	if (!Shl<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
46676	#if USE_TAILCALLS
46677	MUSTTAIL return InterpNext(S);
46678	#else
46679	return true;
46680	#endif
46681	}
46682	PRESERVE_NONE
46683	static bool Interp_ShlSint32Sint64(InterpState &S) {
46684	if (!Shl<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
46685	#if USE_TAILCALLS
46686	MUSTTAIL return InterpNext(S);
46687	#else
46688	return true;
46689	#endif
46690	}
46691	PRESERVE_NONE
46692	static bool Interp_ShlSint32Uint64(InterpState &S) {
46693	if (!Shl<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
46694	#if USE_TAILCALLS
46695	MUSTTAIL return InterpNext(S);
46696	#else
46697	return true;
46698	#endif
46699	}
46700	PRESERVE_NONE
46701	static bool Interp_ShlSint32IntAP(InterpState &S) {
46702	if (!Shl<PT_Sint32, PT_IntAP>(S, S.PC)) return false;
46703	#if USE_TAILCALLS
46704	MUSTTAIL return InterpNext(S);
46705	#else
46706	return true;
46707	#endif
46708	}
46709	PRESERVE_NONE
46710	static bool Interp_ShlSint32IntAPS(InterpState &S) {
46711	if (!Shl<PT_Sint32, PT_IntAPS>(S, S.PC)) return false;
46712	#if USE_TAILCALLS
46713	MUSTTAIL return InterpNext(S);
46714	#else
46715	return true;
46716	#endif
46717	}
46718	PRESERVE_NONE
46719	static bool Interp_ShlUint32Sint8(InterpState &S) {
46720	if (!Shl<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
46721	#if USE_TAILCALLS
46722	MUSTTAIL return InterpNext(S);
46723	#else
46724	return true;
46725	#endif
46726	}
46727	PRESERVE_NONE
46728	static bool Interp_ShlUint32Uint8(InterpState &S) {
46729	if (!Shl<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
46730	#if USE_TAILCALLS
46731	MUSTTAIL return InterpNext(S);
46732	#else
46733	return true;
46734	#endif
46735	}
46736	PRESERVE_NONE
46737	static bool Interp_ShlUint32Sint16(InterpState &S) {
46738	if (!Shl<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
46739	#if USE_TAILCALLS
46740	MUSTTAIL return InterpNext(S);
46741	#else
46742	return true;
46743	#endif
46744	}
46745	PRESERVE_NONE
46746	static bool Interp_ShlUint32Uint16(InterpState &S) {
46747	if (!Shl<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
46748	#if USE_TAILCALLS
46749	MUSTTAIL return InterpNext(S);
46750	#else
46751	return true;
46752	#endif
46753	}
46754	PRESERVE_NONE
46755	static bool Interp_ShlUint32Sint32(InterpState &S) {
46756	if (!Shl<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
46757	#if USE_TAILCALLS
46758	MUSTTAIL return InterpNext(S);
46759	#else
46760	return true;
46761	#endif
46762	}
46763	PRESERVE_NONE
46764	static bool Interp_ShlUint32Uint32(InterpState &S) {
46765	if (!Shl<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
46766	#if USE_TAILCALLS
46767	MUSTTAIL return InterpNext(S);
46768	#else
46769	return true;
46770	#endif
46771	}
46772	PRESERVE_NONE
46773	static bool Interp_ShlUint32Sint64(InterpState &S) {
46774	if (!Shl<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
46775	#if USE_TAILCALLS
46776	MUSTTAIL return InterpNext(S);
46777	#else
46778	return true;
46779	#endif
46780	}
46781	PRESERVE_NONE
46782	static bool Interp_ShlUint32Uint64(InterpState &S) {
46783	if (!Shl<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
46784	#if USE_TAILCALLS
46785	MUSTTAIL return InterpNext(S);
46786	#else
46787	return true;
46788	#endif
46789	}
46790	PRESERVE_NONE
46791	static bool Interp_ShlUint32IntAP(InterpState &S) {
46792	if (!Shl<PT_Uint32, PT_IntAP>(S, S.PC)) return false;
46793	#if USE_TAILCALLS
46794	MUSTTAIL return InterpNext(S);
46795	#else
46796	return true;
46797	#endif
46798	}
46799	PRESERVE_NONE
46800	static bool Interp_ShlUint32IntAPS(InterpState &S) {
46801	if (!Shl<PT_Uint32, PT_IntAPS>(S, S.PC)) return false;
46802	#if USE_TAILCALLS
46803	MUSTTAIL return InterpNext(S);
46804	#else
46805	return true;
46806	#endif
46807	}
46808	PRESERVE_NONE
46809	static bool Interp_ShlSint64Sint8(InterpState &S) {
46810	if (!Shl<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
46811	#if USE_TAILCALLS
46812	MUSTTAIL return InterpNext(S);
46813	#else
46814	return true;
46815	#endif
46816	}
46817	PRESERVE_NONE
46818	static bool Interp_ShlSint64Uint8(InterpState &S) {
46819	if (!Shl<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
46820	#if USE_TAILCALLS
46821	MUSTTAIL return InterpNext(S);
46822	#else
46823	return true;
46824	#endif
46825	}
46826	PRESERVE_NONE
46827	static bool Interp_ShlSint64Sint16(InterpState &S) {
46828	if (!Shl<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
46829	#if USE_TAILCALLS
46830	MUSTTAIL return InterpNext(S);
46831	#else
46832	return true;
46833	#endif
46834	}
46835	PRESERVE_NONE
46836	static bool Interp_ShlSint64Uint16(InterpState &S) {
46837	if (!Shl<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
46838	#if USE_TAILCALLS
46839	MUSTTAIL return InterpNext(S);
46840	#else
46841	return true;
46842	#endif
46843	}
46844	PRESERVE_NONE
46845	static bool Interp_ShlSint64Sint32(InterpState &S) {
46846	if (!Shl<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
46847	#if USE_TAILCALLS
46848	MUSTTAIL return InterpNext(S);
46849	#else
46850	return true;
46851	#endif
46852	}
46853	PRESERVE_NONE
46854	static bool Interp_ShlSint64Uint32(InterpState &S) {
46855	if (!Shl<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
46856	#if USE_TAILCALLS
46857	MUSTTAIL return InterpNext(S);
46858	#else
46859	return true;
46860	#endif
46861	}
46862	PRESERVE_NONE
46863	static bool Interp_ShlSint64Sint64(InterpState &S) {
46864	if (!Shl<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
46865	#if USE_TAILCALLS
46866	MUSTTAIL return InterpNext(S);
46867	#else
46868	return true;
46869	#endif
46870	}
46871	PRESERVE_NONE
46872	static bool Interp_ShlSint64Uint64(InterpState &S) {
46873	if (!Shl<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
46874	#if USE_TAILCALLS
46875	MUSTTAIL return InterpNext(S);
46876	#else
46877	return true;
46878	#endif
46879	}
46880	PRESERVE_NONE
46881	static bool Interp_ShlSint64IntAP(InterpState &S) {
46882	if (!Shl<PT_Sint64, PT_IntAP>(S, S.PC)) return false;
46883	#if USE_TAILCALLS
46884	MUSTTAIL return InterpNext(S);
46885	#else
46886	return true;
46887	#endif
46888	}
46889	PRESERVE_NONE
46890	static bool Interp_ShlSint64IntAPS(InterpState &S) {
46891	if (!Shl<PT_Sint64, PT_IntAPS>(S, S.PC)) return false;
46892	#if USE_TAILCALLS
46893	MUSTTAIL return InterpNext(S);
46894	#else
46895	return true;
46896	#endif
46897	}
46898	PRESERVE_NONE
46899	static bool Interp_ShlUint64Sint8(InterpState &S) {
46900	if (!Shl<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
46901	#if USE_TAILCALLS
46902	MUSTTAIL return InterpNext(S);
46903	#else
46904	return true;
46905	#endif
46906	}
46907	PRESERVE_NONE
46908	static bool Interp_ShlUint64Uint8(InterpState &S) {
46909	if (!Shl<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
46910	#if USE_TAILCALLS
46911	MUSTTAIL return InterpNext(S);
46912	#else
46913	return true;
46914	#endif
46915	}
46916	PRESERVE_NONE
46917	static bool Interp_ShlUint64Sint16(InterpState &S) {
46918	if (!Shl<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
46919	#if USE_TAILCALLS
46920	MUSTTAIL return InterpNext(S);
46921	#else
46922	return true;
46923	#endif
46924	}
46925	PRESERVE_NONE
46926	static bool Interp_ShlUint64Uint16(InterpState &S) {
46927	if (!Shl<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
46928	#if USE_TAILCALLS
46929	MUSTTAIL return InterpNext(S);
46930	#else
46931	return true;
46932	#endif
46933	}
46934	PRESERVE_NONE
46935	static bool Interp_ShlUint64Sint32(InterpState &S) {
46936	if (!Shl<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
46937	#if USE_TAILCALLS
46938	MUSTTAIL return InterpNext(S);
46939	#else
46940	return true;
46941	#endif
46942	}
46943	PRESERVE_NONE
46944	static bool Interp_ShlUint64Uint32(InterpState &S) {
46945	if (!Shl<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
46946	#if USE_TAILCALLS
46947	MUSTTAIL return InterpNext(S);
46948	#else
46949	return true;
46950	#endif
46951	}
46952	PRESERVE_NONE
46953	static bool Interp_ShlUint64Sint64(InterpState &S) {
46954	if (!Shl<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
46955	#if USE_TAILCALLS
46956	MUSTTAIL return InterpNext(S);
46957	#else
46958	return true;
46959	#endif
46960	}
46961	PRESERVE_NONE
46962	static bool Interp_ShlUint64Uint64(InterpState &S) {
46963	if (!Shl<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
46964	#if USE_TAILCALLS
46965	MUSTTAIL return InterpNext(S);
46966	#else
46967	return true;
46968	#endif
46969	}
46970	PRESERVE_NONE
46971	static bool Interp_ShlUint64IntAP(InterpState &S) {
46972	if (!Shl<PT_Uint64, PT_IntAP>(S, S.PC)) return false;
46973	#if USE_TAILCALLS
46974	MUSTTAIL return InterpNext(S);
46975	#else
46976	return true;
46977	#endif
46978	}
46979	PRESERVE_NONE
46980	static bool Interp_ShlUint64IntAPS(InterpState &S) {
46981	if (!Shl<PT_Uint64, PT_IntAPS>(S, S.PC)) return false;
46982	#if USE_TAILCALLS
46983	MUSTTAIL return InterpNext(S);
46984	#else
46985	return true;
46986	#endif
46987	}
46988	PRESERVE_NONE
46989	static bool Interp_ShlIntAPSint8(InterpState &S) {
46990	if (!Shl<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
46991	#if USE_TAILCALLS
46992	MUSTTAIL return InterpNext(S);
46993	#else
46994	return true;
46995	#endif
46996	}
46997	PRESERVE_NONE
46998	static bool Interp_ShlIntAPUint8(InterpState &S) {
46999	if (!Shl<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
47000	#if USE_TAILCALLS
47001	MUSTTAIL return InterpNext(S);
47002	#else
47003	return true;
47004	#endif
47005	}
47006	PRESERVE_NONE
47007	static bool Interp_ShlIntAPSint16(InterpState &S) {
47008	if (!Shl<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
47009	#if USE_TAILCALLS
47010	MUSTTAIL return InterpNext(S);
47011	#else
47012	return true;
47013	#endif
47014	}
47015	PRESERVE_NONE
47016	static bool Interp_ShlIntAPUint16(InterpState &S) {
47017	if (!Shl<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
47018	#if USE_TAILCALLS
47019	MUSTTAIL return InterpNext(S);
47020	#else
47021	return true;
47022	#endif
47023	}
47024	PRESERVE_NONE
47025	static bool Interp_ShlIntAPSint32(InterpState &S) {
47026	if (!Shl<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
47027	#if USE_TAILCALLS
47028	MUSTTAIL return InterpNext(S);
47029	#else
47030	return true;
47031	#endif
47032	}
47033	PRESERVE_NONE
47034	static bool Interp_ShlIntAPUint32(InterpState &S) {
47035	if (!Shl<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
47036	#if USE_TAILCALLS
47037	MUSTTAIL return InterpNext(S);
47038	#else
47039	return true;
47040	#endif
47041	}
47042	PRESERVE_NONE
47043	static bool Interp_ShlIntAPSint64(InterpState &S) {
47044	if (!Shl<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
47045	#if USE_TAILCALLS
47046	MUSTTAIL return InterpNext(S);
47047	#else
47048	return true;
47049	#endif
47050	}
47051	PRESERVE_NONE
47052	static bool Interp_ShlIntAPUint64(InterpState &S) {
47053	if (!Shl<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
47054	#if USE_TAILCALLS
47055	MUSTTAIL return InterpNext(S);
47056	#else
47057	return true;
47058	#endif
47059	}
47060	PRESERVE_NONE
47061	static bool Interp_ShlIntAPIntAP(InterpState &S) {
47062	if (!Shl<PT_IntAP, PT_IntAP>(S, S.PC)) return false;
47063	#if USE_TAILCALLS
47064	MUSTTAIL return InterpNext(S);
47065	#else
47066	return true;
47067	#endif
47068	}
47069	PRESERVE_NONE
47070	static bool Interp_ShlIntAPIntAPS(InterpState &S) {
47071	if (!Shl<PT_IntAP, PT_IntAPS>(S, S.PC)) return false;
47072	#if USE_TAILCALLS
47073	MUSTTAIL return InterpNext(S);
47074	#else
47075	return true;
47076	#endif
47077	}
47078	PRESERVE_NONE
47079	static bool Interp_ShlIntAPSSint8(InterpState &S) {
47080	if (!Shl<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
47081	#if USE_TAILCALLS
47082	MUSTTAIL return InterpNext(S);
47083	#else
47084	return true;
47085	#endif
47086	}
47087	PRESERVE_NONE
47088	static bool Interp_ShlIntAPSUint8(InterpState &S) {
47089	if (!Shl<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
47090	#if USE_TAILCALLS
47091	MUSTTAIL return InterpNext(S);
47092	#else
47093	return true;
47094	#endif
47095	}
47096	PRESERVE_NONE
47097	static bool Interp_ShlIntAPSSint16(InterpState &S) {
47098	if (!Shl<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
47099	#if USE_TAILCALLS
47100	MUSTTAIL return InterpNext(S);
47101	#else
47102	return true;
47103	#endif
47104	}
47105	PRESERVE_NONE
47106	static bool Interp_ShlIntAPSUint16(InterpState &S) {
47107	if (!Shl<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
47108	#if USE_TAILCALLS
47109	MUSTTAIL return InterpNext(S);
47110	#else
47111	return true;
47112	#endif
47113	}
47114	PRESERVE_NONE
47115	static bool Interp_ShlIntAPSSint32(InterpState &S) {
47116	if (!Shl<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
47117	#if USE_TAILCALLS
47118	MUSTTAIL return InterpNext(S);
47119	#else
47120	return true;
47121	#endif
47122	}
47123	PRESERVE_NONE
47124	static bool Interp_ShlIntAPSUint32(InterpState &S) {
47125	if (!Shl<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
47126	#if USE_TAILCALLS
47127	MUSTTAIL return InterpNext(S);
47128	#else
47129	return true;
47130	#endif
47131	}
47132	PRESERVE_NONE
47133	static bool Interp_ShlIntAPSSint64(InterpState &S) {
47134	if (!Shl<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
47135	#if USE_TAILCALLS
47136	MUSTTAIL return InterpNext(S);
47137	#else
47138	return true;
47139	#endif
47140	}
47141	PRESERVE_NONE
47142	static bool Interp_ShlIntAPSUint64(InterpState &S) {
47143	if (!Shl<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
47144	#if USE_TAILCALLS
47145	MUSTTAIL return InterpNext(S);
47146	#else
47147	return true;
47148	#endif
47149	}
47150	PRESERVE_NONE
47151	static bool Interp_ShlIntAPSIntAP(InterpState &S) {
47152	if (!Shl<PT_IntAPS, PT_IntAP>(S, S.PC)) return false;
47153	#if USE_TAILCALLS
47154	MUSTTAIL return InterpNext(S);
47155	#else
47156	return true;
47157	#endif
47158	}
47159	PRESERVE_NONE
47160	static bool Interp_ShlIntAPSIntAPS(InterpState &S) {
47161	if (!Shl<PT_IntAPS, PT_IntAPS>(S, S.PC)) return false;
47162	#if USE_TAILCALLS
47163	MUSTTAIL return InterpNext(S);
47164	#else
47165	return true;
47166	#endif
47167	}
47168	#endif
47169	#ifdef GET_DISASM
47170	case OP_ShlSint8Sint8:
47171	Text.Op = PrintName("ShlSint8Sint8");
47172	break;
47173	case OP_ShlSint8Uint8:
47174	Text.Op = PrintName("ShlSint8Uint8");
47175	break;
47176	case OP_ShlSint8Sint16:
47177	Text.Op = PrintName("ShlSint8Sint16");
47178	break;
47179	case OP_ShlSint8Uint16:
47180	Text.Op = PrintName("ShlSint8Uint16");
47181	break;
47182	case OP_ShlSint8Sint32:
47183	Text.Op = PrintName("ShlSint8Sint32");
47184	break;
47185	case OP_ShlSint8Uint32:
47186	Text.Op = PrintName("ShlSint8Uint32");
47187	break;
47188	case OP_ShlSint8Sint64:
47189	Text.Op = PrintName("ShlSint8Sint64");
47190	break;
47191	case OP_ShlSint8Uint64:
47192	Text.Op = PrintName("ShlSint8Uint64");
47193	break;
47194	case OP_ShlSint8IntAP:
47195	Text.Op = PrintName("ShlSint8IntAP");
47196	break;
47197	case OP_ShlSint8IntAPS:
47198	Text.Op = PrintName("ShlSint8IntAPS");
47199	break;
47200	case OP_ShlUint8Sint8:
47201	Text.Op = PrintName("ShlUint8Sint8");
47202	break;
47203	case OP_ShlUint8Uint8:
47204	Text.Op = PrintName("ShlUint8Uint8");
47205	break;
47206	case OP_ShlUint8Sint16:
47207	Text.Op = PrintName("ShlUint8Sint16");
47208	break;
47209	case OP_ShlUint8Uint16:
47210	Text.Op = PrintName("ShlUint8Uint16");
47211	break;
47212	case OP_ShlUint8Sint32:
47213	Text.Op = PrintName("ShlUint8Sint32");
47214	break;
47215	case OP_ShlUint8Uint32:
47216	Text.Op = PrintName("ShlUint8Uint32");
47217	break;
47218	case OP_ShlUint8Sint64:
47219	Text.Op = PrintName("ShlUint8Sint64");
47220	break;
47221	case OP_ShlUint8Uint64:
47222	Text.Op = PrintName("ShlUint8Uint64");
47223	break;
47224	case OP_ShlUint8IntAP:
47225	Text.Op = PrintName("ShlUint8IntAP");
47226	break;
47227	case OP_ShlUint8IntAPS:
47228	Text.Op = PrintName("ShlUint8IntAPS");
47229	break;
47230	case OP_ShlSint16Sint8:
47231	Text.Op = PrintName("ShlSint16Sint8");
47232	break;
47233	case OP_ShlSint16Uint8:
47234	Text.Op = PrintName("ShlSint16Uint8");
47235	break;
47236	case OP_ShlSint16Sint16:
47237	Text.Op = PrintName("ShlSint16Sint16");
47238	break;
47239	case OP_ShlSint16Uint16:
47240	Text.Op = PrintName("ShlSint16Uint16");
47241	break;
47242	case OP_ShlSint16Sint32:
47243	Text.Op = PrintName("ShlSint16Sint32");
47244	break;
47245	case OP_ShlSint16Uint32:
47246	Text.Op = PrintName("ShlSint16Uint32");
47247	break;
47248	case OP_ShlSint16Sint64:
47249	Text.Op = PrintName("ShlSint16Sint64");
47250	break;
47251	case OP_ShlSint16Uint64:
47252	Text.Op = PrintName("ShlSint16Uint64");
47253	break;
47254	case OP_ShlSint16IntAP:
47255	Text.Op = PrintName("ShlSint16IntAP");
47256	break;
47257	case OP_ShlSint16IntAPS:
47258	Text.Op = PrintName("ShlSint16IntAPS");
47259	break;
47260	case OP_ShlUint16Sint8:
47261	Text.Op = PrintName("ShlUint16Sint8");
47262	break;
47263	case OP_ShlUint16Uint8:
47264	Text.Op = PrintName("ShlUint16Uint8");
47265	break;
47266	case OP_ShlUint16Sint16:
47267	Text.Op = PrintName("ShlUint16Sint16");
47268	break;
47269	case OP_ShlUint16Uint16:
47270	Text.Op = PrintName("ShlUint16Uint16");
47271	break;
47272	case OP_ShlUint16Sint32:
47273	Text.Op = PrintName("ShlUint16Sint32");
47274	break;
47275	case OP_ShlUint16Uint32:
47276	Text.Op = PrintName("ShlUint16Uint32");
47277	break;
47278	case OP_ShlUint16Sint64:
47279	Text.Op = PrintName("ShlUint16Sint64");
47280	break;
47281	case OP_ShlUint16Uint64:
47282	Text.Op = PrintName("ShlUint16Uint64");
47283	break;
47284	case OP_ShlUint16IntAP:
47285	Text.Op = PrintName("ShlUint16IntAP");
47286	break;
47287	case OP_ShlUint16IntAPS:
47288	Text.Op = PrintName("ShlUint16IntAPS");
47289	break;
47290	case OP_ShlSint32Sint8:
47291	Text.Op = PrintName("ShlSint32Sint8");
47292	break;
47293	case OP_ShlSint32Uint8:
47294	Text.Op = PrintName("ShlSint32Uint8");
47295	break;
47296	case OP_ShlSint32Sint16:
47297	Text.Op = PrintName("ShlSint32Sint16");
47298	break;
47299	case OP_ShlSint32Uint16:
47300	Text.Op = PrintName("ShlSint32Uint16");
47301	break;
47302	case OP_ShlSint32Sint32:
47303	Text.Op = PrintName("ShlSint32Sint32");
47304	break;
47305	case OP_ShlSint32Uint32:
47306	Text.Op = PrintName("ShlSint32Uint32");
47307	break;
47308	case OP_ShlSint32Sint64:
47309	Text.Op = PrintName("ShlSint32Sint64");
47310	break;
47311	case OP_ShlSint32Uint64:
47312	Text.Op = PrintName("ShlSint32Uint64");
47313	break;
47314	case OP_ShlSint32IntAP:
47315	Text.Op = PrintName("ShlSint32IntAP");
47316	break;
47317	case OP_ShlSint32IntAPS:
47318	Text.Op = PrintName("ShlSint32IntAPS");
47319	break;
47320	case OP_ShlUint32Sint8:
47321	Text.Op = PrintName("ShlUint32Sint8");
47322	break;
47323	case OP_ShlUint32Uint8:
47324	Text.Op = PrintName("ShlUint32Uint8");
47325	break;
47326	case OP_ShlUint32Sint16:
47327	Text.Op = PrintName("ShlUint32Sint16");
47328	break;
47329	case OP_ShlUint32Uint16:
47330	Text.Op = PrintName("ShlUint32Uint16");
47331	break;
47332	case OP_ShlUint32Sint32:
47333	Text.Op = PrintName("ShlUint32Sint32");
47334	break;
47335	case OP_ShlUint32Uint32:
47336	Text.Op = PrintName("ShlUint32Uint32");
47337	break;
47338	case OP_ShlUint32Sint64:
47339	Text.Op = PrintName("ShlUint32Sint64");
47340	break;
47341	case OP_ShlUint32Uint64:
47342	Text.Op = PrintName("ShlUint32Uint64");
47343	break;
47344	case OP_ShlUint32IntAP:
47345	Text.Op = PrintName("ShlUint32IntAP");
47346	break;
47347	case OP_ShlUint32IntAPS:
47348	Text.Op = PrintName("ShlUint32IntAPS");
47349	break;
47350	case OP_ShlSint64Sint8:
47351	Text.Op = PrintName("ShlSint64Sint8");
47352	break;
47353	case OP_ShlSint64Uint8:
47354	Text.Op = PrintName("ShlSint64Uint8");
47355	break;
47356	case OP_ShlSint64Sint16:
47357	Text.Op = PrintName("ShlSint64Sint16");
47358	break;
47359	case OP_ShlSint64Uint16:
47360	Text.Op = PrintName("ShlSint64Uint16");
47361	break;
47362	case OP_ShlSint64Sint32:
47363	Text.Op = PrintName("ShlSint64Sint32");
47364	break;
47365	case OP_ShlSint64Uint32:
47366	Text.Op = PrintName("ShlSint64Uint32");
47367	break;
47368	case OP_ShlSint64Sint64:
47369	Text.Op = PrintName("ShlSint64Sint64");
47370	break;
47371	case OP_ShlSint64Uint64:
47372	Text.Op = PrintName("ShlSint64Uint64");
47373	break;
47374	case OP_ShlSint64IntAP:
47375	Text.Op = PrintName("ShlSint64IntAP");
47376	break;
47377	case OP_ShlSint64IntAPS:
47378	Text.Op = PrintName("ShlSint64IntAPS");
47379	break;
47380	case OP_ShlUint64Sint8:
47381	Text.Op = PrintName("ShlUint64Sint8");
47382	break;
47383	case OP_ShlUint64Uint8:
47384	Text.Op = PrintName("ShlUint64Uint8");
47385	break;
47386	case OP_ShlUint64Sint16:
47387	Text.Op = PrintName("ShlUint64Sint16");
47388	break;
47389	case OP_ShlUint64Uint16:
47390	Text.Op = PrintName("ShlUint64Uint16");
47391	break;
47392	case OP_ShlUint64Sint32:
47393	Text.Op = PrintName("ShlUint64Sint32");
47394	break;
47395	case OP_ShlUint64Uint32:
47396	Text.Op = PrintName("ShlUint64Uint32");
47397	break;
47398	case OP_ShlUint64Sint64:
47399	Text.Op = PrintName("ShlUint64Sint64");
47400	break;
47401	case OP_ShlUint64Uint64:
47402	Text.Op = PrintName("ShlUint64Uint64");
47403	break;
47404	case OP_ShlUint64IntAP:
47405	Text.Op = PrintName("ShlUint64IntAP");
47406	break;
47407	case OP_ShlUint64IntAPS:
47408	Text.Op = PrintName("ShlUint64IntAPS");
47409	break;
47410	case OP_ShlIntAPSint8:
47411	Text.Op = PrintName("ShlIntAPSint8");
47412	break;
47413	case OP_ShlIntAPUint8:
47414	Text.Op = PrintName("ShlIntAPUint8");
47415	break;
47416	case OP_ShlIntAPSint16:
47417	Text.Op = PrintName("ShlIntAPSint16");
47418	break;
47419	case OP_ShlIntAPUint16:
47420	Text.Op = PrintName("ShlIntAPUint16");
47421	break;
47422	case OP_ShlIntAPSint32:
47423	Text.Op = PrintName("ShlIntAPSint32");
47424	break;
47425	case OP_ShlIntAPUint32:
47426	Text.Op = PrintName("ShlIntAPUint32");
47427	break;
47428	case OP_ShlIntAPSint64:
47429	Text.Op = PrintName("ShlIntAPSint64");
47430	break;
47431	case OP_ShlIntAPUint64:
47432	Text.Op = PrintName("ShlIntAPUint64");
47433	break;
47434	case OP_ShlIntAPIntAP:
47435	Text.Op = PrintName("ShlIntAPIntAP");
47436	break;
47437	case OP_ShlIntAPIntAPS:
47438	Text.Op = PrintName("ShlIntAPIntAPS");
47439	break;
47440	case OP_ShlIntAPSSint8:
47441	Text.Op = PrintName("ShlIntAPSSint8");
47442	break;
47443	case OP_ShlIntAPSUint8:
47444	Text.Op = PrintName("ShlIntAPSUint8");
47445	break;
47446	case OP_ShlIntAPSSint16:
47447	Text.Op = PrintName("ShlIntAPSSint16");
47448	break;
47449	case OP_ShlIntAPSUint16:
47450	Text.Op = PrintName("ShlIntAPSUint16");
47451	break;
47452	case OP_ShlIntAPSSint32:
47453	Text.Op = PrintName("ShlIntAPSSint32");
47454	break;
47455	case OP_ShlIntAPSUint32:
47456	Text.Op = PrintName("ShlIntAPSUint32");
47457	break;
47458	case OP_ShlIntAPSSint64:
47459	Text.Op = PrintName("ShlIntAPSSint64");
47460	break;
47461	case OP_ShlIntAPSUint64:
47462	Text.Op = PrintName("ShlIntAPSUint64");
47463	break;
47464	case OP_ShlIntAPSIntAP:
47465	Text.Op = PrintName("ShlIntAPSIntAP");
47466	break;
47467	case OP_ShlIntAPSIntAPS:
47468	Text.Op = PrintName("ShlIntAPSIntAPS");
47469	break;
47470	#endif
47471	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
47472	bool emitShlSint8Sint8(SourceInfo);
47473	bool emitShlSint8Uint8(SourceInfo);
47474	bool emitShlSint8Sint16(SourceInfo);
47475	bool emitShlSint8Uint16(SourceInfo);
47476	bool emitShlSint8Sint32(SourceInfo);
47477	bool emitShlSint8Uint32(SourceInfo);
47478	bool emitShlSint8Sint64(SourceInfo);
47479	bool emitShlSint8Uint64(SourceInfo);
47480	bool emitShlSint8IntAP(SourceInfo);
47481	bool emitShlSint8IntAPS(SourceInfo);
47482	bool emitShlUint8Sint8(SourceInfo);
47483	bool emitShlUint8Uint8(SourceInfo);
47484	bool emitShlUint8Sint16(SourceInfo);
47485	bool emitShlUint8Uint16(SourceInfo);
47486	bool emitShlUint8Sint32(SourceInfo);
47487	bool emitShlUint8Uint32(SourceInfo);
47488	bool emitShlUint8Sint64(SourceInfo);
47489	bool emitShlUint8Uint64(SourceInfo);
47490	bool emitShlUint8IntAP(SourceInfo);
47491	bool emitShlUint8IntAPS(SourceInfo);
47492	bool emitShlSint16Sint8(SourceInfo);
47493	bool emitShlSint16Uint8(SourceInfo);
47494	bool emitShlSint16Sint16(SourceInfo);
47495	bool emitShlSint16Uint16(SourceInfo);
47496	bool emitShlSint16Sint32(SourceInfo);
47497	bool emitShlSint16Uint32(SourceInfo);
47498	bool emitShlSint16Sint64(SourceInfo);
47499	bool emitShlSint16Uint64(SourceInfo);
47500	bool emitShlSint16IntAP(SourceInfo);
47501	bool emitShlSint16IntAPS(SourceInfo);
47502	bool emitShlUint16Sint8(SourceInfo);
47503	bool emitShlUint16Uint8(SourceInfo);
47504	bool emitShlUint16Sint16(SourceInfo);
47505	bool emitShlUint16Uint16(SourceInfo);
47506	bool emitShlUint16Sint32(SourceInfo);
47507	bool emitShlUint16Uint32(SourceInfo);
47508	bool emitShlUint16Sint64(SourceInfo);
47509	bool emitShlUint16Uint64(SourceInfo);
47510	bool emitShlUint16IntAP(SourceInfo);
47511	bool emitShlUint16IntAPS(SourceInfo);
47512	bool emitShlSint32Sint8(SourceInfo);
47513	bool emitShlSint32Uint8(SourceInfo);
47514	bool emitShlSint32Sint16(SourceInfo);
47515	bool emitShlSint32Uint16(SourceInfo);
47516	bool emitShlSint32Sint32(SourceInfo);
47517	bool emitShlSint32Uint32(SourceInfo);
47518	bool emitShlSint32Sint64(SourceInfo);
47519	bool emitShlSint32Uint64(SourceInfo);
47520	bool emitShlSint32IntAP(SourceInfo);
47521	bool emitShlSint32IntAPS(SourceInfo);
47522	bool emitShlUint32Sint8(SourceInfo);
47523	bool emitShlUint32Uint8(SourceInfo);
47524	bool emitShlUint32Sint16(SourceInfo);
47525	bool emitShlUint32Uint16(SourceInfo);
47526	bool emitShlUint32Sint32(SourceInfo);
47527	bool emitShlUint32Uint32(SourceInfo);
47528	bool emitShlUint32Sint64(SourceInfo);
47529	bool emitShlUint32Uint64(SourceInfo);
47530	bool emitShlUint32IntAP(SourceInfo);
47531	bool emitShlUint32IntAPS(SourceInfo);
47532	bool emitShlSint64Sint8(SourceInfo);
47533	bool emitShlSint64Uint8(SourceInfo);
47534	bool emitShlSint64Sint16(SourceInfo);
47535	bool emitShlSint64Uint16(SourceInfo);
47536	bool emitShlSint64Sint32(SourceInfo);
47537	bool emitShlSint64Uint32(SourceInfo);
47538	bool emitShlSint64Sint64(SourceInfo);
47539	bool emitShlSint64Uint64(SourceInfo);
47540	bool emitShlSint64IntAP(SourceInfo);
47541	bool emitShlSint64IntAPS(SourceInfo);
47542	bool emitShlUint64Sint8(SourceInfo);
47543	bool emitShlUint64Uint8(SourceInfo);
47544	bool emitShlUint64Sint16(SourceInfo);
47545	bool emitShlUint64Uint16(SourceInfo);
47546	bool emitShlUint64Sint32(SourceInfo);
47547	bool emitShlUint64Uint32(SourceInfo);
47548	bool emitShlUint64Sint64(SourceInfo);
47549	bool emitShlUint64Uint64(SourceInfo);
47550	bool emitShlUint64IntAP(SourceInfo);
47551	bool emitShlUint64IntAPS(SourceInfo);
47552	bool emitShlIntAPSint8(SourceInfo);
47553	bool emitShlIntAPUint8(SourceInfo);
47554	bool emitShlIntAPSint16(SourceInfo);
47555	bool emitShlIntAPUint16(SourceInfo);
47556	bool emitShlIntAPSint32(SourceInfo);
47557	bool emitShlIntAPUint32(SourceInfo);
47558	bool emitShlIntAPSint64(SourceInfo);
47559	bool emitShlIntAPUint64(SourceInfo);
47560	bool emitShlIntAPIntAP(SourceInfo);
47561	bool emitShlIntAPIntAPS(SourceInfo);
47562	bool emitShlIntAPSSint8(SourceInfo);
47563	bool emitShlIntAPSUint8(SourceInfo);
47564	bool emitShlIntAPSSint16(SourceInfo);
47565	bool emitShlIntAPSUint16(SourceInfo);
47566	bool emitShlIntAPSSint32(SourceInfo);
47567	bool emitShlIntAPSUint32(SourceInfo);
47568	bool emitShlIntAPSSint64(SourceInfo);
47569	bool emitShlIntAPSUint64(SourceInfo);
47570	bool emitShlIntAPSIntAP(SourceInfo);
47571	bool emitShlIntAPSIntAPS(SourceInfo);
47572	#endif
47573	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
47574	[[nodiscard]] bool emitShl(PrimType, PrimType, SourceInfo I);
47575	#endif
47576	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
47577	bool
47578	#if defined(GET_EVAL_IMPL)
47579	EvalEmitter
47580	#else
47581	ByteCodeEmitter
47582	#endif
47583	::emitShl(PrimType T0, PrimType T1, SourceInfo I) {
47584	switch (T0) {
47585	case PT_Sint8:
47586	switch (T1) {
47587	case PT_Sint8:
47588	return emitShlSint8Sint8(I);
47589	case PT_Uint8:
47590	return emitShlSint8Uint8(I);
47591	case PT_Sint16:
47592	return emitShlSint8Sint16(I);
47593	case PT_Uint16:
47594	return emitShlSint8Uint16(I);
47595	case PT_Sint32:
47596	return emitShlSint8Sint32(I);
47597	case PT_Uint32:
47598	return emitShlSint8Uint32(I);
47599	case PT_Sint64:
47600	return emitShlSint8Sint64(I);
47601	case PT_Uint64:
47602	return emitShlSint8Uint64(I);
47603	case PT_IntAP:
47604	return emitShlSint8IntAP(I);
47605	case PT_IntAPS:
47606	return emitShlSint8IntAPS(I);
47607	default: llvm_unreachable("invalid type: emitShl");
47608	}
47609	llvm_unreachable("invalid enum value");
47610	case PT_Uint8:
47611	switch (T1) {
47612	case PT_Sint8:
47613	return emitShlUint8Sint8(I);
47614	case PT_Uint8:
47615	return emitShlUint8Uint8(I);
47616	case PT_Sint16:
47617	return emitShlUint8Sint16(I);
47618	case PT_Uint16:
47619	return emitShlUint8Uint16(I);
47620	case PT_Sint32:
47621	return emitShlUint8Sint32(I);
47622	case PT_Uint32:
47623	return emitShlUint8Uint32(I);
47624	case PT_Sint64:
47625	return emitShlUint8Sint64(I);
47626	case PT_Uint64:
47627	return emitShlUint8Uint64(I);
47628	case PT_IntAP:
47629	return emitShlUint8IntAP(I);
47630	case PT_IntAPS:
47631	return emitShlUint8IntAPS(I);
47632	default: llvm_unreachable("invalid type: emitShl");
47633	}
47634	llvm_unreachable("invalid enum value");
47635	case PT_Sint16:
47636	switch (T1) {
47637	case PT_Sint8:
47638	return emitShlSint16Sint8(I);
47639	case PT_Uint8:
47640	return emitShlSint16Uint8(I);
47641	case PT_Sint16:
47642	return emitShlSint16Sint16(I);
47643	case PT_Uint16:
47644	return emitShlSint16Uint16(I);
47645	case PT_Sint32:
47646	return emitShlSint16Sint32(I);
47647	case PT_Uint32:
47648	return emitShlSint16Uint32(I);
47649	case PT_Sint64:
47650	return emitShlSint16Sint64(I);
47651	case PT_Uint64:
47652	return emitShlSint16Uint64(I);
47653	case PT_IntAP:
47654	return emitShlSint16IntAP(I);
47655	case PT_IntAPS:
47656	return emitShlSint16IntAPS(I);
47657	default: llvm_unreachable("invalid type: emitShl");
47658	}
47659	llvm_unreachable("invalid enum value");
47660	case PT_Uint16:
47661	switch (T1) {
47662	case PT_Sint8:
47663	return emitShlUint16Sint8(I);
47664	case PT_Uint8:
47665	return emitShlUint16Uint8(I);
47666	case PT_Sint16:
47667	return emitShlUint16Sint16(I);
47668	case PT_Uint16:
47669	return emitShlUint16Uint16(I);
47670	case PT_Sint32:
47671	return emitShlUint16Sint32(I);
47672	case PT_Uint32:
47673	return emitShlUint16Uint32(I);
47674	case PT_Sint64:
47675	return emitShlUint16Sint64(I);
47676	case PT_Uint64:
47677	return emitShlUint16Uint64(I);
47678	case PT_IntAP:
47679	return emitShlUint16IntAP(I);
47680	case PT_IntAPS:
47681	return emitShlUint16IntAPS(I);
47682	default: llvm_unreachable("invalid type: emitShl");
47683	}
47684	llvm_unreachable("invalid enum value");
47685	case PT_Sint32:
47686	switch (T1) {
47687	case PT_Sint8:
47688	return emitShlSint32Sint8(I);
47689	case PT_Uint8:
47690	return emitShlSint32Uint8(I);
47691	case PT_Sint16:
47692	return emitShlSint32Sint16(I);
47693	case PT_Uint16:
47694	return emitShlSint32Uint16(I);
47695	case PT_Sint32:
47696	return emitShlSint32Sint32(I);
47697	case PT_Uint32:
47698	return emitShlSint32Uint32(I);
47699	case PT_Sint64:
47700	return emitShlSint32Sint64(I);
47701	case PT_Uint64:
47702	return emitShlSint32Uint64(I);
47703	case PT_IntAP:
47704	return emitShlSint32IntAP(I);
47705	case PT_IntAPS:
47706	return emitShlSint32IntAPS(I);
47707	default: llvm_unreachable("invalid type: emitShl");
47708	}
47709	llvm_unreachable("invalid enum value");
47710	case PT_Uint32:
47711	switch (T1) {
47712	case PT_Sint8:
47713	return emitShlUint32Sint8(I);
47714	case PT_Uint8:
47715	return emitShlUint32Uint8(I);
47716	case PT_Sint16:
47717	return emitShlUint32Sint16(I);
47718	case PT_Uint16:
47719	return emitShlUint32Uint16(I);
47720	case PT_Sint32:
47721	return emitShlUint32Sint32(I);
47722	case PT_Uint32:
47723	return emitShlUint32Uint32(I);
47724	case PT_Sint64:
47725	return emitShlUint32Sint64(I);
47726	case PT_Uint64:
47727	return emitShlUint32Uint64(I);
47728	case PT_IntAP:
47729	return emitShlUint32IntAP(I);
47730	case PT_IntAPS:
47731	return emitShlUint32IntAPS(I);
47732	default: llvm_unreachable("invalid type: emitShl");
47733	}
47734	llvm_unreachable("invalid enum value");
47735	case PT_Sint64:
47736	switch (T1) {
47737	case PT_Sint8:
47738	return emitShlSint64Sint8(I);
47739	case PT_Uint8:
47740	return emitShlSint64Uint8(I);
47741	case PT_Sint16:
47742	return emitShlSint64Sint16(I);
47743	case PT_Uint16:
47744	return emitShlSint64Uint16(I);
47745	case PT_Sint32:
47746	return emitShlSint64Sint32(I);
47747	case PT_Uint32:
47748	return emitShlSint64Uint32(I);
47749	case PT_Sint64:
47750	return emitShlSint64Sint64(I);
47751	case PT_Uint64:
47752	return emitShlSint64Uint64(I);
47753	case PT_IntAP:
47754	return emitShlSint64IntAP(I);
47755	case PT_IntAPS:
47756	return emitShlSint64IntAPS(I);
47757	default: llvm_unreachable("invalid type: emitShl");
47758	}
47759	llvm_unreachable("invalid enum value");
47760	case PT_Uint64:
47761	switch (T1) {
47762	case PT_Sint8:
47763	return emitShlUint64Sint8(I);
47764	case PT_Uint8:
47765	return emitShlUint64Uint8(I);
47766	case PT_Sint16:
47767	return emitShlUint64Sint16(I);
47768	case PT_Uint16:
47769	return emitShlUint64Uint16(I);
47770	case PT_Sint32:
47771	return emitShlUint64Sint32(I);
47772	case PT_Uint32:
47773	return emitShlUint64Uint32(I);
47774	case PT_Sint64:
47775	return emitShlUint64Sint64(I);
47776	case PT_Uint64:
47777	return emitShlUint64Uint64(I);
47778	case PT_IntAP:
47779	return emitShlUint64IntAP(I);
47780	case PT_IntAPS:
47781	return emitShlUint64IntAPS(I);
47782	default: llvm_unreachable("invalid type: emitShl");
47783	}
47784	llvm_unreachable("invalid enum value");
47785	case PT_IntAP:
47786	switch (T1) {
47787	case PT_Sint8:
47788	return emitShlIntAPSint8(I);
47789	case PT_Uint8:
47790	return emitShlIntAPUint8(I);
47791	case PT_Sint16:
47792	return emitShlIntAPSint16(I);
47793	case PT_Uint16:
47794	return emitShlIntAPUint16(I);
47795	case PT_Sint32:
47796	return emitShlIntAPSint32(I);
47797	case PT_Uint32:
47798	return emitShlIntAPUint32(I);
47799	case PT_Sint64:
47800	return emitShlIntAPSint64(I);
47801	case PT_Uint64:
47802	return emitShlIntAPUint64(I);
47803	case PT_IntAP:
47804	return emitShlIntAPIntAP(I);
47805	case PT_IntAPS:
47806	return emitShlIntAPIntAPS(I);
47807	default: llvm_unreachable("invalid type: emitShl");
47808	}
47809	llvm_unreachable("invalid enum value");
47810	case PT_IntAPS:
47811	switch (T1) {
47812	case PT_Sint8:
47813	return emitShlIntAPSSint8(I);
47814	case PT_Uint8:
47815	return emitShlIntAPSUint8(I);
47816	case PT_Sint16:
47817	return emitShlIntAPSSint16(I);
47818	case PT_Uint16:
47819	return emitShlIntAPSUint16(I);
47820	case PT_Sint32:
47821	return emitShlIntAPSSint32(I);
47822	case PT_Uint32:
47823	return emitShlIntAPSUint32(I);
47824	case PT_Sint64:
47825	return emitShlIntAPSSint64(I);
47826	case PT_Uint64:
47827	return emitShlIntAPSUint64(I);
47828	case PT_IntAP:
47829	return emitShlIntAPSIntAP(I);
47830	case PT_IntAPS:
47831	return emitShlIntAPSIntAPS(I);
47832	default: llvm_unreachable("invalid type: emitShl");
47833	}
47834	llvm_unreachable("invalid enum value");
47835	default: llvm_unreachable("invalid type: emitShl");
47836	}
47837	llvm_unreachable("invalid enum value");
47838	}
47839	#endif
47840	#ifdef GET_LINK_IMPL
47841	bool ByteCodeEmitter::emitShlSint8Sint8(SourceInfo L) {
47842	return emitOp<>(OP_ShlSint8Sint8, L);
47843	}
47844	bool ByteCodeEmitter::emitShlSint8Uint8(SourceInfo L) {
47845	return emitOp<>(OP_ShlSint8Uint8, L);
47846	}
47847	bool ByteCodeEmitter::emitShlSint8Sint16(SourceInfo L) {
47848	return emitOp<>(OP_ShlSint8Sint16, L);
47849	}
47850	bool ByteCodeEmitter::emitShlSint8Uint16(SourceInfo L) {
47851	return emitOp<>(OP_ShlSint8Uint16, L);
47852	}
47853	bool ByteCodeEmitter::emitShlSint8Sint32(SourceInfo L) {
47854	return emitOp<>(OP_ShlSint8Sint32, L);
47855	}
47856	bool ByteCodeEmitter::emitShlSint8Uint32(SourceInfo L) {
47857	return emitOp<>(OP_ShlSint8Uint32, L);
47858	}
47859	bool ByteCodeEmitter::emitShlSint8Sint64(SourceInfo L) {
47860	return emitOp<>(OP_ShlSint8Sint64, L);
47861	}
47862	bool ByteCodeEmitter::emitShlSint8Uint64(SourceInfo L) {
47863	return emitOp<>(OP_ShlSint8Uint64, L);
47864	}
47865	bool ByteCodeEmitter::emitShlSint8IntAP(SourceInfo L) {
47866	return emitOp<>(OP_ShlSint8IntAP, L);
47867	}
47868	bool ByteCodeEmitter::emitShlSint8IntAPS(SourceInfo L) {
47869	return emitOp<>(OP_ShlSint8IntAPS, L);
47870	}
47871	bool ByteCodeEmitter::emitShlUint8Sint8(SourceInfo L) {
47872	return emitOp<>(OP_ShlUint8Sint8, L);
47873	}
47874	bool ByteCodeEmitter::emitShlUint8Uint8(SourceInfo L) {
47875	return emitOp<>(OP_ShlUint8Uint8, L);
47876	}
47877	bool ByteCodeEmitter::emitShlUint8Sint16(SourceInfo L) {
47878	return emitOp<>(OP_ShlUint8Sint16, L);
47879	}
47880	bool ByteCodeEmitter::emitShlUint8Uint16(SourceInfo L) {
47881	return emitOp<>(OP_ShlUint8Uint16, L);
47882	}
47883	bool ByteCodeEmitter::emitShlUint8Sint32(SourceInfo L) {
47884	return emitOp<>(OP_ShlUint8Sint32, L);
47885	}
47886	bool ByteCodeEmitter::emitShlUint8Uint32(SourceInfo L) {
47887	return emitOp<>(OP_ShlUint8Uint32, L);
47888	}
47889	bool ByteCodeEmitter::emitShlUint8Sint64(SourceInfo L) {
47890	return emitOp<>(OP_ShlUint8Sint64, L);
47891	}
47892	bool ByteCodeEmitter::emitShlUint8Uint64(SourceInfo L) {
47893	return emitOp<>(OP_ShlUint8Uint64, L);
47894	}
47895	bool ByteCodeEmitter::emitShlUint8IntAP(SourceInfo L) {
47896	return emitOp<>(OP_ShlUint8IntAP, L);
47897	}
47898	bool ByteCodeEmitter::emitShlUint8IntAPS(SourceInfo L) {
47899	return emitOp<>(OP_ShlUint8IntAPS, L);
47900	}
47901	bool ByteCodeEmitter::emitShlSint16Sint8(SourceInfo L) {
47902	return emitOp<>(OP_ShlSint16Sint8, L);
47903	}
47904	bool ByteCodeEmitter::emitShlSint16Uint8(SourceInfo L) {
47905	return emitOp<>(OP_ShlSint16Uint8, L);
47906	}
47907	bool ByteCodeEmitter::emitShlSint16Sint16(SourceInfo L) {
47908	return emitOp<>(OP_ShlSint16Sint16, L);
47909	}
47910	bool ByteCodeEmitter::emitShlSint16Uint16(SourceInfo L) {
47911	return emitOp<>(OP_ShlSint16Uint16, L);
47912	}
47913	bool ByteCodeEmitter::emitShlSint16Sint32(SourceInfo L) {
47914	return emitOp<>(OP_ShlSint16Sint32, L);
47915	}
47916	bool ByteCodeEmitter::emitShlSint16Uint32(SourceInfo L) {
47917	return emitOp<>(OP_ShlSint16Uint32, L);
47918	}
47919	bool ByteCodeEmitter::emitShlSint16Sint64(SourceInfo L) {
47920	return emitOp<>(OP_ShlSint16Sint64, L);
47921	}
47922	bool ByteCodeEmitter::emitShlSint16Uint64(SourceInfo L) {
47923	return emitOp<>(OP_ShlSint16Uint64, L);
47924	}
47925	bool ByteCodeEmitter::emitShlSint16IntAP(SourceInfo L) {
47926	return emitOp<>(OP_ShlSint16IntAP, L);
47927	}
47928	bool ByteCodeEmitter::emitShlSint16IntAPS(SourceInfo L) {
47929	return emitOp<>(OP_ShlSint16IntAPS, L);
47930	}
47931	bool ByteCodeEmitter::emitShlUint16Sint8(SourceInfo L) {
47932	return emitOp<>(OP_ShlUint16Sint8, L);
47933	}
47934	bool ByteCodeEmitter::emitShlUint16Uint8(SourceInfo L) {
47935	return emitOp<>(OP_ShlUint16Uint8, L);
47936	}
47937	bool ByteCodeEmitter::emitShlUint16Sint16(SourceInfo L) {
47938	return emitOp<>(OP_ShlUint16Sint16, L);
47939	}
47940	bool ByteCodeEmitter::emitShlUint16Uint16(SourceInfo L) {
47941	return emitOp<>(OP_ShlUint16Uint16, L);
47942	}
47943	bool ByteCodeEmitter::emitShlUint16Sint32(SourceInfo L) {
47944	return emitOp<>(OP_ShlUint16Sint32, L);
47945	}
47946	bool ByteCodeEmitter::emitShlUint16Uint32(SourceInfo L) {
47947	return emitOp<>(OP_ShlUint16Uint32, L);
47948	}
47949	bool ByteCodeEmitter::emitShlUint16Sint64(SourceInfo L) {
47950	return emitOp<>(OP_ShlUint16Sint64, L);
47951	}
47952	bool ByteCodeEmitter::emitShlUint16Uint64(SourceInfo L) {
47953	return emitOp<>(OP_ShlUint16Uint64, L);
47954	}
47955	bool ByteCodeEmitter::emitShlUint16IntAP(SourceInfo L) {
47956	return emitOp<>(OP_ShlUint16IntAP, L);
47957	}
47958	bool ByteCodeEmitter::emitShlUint16IntAPS(SourceInfo L) {
47959	return emitOp<>(OP_ShlUint16IntAPS, L);
47960	}
47961	bool ByteCodeEmitter::emitShlSint32Sint8(SourceInfo L) {
47962	return emitOp<>(OP_ShlSint32Sint8, L);
47963	}
47964	bool ByteCodeEmitter::emitShlSint32Uint8(SourceInfo L) {
47965	return emitOp<>(OP_ShlSint32Uint8, L);
47966	}
47967	bool ByteCodeEmitter::emitShlSint32Sint16(SourceInfo L) {
47968	return emitOp<>(OP_ShlSint32Sint16, L);
47969	}
47970	bool ByteCodeEmitter::emitShlSint32Uint16(SourceInfo L) {
47971	return emitOp<>(OP_ShlSint32Uint16, L);
47972	}
47973	bool ByteCodeEmitter::emitShlSint32Sint32(SourceInfo L) {
47974	return emitOp<>(OP_ShlSint32Sint32, L);
47975	}
47976	bool ByteCodeEmitter::emitShlSint32Uint32(SourceInfo L) {
47977	return emitOp<>(OP_ShlSint32Uint32, L);
47978	}
47979	bool ByteCodeEmitter::emitShlSint32Sint64(SourceInfo L) {
47980	return emitOp<>(OP_ShlSint32Sint64, L);
47981	}
47982	bool ByteCodeEmitter::emitShlSint32Uint64(SourceInfo L) {
47983	return emitOp<>(OP_ShlSint32Uint64, L);
47984	}
47985	bool ByteCodeEmitter::emitShlSint32IntAP(SourceInfo L) {
47986	return emitOp<>(OP_ShlSint32IntAP, L);
47987	}
47988	bool ByteCodeEmitter::emitShlSint32IntAPS(SourceInfo L) {
47989	return emitOp<>(OP_ShlSint32IntAPS, L);
47990	}
47991	bool ByteCodeEmitter::emitShlUint32Sint8(SourceInfo L) {
47992	return emitOp<>(OP_ShlUint32Sint8, L);
47993	}
47994	bool ByteCodeEmitter::emitShlUint32Uint8(SourceInfo L) {
47995	return emitOp<>(OP_ShlUint32Uint8, L);
47996	}
47997	bool ByteCodeEmitter::emitShlUint32Sint16(SourceInfo L) {
47998	return emitOp<>(OP_ShlUint32Sint16, L);
47999	}
48000	bool ByteCodeEmitter::emitShlUint32Uint16(SourceInfo L) {
48001	return emitOp<>(OP_ShlUint32Uint16, L);
48002	}
48003	bool ByteCodeEmitter::emitShlUint32Sint32(SourceInfo L) {
48004	return emitOp<>(OP_ShlUint32Sint32, L);
48005	}
48006	bool ByteCodeEmitter::emitShlUint32Uint32(SourceInfo L) {
48007	return emitOp<>(OP_ShlUint32Uint32, L);
48008	}
48009	bool ByteCodeEmitter::emitShlUint32Sint64(SourceInfo L) {
48010	return emitOp<>(OP_ShlUint32Sint64, L);
48011	}
48012	bool ByteCodeEmitter::emitShlUint32Uint64(SourceInfo L) {
48013	return emitOp<>(OP_ShlUint32Uint64, L);
48014	}
48015	bool ByteCodeEmitter::emitShlUint32IntAP(SourceInfo L) {
48016	return emitOp<>(OP_ShlUint32IntAP, L);
48017	}
48018	bool ByteCodeEmitter::emitShlUint32IntAPS(SourceInfo L) {
48019	return emitOp<>(OP_ShlUint32IntAPS, L);
48020	}
48021	bool ByteCodeEmitter::emitShlSint64Sint8(SourceInfo L) {
48022	return emitOp<>(OP_ShlSint64Sint8, L);
48023	}
48024	bool ByteCodeEmitter::emitShlSint64Uint8(SourceInfo L) {
48025	return emitOp<>(OP_ShlSint64Uint8, L);
48026	}
48027	bool ByteCodeEmitter::emitShlSint64Sint16(SourceInfo L) {
48028	return emitOp<>(OP_ShlSint64Sint16, L);
48029	}
48030	bool ByteCodeEmitter::emitShlSint64Uint16(SourceInfo L) {
48031	return emitOp<>(OP_ShlSint64Uint16, L);
48032	}
48033	bool ByteCodeEmitter::emitShlSint64Sint32(SourceInfo L) {
48034	return emitOp<>(OP_ShlSint64Sint32, L);
48035	}
48036	bool ByteCodeEmitter::emitShlSint64Uint32(SourceInfo L) {
48037	return emitOp<>(OP_ShlSint64Uint32, L);
48038	}
48039	bool ByteCodeEmitter::emitShlSint64Sint64(SourceInfo L) {
48040	return emitOp<>(OP_ShlSint64Sint64, L);
48041	}
48042	bool ByteCodeEmitter::emitShlSint64Uint64(SourceInfo L) {
48043	return emitOp<>(OP_ShlSint64Uint64, L);
48044	}
48045	bool ByteCodeEmitter::emitShlSint64IntAP(SourceInfo L) {
48046	return emitOp<>(OP_ShlSint64IntAP, L);
48047	}
48048	bool ByteCodeEmitter::emitShlSint64IntAPS(SourceInfo L) {
48049	return emitOp<>(OP_ShlSint64IntAPS, L);
48050	}
48051	bool ByteCodeEmitter::emitShlUint64Sint8(SourceInfo L) {
48052	return emitOp<>(OP_ShlUint64Sint8, L);
48053	}
48054	bool ByteCodeEmitter::emitShlUint64Uint8(SourceInfo L) {
48055	return emitOp<>(OP_ShlUint64Uint8, L);
48056	}
48057	bool ByteCodeEmitter::emitShlUint64Sint16(SourceInfo L) {
48058	return emitOp<>(OP_ShlUint64Sint16, L);
48059	}
48060	bool ByteCodeEmitter::emitShlUint64Uint16(SourceInfo L) {
48061	return emitOp<>(OP_ShlUint64Uint16, L);
48062	}
48063	bool ByteCodeEmitter::emitShlUint64Sint32(SourceInfo L) {
48064	return emitOp<>(OP_ShlUint64Sint32, L);
48065	}
48066	bool ByteCodeEmitter::emitShlUint64Uint32(SourceInfo L) {
48067	return emitOp<>(OP_ShlUint64Uint32, L);
48068	}
48069	bool ByteCodeEmitter::emitShlUint64Sint64(SourceInfo L) {
48070	return emitOp<>(OP_ShlUint64Sint64, L);
48071	}
48072	bool ByteCodeEmitter::emitShlUint64Uint64(SourceInfo L) {
48073	return emitOp<>(OP_ShlUint64Uint64, L);
48074	}
48075	bool ByteCodeEmitter::emitShlUint64IntAP(SourceInfo L) {
48076	return emitOp<>(OP_ShlUint64IntAP, L);
48077	}
48078	bool ByteCodeEmitter::emitShlUint64IntAPS(SourceInfo L) {
48079	return emitOp<>(OP_ShlUint64IntAPS, L);
48080	}
48081	bool ByteCodeEmitter::emitShlIntAPSint8(SourceInfo L) {
48082	return emitOp<>(OP_ShlIntAPSint8, L);
48083	}
48084	bool ByteCodeEmitter::emitShlIntAPUint8(SourceInfo L) {
48085	return emitOp<>(OP_ShlIntAPUint8, L);
48086	}
48087	bool ByteCodeEmitter::emitShlIntAPSint16(SourceInfo L) {
48088	return emitOp<>(OP_ShlIntAPSint16, L);
48089	}
48090	bool ByteCodeEmitter::emitShlIntAPUint16(SourceInfo L) {
48091	return emitOp<>(OP_ShlIntAPUint16, L);
48092	}
48093	bool ByteCodeEmitter::emitShlIntAPSint32(SourceInfo L) {
48094	return emitOp<>(OP_ShlIntAPSint32, L);
48095	}
48096	bool ByteCodeEmitter::emitShlIntAPUint32(SourceInfo L) {
48097	return emitOp<>(OP_ShlIntAPUint32, L);
48098	}
48099	bool ByteCodeEmitter::emitShlIntAPSint64(SourceInfo L) {
48100	return emitOp<>(OP_ShlIntAPSint64, L);
48101	}
48102	bool ByteCodeEmitter::emitShlIntAPUint64(SourceInfo L) {
48103	return emitOp<>(OP_ShlIntAPUint64, L);
48104	}
48105	bool ByteCodeEmitter::emitShlIntAPIntAP(SourceInfo L) {
48106	return emitOp<>(OP_ShlIntAPIntAP, L);
48107	}
48108	bool ByteCodeEmitter::emitShlIntAPIntAPS(SourceInfo L) {
48109	return emitOp<>(OP_ShlIntAPIntAPS, L);
48110	}
48111	bool ByteCodeEmitter::emitShlIntAPSSint8(SourceInfo L) {
48112	return emitOp<>(OP_ShlIntAPSSint8, L);
48113	}
48114	bool ByteCodeEmitter::emitShlIntAPSUint8(SourceInfo L) {
48115	return emitOp<>(OP_ShlIntAPSUint8, L);
48116	}
48117	bool ByteCodeEmitter::emitShlIntAPSSint16(SourceInfo L) {
48118	return emitOp<>(OP_ShlIntAPSSint16, L);
48119	}
48120	bool ByteCodeEmitter::emitShlIntAPSUint16(SourceInfo L) {
48121	return emitOp<>(OP_ShlIntAPSUint16, L);
48122	}
48123	bool ByteCodeEmitter::emitShlIntAPSSint32(SourceInfo L) {
48124	return emitOp<>(OP_ShlIntAPSSint32, L);
48125	}
48126	bool ByteCodeEmitter::emitShlIntAPSUint32(SourceInfo L) {
48127	return emitOp<>(OP_ShlIntAPSUint32, L);
48128	}
48129	bool ByteCodeEmitter::emitShlIntAPSSint64(SourceInfo L) {
48130	return emitOp<>(OP_ShlIntAPSSint64, L);
48131	}
48132	bool ByteCodeEmitter::emitShlIntAPSUint64(SourceInfo L) {
48133	return emitOp<>(OP_ShlIntAPSUint64, L);
48134	}
48135	bool ByteCodeEmitter::emitShlIntAPSIntAP(SourceInfo L) {
48136	return emitOp<>(OP_ShlIntAPSIntAP, L);
48137	}
48138	bool ByteCodeEmitter::emitShlIntAPSIntAPS(SourceInfo L) {
48139	return emitOp<>(OP_ShlIntAPSIntAPS, L);
48140	}
48141	#endif
48142	#ifdef GET_EVAL_IMPL
48143	bool EvalEmitter::emitShlSint8Sint8(SourceInfo L) {
48144	if (!isActive()) return true;
48145	CurrentSource = L;
48146	return Shl<PT_Sint8, PT_Sint8>(S, CodePtr());
48147	}
48148	bool EvalEmitter::emitShlSint8Uint8(SourceInfo L) {
48149	if (!isActive()) return true;
48150	CurrentSource = L;
48151	return Shl<PT_Sint8, PT_Uint8>(S, CodePtr());
48152	}
48153	bool EvalEmitter::emitShlSint8Sint16(SourceInfo L) {
48154	if (!isActive()) return true;
48155	CurrentSource = L;
48156	return Shl<PT_Sint8, PT_Sint16>(S, CodePtr());
48157	}
48158	bool EvalEmitter::emitShlSint8Uint16(SourceInfo L) {
48159	if (!isActive()) return true;
48160	CurrentSource = L;
48161	return Shl<PT_Sint8, PT_Uint16>(S, CodePtr());
48162	}
48163	bool EvalEmitter::emitShlSint8Sint32(SourceInfo L) {
48164	if (!isActive()) return true;
48165	CurrentSource = L;
48166	return Shl<PT_Sint8, PT_Sint32>(S, CodePtr());
48167	}
48168	bool EvalEmitter::emitShlSint8Uint32(SourceInfo L) {
48169	if (!isActive()) return true;
48170	CurrentSource = L;
48171	return Shl<PT_Sint8, PT_Uint32>(S, CodePtr());
48172	}
48173	bool EvalEmitter::emitShlSint8Sint64(SourceInfo L) {
48174	if (!isActive()) return true;
48175	CurrentSource = L;
48176	return Shl<PT_Sint8, PT_Sint64>(S, CodePtr());
48177	}
48178	bool EvalEmitter::emitShlSint8Uint64(SourceInfo L) {
48179	if (!isActive()) return true;
48180	CurrentSource = L;
48181	return Shl<PT_Sint8, PT_Uint64>(S, CodePtr());
48182	}
48183	bool EvalEmitter::emitShlSint8IntAP(SourceInfo L) {
48184	if (!isActive()) return true;
48185	CurrentSource = L;
48186	return Shl<PT_Sint8, PT_IntAP>(S, CodePtr());
48187	}
48188	bool EvalEmitter::emitShlSint8IntAPS(SourceInfo L) {
48189	if (!isActive()) return true;
48190	CurrentSource = L;
48191	return Shl<PT_Sint8, PT_IntAPS>(S, CodePtr());
48192	}
48193	bool EvalEmitter::emitShlUint8Sint8(SourceInfo L) {
48194	if (!isActive()) return true;
48195	CurrentSource = L;
48196	return Shl<PT_Uint8, PT_Sint8>(S, CodePtr());
48197	}
48198	bool EvalEmitter::emitShlUint8Uint8(SourceInfo L) {
48199	if (!isActive()) return true;
48200	CurrentSource = L;
48201	return Shl<PT_Uint8, PT_Uint8>(S, CodePtr());
48202	}
48203	bool EvalEmitter::emitShlUint8Sint16(SourceInfo L) {
48204	if (!isActive()) return true;
48205	CurrentSource = L;
48206	return Shl<PT_Uint8, PT_Sint16>(S, CodePtr());
48207	}
48208	bool EvalEmitter::emitShlUint8Uint16(SourceInfo L) {
48209	if (!isActive()) return true;
48210	CurrentSource = L;
48211	return Shl<PT_Uint8, PT_Uint16>(S, CodePtr());
48212	}
48213	bool EvalEmitter::emitShlUint8Sint32(SourceInfo L) {
48214	if (!isActive()) return true;
48215	CurrentSource = L;
48216	return Shl<PT_Uint8, PT_Sint32>(S, CodePtr());
48217	}
48218	bool EvalEmitter::emitShlUint8Uint32(SourceInfo L) {
48219	if (!isActive()) return true;
48220	CurrentSource = L;
48221	return Shl<PT_Uint8, PT_Uint32>(S, CodePtr());
48222	}
48223	bool EvalEmitter::emitShlUint8Sint64(SourceInfo L) {
48224	if (!isActive()) return true;
48225	CurrentSource = L;
48226	return Shl<PT_Uint8, PT_Sint64>(S, CodePtr());
48227	}
48228	bool EvalEmitter::emitShlUint8Uint64(SourceInfo L) {
48229	if (!isActive()) return true;
48230	CurrentSource = L;
48231	return Shl<PT_Uint8, PT_Uint64>(S, CodePtr());
48232	}
48233	bool EvalEmitter::emitShlUint8IntAP(SourceInfo L) {
48234	if (!isActive()) return true;
48235	CurrentSource = L;
48236	return Shl<PT_Uint8, PT_IntAP>(S, CodePtr());
48237	}
48238	bool EvalEmitter::emitShlUint8IntAPS(SourceInfo L) {
48239	if (!isActive()) return true;
48240	CurrentSource = L;
48241	return Shl<PT_Uint8, PT_IntAPS>(S, CodePtr());
48242	}
48243	bool EvalEmitter::emitShlSint16Sint8(SourceInfo L) {
48244	if (!isActive()) return true;
48245	CurrentSource = L;
48246	return Shl<PT_Sint16, PT_Sint8>(S, CodePtr());
48247	}
48248	bool EvalEmitter::emitShlSint16Uint8(SourceInfo L) {
48249	if (!isActive()) return true;
48250	CurrentSource = L;
48251	return Shl<PT_Sint16, PT_Uint8>(S, CodePtr());
48252	}
48253	bool EvalEmitter::emitShlSint16Sint16(SourceInfo L) {
48254	if (!isActive()) return true;
48255	CurrentSource = L;
48256	return Shl<PT_Sint16, PT_Sint16>(S, CodePtr());
48257	}
48258	bool EvalEmitter::emitShlSint16Uint16(SourceInfo L) {
48259	if (!isActive()) return true;
48260	CurrentSource = L;
48261	return Shl<PT_Sint16, PT_Uint16>(S, CodePtr());
48262	}
48263	bool EvalEmitter::emitShlSint16Sint32(SourceInfo L) {
48264	if (!isActive()) return true;
48265	CurrentSource = L;
48266	return Shl<PT_Sint16, PT_Sint32>(S, CodePtr());
48267	}
48268	bool EvalEmitter::emitShlSint16Uint32(SourceInfo L) {
48269	if (!isActive()) return true;
48270	CurrentSource = L;
48271	return Shl<PT_Sint16, PT_Uint32>(S, CodePtr());
48272	}
48273	bool EvalEmitter::emitShlSint16Sint64(SourceInfo L) {
48274	if (!isActive()) return true;
48275	CurrentSource = L;
48276	return Shl<PT_Sint16, PT_Sint64>(S, CodePtr());
48277	}
48278	bool EvalEmitter::emitShlSint16Uint64(SourceInfo L) {
48279	if (!isActive()) return true;
48280	CurrentSource = L;
48281	return Shl<PT_Sint16, PT_Uint64>(S, CodePtr());
48282	}
48283	bool EvalEmitter::emitShlSint16IntAP(SourceInfo L) {
48284	if (!isActive()) return true;
48285	CurrentSource = L;
48286	return Shl<PT_Sint16, PT_IntAP>(S, CodePtr());
48287	}
48288	bool EvalEmitter::emitShlSint16IntAPS(SourceInfo L) {
48289	if (!isActive()) return true;
48290	CurrentSource = L;
48291	return Shl<PT_Sint16, PT_IntAPS>(S, CodePtr());
48292	}
48293	bool EvalEmitter::emitShlUint16Sint8(SourceInfo L) {
48294	if (!isActive()) return true;
48295	CurrentSource = L;
48296	return Shl<PT_Uint16, PT_Sint8>(S, CodePtr());
48297	}
48298	bool EvalEmitter::emitShlUint16Uint8(SourceInfo L) {
48299	if (!isActive()) return true;
48300	CurrentSource = L;
48301	return Shl<PT_Uint16, PT_Uint8>(S, CodePtr());
48302	}
48303	bool EvalEmitter::emitShlUint16Sint16(SourceInfo L) {
48304	if (!isActive()) return true;
48305	CurrentSource = L;
48306	return Shl<PT_Uint16, PT_Sint16>(S, CodePtr());
48307	}
48308	bool EvalEmitter::emitShlUint16Uint16(SourceInfo L) {
48309	if (!isActive()) return true;
48310	CurrentSource = L;
48311	return Shl<PT_Uint16, PT_Uint16>(S, CodePtr());
48312	}
48313	bool EvalEmitter::emitShlUint16Sint32(SourceInfo L) {
48314	if (!isActive()) return true;
48315	CurrentSource = L;
48316	return Shl<PT_Uint16, PT_Sint32>(S, CodePtr());
48317	}
48318	bool EvalEmitter::emitShlUint16Uint32(SourceInfo L) {
48319	if (!isActive()) return true;
48320	CurrentSource = L;
48321	return Shl<PT_Uint16, PT_Uint32>(S, CodePtr());
48322	}
48323	bool EvalEmitter::emitShlUint16Sint64(SourceInfo L) {
48324	if (!isActive()) return true;
48325	CurrentSource = L;
48326	return Shl<PT_Uint16, PT_Sint64>(S, CodePtr());
48327	}
48328	bool EvalEmitter::emitShlUint16Uint64(SourceInfo L) {
48329	if (!isActive()) return true;
48330	CurrentSource = L;
48331	return Shl<PT_Uint16, PT_Uint64>(S, CodePtr());
48332	}
48333	bool EvalEmitter::emitShlUint16IntAP(SourceInfo L) {
48334	if (!isActive()) return true;
48335	CurrentSource = L;
48336	return Shl<PT_Uint16, PT_IntAP>(S, CodePtr());
48337	}
48338	bool EvalEmitter::emitShlUint16IntAPS(SourceInfo L) {
48339	if (!isActive()) return true;
48340	CurrentSource = L;
48341	return Shl<PT_Uint16, PT_IntAPS>(S, CodePtr());
48342	}
48343	bool EvalEmitter::emitShlSint32Sint8(SourceInfo L) {
48344	if (!isActive()) return true;
48345	CurrentSource = L;
48346	return Shl<PT_Sint32, PT_Sint8>(S, CodePtr());
48347	}
48348	bool EvalEmitter::emitShlSint32Uint8(SourceInfo L) {
48349	if (!isActive()) return true;
48350	CurrentSource = L;
48351	return Shl<PT_Sint32, PT_Uint8>(S, CodePtr());
48352	}
48353	bool EvalEmitter::emitShlSint32Sint16(SourceInfo L) {
48354	if (!isActive()) return true;
48355	CurrentSource = L;
48356	return Shl<PT_Sint32, PT_Sint16>(S, CodePtr());
48357	}
48358	bool EvalEmitter::emitShlSint32Uint16(SourceInfo L) {
48359	if (!isActive()) return true;
48360	CurrentSource = L;
48361	return Shl<PT_Sint32, PT_Uint16>(S, CodePtr());
48362	}
48363	bool EvalEmitter::emitShlSint32Sint32(SourceInfo L) {
48364	if (!isActive()) return true;
48365	CurrentSource = L;
48366	return Shl<PT_Sint32, PT_Sint32>(S, CodePtr());
48367	}
48368	bool EvalEmitter::emitShlSint32Uint32(SourceInfo L) {
48369	if (!isActive()) return true;
48370	CurrentSource = L;
48371	return Shl<PT_Sint32, PT_Uint32>(S, CodePtr());
48372	}
48373	bool EvalEmitter::emitShlSint32Sint64(SourceInfo L) {
48374	if (!isActive()) return true;
48375	CurrentSource = L;
48376	return Shl<PT_Sint32, PT_Sint64>(S, CodePtr());
48377	}
48378	bool EvalEmitter::emitShlSint32Uint64(SourceInfo L) {
48379	if (!isActive()) return true;
48380	CurrentSource = L;
48381	return Shl<PT_Sint32, PT_Uint64>(S, CodePtr());
48382	}
48383	bool EvalEmitter::emitShlSint32IntAP(SourceInfo L) {
48384	if (!isActive()) return true;
48385	CurrentSource = L;
48386	return Shl<PT_Sint32, PT_IntAP>(S, CodePtr());
48387	}
48388	bool EvalEmitter::emitShlSint32IntAPS(SourceInfo L) {
48389	if (!isActive()) return true;
48390	CurrentSource = L;
48391	return Shl<PT_Sint32, PT_IntAPS>(S, CodePtr());
48392	}
48393	bool EvalEmitter::emitShlUint32Sint8(SourceInfo L) {
48394	if (!isActive()) return true;
48395	CurrentSource = L;
48396	return Shl<PT_Uint32, PT_Sint8>(S, CodePtr());
48397	}
48398	bool EvalEmitter::emitShlUint32Uint8(SourceInfo L) {
48399	if (!isActive()) return true;
48400	CurrentSource = L;
48401	return Shl<PT_Uint32, PT_Uint8>(S, CodePtr());
48402	}
48403	bool EvalEmitter::emitShlUint32Sint16(SourceInfo L) {
48404	if (!isActive()) return true;
48405	CurrentSource = L;
48406	return Shl<PT_Uint32, PT_Sint16>(S, CodePtr());
48407	}
48408	bool EvalEmitter::emitShlUint32Uint16(SourceInfo L) {
48409	if (!isActive()) return true;
48410	CurrentSource = L;
48411	return Shl<PT_Uint32, PT_Uint16>(S, CodePtr());
48412	}
48413	bool EvalEmitter::emitShlUint32Sint32(SourceInfo L) {
48414	if (!isActive()) return true;
48415	CurrentSource = L;
48416	return Shl<PT_Uint32, PT_Sint32>(S, CodePtr());
48417	}
48418	bool EvalEmitter::emitShlUint32Uint32(SourceInfo L) {
48419	if (!isActive()) return true;
48420	CurrentSource = L;
48421	return Shl<PT_Uint32, PT_Uint32>(S, CodePtr());
48422	}
48423	bool EvalEmitter::emitShlUint32Sint64(SourceInfo L) {
48424	if (!isActive()) return true;
48425	CurrentSource = L;
48426	return Shl<PT_Uint32, PT_Sint64>(S, CodePtr());
48427	}
48428	bool EvalEmitter::emitShlUint32Uint64(SourceInfo L) {
48429	if (!isActive()) return true;
48430	CurrentSource = L;
48431	return Shl<PT_Uint32, PT_Uint64>(S, CodePtr());
48432	}
48433	bool EvalEmitter::emitShlUint32IntAP(SourceInfo L) {
48434	if (!isActive()) return true;
48435	CurrentSource = L;
48436	return Shl<PT_Uint32, PT_IntAP>(S, CodePtr());
48437	}
48438	bool EvalEmitter::emitShlUint32IntAPS(SourceInfo L) {
48439	if (!isActive()) return true;
48440	CurrentSource = L;
48441	return Shl<PT_Uint32, PT_IntAPS>(S, CodePtr());
48442	}
48443	bool EvalEmitter::emitShlSint64Sint8(SourceInfo L) {
48444	if (!isActive()) return true;
48445	CurrentSource = L;
48446	return Shl<PT_Sint64, PT_Sint8>(S, CodePtr());
48447	}
48448	bool EvalEmitter::emitShlSint64Uint8(SourceInfo L) {
48449	if (!isActive()) return true;
48450	CurrentSource = L;
48451	return Shl<PT_Sint64, PT_Uint8>(S, CodePtr());
48452	}
48453	bool EvalEmitter::emitShlSint64Sint16(SourceInfo L) {
48454	if (!isActive()) return true;
48455	CurrentSource = L;
48456	return Shl<PT_Sint64, PT_Sint16>(S, CodePtr());
48457	}
48458	bool EvalEmitter::emitShlSint64Uint16(SourceInfo L) {
48459	if (!isActive()) return true;
48460	CurrentSource = L;
48461	return Shl<PT_Sint64, PT_Uint16>(S, CodePtr());
48462	}
48463	bool EvalEmitter::emitShlSint64Sint32(SourceInfo L) {
48464	if (!isActive()) return true;
48465	CurrentSource = L;
48466	return Shl<PT_Sint64, PT_Sint32>(S, CodePtr());
48467	}
48468	bool EvalEmitter::emitShlSint64Uint32(SourceInfo L) {
48469	if (!isActive()) return true;
48470	CurrentSource = L;
48471	return Shl<PT_Sint64, PT_Uint32>(S, CodePtr());
48472	}
48473	bool EvalEmitter::emitShlSint64Sint64(SourceInfo L) {
48474	if (!isActive()) return true;
48475	CurrentSource = L;
48476	return Shl<PT_Sint64, PT_Sint64>(S, CodePtr());
48477	}
48478	bool EvalEmitter::emitShlSint64Uint64(SourceInfo L) {
48479	if (!isActive()) return true;
48480	CurrentSource = L;
48481	return Shl<PT_Sint64, PT_Uint64>(S, CodePtr());
48482	}
48483	bool EvalEmitter::emitShlSint64IntAP(SourceInfo L) {
48484	if (!isActive()) return true;
48485	CurrentSource = L;
48486	return Shl<PT_Sint64, PT_IntAP>(S, CodePtr());
48487	}
48488	bool EvalEmitter::emitShlSint64IntAPS(SourceInfo L) {
48489	if (!isActive()) return true;
48490	CurrentSource = L;
48491	return Shl<PT_Sint64, PT_IntAPS>(S, CodePtr());
48492	}
48493	bool EvalEmitter::emitShlUint64Sint8(SourceInfo L) {
48494	if (!isActive()) return true;
48495	CurrentSource = L;
48496	return Shl<PT_Uint64, PT_Sint8>(S, CodePtr());
48497	}
48498	bool EvalEmitter::emitShlUint64Uint8(SourceInfo L) {
48499	if (!isActive()) return true;
48500	CurrentSource = L;
48501	return Shl<PT_Uint64, PT_Uint8>(S, CodePtr());
48502	}
48503	bool EvalEmitter::emitShlUint64Sint16(SourceInfo L) {
48504	if (!isActive()) return true;
48505	CurrentSource = L;
48506	return Shl<PT_Uint64, PT_Sint16>(S, CodePtr());
48507	}
48508	bool EvalEmitter::emitShlUint64Uint16(SourceInfo L) {
48509	if (!isActive()) return true;
48510	CurrentSource = L;
48511	return Shl<PT_Uint64, PT_Uint16>(S, CodePtr());
48512	}
48513	bool EvalEmitter::emitShlUint64Sint32(SourceInfo L) {
48514	if (!isActive()) return true;
48515	CurrentSource = L;
48516	return Shl<PT_Uint64, PT_Sint32>(S, CodePtr());
48517	}
48518	bool EvalEmitter::emitShlUint64Uint32(SourceInfo L) {
48519	if (!isActive()) return true;
48520	CurrentSource = L;
48521	return Shl<PT_Uint64, PT_Uint32>(S, CodePtr());
48522	}
48523	bool EvalEmitter::emitShlUint64Sint64(SourceInfo L) {
48524	if (!isActive()) return true;
48525	CurrentSource = L;
48526	return Shl<PT_Uint64, PT_Sint64>(S, CodePtr());
48527	}
48528	bool EvalEmitter::emitShlUint64Uint64(SourceInfo L) {
48529	if (!isActive()) return true;
48530	CurrentSource = L;
48531	return Shl<PT_Uint64, PT_Uint64>(S, CodePtr());
48532	}
48533	bool EvalEmitter::emitShlUint64IntAP(SourceInfo L) {
48534	if (!isActive()) return true;
48535	CurrentSource = L;
48536	return Shl<PT_Uint64, PT_IntAP>(S, CodePtr());
48537	}
48538	bool EvalEmitter::emitShlUint64IntAPS(SourceInfo L) {
48539	if (!isActive()) return true;
48540	CurrentSource = L;
48541	return Shl<PT_Uint64, PT_IntAPS>(S, CodePtr());
48542	}
48543	bool EvalEmitter::emitShlIntAPSint8(SourceInfo L) {
48544	if (!isActive()) return true;
48545	CurrentSource = L;
48546	return Shl<PT_IntAP, PT_Sint8>(S, CodePtr());
48547	}
48548	bool EvalEmitter::emitShlIntAPUint8(SourceInfo L) {
48549	if (!isActive()) return true;
48550	CurrentSource = L;
48551	return Shl<PT_IntAP, PT_Uint8>(S, CodePtr());
48552	}
48553	bool EvalEmitter::emitShlIntAPSint16(SourceInfo L) {
48554	if (!isActive()) return true;
48555	CurrentSource = L;
48556	return Shl<PT_IntAP, PT_Sint16>(S, CodePtr());
48557	}
48558	bool EvalEmitter::emitShlIntAPUint16(SourceInfo L) {
48559	if (!isActive()) return true;
48560	CurrentSource = L;
48561	return Shl<PT_IntAP, PT_Uint16>(S, CodePtr());
48562	}
48563	bool EvalEmitter::emitShlIntAPSint32(SourceInfo L) {
48564	if (!isActive()) return true;
48565	CurrentSource = L;
48566	return Shl<PT_IntAP, PT_Sint32>(S, CodePtr());
48567	}
48568	bool EvalEmitter::emitShlIntAPUint32(SourceInfo L) {
48569	if (!isActive()) return true;
48570	CurrentSource = L;
48571	return Shl<PT_IntAP, PT_Uint32>(S, CodePtr());
48572	}
48573	bool EvalEmitter::emitShlIntAPSint64(SourceInfo L) {
48574	if (!isActive()) return true;
48575	CurrentSource = L;
48576	return Shl<PT_IntAP, PT_Sint64>(S, CodePtr());
48577	}
48578	bool EvalEmitter::emitShlIntAPUint64(SourceInfo L) {
48579	if (!isActive()) return true;
48580	CurrentSource = L;
48581	return Shl<PT_IntAP, PT_Uint64>(S, CodePtr());
48582	}
48583	bool EvalEmitter::emitShlIntAPIntAP(SourceInfo L) {
48584	if (!isActive()) return true;
48585	CurrentSource = L;
48586	return Shl<PT_IntAP, PT_IntAP>(S, CodePtr());
48587	}
48588	bool EvalEmitter::emitShlIntAPIntAPS(SourceInfo L) {
48589	if (!isActive()) return true;
48590	CurrentSource = L;
48591	return Shl<PT_IntAP, PT_IntAPS>(S, CodePtr());
48592	}
48593	bool EvalEmitter::emitShlIntAPSSint8(SourceInfo L) {
48594	if (!isActive()) return true;
48595	CurrentSource = L;
48596	return Shl<PT_IntAPS, PT_Sint8>(S, CodePtr());
48597	}
48598	bool EvalEmitter::emitShlIntAPSUint8(SourceInfo L) {
48599	if (!isActive()) return true;
48600	CurrentSource = L;
48601	return Shl<PT_IntAPS, PT_Uint8>(S, CodePtr());
48602	}
48603	bool EvalEmitter::emitShlIntAPSSint16(SourceInfo L) {
48604	if (!isActive()) return true;
48605	CurrentSource = L;
48606	return Shl<PT_IntAPS, PT_Sint16>(S, CodePtr());
48607	}
48608	bool EvalEmitter::emitShlIntAPSUint16(SourceInfo L) {
48609	if (!isActive()) return true;
48610	CurrentSource = L;
48611	return Shl<PT_IntAPS, PT_Uint16>(S, CodePtr());
48612	}
48613	bool EvalEmitter::emitShlIntAPSSint32(SourceInfo L) {
48614	if (!isActive()) return true;
48615	CurrentSource = L;
48616	return Shl<PT_IntAPS, PT_Sint32>(S, CodePtr());
48617	}
48618	bool EvalEmitter::emitShlIntAPSUint32(SourceInfo L) {
48619	if (!isActive()) return true;
48620	CurrentSource = L;
48621	return Shl<PT_IntAPS, PT_Uint32>(S, CodePtr());
48622	}
48623	bool EvalEmitter::emitShlIntAPSSint64(SourceInfo L) {
48624	if (!isActive()) return true;
48625	CurrentSource = L;
48626	return Shl<PT_IntAPS, PT_Sint64>(S, CodePtr());
48627	}
48628	bool EvalEmitter::emitShlIntAPSUint64(SourceInfo L) {
48629	if (!isActive()) return true;
48630	CurrentSource = L;
48631	return Shl<PT_IntAPS, PT_Uint64>(S, CodePtr());
48632	}
48633	bool EvalEmitter::emitShlIntAPSIntAP(SourceInfo L) {
48634	if (!isActive()) return true;
48635	CurrentSource = L;
48636	return Shl<PT_IntAPS, PT_IntAP>(S, CodePtr());
48637	}
48638	bool EvalEmitter::emitShlIntAPSIntAPS(SourceInfo L) {
48639	if (!isActive()) return true;
48640	CurrentSource = L;
48641	return Shl<PT_IntAPS, PT_IntAPS>(S, CodePtr());
48642	}
48643	#endif
48644	#ifdef GET_OPCODE_NAMES
48645	OP_ShrSint8Sint8,
48646	OP_ShrSint8Uint8,
48647	OP_ShrSint8Sint16,
48648	OP_ShrSint8Uint16,
48649	OP_ShrSint8Sint32,
48650	OP_ShrSint8Uint32,
48651	OP_ShrSint8Sint64,
48652	OP_ShrSint8Uint64,
48653	OP_ShrSint8IntAP,
48654	OP_ShrSint8IntAPS,
48655	OP_ShrUint8Sint8,
48656	OP_ShrUint8Uint8,
48657	OP_ShrUint8Sint16,
48658	OP_ShrUint8Uint16,
48659	OP_ShrUint8Sint32,
48660	OP_ShrUint8Uint32,
48661	OP_ShrUint8Sint64,
48662	OP_ShrUint8Uint64,
48663	OP_ShrUint8IntAP,
48664	OP_ShrUint8IntAPS,
48665	OP_ShrSint16Sint8,
48666	OP_ShrSint16Uint8,
48667	OP_ShrSint16Sint16,
48668	OP_ShrSint16Uint16,
48669	OP_ShrSint16Sint32,
48670	OP_ShrSint16Uint32,
48671	OP_ShrSint16Sint64,
48672	OP_ShrSint16Uint64,
48673	OP_ShrSint16IntAP,
48674	OP_ShrSint16IntAPS,
48675	OP_ShrUint16Sint8,
48676	OP_ShrUint16Uint8,
48677	OP_ShrUint16Sint16,
48678	OP_ShrUint16Uint16,
48679	OP_ShrUint16Sint32,
48680	OP_ShrUint16Uint32,
48681	OP_ShrUint16Sint64,
48682	OP_ShrUint16Uint64,
48683	OP_ShrUint16IntAP,
48684	OP_ShrUint16IntAPS,
48685	OP_ShrSint32Sint8,
48686	OP_ShrSint32Uint8,
48687	OP_ShrSint32Sint16,
48688	OP_ShrSint32Uint16,
48689	OP_ShrSint32Sint32,
48690	OP_ShrSint32Uint32,
48691	OP_ShrSint32Sint64,
48692	OP_ShrSint32Uint64,
48693	OP_ShrSint32IntAP,
48694	OP_ShrSint32IntAPS,
48695	OP_ShrUint32Sint8,
48696	OP_ShrUint32Uint8,
48697	OP_ShrUint32Sint16,
48698	OP_ShrUint32Uint16,
48699	OP_ShrUint32Sint32,
48700	OP_ShrUint32Uint32,
48701	OP_ShrUint32Sint64,
48702	OP_ShrUint32Uint64,
48703	OP_ShrUint32IntAP,
48704	OP_ShrUint32IntAPS,
48705	OP_ShrSint64Sint8,
48706	OP_ShrSint64Uint8,
48707	OP_ShrSint64Sint16,
48708	OP_ShrSint64Uint16,
48709	OP_ShrSint64Sint32,
48710	OP_ShrSint64Uint32,
48711	OP_ShrSint64Sint64,
48712	OP_ShrSint64Uint64,
48713	OP_ShrSint64IntAP,
48714	OP_ShrSint64IntAPS,
48715	OP_ShrUint64Sint8,
48716	OP_ShrUint64Uint8,
48717	OP_ShrUint64Sint16,
48718	OP_ShrUint64Uint16,
48719	OP_ShrUint64Sint32,
48720	OP_ShrUint64Uint32,
48721	OP_ShrUint64Sint64,
48722	OP_ShrUint64Uint64,
48723	OP_ShrUint64IntAP,
48724	OP_ShrUint64IntAPS,
48725	OP_ShrIntAPSint8,
48726	OP_ShrIntAPUint8,
48727	OP_ShrIntAPSint16,
48728	OP_ShrIntAPUint16,
48729	OP_ShrIntAPSint32,
48730	OP_ShrIntAPUint32,
48731	OP_ShrIntAPSint64,
48732	OP_ShrIntAPUint64,
48733	OP_ShrIntAPIntAP,
48734	OP_ShrIntAPIntAPS,
48735	OP_ShrIntAPSSint8,
48736	OP_ShrIntAPSUint8,
48737	OP_ShrIntAPSSint16,
48738	OP_ShrIntAPSUint16,
48739	OP_ShrIntAPSSint32,
48740	OP_ShrIntAPSUint32,
48741	OP_ShrIntAPSSint64,
48742	OP_ShrIntAPSUint64,
48743	OP_ShrIntAPSIntAP,
48744	OP_ShrIntAPSIntAPS,
48745	#endif
48746	#ifdef GET_INTERPFN_LIST
48747	&Interp_ShrSint8Sint8,
48748	&Interp_ShrSint8Uint8,
48749	&Interp_ShrSint8Sint16,
48750	&Interp_ShrSint8Uint16,
48751	&Interp_ShrSint8Sint32,
48752	&Interp_ShrSint8Uint32,
48753	&Interp_ShrSint8Sint64,
48754	&Interp_ShrSint8Uint64,
48755	&Interp_ShrSint8IntAP,
48756	&Interp_ShrSint8IntAPS,
48757	&Interp_ShrUint8Sint8,
48758	&Interp_ShrUint8Uint8,
48759	&Interp_ShrUint8Sint16,
48760	&Interp_ShrUint8Uint16,
48761	&Interp_ShrUint8Sint32,
48762	&Interp_ShrUint8Uint32,
48763	&Interp_ShrUint8Sint64,
48764	&Interp_ShrUint8Uint64,
48765	&Interp_ShrUint8IntAP,
48766	&Interp_ShrUint8IntAPS,
48767	&Interp_ShrSint16Sint8,
48768	&Interp_ShrSint16Uint8,
48769	&Interp_ShrSint16Sint16,
48770	&Interp_ShrSint16Uint16,
48771	&Interp_ShrSint16Sint32,
48772	&Interp_ShrSint16Uint32,
48773	&Interp_ShrSint16Sint64,
48774	&Interp_ShrSint16Uint64,
48775	&Interp_ShrSint16IntAP,
48776	&Interp_ShrSint16IntAPS,
48777	&Interp_ShrUint16Sint8,
48778	&Interp_ShrUint16Uint8,
48779	&Interp_ShrUint16Sint16,
48780	&Interp_ShrUint16Uint16,
48781	&Interp_ShrUint16Sint32,
48782	&Interp_ShrUint16Uint32,
48783	&Interp_ShrUint16Sint64,
48784	&Interp_ShrUint16Uint64,
48785	&Interp_ShrUint16IntAP,
48786	&Interp_ShrUint16IntAPS,
48787	&Interp_ShrSint32Sint8,
48788	&Interp_ShrSint32Uint8,
48789	&Interp_ShrSint32Sint16,
48790	&Interp_ShrSint32Uint16,
48791	&Interp_ShrSint32Sint32,
48792	&Interp_ShrSint32Uint32,
48793	&Interp_ShrSint32Sint64,
48794	&Interp_ShrSint32Uint64,
48795	&Interp_ShrSint32IntAP,
48796	&Interp_ShrSint32IntAPS,
48797	&Interp_ShrUint32Sint8,
48798	&Interp_ShrUint32Uint8,
48799	&Interp_ShrUint32Sint16,
48800	&Interp_ShrUint32Uint16,
48801	&Interp_ShrUint32Sint32,
48802	&Interp_ShrUint32Uint32,
48803	&Interp_ShrUint32Sint64,
48804	&Interp_ShrUint32Uint64,
48805	&Interp_ShrUint32IntAP,
48806	&Interp_ShrUint32IntAPS,
48807	&Interp_ShrSint64Sint8,
48808	&Interp_ShrSint64Uint8,
48809	&Interp_ShrSint64Sint16,
48810	&Interp_ShrSint64Uint16,
48811	&Interp_ShrSint64Sint32,
48812	&Interp_ShrSint64Uint32,
48813	&Interp_ShrSint64Sint64,
48814	&Interp_ShrSint64Uint64,
48815	&Interp_ShrSint64IntAP,
48816	&Interp_ShrSint64IntAPS,
48817	&Interp_ShrUint64Sint8,
48818	&Interp_ShrUint64Uint8,
48819	&Interp_ShrUint64Sint16,
48820	&Interp_ShrUint64Uint16,
48821	&Interp_ShrUint64Sint32,
48822	&Interp_ShrUint64Uint32,
48823	&Interp_ShrUint64Sint64,
48824	&Interp_ShrUint64Uint64,
48825	&Interp_ShrUint64IntAP,
48826	&Interp_ShrUint64IntAPS,
48827	&Interp_ShrIntAPSint8,
48828	&Interp_ShrIntAPUint8,
48829	&Interp_ShrIntAPSint16,
48830	&Interp_ShrIntAPUint16,
48831	&Interp_ShrIntAPSint32,
48832	&Interp_ShrIntAPUint32,
48833	&Interp_ShrIntAPSint64,
48834	&Interp_ShrIntAPUint64,
48835	&Interp_ShrIntAPIntAP,
48836	&Interp_ShrIntAPIntAPS,
48837	&Interp_ShrIntAPSSint8,
48838	&Interp_ShrIntAPSUint8,
48839	&Interp_ShrIntAPSSint16,
48840	&Interp_ShrIntAPSUint16,
48841	&Interp_ShrIntAPSSint32,
48842	&Interp_ShrIntAPSUint32,
48843	&Interp_ShrIntAPSSint64,
48844	&Interp_ShrIntAPSUint64,
48845	&Interp_ShrIntAPSIntAP,
48846	&Interp_ShrIntAPSIntAPS,
48847	#endif
48848	#ifdef GET_INTERPFN_DISPATCHERS
48849	PRESERVE_NONE
48850	static bool Interp_ShrSint8Sint8(InterpState &S) {
48851	if (!Shr<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
48852	#if USE_TAILCALLS
48853	MUSTTAIL return InterpNext(S);
48854	#else
48855	return true;
48856	#endif
48857	}
48858	PRESERVE_NONE
48859	static bool Interp_ShrSint8Uint8(InterpState &S) {
48860	if (!Shr<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
48861	#if USE_TAILCALLS
48862	MUSTTAIL return InterpNext(S);
48863	#else
48864	return true;
48865	#endif
48866	}
48867	PRESERVE_NONE
48868	static bool Interp_ShrSint8Sint16(InterpState &S) {
48869	if (!Shr<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
48870	#if USE_TAILCALLS
48871	MUSTTAIL return InterpNext(S);
48872	#else
48873	return true;
48874	#endif
48875	}
48876	PRESERVE_NONE
48877	static bool Interp_ShrSint8Uint16(InterpState &S) {
48878	if (!Shr<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
48879	#if USE_TAILCALLS
48880	MUSTTAIL return InterpNext(S);
48881	#else
48882	return true;
48883	#endif
48884	}
48885	PRESERVE_NONE
48886	static bool Interp_ShrSint8Sint32(InterpState &S) {
48887	if (!Shr<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
48888	#if USE_TAILCALLS
48889	MUSTTAIL return InterpNext(S);
48890	#else
48891	return true;
48892	#endif
48893	}
48894	PRESERVE_NONE
48895	static bool Interp_ShrSint8Uint32(InterpState &S) {
48896	if (!Shr<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
48897	#if USE_TAILCALLS
48898	MUSTTAIL return InterpNext(S);
48899	#else
48900	return true;
48901	#endif
48902	}
48903	PRESERVE_NONE
48904	static bool Interp_ShrSint8Sint64(InterpState &S) {
48905	if (!Shr<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
48906	#if USE_TAILCALLS
48907	MUSTTAIL return InterpNext(S);
48908	#else
48909	return true;
48910	#endif
48911	}
48912	PRESERVE_NONE
48913	static bool Interp_ShrSint8Uint64(InterpState &S) {
48914	if (!Shr<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
48915	#if USE_TAILCALLS
48916	MUSTTAIL return InterpNext(S);
48917	#else
48918	return true;
48919	#endif
48920	}
48921	PRESERVE_NONE
48922	static bool Interp_ShrSint8IntAP(InterpState &S) {
48923	if (!Shr<PT_Sint8, PT_IntAP>(S, S.PC)) return false;
48924	#if USE_TAILCALLS
48925	MUSTTAIL return InterpNext(S);
48926	#else
48927	return true;
48928	#endif
48929	}
48930	PRESERVE_NONE
48931	static bool Interp_ShrSint8IntAPS(InterpState &S) {
48932	if (!Shr<PT_Sint8, PT_IntAPS>(S, S.PC)) return false;
48933	#if USE_TAILCALLS
48934	MUSTTAIL return InterpNext(S);
48935	#else
48936	return true;
48937	#endif
48938	}
48939	PRESERVE_NONE
48940	static bool Interp_ShrUint8Sint8(InterpState &S) {
48941	if (!Shr<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
48942	#if USE_TAILCALLS
48943	MUSTTAIL return InterpNext(S);
48944	#else
48945	return true;
48946	#endif
48947	}
48948	PRESERVE_NONE
48949	static bool Interp_ShrUint8Uint8(InterpState &S) {
48950	if (!Shr<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
48951	#if USE_TAILCALLS
48952	MUSTTAIL return InterpNext(S);
48953	#else
48954	return true;
48955	#endif
48956	}
48957	PRESERVE_NONE
48958	static bool Interp_ShrUint8Sint16(InterpState &S) {
48959	if (!Shr<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
48960	#if USE_TAILCALLS
48961	MUSTTAIL return InterpNext(S);
48962	#else
48963	return true;
48964	#endif
48965	}
48966	PRESERVE_NONE
48967	static bool Interp_ShrUint8Uint16(InterpState &S) {
48968	if (!Shr<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
48969	#if USE_TAILCALLS
48970	MUSTTAIL return InterpNext(S);
48971	#else
48972	return true;
48973	#endif
48974	}
48975	PRESERVE_NONE
48976	static bool Interp_ShrUint8Sint32(InterpState &S) {
48977	if (!Shr<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
48978	#if USE_TAILCALLS
48979	MUSTTAIL return InterpNext(S);
48980	#else
48981	return true;
48982	#endif
48983	}
48984	PRESERVE_NONE
48985	static bool Interp_ShrUint8Uint32(InterpState &S) {
48986	if (!Shr<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
48987	#if USE_TAILCALLS
48988	MUSTTAIL return InterpNext(S);
48989	#else
48990	return true;
48991	#endif
48992	}
48993	PRESERVE_NONE
48994	static bool Interp_ShrUint8Sint64(InterpState &S) {
48995	if (!Shr<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
48996	#if USE_TAILCALLS
48997	MUSTTAIL return InterpNext(S);
48998	#else
48999	return true;
49000	#endif
49001	}
49002	PRESERVE_NONE
49003	static bool Interp_ShrUint8Uint64(InterpState &S) {
49004	if (!Shr<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
49005	#if USE_TAILCALLS
49006	MUSTTAIL return InterpNext(S);
49007	#else
49008	return true;
49009	#endif
49010	}
49011	PRESERVE_NONE
49012	static bool Interp_ShrUint8IntAP(InterpState &S) {
49013	if (!Shr<PT_Uint8, PT_IntAP>(S, S.PC)) return false;
49014	#if USE_TAILCALLS
49015	MUSTTAIL return InterpNext(S);
49016	#else
49017	return true;
49018	#endif
49019	}
49020	PRESERVE_NONE
49021	static bool Interp_ShrUint8IntAPS(InterpState &S) {
49022	if (!Shr<PT_Uint8, PT_IntAPS>(S, S.PC)) return false;
49023	#if USE_TAILCALLS
49024	MUSTTAIL return InterpNext(S);
49025	#else
49026	return true;
49027	#endif
49028	}
49029	PRESERVE_NONE
49030	static bool Interp_ShrSint16Sint8(InterpState &S) {
49031	if (!Shr<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
49032	#if USE_TAILCALLS
49033	MUSTTAIL return InterpNext(S);
49034	#else
49035	return true;
49036	#endif
49037	}
49038	PRESERVE_NONE
49039	static bool Interp_ShrSint16Uint8(InterpState &S) {
49040	if (!Shr<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
49041	#if USE_TAILCALLS
49042	MUSTTAIL return InterpNext(S);
49043	#else
49044	return true;
49045	#endif
49046	}
49047	PRESERVE_NONE
49048	static bool Interp_ShrSint16Sint16(InterpState &S) {
49049	if (!Shr<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
49050	#if USE_TAILCALLS
49051	MUSTTAIL return InterpNext(S);
49052	#else
49053	return true;
49054	#endif
49055	}
49056	PRESERVE_NONE
49057	static bool Interp_ShrSint16Uint16(InterpState &S) {
49058	if (!Shr<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
49059	#if USE_TAILCALLS
49060	MUSTTAIL return InterpNext(S);
49061	#else
49062	return true;
49063	#endif
49064	}
49065	PRESERVE_NONE
49066	static bool Interp_ShrSint16Sint32(InterpState &S) {
49067	if (!Shr<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
49068	#if USE_TAILCALLS
49069	MUSTTAIL return InterpNext(S);
49070	#else
49071	return true;
49072	#endif
49073	}
49074	PRESERVE_NONE
49075	static bool Interp_ShrSint16Uint32(InterpState &S) {
49076	if (!Shr<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
49077	#if USE_TAILCALLS
49078	MUSTTAIL return InterpNext(S);
49079	#else
49080	return true;
49081	#endif
49082	}
49083	PRESERVE_NONE
49084	static bool Interp_ShrSint16Sint64(InterpState &S) {
49085	if (!Shr<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
49086	#if USE_TAILCALLS
49087	MUSTTAIL return InterpNext(S);
49088	#else
49089	return true;
49090	#endif
49091	}
49092	PRESERVE_NONE
49093	static bool Interp_ShrSint16Uint64(InterpState &S) {
49094	if (!Shr<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
49095	#if USE_TAILCALLS
49096	MUSTTAIL return InterpNext(S);
49097	#else
49098	return true;
49099	#endif
49100	}
49101	PRESERVE_NONE
49102	static bool Interp_ShrSint16IntAP(InterpState &S) {
49103	if (!Shr<PT_Sint16, PT_IntAP>(S, S.PC)) return false;
49104	#if USE_TAILCALLS
49105	MUSTTAIL return InterpNext(S);
49106	#else
49107	return true;
49108	#endif
49109	}
49110	PRESERVE_NONE
49111	static bool Interp_ShrSint16IntAPS(InterpState &S) {
49112	if (!Shr<PT_Sint16, PT_IntAPS>(S, S.PC)) return false;
49113	#if USE_TAILCALLS
49114	MUSTTAIL return InterpNext(S);
49115	#else
49116	return true;
49117	#endif
49118	}
49119	PRESERVE_NONE
49120	static bool Interp_ShrUint16Sint8(InterpState &S) {
49121	if (!Shr<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
49122	#if USE_TAILCALLS
49123	MUSTTAIL return InterpNext(S);
49124	#else
49125	return true;
49126	#endif
49127	}
49128	PRESERVE_NONE
49129	static bool Interp_ShrUint16Uint8(InterpState &S) {
49130	if (!Shr<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
49131	#if USE_TAILCALLS
49132	MUSTTAIL return InterpNext(S);
49133	#else
49134	return true;
49135	#endif
49136	}
49137	PRESERVE_NONE
49138	static bool Interp_ShrUint16Sint16(InterpState &S) {
49139	if (!Shr<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
49140	#if USE_TAILCALLS
49141	MUSTTAIL return InterpNext(S);
49142	#else
49143	return true;
49144	#endif
49145	}
49146	PRESERVE_NONE
49147	static bool Interp_ShrUint16Uint16(InterpState &S) {
49148	if (!Shr<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
49149	#if USE_TAILCALLS
49150	MUSTTAIL return InterpNext(S);
49151	#else
49152	return true;
49153	#endif
49154	}
49155	PRESERVE_NONE
49156	static bool Interp_ShrUint16Sint32(InterpState &S) {
49157	if (!Shr<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
49158	#if USE_TAILCALLS
49159	MUSTTAIL return InterpNext(S);
49160	#else
49161	return true;
49162	#endif
49163	}
49164	PRESERVE_NONE
49165	static bool Interp_ShrUint16Uint32(InterpState &S) {
49166	if (!Shr<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
49167	#if USE_TAILCALLS
49168	MUSTTAIL return InterpNext(S);
49169	#else
49170	return true;
49171	#endif
49172	}
49173	PRESERVE_NONE
49174	static bool Interp_ShrUint16Sint64(InterpState &S) {
49175	if (!Shr<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
49176	#if USE_TAILCALLS
49177	MUSTTAIL return InterpNext(S);
49178	#else
49179	return true;
49180	#endif
49181	}
49182	PRESERVE_NONE
49183	static bool Interp_ShrUint16Uint64(InterpState &S) {
49184	if (!Shr<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
49185	#if USE_TAILCALLS
49186	MUSTTAIL return InterpNext(S);
49187	#else
49188	return true;
49189	#endif
49190	}
49191	PRESERVE_NONE
49192	static bool Interp_ShrUint16IntAP(InterpState &S) {
49193	if (!Shr<PT_Uint16, PT_IntAP>(S, S.PC)) return false;
49194	#if USE_TAILCALLS
49195	MUSTTAIL return InterpNext(S);
49196	#else
49197	return true;
49198	#endif
49199	}
49200	PRESERVE_NONE
49201	static bool Interp_ShrUint16IntAPS(InterpState &S) {
49202	if (!Shr<PT_Uint16, PT_IntAPS>(S, S.PC)) return false;
49203	#if USE_TAILCALLS
49204	MUSTTAIL return InterpNext(S);
49205	#else
49206	return true;
49207	#endif
49208	}
49209	PRESERVE_NONE
49210	static bool Interp_ShrSint32Sint8(InterpState &S) {
49211	if (!Shr<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
49212	#if USE_TAILCALLS
49213	MUSTTAIL return InterpNext(S);
49214	#else
49215	return true;
49216	#endif
49217	}
49218	PRESERVE_NONE
49219	static bool Interp_ShrSint32Uint8(InterpState &S) {
49220	if (!Shr<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
49221	#if USE_TAILCALLS
49222	MUSTTAIL return InterpNext(S);
49223	#else
49224	return true;
49225	#endif
49226	}
49227	PRESERVE_NONE
49228	static bool Interp_ShrSint32Sint16(InterpState &S) {
49229	if (!Shr<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
49230	#if USE_TAILCALLS
49231	MUSTTAIL return InterpNext(S);
49232	#else
49233	return true;
49234	#endif
49235	}
49236	PRESERVE_NONE
49237	static bool Interp_ShrSint32Uint16(InterpState &S) {
49238	if (!Shr<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
49239	#if USE_TAILCALLS
49240	MUSTTAIL return InterpNext(S);
49241	#else
49242	return true;
49243	#endif
49244	}
49245	PRESERVE_NONE
49246	static bool Interp_ShrSint32Sint32(InterpState &S) {
49247	if (!Shr<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
49248	#if USE_TAILCALLS
49249	MUSTTAIL return InterpNext(S);
49250	#else
49251	return true;
49252	#endif
49253	}
49254	PRESERVE_NONE
49255	static bool Interp_ShrSint32Uint32(InterpState &S) {
49256	if (!Shr<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
49257	#if USE_TAILCALLS
49258	MUSTTAIL return InterpNext(S);
49259	#else
49260	return true;
49261	#endif
49262	}
49263	PRESERVE_NONE
49264	static bool Interp_ShrSint32Sint64(InterpState &S) {
49265	if (!Shr<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
49266	#if USE_TAILCALLS
49267	MUSTTAIL return InterpNext(S);
49268	#else
49269	return true;
49270	#endif
49271	}
49272	PRESERVE_NONE
49273	static bool Interp_ShrSint32Uint64(InterpState &S) {
49274	if (!Shr<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
49275	#if USE_TAILCALLS
49276	MUSTTAIL return InterpNext(S);
49277	#else
49278	return true;
49279	#endif
49280	}
49281	PRESERVE_NONE
49282	static bool Interp_ShrSint32IntAP(InterpState &S) {
49283	if (!Shr<PT_Sint32, PT_IntAP>(S, S.PC)) return false;
49284	#if USE_TAILCALLS
49285	MUSTTAIL return InterpNext(S);
49286	#else
49287	return true;
49288	#endif
49289	}
49290	PRESERVE_NONE
49291	static bool Interp_ShrSint32IntAPS(InterpState &S) {
49292	if (!Shr<PT_Sint32, PT_IntAPS>(S, S.PC)) return false;
49293	#if USE_TAILCALLS
49294	MUSTTAIL return InterpNext(S);
49295	#else
49296	return true;
49297	#endif
49298	}
49299	PRESERVE_NONE
49300	static bool Interp_ShrUint32Sint8(InterpState &S) {
49301	if (!Shr<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
49302	#if USE_TAILCALLS
49303	MUSTTAIL return InterpNext(S);
49304	#else
49305	return true;
49306	#endif
49307	}
49308	PRESERVE_NONE
49309	static bool Interp_ShrUint32Uint8(InterpState &S) {
49310	if (!Shr<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
49311	#if USE_TAILCALLS
49312	MUSTTAIL return InterpNext(S);
49313	#else
49314	return true;
49315	#endif
49316	}
49317	PRESERVE_NONE
49318	static bool Interp_ShrUint32Sint16(InterpState &S) {
49319	if (!Shr<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
49320	#if USE_TAILCALLS
49321	MUSTTAIL return InterpNext(S);
49322	#else
49323	return true;
49324	#endif
49325	}
49326	PRESERVE_NONE
49327	static bool Interp_ShrUint32Uint16(InterpState &S) {
49328	if (!Shr<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
49329	#if USE_TAILCALLS
49330	MUSTTAIL return InterpNext(S);
49331	#else
49332	return true;
49333	#endif
49334	}
49335	PRESERVE_NONE
49336	static bool Interp_ShrUint32Sint32(InterpState &S) {
49337	if (!Shr<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
49338	#if USE_TAILCALLS
49339	MUSTTAIL return InterpNext(S);
49340	#else
49341	return true;
49342	#endif
49343	}
49344	PRESERVE_NONE
49345	static bool Interp_ShrUint32Uint32(InterpState &S) {
49346	if (!Shr<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
49347	#if USE_TAILCALLS
49348	MUSTTAIL return InterpNext(S);
49349	#else
49350	return true;
49351	#endif
49352	}
49353	PRESERVE_NONE
49354	static bool Interp_ShrUint32Sint64(InterpState &S) {
49355	if (!Shr<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
49356	#if USE_TAILCALLS
49357	MUSTTAIL return InterpNext(S);
49358	#else
49359	return true;
49360	#endif
49361	}
49362	PRESERVE_NONE
49363	static bool Interp_ShrUint32Uint64(InterpState &S) {
49364	if (!Shr<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
49365	#if USE_TAILCALLS
49366	MUSTTAIL return InterpNext(S);
49367	#else
49368	return true;
49369	#endif
49370	}
49371	PRESERVE_NONE
49372	static bool Interp_ShrUint32IntAP(InterpState &S) {
49373	if (!Shr<PT_Uint32, PT_IntAP>(S, S.PC)) return false;
49374	#if USE_TAILCALLS
49375	MUSTTAIL return InterpNext(S);
49376	#else
49377	return true;
49378	#endif
49379	}
49380	PRESERVE_NONE
49381	static bool Interp_ShrUint32IntAPS(InterpState &S) {
49382	if (!Shr<PT_Uint32, PT_IntAPS>(S, S.PC)) return false;
49383	#if USE_TAILCALLS
49384	MUSTTAIL return InterpNext(S);
49385	#else
49386	return true;
49387	#endif
49388	}
49389	PRESERVE_NONE
49390	static bool Interp_ShrSint64Sint8(InterpState &S) {
49391	if (!Shr<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
49392	#if USE_TAILCALLS
49393	MUSTTAIL return InterpNext(S);
49394	#else
49395	return true;
49396	#endif
49397	}
49398	PRESERVE_NONE
49399	static bool Interp_ShrSint64Uint8(InterpState &S) {
49400	if (!Shr<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
49401	#if USE_TAILCALLS
49402	MUSTTAIL return InterpNext(S);
49403	#else
49404	return true;
49405	#endif
49406	}
49407	PRESERVE_NONE
49408	static bool Interp_ShrSint64Sint16(InterpState &S) {
49409	if (!Shr<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
49410	#if USE_TAILCALLS
49411	MUSTTAIL return InterpNext(S);
49412	#else
49413	return true;
49414	#endif
49415	}
49416	PRESERVE_NONE
49417	static bool Interp_ShrSint64Uint16(InterpState &S) {
49418	if (!Shr<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
49419	#if USE_TAILCALLS
49420	MUSTTAIL return InterpNext(S);
49421	#else
49422	return true;
49423	#endif
49424	}
49425	PRESERVE_NONE
49426	static bool Interp_ShrSint64Sint32(InterpState &S) {
49427	if (!Shr<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
49428	#if USE_TAILCALLS
49429	MUSTTAIL return InterpNext(S);
49430	#else
49431	return true;
49432	#endif
49433	}
49434	PRESERVE_NONE
49435	static bool Interp_ShrSint64Uint32(InterpState &S) {
49436	if (!Shr<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
49437	#if USE_TAILCALLS
49438	MUSTTAIL return InterpNext(S);
49439	#else
49440	return true;
49441	#endif
49442	}
49443	PRESERVE_NONE
49444	static bool Interp_ShrSint64Sint64(InterpState &S) {
49445	if (!Shr<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
49446	#if USE_TAILCALLS
49447	MUSTTAIL return InterpNext(S);
49448	#else
49449	return true;
49450	#endif
49451	}
49452	PRESERVE_NONE
49453	static bool Interp_ShrSint64Uint64(InterpState &S) {
49454	if (!Shr<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
49455	#if USE_TAILCALLS
49456	MUSTTAIL return InterpNext(S);
49457	#else
49458	return true;
49459	#endif
49460	}
49461	PRESERVE_NONE
49462	static bool Interp_ShrSint64IntAP(InterpState &S) {
49463	if (!Shr<PT_Sint64, PT_IntAP>(S, S.PC)) return false;
49464	#if USE_TAILCALLS
49465	MUSTTAIL return InterpNext(S);
49466	#else
49467	return true;
49468	#endif
49469	}
49470	PRESERVE_NONE
49471	static bool Interp_ShrSint64IntAPS(InterpState &S) {
49472	if (!Shr<PT_Sint64, PT_IntAPS>(S, S.PC)) return false;
49473	#if USE_TAILCALLS
49474	MUSTTAIL return InterpNext(S);
49475	#else
49476	return true;
49477	#endif
49478	}
49479	PRESERVE_NONE
49480	static bool Interp_ShrUint64Sint8(InterpState &S) {
49481	if (!Shr<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
49482	#if USE_TAILCALLS
49483	MUSTTAIL return InterpNext(S);
49484	#else
49485	return true;
49486	#endif
49487	}
49488	PRESERVE_NONE
49489	static bool Interp_ShrUint64Uint8(InterpState &S) {
49490	if (!Shr<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
49491	#if USE_TAILCALLS
49492	MUSTTAIL return InterpNext(S);
49493	#else
49494	return true;
49495	#endif
49496	}
49497	PRESERVE_NONE
49498	static bool Interp_ShrUint64Sint16(InterpState &S) {
49499	if (!Shr<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
49500	#if USE_TAILCALLS
49501	MUSTTAIL return InterpNext(S);
49502	#else
49503	return true;
49504	#endif
49505	}
49506	PRESERVE_NONE
49507	static bool Interp_ShrUint64Uint16(InterpState &S) {
49508	if (!Shr<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
49509	#if USE_TAILCALLS
49510	MUSTTAIL return InterpNext(S);
49511	#else
49512	return true;
49513	#endif
49514	}
49515	PRESERVE_NONE
49516	static bool Interp_ShrUint64Sint32(InterpState &S) {
49517	if (!Shr<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
49518	#if USE_TAILCALLS
49519	MUSTTAIL return InterpNext(S);
49520	#else
49521	return true;
49522	#endif
49523	}
49524	PRESERVE_NONE
49525	static bool Interp_ShrUint64Uint32(InterpState &S) {
49526	if (!Shr<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
49527	#if USE_TAILCALLS
49528	MUSTTAIL return InterpNext(S);
49529	#else
49530	return true;
49531	#endif
49532	}
49533	PRESERVE_NONE
49534	static bool Interp_ShrUint64Sint64(InterpState &S) {
49535	if (!Shr<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
49536	#if USE_TAILCALLS
49537	MUSTTAIL return InterpNext(S);
49538	#else
49539	return true;
49540	#endif
49541	}
49542	PRESERVE_NONE
49543	static bool Interp_ShrUint64Uint64(InterpState &S) {
49544	if (!Shr<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
49545	#if USE_TAILCALLS
49546	MUSTTAIL return InterpNext(S);
49547	#else
49548	return true;
49549	#endif
49550	}
49551	PRESERVE_NONE
49552	static bool Interp_ShrUint64IntAP(InterpState &S) {
49553	if (!Shr<PT_Uint64, PT_IntAP>(S, S.PC)) return false;
49554	#if USE_TAILCALLS
49555	MUSTTAIL return InterpNext(S);
49556	#else
49557	return true;
49558	#endif
49559	}
49560	PRESERVE_NONE
49561	static bool Interp_ShrUint64IntAPS(InterpState &S) {
49562	if (!Shr<PT_Uint64, PT_IntAPS>(S, S.PC)) return false;
49563	#if USE_TAILCALLS
49564	MUSTTAIL return InterpNext(S);
49565	#else
49566	return true;
49567	#endif
49568	}
49569	PRESERVE_NONE
49570	static bool Interp_ShrIntAPSint8(InterpState &S) {
49571	if (!Shr<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
49572	#if USE_TAILCALLS
49573	MUSTTAIL return InterpNext(S);
49574	#else
49575	return true;
49576	#endif
49577	}
49578	PRESERVE_NONE
49579	static bool Interp_ShrIntAPUint8(InterpState &S) {
49580	if (!Shr<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
49581	#if USE_TAILCALLS
49582	MUSTTAIL return InterpNext(S);
49583	#else
49584	return true;
49585	#endif
49586	}
49587	PRESERVE_NONE
49588	static bool Interp_ShrIntAPSint16(InterpState &S) {
49589	if (!Shr<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
49590	#if USE_TAILCALLS
49591	MUSTTAIL return InterpNext(S);
49592	#else
49593	return true;
49594	#endif
49595	}
49596	PRESERVE_NONE
49597	static bool Interp_ShrIntAPUint16(InterpState &S) {
49598	if (!Shr<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
49599	#if USE_TAILCALLS
49600	MUSTTAIL return InterpNext(S);
49601	#else
49602	return true;
49603	#endif
49604	}
49605	PRESERVE_NONE
49606	static bool Interp_ShrIntAPSint32(InterpState &S) {
49607	if (!Shr<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
49608	#if USE_TAILCALLS
49609	MUSTTAIL return InterpNext(S);
49610	#else
49611	return true;
49612	#endif
49613	}
49614	PRESERVE_NONE
49615	static bool Interp_ShrIntAPUint32(InterpState &S) {
49616	if (!Shr<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
49617	#if USE_TAILCALLS
49618	MUSTTAIL return InterpNext(S);
49619	#else
49620	return true;
49621	#endif
49622	}
49623	PRESERVE_NONE
49624	static bool Interp_ShrIntAPSint64(InterpState &S) {
49625	if (!Shr<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
49626	#if USE_TAILCALLS
49627	MUSTTAIL return InterpNext(S);
49628	#else
49629	return true;
49630	#endif
49631	}
49632	PRESERVE_NONE
49633	static bool Interp_ShrIntAPUint64(InterpState &S) {
49634	if (!Shr<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
49635	#if USE_TAILCALLS
49636	MUSTTAIL return InterpNext(S);
49637	#else
49638	return true;
49639	#endif
49640	}
49641	PRESERVE_NONE
49642	static bool Interp_ShrIntAPIntAP(InterpState &S) {
49643	if (!Shr<PT_IntAP, PT_IntAP>(S, S.PC)) return false;
49644	#if USE_TAILCALLS
49645	MUSTTAIL return InterpNext(S);
49646	#else
49647	return true;
49648	#endif
49649	}
49650	PRESERVE_NONE
49651	static bool Interp_ShrIntAPIntAPS(InterpState &S) {
49652	if (!Shr<PT_IntAP, PT_IntAPS>(S, S.PC)) return false;
49653	#if USE_TAILCALLS
49654	MUSTTAIL return InterpNext(S);
49655	#else
49656	return true;
49657	#endif
49658	}
49659	PRESERVE_NONE
49660	static bool Interp_ShrIntAPSSint8(InterpState &S) {
49661	if (!Shr<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
49662	#if USE_TAILCALLS
49663	MUSTTAIL return InterpNext(S);
49664	#else
49665	return true;
49666	#endif
49667	}
49668	PRESERVE_NONE
49669	static bool Interp_ShrIntAPSUint8(InterpState &S) {
49670	if (!Shr<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
49671	#if USE_TAILCALLS
49672	MUSTTAIL return InterpNext(S);
49673	#else
49674	return true;
49675	#endif
49676	}
49677	PRESERVE_NONE
49678	static bool Interp_ShrIntAPSSint16(InterpState &S) {
49679	if (!Shr<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
49680	#if USE_TAILCALLS
49681	MUSTTAIL return InterpNext(S);
49682	#else
49683	return true;
49684	#endif
49685	}
49686	PRESERVE_NONE
49687	static bool Interp_ShrIntAPSUint16(InterpState &S) {
49688	if (!Shr<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
49689	#if USE_TAILCALLS
49690	MUSTTAIL return InterpNext(S);
49691	#else
49692	return true;
49693	#endif
49694	}
49695	PRESERVE_NONE
49696	static bool Interp_ShrIntAPSSint32(InterpState &S) {
49697	if (!Shr<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
49698	#if USE_TAILCALLS
49699	MUSTTAIL return InterpNext(S);
49700	#else
49701	return true;
49702	#endif
49703	}
49704	PRESERVE_NONE
49705	static bool Interp_ShrIntAPSUint32(InterpState &S) {
49706	if (!Shr<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
49707	#if USE_TAILCALLS
49708	MUSTTAIL return InterpNext(S);
49709	#else
49710	return true;
49711	#endif
49712	}
49713	PRESERVE_NONE
49714	static bool Interp_ShrIntAPSSint64(InterpState &S) {
49715	if (!Shr<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
49716	#if USE_TAILCALLS
49717	MUSTTAIL return InterpNext(S);
49718	#else
49719	return true;
49720	#endif
49721	}
49722	PRESERVE_NONE
49723	static bool Interp_ShrIntAPSUint64(InterpState &S) {
49724	if (!Shr<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
49725	#if USE_TAILCALLS
49726	MUSTTAIL return InterpNext(S);
49727	#else
49728	return true;
49729	#endif
49730	}
49731	PRESERVE_NONE
49732	static bool Interp_ShrIntAPSIntAP(InterpState &S) {
49733	if (!Shr<PT_IntAPS, PT_IntAP>(S, S.PC)) return false;
49734	#if USE_TAILCALLS
49735	MUSTTAIL return InterpNext(S);
49736	#else
49737	return true;
49738	#endif
49739	}
49740	PRESERVE_NONE
49741	static bool Interp_ShrIntAPSIntAPS(InterpState &S) {
49742	if (!Shr<PT_IntAPS, PT_IntAPS>(S, S.PC)) return false;
49743	#if USE_TAILCALLS
49744	MUSTTAIL return InterpNext(S);
49745	#else
49746	return true;
49747	#endif
49748	}
49749	#endif
49750	#ifdef GET_DISASM
49751	case OP_ShrSint8Sint8:
49752	Text.Op = PrintName("ShrSint8Sint8");
49753	break;
49754	case OP_ShrSint8Uint8:
49755	Text.Op = PrintName("ShrSint8Uint8");
49756	break;
49757	case OP_ShrSint8Sint16:
49758	Text.Op = PrintName("ShrSint8Sint16");
49759	break;
49760	case OP_ShrSint8Uint16:
49761	Text.Op = PrintName("ShrSint8Uint16");
49762	break;
49763	case OP_ShrSint8Sint32:
49764	Text.Op = PrintName("ShrSint8Sint32");
49765	break;
49766	case OP_ShrSint8Uint32:
49767	Text.Op = PrintName("ShrSint8Uint32");
49768	break;
49769	case OP_ShrSint8Sint64:
49770	Text.Op = PrintName("ShrSint8Sint64");
49771	break;
49772	case OP_ShrSint8Uint64:
49773	Text.Op = PrintName("ShrSint8Uint64");
49774	break;
49775	case OP_ShrSint8IntAP:
49776	Text.Op = PrintName("ShrSint8IntAP");
49777	break;
49778	case OP_ShrSint8IntAPS:
49779	Text.Op = PrintName("ShrSint8IntAPS");
49780	break;
49781	case OP_ShrUint8Sint8:
49782	Text.Op = PrintName("ShrUint8Sint8");
49783	break;
49784	case OP_ShrUint8Uint8:
49785	Text.Op = PrintName("ShrUint8Uint8");
49786	break;
49787	case OP_ShrUint8Sint16:
49788	Text.Op = PrintName("ShrUint8Sint16");
49789	break;
49790	case OP_ShrUint8Uint16:
49791	Text.Op = PrintName("ShrUint8Uint16");
49792	break;
49793	case OP_ShrUint8Sint32:
49794	Text.Op = PrintName("ShrUint8Sint32");
49795	break;
49796	case OP_ShrUint8Uint32:
49797	Text.Op = PrintName("ShrUint8Uint32");
49798	break;
49799	case OP_ShrUint8Sint64:
49800	Text.Op = PrintName("ShrUint8Sint64");
49801	break;
49802	case OP_ShrUint8Uint64:
49803	Text.Op = PrintName("ShrUint8Uint64");
49804	break;
49805	case OP_ShrUint8IntAP:
49806	Text.Op = PrintName("ShrUint8IntAP");
49807	break;
49808	case OP_ShrUint8IntAPS:
49809	Text.Op = PrintName("ShrUint8IntAPS");
49810	break;
49811	case OP_ShrSint16Sint8:
49812	Text.Op = PrintName("ShrSint16Sint8");
49813	break;
49814	case OP_ShrSint16Uint8:
49815	Text.Op = PrintName("ShrSint16Uint8");
49816	break;
49817	case OP_ShrSint16Sint16:
49818	Text.Op = PrintName("ShrSint16Sint16");
49819	break;
49820	case OP_ShrSint16Uint16:
49821	Text.Op = PrintName("ShrSint16Uint16");
49822	break;
49823	case OP_ShrSint16Sint32:
49824	Text.Op = PrintName("ShrSint16Sint32");
49825	break;
49826	case OP_ShrSint16Uint32:
49827	Text.Op = PrintName("ShrSint16Uint32");
49828	break;
49829	case OP_ShrSint16Sint64:
49830	Text.Op = PrintName("ShrSint16Sint64");
49831	break;
49832	case OP_ShrSint16Uint64:
49833	Text.Op = PrintName("ShrSint16Uint64");
49834	break;
49835	case OP_ShrSint16IntAP:
49836	Text.Op = PrintName("ShrSint16IntAP");
49837	break;
49838	case OP_ShrSint16IntAPS:
49839	Text.Op = PrintName("ShrSint16IntAPS");
49840	break;
49841	case OP_ShrUint16Sint8:
49842	Text.Op = PrintName("ShrUint16Sint8");
49843	break;
49844	case OP_ShrUint16Uint8:
49845	Text.Op = PrintName("ShrUint16Uint8");
49846	break;
49847	case OP_ShrUint16Sint16:
49848	Text.Op = PrintName("ShrUint16Sint16");
49849	break;
49850	case OP_ShrUint16Uint16:
49851	Text.Op = PrintName("ShrUint16Uint16");
49852	break;
49853	case OP_ShrUint16Sint32:
49854	Text.Op = PrintName("ShrUint16Sint32");
49855	break;
49856	case OP_ShrUint16Uint32:
49857	Text.Op = PrintName("ShrUint16Uint32");
49858	break;
49859	case OP_ShrUint16Sint64:
49860	Text.Op = PrintName("ShrUint16Sint64");
49861	break;
49862	case OP_ShrUint16Uint64:
49863	Text.Op = PrintName("ShrUint16Uint64");
49864	break;
49865	case OP_ShrUint16IntAP:
49866	Text.Op = PrintName("ShrUint16IntAP");
49867	break;
49868	case OP_ShrUint16IntAPS:
49869	Text.Op = PrintName("ShrUint16IntAPS");
49870	break;
49871	case OP_ShrSint32Sint8:
49872	Text.Op = PrintName("ShrSint32Sint8");
49873	break;
49874	case OP_ShrSint32Uint8:
49875	Text.Op = PrintName("ShrSint32Uint8");
49876	break;
49877	case OP_ShrSint32Sint16:
49878	Text.Op = PrintName("ShrSint32Sint16");
49879	break;
49880	case OP_ShrSint32Uint16:
49881	Text.Op = PrintName("ShrSint32Uint16");
49882	break;
49883	case OP_ShrSint32Sint32:
49884	Text.Op = PrintName("ShrSint32Sint32");
49885	break;
49886	case OP_ShrSint32Uint32:
49887	Text.Op = PrintName("ShrSint32Uint32");
49888	break;
49889	case OP_ShrSint32Sint64:
49890	Text.Op = PrintName("ShrSint32Sint64");
49891	break;
49892	case OP_ShrSint32Uint64:
49893	Text.Op = PrintName("ShrSint32Uint64");
49894	break;
49895	case OP_ShrSint32IntAP:
49896	Text.Op = PrintName("ShrSint32IntAP");
49897	break;
49898	case OP_ShrSint32IntAPS:
49899	Text.Op = PrintName("ShrSint32IntAPS");
49900	break;
49901	case OP_ShrUint32Sint8:
49902	Text.Op = PrintName("ShrUint32Sint8");
49903	break;
49904	case OP_ShrUint32Uint8:
49905	Text.Op = PrintName("ShrUint32Uint8");
49906	break;
49907	case OP_ShrUint32Sint16:
49908	Text.Op = PrintName("ShrUint32Sint16");
49909	break;
49910	case OP_ShrUint32Uint16:
49911	Text.Op = PrintName("ShrUint32Uint16");
49912	break;
49913	case OP_ShrUint32Sint32:
49914	Text.Op = PrintName("ShrUint32Sint32");
49915	break;
49916	case OP_ShrUint32Uint32:
49917	Text.Op = PrintName("ShrUint32Uint32");
49918	break;
49919	case OP_ShrUint32Sint64:
49920	Text.Op = PrintName("ShrUint32Sint64");
49921	break;
49922	case OP_ShrUint32Uint64:
49923	Text.Op = PrintName("ShrUint32Uint64");
49924	break;
49925	case OP_ShrUint32IntAP:
49926	Text.Op = PrintName("ShrUint32IntAP");
49927	break;
49928	case OP_ShrUint32IntAPS:
49929	Text.Op = PrintName("ShrUint32IntAPS");
49930	break;
49931	case OP_ShrSint64Sint8:
49932	Text.Op = PrintName("ShrSint64Sint8");
49933	break;
49934	case OP_ShrSint64Uint8:
49935	Text.Op = PrintName("ShrSint64Uint8");
49936	break;
49937	case OP_ShrSint64Sint16:
49938	Text.Op = PrintName("ShrSint64Sint16");
49939	break;
49940	case OP_ShrSint64Uint16:
49941	Text.Op = PrintName("ShrSint64Uint16");
49942	break;
49943	case OP_ShrSint64Sint32:
49944	Text.Op = PrintName("ShrSint64Sint32");
49945	break;
49946	case OP_ShrSint64Uint32:
49947	Text.Op = PrintName("ShrSint64Uint32");
49948	break;
49949	case OP_ShrSint64Sint64:
49950	Text.Op = PrintName("ShrSint64Sint64");
49951	break;
49952	case OP_ShrSint64Uint64:
49953	Text.Op = PrintName("ShrSint64Uint64");
49954	break;
49955	case OP_ShrSint64IntAP:
49956	Text.Op = PrintName("ShrSint64IntAP");
49957	break;
49958	case OP_ShrSint64IntAPS:
49959	Text.Op = PrintName("ShrSint64IntAPS");
49960	break;
49961	case OP_ShrUint64Sint8:
49962	Text.Op = PrintName("ShrUint64Sint8");
49963	break;
49964	case OP_ShrUint64Uint8:
49965	Text.Op = PrintName("ShrUint64Uint8");
49966	break;
49967	case OP_ShrUint64Sint16:
49968	Text.Op = PrintName("ShrUint64Sint16");
49969	break;
49970	case OP_ShrUint64Uint16:
49971	Text.Op = PrintName("ShrUint64Uint16");
49972	break;
49973	case OP_ShrUint64Sint32:
49974	Text.Op = PrintName("ShrUint64Sint32");
49975	break;
49976	case OP_ShrUint64Uint32:
49977	Text.Op = PrintName("ShrUint64Uint32");
49978	break;
49979	case OP_ShrUint64Sint64:
49980	Text.Op = PrintName("ShrUint64Sint64");
49981	break;
49982	case OP_ShrUint64Uint64:
49983	Text.Op = PrintName("ShrUint64Uint64");
49984	break;
49985	case OP_ShrUint64IntAP:
49986	Text.Op = PrintName("ShrUint64IntAP");
49987	break;
49988	case OP_ShrUint64IntAPS:
49989	Text.Op = PrintName("ShrUint64IntAPS");
49990	break;
49991	case OP_ShrIntAPSint8:
49992	Text.Op = PrintName("ShrIntAPSint8");
49993	break;
49994	case OP_ShrIntAPUint8:
49995	Text.Op = PrintName("ShrIntAPUint8");
49996	break;
49997	case OP_ShrIntAPSint16:
49998	Text.Op = PrintName("ShrIntAPSint16");
49999	break;
50000	case OP_ShrIntAPUint16:
50001	Text.Op = PrintName("ShrIntAPUint16");
50002	break;
50003	case OP_ShrIntAPSint32:
50004	Text.Op = PrintName("ShrIntAPSint32");
50005	break;
50006	case OP_ShrIntAPUint32:
50007	Text.Op = PrintName("ShrIntAPUint32");
50008	break;
50009	case OP_ShrIntAPSint64:
50010	Text.Op = PrintName("ShrIntAPSint64");
50011	break;
50012	case OP_ShrIntAPUint64:
50013	Text.Op = PrintName("ShrIntAPUint64");
50014	break;
50015	case OP_ShrIntAPIntAP:
50016	Text.Op = PrintName("ShrIntAPIntAP");
50017	break;
50018	case OP_ShrIntAPIntAPS:
50019	Text.Op = PrintName("ShrIntAPIntAPS");
50020	break;
50021	case OP_ShrIntAPSSint8:
50022	Text.Op = PrintName("ShrIntAPSSint8");
50023	break;
50024	case OP_ShrIntAPSUint8:
50025	Text.Op = PrintName("ShrIntAPSUint8");
50026	break;
50027	case OP_ShrIntAPSSint16:
50028	Text.Op = PrintName("ShrIntAPSSint16");
50029	break;
50030	case OP_ShrIntAPSUint16:
50031	Text.Op = PrintName("ShrIntAPSUint16");
50032	break;
50033	case OP_ShrIntAPSSint32:
50034	Text.Op = PrintName("ShrIntAPSSint32");
50035	break;
50036	case OP_ShrIntAPSUint32:
50037	Text.Op = PrintName("ShrIntAPSUint32");
50038	break;
50039	case OP_ShrIntAPSSint64:
50040	Text.Op = PrintName("ShrIntAPSSint64");
50041	break;
50042	case OP_ShrIntAPSUint64:
50043	Text.Op = PrintName("ShrIntAPSUint64");
50044	break;
50045	case OP_ShrIntAPSIntAP:
50046	Text.Op = PrintName("ShrIntAPSIntAP");
50047	break;
50048	case OP_ShrIntAPSIntAPS:
50049	Text.Op = PrintName("ShrIntAPSIntAPS");
50050	break;
50051	#endif
50052	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
50053	bool emitShrSint8Sint8(SourceInfo);
50054	bool emitShrSint8Uint8(SourceInfo);
50055	bool emitShrSint8Sint16(SourceInfo);
50056	bool emitShrSint8Uint16(SourceInfo);
50057	bool emitShrSint8Sint32(SourceInfo);
50058	bool emitShrSint8Uint32(SourceInfo);
50059	bool emitShrSint8Sint64(SourceInfo);
50060	bool emitShrSint8Uint64(SourceInfo);
50061	bool emitShrSint8IntAP(SourceInfo);
50062	bool emitShrSint8IntAPS(SourceInfo);
50063	bool emitShrUint8Sint8(SourceInfo);
50064	bool emitShrUint8Uint8(SourceInfo);
50065	bool emitShrUint8Sint16(SourceInfo);
50066	bool emitShrUint8Uint16(SourceInfo);
50067	bool emitShrUint8Sint32(SourceInfo);
50068	bool emitShrUint8Uint32(SourceInfo);
50069	bool emitShrUint8Sint64(SourceInfo);
50070	bool emitShrUint8Uint64(SourceInfo);
50071	bool emitShrUint8IntAP(SourceInfo);
50072	bool emitShrUint8IntAPS(SourceInfo);
50073	bool emitShrSint16Sint8(SourceInfo);
50074	bool emitShrSint16Uint8(SourceInfo);
50075	bool emitShrSint16Sint16(SourceInfo);
50076	bool emitShrSint16Uint16(SourceInfo);
50077	bool emitShrSint16Sint32(SourceInfo);
50078	bool emitShrSint16Uint32(SourceInfo);
50079	bool emitShrSint16Sint64(SourceInfo);
50080	bool emitShrSint16Uint64(SourceInfo);
50081	bool emitShrSint16IntAP(SourceInfo);
50082	bool emitShrSint16IntAPS(SourceInfo);
50083	bool emitShrUint16Sint8(SourceInfo);
50084	bool emitShrUint16Uint8(SourceInfo);
50085	bool emitShrUint16Sint16(SourceInfo);
50086	bool emitShrUint16Uint16(SourceInfo);
50087	bool emitShrUint16Sint32(SourceInfo);
50088	bool emitShrUint16Uint32(SourceInfo);
50089	bool emitShrUint16Sint64(SourceInfo);
50090	bool emitShrUint16Uint64(SourceInfo);
50091	bool emitShrUint16IntAP(SourceInfo);
50092	bool emitShrUint16IntAPS(SourceInfo);
50093	bool emitShrSint32Sint8(SourceInfo);
50094	bool emitShrSint32Uint8(SourceInfo);
50095	bool emitShrSint32Sint16(SourceInfo);
50096	bool emitShrSint32Uint16(SourceInfo);
50097	bool emitShrSint32Sint32(SourceInfo);
50098	bool emitShrSint32Uint32(SourceInfo);
50099	bool emitShrSint32Sint64(SourceInfo);
50100	bool emitShrSint32Uint64(SourceInfo);
50101	bool emitShrSint32IntAP(SourceInfo);
50102	bool emitShrSint32IntAPS(SourceInfo);
50103	bool emitShrUint32Sint8(SourceInfo);
50104	bool emitShrUint32Uint8(SourceInfo);
50105	bool emitShrUint32Sint16(SourceInfo);
50106	bool emitShrUint32Uint16(SourceInfo);
50107	bool emitShrUint32Sint32(SourceInfo);
50108	bool emitShrUint32Uint32(SourceInfo);
50109	bool emitShrUint32Sint64(SourceInfo);
50110	bool emitShrUint32Uint64(SourceInfo);
50111	bool emitShrUint32IntAP(SourceInfo);
50112	bool emitShrUint32IntAPS(SourceInfo);
50113	bool emitShrSint64Sint8(SourceInfo);
50114	bool emitShrSint64Uint8(SourceInfo);
50115	bool emitShrSint64Sint16(SourceInfo);
50116	bool emitShrSint64Uint16(SourceInfo);
50117	bool emitShrSint64Sint32(SourceInfo);
50118	bool emitShrSint64Uint32(SourceInfo);
50119	bool emitShrSint64Sint64(SourceInfo);
50120	bool emitShrSint64Uint64(SourceInfo);
50121	bool emitShrSint64IntAP(SourceInfo);
50122	bool emitShrSint64IntAPS(SourceInfo);
50123	bool emitShrUint64Sint8(SourceInfo);
50124	bool emitShrUint64Uint8(SourceInfo);
50125	bool emitShrUint64Sint16(SourceInfo);
50126	bool emitShrUint64Uint16(SourceInfo);
50127	bool emitShrUint64Sint32(SourceInfo);
50128	bool emitShrUint64Uint32(SourceInfo);
50129	bool emitShrUint64Sint64(SourceInfo);
50130	bool emitShrUint64Uint64(SourceInfo);
50131	bool emitShrUint64IntAP(SourceInfo);
50132	bool emitShrUint64IntAPS(SourceInfo);
50133	bool emitShrIntAPSint8(SourceInfo);
50134	bool emitShrIntAPUint8(SourceInfo);
50135	bool emitShrIntAPSint16(SourceInfo);
50136	bool emitShrIntAPUint16(SourceInfo);
50137	bool emitShrIntAPSint32(SourceInfo);
50138	bool emitShrIntAPUint32(SourceInfo);
50139	bool emitShrIntAPSint64(SourceInfo);
50140	bool emitShrIntAPUint64(SourceInfo);
50141	bool emitShrIntAPIntAP(SourceInfo);
50142	bool emitShrIntAPIntAPS(SourceInfo);
50143	bool emitShrIntAPSSint8(SourceInfo);
50144	bool emitShrIntAPSUint8(SourceInfo);
50145	bool emitShrIntAPSSint16(SourceInfo);
50146	bool emitShrIntAPSUint16(SourceInfo);
50147	bool emitShrIntAPSSint32(SourceInfo);
50148	bool emitShrIntAPSUint32(SourceInfo);
50149	bool emitShrIntAPSSint64(SourceInfo);
50150	bool emitShrIntAPSUint64(SourceInfo);
50151	bool emitShrIntAPSIntAP(SourceInfo);
50152	bool emitShrIntAPSIntAPS(SourceInfo);
50153	#endif
50154	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
50155	[[nodiscard]] bool emitShr(PrimType, PrimType, SourceInfo I);
50156	#endif
50157	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
50158	bool
50159	#if defined(GET_EVAL_IMPL)
50160	EvalEmitter
50161	#else
50162	ByteCodeEmitter
50163	#endif
50164	::emitShr(PrimType T0, PrimType T1, SourceInfo I) {
50165	switch (T0) {
50166	case PT_Sint8:
50167	switch (T1) {
50168	case PT_Sint8:
50169	return emitShrSint8Sint8(I);
50170	case PT_Uint8:
50171	return emitShrSint8Uint8(I);
50172	case PT_Sint16:
50173	return emitShrSint8Sint16(I);
50174	case PT_Uint16:
50175	return emitShrSint8Uint16(I);
50176	case PT_Sint32:
50177	return emitShrSint8Sint32(I);
50178	case PT_Uint32:
50179	return emitShrSint8Uint32(I);
50180	case PT_Sint64:
50181	return emitShrSint8Sint64(I);
50182	case PT_Uint64:
50183	return emitShrSint8Uint64(I);
50184	case PT_IntAP:
50185	return emitShrSint8IntAP(I);
50186	case PT_IntAPS:
50187	return emitShrSint8IntAPS(I);
50188	default: llvm_unreachable("invalid type: emitShr");
50189	}
50190	llvm_unreachable("invalid enum value");
50191	case PT_Uint8:
50192	switch (T1) {
50193	case PT_Sint8:
50194	return emitShrUint8Sint8(I);
50195	case PT_Uint8:
50196	return emitShrUint8Uint8(I);
50197	case PT_Sint16:
50198	return emitShrUint8Sint16(I);
50199	case PT_Uint16:
50200	return emitShrUint8Uint16(I);
50201	case PT_Sint32:
50202	return emitShrUint8Sint32(I);
50203	case PT_Uint32:
50204	return emitShrUint8Uint32(I);
50205	case PT_Sint64:
50206	return emitShrUint8Sint64(I);
50207	case PT_Uint64:
50208	return emitShrUint8Uint64(I);
50209	case PT_IntAP:
50210	return emitShrUint8IntAP(I);
50211	case PT_IntAPS:
50212	return emitShrUint8IntAPS(I);
50213	default: llvm_unreachable("invalid type: emitShr");
50214	}
50215	llvm_unreachable("invalid enum value");
50216	case PT_Sint16:
50217	switch (T1) {
50218	case PT_Sint8:
50219	return emitShrSint16Sint8(I);
50220	case PT_Uint8:
50221	return emitShrSint16Uint8(I);
50222	case PT_Sint16:
50223	return emitShrSint16Sint16(I);
50224	case PT_Uint16:
50225	return emitShrSint16Uint16(I);
50226	case PT_Sint32:
50227	return emitShrSint16Sint32(I);
50228	case PT_Uint32:
50229	return emitShrSint16Uint32(I);
50230	case PT_Sint64:
50231	return emitShrSint16Sint64(I);
50232	case PT_Uint64:
50233	return emitShrSint16Uint64(I);
50234	case PT_IntAP:
50235	return emitShrSint16IntAP(I);
50236	case PT_IntAPS:
50237	return emitShrSint16IntAPS(I);
50238	default: llvm_unreachable("invalid type: emitShr");
50239	}
50240	llvm_unreachable("invalid enum value");
50241	case PT_Uint16:
50242	switch (T1) {
50243	case PT_Sint8:
50244	return emitShrUint16Sint8(I);
50245	case PT_Uint8:
50246	return emitShrUint16Uint8(I);
50247	case PT_Sint16:
50248	return emitShrUint16Sint16(I);
50249	case PT_Uint16:
50250	return emitShrUint16Uint16(I);
50251	case PT_Sint32:
50252	return emitShrUint16Sint32(I);
50253	case PT_Uint32:
50254	return emitShrUint16Uint32(I);
50255	case PT_Sint64:
50256	return emitShrUint16Sint64(I);
50257	case PT_Uint64:
50258	return emitShrUint16Uint64(I);
50259	case PT_IntAP:
50260	return emitShrUint16IntAP(I);
50261	case PT_IntAPS:
50262	return emitShrUint16IntAPS(I);
50263	default: llvm_unreachable("invalid type: emitShr");
50264	}
50265	llvm_unreachable("invalid enum value");
50266	case PT_Sint32:
50267	switch (T1) {
50268	case PT_Sint8:
50269	return emitShrSint32Sint8(I);
50270	case PT_Uint8:
50271	return emitShrSint32Uint8(I);
50272	case PT_Sint16:
50273	return emitShrSint32Sint16(I);
50274	case PT_Uint16:
50275	return emitShrSint32Uint16(I);
50276	case PT_Sint32:
50277	return emitShrSint32Sint32(I);
50278	case PT_Uint32:
50279	return emitShrSint32Uint32(I);
50280	case PT_Sint64:
50281	return emitShrSint32Sint64(I);
50282	case PT_Uint64:
50283	return emitShrSint32Uint64(I);
50284	case PT_IntAP:
50285	return emitShrSint32IntAP(I);
50286	case PT_IntAPS:
50287	return emitShrSint32IntAPS(I);
50288	default: llvm_unreachable("invalid type: emitShr");
50289	}
50290	llvm_unreachable("invalid enum value");
50291	case PT_Uint32:
50292	switch (T1) {
50293	case PT_Sint8:
50294	return emitShrUint32Sint8(I);
50295	case PT_Uint8:
50296	return emitShrUint32Uint8(I);
50297	case PT_Sint16:
50298	return emitShrUint32Sint16(I);
50299	case PT_Uint16:
50300	return emitShrUint32Uint16(I);
50301	case PT_Sint32:
50302	return emitShrUint32Sint32(I);
50303	case PT_Uint32:
50304	return emitShrUint32Uint32(I);
50305	case PT_Sint64:
50306	return emitShrUint32Sint64(I);
50307	case PT_Uint64:
50308	return emitShrUint32Uint64(I);
50309	case PT_IntAP:
50310	return emitShrUint32IntAP(I);
50311	case PT_IntAPS:
50312	return emitShrUint32IntAPS(I);
50313	default: llvm_unreachable("invalid type: emitShr");
50314	}
50315	llvm_unreachable("invalid enum value");
50316	case PT_Sint64:
50317	switch (T1) {
50318	case PT_Sint8:
50319	return emitShrSint64Sint8(I);
50320	case PT_Uint8:
50321	return emitShrSint64Uint8(I);
50322	case PT_Sint16:
50323	return emitShrSint64Sint16(I);
50324	case PT_Uint16:
50325	return emitShrSint64Uint16(I);
50326	case PT_Sint32:
50327	return emitShrSint64Sint32(I);
50328	case PT_Uint32:
50329	return emitShrSint64Uint32(I);
50330	case PT_Sint64:
50331	return emitShrSint64Sint64(I);
50332	case PT_Uint64:
50333	return emitShrSint64Uint64(I);
50334	case PT_IntAP:
50335	return emitShrSint64IntAP(I);
50336	case PT_IntAPS:
50337	return emitShrSint64IntAPS(I);
50338	default: llvm_unreachable("invalid type: emitShr");
50339	}
50340	llvm_unreachable("invalid enum value");
50341	case PT_Uint64:
50342	switch (T1) {
50343	case PT_Sint8:
50344	return emitShrUint64Sint8(I);
50345	case PT_Uint8:
50346	return emitShrUint64Uint8(I);
50347	case PT_Sint16:
50348	return emitShrUint64Sint16(I);
50349	case PT_Uint16:
50350	return emitShrUint64Uint16(I);
50351	case PT_Sint32:
50352	return emitShrUint64Sint32(I);
50353	case PT_Uint32:
50354	return emitShrUint64Uint32(I);
50355	case PT_Sint64:
50356	return emitShrUint64Sint64(I);
50357	case PT_Uint64:
50358	return emitShrUint64Uint64(I);
50359	case PT_IntAP:
50360	return emitShrUint64IntAP(I);
50361	case PT_IntAPS:
50362	return emitShrUint64IntAPS(I);
50363	default: llvm_unreachable("invalid type: emitShr");
50364	}
50365	llvm_unreachable("invalid enum value");
50366	case PT_IntAP:
50367	switch (T1) {
50368	case PT_Sint8:
50369	return emitShrIntAPSint8(I);
50370	case PT_Uint8:
50371	return emitShrIntAPUint8(I);
50372	case PT_Sint16:
50373	return emitShrIntAPSint16(I);
50374	case PT_Uint16:
50375	return emitShrIntAPUint16(I);
50376	case PT_Sint32:
50377	return emitShrIntAPSint32(I);
50378	case PT_Uint32:
50379	return emitShrIntAPUint32(I);
50380	case PT_Sint64:
50381	return emitShrIntAPSint64(I);
50382	case PT_Uint64:
50383	return emitShrIntAPUint64(I);
50384	case PT_IntAP:
50385	return emitShrIntAPIntAP(I);
50386	case PT_IntAPS:
50387	return emitShrIntAPIntAPS(I);
50388	default: llvm_unreachable("invalid type: emitShr");
50389	}
50390	llvm_unreachable("invalid enum value");
50391	case PT_IntAPS:
50392	switch (T1) {
50393	case PT_Sint8:
50394	return emitShrIntAPSSint8(I);
50395	case PT_Uint8:
50396	return emitShrIntAPSUint8(I);
50397	case PT_Sint16:
50398	return emitShrIntAPSSint16(I);
50399	case PT_Uint16:
50400	return emitShrIntAPSUint16(I);
50401	case PT_Sint32:
50402	return emitShrIntAPSSint32(I);
50403	case PT_Uint32:
50404	return emitShrIntAPSUint32(I);
50405	case PT_Sint64:
50406	return emitShrIntAPSSint64(I);
50407	case PT_Uint64:
50408	return emitShrIntAPSUint64(I);
50409	case PT_IntAP:
50410	return emitShrIntAPSIntAP(I);
50411	case PT_IntAPS:
50412	return emitShrIntAPSIntAPS(I);
50413	default: llvm_unreachable("invalid type: emitShr");
50414	}
50415	llvm_unreachable("invalid enum value");
50416	default: llvm_unreachable("invalid type: emitShr");
50417	}
50418	llvm_unreachable("invalid enum value");
50419	}
50420	#endif
50421	#ifdef GET_LINK_IMPL
50422	bool ByteCodeEmitter::emitShrSint8Sint8(SourceInfo L) {
50423	return emitOp<>(OP_ShrSint8Sint8, L);
50424	}
50425	bool ByteCodeEmitter::emitShrSint8Uint8(SourceInfo L) {
50426	return emitOp<>(OP_ShrSint8Uint8, L);
50427	}
50428	bool ByteCodeEmitter::emitShrSint8Sint16(SourceInfo L) {
50429	return emitOp<>(OP_ShrSint8Sint16, L);
50430	}
50431	bool ByteCodeEmitter::emitShrSint8Uint16(SourceInfo L) {
50432	return emitOp<>(OP_ShrSint8Uint16, L);
50433	}
50434	bool ByteCodeEmitter::emitShrSint8Sint32(SourceInfo L) {
50435	return emitOp<>(OP_ShrSint8Sint32, L);
50436	}
50437	bool ByteCodeEmitter::emitShrSint8Uint32(SourceInfo L) {
50438	return emitOp<>(OP_ShrSint8Uint32, L);
50439	}
50440	bool ByteCodeEmitter::emitShrSint8Sint64(SourceInfo L) {
50441	return emitOp<>(OP_ShrSint8Sint64, L);
50442	}
50443	bool ByteCodeEmitter::emitShrSint8Uint64(SourceInfo L) {
50444	return emitOp<>(OP_ShrSint8Uint64, L);
50445	}
50446	bool ByteCodeEmitter::emitShrSint8IntAP(SourceInfo L) {
50447	return emitOp<>(OP_ShrSint8IntAP, L);
50448	}
50449	bool ByteCodeEmitter::emitShrSint8IntAPS(SourceInfo L) {
50450	return emitOp<>(OP_ShrSint8IntAPS, L);
50451	}
50452	bool ByteCodeEmitter::emitShrUint8Sint8(SourceInfo L) {
50453	return emitOp<>(OP_ShrUint8Sint8, L);
50454	}
50455	bool ByteCodeEmitter::emitShrUint8Uint8(SourceInfo L) {
50456	return emitOp<>(OP_ShrUint8Uint8, L);
50457	}
50458	bool ByteCodeEmitter::emitShrUint8Sint16(SourceInfo L) {
50459	return emitOp<>(OP_ShrUint8Sint16, L);
50460	}
50461	bool ByteCodeEmitter::emitShrUint8Uint16(SourceInfo L) {
50462	return emitOp<>(OP_ShrUint8Uint16, L);
50463	}
50464	bool ByteCodeEmitter::emitShrUint8Sint32(SourceInfo L) {
50465	return emitOp<>(OP_ShrUint8Sint32, L);
50466	}
50467	bool ByteCodeEmitter::emitShrUint8Uint32(SourceInfo L) {
50468	return emitOp<>(OP_ShrUint8Uint32, L);
50469	}
50470	bool ByteCodeEmitter::emitShrUint8Sint64(SourceInfo L) {
50471	return emitOp<>(OP_ShrUint8Sint64, L);
50472	}
50473	bool ByteCodeEmitter::emitShrUint8Uint64(SourceInfo L) {
50474	return emitOp<>(OP_ShrUint8Uint64, L);
50475	}
50476	bool ByteCodeEmitter::emitShrUint8IntAP(SourceInfo L) {
50477	return emitOp<>(OP_ShrUint8IntAP, L);
50478	}
50479	bool ByteCodeEmitter::emitShrUint8IntAPS(SourceInfo L) {
50480	return emitOp<>(OP_ShrUint8IntAPS, L);
50481	}
50482	bool ByteCodeEmitter::emitShrSint16Sint8(SourceInfo L) {
50483	return emitOp<>(OP_ShrSint16Sint8, L);
50484	}
50485	bool ByteCodeEmitter::emitShrSint16Uint8(SourceInfo L) {
50486	return emitOp<>(OP_ShrSint16Uint8, L);
50487	}
50488	bool ByteCodeEmitter::emitShrSint16Sint16(SourceInfo L) {
50489	return emitOp<>(OP_ShrSint16Sint16, L);
50490	}
50491	bool ByteCodeEmitter::emitShrSint16Uint16(SourceInfo L) {
50492	return emitOp<>(OP_ShrSint16Uint16, L);
50493	}
50494	bool ByteCodeEmitter::emitShrSint16Sint32(SourceInfo L) {
50495	return emitOp<>(OP_ShrSint16Sint32, L);
50496	}
50497	bool ByteCodeEmitter::emitShrSint16Uint32(SourceInfo L) {
50498	return emitOp<>(OP_ShrSint16Uint32, L);
50499	}
50500	bool ByteCodeEmitter::emitShrSint16Sint64(SourceInfo L) {
50501	return emitOp<>(OP_ShrSint16Sint64, L);
50502	}
50503	bool ByteCodeEmitter::emitShrSint16Uint64(SourceInfo L) {
50504	return emitOp<>(OP_ShrSint16Uint64, L);
50505	}
50506	bool ByteCodeEmitter::emitShrSint16IntAP(SourceInfo L) {
50507	return emitOp<>(OP_ShrSint16IntAP, L);
50508	}
50509	bool ByteCodeEmitter::emitShrSint16IntAPS(SourceInfo L) {
50510	return emitOp<>(OP_ShrSint16IntAPS, L);
50511	}
50512	bool ByteCodeEmitter::emitShrUint16Sint8(SourceInfo L) {
50513	return emitOp<>(OP_ShrUint16Sint8, L);
50514	}
50515	bool ByteCodeEmitter::emitShrUint16Uint8(SourceInfo L) {
50516	return emitOp<>(OP_ShrUint16Uint8, L);
50517	}
50518	bool ByteCodeEmitter::emitShrUint16Sint16(SourceInfo L) {
50519	return emitOp<>(OP_ShrUint16Sint16, L);
50520	}
50521	bool ByteCodeEmitter::emitShrUint16Uint16(SourceInfo L) {
50522	return emitOp<>(OP_ShrUint16Uint16, L);
50523	}
50524	bool ByteCodeEmitter::emitShrUint16Sint32(SourceInfo L) {
50525	return emitOp<>(OP_ShrUint16Sint32, L);
50526	}
50527	bool ByteCodeEmitter::emitShrUint16Uint32(SourceInfo L) {
50528	return emitOp<>(OP_ShrUint16Uint32, L);
50529	}
50530	bool ByteCodeEmitter::emitShrUint16Sint64(SourceInfo L) {
50531	return emitOp<>(OP_ShrUint16Sint64, L);
50532	}
50533	bool ByteCodeEmitter::emitShrUint16Uint64(SourceInfo L) {
50534	return emitOp<>(OP_ShrUint16Uint64, L);
50535	}
50536	bool ByteCodeEmitter::emitShrUint16IntAP(SourceInfo L) {
50537	return emitOp<>(OP_ShrUint16IntAP, L);
50538	}
50539	bool ByteCodeEmitter::emitShrUint16IntAPS(SourceInfo L) {
50540	return emitOp<>(OP_ShrUint16IntAPS, L);
50541	}
50542	bool ByteCodeEmitter::emitShrSint32Sint8(SourceInfo L) {
50543	return emitOp<>(OP_ShrSint32Sint8, L);
50544	}
50545	bool ByteCodeEmitter::emitShrSint32Uint8(SourceInfo L) {
50546	return emitOp<>(OP_ShrSint32Uint8, L);
50547	}
50548	bool ByteCodeEmitter::emitShrSint32Sint16(SourceInfo L) {
50549	return emitOp<>(OP_ShrSint32Sint16, L);
50550	}
50551	bool ByteCodeEmitter::emitShrSint32Uint16(SourceInfo L) {
50552	return emitOp<>(OP_ShrSint32Uint16, L);
50553	}
50554	bool ByteCodeEmitter::emitShrSint32Sint32(SourceInfo L) {
50555	return emitOp<>(OP_ShrSint32Sint32, L);
50556	}
50557	bool ByteCodeEmitter::emitShrSint32Uint32(SourceInfo L) {
50558	return emitOp<>(OP_ShrSint32Uint32, L);
50559	}
50560	bool ByteCodeEmitter::emitShrSint32Sint64(SourceInfo L) {
50561	return emitOp<>(OP_ShrSint32Sint64, L);
50562	}
50563	bool ByteCodeEmitter::emitShrSint32Uint64(SourceInfo L) {
50564	return emitOp<>(OP_ShrSint32Uint64, L);
50565	}
50566	bool ByteCodeEmitter::emitShrSint32IntAP(SourceInfo L) {
50567	return emitOp<>(OP_ShrSint32IntAP, L);
50568	}
50569	bool ByteCodeEmitter::emitShrSint32IntAPS(SourceInfo L) {
50570	return emitOp<>(OP_ShrSint32IntAPS, L);
50571	}
50572	bool ByteCodeEmitter::emitShrUint32Sint8(SourceInfo L) {
50573	return emitOp<>(OP_ShrUint32Sint8, L);
50574	}
50575	bool ByteCodeEmitter::emitShrUint32Uint8(SourceInfo L) {
50576	return emitOp<>(OP_ShrUint32Uint8, L);
50577	}
50578	bool ByteCodeEmitter::emitShrUint32Sint16(SourceInfo L) {
50579	return emitOp<>(OP_ShrUint32Sint16, L);
50580	}
50581	bool ByteCodeEmitter::emitShrUint32Uint16(SourceInfo L) {
50582	return emitOp<>(OP_ShrUint32Uint16, L);
50583	}
50584	bool ByteCodeEmitter::emitShrUint32Sint32(SourceInfo L) {
50585	return emitOp<>(OP_ShrUint32Sint32, L);
50586	}
50587	bool ByteCodeEmitter::emitShrUint32Uint32(SourceInfo L) {
50588	return emitOp<>(OP_ShrUint32Uint32, L);
50589	}
50590	bool ByteCodeEmitter::emitShrUint32Sint64(SourceInfo L) {
50591	return emitOp<>(OP_ShrUint32Sint64, L);
50592	}
50593	bool ByteCodeEmitter::emitShrUint32Uint64(SourceInfo L) {
50594	return emitOp<>(OP_ShrUint32Uint64, L);
50595	}
50596	bool ByteCodeEmitter::emitShrUint32IntAP(SourceInfo L) {
50597	return emitOp<>(OP_ShrUint32IntAP, L);
50598	}
50599	bool ByteCodeEmitter::emitShrUint32IntAPS(SourceInfo L) {
50600	return emitOp<>(OP_ShrUint32IntAPS, L);
50601	}
50602	bool ByteCodeEmitter::emitShrSint64Sint8(SourceInfo L) {
50603	return emitOp<>(OP_ShrSint64Sint8, L);
50604	}
50605	bool ByteCodeEmitter::emitShrSint64Uint8(SourceInfo L) {
50606	return emitOp<>(OP_ShrSint64Uint8, L);
50607	}
50608	bool ByteCodeEmitter::emitShrSint64Sint16(SourceInfo L) {
50609	return emitOp<>(OP_ShrSint64Sint16, L);
50610	}
50611	bool ByteCodeEmitter::emitShrSint64Uint16(SourceInfo L) {
50612	return emitOp<>(OP_ShrSint64Uint16, L);
50613	}
50614	bool ByteCodeEmitter::emitShrSint64Sint32(SourceInfo L) {
50615	return emitOp<>(OP_ShrSint64Sint32, L);
50616	}
50617	bool ByteCodeEmitter::emitShrSint64Uint32(SourceInfo L) {
50618	return emitOp<>(OP_ShrSint64Uint32, L);
50619	}
50620	bool ByteCodeEmitter::emitShrSint64Sint64(SourceInfo L) {
50621	return emitOp<>(OP_ShrSint64Sint64, L);
50622	}
50623	bool ByteCodeEmitter::emitShrSint64Uint64(SourceInfo L) {
50624	return emitOp<>(OP_ShrSint64Uint64, L);
50625	}
50626	bool ByteCodeEmitter::emitShrSint64IntAP(SourceInfo L) {
50627	return emitOp<>(OP_ShrSint64IntAP, L);
50628	}
50629	bool ByteCodeEmitter::emitShrSint64IntAPS(SourceInfo L) {
50630	return emitOp<>(OP_ShrSint64IntAPS, L);
50631	}
50632	bool ByteCodeEmitter::emitShrUint64Sint8(SourceInfo L) {
50633	return emitOp<>(OP_ShrUint64Sint8, L);
50634	}
50635	bool ByteCodeEmitter::emitShrUint64Uint8(SourceInfo L) {
50636	return emitOp<>(OP_ShrUint64Uint8, L);
50637	}
50638	bool ByteCodeEmitter::emitShrUint64Sint16(SourceInfo L) {
50639	return emitOp<>(OP_ShrUint64Sint16, L);
50640	}
50641	bool ByteCodeEmitter::emitShrUint64Uint16(SourceInfo L) {
50642	return emitOp<>(OP_ShrUint64Uint16, L);
50643	}
50644	bool ByteCodeEmitter::emitShrUint64Sint32(SourceInfo L) {
50645	return emitOp<>(OP_ShrUint64Sint32, L);
50646	}
50647	bool ByteCodeEmitter::emitShrUint64Uint32(SourceInfo L) {
50648	return emitOp<>(OP_ShrUint64Uint32, L);
50649	}
50650	bool ByteCodeEmitter::emitShrUint64Sint64(SourceInfo L) {
50651	return emitOp<>(OP_ShrUint64Sint64, L);
50652	}
50653	bool ByteCodeEmitter::emitShrUint64Uint64(SourceInfo L) {
50654	return emitOp<>(OP_ShrUint64Uint64, L);
50655	}
50656	bool ByteCodeEmitter::emitShrUint64IntAP(SourceInfo L) {
50657	return emitOp<>(OP_ShrUint64IntAP, L);
50658	}
50659	bool ByteCodeEmitter::emitShrUint64IntAPS(SourceInfo L) {
50660	return emitOp<>(OP_ShrUint64IntAPS, L);
50661	}
50662	bool ByteCodeEmitter::emitShrIntAPSint8(SourceInfo L) {
50663	return emitOp<>(OP_ShrIntAPSint8, L);
50664	}
50665	bool ByteCodeEmitter::emitShrIntAPUint8(SourceInfo L) {
50666	return emitOp<>(OP_ShrIntAPUint8, L);
50667	}
50668	bool ByteCodeEmitter::emitShrIntAPSint16(SourceInfo L) {
50669	return emitOp<>(OP_ShrIntAPSint16, L);
50670	}
50671	bool ByteCodeEmitter::emitShrIntAPUint16(SourceInfo L) {
50672	return emitOp<>(OP_ShrIntAPUint16, L);
50673	}
50674	bool ByteCodeEmitter::emitShrIntAPSint32(SourceInfo L) {
50675	return emitOp<>(OP_ShrIntAPSint32, L);
50676	}
50677	bool ByteCodeEmitter::emitShrIntAPUint32(SourceInfo L) {
50678	return emitOp<>(OP_ShrIntAPUint32, L);
50679	}
50680	bool ByteCodeEmitter::emitShrIntAPSint64(SourceInfo L) {
50681	return emitOp<>(OP_ShrIntAPSint64, L);
50682	}
50683	bool ByteCodeEmitter::emitShrIntAPUint64(SourceInfo L) {
50684	return emitOp<>(OP_ShrIntAPUint64, L);
50685	}
50686	bool ByteCodeEmitter::emitShrIntAPIntAP(SourceInfo L) {
50687	return emitOp<>(OP_ShrIntAPIntAP, L);
50688	}
50689	bool ByteCodeEmitter::emitShrIntAPIntAPS(SourceInfo L) {
50690	return emitOp<>(OP_ShrIntAPIntAPS, L);
50691	}
50692	bool ByteCodeEmitter::emitShrIntAPSSint8(SourceInfo L) {
50693	return emitOp<>(OP_ShrIntAPSSint8, L);
50694	}
50695	bool ByteCodeEmitter::emitShrIntAPSUint8(SourceInfo L) {
50696	return emitOp<>(OP_ShrIntAPSUint8, L);
50697	}
50698	bool ByteCodeEmitter::emitShrIntAPSSint16(SourceInfo L) {
50699	return emitOp<>(OP_ShrIntAPSSint16, L);
50700	}
50701	bool ByteCodeEmitter::emitShrIntAPSUint16(SourceInfo L) {
50702	return emitOp<>(OP_ShrIntAPSUint16, L);
50703	}
50704	bool ByteCodeEmitter::emitShrIntAPSSint32(SourceInfo L) {
50705	return emitOp<>(OP_ShrIntAPSSint32, L);
50706	}
50707	bool ByteCodeEmitter::emitShrIntAPSUint32(SourceInfo L) {
50708	return emitOp<>(OP_ShrIntAPSUint32, L);
50709	}
50710	bool ByteCodeEmitter::emitShrIntAPSSint64(SourceInfo L) {
50711	return emitOp<>(OP_ShrIntAPSSint64, L);
50712	}
50713	bool ByteCodeEmitter::emitShrIntAPSUint64(SourceInfo L) {
50714	return emitOp<>(OP_ShrIntAPSUint64, L);
50715	}
50716	bool ByteCodeEmitter::emitShrIntAPSIntAP(SourceInfo L) {
50717	return emitOp<>(OP_ShrIntAPSIntAP, L);
50718	}
50719	bool ByteCodeEmitter::emitShrIntAPSIntAPS(SourceInfo L) {
50720	return emitOp<>(OP_ShrIntAPSIntAPS, L);
50721	}
50722	#endif
50723	#ifdef GET_EVAL_IMPL
50724	bool EvalEmitter::emitShrSint8Sint8(SourceInfo L) {
50725	if (!isActive()) return true;
50726	CurrentSource = L;
50727	return Shr<PT_Sint8, PT_Sint8>(S, CodePtr());
50728	}
50729	bool EvalEmitter::emitShrSint8Uint8(SourceInfo L) {
50730	if (!isActive()) return true;
50731	CurrentSource = L;
50732	return Shr<PT_Sint8, PT_Uint8>(S, CodePtr());
50733	}
50734	bool EvalEmitter::emitShrSint8Sint16(SourceInfo L) {
50735	if (!isActive()) return true;
50736	CurrentSource = L;
50737	return Shr<PT_Sint8, PT_Sint16>(S, CodePtr());
50738	}
50739	bool EvalEmitter::emitShrSint8Uint16(SourceInfo L) {
50740	if (!isActive()) return true;
50741	CurrentSource = L;
50742	return Shr<PT_Sint8, PT_Uint16>(S, CodePtr());
50743	}
50744	bool EvalEmitter::emitShrSint8Sint32(SourceInfo L) {
50745	if (!isActive()) return true;
50746	CurrentSource = L;
50747	return Shr<PT_Sint8, PT_Sint32>(S, CodePtr());
50748	}
50749	bool EvalEmitter::emitShrSint8Uint32(SourceInfo L) {
50750	if (!isActive()) return true;
50751	CurrentSource = L;
50752	return Shr<PT_Sint8, PT_Uint32>(S, CodePtr());
50753	}
50754	bool EvalEmitter::emitShrSint8Sint64(SourceInfo L) {
50755	if (!isActive()) return true;
50756	CurrentSource = L;
50757	return Shr<PT_Sint8, PT_Sint64>(S, CodePtr());
50758	}
50759	bool EvalEmitter::emitShrSint8Uint64(SourceInfo L) {
50760	if (!isActive()) return true;
50761	CurrentSource = L;
50762	return Shr<PT_Sint8, PT_Uint64>(S, CodePtr());
50763	}
50764	bool EvalEmitter::emitShrSint8IntAP(SourceInfo L) {
50765	if (!isActive()) return true;
50766	CurrentSource = L;
50767	return Shr<PT_Sint8, PT_IntAP>(S, CodePtr());
50768	}
50769	bool EvalEmitter::emitShrSint8IntAPS(SourceInfo L) {
50770	if (!isActive()) return true;
50771	CurrentSource = L;
50772	return Shr<PT_Sint8, PT_IntAPS>(S, CodePtr());
50773	}
50774	bool EvalEmitter::emitShrUint8Sint8(SourceInfo L) {
50775	if (!isActive()) return true;
50776	CurrentSource = L;
50777	return Shr<PT_Uint8, PT_Sint8>(S, CodePtr());
50778	}
50779	bool EvalEmitter::emitShrUint8Uint8(SourceInfo L) {
50780	if (!isActive()) return true;
50781	CurrentSource = L;
50782	return Shr<PT_Uint8, PT_Uint8>(S, CodePtr());
50783	}
50784	bool EvalEmitter::emitShrUint8Sint16(SourceInfo L) {
50785	if (!isActive()) return true;
50786	CurrentSource = L;
50787	return Shr<PT_Uint8, PT_Sint16>(S, CodePtr());
50788	}
50789	bool EvalEmitter::emitShrUint8Uint16(SourceInfo L) {
50790	if (!isActive()) return true;
50791	CurrentSource = L;
50792	return Shr<PT_Uint8, PT_Uint16>(S, CodePtr());
50793	}
50794	bool EvalEmitter::emitShrUint8Sint32(SourceInfo L) {
50795	if (!isActive()) return true;
50796	CurrentSource = L;
50797	return Shr<PT_Uint8, PT_Sint32>(S, CodePtr());
50798	}
50799	bool EvalEmitter::emitShrUint8Uint32(SourceInfo L) {
50800	if (!isActive()) return true;
50801	CurrentSource = L;
50802	return Shr<PT_Uint8, PT_Uint32>(S, CodePtr());
50803	}
50804	bool EvalEmitter::emitShrUint8Sint64(SourceInfo L) {
50805	if (!isActive()) return true;
50806	CurrentSource = L;
50807	return Shr<PT_Uint8, PT_Sint64>(S, CodePtr());
50808	}
50809	bool EvalEmitter::emitShrUint8Uint64(SourceInfo L) {
50810	if (!isActive()) return true;
50811	CurrentSource = L;
50812	return Shr<PT_Uint8, PT_Uint64>(S, CodePtr());
50813	}
50814	bool EvalEmitter::emitShrUint8IntAP(SourceInfo L) {
50815	if (!isActive()) return true;
50816	CurrentSource = L;
50817	return Shr<PT_Uint8, PT_IntAP>(S, CodePtr());
50818	}
50819	bool EvalEmitter::emitShrUint8IntAPS(SourceInfo L) {
50820	if (!isActive()) return true;
50821	CurrentSource = L;
50822	return Shr<PT_Uint8, PT_IntAPS>(S, CodePtr());
50823	}
50824	bool EvalEmitter::emitShrSint16Sint8(SourceInfo L) {
50825	if (!isActive()) return true;
50826	CurrentSource = L;
50827	return Shr<PT_Sint16, PT_Sint8>(S, CodePtr());
50828	}
50829	bool EvalEmitter::emitShrSint16Uint8(SourceInfo L) {
50830	if (!isActive()) return true;
50831	CurrentSource = L;
50832	return Shr<PT_Sint16, PT_Uint8>(S, CodePtr());
50833	}
50834	bool EvalEmitter::emitShrSint16Sint16(SourceInfo L) {
50835	if (!isActive()) return true;
50836	CurrentSource = L;
50837	return Shr<PT_Sint16, PT_Sint16>(S, CodePtr());
50838	}
50839	bool EvalEmitter::emitShrSint16Uint16(SourceInfo L) {
50840	if (!isActive()) return true;
50841	CurrentSource = L;
50842	return Shr<PT_Sint16, PT_Uint16>(S, CodePtr());
50843	}
50844	bool EvalEmitter::emitShrSint16Sint32(SourceInfo L) {
50845	if (!isActive()) return true;
50846	CurrentSource = L;
50847	return Shr<PT_Sint16, PT_Sint32>(S, CodePtr());
50848	}
50849	bool EvalEmitter::emitShrSint16Uint32(SourceInfo L) {
50850	if (!isActive()) return true;
50851	CurrentSource = L;
50852	return Shr<PT_Sint16, PT_Uint32>(S, CodePtr());
50853	}
50854	bool EvalEmitter::emitShrSint16Sint64(SourceInfo L) {
50855	if (!isActive()) return true;
50856	CurrentSource = L;
50857	return Shr<PT_Sint16, PT_Sint64>(S, CodePtr());
50858	}
50859	bool EvalEmitter::emitShrSint16Uint64(SourceInfo L) {
50860	if (!isActive()) return true;
50861	CurrentSource = L;
50862	return Shr<PT_Sint16, PT_Uint64>(S, CodePtr());
50863	}
50864	bool EvalEmitter::emitShrSint16IntAP(SourceInfo L) {
50865	if (!isActive()) return true;
50866	CurrentSource = L;
50867	return Shr<PT_Sint16, PT_IntAP>(S, CodePtr());
50868	}
50869	bool EvalEmitter::emitShrSint16IntAPS(SourceInfo L) {
50870	if (!isActive()) return true;
50871	CurrentSource = L;
50872	return Shr<PT_Sint16, PT_IntAPS>(S, CodePtr());
50873	}
50874	bool EvalEmitter::emitShrUint16Sint8(SourceInfo L) {
50875	if (!isActive()) return true;
50876	CurrentSource = L;
50877	return Shr<PT_Uint16, PT_Sint8>(S, CodePtr());
50878	}
50879	bool EvalEmitter::emitShrUint16Uint8(SourceInfo L) {
50880	if (!isActive()) return true;
50881	CurrentSource = L;
50882	return Shr<PT_Uint16, PT_Uint8>(S, CodePtr());
50883	}
50884	bool EvalEmitter::emitShrUint16Sint16(SourceInfo L) {
50885	if (!isActive()) return true;
50886	CurrentSource = L;
50887	return Shr<PT_Uint16, PT_Sint16>(S, CodePtr());
50888	}
50889	bool EvalEmitter::emitShrUint16Uint16(SourceInfo L) {
50890	if (!isActive()) return true;
50891	CurrentSource = L;
50892	return Shr<PT_Uint16, PT_Uint16>(S, CodePtr());
50893	}
50894	bool EvalEmitter::emitShrUint16Sint32(SourceInfo L) {
50895	if (!isActive()) return true;
50896	CurrentSource = L;
50897	return Shr<PT_Uint16, PT_Sint32>(S, CodePtr());
50898	}
50899	bool EvalEmitter::emitShrUint16Uint32(SourceInfo L) {
50900	if (!isActive()) return true;
50901	CurrentSource = L;
50902	return Shr<PT_Uint16, PT_Uint32>(S, CodePtr());
50903	}
50904	bool EvalEmitter::emitShrUint16Sint64(SourceInfo L) {
50905	if (!isActive()) return true;
50906	CurrentSource = L;
50907	return Shr<PT_Uint16, PT_Sint64>(S, CodePtr());
50908	}
50909	bool EvalEmitter::emitShrUint16Uint64(SourceInfo L) {
50910	if (!isActive()) return true;
50911	CurrentSource = L;
50912	return Shr<PT_Uint16, PT_Uint64>(S, CodePtr());
50913	}
50914	bool EvalEmitter::emitShrUint16IntAP(SourceInfo L) {
50915	if (!isActive()) return true;
50916	CurrentSource = L;
50917	return Shr<PT_Uint16, PT_IntAP>(S, CodePtr());
50918	}
50919	bool EvalEmitter::emitShrUint16IntAPS(SourceInfo L) {
50920	if (!isActive()) return true;
50921	CurrentSource = L;
50922	return Shr<PT_Uint16, PT_IntAPS>(S, CodePtr());
50923	}
50924	bool EvalEmitter::emitShrSint32Sint8(SourceInfo L) {
50925	if (!isActive()) return true;
50926	CurrentSource = L;
50927	return Shr<PT_Sint32, PT_Sint8>(S, CodePtr());
50928	}
50929	bool EvalEmitter::emitShrSint32Uint8(SourceInfo L) {
50930	if (!isActive()) return true;
50931	CurrentSource = L;
50932	return Shr<PT_Sint32, PT_Uint8>(S, CodePtr());
50933	}
50934	bool EvalEmitter::emitShrSint32Sint16(SourceInfo L) {
50935	if (!isActive()) return true;
50936	CurrentSource = L;
50937	return Shr<PT_Sint32, PT_Sint16>(S, CodePtr());
50938	}
50939	bool EvalEmitter::emitShrSint32Uint16(SourceInfo L) {
50940	if (!isActive()) return true;
50941	CurrentSource = L;
50942	return Shr<PT_Sint32, PT_Uint16>(S, CodePtr());
50943	}
50944	bool EvalEmitter::emitShrSint32Sint32(SourceInfo L) {
50945	if (!isActive()) return true;
50946	CurrentSource = L;
50947	return Shr<PT_Sint32, PT_Sint32>(S, CodePtr());
50948	}
50949	bool EvalEmitter::emitShrSint32Uint32(SourceInfo L) {
50950	if (!isActive()) return true;
50951	CurrentSource = L;
50952	return Shr<PT_Sint32, PT_Uint32>(S, CodePtr());
50953	}
50954	bool EvalEmitter::emitShrSint32Sint64(SourceInfo L) {
50955	if (!isActive()) return true;
50956	CurrentSource = L;
50957	return Shr<PT_Sint32, PT_Sint64>(S, CodePtr());
50958	}
50959	bool EvalEmitter::emitShrSint32Uint64(SourceInfo L) {
50960	if (!isActive()) return true;
50961	CurrentSource = L;
50962	return Shr<PT_Sint32, PT_Uint64>(S, CodePtr());
50963	}
50964	bool EvalEmitter::emitShrSint32IntAP(SourceInfo L) {
50965	if (!isActive()) return true;
50966	CurrentSource = L;
50967	return Shr<PT_Sint32, PT_IntAP>(S, CodePtr());
50968	}
50969	bool EvalEmitter::emitShrSint32IntAPS(SourceInfo L) {
50970	if (!isActive()) return true;
50971	CurrentSource = L;
50972	return Shr<PT_Sint32, PT_IntAPS>(S, CodePtr());
50973	}
50974	bool EvalEmitter::emitShrUint32Sint8(SourceInfo L) {
50975	if (!isActive()) return true;
50976	CurrentSource = L;
50977	return Shr<PT_Uint32, PT_Sint8>(S, CodePtr());
50978	}
50979	bool EvalEmitter::emitShrUint32Uint8(SourceInfo L) {
50980	if (!isActive()) return true;
50981	CurrentSource = L;
50982	return Shr<PT_Uint32, PT_Uint8>(S, CodePtr());
50983	}
50984	bool EvalEmitter::emitShrUint32Sint16(SourceInfo L) {
50985	if (!isActive()) return true;
50986	CurrentSource = L;
50987	return Shr<PT_Uint32, PT_Sint16>(S, CodePtr());
50988	}
50989	bool EvalEmitter::emitShrUint32Uint16(SourceInfo L) {
50990	if (!isActive()) return true;
50991	CurrentSource = L;
50992	return Shr<PT_Uint32, PT_Uint16>(S, CodePtr());
50993	}
50994	bool EvalEmitter::emitShrUint32Sint32(SourceInfo L) {
50995	if (!isActive()) return true;
50996	CurrentSource = L;
50997	return Shr<PT_Uint32, PT_Sint32>(S, CodePtr());
50998	}
50999	bool EvalEmitter::emitShrUint32Uint32(SourceInfo L) {
51000	if (!isActive()) return true;
51001	CurrentSource = L;
51002	return Shr<PT_Uint32, PT_Uint32>(S, CodePtr());
51003	}
51004	bool EvalEmitter::emitShrUint32Sint64(SourceInfo L) {
51005	if (!isActive()) return true;
51006	CurrentSource = L;
51007	return Shr<PT_Uint32, PT_Sint64>(S, CodePtr());
51008	}
51009	bool EvalEmitter::emitShrUint32Uint64(SourceInfo L) {
51010	if (!isActive()) return true;
51011	CurrentSource = L;
51012	return Shr<PT_Uint32, PT_Uint64>(S, CodePtr());
51013	}
51014	bool EvalEmitter::emitShrUint32IntAP(SourceInfo L) {
51015	if (!isActive()) return true;
51016	CurrentSource = L;
51017	return Shr<PT_Uint32, PT_IntAP>(S, CodePtr());
51018	}
51019	bool EvalEmitter::emitShrUint32IntAPS(SourceInfo L) {
51020	if (!isActive()) return true;
51021	CurrentSource = L;
51022	return Shr<PT_Uint32, PT_IntAPS>(S, CodePtr());
51023	}
51024	bool EvalEmitter::emitShrSint64Sint8(SourceInfo L) {
51025	if (!isActive()) return true;
51026	CurrentSource = L;
51027	return Shr<PT_Sint64, PT_Sint8>(S, CodePtr());
51028	}
51029	bool EvalEmitter::emitShrSint64Uint8(SourceInfo L) {
51030	if (!isActive()) return true;
51031	CurrentSource = L;
51032	return Shr<PT_Sint64, PT_Uint8>(S, CodePtr());
51033	}
51034	bool EvalEmitter::emitShrSint64Sint16(SourceInfo L) {
51035	if (!isActive()) return true;
51036	CurrentSource = L;
51037	return Shr<PT_Sint64, PT_Sint16>(S, CodePtr());
51038	}
51039	bool EvalEmitter::emitShrSint64Uint16(SourceInfo L) {
51040	if (!isActive()) return true;
51041	CurrentSource = L;
51042	return Shr<PT_Sint64, PT_Uint16>(S, CodePtr());
51043	}
51044	bool EvalEmitter::emitShrSint64Sint32(SourceInfo L) {
51045	if (!isActive()) return true;
51046	CurrentSource = L;
51047	return Shr<PT_Sint64, PT_Sint32>(S, CodePtr());
51048	}
51049	bool EvalEmitter::emitShrSint64Uint32(SourceInfo L) {
51050	if (!isActive()) return true;
51051	CurrentSource = L;
51052	return Shr<PT_Sint64, PT_Uint32>(S, CodePtr());
51053	}
51054	bool EvalEmitter::emitShrSint64Sint64(SourceInfo L) {
51055	if (!isActive()) return true;
51056	CurrentSource = L;
51057	return Shr<PT_Sint64, PT_Sint64>(S, CodePtr());
51058	}
51059	bool EvalEmitter::emitShrSint64Uint64(SourceInfo L) {
51060	if (!isActive()) return true;
51061	CurrentSource = L;
51062	return Shr<PT_Sint64, PT_Uint64>(S, CodePtr());
51063	}
51064	bool EvalEmitter::emitShrSint64IntAP(SourceInfo L) {
51065	if (!isActive()) return true;
51066	CurrentSource = L;
51067	return Shr<PT_Sint64, PT_IntAP>(S, CodePtr());
51068	}
51069	bool EvalEmitter::emitShrSint64IntAPS(SourceInfo L) {
51070	if (!isActive()) return true;
51071	CurrentSource = L;
51072	return Shr<PT_Sint64, PT_IntAPS>(S, CodePtr());
51073	}
51074	bool EvalEmitter::emitShrUint64Sint8(SourceInfo L) {
51075	if (!isActive()) return true;
51076	CurrentSource = L;
51077	return Shr<PT_Uint64, PT_Sint8>(S, CodePtr());
51078	}
51079	bool EvalEmitter::emitShrUint64Uint8(SourceInfo L) {
51080	if (!isActive()) return true;
51081	CurrentSource = L;
51082	return Shr<PT_Uint64, PT_Uint8>(S, CodePtr());
51083	}
51084	bool EvalEmitter::emitShrUint64Sint16(SourceInfo L) {
51085	if (!isActive()) return true;
51086	CurrentSource = L;
51087	return Shr<PT_Uint64, PT_Sint16>(S, CodePtr());
51088	}
51089	bool EvalEmitter::emitShrUint64Uint16(SourceInfo L) {
51090	if (!isActive()) return true;
51091	CurrentSource = L;
51092	return Shr<PT_Uint64, PT_Uint16>(S, CodePtr());
51093	}
51094	bool EvalEmitter::emitShrUint64Sint32(SourceInfo L) {
51095	if (!isActive()) return true;
51096	CurrentSource = L;
51097	return Shr<PT_Uint64, PT_Sint32>(S, CodePtr());
51098	}
51099	bool EvalEmitter::emitShrUint64Uint32(SourceInfo L) {
51100	if (!isActive()) return true;
51101	CurrentSource = L;
51102	return Shr<PT_Uint64, PT_Uint32>(S, CodePtr());
51103	}
51104	bool EvalEmitter::emitShrUint64Sint64(SourceInfo L) {
51105	if (!isActive()) return true;
51106	CurrentSource = L;
51107	return Shr<PT_Uint64, PT_Sint64>(S, CodePtr());
51108	}
51109	bool EvalEmitter::emitShrUint64Uint64(SourceInfo L) {
51110	if (!isActive()) return true;
51111	CurrentSource = L;
51112	return Shr<PT_Uint64, PT_Uint64>(S, CodePtr());
51113	}
51114	bool EvalEmitter::emitShrUint64IntAP(SourceInfo L) {
51115	if (!isActive()) return true;
51116	CurrentSource = L;
51117	return Shr<PT_Uint64, PT_IntAP>(S, CodePtr());
51118	}
51119	bool EvalEmitter::emitShrUint64IntAPS(SourceInfo L) {
51120	if (!isActive()) return true;
51121	CurrentSource = L;
51122	return Shr<PT_Uint64, PT_IntAPS>(S, CodePtr());
51123	}
51124	bool EvalEmitter::emitShrIntAPSint8(SourceInfo L) {
51125	if (!isActive()) return true;
51126	CurrentSource = L;
51127	return Shr<PT_IntAP, PT_Sint8>(S, CodePtr());
51128	}
51129	bool EvalEmitter::emitShrIntAPUint8(SourceInfo L) {
51130	if (!isActive()) return true;
51131	CurrentSource = L;
51132	return Shr<PT_IntAP, PT_Uint8>(S, CodePtr());
51133	}
51134	bool EvalEmitter::emitShrIntAPSint16(SourceInfo L) {
51135	if (!isActive()) return true;
51136	CurrentSource = L;
51137	return Shr<PT_IntAP, PT_Sint16>(S, CodePtr());
51138	}
51139	bool EvalEmitter::emitShrIntAPUint16(SourceInfo L) {
51140	if (!isActive()) return true;
51141	CurrentSource = L;
51142	return Shr<PT_IntAP, PT_Uint16>(S, CodePtr());
51143	}
51144	bool EvalEmitter::emitShrIntAPSint32(SourceInfo L) {
51145	if (!isActive()) return true;
51146	CurrentSource = L;
51147	return Shr<PT_IntAP, PT_Sint32>(S, CodePtr());
51148	}
51149	bool EvalEmitter::emitShrIntAPUint32(SourceInfo L) {
51150	if (!isActive()) return true;
51151	CurrentSource = L;
51152	return Shr<PT_IntAP, PT_Uint32>(S, CodePtr());
51153	}
51154	bool EvalEmitter::emitShrIntAPSint64(SourceInfo L) {
51155	if (!isActive()) return true;
51156	CurrentSource = L;
51157	return Shr<PT_IntAP, PT_Sint64>(S, CodePtr());
51158	}
51159	bool EvalEmitter::emitShrIntAPUint64(SourceInfo L) {
51160	if (!isActive()) return true;
51161	CurrentSource = L;
51162	return Shr<PT_IntAP, PT_Uint64>(S, CodePtr());
51163	}
51164	bool EvalEmitter::emitShrIntAPIntAP(SourceInfo L) {
51165	if (!isActive()) return true;
51166	CurrentSource = L;
51167	return Shr<PT_IntAP, PT_IntAP>(S, CodePtr());
51168	}
51169	bool EvalEmitter::emitShrIntAPIntAPS(SourceInfo L) {
51170	if (!isActive()) return true;
51171	CurrentSource = L;
51172	return Shr<PT_IntAP, PT_IntAPS>(S, CodePtr());
51173	}
51174	bool EvalEmitter::emitShrIntAPSSint8(SourceInfo L) {
51175	if (!isActive()) return true;
51176	CurrentSource = L;
51177	return Shr<PT_IntAPS, PT_Sint8>(S, CodePtr());
51178	}
51179	bool EvalEmitter::emitShrIntAPSUint8(SourceInfo L) {
51180	if (!isActive()) return true;
51181	CurrentSource = L;
51182	return Shr<PT_IntAPS, PT_Uint8>(S, CodePtr());
51183	}
51184	bool EvalEmitter::emitShrIntAPSSint16(SourceInfo L) {
51185	if (!isActive()) return true;
51186	CurrentSource = L;
51187	return Shr<PT_IntAPS, PT_Sint16>(S, CodePtr());
51188	}
51189	bool EvalEmitter::emitShrIntAPSUint16(SourceInfo L) {
51190	if (!isActive()) return true;
51191	CurrentSource = L;
51192	return Shr<PT_IntAPS, PT_Uint16>(S, CodePtr());
51193	}
51194	bool EvalEmitter::emitShrIntAPSSint32(SourceInfo L) {
51195	if (!isActive()) return true;
51196	CurrentSource = L;
51197	return Shr<PT_IntAPS, PT_Sint32>(S, CodePtr());
51198	}
51199	bool EvalEmitter::emitShrIntAPSUint32(SourceInfo L) {
51200	if (!isActive()) return true;
51201	CurrentSource = L;
51202	return Shr<PT_IntAPS, PT_Uint32>(S, CodePtr());
51203	}
51204	bool EvalEmitter::emitShrIntAPSSint64(SourceInfo L) {
51205	if (!isActive()) return true;
51206	CurrentSource = L;
51207	return Shr<PT_IntAPS, PT_Sint64>(S, CodePtr());
51208	}
51209	bool EvalEmitter::emitShrIntAPSUint64(SourceInfo L) {
51210	if (!isActive()) return true;
51211	CurrentSource = L;
51212	return Shr<PT_IntAPS, PT_Uint64>(S, CodePtr());
51213	}
51214	bool EvalEmitter::emitShrIntAPSIntAP(SourceInfo L) {
51215	if (!isActive()) return true;
51216	CurrentSource = L;
51217	return Shr<PT_IntAPS, PT_IntAP>(S, CodePtr());
51218	}
51219	bool EvalEmitter::emitShrIntAPSIntAPS(SourceInfo L) {
51220	if (!isActive()) return true;
51221	CurrentSource = L;
51222	return Shr<PT_IntAPS, PT_IntAPS>(S, CodePtr());
51223	}
51224	#endif
51225	#ifdef GET_OPCODE_NAMES
51226	OP_SideEffect,
51227	#endif
51228	#ifdef GET_INTERPFN_LIST
51229	&Interp_SideEffect,
51230	#endif
51231	#ifdef GET_INTERPFN_DISPATCHERS
51232	PRESERVE_NONE
51233	static bool Interp_SideEffect(InterpState &S) {
51234	if (!SideEffect(S)) return false;
51235	#if USE_TAILCALLS
51236	MUSTTAIL return InterpNext(S);
51237	#else
51238	return true;
51239	#endif
51240	}
51241	#endif
51242	#ifdef GET_DISASM
51243	case OP_SideEffect:
51244	Text.Op = PrintName("SideEffect");
51245	break;
51246	#endif
51247	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51248	bool emitSideEffect(SourceInfo);
51249	#endif
51250	#ifdef GET_LINK_IMPL
51251	bool ByteCodeEmitter::emitSideEffect(SourceInfo L) {
51252	return emitOp<>(OP_SideEffect, L);
51253	}
51254	#endif
51255	#ifdef GET_EVAL_IMPL
51256	bool EvalEmitter::emitSideEffect(SourceInfo L) {
51257	if (!isActive()) return true;
51258	CurrentSource = L;
51259	return SideEffect(S);
51260	}
51261	#endif
51262	#ifdef GET_OPCODE_NAMES
51263	OP_SizelessVectorElementSize,
51264	#endif
51265	#ifdef GET_INTERPFN_LIST
51266	&Interp_SizelessVectorElementSize,
51267	#endif
51268	#ifdef GET_INTERPFN_DISPATCHERS
51269	PRESERVE_NONE
51270	static bool Interp_SizelessVectorElementSize(InterpState &S) {
51271	if (!SizelessVectorElementSize(S, S.PC)) return false;
51272	#if USE_TAILCALLS
51273	MUSTTAIL return InterpNext(S);
51274	#else
51275	return true;
51276	#endif
51277	}
51278	#endif
51279	#ifdef GET_DISASM
51280	case OP_SizelessVectorElementSize:
51281	Text.Op = PrintName("SizelessVectorElementSize");
51282	break;
51283	#endif
51284	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51285	bool emitSizelessVectorElementSize(SourceInfo);
51286	#endif
51287	#ifdef GET_LINK_IMPL
51288	bool ByteCodeEmitter::emitSizelessVectorElementSize(SourceInfo L) {
51289	return emitOp<>(OP_SizelessVectorElementSize, L);
51290	}
51291	#endif
51292	#ifdef GET_EVAL_IMPL
51293	bool EvalEmitter::emitSizelessVectorElementSize(SourceInfo L) {
51294	if (!isActive()) return true;
51295	CurrentSource = L;
51296	return SizelessVectorElementSize(S, CodePtr());
51297	}
51298	#endif
51299	#ifdef GET_OPCODE_NAMES
51300	OP_StartInit,
51301	#endif
51302	#ifdef GET_INTERPFN_LIST
51303	&Interp_StartInit,
51304	#endif
51305	#ifdef GET_INTERPFN_DISPATCHERS
51306	PRESERVE_NONE
51307	static bool Interp_StartInit(InterpState &S) {
51308	StartInit(S);
51309	#if USE_TAILCALLS
51310	MUSTTAIL return InterpNext(S);
51311	#else
51312	return true;
51313	#endif
51314	}
51315	#endif
51316	#ifdef GET_DISASM
51317	case OP_StartInit:
51318	Text.Op = PrintName("StartInit");
51319	break;
51320	#endif
51321	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51322	bool emitStartInit(SourceInfo);
51323	#endif
51324	#ifdef GET_LINK_IMPL
51325	bool ByteCodeEmitter::emitStartInit(SourceInfo L) {
51326	return emitOp<>(OP_StartInit, L);
51327	}
51328	#endif
51329	#ifdef GET_EVAL_IMPL
51330	bool EvalEmitter::emitStartInit(SourceInfo L) {
51331	if (!isActive()) return true;
51332	CurrentSource = L;
51333	return StartInit(S);
51334	}
51335	#endif
51336	#ifdef GET_OPCODE_NAMES
51337	OP_StartSpeculation,
51338	#endif
51339	#ifdef GET_INTERPFN_LIST
51340	&Interp_StartSpeculation,
51341	#endif
51342	#ifdef GET_INTERPFN_DISPATCHERS
51343	PRESERVE_NONE
51344	static bool Interp_StartSpeculation(InterpState &S) {
51345	StartSpeculation(S);
51346	#if USE_TAILCALLS
51347	MUSTTAIL return InterpNext(S);
51348	#else
51349	return true;
51350	#endif
51351	}
51352	#endif
51353	#ifdef GET_DISASM
51354	case OP_StartSpeculation:
51355	Text.Op = PrintName("StartSpeculation");
51356	break;
51357	#endif
51358	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51359	bool emitStartSpeculation(SourceInfo);
51360	#endif
51361	#ifdef GET_LINK_IMPL
51362	bool ByteCodeEmitter::emitStartSpeculation(SourceInfo L) {
51363	return emitOp<>(OP_StartSpeculation, L);
51364	}
51365	#endif
51366	#ifdef GET_EVAL_IMPL
51367	bool EvalEmitter::emitStartSpeculation(SourceInfo L) {
51368	if (!isActive()) return true;
51369	CurrentSource = L;
51370	return StartSpeculation(S);
51371	}
51372	#endif
51373	#ifdef GET_OPCODE_NAMES
51374	OP_StartThisLifetime,
51375	#endif
51376	#ifdef GET_INTERPFN_LIST
51377	&Interp_StartThisLifetime,
51378	#endif
51379	#ifdef GET_INTERPFN_DISPATCHERS
51380	PRESERVE_NONE
51381	static bool Interp_StartThisLifetime(InterpState &S) {
51382	if (!StartThisLifetime(S)) return false;
51383	#if USE_TAILCALLS
51384	MUSTTAIL return InterpNext(S);
51385	#else
51386	return true;
51387	#endif
51388	}
51389	#endif
51390	#ifdef GET_DISASM
51391	case OP_StartThisLifetime:
51392	Text.Op = PrintName("StartThisLifetime");
51393	break;
51394	#endif
51395	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51396	bool emitStartThisLifetime(SourceInfo);
51397	#endif
51398	#ifdef GET_LINK_IMPL
51399	bool ByteCodeEmitter::emitStartThisLifetime(SourceInfo L) {
51400	return emitOp<>(OP_StartThisLifetime, L);
51401	}
51402	#endif
51403	#ifdef GET_EVAL_IMPL
51404	bool EvalEmitter::emitStartThisLifetime(SourceInfo L) {
51405	if (!isActive()) return true;
51406	CurrentSource = L;
51407	return StartThisLifetime(S);
51408	}
51409	#endif
51410	#ifdef GET_OPCODE_NAMES
51411	OP_StartThisLifetime1,
51412	#endif
51413	#ifdef GET_INTERPFN_LIST
51414	&Interp_StartThisLifetime1,
51415	#endif
51416	#ifdef GET_INTERPFN_DISPATCHERS
51417	PRESERVE_NONE
51418	static bool Interp_StartThisLifetime1(InterpState &S) {
51419	if (!StartThisLifetime1(S)) return false;
51420	#if USE_TAILCALLS
51421	MUSTTAIL return InterpNext(S);
51422	#else
51423	return true;
51424	#endif
51425	}
51426	#endif
51427	#ifdef GET_DISASM
51428	case OP_StartThisLifetime1:
51429	Text.Op = PrintName("StartThisLifetime1");
51430	break;
51431	#endif
51432	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51433	bool emitStartThisLifetime1(SourceInfo);
51434	#endif
51435	#ifdef GET_LINK_IMPL
51436	bool ByteCodeEmitter::emitStartThisLifetime1(SourceInfo L) {
51437	return emitOp<>(OP_StartThisLifetime1, L);
51438	}
51439	#endif
51440	#ifdef GET_EVAL_IMPL
51441	bool EvalEmitter::emitStartThisLifetime1(SourceInfo L) {
51442	if (!isActive()) return true;
51443	CurrentSource = L;
51444	return StartThisLifetime1(S);
51445	}
51446	#endif
51447	#ifdef GET_OPCODE_NAMES
51448	OP_StoreSint8,
51449	OP_StoreUint8,
51450	OP_StoreSint16,
51451	OP_StoreUint16,
51452	OP_StoreSint32,
51453	OP_StoreUint32,
51454	OP_StoreSint64,
51455	OP_StoreUint64,
51456	OP_StoreIntAP,
51457	OP_StoreIntAPS,
51458	OP_StoreBool,
51459	OP_StoreFixedPoint,
51460	OP_StorePtr,
51461	OP_StoreMemberPtr,
51462	OP_StoreFloat,
51463	#endif
51464	#ifdef GET_INTERPFN_LIST
51465	&Interp_StoreSint8,
51466	&Interp_StoreUint8,
51467	&Interp_StoreSint16,
51468	&Interp_StoreUint16,
51469	&Interp_StoreSint32,
51470	&Interp_StoreUint32,
51471	&Interp_StoreSint64,
51472	&Interp_StoreUint64,
51473	&Interp_StoreIntAP,
51474	&Interp_StoreIntAPS,
51475	&Interp_StoreBool,
51476	&Interp_StoreFixedPoint,
51477	&Interp_StorePtr,
51478	&Interp_StoreMemberPtr,
51479	&Interp_StoreFloat,
51480	#endif
51481	#ifdef GET_INTERPFN_DISPATCHERS
51482	PRESERVE_NONE
51483	static bool Interp_StoreSint8(InterpState &S) {
51484	if (!Store<PT_Sint8>(S, S.PC)) return false;
51485	#if USE_TAILCALLS
51486	MUSTTAIL return InterpNext(S);
51487	#else
51488	return true;
51489	#endif
51490	}
51491	PRESERVE_NONE
51492	static bool Interp_StoreUint8(InterpState &S) {
51493	if (!Store<PT_Uint8>(S, S.PC)) return false;
51494	#if USE_TAILCALLS
51495	MUSTTAIL return InterpNext(S);
51496	#else
51497	return true;
51498	#endif
51499	}
51500	PRESERVE_NONE
51501	static bool Interp_StoreSint16(InterpState &S) {
51502	if (!Store<PT_Sint16>(S, S.PC)) return false;
51503	#if USE_TAILCALLS
51504	MUSTTAIL return InterpNext(S);
51505	#else
51506	return true;
51507	#endif
51508	}
51509	PRESERVE_NONE
51510	static bool Interp_StoreUint16(InterpState &S) {
51511	if (!Store<PT_Uint16>(S, S.PC)) return false;
51512	#if USE_TAILCALLS
51513	MUSTTAIL return InterpNext(S);
51514	#else
51515	return true;
51516	#endif
51517	}
51518	PRESERVE_NONE
51519	static bool Interp_StoreSint32(InterpState &S) {
51520	if (!Store<PT_Sint32>(S, S.PC)) return false;
51521	#if USE_TAILCALLS
51522	MUSTTAIL return InterpNext(S);
51523	#else
51524	return true;
51525	#endif
51526	}
51527	PRESERVE_NONE
51528	static bool Interp_StoreUint32(InterpState &S) {
51529	if (!Store<PT_Uint32>(S, S.PC)) return false;
51530	#if USE_TAILCALLS
51531	MUSTTAIL return InterpNext(S);
51532	#else
51533	return true;
51534	#endif
51535	}
51536	PRESERVE_NONE
51537	static bool Interp_StoreSint64(InterpState &S) {
51538	if (!Store<PT_Sint64>(S, S.PC)) return false;
51539	#if USE_TAILCALLS
51540	MUSTTAIL return InterpNext(S);
51541	#else
51542	return true;
51543	#endif
51544	}
51545	PRESERVE_NONE
51546	static bool Interp_StoreUint64(InterpState &S) {
51547	if (!Store<PT_Uint64>(S, S.PC)) return false;
51548	#if USE_TAILCALLS
51549	MUSTTAIL return InterpNext(S);
51550	#else
51551	return true;
51552	#endif
51553	}
51554	PRESERVE_NONE
51555	static bool Interp_StoreIntAP(InterpState &S) {
51556	if (!Store<PT_IntAP>(S, S.PC)) return false;
51557	#if USE_TAILCALLS
51558	MUSTTAIL return InterpNext(S);
51559	#else
51560	return true;
51561	#endif
51562	}
51563	PRESERVE_NONE
51564	static bool Interp_StoreIntAPS(InterpState &S) {
51565	if (!Store<PT_IntAPS>(S, S.PC)) return false;
51566	#if USE_TAILCALLS
51567	MUSTTAIL return InterpNext(S);
51568	#else
51569	return true;
51570	#endif
51571	}
51572	PRESERVE_NONE
51573	static bool Interp_StoreBool(InterpState &S) {
51574	if (!Store<PT_Bool>(S, S.PC)) return false;
51575	#if USE_TAILCALLS
51576	MUSTTAIL return InterpNext(S);
51577	#else
51578	return true;
51579	#endif
51580	}
51581	PRESERVE_NONE
51582	static bool Interp_StoreFixedPoint(InterpState &S) {
51583	if (!Store<PT_FixedPoint>(S, S.PC)) return false;
51584	#if USE_TAILCALLS
51585	MUSTTAIL return InterpNext(S);
51586	#else
51587	return true;
51588	#endif
51589	}
51590	PRESERVE_NONE
51591	static bool Interp_StorePtr(InterpState &S) {
51592	if (!Store<PT_Ptr>(S, S.PC)) return false;
51593	#if USE_TAILCALLS
51594	MUSTTAIL return InterpNext(S);
51595	#else
51596	return true;
51597	#endif
51598	}
51599	PRESERVE_NONE
51600	static bool Interp_StoreMemberPtr(InterpState &S) {
51601	if (!Store<PT_MemberPtr>(S, S.PC)) return false;
51602	#if USE_TAILCALLS
51603	MUSTTAIL return InterpNext(S);
51604	#else
51605	return true;
51606	#endif
51607	}
51608	PRESERVE_NONE
51609	static bool Interp_StoreFloat(InterpState &S) {
51610	if (!Store<PT_Float>(S, S.PC)) return false;
51611	#if USE_TAILCALLS
51612	MUSTTAIL return InterpNext(S);
51613	#else
51614	return true;
51615	#endif
51616	}
51617	#endif
51618	#ifdef GET_DISASM
51619	case OP_StoreSint8:
51620	Text.Op = PrintName("StoreSint8");
51621	break;
51622	case OP_StoreUint8:
51623	Text.Op = PrintName("StoreUint8");
51624	break;
51625	case OP_StoreSint16:
51626	Text.Op = PrintName("StoreSint16");
51627	break;
51628	case OP_StoreUint16:
51629	Text.Op = PrintName("StoreUint16");
51630	break;
51631	case OP_StoreSint32:
51632	Text.Op = PrintName("StoreSint32");
51633	break;
51634	case OP_StoreUint32:
51635	Text.Op = PrintName("StoreUint32");
51636	break;
51637	case OP_StoreSint64:
51638	Text.Op = PrintName("StoreSint64");
51639	break;
51640	case OP_StoreUint64:
51641	Text.Op = PrintName("StoreUint64");
51642	break;
51643	case OP_StoreIntAP:
51644	Text.Op = PrintName("StoreIntAP");
51645	break;
51646	case OP_StoreIntAPS:
51647	Text.Op = PrintName("StoreIntAPS");
51648	break;
51649	case OP_StoreBool:
51650	Text.Op = PrintName("StoreBool");
51651	break;
51652	case OP_StoreFixedPoint:
51653	Text.Op = PrintName("StoreFixedPoint");
51654	break;
51655	case OP_StorePtr:
51656	Text.Op = PrintName("StorePtr");
51657	break;
51658	case OP_StoreMemberPtr:
51659	Text.Op = PrintName("StoreMemberPtr");
51660	break;
51661	case OP_StoreFloat:
51662	Text.Op = PrintName("StoreFloat");
51663	break;
51664	#endif
51665	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51666	bool emitStoreSint8(SourceInfo);
51667	bool emitStoreUint8(SourceInfo);
51668	bool emitStoreSint16(SourceInfo);
51669	bool emitStoreUint16(SourceInfo);
51670	bool emitStoreSint32(SourceInfo);
51671	bool emitStoreUint32(SourceInfo);
51672	bool emitStoreSint64(SourceInfo);
51673	bool emitStoreUint64(SourceInfo);
51674	bool emitStoreIntAP(SourceInfo);
51675	bool emitStoreIntAPS(SourceInfo);
51676	bool emitStoreBool(SourceInfo);
51677	bool emitStoreFixedPoint(SourceInfo);
51678	bool emitStorePtr(SourceInfo);
51679	bool emitStoreMemberPtr(SourceInfo);
51680	bool emitStoreFloat(SourceInfo);
51681	#endif
51682	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
51683	[[nodiscard]] bool emitStore(PrimType, SourceInfo I);
51684	#endif
51685	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
51686	bool
51687	#if defined(GET_EVAL_IMPL)
51688	EvalEmitter
51689	#else
51690	ByteCodeEmitter
51691	#endif
51692	::emitStore(PrimType T0, SourceInfo I) {
51693	switch (T0) {
51694	case PT_Sint8:
51695	return emitStoreSint8(I);
51696	case PT_Uint8:
51697	return emitStoreUint8(I);
51698	case PT_Sint16:
51699	return emitStoreSint16(I);
51700	case PT_Uint16:
51701	return emitStoreUint16(I);
51702	case PT_Sint32:
51703	return emitStoreSint32(I);
51704	case PT_Uint32:
51705	return emitStoreUint32(I);
51706	case PT_Sint64:
51707	return emitStoreSint64(I);
51708	case PT_Uint64:
51709	return emitStoreUint64(I);
51710	case PT_IntAP:
51711	return emitStoreIntAP(I);
51712	case PT_IntAPS:
51713	return emitStoreIntAPS(I);
51714	case PT_Bool:
51715	return emitStoreBool(I);
51716	case PT_FixedPoint:
51717	return emitStoreFixedPoint(I);
51718	case PT_Ptr:
51719	return emitStorePtr(I);
51720	case PT_MemberPtr:
51721	return emitStoreMemberPtr(I);
51722	case PT_Float:
51723	return emitStoreFloat(I);
51724	}
51725	llvm_unreachable("invalid enum value");
51726	}
51727	#endif
51728	#ifdef GET_LINK_IMPL
51729	bool ByteCodeEmitter::emitStoreSint8(SourceInfo L) {
51730	return emitOp<>(OP_StoreSint8, L);
51731	}
51732	bool ByteCodeEmitter::emitStoreUint8(SourceInfo L) {
51733	return emitOp<>(OP_StoreUint8, L);
51734	}
51735	bool ByteCodeEmitter::emitStoreSint16(SourceInfo L) {
51736	return emitOp<>(OP_StoreSint16, L);
51737	}
51738	bool ByteCodeEmitter::emitStoreUint16(SourceInfo L) {
51739	return emitOp<>(OP_StoreUint16, L);
51740	}
51741	bool ByteCodeEmitter::emitStoreSint32(SourceInfo L) {
51742	return emitOp<>(OP_StoreSint32, L);
51743	}
51744	bool ByteCodeEmitter::emitStoreUint32(SourceInfo L) {
51745	return emitOp<>(OP_StoreUint32, L);
51746	}
51747	bool ByteCodeEmitter::emitStoreSint64(SourceInfo L) {
51748	return emitOp<>(OP_StoreSint64, L);
51749	}
51750	bool ByteCodeEmitter::emitStoreUint64(SourceInfo L) {
51751	return emitOp<>(OP_StoreUint64, L);
51752	}
51753	bool ByteCodeEmitter::emitStoreIntAP(SourceInfo L) {
51754	return emitOp<>(OP_StoreIntAP, L);
51755	}
51756	bool ByteCodeEmitter::emitStoreIntAPS(SourceInfo L) {
51757	return emitOp<>(OP_StoreIntAPS, L);
51758	}
51759	bool ByteCodeEmitter::emitStoreBool(SourceInfo L) {
51760	return emitOp<>(OP_StoreBool, L);
51761	}
51762	bool ByteCodeEmitter::emitStoreFixedPoint(SourceInfo L) {
51763	return emitOp<>(OP_StoreFixedPoint, L);
51764	}
51765	bool ByteCodeEmitter::emitStorePtr(SourceInfo L) {
51766	return emitOp<>(OP_StorePtr, L);
51767	}
51768	bool ByteCodeEmitter::emitStoreMemberPtr(SourceInfo L) {
51769	return emitOp<>(OP_StoreMemberPtr, L);
51770	}
51771	bool ByteCodeEmitter::emitStoreFloat(SourceInfo L) {
51772	return emitOp<>(OP_StoreFloat, L);
51773	}
51774	#endif
51775	#ifdef GET_EVAL_IMPL
51776	bool EvalEmitter::emitStoreSint8(SourceInfo L) {
51777	if (!isActive()) return true;
51778	CurrentSource = L;
51779	return Store<PT_Sint8>(S, CodePtr());
51780	}
51781	bool EvalEmitter::emitStoreUint8(SourceInfo L) {
51782	if (!isActive()) return true;
51783	CurrentSource = L;
51784	return Store<PT_Uint8>(S, CodePtr());
51785	}
51786	bool EvalEmitter::emitStoreSint16(SourceInfo L) {
51787	if (!isActive()) return true;
51788	CurrentSource = L;
51789	return Store<PT_Sint16>(S, CodePtr());
51790	}
51791	bool EvalEmitter::emitStoreUint16(SourceInfo L) {
51792	if (!isActive()) return true;
51793	CurrentSource = L;
51794	return Store<PT_Uint16>(S, CodePtr());
51795	}
51796	bool EvalEmitter::emitStoreSint32(SourceInfo L) {
51797	if (!isActive()) return true;
51798	CurrentSource = L;
51799	return Store<PT_Sint32>(S, CodePtr());
51800	}
51801	bool EvalEmitter::emitStoreUint32(SourceInfo L) {
51802	if (!isActive()) return true;
51803	CurrentSource = L;
51804	return Store<PT_Uint32>(S, CodePtr());
51805	}
51806	bool EvalEmitter::emitStoreSint64(SourceInfo L) {
51807	if (!isActive()) return true;
51808	CurrentSource = L;
51809	return Store<PT_Sint64>(S, CodePtr());
51810	}
51811	bool EvalEmitter::emitStoreUint64(SourceInfo L) {
51812	if (!isActive()) return true;
51813	CurrentSource = L;
51814	return Store<PT_Uint64>(S, CodePtr());
51815	}
51816	bool EvalEmitter::emitStoreIntAP(SourceInfo L) {
51817	if (!isActive()) return true;
51818	CurrentSource = L;
51819	return Store<PT_IntAP>(S, CodePtr());
51820	}
51821	bool EvalEmitter::emitStoreIntAPS(SourceInfo L) {
51822	if (!isActive()) return true;
51823	CurrentSource = L;
51824	return Store<PT_IntAPS>(S, CodePtr());
51825	}
51826	bool EvalEmitter::emitStoreBool(SourceInfo L) {
51827	if (!isActive()) return true;
51828	CurrentSource = L;
51829	return Store<PT_Bool>(S, CodePtr());
51830	}
51831	bool EvalEmitter::emitStoreFixedPoint(SourceInfo L) {
51832	if (!isActive()) return true;
51833	CurrentSource = L;
51834	return Store<PT_FixedPoint>(S, CodePtr());
51835	}
51836	bool EvalEmitter::emitStorePtr(SourceInfo L) {
51837	if (!isActive()) return true;
51838	CurrentSource = L;
51839	return Store<PT_Ptr>(S, CodePtr());
51840	}
51841	bool EvalEmitter::emitStoreMemberPtr(SourceInfo L) {
51842	if (!isActive()) return true;
51843	CurrentSource = L;
51844	return Store<PT_MemberPtr>(S, CodePtr());
51845	}
51846	bool EvalEmitter::emitStoreFloat(SourceInfo L) {
51847	if (!isActive()) return true;
51848	CurrentSource = L;
51849	return Store<PT_Float>(S, CodePtr());
51850	}
51851	#endif
51852	#ifdef GET_OPCODE_NAMES
51853	OP_StoreActivateSint8,
51854	OP_StoreActivateUint8,
51855	OP_StoreActivateSint16,
51856	OP_StoreActivateUint16,
51857	OP_StoreActivateSint32,
51858	OP_StoreActivateUint32,
51859	OP_StoreActivateSint64,
51860	OP_StoreActivateUint64,
51861	OP_StoreActivateIntAP,
51862	OP_StoreActivateIntAPS,
51863	OP_StoreActivateBool,
51864	OP_StoreActivateFixedPoint,
51865	OP_StoreActivatePtr,
51866	OP_StoreActivateMemberPtr,
51867	OP_StoreActivateFloat,
51868	#endif
51869	#ifdef GET_INTERPFN_LIST
51870	&Interp_StoreActivateSint8,
51871	&Interp_StoreActivateUint8,
51872	&Interp_StoreActivateSint16,
51873	&Interp_StoreActivateUint16,
51874	&Interp_StoreActivateSint32,
51875	&Interp_StoreActivateUint32,
51876	&Interp_StoreActivateSint64,
51877	&Interp_StoreActivateUint64,
51878	&Interp_StoreActivateIntAP,
51879	&Interp_StoreActivateIntAPS,
51880	&Interp_StoreActivateBool,
51881	&Interp_StoreActivateFixedPoint,
51882	&Interp_StoreActivatePtr,
51883	&Interp_StoreActivateMemberPtr,
51884	&Interp_StoreActivateFloat,
51885	#endif
51886	#ifdef GET_INTERPFN_DISPATCHERS
51887	PRESERVE_NONE
51888	static bool Interp_StoreActivateSint8(InterpState &S) {
51889	if (!StoreActivate<PT_Sint8>(S, S.PC)) return false;
51890	#if USE_TAILCALLS
51891	MUSTTAIL return InterpNext(S);
51892	#else
51893	return true;
51894	#endif
51895	}
51896	PRESERVE_NONE
51897	static bool Interp_StoreActivateUint8(InterpState &S) {
51898	if (!StoreActivate<PT_Uint8>(S, S.PC)) return false;
51899	#if USE_TAILCALLS
51900	MUSTTAIL return InterpNext(S);
51901	#else
51902	return true;
51903	#endif
51904	}
51905	PRESERVE_NONE
51906	static bool Interp_StoreActivateSint16(InterpState &S) {
51907	if (!StoreActivate<PT_Sint16>(S, S.PC)) return false;
51908	#if USE_TAILCALLS
51909	MUSTTAIL return InterpNext(S);
51910	#else
51911	return true;
51912	#endif
51913	}
51914	PRESERVE_NONE
51915	static bool Interp_StoreActivateUint16(InterpState &S) {
51916	if (!StoreActivate<PT_Uint16>(S, S.PC)) return false;
51917	#if USE_TAILCALLS
51918	MUSTTAIL return InterpNext(S);
51919	#else
51920	return true;
51921	#endif
51922	}
51923	PRESERVE_NONE
51924	static bool Interp_StoreActivateSint32(InterpState &S) {
51925	if (!StoreActivate<PT_Sint32>(S, S.PC)) return false;
51926	#if USE_TAILCALLS
51927	MUSTTAIL return InterpNext(S);
51928	#else
51929	return true;
51930	#endif
51931	}
51932	PRESERVE_NONE
51933	static bool Interp_StoreActivateUint32(InterpState &S) {
51934	if (!StoreActivate<PT_Uint32>(S, S.PC)) return false;
51935	#if USE_TAILCALLS
51936	MUSTTAIL return InterpNext(S);
51937	#else
51938	return true;
51939	#endif
51940	}
51941	PRESERVE_NONE
51942	static bool Interp_StoreActivateSint64(InterpState &S) {
51943	if (!StoreActivate<PT_Sint64>(S, S.PC)) return false;
51944	#if USE_TAILCALLS
51945	MUSTTAIL return InterpNext(S);
51946	#else
51947	return true;
51948	#endif
51949	}
51950	PRESERVE_NONE
51951	static bool Interp_StoreActivateUint64(InterpState &S) {
51952	if (!StoreActivate<PT_Uint64>(S, S.PC)) return false;
51953	#if USE_TAILCALLS
51954	MUSTTAIL return InterpNext(S);
51955	#else
51956	return true;
51957	#endif
51958	}
51959	PRESERVE_NONE
51960	static bool Interp_StoreActivateIntAP(InterpState &S) {
51961	if (!StoreActivate<PT_IntAP>(S, S.PC)) return false;
51962	#if USE_TAILCALLS
51963	MUSTTAIL return InterpNext(S);
51964	#else
51965	return true;
51966	#endif
51967	}
51968	PRESERVE_NONE
51969	static bool Interp_StoreActivateIntAPS(InterpState &S) {
51970	if (!StoreActivate<PT_IntAPS>(S, S.PC)) return false;
51971	#if USE_TAILCALLS
51972	MUSTTAIL return InterpNext(S);
51973	#else
51974	return true;
51975	#endif
51976	}
51977	PRESERVE_NONE
51978	static bool Interp_StoreActivateBool(InterpState &S) {
51979	if (!StoreActivate<PT_Bool>(S, S.PC)) return false;
51980	#if USE_TAILCALLS
51981	MUSTTAIL return InterpNext(S);
51982	#else
51983	return true;
51984	#endif
51985	}
51986	PRESERVE_NONE
51987	static bool Interp_StoreActivateFixedPoint(InterpState &S) {
51988	if (!StoreActivate<PT_FixedPoint>(S, S.PC)) return false;
51989	#if USE_TAILCALLS
51990	MUSTTAIL return InterpNext(S);
51991	#else
51992	return true;
51993	#endif
51994	}
51995	PRESERVE_NONE
51996	static bool Interp_StoreActivatePtr(InterpState &S) {
51997	if (!StoreActivate<PT_Ptr>(S, S.PC)) return false;
51998	#if USE_TAILCALLS
51999	MUSTTAIL return InterpNext(S);
52000	#else
52001	return true;
52002	#endif
52003	}
52004	PRESERVE_NONE
52005	static bool Interp_StoreActivateMemberPtr(InterpState &S) {
52006	if (!StoreActivate<PT_MemberPtr>(S, S.PC)) return false;
52007	#if USE_TAILCALLS
52008	MUSTTAIL return InterpNext(S);
52009	#else
52010	return true;
52011	#endif
52012	}
52013	PRESERVE_NONE
52014	static bool Interp_StoreActivateFloat(InterpState &S) {
52015	if (!StoreActivate<PT_Float>(S, S.PC)) return false;
52016	#if USE_TAILCALLS
52017	MUSTTAIL return InterpNext(S);
52018	#else
52019	return true;
52020	#endif
52021	}
52022	#endif
52023	#ifdef GET_DISASM
52024	case OP_StoreActivateSint8:
52025	Text.Op = PrintName("StoreActivateSint8");
52026	break;
52027	case OP_StoreActivateUint8:
52028	Text.Op = PrintName("StoreActivateUint8");
52029	break;
52030	case OP_StoreActivateSint16:
52031	Text.Op = PrintName("StoreActivateSint16");
52032	break;
52033	case OP_StoreActivateUint16:
52034	Text.Op = PrintName("StoreActivateUint16");
52035	break;
52036	case OP_StoreActivateSint32:
52037	Text.Op = PrintName("StoreActivateSint32");
52038	break;
52039	case OP_StoreActivateUint32:
52040	Text.Op = PrintName("StoreActivateUint32");
52041	break;
52042	case OP_StoreActivateSint64:
52043	Text.Op = PrintName("StoreActivateSint64");
52044	break;
52045	case OP_StoreActivateUint64:
52046	Text.Op = PrintName("StoreActivateUint64");
52047	break;
52048	case OP_StoreActivateIntAP:
52049	Text.Op = PrintName("StoreActivateIntAP");
52050	break;
52051	case OP_StoreActivateIntAPS:
52052	Text.Op = PrintName("StoreActivateIntAPS");
52053	break;
52054	case OP_StoreActivateBool:
52055	Text.Op = PrintName("StoreActivateBool");
52056	break;
52057	case OP_StoreActivateFixedPoint:
52058	Text.Op = PrintName("StoreActivateFixedPoint");
52059	break;
52060	case OP_StoreActivatePtr:
52061	Text.Op = PrintName("StoreActivatePtr");
52062	break;
52063	case OP_StoreActivateMemberPtr:
52064	Text.Op = PrintName("StoreActivateMemberPtr");
52065	break;
52066	case OP_StoreActivateFloat:
52067	Text.Op = PrintName("StoreActivateFloat");
52068	break;
52069	#endif
52070	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52071	bool emitStoreActivateSint8(SourceInfo);
52072	bool emitStoreActivateUint8(SourceInfo);
52073	bool emitStoreActivateSint16(SourceInfo);
52074	bool emitStoreActivateUint16(SourceInfo);
52075	bool emitStoreActivateSint32(SourceInfo);
52076	bool emitStoreActivateUint32(SourceInfo);
52077	bool emitStoreActivateSint64(SourceInfo);
52078	bool emitStoreActivateUint64(SourceInfo);
52079	bool emitStoreActivateIntAP(SourceInfo);
52080	bool emitStoreActivateIntAPS(SourceInfo);
52081	bool emitStoreActivateBool(SourceInfo);
52082	bool emitStoreActivateFixedPoint(SourceInfo);
52083	bool emitStoreActivatePtr(SourceInfo);
52084	bool emitStoreActivateMemberPtr(SourceInfo);
52085	bool emitStoreActivateFloat(SourceInfo);
52086	#endif
52087	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52088	[[nodiscard]] bool emitStoreActivate(PrimType, SourceInfo I);
52089	#endif
52090	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
52091	bool
52092	#if defined(GET_EVAL_IMPL)
52093	EvalEmitter
52094	#else
52095	ByteCodeEmitter
52096	#endif
52097	::emitStoreActivate(PrimType T0, SourceInfo I) {
52098	switch (T0) {
52099	case PT_Sint8:
52100	return emitStoreActivateSint8(I);
52101	case PT_Uint8:
52102	return emitStoreActivateUint8(I);
52103	case PT_Sint16:
52104	return emitStoreActivateSint16(I);
52105	case PT_Uint16:
52106	return emitStoreActivateUint16(I);
52107	case PT_Sint32:
52108	return emitStoreActivateSint32(I);
52109	case PT_Uint32:
52110	return emitStoreActivateUint32(I);
52111	case PT_Sint64:
52112	return emitStoreActivateSint64(I);
52113	case PT_Uint64:
52114	return emitStoreActivateUint64(I);
52115	case PT_IntAP:
52116	return emitStoreActivateIntAP(I);
52117	case PT_IntAPS:
52118	return emitStoreActivateIntAPS(I);
52119	case PT_Bool:
52120	return emitStoreActivateBool(I);
52121	case PT_FixedPoint:
52122	return emitStoreActivateFixedPoint(I);
52123	case PT_Ptr:
52124	return emitStoreActivatePtr(I);
52125	case PT_MemberPtr:
52126	return emitStoreActivateMemberPtr(I);
52127	case PT_Float:
52128	return emitStoreActivateFloat(I);
52129	}
52130	llvm_unreachable("invalid enum value");
52131	}
52132	#endif
52133	#ifdef GET_LINK_IMPL
52134	bool ByteCodeEmitter::emitStoreActivateSint8(SourceInfo L) {
52135	return emitOp<>(OP_StoreActivateSint8, L);
52136	}
52137	bool ByteCodeEmitter::emitStoreActivateUint8(SourceInfo L) {
52138	return emitOp<>(OP_StoreActivateUint8, L);
52139	}
52140	bool ByteCodeEmitter::emitStoreActivateSint16(SourceInfo L) {
52141	return emitOp<>(OP_StoreActivateSint16, L);
52142	}
52143	bool ByteCodeEmitter::emitStoreActivateUint16(SourceInfo L) {
52144	return emitOp<>(OP_StoreActivateUint16, L);
52145	}
52146	bool ByteCodeEmitter::emitStoreActivateSint32(SourceInfo L) {
52147	return emitOp<>(OP_StoreActivateSint32, L);
52148	}
52149	bool ByteCodeEmitter::emitStoreActivateUint32(SourceInfo L) {
52150	return emitOp<>(OP_StoreActivateUint32, L);
52151	}
52152	bool ByteCodeEmitter::emitStoreActivateSint64(SourceInfo L) {
52153	return emitOp<>(OP_StoreActivateSint64, L);
52154	}
52155	bool ByteCodeEmitter::emitStoreActivateUint64(SourceInfo L) {
52156	return emitOp<>(OP_StoreActivateUint64, L);
52157	}
52158	bool ByteCodeEmitter::emitStoreActivateIntAP(SourceInfo L) {
52159	return emitOp<>(OP_StoreActivateIntAP, L);
52160	}
52161	bool ByteCodeEmitter::emitStoreActivateIntAPS(SourceInfo L) {
52162	return emitOp<>(OP_StoreActivateIntAPS, L);
52163	}
52164	bool ByteCodeEmitter::emitStoreActivateBool(SourceInfo L) {
52165	return emitOp<>(OP_StoreActivateBool, L);
52166	}
52167	bool ByteCodeEmitter::emitStoreActivateFixedPoint(SourceInfo L) {
52168	return emitOp<>(OP_StoreActivateFixedPoint, L);
52169	}
52170	bool ByteCodeEmitter::emitStoreActivatePtr(SourceInfo L) {
52171	return emitOp<>(OP_StoreActivatePtr, L);
52172	}
52173	bool ByteCodeEmitter::emitStoreActivateMemberPtr(SourceInfo L) {
52174	return emitOp<>(OP_StoreActivateMemberPtr, L);
52175	}
52176	bool ByteCodeEmitter::emitStoreActivateFloat(SourceInfo L) {
52177	return emitOp<>(OP_StoreActivateFloat, L);
52178	}
52179	#endif
52180	#ifdef GET_EVAL_IMPL
52181	bool EvalEmitter::emitStoreActivateSint8(SourceInfo L) {
52182	if (!isActive()) return true;
52183	CurrentSource = L;
52184	return StoreActivate<PT_Sint8>(S, CodePtr());
52185	}
52186	bool EvalEmitter::emitStoreActivateUint8(SourceInfo L) {
52187	if (!isActive()) return true;
52188	CurrentSource = L;
52189	return StoreActivate<PT_Uint8>(S, CodePtr());
52190	}
52191	bool EvalEmitter::emitStoreActivateSint16(SourceInfo L) {
52192	if (!isActive()) return true;
52193	CurrentSource = L;
52194	return StoreActivate<PT_Sint16>(S, CodePtr());
52195	}
52196	bool EvalEmitter::emitStoreActivateUint16(SourceInfo L) {
52197	if (!isActive()) return true;
52198	CurrentSource = L;
52199	return StoreActivate<PT_Uint16>(S, CodePtr());
52200	}
52201	bool EvalEmitter::emitStoreActivateSint32(SourceInfo L) {
52202	if (!isActive()) return true;
52203	CurrentSource = L;
52204	return StoreActivate<PT_Sint32>(S, CodePtr());
52205	}
52206	bool EvalEmitter::emitStoreActivateUint32(SourceInfo L) {
52207	if (!isActive()) return true;
52208	CurrentSource = L;
52209	return StoreActivate<PT_Uint32>(S, CodePtr());
52210	}
52211	bool EvalEmitter::emitStoreActivateSint64(SourceInfo L) {
52212	if (!isActive()) return true;
52213	CurrentSource = L;
52214	return StoreActivate<PT_Sint64>(S, CodePtr());
52215	}
52216	bool EvalEmitter::emitStoreActivateUint64(SourceInfo L) {
52217	if (!isActive()) return true;
52218	CurrentSource = L;
52219	return StoreActivate<PT_Uint64>(S, CodePtr());
52220	}
52221	bool EvalEmitter::emitStoreActivateIntAP(SourceInfo L) {
52222	if (!isActive()) return true;
52223	CurrentSource = L;
52224	return StoreActivate<PT_IntAP>(S, CodePtr());
52225	}
52226	bool EvalEmitter::emitStoreActivateIntAPS(SourceInfo L) {
52227	if (!isActive()) return true;
52228	CurrentSource = L;
52229	return StoreActivate<PT_IntAPS>(S, CodePtr());
52230	}
52231	bool EvalEmitter::emitStoreActivateBool(SourceInfo L) {
52232	if (!isActive()) return true;
52233	CurrentSource = L;
52234	return StoreActivate<PT_Bool>(S, CodePtr());
52235	}
52236	bool EvalEmitter::emitStoreActivateFixedPoint(SourceInfo L) {
52237	if (!isActive()) return true;
52238	CurrentSource = L;
52239	return StoreActivate<PT_FixedPoint>(S, CodePtr());
52240	}
52241	bool EvalEmitter::emitStoreActivatePtr(SourceInfo L) {
52242	if (!isActive()) return true;
52243	CurrentSource = L;
52244	return StoreActivate<PT_Ptr>(S, CodePtr());
52245	}
52246	bool EvalEmitter::emitStoreActivateMemberPtr(SourceInfo L) {
52247	if (!isActive()) return true;
52248	CurrentSource = L;
52249	return StoreActivate<PT_MemberPtr>(S, CodePtr());
52250	}
52251	bool EvalEmitter::emitStoreActivateFloat(SourceInfo L) {
52252	if (!isActive()) return true;
52253	CurrentSource = L;
52254	return StoreActivate<PT_Float>(S, CodePtr());
52255	}
52256	#endif
52257	#ifdef GET_OPCODE_NAMES
52258	OP_StoreActivatePopSint8,
52259	OP_StoreActivatePopUint8,
52260	OP_StoreActivatePopSint16,
52261	OP_StoreActivatePopUint16,
52262	OP_StoreActivatePopSint32,
52263	OP_StoreActivatePopUint32,
52264	OP_StoreActivatePopSint64,
52265	OP_StoreActivatePopUint64,
52266	OP_StoreActivatePopIntAP,
52267	OP_StoreActivatePopIntAPS,
52268	OP_StoreActivatePopBool,
52269	OP_StoreActivatePopFixedPoint,
52270	OP_StoreActivatePopPtr,
52271	OP_StoreActivatePopMemberPtr,
52272	OP_StoreActivatePopFloat,
52273	#endif
52274	#ifdef GET_INTERPFN_LIST
52275	&Interp_StoreActivatePopSint8,
52276	&Interp_StoreActivatePopUint8,
52277	&Interp_StoreActivatePopSint16,
52278	&Interp_StoreActivatePopUint16,
52279	&Interp_StoreActivatePopSint32,
52280	&Interp_StoreActivatePopUint32,
52281	&Interp_StoreActivatePopSint64,
52282	&Interp_StoreActivatePopUint64,
52283	&Interp_StoreActivatePopIntAP,
52284	&Interp_StoreActivatePopIntAPS,
52285	&Interp_StoreActivatePopBool,
52286	&Interp_StoreActivatePopFixedPoint,
52287	&Interp_StoreActivatePopPtr,
52288	&Interp_StoreActivatePopMemberPtr,
52289	&Interp_StoreActivatePopFloat,
52290	#endif
52291	#ifdef GET_INTERPFN_DISPATCHERS
52292	PRESERVE_NONE
52293	static bool Interp_StoreActivatePopSint8(InterpState &S) {
52294	if (!StoreActivatePop<PT_Sint8>(S, S.PC)) return false;
52295	#if USE_TAILCALLS
52296	MUSTTAIL return InterpNext(S);
52297	#else
52298	return true;
52299	#endif
52300	}
52301	PRESERVE_NONE
52302	static bool Interp_StoreActivatePopUint8(InterpState &S) {
52303	if (!StoreActivatePop<PT_Uint8>(S, S.PC)) return false;
52304	#if USE_TAILCALLS
52305	MUSTTAIL return InterpNext(S);
52306	#else
52307	return true;
52308	#endif
52309	}
52310	PRESERVE_NONE
52311	static bool Interp_StoreActivatePopSint16(InterpState &S) {
52312	if (!StoreActivatePop<PT_Sint16>(S, S.PC)) return false;
52313	#if USE_TAILCALLS
52314	MUSTTAIL return InterpNext(S);
52315	#else
52316	return true;
52317	#endif
52318	}
52319	PRESERVE_NONE
52320	static bool Interp_StoreActivatePopUint16(InterpState &S) {
52321	if (!StoreActivatePop<PT_Uint16>(S, S.PC)) return false;
52322	#if USE_TAILCALLS
52323	MUSTTAIL return InterpNext(S);
52324	#else
52325	return true;
52326	#endif
52327	}
52328	PRESERVE_NONE
52329	static bool Interp_StoreActivatePopSint32(InterpState &S) {
52330	if (!StoreActivatePop<PT_Sint32>(S, S.PC)) return false;
52331	#if USE_TAILCALLS
52332	MUSTTAIL return InterpNext(S);
52333	#else
52334	return true;
52335	#endif
52336	}
52337	PRESERVE_NONE
52338	static bool Interp_StoreActivatePopUint32(InterpState &S) {
52339	if (!StoreActivatePop<PT_Uint32>(S, S.PC)) return false;
52340	#if USE_TAILCALLS
52341	MUSTTAIL return InterpNext(S);
52342	#else
52343	return true;
52344	#endif
52345	}
52346	PRESERVE_NONE
52347	static bool Interp_StoreActivatePopSint64(InterpState &S) {
52348	if (!StoreActivatePop<PT_Sint64>(S, S.PC)) return false;
52349	#if USE_TAILCALLS
52350	MUSTTAIL return InterpNext(S);
52351	#else
52352	return true;
52353	#endif
52354	}
52355	PRESERVE_NONE
52356	static bool Interp_StoreActivatePopUint64(InterpState &S) {
52357	if (!StoreActivatePop<PT_Uint64>(S, S.PC)) return false;
52358	#if USE_TAILCALLS
52359	MUSTTAIL return InterpNext(S);
52360	#else
52361	return true;
52362	#endif
52363	}
52364	PRESERVE_NONE
52365	static bool Interp_StoreActivatePopIntAP(InterpState &S) {
52366	if (!StoreActivatePop<PT_IntAP>(S, S.PC)) return false;
52367	#if USE_TAILCALLS
52368	MUSTTAIL return InterpNext(S);
52369	#else
52370	return true;
52371	#endif
52372	}
52373	PRESERVE_NONE
52374	static bool Interp_StoreActivatePopIntAPS(InterpState &S) {
52375	if (!StoreActivatePop<PT_IntAPS>(S, S.PC)) return false;
52376	#if USE_TAILCALLS
52377	MUSTTAIL return InterpNext(S);
52378	#else
52379	return true;
52380	#endif
52381	}
52382	PRESERVE_NONE
52383	static bool Interp_StoreActivatePopBool(InterpState &S) {
52384	if (!StoreActivatePop<PT_Bool>(S, S.PC)) return false;
52385	#if USE_TAILCALLS
52386	MUSTTAIL return InterpNext(S);
52387	#else
52388	return true;
52389	#endif
52390	}
52391	PRESERVE_NONE
52392	static bool Interp_StoreActivatePopFixedPoint(InterpState &S) {
52393	if (!StoreActivatePop<PT_FixedPoint>(S, S.PC)) return false;
52394	#if USE_TAILCALLS
52395	MUSTTAIL return InterpNext(S);
52396	#else
52397	return true;
52398	#endif
52399	}
52400	PRESERVE_NONE
52401	static bool Interp_StoreActivatePopPtr(InterpState &S) {
52402	if (!StoreActivatePop<PT_Ptr>(S, S.PC)) return false;
52403	#if USE_TAILCALLS
52404	MUSTTAIL return InterpNext(S);
52405	#else
52406	return true;
52407	#endif
52408	}
52409	PRESERVE_NONE
52410	static bool Interp_StoreActivatePopMemberPtr(InterpState &S) {
52411	if (!StoreActivatePop<PT_MemberPtr>(S, S.PC)) return false;
52412	#if USE_TAILCALLS
52413	MUSTTAIL return InterpNext(S);
52414	#else
52415	return true;
52416	#endif
52417	}
52418	PRESERVE_NONE
52419	static bool Interp_StoreActivatePopFloat(InterpState &S) {
52420	if (!StoreActivatePop<PT_Float>(S, S.PC)) return false;
52421	#if USE_TAILCALLS
52422	MUSTTAIL return InterpNext(S);
52423	#else
52424	return true;
52425	#endif
52426	}
52427	#endif
52428	#ifdef GET_DISASM
52429	case OP_StoreActivatePopSint8:
52430	Text.Op = PrintName("StoreActivatePopSint8");
52431	break;
52432	case OP_StoreActivatePopUint8:
52433	Text.Op = PrintName("StoreActivatePopUint8");
52434	break;
52435	case OP_StoreActivatePopSint16:
52436	Text.Op = PrintName("StoreActivatePopSint16");
52437	break;
52438	case OP_StoreActivatePopUint16:
52439	Text.Op = PrintName("StoreActivatePopUint16");
52440	break;
52441	case OP_StoreActivatePopSint32:
52442	Text.Op = PrintName("StoreActivatePopSint32");
52443	break;
52444	case OP_StoreActivatePopUint32:
52445	Text.Op = PrintName("StoreActivatePopUint32");
52446	break;
52447	case OP_StoreActivatePopSint64:
52448	Text.Op = PrintName("StoreActivatePopSint64");
52449	break;
52450	case OP_StoreActivatePopUint64:
52451	Text.Op = PrintName("StoreActivatePopUint64");
52452	break;
52453	case OP_StoreActivatePopIntAP:
52454	Text.Op = PrintName("StoreActivatePopIntAP");
52455	break;
52456	case OP_StoreActivatePopIntAPS:
52457	Text.Op = PrintName("StoreActivatePopIntAPS");
52458	break;
52459	case OP_StoreActivatePopBool:
52460	Text.Op = PrintName("StoreActivatePopBool");
52461	break;
52462	case OP_StoreActivatePopFixedPoint:
52463	Text.Op = PrintName("StoreActivatePopFixedPoint");
52464	break;
52465	case OP_StoreActivatePopPtr:
52466	Text.Op = PrintName("StoreActivatePopPtr");
52467	break;
52468	case OP_StoreActivatePopMemberPtr:
52469	Text.Op = PrintName("StoreActivatePopMemberPtr");
52470	break;
52471	case OP_StoreActivatePopFloat:
52472	Text.Op = PrintName("StoreActivatePopFloat");
52473	break;
52474	#endif
52475	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52476	bool emitStoreActivatePopSint8(SourceInfo);
52477	bool emitStoreActivatePopUint8(SourceInfo);
52478	bool emitStoreActivatePopSint16(SourceInfo);
52479	bool emitStoreActivatePopUint16(SourceInfo);
52480	bool emitStoreActivatePopSint32(SourceInfo);
52481	bool emitStoreActivatePopUint32(SourceInfo);
52482	bool emitStoreActivatePopSint64(SourceInfo);
52483	bool emitStoreActivatePopUint64(SourceInfo);
52484	bool emitStoreActivatePopIntAP(SourceInfo);
52485	bool emitStoreActivatePopIntAPS(SourceInfo);
52486	bool emitStoreActivatePopBool(SourceInfo);
52487	bool emitStoreActivatePopFixedPoint(SourceInfo);
52488	bool emitStoreActivatePopPtr(SourceInfo);
52489	bool emitStoreActivatePopMemberPtr(SourceInfo);
52490	bool emitStoreActivatePopFloat(SourceInfo);
52491	#endif
52492	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52493	[[nodiscard]] bool emitStoreActivatePop(PrimType, SourceInfo I);
52494	#endif
52495	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
52496	bool
52497	#if defined(GET_EVAL_IMPL)
52498	EvalEmitter
52499	#else
52500	ByteCodeEmitter
52501	#endif
52502	::emitStoreActivatePop(PrimType T0, SourceInfo I) {
52503	switch (T0) {
52504	case PT_Sint8:
52505	return emitStoreActivatePopSint8(I);
52506	case PT_Uint8:
52507	return emitStoreActivatePopUint8(I);
52508	case PT_Sint16:
52509	return emitStoreActivatePopSint16(I);
52510	case PT_Uint16:
52511	return emitStoreActivatePopUint16(I);
52512	case PT_Sint32:
52513	return emitStoreActivatePopSint32(I);
52514	case PT_Uint32:
52515	return emitStoreActivatePopUint32(I);
52516	case PT_Sint64:
52517	return emitStoreActivatePopSint64(I);
52518	case PT_Uint64:
52519	return emitStoreActivatePopUint64(I);
52520	case PT_IntAP:
52521	return emitStoreActivatePopIntAP(I);
52522	case PT_IntAPS:
52523	return emitStoreActivatePopIntAPS(I);
52524	case PT_Bool:
52525	return emitStoreActivatePopBool(I);
52526	case PT_FixedPoint:
52527	return emitStoreActivatePopFixedPoint(I);
52528	case PT_Ptr:
52529	return emitStoreActivatePopPtr(I);
52530	case PT_MemberPtr:
52531	return emitStoreActivatePopMemberPtr(I);
52532	case PT_Float:
52533	return emitStoreActivatePopFloat(I);
52534	}
52535	llvm_unreachable("invalid enum value");
52536	}
52537	#endif
52538	#ifdef GET_LINK_IMPL
52539	bool ByteCodeEmitter::emitStoreActivatePopSint8(SourceInfo L) {
52540	return emitOp<>(OP_StoreActivatePopSint8, L);
52541	}
52542	bool ByteCodeEmitter::emitStoreActivatePopUint8(SourceInfo L) {
52543	return emitOp<>(OP_StoreActivatePopUint8, L);
52544	}
52545	bool ByteCodeEmitter::emitStoreActivatePopSint16(SourceInfo L) {
52546	return emitOp<>(OP_StoreActivatePopSint16, L);
52547	}
52548	bool ByteCodeEmitter::emitStoreActivatePopUint16(SourceInfo L) {
52549	return emitOp<>(OP_StoreActivatePopUint16, L);
52550	}
52551	bool ByteCodeEmitter::emitStoreActivatePopSint32(SourceInfo L) {
52552	return emitOp<>(OP_StoreActivatePopSint32, L);
52553	}
52554	bool ByteCodeEmitter::emitStoreActivatePopUint32(SourceInfo L) {
52555	return emitOp<>(OP_StoreActivatePopUint32, L);
52556	}
52557	bool ByteCodeEmitter::emitStoreActivatePopSint64(SourceInfo L) {
52558	return emitOp<>(OP_StoreActivatePopSint64, L);
52559	}
52560	bool ByteCodeEmitter::emitStoreActivatePopUint64(SourceInfo L) {
52561	return emitOp<>(OP_StoreActivatePopUint64, L);
52562	}
52563	bool ByteCodeEmitter::emitStoreActivatePopIntAP(SourceInfo L) {
52564	return emitOp<>(OP_StoreActivatePopIntAP, L);
52565	}
52566	bool ByteCodeEmitter::emitStoreActivatePopIntAPS(SourceInfo L) {
52567	return emitOp<>(OP_StoreActivatePopIntAPS, L);
52568	}
52569	bool ByteCodeEmitter::emitStoreActivatePopBool(SourceInfo L) {
52570	return emitOp<>(OP_StoreActivatePopBool, L);
52571	}
52572	bool ByteCodeEmitter::emitStoreActivatePopFixedPoint(SourceInfo L) {
52573	return emitOp<>(OP_StoreActivatePopFixedPoint, L);
52574	}
52575	bool ByteCodeEmitter::emitStoreActivatePopPtr(SourceInfo L) {
52576	return emitOp<>(OP_StoreActivatePopPtr, L);
52577	}
52578	bool ByteCodeEmitter::emitStoreActivatePopMemberPtr(SourceInfo L) {
52579	return emitOp<>(OP_StoreActivatePopMemberPtr, L);
52580	}
52581	bool ByteCodeEmitter::emitStoreActivatePopFloat(SourceInfo L) {
52582	return emitOp<>(OP_StoreActivatePopFloat, L);
52583	}
52584	#endif
52585	#ifdef GET_EVAL_IMPL
52586	bool EvalEmitter::emitStoreActivatePopSint8(SourceInfo L) {
52587	if (!isActive()) return true;
52588	CurrentSource = L;
52589	return StoreActivatePop<PT_Sint8>(S, CodePtr());
52590	}
52591	bool EvalEmitter::emitStoreActivatePopUint8(SourceInfo L) {
52592	if (!isActive()) return true;
52593	CurrentSource = L;
52594	return StoreActivatePop<PT_Uint8>(S, CodePtr());
52595	}
52596	bool EvalEmitter::emitStoreActivatePopSint16(SourceInfo L) {
52597	if (!isActive()) return true;
52598	CurrentSource = L;
52599	return StoreActivatePop<PT_Sint16>(S, CodePtr());
52600	}
52601	bool EvalEmitter::emitStoreActivatePopUint16(SourceInfo L) {
52602	if (!isActive()) return true;
52603	CurrentSource = L;
52604	return StoreActivatePop<PT_Uint16>(S, CodePtr());
52605	}
52606	bool EvalEmitter::emitStoreActivatePopSint32(SourceInfo L) {
52607	if (!isActive()) return true;
52608	CurrentSource = L;
52609	return StoreActivatePop<PT_Sint32>(S, CodePtr());
52610	}
52611	bool EvalEmitter::emitStoreActivatePopUint32(SourceInfo L) {
52612	if (!isActive()) return true;
52613	CurrentSource = L;
52614	return StoreActivatePop<PT_Uint32>(S, CodePtr());
52615	}
52616	bool EvalEmitter::emitStoreActivatePopSint64(SourceInfo L) {
52617	if (!isActive()) return true;
52618	CurrentSource = L;
52619	return StoreActivatePop<PT_Sint64>(S, CodePtr());
52620	}
52621	bool EvalEmitter::emitStoreActivatePopUint64(SourceInfo L) {
52622	if (!isActive()) return true;
52623	CurrentSource = L;
52624	return StoreActivatePop<PT_Uint64>(S, CodePtr());
52625	}
52626	bool EvalEmitter::emitStoreActivatePopIntAP(SourceInfo L) {
52627	if (!isActive()) return true;
52628	CurrentSource = L;
52629	return StoreActivatePop<PT_IntAP>(S, CodePtr());
52630	}
52631	bool EvalEmitter::emitStoreActivatePopIntAPS(SourceInfo L) {
52632	if (!isActive()) return true;
52633	CurrentSource = L;
52634	return StoreActivatePop<PT_IntAPS>(S, CodePtr());
52635	}
52636	bool EvalEmitter::emitStoreActivatePopBool(SourceInfo L) {
52637	if (!isActive()) return true;
52638	CurrentSource = L;
52639	return StoreActivatePop<PT_Bool>(S, CodePtr());
52640	}
52641	bool EvalEmitter::emitStoreActivatePopFixedPoint(SourceInfo L) {
52642	if (!isActive()) return true;
52643	CurrentSource = L;
52644	return StoreActivatePop<PT_FixedPoint>(S, CodePtr());
52645	}
52646	bool EvalEmitter::emitStoreActivatePopPtr(SourceInfo L) {
52647	if (!isActive()) return true;
52648	CurrentSource = L;
52649	return StoreActivatePop<PT_Ptr>(S, CodePtr());
52650	}
52651	bool EvalEmitter::emitStoreActivatePopMemberPtr(SourceInfo L) {
52652	if (!isActive()) return true;
52653	CurrentSource = L;
52654	return StoreActivatePop<PT_MemberPtr>(S, CodePtr());
52655	}
52656	bool EvalEmitter::emitStoreActivatePopFloat(SourceInfo L) {
52657	if (!isActive()) return true;
52658	CurrentSource = L;
52659	return StoreActivatePop<PT_Float>(S, CodePtr());
52660	}
52661	#endif
52662	#ifdef GET_OPCODE_NAMES
52663	OP_StoreBitFieldSint8,
52664	OP_StoreBitFieldUint8,
52665	OP_StoreBitFieldSint16,
52666	OP_StoreBitFieldUint16,
52667	OP_StoreBitFieldSint32,
52668	OP_StoreBitFieldUint32,
52669	OP_StoreBitFieldSint64,
52670	OP_StoreBitFieldUint64,
52671	OP_StoreBitFieldIntAP,
52672	OP_StoreBitFieldIntAPS,
52673	OP_StoreBitFieldBool,
52674	OP_StoreBitFieldFixedPoint,
52675	#endif
52676	#ifdef GET_INTERPFN_LIST
52677	&Interp_StoreBitFieldSint8,
52678	&Interp_StoreBitFieldUint8,
52679	&Interp_StoreBitFieldSint16,
52680	&Interp_StoreBitFieldUint16,
52681	&Interp_StoreBitFieldSint32,
52682	&Interp_StoreBitFieldUint32,
52683	&Interp_StoreBitFieldSint64,
52684	&Interp_StoreBitFieldUint64,
52685	&Interp_StoreBitFieldIntAP,
52686	&Interp_StoreBitFieldIntAPS,
52687	&Interp_StoreBitFieldBool,
52688	&Interp_StoreBitFieldFixedPoint,
52689	#endif
52690	#ifdef GET_INTERPFN_DISPATCHERS
52691	PRESERVE_NONE
52692	static bool Interp_StoreBitFieldSint8(InterpState &S) {
52693	if (!StoreBitField<PT_Sint8>(S, S.PC)) return false;
52694	#if USE_TAILCALLS
52695	MUSTTAIL return InterpNext(S);
52696	#else
52697	return true;
52698	#endif
52699	}
52700	PRESERVE_NONE
52701	static bool Interp_StoreBitFieldUint8(InterpState &S) {
52702	if (!StoreBitField<PT_Uint8>(S, S.PC)) return false;
52703	#if USE_TAILCALLS
52704	MUSTTAIL return InterpNext(S);
52705	#else
52706	return true;
52707	#endif
52708	}
52709	PRESERVE_NONE
52710	static bool Interp_StoreBitFieldSint16(InterpState &S) {
52711	if (!StoreBitField<PT_Sint16>(S, S.PC)) return false;
52712	#if USE_TAILCALLS
52713	MUSTTAIL return InterpNext(S);
52714	#else
52715	return true;
52716	#endif
52717	}
52718	PRESERVE_NONE
52719	static bool Interp_StoreBitFieldUint16(InterpState &S) {
52720	if (!StoreBitField<PT_Uint16>(S, S.PC)) return false;
52721	#if USE_TAILCALLS
52722	MUSTTAIL return InterpNext(S);
52723	#else
52724	return true;
52725	#endif
52726	}
52727	PRESERVE_NONE
52728	static bool Interp_StoreBitFieldSint32(InterpState &S) {
52729	if (!StoreBitField<PT_Sint32>(S, S.PC)) return false;
52730	#if USE_TAILCALLS
52731	MUSTTAIL return InterpNext(S);
52732	#else
52733	return true;
52734	#endif
52735	}
52736	PRESERVE_NONE
52737	static bool Interp_StoreBitFieldUint32(InterpState &S) {
52738	if (!StoreBitField<PT_Uint32>(S, S.PC)) return false;
52739	#if USE_TAILCALLS
52740	MUSTTAIL return InterpNext(S);
52741	#else
52742	return true;
52743	#endif
52744	}
52745	PRESERVE_NONE
52746	static bool Interp_StoreBitFieldSint64(InterpState &S) {
52747	if (!StoreBitField<PT_Sint64>(S, S.PC)) return false;
52748	#if USE_TAILCALLS
52749	MUSTTAIL return InterpNext(S);
52750	#else
52751	return true;
52752	#endif
52753	}
52754	PRESERVE_NONE
52755	static bool Interp_StoreBitFieldUint64(InterpState &S) {
52756	if (!StoreBitField<PT_Uint64>(S, S.PC)) return false;
52757	#if USE_TAILCALLS
52758	MUSTTAIL return InterpNext(S);
52759	#else
52760	return true;
52761	#endif
52762	}
52763	PRESERVE_NONE
52764	static bool Interp_StoreBitFieldIntAP(InterpState &S) {
52765	if (!StoreBitField<PT_IntAP>(S, S.PC)) return false;
52766	#if USE_TAILCALLS
52767	MUSTTAIL return InterpNext(S);
52768	#else
52769	return true;
52770	#endif
52771	}
52772	PRESERVE_NONE
52773	static bool Interp_StoreBitFieldIntAPS(InterpState &S) {
52774	if (!StoreBitField<PT_IntAPS>(S, S.PC)) return false;
52775	#if USE_TAILCALLS
52776	MUSTTAIL return InterpNext(S);
52777	#else
52778	return true;
52779	#endif
52780	}
52781	PRESERVE_NONE
52782	static bool Interp_StoreBitFieldBool(InterpState &S) {
52783	if (!StoreBitField<PT_Bool>(S, S.PC)) return false;
52784	#if USE_TAILCALLS
52785	MUSTTAIL return InterpNext(S);
52786	#else
52787	return true;
52788	#endif
52789	}
52790	PRESERVE_NONE
52791	static bool Interp_StoreBitFieldFixedPoint(InterpState &S) {
52792	if (!StoreBitField<PT_FixedPoint>(S, S.PC)) return false;
52793	#if USE_TAILCALLS
52794	MUSTTAIL return InterpNext(S);
52795	#else
52796	return true;
52797	#endif
52798	}
52799	#endif
52800	#ifdef GET_DISASM
52801	case OP_StoreBitFieldSint8:
52802	Text.Op = PrintName("StoreBitFieldSint8");
52803	break;
52804	case OP_StoreBitFieldUint8:
52805	Text.Op = PrintName("StoreBitFieldUint8");
52806	break;
52807	case OP_StoreBitFieldSint16:
52808	Text.Op = PrintName("StoreBitFieldSint16");
52809	break;
52810	case OP_StoreBitFieldUint16:
52811	Text.Op = PrintName("StoreBitFieldUint16");
52812	break;
52813	case OP_StoreBitFieldSint32:
52814	Text.Op = PrintName("StoreBitFieldSint32");
52815	break;
52816	case OP_StoreBitFieldUint32:
52817	Text.Op = PrintName("StoreBitFieldUint32");
52818	break;
52819	case OP_StoreBitFieldSint64:
52820	Text.Op = PrintName("StoreBitFieldSint64");
52821	break;
52822	case OP_StoreBitFieldUint64:
52823	Text.Op = PrintName("StoreBitFieldUint64");
52824	break;
52825	case OP_StoreBitFieldIntAP:
52826	Text.Op = PrintName("StoreBitFieldIntAP");
52827	break;
52828	case OP_StoreBitFieldIntAPS:
52829	Text.Op = PrintName("StoreBitFieldIntAPS");
52830	break;
52831	case OP_StoreBitFieldBool:
52832	Text.Op = PrintName("StoreBitFieldBool");
52833	break;
52834	case OP_StoreBitFieldFixedPoint:
52835	Text.Op = PrintName("StoreBitFieldFixedPoint");
52836	break;
52837	#endif
52838	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52839	bool emitStoreBitFieldSint8(SourceInfo);
52840	bool emitStoreBitFieldUint8(SourceInfo);
52841	bool emitStoreBitFieldSint16(SourceInfo);
52842	bool emitStoreBitFieldUint16(SourceInfo);
52843	bool emitStoreBitFieldSint32(SourceInfo);
52844	bool emitStoreBitFieldUint32(SourceInfo);
52845	bool emitStoreBitFieldSint64(SourceInfo);
52846	bool emitStoreBitFieldUint64(SourceInfo);
52847	bool emitStoreBitFieldIntAP(SourceInfo);
52848	bool emitStoreBitFieldIntAPS(SourceInfo);
52849	bool emitStoreBitFieldBool(SourceInfo);
52850	bool emitStoreBitFieldFixedPoint(SourceInfo);
52851	#endif
52852	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
52853	[[nodiscard]] bool emitStoreBitField(PrimType, SourceInfo I);
52854	#endif
52855	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
52856	bool
52857	#if defined(GET_EVAL_IMPL)
52858	EvalEmitter
52859	#else
52860	ByteCodeEmitter
52861	#endif
52862	::emitStoreBitField(PrimType T0, SourceInfo I) {
52863	switch (T0) {
52864	case PT_Sint8:
52865	return emitStoreBitFieldSint8(I);
52866	case PT_Uint8:
52867	return emitStoreBitFieldUint8(I);
52868	case PT_Sint16:
52869	return emitStoreBitFieldSint16(I);
52870	case PT_Uint16:
52871	return emitStoreBitFieldUint16(I);
52872	case PT_Sint32:
52873	return emitStoreBitFieldSint32(I);
52874	case PT_Uint32:
52875	return emitStoreBitFieldUint32(I);
52876	case PT_Sint64:
52877	return emitStoreBitFieldSint64(I);
52878	case PT_Uint64:
52879	return emitStoreBitFieldUint64(I);
52880	case PT_IntAP:
52881	return emitStoreBitFieldIntAP(I);
52882	case PT_IntAPS:
52883	return emitStoreBitFieldIntAPS(I);
52884	case PT_Bool:
52885	return emitStoreBitFieldBool(I);
52886	case PT_FixedPoint:
52887	return emitStoreBitFieldFixedPoint(I);
52888	default: llvm_unreachable("invalid type: emitStoreBitField");
52889	}
52890	llvm_unreachable("invalid enum value");
52891	}
52892	#endif
52893	#ifdef GET_LINK_IMPL
52894	bool ByteCodeEmitter::emitStoreBitFieldSint8(SourceInfo L) {
52895	return emitOp<>(OP_StoreBitFieldSint8, L);
52896	}
52897	bool ByteCodeEmitter::emitStoreBitFieldUint8(SourceInfo L) {
52898	return emitOp<>(OP_StoreBitFieldUint8, L);
52899	}
52900	bool ByteCodeEmitter::emitStoreBitFieldSint16(SourceInfo L) {
52901	return emitOp<>(OP_StoreBitFieldSint16, L);
52902	}
52903	bool ByteCodeEmitter::emitStoreBitFieldUint16(SourceInfo L) {
52904	return emitOp<>(OP_StoreBitFieldUint16, L);
52905	}
52906	bool ByteCodeEmitter::emitStoreBitFieldSint32(SourceInfo L) {
52907	return emitOp<>(OP_StoreBitFieldSint32, L);
52908	}
52909	bool ByteCodeEmitter::emitStoreBitFieldUint32(SourceInfo L) {
52910	return emitOp<>(OP_StoreBitFieldUint32, L);
52911	}
52912	bool ByteCodeEmitter::emitStoreBitFieldSint64(SourceInfo L) {
52913	return emitOp<>(OP_StoreBitFieldSint64, L);
52914	}
52915	bool ByteCodeEmitter::emitStoreBitFieldUint64(SourceInfo L) {
52916	return emitOp<>(OP_StoreBitFieldUint64, L);
52917	}
52918	bool ByteCodeEmitter::emitStoreBitFieldIntAP(SourceInfo L) {
52919	return emitOp<>(OP_StoreBitFieldIntAP, L);
52920	}
52921	bool ByteCodeEmitter::emitStoreBitFieldIntAPS(SourceInfo L) {
52922	return emitOp<>(OP_StoreBitFieldIntAPS, L);
52923	}
52924	bool ByteCodeEmitter::emitStoreBitFieldBool(SourceInfo L) {
52925	return emitOp<>(OP_StoreBitFieldBool, L);
52926	}
52927	bool ByteCodeEmitter::emitStoreBitFieldFixedPoint(SourceInfo L) {
52928	return emitOp<>(OP_StoreBitFieldFixedPoint, L);
52929	}
52930	#endif
52931	#ifdef GET_EVAL_IMPL
52932	bool EvalEmitter::emitStoreBitFieldSint8(SourceInfo L) {
52933	if (!isActive()) return true;
52934	CurrentSource = L;
52935	return StoreBitField<PT_Sint8>(S, CodePtr());
52936	}
52937	bool EvalEmitter::emitStoreBitFieldUint8(SourceInfo L) {
52938	if (!isActive()) return true;
52939	CurrentSource = L;
52940	return StoreBitField<PT_Uint8>(S, CodePtr());
52941	}
52942	bool EvalEmitter::emitStoreBitFieldSint16(SourceInfo L) {
52943	if (!isActive()) return true;
52944	CurrentSource = L;
52945	return StoreBitField<PT_Sint16>(S, CodePtr());
52946	}
52947	bool EvalEmitter::emitStoreBitFieldUint16(SourceInfo L) {
52948	if (!isActive()) return true;
52949	CurrentSource = L;
52950	return StoreBitField<PT_Uint16>(S, CodePtr());
52951	}
52952	bool EvalEmitter::emitStoreBitFieldSint32(SourceInfo L) {
52953	if (!isActive()) return true;
52954	CurrentSource = L;
52955	return StoreBitField<PT_Sint32>(S, CodePtr());
52956	}
52957	bool EvalEmitter::emitStoreBitFieldUint32(SourceInfo L) {
52958	if (!isActive()) return true;
52959	CurrentSource = L;
52960	return StoreBitField<PT_Uint32>(S, CodePtr());
52961	}
52962	bool EvalEmitter::emitStoreBitFieldSint64(SourceInfo L) {
52963	if (!isActive()) return true;
52964	CurrentSource = L;
52965	return StoreBitField<PT_Sint64>(S, CodePtr());
52966	}
52967	bool EvalEmitter::emitStoreBitFieldUint64(SourceInfo L) {
52968	if (!isActive()) return true;
52969	CurrentSource = L;
52970	return StoreBitField<PT_Uint64>(S, CodePtr());
52971	}
52972	bool EvalEmitter::emitStoreBitFieldIntAP(SourceInfo L) {
52973	if (!isActive()) return true;
52974	CurrentSource = L;
52975	return StoreBitField<PT_IntAP>(S, CodePtr());
52976	}
52977	bool EvalEmitter::emitStoreBitFieldIntAPS(SourceInfo L) {
52978	if (!isActive()) return true;
52979	CurrentSource = L;
52980	return StoreBitField<PT_IntAPS>(S, CodePtr());
52981	}
52982	bool EvalEmitter::emitStoreBitFieldBool(SourceInfo L) {
52983	if (!isActive()) return true;
52984	CurrentSource = L;
52985	return StoreBitField<PT_Bool>(S, CodePtr());
52986	}
52987	bool EvalEmitter::emitStoreBitFieldFixedPoint(SourceInfo L) {
52988	if (!isActive()) return true;
52989	CurrentSource = L;
52990	return StoreBitField<PT_FixedPoint>(S, CodePtr());
52991	}
52992	#endif
52993	#ifdef GET_OPCODE_NAMES
52994	OP_StoreBitFieldActivateSint8,
52995	OP_StoreBitFieldActivateUint8,
52996	OP_StoreBitFieldActivateSint16,
52997	OP_StoreBitFieldActivateUint16,
52998	OP_StoreBitFieldActivateSint32,
52999	OP_StoreBitFieldActivateUint32,
53000	OP_StoreBitFieldActivateSint64,
53001	OP_StoreBitFieldActivateUint64,
53002	OP_StoreBitFieldActivateIntAP,
53003	OP_StoreBitFieldActivateIntAPS,
53004	OP_StoreBitFieldActivateBool,
53005	OP_StoreBitFieldActivateFixedPoint,
53006	#endif
53007	#ifdef GET_INTERPFN_LIST
53008	&Interp_StoreBitFieldActivateSint8,
53009	&Interp_StoreBitFieldActivateUint8,
53010	&Interp_StoreBitFieldActivateSint16,
53011	&Interp_StoreBitFieldActivateUint16,
53012	&Interp_StoreBitFieldActivateSint32,
53013	&Interp_StoreBitFieldActivateUint32,
53014	&Interp_StoreBitFieldActivateSint64,
53015	&Interp_StoreBitFieldActivateUint64,
53016	&Interp_StoreBitFieldActivateIntAP,
53017	&Interp_StoreBitFieldActivateIntAPS,
53018	&Interp_StoreBitFieldActivateBool,
53019	&Interp_StoreBitFieldActivateFixedPoint,
53020	#endif
53021	#ifdef GET_INTERPFN_DISPATCHERS
53022	PRESERVE_NONE
53023	static bool Interp_StoreBitFieldActivateSint8(InterpState &S) {
53024	if (!StoreBitFieldActivate<PT_Sint8>(S, S.PC)) return false;
53025	#if USE_TAILCALLS
53026	MUSTTAIL return InterpNext(S);
53027	#else
53028	return true;
53029	#endif
53030	}
53031	PRESERVE_NONE
53032	static bool Interp_StoreBitFieldActivateUint8(InterpState &S) {
53033	if (!StoreBitFieldActivate<PT_Uint8>(S, S.PC)) return false;
53034	#if USE_TAILCALLS
53035	MUSTTAIL return InterpNext(S);
53036	#else
53037	return true;
53038	#endif
53039	}
53040	PRESERVE_NONE
53041	static bool Interp_StoreBitFieldActivateSint16(InterpState &S) {
53042	if (!StoreBitFieldActivate<PT_Sint16>(S, S.PC)) return false;
53043	#if USE_TAILCALLS
53044	MUSTTAIL return InterpNext(S);
53045	#else
53046	return true;
53047	#endif
53048	}
53049	PRESERVE_NONE
53050	static bool Interp_StoreBitFieldActivateUint16(InterpState &S) {
53051	if (!StoreBitFieldActivate<PT_Uint16>(S, S.PC)) return false;
53052	#if USE_TAILCALLS
53053	MUSTTAIL return InterpNext(S);
53054	#else
53055	return true;
53056	#endif
53057	}
53058	PRESERVE_NONE
53059	static bool Interp_StoreBitFieldActivateSint32(InterpState &S) {
53060	if (!StoreBitFieldActivate<PT_Sint32>(S, S.PC)) return false;
53061	#if USE_TAILCALLS
53062	MUSTTAIL return InterpNext(S);
53063	#else
53064	return true;
53065	#endif
53066	}
53067	PRESERVE_NONE
53068	static bool Interp_StoreBitFieldActivateUint32(InterpState &S) {
53069	if (!StoreBitFieldActivate<PT_Uint32>(S, S.PC)) return false;
53070	#if USE_TAILCALLS
53071	MUSTTAIL return InterpNext(S);
53072	#else
53073	return true;
53074	#endif
53075	}
53076	PRESERVE_NONE
53077	static bool Interp_StoreBitFieldActivateSint64(InterpState &S) {
53078	if (!StoreBitFieldActivate<PT_Sint64>(S, S.PC)) return false;
53079	#if USE_TAILCALLS
53080	MUSTTAIL return InterpNext(S);
53081	#else
53082	return true;
53083	#endif
53084	}
53085	PRESERVE_NONE
53086	static bool Interp_StoreBitFieldActivateUint64(InterpState &S) {
53087	if (!StoreBitFieldActivate<PT_Uint64>(S, S.PC)) return false;
53088	#if USE_TAILCALLS
53089	MUSTTAIL return InterpNext(S);
53090	#else
53091	return true;
53092	#endif
53093	}
53094	PRESERVE_NONE
53095	static bool Interp_StoreBitFieldActivateIntAP(InterpState &S) {
53096	if (!StoreBitFieldActivate<PT_IntAP>(S, S.PC)) return false;
53097	#if USE_TAILCALLS
53098	MUSTTAIL return InterpNext(S);
53099	#else
53100	return true;
53101	#endif
53102	}
53103	PRESERVE_NONE
53104	static bool Interp_StoreBitFieldActivateIntAPS(InterpState &S) {
53105	if (!StoreBitFieldActivate<PT_IntAPS>(S, S.PC)) return false;
53106	#if USE_TAILCALLS
53107	MUSTTAIL return InterpNext(S);
53108	#else
53109	return true;
53110	#endif
53111	}
53112	PRESERVE_NONE
53113	static bool Interp_StoreBitFieldActivateBool(InterpState &S) {
53114	if (!StoreBitFieldActivate<PT_Bool>(S, S.PC)) return false;
53115	#if USE_TAILCALLS
53116	MUSTTAIL return InterpNext(S);
53117	#else
53118	return true;
53119	#endif
53120	}
53121	PRESERVE_NONE
53122	static bool Interp_StoreBitFieldActivateFixedPoint(InterpState &S) {
53123	if (!StoreBitFieldActivate<PT_FixedPoint>(S, S.PC)) return false;
53124	#if USE_TAILCALLS
53125	MUSTTAIL return InterpNext(S);
53126	#else
53127	return true;
53128	#endif
53129	}
53130	#endif
53131	#ifdef GET_DISASM
53132	case OP_StoreBitFieldActivateSint8:
53133	Text.Op = PrintName("StoreBitFieldActivateSint8");
53134	break;
53135	case OP_StoreBitFieldActivateUint8:
53136	Text.Op = PrintName("StoreBitFieldActivateUint8");
53137	break;
53138	case OP_StoreBitFieldActivateSint16:
53139	Text.Op = PrintName("StoreBitFieldActivateSint16");
53140	break;
53141	case OP_StoreBitFieldActivateUint16:
53142	Text.Op = PrintName("StoreBitFieldActivateUint16");
53143	break;
53144	case OP_StoreBitFieldActivateSint32:
53145	Text.Op = PrintName("StoreBitFieldActivateSint32");
53146	break;
53147	case OP_StoreBitFieldActivateUint32:
53148	Text.Op = PrintName("StoreBitFieldActivateUint32");
53149	break;
53150	case OP_StoreBitFieldActivateSint64:
53151	Text.Op = PrintName("StoreBitFieldActivateSint64");
53152	break;
53153	case OP_StoreBitFieldActivateUint64:
53154	Text.Op = PrintName("StoreBitFieldActivateUint64");
53155	break;
53156	case OP_StoreBitFieldActivateIntAP:
53157	Text.Op = PrintName("StoreBitFieldActivateIntAP");
53158	break;
53159	case OP_StoreBitFieldActivateIntAPS:
53160	Text.Op = PrintName("StoreBitFieldActivateIntAPS");
53161	break;
53162	case OP_StoreBitFieldActivateBool:
53163	Text.Op = PrintName("StoreBitFieldActivateBool");
53164	break;
53165	case OP_StoreBitFieldActivateFixedPoint:
53166	Text.Op = PrintName("StoreBitFieldActivateFixedPoint");
53167	break;
53168	#endif
53169	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53170	bool emitStoreBitFieldActivateSint8(SourceInfo);
53171	bool emitStoreBitFieldActivateUint8(SourceInfo);
53172	bool emitStoreBitFieldActivateSint16(SourceInfo);
53173	bool emitStoreBitFieldActivateUint16(SourceInfo);
53174	bool emitStoreBitFieldActivateSint32(SourceInfo);
53175	bool emitStoreBitFieldActivateUint32(SourceInfo);
53176	bool emitStoreBitFieldActivateSint64(SourceInfo);
53177	bool emitStoreBitFieldActivateUint64(SourceInfo);
53178	bool emitStoreBitFieldActivateIntAP(SourceInfo);
53179	bool emitStoreBitFieldActivateIntAPS(SourceInfo);
53180	bool emitStoreBitFieldActivateBool(SourceInfo);
53181	bool emitStoreBitFieldActivateFixedPoint(SourceInfo);
53182	#endif
53183	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53184	[[nodiscard]] bool emitStoreBitFieldActivate(PrimType, SourceInfo I);
53185	#endif
53186	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
53187	bool
53188	#if defined(GET_EVAL_IMPL)
53189	EvalEmitter
53190	#else
53191	ByteCodeEmitter
53192	#endif
53193	::emitStoreBitFieldActivate(PrimType T0, SourceInfo I) {
53194	switch (T0) {
53195	case PT_Sint8:
53196	return emitStoreBitFieldActivateSint8(I);
53197	case PT_Uint8:
53198	return emitStoreBitFieldActivateUint8(I);
53199	case PT_Sint16:
53200	return emitStoreBitFieldActivateSint16(I);
53201	case PT_Uint16:
53202	return emitStoreBitFieldActivateUint16(I);
53203	case PT_Sint32:
53204	return emitStoreBitFieldActivateSint32(I);
53205	case PT_Uint32:
53206	return emitStoreBitFieldActivateUint32(I);
53207	case PT_Sint64:
53208	return emitStoreBitFieldActivateSint64(I);
53209	case PT_Uint64:
53210	return emitStoreBitFieldActivateUint64(I);
53211	case PT_IntAP:
53212	return emitStoreBitFieldActivateIntAP(I);
53213	case PT_IntAPS:
53214	return emitStoreBitFieldActivateIntAPS(I);
53215	case PT_Bool:
53216	return emitStoreBitFieldActivateBool(I);
53217	case PT_FixedPoint:
53218	return emitStoreBitFieldActivateFixedPoint(I);
53219	default: llvm_unreachable("invalid type: emitStoreBitFieldActivate");
53220	}
53221	llvm_unreachable("invalid enum value");
53222	}
53223	#endif
53224	#ifdef GET_LINK_IMPL
53225	bool ByteCodeEmitter::emitStoreBitFieldActivateSint8(SourceInfo L) {
53226	return emitOp<>(OP_StoreBitFieldActivateSint8, L);
53227	}
53228	bool ByteCodeEmitter::emitStoreBitFieldActivateUint8(SourceInfo L) {
53229	return emitOp<>(OP_StoreBitFieldActivateUint8, L);
53230	}
53231	bool ByteCodeEmitter::emitStoreBitFieldActivateSint16(SourceInfo L) {
53232	return emitOp<>(OP_StoreBitFieldActivateSint16, L);
53233	}
53234	bool ByteCodeEmitter::emitStoreBitFieldActivateUint16(SourceInfo L) {
53235	return emitOp<>(OP_StoreBitFieldActivateUint16, L);
53236	}
53237	bool ByteCodeEmitter::emitStoreBitFieldActivateSint32(SourceInfo L) {
53238	return emitOp<>(OP_StoreBitFieldActivateSint32, L);
53239	}
53240	bool ByteCodeEmitter::emitStoreBitFieldActivateUint32(SourceInfo L) {
53241	return emitOp<>(OP_StoreBitFieldActivateUint32, L);
53242	}
53243	bool ByteCodeEmitter::emitStoreBitFieldActivateSint64(SourceInfo L) {
53244	return emitOp<>(OP_StoreBitFieldActivateSint64, L);
53245	}
53246	bool ByteCodeEmitter::emitStoreBitFieldActivateUint64(SourceInfo L) {
53247	return emitOp<>(OP_StoreBitFieldActivateUint64, L);
53248	}
53249	bool ByteCodeEmitter::emitStoreBitFieldActivateIntAP(SourceInfo L) {
53250	return emitOp<>(OP_StoreBitFieldActivateIntAP, L);
53251	}
53252	bool ByteCodeEmitter::emitStoreBitFieldActivateIntAPS(SourceInfo L) {
53253	return emitOp<>(OP_StoreBitFieldActivateIntAPS, L);
53254	}
53255	bool ByteCodeEmitter::emitStoreBitFieldActivateBool(SourceInfo L) {
53256	return emitOp<>(OP_StoreBitFieldActivateBool, L);
53257	}
53258	bool ByteCodeEmitter::emitStoreBitFieldActivateFixedPoint(SourceInfo L) {
53259	return emitOp<>(OP_StoreBitFieldActivateFixedPoint, L);
53260	}
53261	#endif
53262	#ifdef GET_EVAL_IMPL
53263	bool EvalEmitter::emitStoreBitFieldActivateSint8(SourceInfo L) {
53264	if (!isActive()) return true;
53265	CurrentSource = L;
53266	return StoreBitFieldActivate<PT_Sint8>(S, CodePtr());
53267	}
53268	bool EvalEmitter::emitStoreBitFieldActivateUint8(SourceInfo L) {
53269	if (!isActive()) return true;
53270	CurrentSource = L;
53271	return StoreBitFieldActivate<PT_Uint8>(S, CodePtr());
53272	}
53273	bool EvalEmitter::emitStoreBitFieldActivateSint16(SourceInfo L) {
53274	if (!isActive()) return true;
53275	CurrentSource = L;
53276	return StoreBitFieldActivate<PT_Sint16>(S, CodePtr());
53277	}
53278	bool EvalEmitter::emitStoreBitFieldActivateUint16(SourceInfo L) {
53279	if (!isActive()) return true;
53280	CurrentSource = L;
53281	return StoreBitFieldActivate<PT_Uint16>(S, CodePtr());
53282	}
53283	bool EvalEmitter::emitStoreBitFieldActivateSint32(SourceInfo L) {
53284	if (!isActive()) return true;
53285	CurrentSource = L;
53286	return StoreBitFieldActivate<PT_Sint32>(S, CodePtr());
53287	}
53288	bool EvalEmitter::emitStoreBitFieldActivateUint32(SourceInfo L) {
53289	if (!isActive()) return true;
53290	CurrentSource = L;
53291	return StoreBitFieldActivate<PT_Uint32>(S, CodePtr());
53292	}
53293	bool EvalEmitter::emitStoreBitFieldActivateSint64(SourceInfo L) {
53294	if (!isActive()) return true;
53295	CurrentSource = L;
53296	return StoreBitFieldActivate<PT_Sint64>(S, CodePtr());
53297	}
53298	bool EvalEmitter::emitStoreBitFieldActivateUint64(SourceInfo L) {
53299	if (!isActive()) return true;
53300	CurrentSource = L;
53301	return StoreBitFieldActivate<PT_Uint64>(S, CodePtr());
53302	}
53303	bool EvalEmitter::emitStoreBitFieldActivateIntAP(SourceInfo L) {
53304	if (!isActive()) return true;
53305	CurrentSource = L;
53306	return StoreBitFieldActivate<PT_IntAP>(S, CodePtr());
53307	}
53308	bool EvalEmitter::emitStoreBitFieldActivateIntAPS(SourceInfo L) {
53309	if (!isActive()) return true;
53310	CurrentSource = L;
53311	return StoreBitFieldActivate<PT_IntAPS>(S, CodePtr());
53312	}
53313	bool EvalEmitter::emitStoreBitFieldActivateBool(SourceInfo L) {
53314	if (!isActive()) return true;
53315	CurrentSource = L;
53316	return StoreBitFieldActivate<PT_Bool>(S, CodePtr());
53317	}
53318	bool EvalEmitter::emitStoreBitFieldActivateFixedPoint(SourceInfo L) {
53319	if (!isActive()) return true;
53320	CurrentSource = L;
53321	return StoreBitFieldActivate<PT_FixedPoint>(S, CodePtr());
53322	}
53323	#endif
53324	#ifdef GET_OPCODE_NAMES
53325	OP_StoreBitFieldActivatePopSint8,
53326	OP_StoreBitFieldActivatePopUint8,
53327	OP_StoreBitFieldActivatePopSint16,
53328	OP_StoreBitFieldActivatePopUint16,
53329	OP_StoreBitFieldActivatePopSint32,
53330	OP_StoreBitFieldActivatePopUint32,
53331	OP_StoreBitFieldActivatePopSint64,
53332	OP_StoreBitFieldActivatePopUint64,
53333	OP_StoreBitFieldActivatePopIntAP,
53334	OP_StoreBitFieldActivatePopIntAPS,
53335	OP_StoreBitFieldActivatePopBool,
53336	OP_StoreBitFieldActivatePopFixedPoint,
53337	#endif
53338	#ifdef GET_INTERPFN_LIST
53339	&Interp_StoreBitFieldActivatePopSint8,
53340	&Interp_StoreBitFieldActivatePopUint8,
53341	&Interp_StoreBitFieldActivatePopSint16,
53342	&Interp_StoreBitFieldActivatePopUint16,
53343	&Interp_StoreBitFieldActivatePopSint32,
53344	&Interp_StoreBitFieldActivatePopUint32,
53345	&Interp_StoreBitFieldActivatePopSint64,
53346	&Interp_StoreBitFieldActivatePopUint64,
53347	&Interp_StoreBitFieldActivatePopIntAP,
53348	&Interp_StoreBitFieldActivatePopIntAPS,
53349	&Interp_StoreBitFieldActivatePopBool,
53350	&Interp_StoreBitFieldActivatePopFixedPoint,
53351	#endif
53352	#ifdef GET_INTERPFN_DISPATCHERS
53353	PRESERVE_NONE
53354	static bool Interp_StoreBitFieldActivatePopSint8(InterpState &S) {
53355	if (!StoreBitFieldActivatePop<PT_Sint8>(S, S.PC)) return false;
53356	#if USE_TAILCALLS
53357	MUSTTAIL return InterpNext(S);
53358	#else
53359	return true;
53360	#endif
53361	}
53362	PRESERVE_NONE
53363	static bool Interp_StoreBitFieldActivatePopUint8(InterpState &S) {
53364	if (!StoreBitFieldActivatePop<PT_Uint8>(S, S.PC)) return false;
53365	#if USE_TAILCALLS
53366	MUSTTAIL return InterpNext(S);
53367	#else
53368	return true;
53369	#endif
53370	}
53371	PRESERVE_NONE
53372	static bool Interp_StoreBitFieldActivatePopSint16(InterpState &S) {
53373	if (!StoreBitFieldActivatePop<PT_Sint16>(S, S.PC)) return false;
53374	#if USE_TAILCALLS
53375	MUSTTAIL return InterpNext(S);
53376	#else
53377	return true;
53378	#endif
53379	}
53380	PRESERVE_NONE
53381	static bool Interp_StoreBitFieldActivatePopUint16(InterpState &S) {
53382	if (!StoreBitFieldActivatePop<PT_Uint16>(S, S.PC)) return false;
53383	#if USE_TAILCALLS
53384	MUSTTAIL return InterpNext(S);
53385	#else
53386	return true;
53387	#endif
53388	}
53389	PRESERVE_NONE
53390	static bool Interp_StoreBitFieldActivatePopSint32(InterpState &S) {
53391	if (!StoreBitFieldActivatePop<PT_Sint32>(S, S.PC)) return false;
53392	#if USE_TAILCALLS
53393	MUSTTAIL return InterpNext(S);
53394	#else
53395	return true;
53396	#endif
53397	}
53398	PRESERVE_NONE
53399	static bool Interp_StoreBitFieldActivatePopUint32(InterpState &S) {
53400	if (!StoreBitFieldActivatePop<PT_Uint32>(S, S.PC)) return false;
53401	#if USE_TAILCALLS
53402	MUSTTAIL return InterpNext(S);
53403	#else
53404	return true;
53405	#endif
53406	}
53407	PRESERVE_NONE
53408	static bool Interp_StoreBitFieldActivatePopSint64(InterpState &S) {
53409	if (!StoreBitFieldActivatePop<PT_Sint64>(S, S.PC)) return false;
53410	#if USE_TAILCALLS
53411	MUSTTAIL return InterpNext(S);
53412	#else
53413	return true;
53414	#endif
53415	}
53416	PRESERVE_NONE
53417	static bool Interp_StoreBitFieldActivatePopUint64(InterpState &S) {
53418	if (!StoreBitFieldActivatePop<PT_Uint64>(S, S.PC)) return false;
53419	#if USE_TAILCALLS
53420	MUSTTAIL return InterpNext(S);
53421	#else
53422	return true;
53423	#endif
53424	}
53425	PRESERVE_NONE
53426	static bool Interp_StoreBitFieldActivatePopIntAP(InterpState &S) {
53427	if (!StoreBitFieldActivatePop<PT_IntAP>(S, S.PC)) return false;
53428	#if USE_TAILCALLS
53429	MUSTTAIL return InterpNext(S);
53430	#else
53431	return true;
53432	#endif
53433	}
53434	PRESERVE_NONE
53435	static bool Interp_StoreBitFieldActivatePopIntAPS(InterpState &S) {
53436	if (!StoreBitFieldActivatePop<PT_IntAPS>(S, S.PC)) return false;
53437	#if USE_TAILCALLS
53438	MUSTTAIL return InterpNext(S);
53439	#else
53440	return true;
53441	#endif
53442	}
53443	PRESERVE_NONE
53444	static bool Interp_StoreBitFieldActivatePopBool(InterpState &S) {
53445	if (!StoreBitFieldActivatePop<PT_Bool>(S, S.PC)) return false;
53446	#if USE_TAILCALLS
53447	MUSTTAIL return InterpNext(S);
53448	#else
53449	return true;
53450	#endif
53451	}
53452	PRESERVE_NONE
53453	static bool Interp_StoreBitFieldActivatePopFixedPoint(InterpState &S) {
53454	if (!StoreBitFieldActivatePop<PT_FixedPoint>(S, S.PC)) return false;
53455	#if USE_TAILCALLS
53456	MUSTTAIL return InterpNext(S);
53457	#else
53458	return true;
53459	#endif
53460	}
53461	#endif
53462	#ifdef GET_DISASM
53463	case OP_StoreBitFieldActivatePopSint8:
53464	Text.Op = PrintName("StoreBitFieldActivatePopSint8");
53465	break;
53466	case OP_StoreBitFieldActivatePopUint8:
53467	Text.Op = PrintName("StoreBitFieldActivatePopUint8");
53468	break;
53469	case OP_StoreBitFieldActivatePopSint16:
53470	Text.Op = PrintName("StoreBitFieldActivatePopSint16");
53471	break;
53472	case OP_StoreBitFieldActivatePopUint16:
53473	Text.Op = PrintName("StoreBitFieldActivatePopUint16");
53474	break;
53475	case OP_StoreBitFieldActivatePopSint32:
53476	Text.Op = PrintName("StoreBitFieldActivatePopSint32");
53477	break;
53478	case OP_StoreBitFieldActivatePopUint32:
53479	Text.Op = PrintName("StoreBitFieldActivatePopUint32");
53480	break;
53481	case OP_StoreBitFieldActivatePopSint64:
53482	Text.Op = PrintName("StoreBitFieldActivatePopSint64");
53483	break;
53484	case OP_StoreBitFieldActivatePopUint64:
53485	Text.Op = PrintName("StoreBitFieldActivatePopUint64");
53486	break;
53487	case OP_StoreBitFieldActivatePopIntAP:
53488	Text.Op = PrintName("StoreBitFieldActivatePopIntAP");
53489	break;
53490	case OP_StoreBitFieldActivatePopIntAPS:
53491	Text.Op = PrintName("StoreBitFieldActivatePopIntAPS");
53492	break;
53493	case OP_StoreBitFieldActivatePopBool:
53494	Text.Op = PrintName("StoreBitFieldActivatePopBool");
53495	break;
53496	case OP_StoreBitFieldActivatePopFixedPoint:
53497	Text.Op = PrintName("StoreBitFieldActivatePopFixedPoint");
53498	break;
53499	#endif
53500	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53501	bool emitStoreBitFieldActivatePopSint8(SourceInfo);
53502	bool emitStoreBitFieldActivatePopUint8(SourceInfo);
53503	bool emitStoreBitFieldActivatePopSint16(SourceInfo);
53504	bool emitStoreBitFieldActivatePopUint16(SourceInfo);
53505	bool emitStoreBitFieldActivatePopSint32(SourceInfo);
53506	bool emitStoreBitFieldActivatePopUint32(SourceInfo);
53507	bool emitStoreBitFieldActivatePopSint64(SourceInfo);
53508	bool emitStoreBitFieldActivatePopUint64(SourceInfo);
53509	bool emitStoreBitFieldActivatePopIntAP(SourceInfo);
53510	bool emitStoreBitFieldActivatePopIntAPS(SourceInfo);
53511	bool emitStoreBitFieldActivatePopBool(SourceInfo);
53512	bool emitStoreBitFieldActivatePopFixedPoint(SourceInfo);
53513	#endif
53514	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53515	[[nodiscard]] bool emitStoreBitFieldActivatePop(PrimType, SourceInfo I);
53516	#endif
53517	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
53518	bool
53519	#if defined(GET_EVAL_IMPL)
53520	EvalEmitter
53521	#else
53522	ByteCodeEmitter
53523	#endif
53524	::emitStoreBitFieldActivatePop(PrimType T0, SourceInfo I) {
53525	switch (T0) {
53526	case PT_Sint8:
53527	return emitStoreBitFieldActivatePopSint8(I);
53528	case PT_Uint8:
53529	return emitStoreBitFieldActivatePopUint8(I);
53530	case PT_Sint16:
53531	return emitStoreBitFieldActivatePopSint16(I);
53532	case PT_Uint16:
53533	return emitStoreBitFieldActivatePopUint16(I);
53534	case PT_Sint32:
53535	return emitStoreBitFieldActivatePopSint32(I);
53536	case PT_Uint32:
53537	return emitStoreBitFieldActivatePopUint32(I);
53538	case PT_Sint64:
53539	return emitStoreBitFieldActivatePopSint64(I);
53540	case PT_Uint64:
53541	return emitStoreBitFieldActivatePopUint64(I);
53542	case PT_IntAP:
53543	return emitStoreBitFieldActivatePopIntAP(I);
53544	case PT_IntAPS:
53545	return emitStoreBitFieldActivatePopIntAPS(I);
53546	case PT_Bool:
53547	return emitStoreBitFieldActivatePopBool(I);
53548	case PT_FixedPoint:
53549	return emitStoreBitFieldActivatePopFixedPoint(I);
53550	default: llvm_unreachable("invalid type: emitStoreBitFieldActivatePop");
53551	}
53552	llvm_unreachable("invalid enum value");
53553	}
53554	#endif
53555	#ifdef GET_LINK_IMPL
53556	bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint8(SourceInfo L) {
53557	return emitOp<>(OP_StoreBitFieldActivatePopSint8, L);
53558	}
53559	bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint8(SourceInfo L) {
53560	return emitOp<>(OP_StoreBitFieldActivatePopUint8, L);
53561	}
53562	bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint16(SourceInfo L) {
53563	return emitOp<>(OP_StoreBitFieldActivatePopSint16, L);
53564	}
53565	bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint16(SourceInfo L) {
53566	return emitOp<>(OP_StoreBitFieldActivatePopUint16, L);
53567	}
53568	bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint32(SourceInfo L) {
53569	return emitOp<>(OP_StoreBitFieldActivatePopSint32, L);
53570	}
53571	bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint32(SourceInfo L) {
53572	return emitOp<>(OP_StoreBitFieldActivatePopUint32, L);
53573	}
53574	bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint64(SourceInfo L) {
53575	return emitOp<>(OP_StoreBitFieldActivatePopSint64, L);
53576	}
53577	bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint64(SourceInfo L) {
53578	return emitOp<>(OP_StoreBitFieldActivatePopUint64, L);
53579	}
53580	bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAP(SourceInfo L) {
53581	return emitOp<>(OP_StoreBitFieldActivatePopIntAP, L);
53582	}
53583	bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAPS(SourceInfo L) {
53584	return emitOp<>(OP_StoreBitFieldActivatePopIntAPS, L);
53585	}
53586	bool ByteCodeEmitter::emitStoreBitFieldActivatePopBool(SourceInfo L) {
53587	return emitOp<>(OP_StoreBitFieldActivatePopBool, L);
53588	}
53589	bool ByteCodeEmitter::emitStoreBitFieldActivatePopFixedPoint(SourceInfo L) {
53590	return emitOp<>(OP_StoreBitFieldActivatePopFixedPoint, L);
53591	}
53592	#endif
53593	#ifdef GET_EVAL_IMPL
53594	bool EvalEmitter::emitStoreBitFieldActivatePopSint8(SourceInfo L) {
53595	if (!isActive()) return true;
53596	CurrentSource = L;
53597	return StoreBitFieldActivatePop<PT_Sint8>(S, CodePtr());
53598	}
53599	bool EvalEmitter::emitStoreBitFieldActivatePopUint8(SourceInfo L) {
53600	if (!isActive()) return true;
53601	CurrentSource = L;
53602	return StoreBitFieldActivatePop<PT_Uint8>(S, CodePtr());
53603	}
53604	bool EvalEmitter::emitStoreBitFieldActivatePopSint16(SourceInfo L) {
53605	if (!isActive()) return true;
53606	CurrentSource = L;
53607	return StoreBitFieldActivatePop<PT_Sint16>(S, CodePtr());
53608	}
53609	bool EvalEmitter::emitStoreBitFieldActivatePopUint16(SourceInfo L) {
53610	if (!isActive()) return true;
53611	CurrentSource = L;
53612	return StoreBitFieldActivatePop<PT_Uint16>(S, CodePtr());
53613	}
53614	bool EvalEmitter::emitStoreBitFieldActivatePopSint32(SourceInfo L) {
53615	if (!isActive()) return true;
53616	CurrentSource = L;
53617	return StoreBitFieldActivatePop<PT_Sint32>(S, CodePtr());
53618	}
53619	bool EvalEmitter::emitStoreBitFieldActivatePopUint32(SourceInfo L) {
53620	if (!isActive()) return true;
53621	CurrentSource = L;
53622	return StoreBitFieldActivatePop<PT_Uint32>(S, CodePtr());
53623	}
53624	bool EvalEmitter::emitStoreBitFieldActivatePopSint64(SourceInfo L) {
53625	if (!isActive()) return true;
53626	CurrentSource = L;
53627	return StoreBitFieldActivatePop<PT_Sint64>(S, CodePtr());
53628	}
53629	bool EvalEmitter::emitStoreBitFieldActivatePopUint64(SourceInfo L) {
53630	if (!isActive()) return true;
53631	CurrentSource = L;
53632	return StoreBitFieldActivatePop<PT_Uint64>(S, CodePtr());
53633	}
53634	bool EvalEmitter::emitStoreBitFieldActivatePopIntAP(SourceInfo L) {
53635	if (!isActive()) return true;
53636	CurrentSource = L;
53637	return StoreBitFieldActivatePop<PT_IntAP>(S, CodePtr());
53638	}
53639	bool EvalEmitter::emitStoreBitFieldActivatePopIntAPS(SourceInfo L) {
53640	if (!isActive()) return true;
53641	CurrentSource = L;
53642	return StoreBitFieldActivatePop<PT_IntAPS>(S, CodePtr());
53643	}
53644	bool EvalEmitter::emitStoreBitFieldActivatePopBool(SourceInfo L) {
53645	if (!isActive()) return true;
53646	CurrentSource = L;
53647	return StoreBitFieldActivatePop<PT_Bool>(S, CodePtr());
53648	}
53649	bool EvalEmitter::emitStoreBitFieldActivatePopFixedPoint(SourceInfo L) {
53650	if (!isActive()) return true;
53651	CurrentSource = L;
53652	return StoreBitFieldActivatePop<PT_FixedPoint>(S, CodePtr());
53653	}
53654	#endif
53655	#ifdef GET_OPCODE_NAMES
53656	OP_StoreBitFieldPopSint8,
53657	OP_StoreBitFieldPopUint8,
53658	OP_StoreBitFieldPopSint16,
53659	OP_StoreBitFieldPopUint16,
53660	OP_StoreBitFieldPopSint32,
53661	OP_StoreBitFieldPopUint32,
53662	OP_StoreBitFieldPopSint64,
53663	OP_StoreBitFieldPopUint64,
53664	OP_StoreBitFieldPopIntAP,
53665	OP_StoreBitFieldPopIntAPS,
53666	OP_StoreBitFieldPopBool,
53667	OP_StoreBitFieldPopFixedPoint,
53668	#endif
53669	#ifdef GET_INTERPFN_LIST
53670	&Interp_StoreBitFieldPopSint8,
53671	&Interp_StoreBitFieldPopUint8,
53672	&Interp_StoreBitFieldPopSint16,
53673	&Interp_StoreBitFieldPopUint16,
53674	&Interp_StoreBitFieldPopSint32,
53675	&Interp_StoreBitFieldPopUint32,
53676	&Interp_StoreBitFieldPopSint64,
53677	&Interp_StoreBitFieldPopUint64,
53678	&Interp_StoreBitFieldPopIntAP,
53679	&Interp_StoreBitFieldPopIntAPS,
53680	&Interp_StoreBitFieldPopBool,
53681	&Interp_StoreBitFieldPopFixedPoint,
53682	#endif
53683	#ifdef GET_INTERPFN_DISPATCHERS
53684	PRESERVE_NONE
53685	static bool Interp_StoreBitFieldPopSint8(InterpState &S) {
53686	if (!StoreBitFieldPop<PT_Sint8>(S, S.PC)) return false;
53687	#if USE_TAILCALLS
53688	MUSTTAIL return InterpNext(S);
53689	#else
53690	return true;
53691	#endif
53692	}
53693	PRESERVE_NONE
53694	static bool Interp_StoreBitFieldPopUint8(InterpState &S) {
53695	if (!StoreBitFieldPop<PT_Uint8>(S, S.PC)) return false;
53696	#if USE_TAILCALLS
53697	MUSTTAIL return InterpNext(S);
53698	#else
53699	return true;
53700	#endif
53701	}
53702	PRESERVE_NONE
53703	static bool Interp_StoreBitFieldPopSint16(InterpState &S) {
53704	if (!StoreBitFieldPop<PT_Sint16>(S, S.PC)) return false;
53705	#if USE_TAILCALLS
53706	MUSTTAIL return InterpNext(S);
53707	#else
53708	return true;
53709	#endif
53710	}
53711	PRESERVE_NONE
53712	static bool Interp_StoreBitFieldPopUint16(InterpState &S) {
53713	if (!StoreBitFieldPop<PT_Uint16>(S, S.PC)) return false;
53714	#if USE_TAILCALLS
53715	MUSTTAIL return InterpNext(S);
53716	#else
53717	return true;
53718	#endif
53719	}
53720	PRESERVE_NONE
53721	static bool Interp_StoreBitFieldPopSint32(InterpState &S) {
53722	if (!StoreBitFieldPop<PT_Sint32>(S, S.PC)) return false;
53723	#if USE_TAILCALLS
53724	MUSTTAIL return InterpNext(S);
53725	#else
53726	return true;
53727	#endif
53728	}
53729	PRESERVE_NONE
53730	static bool Interp_StoreBitFieldPopUint32(InterpState &S) {
53731	if (!StoreBitFieldPop<PT_Uint32>(S, S.PC)) return false;
53732	#if USE_TAILCALLS
53733	MUSTTAIL return InterpNext(S);
53734	#else
53735	return true;
53736	#endif
53737	}
53738	PRESERVE_NONE
53739	static bool Interp_StoreBitFieldPopSint64(InterpState &S) {
53740	if (!StoreBitFieldPop<PT_Sint64>(S, S.PC)) return false;
53741	#if USE_TAILCALLS
53742	MUSTTAIL return InterpNext(S);
53743	#else
53744	return true;
53745	#endif
53746	}
53747	PRESERVE_NONE
53748	static bool Interp_StoreBitFieldPopUint64(InterpState &S) {
53749	if (!StoreBitFieldPop<PT_Uint64>(S, S.PC)) return false;
53750	#if USE_TAILCALLS
53751	MUSTTAIL return InterpNext(S);
53752	#else
53753	return true;
53754	#endif
53755	}
53756	PRESERVE_NONE
53757	static bool Interp_StoreBitFieldPopIntAP(InterpState &S) {
53758	if (!StoreBitFieldPop<PT_IntAP>(S, S.PC)) return false;
53759	#if USE_TAILCALLS
53760	MUSTTAIL return InterpNext(S);
53761	#else
53762	return true;
53763	#endif
53764	}
53765	PRESERVE_NONE
53766	static bool Interp_StoreBitFieldPopIntAPS(InterpState &S) {
53767	if (!StoreBitFieldPop<PT_IntAPS>(S, S.PC)) return false;
53768	#if USE_TAILCALLS
53769	MUSTTAIL return InterpNext(S);
53770	#else
53771	return true;
53772	#endif
53773	}
53774	PRESERVE_NONE
53775	static bool Interp_StoreBitFieldPopBool(InterpState &S) {
53776	if (!StoreBitFieldPop<PT_Bool>(S, S.PC)) return false;
53777	#if USE_TAILCALLS
53778	MUSTTAIL return InterpNext(S);
53779	#else
53780	return true;
53781	#endif
53782	}
53783	PRESERVE_NONE
53784	static bool Interp_StoreBitFieldPopFixedPoint(InterpState &S) {
53785	if (!StoreBitFieldPop<PT_FixedPoint>(S, S.PC)) return false;
53786	#if USE_TAILCALLS
53787	MUSTTAIL return InterpNext(S);
53788	#else
53789	return true;
53790	#endif
53791	}
53792	#endif
53793	#ifdef GET_DISASM
53794	case OP_StoreBitFieldPopSint8:
53795	Text.Op = PrintName("StoreBitFieldPopSint8");
53796	break;
53797	case OP_StoreBitFieldPopUint8:
53798	Text.Op = PrintName("StoreBitFieldPopUint8");
53799	break;
53800	case OP_StoreBitFieldPopSint16:
53801	Text.Op = PrintName("StoreBitFieldPopSint16");
53802	break;
53803	case OP_StoreBitFieldPopUint16:
53804	Text.Op = PrintName("StoreBitFieldPopUint16");
53805	break;
53806	case OP_StoreBitFieldPopSint32:
53807	Text.Op = PrintName("StoreBitFieldPopSint32");
53808	break;
53809	case OP_StoreBitFieldPopUint32:
53810	Text.Op = PrintName("StoreBitFieldPopUint32");
53811	break;
53812	case OP_StoreBitFieldPopSint64:
53813	Text.Op = PrintName("StoreBitFieldPopSint64");
53814	break;
53815	case OP_StoreBitFieldPopUint64:
53816	Text.Op = PrintName("StoreBitFieldPopUint64");
53817	break;
53818	case OP_StoreBitFieldPopIntAP:
53819	Text.Op = PrintName("StoreBitFieldPopIntAP");
53820	break;
53821	case OP_StoreBitFieldPopIntAPS:
53822	Text.Op = PrintName("StoreBitFieldPopIntAPS");
53823	break;
53824	case OP_StoreBitFieldPopBool:
53825	Text.Op = PrintName("StoreBitFieldPopBool");
53826	break;
53827	case OP_StoreBitFieldPopFixedPoint:
53828	Text.Op = PrintName("StoreBitFieldPopFixedPoint");
53829	break;
53830	#endif
53831	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53832	bool emitStoreBitFieldPopSint8(SourceInfo);
53833	bool emitStoreBitFieldPopUint8(SourceInfo);
53834	bool emitStoreBitFieldPopSint16(SourceInfo);
53835	bool emitStoreBitFieldPopUint16(SourceInfo);
53836	bool emitStoreBitFieldPopSint32(SourceInfo);
53837	bool emitStoreBitFieldPopUint32(SourceInfo);
53838	bool emitStoreBitFieldPopSint64(SourceInfo);
53839	bool emitStoreBitFieldPopUint64(SourceInfo);
53840	bool emitStoreBitFieldPopIntAP(SourceInfo);
53841	bool emitStoreBitFieldPopIntAPS(SourceInfo);
53842	bool emitStoreBitFieldPopBool(SourceInfo);
53843	bool emitStoreBitFieldPopFixedPoint(SourceInfo);
53844	#endif
53845	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
53846	[[nodiscard]] bool emitStoreBitFieldPop(PrimType, SourceInfo I);
53847	#endif
53848	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
53849	bool
53850	#if defined(GET_EVAL_IMPL)
53851	EvalEmitter
53852	#else
53853	ByteCodeEmitter
53854	#endif
53855	::emitStoreBitFieldPop(PrimType T0, SourceInfo I) {
53856	switch (T0) {
53857	case PT_Sint8:
53858	return emitStoreBitFieldPopSint8(I);
53859	case PT_Uint8:
53860	return emitStoreBitFieldPopUint8(I);
53861	case PT_Sint16:
53862	return emitStoreBitFieldPopSint16(I);
53863	case PT_Uint16:
53864	return emitStoreBitFieldPopUint16(I);
53865	case PT_Sint32:
53866	return emitStoreBitFieldPopSint32(I);
53867	case PT_Uint32:
53868	return emitStoreBitFieldPopUint32(I);
53869	case PT_Sint64:
53870	return emitStoreBitFieldPopSint64(I);
53871	case PT_Uint64:
53872	return emitStoreBitFieldPopUint64(I);
53873	case PT_IntAP:
53874	return emitStoreBitFieldPopIntAP(I);
53875	case PT_IntAPS:
53876	return emitStoreBitFieldPopIntAPS(I);
53877	case PT_Bool:
53878	return emitStoreBitFieldPopBool(I);
53879	case PT_FixedPoint:
53880	return emitStoreBitFieldPopFixedPoint(I);
53881	default: llvm_unreachable("invalid type: emitStoreBitFieldPop");
53882	}
53883	llvm_unreachable("invalid enum value");
53884	}
53885	#endif
53886	#ifdef GET_LINK_IMPL
53887	bool ByteCodeEmitter::emitStoreBitFieldPopSint8(SourceInfo L) {
53888	return emitOp<>(OP_StoreBitFieldPopSint8, L);
53889	}
53890	bool ByteCodeEmitter::emitStoreBitFieldPopUint8(SourceInfo L) {
53891	return emitOp<>(OP_StoreBitFieldPopUint8, L);
53892	}
53893	bool ByteCodeEmitter::emitStoreBitFieldPopSint16(SourceInfo L) {
53894	return emitOp<>(OP_StoreBitFieldPopSint16, L);
53895	}
53896	bool ByteCodeEmitter::emitStoreBitFieldPopUint16(SourceInfo L) {
53897	return emitOp<>(OP_StoreBitFieldPopUint16, L);
53898	}
53899	bool ByteCodeEmitter::emitStoreBitFieldPopSint32(SourceInfo L) {
53900	return emitOp<>(OP_StoreBitFieldPopSint32, L);
53901	}
53902	bool ByteCodeEmitter::emitStoreBitFieldPopUint32(SourceInfo L) {
53903	return emitOp<>(OP_StoreBitFieldPopUint32, L);
53904	}
53905	bool ByteCodeEmitter::emitStoreBitFieldPopSint64(SourceInfo L) {
53906	return emitOp<>(OP_StoreBitFieldPopSint64, L);
53907	}
53908	bool ByteCodeEmitter::emitStoreBitFieldPopUint64(SourceInfo L) {
53909	return emitOp<>(OP_StoreBitFieldPopUint64, L);
53910	}
53911	bool ByteCodeEmitter::emitStoreBitFieldPopIntAP(SourceInfo L) {
53912	return emitOp<>(OP_StoreBitFieldPopIntAP, L);
53913	}
53914	bool ByteCodeEmitter::emitStoreBitFieldPopIntAPS(SourceInfo L) {
53915	return emitOp<>(OP_StoreBitFieldPopIntAPS, L);
53916	}
53917	bool ByteCodeEmitter::emitStoreBitFieldPopBool(SourceInfo L) {
53918	return emitOp<>(OP_StoreBitFieldPopBool, L);
53919	}
53920	bool ByteCodeEmitter::emitStoreBitFieldPopFixedPoint(SourceInfo L) {
53921	return emitOp<>(OP_StoreBitFieldPopFixedPoint, L);
53922	}
53923	#endif
53924	#ifdef GET_EVAL_IMPL
53925	bool EvalEmitter::emitStoreBitFieldPopSint8(SourceInfo L) {
53926	if (!isActive()) return true;
53927	CurrentSource = L;
53928	return StoreBitFieldPop<PT_Sint8>(S, CodePtr());
53929	}
53930	bool EvalEmitter::emitStoreBitFieldPopUint8(SourceInfo L) {
53931	if (!isActive()) return true;
53932	CurrentSource = L;
53933	return StoreBitFieldPop<PT_Uint8>(S, CodePtr());
53934	}
53935	bool EvalEmitter::emitStoreBitFieldPopSint16(SourceInfo L) {
53936	if (!isActive()) return true;
53937	CurrentSource = L;
53938	return StoreBitFieldPop<PT_Sint16>(S, CodePtr());
53939	}
53940	bool EvalEmitter::emitStoreBitFieldPopUint16(SourceInfo L) {
53941	if (!isActive()) return true;
53942	CurrentSource = L;
53943	return StoreBitFieldPop<PT_Uint16>(S, CodePtr());
53944	}
53945	bool EvalEmitter::emitStoreBitFieldPopSint32(SourceInfo L) {
53946	if (!isActive()) return true;
53947	CurrentSource = L;
53948	return StoreBitFieldPop<PT_Sint32>(S, CodePtr());
53949	}
53950	bool EvalEmitter::emitStoreBitFieldPopUint32(SourceInfo L) {
53951	if (!isActive()) return true;
53952	CurrentSource = L;
53953	return StoreBitFieldPop<PT_Uint32>(S, CodePtr());
53954	}
53955	bool EvalEmitter::emitStoreBitFieldPopSint64(SourceInfo L) {
53956	if (!isActive()) return true;
53957	CurrentSource = L;
53958	return StoreBitFieldPop<PT_Sint64>(S, CodePtr());
53959	}
53960	bool EvalEmitter::emitStoreBitFieldPopUint64(SourceInfo L) {
53961	if (!isActive()) return true;
53962	CurrentSource = L;
53963	return StoreBitFieldPop<PT_Uint64>(S, CodePtr());
53964	}
53965	bool EvalEmitter::emitStoreBitFieldPopIntAP(SourceInfo L) {
53966	if (!isActive()) return true;
53967	CurrentSource = L;
53968	return StoreBitFieldPop<PT_IntAP>(S, CodePtr());
53969	}
53970	bool EvalEmitter::emitStoreBitFieldPopIntAPS(SourceInfo L) {
53971	if (!isActive()) return true;
53972	CurrentSource = L;
53973	return StoreBitFieldPop<PT_IntAPS>(S, CodePtr());
53974	}
53975	bool EvalEmitter::emitStoreBitFieldPopBool(SourceInfo L) {
53976	if (!isActive()) return true;
53977	CurrentSource = L;
53978	return StoreBitFieldPop<PT_Bool>(S, CodePtr());
53979	}
53980	bool EvalEmitter::emitStoreBitFieldPopFixedPoint(SourceInfo L) {
53981	if (!isActive()) return true;
53982	CurrentSource = L;
53983	return StoreBitFieldPop<PT_FixedPoint>(S, CodePtr());
53984	}
53985	#endif
53986	#ifdef GET_OPCODE_NAMES
53987	OP_StorePopSint8,
53988	OP_StorePopUint8,
53989	OP_StorePopSint16,
53990	OP_StorePopUint16,
53991	OP_StorePopSint32,
53992	OP_StorePopUint32,
53993	OP_StorePopSint64,
53994	OP_StorePopUint64,
53995	OP_StorePopIntAP,
53996	OP_StorePopIntAPS,
53997	OP_StorePopBool,
53998	OP_StorePopFixedPoint,
53999	OP_StorePopPtr,
54000	OP_StorePopMemberPtr,
54001	OP_StorePopFloat,
54002	#endif
54003	#ifdef GET_INTERPFN_LIST
54004	&Interp_StorePopSint8,
54005	&Interp_StorePopUint8,
54006	&Interp_StorePopSint16,
54007	&Interp_StorePopUint16,
54008	&Interp_StorePopSint32,
54009	&Interp_StorePopUint32,
54010	&Interp_StorePopSint64,
54011	&Interp_StorePopUint64,
54012	&Interp_StorePopIntAP,
54013	&Interp_StorePopIntAPS,
54014	&Interp_StorePopBool,
54015	&Interp_StorePopFixedPoint,
54016	&Interp_StorePopPtr,
54017	&Interp_StorePopMemberPtr,
54018	&Interp_StorePopFloat,
54019	#endif
54020	#ifdef GET_INTERPFN_DISPATCHERS
54021	PRESERVE_NONE
54022	static bool Interp_StorePopSint8(InterpState &S) {
54023	if (!StorePop<PT_Sint8>(S, S.PC)) return false;
54024	#if USE_TAILCALLS
54025	MUSTTAIL return InterpNext(S);
54026	#else
54027	return true;
54028	#endif
54029	}
54030	PRESERVE_NONE
54031	static bool Interp_StorePopUint8(InterpState &S) {
54032	if (!StorePop<PT_Uint8>(S, S.PC)) return false;
54033	#if USE_TAILCALLS
54034	MUSTTAIL return InterpNext(S);
54035	#else
54036	return true;
54037	#endif
54038	}
54039	PRESERVE_NONE
54040	static bool Interp_StorePopSint16(InterpState &S) {
54041	if (!StorePop<PT_Sint16>(S, S.PC)) return false;
54042	#if USE_TAILCALLS
54043	MUSTTAIL return InterpNext(S);
54044	#else
54045	return true;
54046	#endif
54047	}
54048	PRESERVE_NONE
54049	static bool Interp_StorePopUint16(InterpState &S) {
54050	if (!StorePop<PT_Uint16>(S, S.PC)) return false;
54051	#if USE_TAILCALLS
54052	MUSTTAIL return InterpNext(S);
54053	#else
54054	return true;
54055	#endif
54056	}
54057	PRESERVE_NONE
54058	static bool Interp_StorePopSint32(InterpState &S) {
54059	if (!StorePop<PT_Sint32>(S, S.PC)) return false;
54060	#if USE_TAILCALLS
54061	MUSTTAIL return InterpNext(S);
54062	#else
54063	return true;
54064	#endif
54065	}
54066	PRESERVE_NONE
54067	static bool Interp_StorePopUint32(InterpState &S) {
54068	if (!StorePop<PT_Uint32>(S, S.PC)) return false;
54069	#if USE_TAILCALLS
54070	MUSTTAIL return InterpNext(S);
54071	#else
54072	return true;
54073	#endif
54074	}
54075	PRESERVE_NONE
54076	static bool Interp_StorePopSint64(InterpState &S) {
54077	if (!StorePop<PT_Sint64>(S, S.PC)) return false;
54078	#if USE_TAILCALLS
54079	MUSTTAIL return InterpNext(S);
54080	#else
54081	return true;
54082	#endif
54083	}
54084	PRESERVE_NONE
54085	static bool Interp_StorePopUint64(InterpState &S) {
54086	if (!StorePop<PT_Uint64>(S, S.PC)) return false;
54087	#if USE_TAILCALLS
54088	MUSTTAIL return InterpNext(S);
54089	#else
54090	return true;
54091	#endif
54092	}
54093	PRESERVE_NONE
54094	static bool Interp_StorePopIntAP(InterpState &S) {
54095	if (!StorePop<PT_IntAP>(S, S.PC)) return false;
54096	#if USE_TAILCALLS
54097	MUSTTAIL return InterpNext(S);
54098	#else
54099	return true;
54100	#endif
54101	}
54102	PRESERVE_NONE
54103	static bool Interp_StorePopIntAPS(InterpState &S) {
54104	if (!StorePop<PT_IntAPS>(S, S.PC)) return false;
54105	#if USE_TAILCALLS
54106	MUSTTAIL return InterpNext(S);
54107	#else
54108	return true;
54109	#endif
54110	}
54111	PRESERVE_NONE
54112	static bool Interp_StorePopBool(InterpState &S) {
54113	if (!StorePop<PT_Bool>(S, S.PC)) return false;
54114	#if USE_TAILCALLS
54115	MUSTTAIL return InterpNext(S);
54116	#else
54117	return true;
54118	#endif
54119	}
54120	PRESERVE_NONE
54121	static bool Interp_StorePopFixedPoint(InterpState &S) {
54122	if (!StorePop<PT_FixedPoint>(S, S.PC)) return false;
54123	#if USE_TAILCALLS
54124	MUSTTAIL return InterpNext(S);
54125	#else
54126	return true;
54127	#endif
54128	}
54129	PRESERVE_NONE
54130	static bool Interp_StorePopPtr(InterpState &S) {
54131	if (!StorePop<PT_Ptr>(S, S.PC)) return false;
54132	#if USE_TAILCALLS
54133	MUSTTAIL return InterpNext(S);
54134	#else
54135	return true;
54136	#endif
54137	}
54138	PRESERVE_NONE
54139	static bool Interp_StorePopMemberPtr(InterpState &S) {
54140	if (!StorePop<PT_MemberPtr>(S, S.PC)) return false;
54141	#if USE_TAILCALLS
54142	MUSTTAIL return InterpNext(S);
54143	#else
54144	return true;
54145	#endif
54146	}
54147	PRESERVE_NONE
54148	static bool Interp_StorePopFloat(InterpState &S) {
54149	if (!StorePop<PT_Float>(S, S.PC)) return false;
54150	#if USE_TAILCALLS
54151	MUSTTAIL return InterpNext(S);
54152	#else
54153	return true;
54154	#endif
54155	}
54156	#endif
54157	#ifdef GET_DISASM
54158	case OP_StorePopSint8:
54159	Text.Op = PrintName("StorePopSint8");
54160	break;
54161	case OP_StorePopUint8:
54162	Text.Op = PrintName("StorePopUint8");
54163	break;
54164	case OP_StorePopSint16:
54165	Text.Op = PrintName("StorePopSint16");
54166	break;
54167	case OP_StorePopUint16:
54168	Text.Op = PrintName("StorePopUint16");
54169	break;
54170	case OP_StorePopSint32:
54171	Text.Op = PrintName("StorePopSint32");
54172	break;
54173	case OP_StorePopUint32:
54174	Text.Op = PrintName("StorePopUint32");
54175	break;
54176	case OP_StorePopSint64:
54177	Text.Op = PrintName("StorePopSint64");
54178	break;
54179	case OP_StorePopUint64:
54180	Text.Op = PrintName("StorePopUint64");
54181	break;
54182	case OP_StorePopIntAP:
54183	Text.Op = PrintName("StorePopIntAP");
54184	break;
54185	case OP_StorePopIntAPS:
54186	Text.Op = PrintName("StorePopIntAPS");
54187	break;
54188	case OP_StorePopBool:
54189	Text.Op = PrintName("StorePopBool");
54190	break;
54191	case OP_StorePopFixedPoint:
54192	Text.Op = PrintName("StorePopFixedPoint");
54193	break;
54194	case OP_StorePopPtr:
54195	Text.Op = PrintName("StorePopPtr");
54196	break;
54197	case OP_StorePopMemberPtr:
54198	Text.Op = PrintName("StorePopMemberPtr");
54199	break;
54200	case OP_StorePopFloat:
54201	Text.Op = PrintName("StorePopFloat");
54202	break;
54203	#endif
54204	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54205	bool emitStorePopSint8(SourceInfo);
54206	bool emitStorePopUint8(SourceInfo);
54207	bool emitStorePopSint16(SourceInfo);
54208	bool emitStorePopUint16(SourceInfo);
54209	bool emitStorePopSint32(SourceInfo);
54210	bool emitStorePopUint32(SourceInfo);
54211	bool emitStorePopSint64(SourceInfo);
54212	bool emitStorePopUint64(SourceInfo);
54213	bool emitStorePopIntAP(SourceInfo);
54214	bool emitStorePopIntAPS(SourceInfo);
54215	bool emitStorePopBool(SourceInfo);
54216	bool emitStorePopFixedPoint(SourceInfo);
54217	bool emitStorePopPtr(SourceInfo);
54218	bool emitStorePopMemberPtr(SourceInfo);
54219	bool emitStorePopFloat(SourceInfo);
54220	#endif
54221	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54222	[[nodiscard]] bool emitStorePop(PrimType, SourceInfo I);
54223	#endif
54224	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
54225	bool
54226	#if defined(GET_EVAL_IMPL)
54227	EvalEmitter
54228	#else
54229	ByteCodeEmitter
54230	#endif
54231	::emitStorePop(PrimType T0, SourceInfo I) {
54232	switch (T0) {
54233	case PT_Sint8:
54234	return emitStorePopSint8(I);
54235	case PT_Uint8:
54236	return emitStorePopUint8(I);
54237	case PT_Sint16:
54238	return emitStorePopSint16(I);
54239	case PT_Uint16:
54240	return emitStorePopUint16(I);
54241	case PT_Sint32:
54242	return emitStorePopSint32(I);
54243	case PT_Uint32:
54244	return emitStorePopUint32(I);
54245	case PT_Sint64:
54246	return emitStorePopSint64(I);
54247	case PT_Uint64:
54248	return emitStorePopUint64(I);
54249	case PT_IntAP:
54250	return emitStorePopIntAP(I);
54251	case PT_IntAPS:
54252	return emitStorePopIntAPS(I);
54253	case PT_Bool:
54254	return emitStorePopBool(I);
54255	case PT_FixedPoint:
54256	return emitStorePopFixedPoint(I);
54257	case PT_Ptr:
54258	return emitStorePopPtr(I);
54259	case PT_MemberPtr:
54260	return emitStorePopMemberPtr(I);
54261	case PT_Float:
54262	return emitStorePopFloat(I);
54263	}
54264	llvm_unreachable("invalid enum value");
54265	}
54266	#endif
54267	#ifdef GET_LINK_IMPL
54268	bool ByteCodeEmitter::emitStorePopSint8(SourceInfo L) {
54269	return emitOp<>(OP_StorePopSint8, L);
54270	}
54271	bool ByteCodeEmitter::emitStorePopUint8(SourceInfo L) {
54272	return emitOp<>(OP_StorePopUint8, L);
54273	}
54274	bool ByteCodeEmitter::emitStorePopSint16(SourceInfo L) {
54275	return emitOp<>(OP_StorePopSint16, L);
54276	}
54277	bool ByteCodeEmitter::emitStorePopUint16(SourceInfo L) {
54278	return emitOp<>(OP_StorePopUint16, L);
54279	}
54280	bool ByteCodeEmitter::emitStorePopSint32(SourceInfo L) {
54281	return emitOp<>(OP_StorePopSint32, L);
54282	}
54283	bool ByteCodeEmitter::emitStorePopUint32(SourceInfo L) {
54284	return emitOp<>(OP_StorePopUint32, L);
54285	}
54286	bool ByteCodeEmitter::emitStorePopSint64(SourceInfo L) {
54287	return emitOp<>(OP_StorePopSint64, L);
54288	}
54289	bool ByteCodeEmitter::emitStorePopUint64(SourceInfo L) {
54290	return emitOp<>(OP_StorePopUint64, L);
54291	}
54292	bool ByteCodeEmitter::emitStorePopIntAP(SourceInfo L) {
54293	return emitOp<>(OP_StorePopIntAP, L);
54294	}
54295	bool ByteCodeEmitter::emitStorePopIntAPS(SourceInfo L) {
54296	return emitOp<>(OP_StorePopIntAPS, L);
54297	}
54298	bool ByteCodeEmitter::emitStorePopBool(SourceInfo L) {
54299	return emitOp<>(OP_StorePopBool, L);
54300	}
54301	bool ByteCodeEmitter::emitStorePopFixedPoint(SourceInfo L) {
54302	return emitOp<>(OP_StorePopFixedPoint, L);
54303	}
54304	bool ByteCodeEmitter::emitStorePopPtr(SourceInfo L) {
54305	return emitOp<>(OP_StorePopPtr, L);
54306	}
54307	bool ByteCodeEmitter::emitStorePopMemberPtr(SourceInfo L) {
54308	return emitOp<>(OP_StorePopMemberPtr, L);
54309	}
54310	bool ByteCodeEmitter::emitStorePopFloat(SourceInfo L) {
54311	return emitOp<>(OP_StorePopFloat, L);
54312	}
54313	#endif
54314	#ifdef GET_EVAL_IMPL
54315	bool EvalEmitter::emitStorePopSint8(SourceInfo L) {
54316	if (!isActive()) return true;
54317	CurrentSource = L;
54318	return StorePop<PT_Sint8>(S, CodePtr());
54319	}
54320	bool EvalEmitter::emitStorePopUint8(SourceInfo L) {
54321	if (!isActive()) return true;
54322	CurrentSource = L;
54323	return StorePop<PT_Uint8>(S, CodePtr());
54324	}
54325	bool EvalEmitter::emitStorePopSint16(SourceInfo L) {
54326	if (!isActive()) return true;
54327	CurrentSource = L;
54328	return StorePop<PT_Sint16>(S, CodePtr());
54329	}
54330	bool EvalEmitter::emitStorePopUint16(SourceInfo L) {
54331	if (!isActive()) return true;
54332	CurrentSource = L;
54333	return StorePop<PT_Uint16>(S, CodePtr());
54334	}
54335	bool EvalEmitter::emitStorePopSint32(SourceInfo L) {
54336	if (!isActive()) return true;
54337	CurrentSource = L;
54338	return StorePop<PT_Sint32>(S, CodePtr());
54339	}
54340	bool EvalEmitter::emitStorePopUint32(SourceInfo L) {
54341	if (!isActive()) return true;
54342	CurrentSource = L;
54343	return StorePop<PT_Uint32>(S, CodePtr());
54344	}
54345	bool EvalEmitter::emitStorePopSint64(SourceInfo L) {
54346	if (!isActive()) return true;
54347	CurrentSource = L;
54348	return StorePop<PT_Sint64>(S, CodePtr());
54349	}
54350	bool EvalEmitter::emitStorePopUint64(SourceInfo L) {
54351	if (!isActive()) return true;
54352	CurrentSource = L;
54353	return StorePop<PT_Uint64>(S, CodePtr());
54354	}
54355	bool EvalEmitter::emitStorePopIntAP(SourceInfo L) {
54356	if (!isActive()) return true;
54357	CurrentSource = L;
54358	return StorePop<PT_IntAP>(S, CodePtr());
54359	}
54360	bool EvalEmitter::emitStorePopIntAPS(SourceInfo L) {
54361	if (!isActive()) return true;
54362	CurrentSource = L;
54363	return StorePop<PT_IntAPS>(S, CodePtr());
54364	}
54365	bool EvalEmitter::emitStorePopBool(SourceInfo L) {
54366	if (!isActive()) return true;
54367	CurrentSource = L;
54368	return StorePop<PT_Bool>(S, CodePtr());
54369	}
54370	bool EvalEmitter::emitStorePopFixedPoint(SourceInfo L) {
54371	if (!isActive()) return true;
54372	CurrentSource = L;
54373	return StorePop<PT_FixedPoint>(S, CodePtr());
54374	}
54375	bool EvalEmitter::emitStorePopPtr(SourceInfo L) {
54376	if (!isActive()) return true;
54377	CurrentSource = L;
54378	return StorePop<PT_Ptr>(S, CodePtr());
54379	}
54380	bool EvalEmitter::emitStorePopMemberPtr(SourceInfo L) {
54381	if (!isActive()) return true;
54382	CurrentSource = L;
54383	return StorePop<PT_MemberPtr>(S, CodePtr());
54384	}
54385	bool EvalEmitter::emitStorePopFloat(SourceInfo L) {
54386	if (!isActive()) return true;
54387	CurrentSource = L;
54388	return StorePop<PT_Float>(S, CodePtr());
54389	}
54390	#endif
54391	#ifdef GET_OPCODE_NAMES
54392	OP_SubSint8,
54393	OP_SubUint8,
54394	OP_SubSint16,
54395	OP_SubUint16,
54396	OP_SubSint32,
54397	OP_SubUint32,
54398	OP_SubSint64,
54399	OP_SubUint64,
54400	OP_SubIntAP,
54401	OP_SubIntAPS,
54402	OP_SubBool,
54403	OP_SubFixedPoint,
54404	#endif
54405	#ifdef GET_INTERPFN_LIST
54406	&Interp_SubSint8,
54407	&Interp_SubUint8,
54408	&Interp_SubSint16,
54409	&Interp_SubUint16,
54410	&Interp_SubSint32,
54411	&Interp_SubUint32,
54412	&Interp_SubSint64,
54413	&Interp_SubUint64,
54414	&Interp_SubIntAP,
54415	&Interp_SubIntAPS,
54416	&Interp_SubBool,
54417	&Interp_SubFixedPoint,
54418	#endif
54419	#ifdef GET_INTERPFN_DISPATCHERS
54420	PRESERVE_NONE
54421	static bool Interp_SubSint8(InterpState &S) {
54422	if (!Sub<PT_Sint8>(S, S.PC)) return false;
54423	#if USE_TAILCALLS
54424	MUSTTAIL return InterpNext(S);
54425	#else
54426	return true;
54427	#endif
54428	}
54429	PRESERVE_NONE
54430	static bool Interp_SubUint8(InterpState &S) {
54431	if (!Sub<PT_Uint8>(S, S.PC)) return false;
54432	#if USE_TAILCALLS
54433	MUSTTAIL return InterpNext(S);
54434	#else
54435	return true;
54436	#endif
54437	}
54438	PRESERVE_NONE
54439	static bool Interp_SubSint16(InterpState &S) {
54440	if (!Sub<PT_Sint16>(S, S.PC)) return false;
54441	#if USE_TAILCALLS
54442	MUSTTAIL return InterpNext(S);
54443	#else
54444	return true;
54445	#endif
54446	}
54447	PRESERVE_NONE
54448	static bool Interp_SubUint16(InterpState &S) {
54449	if (!Sub<PT_Uint16>(S, S.PC)) return false;
54450	#if USE_TAILCALLS
54451	MUSTTAIL return InterpNext(S);
54452	#else
54453	return true;
54454	#endif
54455	}
54456	PRESERVE_NONE
54457	static bool Interp_SubSint32(InterpState &S) {
54458	if (!Sub<PT_Sint32>(S, S.PC)) return false;
54459	#if USE_TAILCALLS
54460	MUSTTAIL return InterpNext(S);
54461	#else
54462	return true;
54463	#endif
54464	}
54465	PRESERVE_NONE
54466	static bool Interp_SubUint32(InterpState &S) {
54467	if (!Sub<PT_Uint32>(S, S.PC)) return false;
54468	#if USE_TAILCALLS
54469	MUSTTAIL return InterpNext(S);
54470	#else
54471	return true;
54472	#endif
54473	}
54474	PRESERVE_NONE
54475	static bool Interp_SubSint64(InterpState &S) {
54476	if (!Sub<PT_Sint64>(S, S.PC)) return false;
54477	#if USE_TAILCALLS
54478	MUSTTAIL return InterpNext(S);
54479	#else
54480	return true;
54481	#endif
54482	}
54483	PRESERVE_NONE
54484	static bool Interp_SubUint64(InterpState &S) {
54485	if (!Sub<PT_Uint64>(S, S.PC)) return false;
54486	#if USE_TAILCALLS
54487	MUSTTAIL return InterpNext(S);
54488	#else
54489	return true;
54490	#endif
54491	}
54492	PRESERVE_NONE
54493	static bool Interp_SubIntAP(InterpState &S) {
54494	if (!Sub<PT_IntAP>(S, S.PC)) return false;
54495	#if USE_TAILCALLS
54496	MUSTTAIL return InterpNext(S);
54497	#else
54498	return true;
54499	#endif
54500	}
54501	PRESERVE_NONE
54502	static bool Interp_SubIntAPS(InterpState &S) {
54503	if (!Sub<PT_IntAPS>(S, S.PC)) return false;
54504	#if USE_TAILCALLS
54505	MUSTTAIL return InterpNext(S);
54506	#else
54507	return true;
54508	#endif
54509	}
54510	PRESERVE_NONE
54511	static bool Interp_SubBool(InterpState &S) {
54512	if (!Sub<PT_Bool>(S, S.PC)) return false;
54513	#if USE_TAILCALLS
54514	MUSTTAIL return InterpNext(S);
54515	#else
54516	return true;
54517	#endif
54518	}
54519	PRESERVE_NONE
54520	static bool Interp_SubFixedPoint(InterpState &S) {
54521	if (!Sub<PT_FixedPoint>(S, S.PC)) return false;
54522	#if USE_TAILCALLS
54523	MUSTTAIL return InterpNext(S);
54524	#else
54525	return true;
54526	#endif
54527	}
54528	#endif
54529	#ifdef GET_DISASM
54530	case OP_SubSint8:
54531	Text.Op = PrintName("SubSint8");
54532	break;
54533	case OP_SubUint8:
54534	Text.Op = PrintName("SubUint8");
54535	break;
54536	case OP_SubSint16:
54537	Text.Op = PrintName("SubSint16");
54538	break;
54539	case OP_SubUint16:
54540	Text.Op = PrintName("SubUint16");
54541	break;
54542	case OP_SubSint32:
54543	Text.Op = PrintName("SubSint32");
54544	break;
54545	case OP_SubUint32:
54546	Text.Op = PrintName("SubUint32");
54547	break;
54548	case OP_SubSint64:
54549	Text.Op = PrintName("SubSint64");
54550	break;
54551	case OP_SubUint64:
54552	Text.Op = PrintName("SubUint64");
54553	break;
54554	case OP_SubIntAP:
54555	Text.Op = PrintName("SubIntAP");
54556	break;
54557	case OP_SubIntAPS:
54558	Text.Op = PrintName("SubIntAPS");
54559	break;
54560	case OP_SubBool:
54561	Text.Op = PrintName("SubBool");
54562	break;
54563	case OP_SubFixedPoint:
54564	Text.Op = PrintName("SubFixedPoint");
54565	break;
54566	#endif
54567	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54568	bool emitSubSint8(SourceInfo);
54569	bool emitSubUint8(SourceInfo);
54570	bool emitSubSint16(SourceInfo);
54571	bool emitSubUint16(SourceInfo);
54572	bool emitSubSint32(SourceInfo);
54573	bool emitSubUint32(SourceInfo);
54574	bool emitSubSint64(SourceInfo);
54575	bool emitSubUint64(SourceInfo);
54576	bool emitSubIntAP(SourceInfo);
54577	bool emitSubIntAPS(SourceInfo);
54578	bool emitSubBool(SourceInfo);
54579	bool emitSubFixedPoint(SourceInfo);
54580	#endif
54581	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54582	[[nodiscard]] bool emitSub(PrimType, SourceInfo I);
54583	#endif
54584	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
54585	bool
54586	#if defined(GET_EVAL_IMPL)
54587	EvalEmitter
54588	#else
54589	ByteCodeEmitter
54590	#endif
54591	::emitSub(PrimType T0, SourceInfo I) {
54592	switch (T0) {
54593	case PT_Sint8:
54594	return emitSubSint8(I);
54595	case PT_Uint8:
54596	return emitSubUint8(I);
54597	case PT_Sint16:
54598	return emitSubSint16(I);
54599	case PT_Uint16:
54600	return emitSubUint16(I);
54601	case PT_Sint32:
54602	return emitSubSint32(I);
54603	case PT_Uint32:
54604	return emitSubUint32(I);
54605	case PT_Sint64:
54606	return emitSubSint64(I);
54607	case PT_Uint64:
54608	return emitSubUint64(I);
54609	case PT_IntAP:
54610	return emitSubIntAP(I);
54611	case PT_IntAPS:
54612	return emitSubIntAPS(I);
54613	case PT_Bool:
54614	return emitSubBool(I);
54615	case PT_FixedPoint:
54616	return emitSubFixedPoint(I);
54617	default: llvm_unreachable("invalid type: emitSub");
54618	}
54619	llvm_unreachable("invalid enum value");
54620	}
54621	#endif
54622	#ifdef GET_LINK_IMPL
54623	bool ByteCodeEmitter::emitSubSint8(SourceInfo L) {
54624	return emitOp<>(OP_SubSint8, L);
54625	}
54626	bool ByteCodeEmitter::emitSubUint8(SourceInfo L) {
54627	return emitOp<>(OP_SubUint8, L);
54628	}
54629	bool ByteCodeEmitter::emitSubSint16(SourceInfo L) {
54630	return emitOp<>(OP_SubSint16, L);
54631	}
54632	bool ByteCodeEmitter::emitSubUint16(SourceInfo L) {
54633	return emitOp<>(OP_SubUint16, L);
54634	}
54635	bool ByteCodeEmitter::emitSubSint32(SourceInfo L) {
54636	return emitOp<>(OP_SubSint32, L);
54637	}
54638	bool ByteCodeEmitter::emitSubUint32(SourceInfo L) {
54639	return emitOp<>(OP_SubUint32, L);
54640	}
54641	bool ByteCodeEmitter::emitSubSint64(SourceInfo L) {
54642	return emitOp<>(OP_SubSint64, L);
54643	}
54644	bool ByteCodeEmitter::emitSubUint64(SourceInfo L) {
54645	return emitOp<>(OP_SubUint64, L);
54646	}
54647	bool ByteCodeEmitter::emitSubIntAP(SourceInfo L) {
54648	return emitOp<>(OP_SubIntAP, L);
54649	}
54650	bool ByteCodeEmitter::emitSubIntAPS(SourceInfo L) {
54651	return emitOp<>(OP_SubIntAPS, L);
54652	}
54653	bool ByteCodeEmitter::emitSubBool(SourceInfo L) {
54654	return emitOp<>(OP_SubBool, L);
54655	}
54656	bool ByteCodeEmitter::emitSubFixedPoint(SourceInfo L) {
54657	return emitOp<>(OP_SubFixedPoint, L);
54658	}
54659	#endif
54660	#ifdef GET_EVAL_IMPL
54661	bool EvalEmitter::emitSubSint8(SourceInfo L) {
54662	if (!isActive()) return true;
54663	CurrentSource = L;
54664	return Sub<PT_Sint8>(S, CodePtr());
54665	}
54666	bool EvalEmitter::emitSubUint8(SourceInfo L) {
54667	if (!isActive()) return true;
54668	CurrentSource = L;
54669	return Sub<PT_Uint8>(S, CodePtr());
54670	}
54671	bool EvalEmitter::emitSubSint16(SourceInfo L) {
54672	if (!isActive()) return true;
54673	CurrentSource = L;
54674	return Sub<PT_Sint16>(S, CodePtr());
54675	}
54676	bool EvalEmitter::emitSubUint16(SourceInfo L) {
54677	if (!isActive()) return true;
54678	CurrentSource = L;
54679	return Sub<PT_Uint16>(S, CodePtr());
54680	}
54681	bool EvalEmitter::emitSubSint32(SourceInfo L) {
54682	if (!isActive()) return true;
54683	CurrentSource = L;
54684	return Sub<PT_Sint32>(S, CodePtr());
54685	}
54686	bool EvalEmitter::emitSubUint32(SourceInfo L) {
54687	if (!isActive()) return true;
54688	CurrentSource = L;
54689	return Sub<PT_Uint32>(S, CodePtr());
54690	}
54691	bool EvalEmitter::emitSubSint64(SourceInfo L) {
54692	if (!isActive()) return true;
54693	CurrentSource = L;
54694	return Sub<PT_Sint64>(S, CodePtr());
54695	}
54696	bool EvalEmitter::emitSubUint64(SourceInfo L) {
54697	if (!isActive()) return true;
54698	CurrentSource = L;
54699	return Sub<PT_Uint64>(S, CodePtr());
54700	}
54701	bool EvalEmitter::emitSubIntAP(SourceInfo L) {
54702	if (!isActive()) return true;
54703	CurrentSource = L;
54704	return Sub<PT_IntAP>(S, CodePtr());
54705	}
54706	bool EvalEmitter::emitSubIntAPS(SourceInfo L) {
54707	if (!isActive()) return true;
54708	CurrentSource = L;
54709	return Sub<PT_IntAPS>(S, CodePtr());
54710	}
54711	bool EvalEmitter::emitSubBool(SourceInfo L) {
54712	if (!isActive()) return true;
54713	CurrentSource = L;
54714	return Sub<PT_Bool>(S, CodePtr());
54715	}
54716	bool EvalEmitter::emitSubFixedPoint(SourceInfo L) {
54717	if (!isActive()) return true;
54718	CurrentSource = L;
54719	return Sub<PT_FixedPoint>(S, CodePtr());
54720	}
54721	#endif
54722	#ifdef GET_OPCODE_NAMES
54723	OP_SubOffsetSint8,
54724	OP_SubOffsetUint8,
54725	OP_SubOffsetSint16,
54726	OP_SubOffsetUint16,
54727	OP_SubOffsetSint32,
54728	OP_SubOffsetUint32,
54729	OP_SubOffsetSint64,
54730	OP_SubOffsetUint64,
54731	OP_SubOffsetIntAP,
54732	OP_SubOffsetIntAPS,
54733	OP_SubOffsetBool,
54734	#endif
54735	#ifdef GET_INTERPFN_LIST
54736	&Interp_SubOffsetSint8,
54737	&Interp_SubOffsetUint8,
54738	&Interp_SubOffsetSint16,
54739	&Interp_SubOffsetUint16,
54740	&Interp_SubOffsetSint32,
54741	&Interp_SubOffsetUint32,
54742	&Interp_SubOffsetSint64,
54743	&Interp_SubOffsetUint64,
54744	&Interp_SubOffsetIntAP,
54745	&Interp_SubOffsetIntAPS,
54746	&Interp_SubOffsetBool,
54747	#endif
54748	#ifdef GET_INTERPFN_DISPATCHERS
54749	PRESERVE_NONE
54750	static bool Interp_SubOffsetSint8(InterpState &S) {
54751	if (!SubOffset<PT_Sint8>(S, S.PC)) return false;
54752	#if USE_TAILCALLS
54753	MUSTTAIL return InterpNext(S);
54754	#else
54755	return true;
54756	#endif
54757	}
54758	PRESERVE_NONE
54759	static bool Interp_SubOffsetUint8(InterpState &S) {
54760	if (!SubOffset<PT_Uint8>(S, S.PC)) return false;
54761	#if USE_TAILCALLS
54762	MUSTTAIL return InterpNext(S);
54763	#else
54764	return true;
54765	#endif
54766	}
54767	PRESERVE_NONE
54768	static bool Interp_SubOffsetSint16(InterpState &S) {
54769	if (!SubOffset<PT_Sint16>(S, S.PC)) return false;
54770	#if USE_TAILCALLS
54771	MUSTTAIL return InterpNext(S);
54772	#else
54773	return true;
54774	#endif
54775	}
54776	PRESERVE_NONE
54777	static bool Interp_SubOffsetUint16(InterpState &S) {
54778	if (!SubOffset<PT_Uint16>(S, S.PC)) return false;
54779	#if USE_TAILCALLS
54780	MUSTTAIL return InterpNext(S);
54781	#else
54782	return true;
54783	#endif
54784	}
54785	PRESERVE_NONE
54786	static bool Interp_SubOffsetSint32(InterpState &S) {
54787	if (!SubOffset<PT_Sint32>(S, S.PC)) return false;
54788	#if USE_TAILCALLS
54789	MUSTTAIL return InterpNext(S);
54790	#else
54791	return true;
54792	#endif
54793	}
54794	PRESERVE_NONE
54795	static bool Interp_SubOffsetUint32(InterpState &S) {
54796	if (!SubOffset<PT_Uint32>(S, S.PC)) return false;
54797	#if USE_TAILCALLS
54798	MUSTTAIL return InterpNext(S);
54799	#else
54800	return true;
54801	#endif
54802	}
54803	PRESERVE_NONE
54804	static bool Interp_SubOffsetSint64(InterpState &S) {
54805	if (!SubOffset<PT_Sint64>(S, S.PC)) return false;
54806	#if USE_TAILCALLS
54807	MUSTTAIL return InterpNext(S);
54808	#else
54809	return true;
54810	#endif
54811	}
54812	PRESERVE_NONE
54813	static bool Interp_SubOffsetUint64(InterpState &S) {
54814	if (!SubOffset<PT_Uint64>(S, S.PC)) return false;
54815	#if USE_TAILCALLS
54816	MUSTTAIL return InterpNext(S);
54817	#else
54818	return true;
54819	#endif
54820	}
54821	PRESERVE_NONE
54822	static bool Interp_SubOffsetIntAP(InterpState &S) {
54823	if (!SubOffset<PT_IntAP>(S, S.PC)) return false;
54824	#if USE_TAILCALLS
54825	MUSTTAIL return InterpNext(S);
54826	#else
54827	return true;
54828	#endif
54829	}
54830	PRESERVE_NONE
54831	static bool Interp_SubOffsetIntAPS(InterpState &S) {
54832	if (!SubOffset<PT_IntAPS>(S, S.PC)) return false;
54833	#if USE_TAILCALLS
54834	MUSTTAIL return InterpNext(S);
54835	#else
54836	return true;
54837	#endif
54838	}
54839	PRESERVE_NONE
54840	static bool Interp_SubOffsetBool(InterpState &S) {
54841	if (!SubOffset<PT_Bool>(S, S.PC)) return false;
54842	#if USE_TAILCALLS
54843	MUSTTAIL return InterpNext(S);
54844	#else
54845	return true;
54846	#endif
54847	}
54848	#endif
54849	#ifdef GET_DISASM
54850	case OP_SubOffsetSint8:
54851	Text.Op = PrintName("SubOffsetSint8");
54852	break;
54853	case OP_SubOffsetUint8:
54854	Text.Op = PrintName("SubOffsetUint8");
54855	break;
54856	case OP_SubOffsetSint16:
54857	Text.Op = PrintName("SubOffsetSint16");
54858	break;
54859	case OP_SubOffsetUint16:
54860	Text.Op = PrintName("SubOffsetUint16");
54861	break;
54862	case OP_SubOffsetSint32:
54863	Text.Op = PrintName("SubOffsetSint32");
54864	break;
54865	case OP_SubOffsetUint32:
54866	Text.Op = PrintName("SubOffsetUint32");
54867	break;
54868	case OP_SubOffsetSint64:
54869	Text.Op = PrintName("SubOffsetSint64");
54870	break;
54871	case OP_SubOffsetUint64:
54872	Text.Op = PrintName("SubOffsetUint64");
54873	break;
54874	case OP_SubOffsetIntAP:
54875	Text.Op = PrintName("SubOffsetIntAP");
54876	break;
54877	case OP_SubOffsetIntAPS:
54878	Text.Op = PrintName("SubOffsetIntAPS");
54879	break;
54880	case OP_SubOffsetBool:
54881	Text.Op = PrintName("SubOffsetBool");
54882	break;
54883	#endif
54884	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54885	bool emitSubOffsetSint8(SourceInfo);
54886	bool emitSubOffsetUint8(SourceInfo);
54887	bool emitSubOffsetSint16(SourceInfo);
54888	bool emitSubOffsetUint16(SourceInfo);
54889	bool emitSubOffsetSint32(SourceInfo);
54890	bool emitSubOffsetUint32(SourceInfo);
54891	bool emitSubOffsetSint64(SourceInfo);
54892	bool emitSubOffsetUint64(SourceInfo);
54893	bool emitSubOffsetIntAP(SourceInfo);
54894	bool emitSubOffsetIntAPS(SourceInfo);
54895	bool emitSubOffsetBool(SourceInfo);
54896	#endif
54897	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
54898	[[nodiscard]] bool emitSubOffset(PrimType, SourceInfo I);
54899	#endif
54900	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
54901	bool
54902	#if defined(GET_EVAL_IMPL)
54903	EvalEmitter
54904	#else
54905	ByteCodeEmitter
54906	#endif
54907	::emitSubOffset(PrimType T0, SourceInfo I) {
54908	switch (T0) {
54909	case PT_Sint8:
54910	return emitSubOffsetSint8(I);
54911	case PT_Uint8:
54912	return emitSubOffsetUint8(I);
54913	case PT_Sint16:
54914	return emitSubOffsetSint16(I);
54915	case PT_Uint16:
54916	return emitSubOffsetUint16(I);
54917	case PT_Sint32:
54918	return emitSubOffsetSint32(I);
54919	case PT_Uint32:
54920	return emitSubOffsetUint32(I);
54921	case PT_Sint64:
54922	return emitSubOffsetSint64(I);
54923	case PT_Uint64:
54924	return emitSubOffsetUint64(I);
54925	case PT_IntAP:
54926	return emitSubOffsetIntAP(I);
54927	case PT_IntAPS:
54928	return emitSubOffsetIntAPS(I);
54929	case PT_Bool:
54930	return emitSubOffsetBool(I);
54931	default: llvm_unreachable("invalid type: emitSubOffset");
54932	}
54933	llvm_unreachable("invalid enum value");
54934	}
54935	#endif
54936	#ifdef GET_LINK_IMPL
54937	bool ByteCodeEmitter::emitSubOffsetSint8(SourceInfo L) {
54938	return emitOp<>(OP_SubOffsetSint8, L);
54939	}
54940	bool ByteCodeEmitter::emitSubOffsetUint8(SourceInfo L) {
54941	return emitOp<>(OP_SubOffsetUint8, L);
54942	}
54943	bool ByteCodeEmitter::emitSubOffsetSint16(SourceInfo L) {
54944	return emitOp<>(OP_SubOffsetSint16, L);
54945	}
54946	bool ByteCodeEmitter::emitSubOffsetUint16(SourceInfo L) {
54947	return emitOp<>(OP_SubOffsetUint16, L);
54948	}
54949	bool ByteCodeEmitter::emitSubOffsetSint32(SourceInfo L) {
54950	return emitOp<>(OP_SubOffsetSint32, L);
54951	}
54952	bool ByteCodeEmitter::emitSubOffsetUint32(SourceInfo L) {
54953	return emitOp<>(OP_SubOffsetUint32, L);
54954	}
54955	bool ByteCodeEmitter::emitSubOffsetSint64(SourceInfo L) {
54956	return emitOp<>(OP_SubOffsetSint64, L);
54957	}
54958	bool ByteCodeEmitter::emitSubOffsetUint64(SourceInfo L) {
54959	return emitOp<>(OP_SubOffsetUint64, L);
54960	}
54961	bool ByteCodeEmitter::emitSubOffsetIntAP(SourceInfo L) {
54962	return emitOp<>(OP_SubOffsetIntAP, L);
54963	}
54964	bool ByteCodeEmitter::emitSubOffsetIntAPS(SourceInfo L) {
54965	return emitOp<>(OP_SubOffsetIntAPS, L);
54966	}
54967	bool ByteCodeEmitter::emitSubOffsetBool(SourceInfo L) {
54968	return emitOp<>(OP_SubOffsetBool, L);
54969	}
54970	#endif
54971	#ifdef GET_EVAL_IMPL
54972	bool EvalEmitter::emitSubOffsetSint8(SourceInfo L) {
54973	if (!isActive()) return true;
54974	CurrentSource = L;
54975	return SubOffset<PT_Sint8>(S, CodePtr());
54976	}
54977	bool EvalEmitter::emitSubOffsetUint8(SourceInfo L) {
54978	if (!isActive()) return true;
54979	CurrentSource = L;
54980	return SubOffset<PT_Uint8>(S, CodePtr());
54981	}
54982	bool EvalEmitter::emitSubOffsetSint16(SourceInfo L) {
54983	if (!isActive()) return true;
54984	CurrentSource = L;
54985	return SubOffset<PT_Sint16>(S, CodePtr());
54986	}
54987	bool EvalEmitter::emitSubOffsetUint16(SourceInfo L) {
54988	if (!isActive()) return true;
54989	CurrentSource = L;
54990	return SubOffset<PT_Uint16>(S, CodePtr());
54991	}
54992	bool EvalEmitter::emitSubOffsetSint32(SourceInfo L) {
54993	if (!isActive()) return true;
54994	CurrentSource = L;
54995	return SubOffset<PT_Sint32>(S, CodePtr());
54996	}
54997	bool EvalEmitter::emitSubOffsetUint32(SourceInfo L) {
54998	if (!isActive()) return true;
54999	CurrentSource = L;
55000	return SubOffset<PT_Uint32>(S, CodePtr());
55001	}
55002	bool EvalEmitter::emitSubOffsetSint64(SourceInfo L) {
55003	if (!isActive()) return true;
55004	CurrentSource = L;
55005	return SubOffset<PT_Sint64>(S, CodePtr());
55006	}
55007	bool EvalEmitter::emitSubOffsetUint64(SourceInfo L) {
55008	if (!isActive()) return true;
55009	CurrentSource = L;
55010	return SubOffset<PT_Uint64>(S, CodePtr());
55011	}
55012	bool EvalEmitter::emitSubOffsetIntAP(SourceInfo L) {
55013	if (!isActive()) return true;
55014	CurrentSource = L;
55015	return SubOffset<PT_IntAP>(S, CodePtr());
55016	}
55017	bool EvalEmitter::emitSubOffsetIntAPS(SourceInfo L) {
55018	if (!isActive()) return true;
55019	CurrentSource = L;
55020	return SubOffset<PT_IntAPS>(S, CodePtr());
55021	}
55022	bool EvalEmitter::emitSubOffsetBool(SourceInfo L) {
55023	if (!isActive()) return true;
55024	CurrentSource = L;
55025	return SubOffset<PT_Bool>(S, CodePtr());
55026	}
55027	#endif
55028	#ifdef GET_OPCODE_NAMES
55029	OP_SubPtrSint8,
55030	OP_SubPtrUint8,
55031	OP_SubPtrSint16,
55032	OP_SubPtrUint16,
55033	OP_SubPtrSint32,
55034	OP_SubPtrUint32,
55035	OP_SubPtrSint64,
55036	OP_SubPtrUint64,
55037	OP_SubPtrIntAP,
55038	OP_SubPtrIntAPS,
55039	#endif
55040	#ifdef GET_INTERPFN_LIST
55041	&Interp_SubPtrSint8,
55042	&Interp_SubPtrUint8,
55043	&Interp_SubPtrSint16,
55044	&Interp_SubPtrUint16,
55045	&Interp_SubPtrSint32,
55046	&Interp_SubPtrUint32,
55047	&Interp_SubPtrSint64,
55048	&Interp_SubPtrUint64,
55049	&Interp_SubPtrIntAP,
55050	&Interp_SubPtrIntAPS,
55051	#endif
55052	#ifdef GET_INTERPFN_DISPATCHERS
55053	PRESERVE_NONE
55054	static bool Interp_SubPtrSint8(InterpState &S) {
55055	{
55056	CodePtr OpPC = S.PC;
55057	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55058	if (!SubPtr<PT_Sint8>(S, OpPC, V0)) return false;
55059	}
55060	#if USE_TAILCALLS
55061	MUSTTAIL return InterpNext(S);
55062	#else
55063	return true;
55064	#endif
55065	}
55066	PRESERVE_NONE
55067	static bool Interp_SubPtrUint8(InterpState &S) {
55068	{
55069	CodePtr OpPC = S.PC;
55070	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55071	if (!SubPtr<PT_Uint8>(S, OpPC, V0)) return false;
55072	}
55073	#if USE_TAILCALLS
55074	MUSTTAIL return InterpNext(S);
55075	#else
55076	return true;
55077	#endif
55078	}
55079	PRESERVE_NONE
55080	static bool Interp_SubPtrSint16(InterpState &S) {
55081	{
55082	CodePtr OpPC = S.PC;
55083	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55084	if (!SubPtr<PT_Sint16>(S, OpPC, V0)) return false;
55085	}
55086	#if USE_TAILCALLS
55087	MUSTTAIL return InterpNext(S);
55088	#else
55089	return true;
55090	#endif
55091	}
55092	PRESERVE_NONE
55093	static bool Interp_SubPtrUint16(InterpState &S) {
55094	{
55095	CodePtr OpPC = S.PC;
55096	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55097	if (!SubPtr<PT_Uint16>(S, OpPC, V0)) return false;
55098	}
55099	#if USE_TAILCALLS
55100	MUSTTAIL return InterpNext(S);
55101	#else
55102	return true;
55103	#endif
55104	}
55105	PRESERVE_NONE
55106	static bool Interp_SubPtrSint32(InterpState &S) {
55107	{
55108	CodePtr OpPC = S.PC;
55109	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55110	if (!SubPtr<PT_Sint32>(S, OpPC, V0)) return false;
55111	}
55112	#if USE_TAILCALLS
55113	MUSTTAIL return InterpNext(S);
55114	#else
55115	return true;
55116	#endif
55117	}
55118	PRESERVE_NONE
55119	static bool Interp_SubPtrUint32(InterpState &S) {
55120	{
55121	CodePtr OpPC = S.PC;
55122	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55123	if (!SubPtr<PT_Uint32>(S, OpPC, V0)) return false;
55124	}
55125	#if USE_TAILCALLS
55126	MUSTTAIL return InterpNext(S);
55127	#else
55128	return true;
55129	#endif
55130	}
55131	PRESERVE_NONE
55132	static bool Interp_SubPtrSint64(InterpState &S) {
55133	{
55134	CodePtr OpPC = S.PC;
55135	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55136	if (!SubPtr<PT_Sint64>(S, OpPC, V0)) return false;
55137	}
55138	#if USE_TAILCALLS
55139	MUSTTAIL return InterpNext(S);
55140	#else
55141	return true;
55142	#endif
55143	}
55144	PRESERVE_NONE
55145	static bool Interp_SubPtrUint64(InterpState &S) {
55146	{
55147	CodePtr OpPC = S.PC;
55148	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55149	if (!SubPtr<PT_Uint64>(S, OpPC, V0)) return false;
55150	}
55151	#if USE_TAILCALLS
55152	MUSTTAIL return InterpNext(S);
55153	#else
55154	return true;
55155	#endif
55156	}
55157	PRESERVE_NONE
55158	static bool Interp_SubPtrIntAP(InterpState &S) {
55159	{
55160	CodePtr OpPC = S.PC;
55161	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55162	if (!SubPtr<PT_IntAP>(S, OpPC, V0)) return false;
55163	}
55164	#if USE_TAILCALLS
55165	MUSTTAIL return InterpNext(S);
55166	#else
55167	return true;
55168	#endif
55169	}
55170	PRESERVE_NONE
55171	static bool Interp_SubPtrIntAPS(InterpState &S) {
55172	{
55173	CodePtr OpPC = S.PC;
55174	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55175	if (!SubPtr<PT_IntAPS>(S, OpPC, V0)) return false;
55176	}
55177	#if USE_TAILCALLS
55178	MUSTTAIL return InterpNext(S);
55179	#else
55180	return true;
55181	#endif
55182	}
55183	#endif
55184	#ifdef GET_DISASM
55185	case OP_SubPtrSint8:
55186	Text.Op = PrintName("SubPtrSint8");
55187	Text.Args.push_back(printArg<uint32_t>(P, PC));
55188	break;
55189	case OP_SubPtrUint8:
55190	Text.Op = PrintName("SubPtrUint8");
55191	Text.Args.push_back(printArg<uint32_t>(P, PC));
55192	break;
55193	case OP_SubPtrSint16:
55194	Text.Op = PrintName("SubPtrSint16");
55195	Text.Args.push_back(printArg<uint32_t>(P, PC));
55196	break;
55197	case OP_SubPtrUint16:
55198	Text.Op = PrintName("SubPtrUint16");
55199	Text.Args.push_back(printArg<uint32_t>(P, PC));
55200	break;
55201	case OP_SubPtrSint32:
55202	Text.Op = PrintName("SubPtrSint32");
55203	Text.Args.push_back(printArg<uint32_t>(P, PC));
55204	break;
55205	case OP_SubPtrUint32:
55206	Text.Op = PrintName("SubPtrUint32");
55207	Text.Args.push_back(printArg<uint32_t>(P, PC));
55208	break;
55209	case OP_SubPtrSint64:
55210	Text.Op = PrintName("SubPtrSint64");
55211	Text.Args.push_back(printArg<uint32_t>(P, PC));
55212	break;
55213	case OP_SubPtrUint64:
55214	Text.Op = PrintName("SubPtrUint64");
55215	Text.Args.push_back(printArg<uint32_t>(P, PC));
55216	break;
55217	case OP_SubPtrIntAP:
55218	Text.Op = PrintName("SubPtrIntAP");
55219	Text.Args.push_back(printArg<uint32_t>(P, PC));
55220	break;
55221	case OP_SubPtrIntAPS:
55222	Text.Op = PrintName("SubPtrIntAPS");
55223	Text.Args.push_back(printArg<uint32_t>(P, PC));
55224	break;
55225	#endif
55226	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55227	bool emitSubPtrSint8( uint32_t , SourceInfo);
55228	bool emitSubPtrUint8( uint32_t , SourceInfo);
55229	bool emitSubPtrSint16( uint32_t , SourceInfo);
55230	bool emitSubPtrUint16( uint32_t , SourceInfo);
55231	bool emitSubPtrSint32( uint32_t , SourceInfo);
55232	bool emitSubPtrUint32( uint32_t , SourceInfo);
55233	bool emitSubPtrSint64( uint32_t , SourceInfo);
55234	bool emitSubPtrUint64( uint32_t , SourceInfo);
55235	bool emitSubPtrIntAP( uint32_t , SourceInfo);
55236	bool emitSubPtrIntAPS( uint32_t , SourceInfo);
55237	#endif
55238	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55239	[[nodiscard]] bool emitSubPtr(PrimType, uint32_t, SourceInfo I);
55240	#endif
55241	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
55242	bool
55243	#if defined(GET_EVAL_IMPL)
55244	EvalEmitter
55245	#else
55246	ByteCodeEmitter
55247	#endif
55248	::emitSubPtr(PrimType T0, uint32_t A0, SourceInfo I) {
55249	switch (T0) {
55250	case PT_Sint8:
55251	return emitSubPtrSint8(A0, I);
55252	case PT_Uint8:
55253	return emitSubPtrUint8(A0, I);
55254	case PT_Sint16:
55255	return emitSubPtrSint16(A0, I);
55256	case PT_Uint16:
55257	return emitSubPtrUint16(A0, I);
55258	case PT_Sint32:
55259	return emitSubPtrSint32(A0, I);
55260	case PT_Uint32:
55261	return emitSubPtrUint32(A0, I);
55262	case PT_Sint64:
55263	return emitSubPtrSint64(A0, I);
55264	case PT_Uint64:
55265	return emitSubPtrUint64(A0, I);
55266	case PT_IntAP:
55267	return emitSubPtrIntAP(A0, I);
55268	case PT_IntAPS:
55269	return emitSubPtrIntAPS(A0, I);
55270	default: llvm_unreachable("invalid type: emitSubPtr");
55271	}
55272	llvm_unreachable("invalid enum value");
55273	}
55274	#endif
55275	#ifdef GET_LINK_IMPL
55276	bool ByteCodeEmitter::emitSubPtrSint8( uint32_t A0, SourceInfo L) {
55277	return emitOp<uint32_t>(OP_SubPtrSint8, A0, L);
55278	}
55279	bool ByteCodeEmitter::emitSubPtrUint8( uint32_t A0, SourceInfo L) {
55280	return emitOp<uint32_t>(OP_SubPtrUint8, A0, L);
55281	}
55282	bool ByteCodeEmitter::emitSubPtrSint16( uint32_t A0, SourceInfo L) {
55283	return emitOp<uint32_t>(OP_SubPtrSint16, A0, L);
55284	}
55285	bool ByteCodeEmitter::emitSubPtrUint16( uint32_t A0, SourceInfo L) {
55286	return emitOp<uint32_t>(OP_SubPtrUint16, A0, L);
55287	}
55288	bool ByteCodeEmitter::emitSubPtrSint32( uint32_t A0, SourceInfo L) {
55289	return emitOp<uint32_t>(OP_SubPtrSint32, A0, L);
55290	}
55291	bool ByteCodeEmitter::emitSubPtrUint32( uint32_t A0, SourceInfo L) {
55292	return emitOp<uint32_t>(OP_SubPtrUint32, A0, L);
55293	}
55294	bool ByteCodeEmitter::emitSubPtrSint64( uint32_t A0, SourceInfo L) {
55295	return emitOp<uint32_t>(OP_SubPtrSint64, A0, L);
55296	}
55297	bool ByteCodeEmitter::emitSubPtrUint64( uint32_t A0, SourceInfo L) {
55298	return emitOp<uint32_t>(OP_SubPtrUint64, A0, L);
55299	}
55300	bool ByteCodeEmitter::emitSubPtrIntAP( uint32_t A0, SourceInfo L) {
55301	return emitOp<uint32_t>(OP_SubPtrIntAP, A0, L);
55302	}
55303	bool ByteCodeEmitter::emitSubPtrIntAPS( uint32_t A0, SourceInfo L) {
55304	return emitOp<uint32_t>(OP_SubPtrIntAPS, A0, L);
55305	}
55306	#endif
55307	#ifdef GET_EVAL_IMPL
55308	bool EvalEmitter::emitSubPtrSint8( uint32_t A0, SourceInfo L) {
55309	if (!isActive()) return true;
55310	CurrentSource = L;
55311	return SubPtr<PT_Sint8>(S, CodePtr(), A0);
55312	}
55313	bool EvalEmitter::emitSubPtrUint8( uint32_t A0, SourceInfo L) {
55314	if (!isActive()) return true;
55315	CurrentSource = L;
55316	return SubPtr<PT_Uint8>(S, CodePtr(), A0);
55317	}
55318	bool EvalEmitter::emitSubPtrSint16( uint32_t A0, SourceInfo L) {
55319	if (!isActive()) return true;
55320	CurrentSource = L;
55321	return SubPtr<PT_Sint16>(S, CodePtr(), A0);
55322	}
55323	bool EvalEmitter::emitSubPtrUint16( uint32_t A0, SourceInfo L) {
55324	if (!isActive()) return true;
55325	CurrentSource = L;
55326	return SubPtr<PT_Uint16>(S, CodePtr(), A0);
55327	}
55328	bool EvalEmitter::emitSubPtrSint32( uint32_t A0, SourceInfo L) {
55329	if (!isActive()) return true;
55330	CurrentSource = L;
55331	return SubPtr<PT_Sint32>(S, CodePtr(), A0);
55332	}
55333	bool EvalEmitter::emitSubPtrUint32( uint32_t A0, SourceInfo L) {
55334	if (!isActive()) return true;
55335	CurrentSource = L;
55336	return SubPtr<PT_Uint32>(S, CodePtr(), A0);
55337	}
55338	bool EvalEmitter::emitSubPtrSint64( uint32_t A0, SourceInfo L) {
55339	if (!isActive()) return true;
55340	CurrentSource = L;
55341	return SubPtr<PT_Sint64>(S, CodePtr(), A0);
55342	}
55343	bool EvalEmitter::emitSubPtrUint64( uint32_t A0, SourceInfo L) {
55344	if (!isActive()) return true;
55345	CurrentSource = L;
55346	return SubPtr<PT_Uint64>(S, CodePtr(), A0);
55347	}
55348	bool EvalEmitter::emitSubPtrIntAP( uint32_t A0, SourceInfo L) {
55349	if (!isActive()) return true;
55350	CurrentSource = L;
55351	return SubPtr<PT_IntAP>(S, CodePtr(), A0);
55352	}
55353	bool EvalEmitter::emitSubPtrIntAPS( uint32_t A0, SourceInfo L) {
55354	if (!isActive()) return true;
55355	CurrentSource = L;
55356	return SubPtr<PT_IntAPS>(S, CodePtr(), A0);
55357	}
55358	#endif
55359	#ifdef GET_OPCODE_NAMES
55360	OP_Subf,
55361	#endif
55362	#ifdef GET_INTERPFN_LIST
55363	&Interp_Subf,
55364	#endif
55365	#ifdef GET_INTERPFN_DISPATCHERS
55366	PRESERVE_NONE
55367	static bool Interp_Subf(InterpState &S) {
55368	{
55369	CodePtr OpPC = S.PC;
55370	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55371	if (!Subf(S, OpPC, V0)) return false;
55372	}
55373	#if USE_TAILCALLS
55374	MUSTTAIL return InterpNext(S);
55375	#else
55376	return true;
55377	#endif
55378	}
55379	#endif
55380	#ifdef GET_DISASM
55381	case OP_Subf:
55382	Text.Op = PrintName("Subf");
55383	Text.Args.push_back(printArg<uint32_t>(P, PC));
55384	break;
55385	#endif
55386	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55387	bool emitSubf( uint32_t , SourceInfo);
55388	#endif
55389	#ifdef GET_LINK_IMPL
55390	bool ByteCodeEmitter::emitSubf( uint32_t A0, SourceInfo L) {
55391	return emitOp<uint32_t>(OP_Subf, A0, L);
55392	}
55393	#endif
55394	#ifdef GET_EVAL_IMPL
55395	bool EvalEmitter::emitSubf( uint32_t A0, SourceInfo L) {
55396	if (!isActive()) return true;
55397	CurrentSource = L;
55398	return Subf(S, CodePtr(), A0);
55399	}
55400	#endif
55401	#ifdef GET_OPCODE_NAMES
55402	OP_This,
55403	#endif
55404	#ifdef GET_INTERPFN_LIST
55405	&Interp_This,
55406	#endif
55407	#ifdef GET_INTERPFN_DISPATCHERS
55408	PRESERVE_NONE
55409	static bool Interp_This(InterpState &S) {
55410	if (!This(S, S.PC)) return false;
55411	#if USE_TAILCALLS
55412	MUSTTAIL return InterpNext(S);
55413	#else
55414	return true;
55415	#endif
55416	}
55417	#endif
55418	#ifdef GET_DISASM
55419	case OP_This:
55420	Text.Op = PrintName("This");
55421	break;
55422	#endif
55423	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55424	bool emitThis(SourceInfo);
55425	#endif
55426	#ifdef GET_LINK_IMPL
55427	bool ByteCodeEmitter::emitThis(SourceInfo L) {
55428	return emitOp<>(OP_This, L);
55429	}
55430	#endif
55431	#ifdef GET_EVAL_IMPL
55432	bool EvalEmitter::emitThis(SourceInfo L) {
55433	if (!isActive()) return true;
55434	CurrentSource = L;
55435	return This(S, CodePtr());
55436	}
55437	#endif
55438	#ifdef GET_OPCODE_NAMES
55439	OP_ToMemberPtr,
55440	#endif
55441	#ifdef GET_INTERPFN_LIST
55442	&Interp_ToMemberPtr,
55443	#endif
55444	#ifdef GET_INTERPFN_DISPATCHERS
55445	PRESERVE_NONE
55446	static bool Interp_ToMemberPtr(InterpState &S) {
55447	ToMemberPtr(S);
55448	#if USE_TAILCALLS
55449	MUSTTAIL return InterpNext(S);
55450	#else
55451	return true;
55452	#endif
55453	}
55454	#endif
55455	#ifdef GET_DISASM
55456	case OP_ToMemberPtr:
55457	Text.Op = PrintName("ToMemberPtr");
55458	break;
55459	#endif
55460	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55461	bool emitToMemberPtr(SourceInfo);
55462	#endif
55463	#ifdef GET_LINK_IMPL
55464	bool ByteCodeEmitter::emitToMemberPtr(SourceInfo L) {
55465	return emitOp<>(OP_ToMemberPtr, L);
55466	}
55467	#endif
55468	#ifdef GET_EVAL_IMPL
55469	bool EvalEmitter::emitToMemberPtr(SourceInfo L) {
55470	if (!isActive()) return true;
55471	CurrentSource = L;
55472	return ToMemberPtr(S);
55473	}
55474	#endif
55475	#ifdef GET_OPCODE_NAMES
55476	OP_Unsupported,
55477	#endif
55478	#ifdef GET_INTERPFN_LIST
55479	&Interp_Unsupported,
55480	#endif
55481	#ifdef GET_INTERPFN_DISPATCHERS
55482	PRESERVE_NONE
55483	static bool Interp_Unsupported(InterpState &S) {
55484	if (!Unsupported(S, S.PC)) return false;
55485	#if USE_TAILCALLS
55486	MUSTTAIL return InterpNext(S);
55487	#else
55488	return true;
55489	#endif
55490	}
55491	#endif
55492	#ifdef GET_DISASM
55493	case OP_Unsupported:
55494	Text.Op = PrintName("Unsupported");
55495	break;
55496	#endif
55497	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55498	bool emitUnsupported(SourceInfo);
55499	#endif
55500	#ifdef GET_LINK_IMPL
55501	bool ByteCodeEmitter::emitUnsupported(SourceInfo L) {
55502	return emitOp<>(OP_Unsupported, L);
55503	}
55504	#endif
55505	#ifdef GET_EVAL_IMPL
55506	bool EvalEmitter::emitUnsupported(SourceInfo L) {
55507	if (!isActive()) return true;
55508	CurrentSource = L;
55509	return Unsupported(S, CodePtr());
55510	}
55511	#endif
55512	#ifdef GET_OPCODE_NAMES
55513	OP_ZeroSint8,
55514	OP_ZeroUint8,
55515	OP_ZeroSint16,
55516	OP_ZeroUint16,
55517	OP_ZeroSint32,
55518	OP_ZeroUint32,
55519	OP_ZeroSint64,
55520	OP_ZeroUint64,
55521	OP_ZeroBool,
55522	#endif
55523	#ifdef GET_INTERPFN_LIST
55524	&Interp_ZeroSint8,
55525	&Interp_ZeroUint8,
55526	&Interp_ZeroSint16,
55527	&Interp_ZeroUint16,
55528	&Interp_ZeroSint32,
55529	&Interp_ZeroUint32,
55530	&Interp_ZeroSint64,
55531	&Interp_ZeroUint64,
55532	&Interp_ZeroBool,
55533	#endif
55534	#ifdef GET_INTERPFN_DISPATCHERS
55535	PRESERVE_NONE
55536	static bool Interp_ZeroSint8(InterpState &S) {
55537	Zero<PT_Sint8>(S);
55538	#if USE_TAILCALLS
55539	MUSTTAIL return InterpNext(S);
55540	#else
55541	return true;
55542	#endif
55543	}
55544	PRESERVE_NONE
55545	static bool Interp_ZeroUint8(InterpState &S) {
55546	Zero<PT_Uint8>(S);
55547	#if USE_TAILCALLS
55548	MUSTTAIL return InterpNext(S);
55549	#else
55550	return true;
55551	#endif
55552	}
55553	PRESERVE_NONE
55554	static bool Interp_ZeroSint16(InterpState &S) {
55555	Zero<PT_Sint16>(S);
55556	#if USE_TAILCALLS
55557	MUSTTAIL return InterpNext(S);
55558	#else
55559	return true;
55560	#endif
55561	}
55562	PRESERVE_NONE
55563	static bool Interp_ZeroUint16(InterpState &S) {
55564	Zero<PT_Uint16>(S);
55565	#if USE_TAILCALLS
55566	MUSTTAIL return InterpNext(S);
55567	#else
55568	return true;
55569	#endif
55570	}
55571	PRESERVE_NONE
55572	static bool Interp_ZeroSint32(InterpState &S) {
55573	Zero<PT_Sint32>(S);
55574	#if USE_TAILCALLS
55575	MUSTTAIL return InterpNext(S);
55576	#else
55577	return true;
55578	#endif
55579	}
55580	PRESERVE_NONE
55581	static bool Interp_ZeroUint32(InterpState &S) {
55582	Zero<PT_Uint32>(S);
55583	#if USE_TAILCALLS
55584	MUSTTAIL return InterpNext(S);
55585	#else
55586	return true;
55587	#endif
55588	}
55589	PRESERVE_NONE
55590	static bool Interp_ZeroSint64(InterpState &S) {
55591	Zero<PT_Sint64>(S);
55592	#if USE_TAILCALLS
55593	MUSTTAIL return InterpNext(S);
55594	#else
55595	return true;
55596	#endif
55597	}
55598	PRESERVE_NONE
55599	static bool Interp_ZeroUint64(InterpState &S) {
55600	Zero<PT_Uint64>(S);
55601	#if USE_TAILCALLS
55602	MUSTTAIL return InterpNext(S);
55603	#else
55604	return true;
55605	#endif
55606	}
55607	PRESERVE_NONE
55608	static bool Interp_ZeroBool(InterpState &S) {
55609	Zero<PT_Bool>(S);
55610	#if USE_TAILCALLS
55611	MUSTTAIL return InterpNext(S);
55612	#else
55613	return true;
55614	#endif
55615	}
55616	#endif
55617	#ifdef GET_DISASM
55618	case OP_ZeroSint8:
55619	Text.Op = PrintName("ZeroSint8");
55620	break;
55621	case OP_ZeroUint8:
55622	Text.Op = PrintName("ZeroUint8");
55623	break;
55624	case OP_ZeroSint16:
55625	Text.Op = PrintName("ZeroSint16");
55626	break;
55627	case OP_ZeroUint16:
55628	Text.Op = PrintName("ZeroUint16");
55629	break;
55630	case OP_ZeroSint32:
55631	Text.Op = PrintName("ZeroSint32");
55632	break;
55633	case OP_ZeroUint32:
55634	Text.Op = PrintName("ZeroUint32");
55635	break;
55636	case OP_ZeroSint64:
55637	Text.Op = PrintName("ZeroSint64");
55638	break;
55639	case OP_ZeroUint64:
55640	Text.Op = PrintName("ZeroUint64");
55641	break;
55642	case OP_ZeroBool:
55643	Text.Op = PrintName("ZeroBool");
55644	break;
55645	#endif
55646	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55647	bool emitZeroSint8(SourceInfo);
55648	bool emitZeroUint8(SourceInfo);
55649	bool emitZeroSint16(SourceInfo);
55650	bool emitZeroUint16(SourceInfo);
55651	bool emitZeroSint32(SourceInfo);
55652	bool emitZeroUint32(SourceInfo);
55653	bool emitZeroSint64(SourceInfo);
55654	bool emitZeroUint64(SourceInfo);
55655	bool emitZeroBool(SourceInfo);
55656	#endif
55657	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55658	[[nodiscard]] bool emitZero(PrimType, SourceInfo I);
55659	#endif
55660	#if defined(GET_EVAL_IMPL) \|\| defined(GET_LINK_IMPL)
55661	bool
55662	#if defined(GET_EVAL_IMPL)
55663	EvalEmitter
55664	#else
55665	ByteCodeEmitter
55666	#endif
55667	::emitZero(PrimType T0, SourceInfo I) {
55668	switch (T0) {
55669	case PT_Sint8:
55670	return emitZeroSint8(I);
55671	case PT_Uint8:
55672	return emitZeroUint8(I);
55673	case PT_Sint16:
55674	return emitZeroSint16(I);
55675	case PT_Uint16:
55676	return emitZeroUint16(I);
55677	case PT_Sint32:
55678	return emitZeroSint32(I);
55679	case PT_Uint32:
55680	return emitZeroUint32(I);
55681	case PT_Sint64:
55682	return emitZeroSint64(I);
55683	case PT_Uint64:
55684	return emitZeroUint64(I);
55685	case PT_Bool:
55686	return emitZeroBool(I);
55687	default: llvm_unreachable("invalid type: emitZero");
55688	}
55689	llvm_unreachable("invalid enum value");
55690	}
55691	#endif
55692	#ifdef GET_LINK_IMPL
55693	bool ByteCodeEmitter::emitZeroSint8(SourceInfo L) {
55694	return emitOp<>(OP_ZeroSint8, L);
55695	}
55696	bool ByteCodeEmitter::emitZeroUint8(SourceInfo L) {
55697	return emitOp<>(OP_ZeroUint8, L);
55698	}
55699	bool ByteCodeEmitter::emitZeroSint16(SourceInfo L) {
55700	return emitOp<>(OP_ZeroSint16, L);
55701	}
55702	bool ByteCodeEmitter::emitZeroUint16(SourceInfo L) {
55703	return emitOp<>(OP_ZeroUint16, L);
55704	}
55705	bool ByteCodeEmitter::emitZeroSint32(SourceInfo L) {
55706	return emitOp<>(OP_ZeroSint32, L);
55707	}
55708	bool ByteCodeEmitter::emitZeroUint32(SourceInfo L) {
55709	return emitOp<>(OP_ZeroUint32, L);
55710	}
55711	bool ByteCodeEmitter::emitZeroSint64(SourceInfo L) {
55712	return emitOp<>(OP_ZeroSint64, L);
55713	}
55714	bool ByteCodeEmitter::emitZeroUint64(SourceInfo L) {
55715	return emitOp<>(OP_ZeroUint64, L);
55716	}
55717	bool ByteCodeEmitter::emitZeroBool(SourceInfo L) {
55718	return emitOp<>(OP_ZeroBool, L);
55719	}
55720	#endif
55721	#ifdef GET_EVAL_IMPL
55722	bool EvalEmitter::emitZeroSint8(SourceInfo L) {
55723	if (!isActive()) return true;
55724	CurrentSource = L;
55725	return Zero<PT_Sint8>(S);
55726	}
55727	bool EvalEmitter::emitZeroUint8(SourceInfo L) {
55728	if (!isActive()) return true;
55729	CurrentSource = L;
55730	return Zero<PT_Uint8>(S);
55731	}
55732	bool EvalEmitter::emitZeroSint16(SourceInfo L) {
55733	if (!isActive()) return true;
55734	CurrentSource = L;
55735	return Zero<PT_Sint16>(S);
55736	}
55737	bool EvalEmitter::emitZeroUint16(SourceInfo L) {
55738	if (!isActive()) return true;
55739	CurrentSource = L;
55740	return Zero<PT_Uint16>(S);
55741	}
55742	bool EvalEmitter::emitZeroSint32(SourceInfo L) {
55743	if (!isActive()) return true;
55744	CurrentSource = L;
55745	return Zero<PT_Sint32>(S);
55746	}
55747	bool EvalEmitter::emitZeroUint32(SourceInfo L) {
55748	if (!isActive()) return true;
55749	CurrentSource = L;
55750	return Zero<PT_Uint32>(S);
55751	}
55752	bool EvalEmitter::emitZeroSint64(SourceInfo L) {
55753	if (!isActive()) return true;
55754	CurrentSource = L;
55755	return Zero<PT_Sint64>(S);
55756	}
55757	bool EvalEmitter::emitZeroUint64(SourceInfo L) {
55758	if (!isActive()) return true;
55759	CurrentSource = L;
55760	return Zero<PT_Uint64>(S);
55761	}
55762	bool EvalEmitter::emitZeroBool(SourceInfo L) {
55763	if (!isActive()) return true;
55764	CurrentSource = L;
55765	return Zero<PT_Bool>(S);
55766	}
55767	#endif
55768	#ifdef GET_OPCODE_NAMES
55769	OP_ZeroIntAP,
55770	#endif
55771	#ifdef GET_INTERPFN_LIST
55772	&Interp_ZeroIntAP,
55773	#endif
55774	#ifdef GET_INTERPFN_DISPATCHERS
55775	PRESERVE_NONE
55776	static bool Interp_ZeroIntAP(InterpState &S) {
55777	{
55778	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55779	ZeroIntAP(S, V0);
55780	}
55781	#if USE_TAILCALLS
55782	MUSTTAIL return InterpNext(S);
55783	#else
55784	return true;
55785	#endif
55786	}
55787	#endif
55788	#ifdef GET_DISASM
55789	case OP_ZeroIntAP:
55790	Text.Op = PrintName("ZeroIntAP");
55791	Text.Args.push_back(printArg<uint32_t>(P, PC));
55792	break;
55793	#endif
55794	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55795	bool emitZeroIntAP( uint32_t , SourceInfo);
55796	#endif
55797	#ifdef GET_LINK_IMPL
55798	bool ByteCodeEmitter::emitZeroIntAP( uint32_t A0, SourceInfo L) {
55799	return emitOp<uint32_t>(OP_ZeroIntAP, A0, L);
55800	}
55801	#endif
55802	#ifdef GET_EVAL_IMPL
55803	bool EvalEmitter::emitZeroIntAP( uint32_t A0, SourceInfo L) {
55804	if (!isActive()) return true;
55805	CurrentSource = L;
55806	return ZeroIntAP(S, A0);
55807	}
55808	#endif
55809	#ifdef GET_OPCODE_NAMES
55810	OP_ZeroIntAPS,
55811	#endif
55812	#ifdef GET_INTERPFN_LIST
55813	&Interp_ZeroIntAPS,
55814	#endif
55815	#ifdef GET_INTERPFN_DISPATCHERS
55816	PRESERVE_NONE
55817	static bool Interp_ZeroIntAPS(InterpState &S) {
55818	{
55819	const auto V0 = ReadArg<uint32_t>(S, S.PC);
55820	ZeroIntAPS(S, V0);
55821	}
55822	#if USE_TAILCALLS
55823	MUSTTAIL return InterpNext(S);
55824	#else
55825	return true;
55826	#endif
55827	}
55828	#endif
55829	#ifdef GET_DISASM
55830	case OP_ZeroIntAPS:
55831	Text.Op = PrintName("ZeroIntAPS");
55832	Text.Args.push_back(printArg<uint32_t>(P, PC));
55833	break;
55834	#endif
55835	#if defined(GET_EVAL_PROTO) \|\| defined(GET_LINK_PROTO)
55836	bool emitZeroIntAPS( uint32_t , SourceInfo);
55837	#endif
55838	#ifdef GET_LINK_IMPL
55839	bool ByteCodeEmitter::emitZeroIntAPS( uint32_t A0, SourceInfo L) {
55840	return emitOp<uint32_t>(OP_ZeroIntAPS, A0, L);
55841	}
55842	#endif
55843	#ifdef GET_EVAL_IMPL
55844	bool EvalEmitter::emitZeroIntAPS( uint32_t A0, SourceInfo L) {
55845	if (!isActive()) return true;
55846	CurrentSource = L;
55847	return ZeroIntAPS(S, A0);
55848	}
55849	#endif
55850

Browse the source code of llvm_projects/build/tools/clang/lib/AST/Opcodes.inc