1 use crate::ir::{MemFlags, TrapCode};
2 use crate::isa::s390x::inst::*;
3 use crate::isa::s390x::settings as s390x_settings;
4 
5 #[cfg(test)]
simm20_zero() -> SImm206 fn simm20_zero() -> SImm20 {
7     SImm20::maybe_from_i64(0).unwrap()
8 }
9 
10 #[test]
test_s390x_binemit()11 fn test_s390x_binemit() {
12     let mut insns = Vec::<(Inst, &str, &str)>::new();
13 
14     insns.push((Inst::Nop0, "", "nop-zero-len"));
15     insns.push((Inst::Nop2, "0707", "nop"));
16 
17     insns.push((
18         Inst::AluRRR {
19             alu_op: ALUOp::Add32,
20             rd: writable_gpr(1),
21             rn: gpr(2),
22             rm: gpr(3),
23         },
24         "B9F83012",
25         "ark %r1, %r2, %r3",
26     ));
27     insns.push((
28         Inst::AluRRR {
29             alu_op: ALUOp::Add64,
30             rd: writable_gpr(4),
31             rn: gpr(5),
32             rm: gpr(6),
33         },
34         "B9E86045",
35         "agrk %r4, %r5, %r6",
36     ));
37     insns.push((
38         Inst::AluRRR {
39             alu_op: ALUOp::AddLogical32,
40             rd: writable_gpr(1),
41             rn: gpr(2),
42             rm: gpr(3),
43         },
44         "B9FA3012",
45         "alrk %r1, %r2, %r3",
46     ));
47     insns.push((
48         Inst::AluRRR {
49             alu_op: ALUOp::AddLogical64,
50             rd: writable_gpr(4),
51             rn: gpr(5),
52             rm: gpr(6),
53         },
54         "B9EA6045",
55         "algrk %r4, %r5, %r6",
56     ));
57     insns.push((
58         Inst::AluRRR {
59             alu_op: ALUOp::Sub32,
60             rd: writable_gpr(1),
61             rn: gpr(2),
62             rm: gpr(3),
63         },
64         "B9F93012",
65         "srk %r1, %r2, %r3",
66     ));
67     insns.push((
68         Inst::AluRRR {
69             alu_op: ALUOp::Sub64,
70             rd: writable_gpr(4),
71             rn: gpr(5),
72             rm: gpr(6),
73         },
74         "B9E96045",
75         "sgrk %r4, %r5, %r6",
76     ));
77     insns.push((
78         Inst::AluRRR {
79             alu_op: ALUOp::SubLogical32,
80             rd: writable_gpr(1),
81             rn: gpr(2),
82             rm: gpr(3),
83         },
84         "B9FB3012",
85         "slrk %r1, %r2, %r3",
86     ));
87     insns.push((
88         Inst::AluRRR {
89             alu_op: ALUOp::SubLogical64,
90             rd: writable_gpr(4),
91             rn: gpr(5),
92             rm: gpr(6),
93         },
94         "B9EB6045",
95         "slgrk %r4, %r5, %r6",
96     ));
97     insns.push((
98         Inst::AluRRR {
99             alu_op: ALUOp::Mul32,
100             rd: writable_gpr(1),
101             rn: gpr(2),
102             rm: gpr(3),
103         },
104         "B9FD3012",
105         "msrkc %r1, %r2, %r3",
106     ));
107     insns.push((
108         Inst::AluRRR {
109             alu_op: ALUOp::Mul64,
110             rd: writable_gpr(4),
111             rn: gpr(5),
112             rm: gpr(6),
113         },
114         "B9ED6045",
115         "msgrkc %r4, %r5, %r6",
116     ));
117     insns.push((
118         Inst::AluRRR {
119             alu_op: ALUOp::And32,
120             rd: writable_gpr(1),
121             rn: gpr(2),
122             rm: gpr(3),
123         },
124         "B9F43012",
125         "nrk %r1, %r2, %r3",
126     ));
127     insns.push((
128         Inst::AluRRR {
129             alu_op: ALUOp::And64,
130             rd: writable_gpr(4),
131             rn: gpr(5),
132             rm: gpr(6),
133         },
134         "B9E46045",
135         "ngrk %r4, %r5, %r6",
136     ));
137     insns.push((
138         Inst::AluRRR {
139             alu_op: ALUOp::Orr32,
140             rd: writable_gpr(1),
141             rn: gpr(2),
142             rm: gpr(3),
143         },
144         "B9F63012",
145         "ork %r1, %r2, %r3",
146     ));
147     insns.push((
148         Inst::AluRRR {
149             alu_op: ALUOp::Orr64,
150             rd: writable_gpr(4),
151             rn: gpr(5),
152             rm: gpr(6),
153         },
154         "B9E66045",
155         "ogrk %r4, %r5, %r6",
156     ));
157     insns.push((
158         Inst::AluRRR {
159             alu_op: ALUOp::Xor32,
160             rd: writable_gpr(1),
161             rn: gpr(2),
162             rm: gpr(3),
163         },
164         "B9F73012",
165         "xrk %r1, %r2, %r3",
166     ));
167     insns.push((
168         Inst::AluRRR {
169             alu_op: ALUOp::Xor64,
170             rd: writable_gpr(4),
171             rn: gpr(5),
172             rm: gpr(6),
173         },
174         "B9E76045",
175         "xgrk %r4, %r5, %r6",
176     ));
177     insns.push((
178         Inst::AluRRR {
179             alu_op: ALUOp::NotAnd32,
180             rd: writable_gpr(1),
181             rn: gpr(2),
182             rm: gpr(3),
183         },
184         "B9743012",
185         "nnrk %r1, %r2, %r3",
186     ));
187     insns.push((
188         Inst::AluRRR {
189             alu_op: ALUOp::NotAnd64,
190             rd: writable_gpr(4),
191             rn: gpr(5),
192             rm: gpr(6),
193         },
194         "B9646045",
195         "nngrk %r4, %r5, %r6",
196     ));
197     insns.push((
198         Inst::AluRRR {
199             alu_op: ALUOp::NotOrr32,
200             rd: writable_gpr(1),
201             rn: gpr(2),
202             rm: gpr(3),
203         },
204         "B9763012",
205         "nork %r1, %r2, %r3",
206     ));
207     insns.push((
208         Inst::AluRRR {
209             alu_op: ALUOp::NotOrr64,
210             rd: writable_gpr(4),
211             rn: gpr(5),
212             rm: gpr(6),
213         },
214         "B9666045",
215         "nogrk %r4, %r5, %r6",
216     ));
217     insns.push((
218         Inst::AluRRR {
219             alu_op: ALUOp::NotXor32,
220             rd: writable_gpr(1),
221             rn: gpr(2),
222             rm: gpr(3),
223         },
224         "B9773012",
225         "nxrk %r1, %r2, %r3",
226     ));
227     insns.push((
228         Inst::AluRRR {
229             alu_op: ALUOp::NotXor64,
230             rd: writable_gpr(4),
231             rn: gpr(5),
232             rm: gpr(6),
233         },
234         "B9676045",
235         "nxgrk %r4, %r5, %r6",
236     ));
237     insns.push((
238         Inst::AluRRR {
239             alu_op: ALUOp::AndNot32,
240             rd: writable_gpr(1),
241             rn: gpr(2),
242             rm: gpr(3),
243         },
244         "B9F53012",
245         "ncrk %r1, %r2, %r3",
246     ));
247     insns.push((
248         Inst::AluRRR {
249             alu_op: ALUOp::AndNot64,
250             rd: writable_gpr(4),
251             rn: gpr(5),
252             rm: gpr(6),
253         },
254         "B9E56045",
255         "ncgrk %r4, %r5, %r6",
256     ));
257     insns.push((
258         Inst::AluRRR {
259             alu_op: ALUOp::OrrNot32,
260             rd: writable_gpr(1),
261             rn: gpr(2),
262             rm: gpr(3),
263         },
264         "B9753012",
265         "ocrk %r1, %r2, %r3",
266     ));
267     insns.push((
268         Inst::AluRRR {
269             alu_op: ALUOp::OrrNot64,
270             rd: writable_gpr(4),
271             rn: gpr(5),
272             rm: gpr(6),
273         },
274         "B9656045",
275         "ocgrk %r4, %r5, %r6",
276     ));
277 
278     insns.push((
279         Inst::AluRRSImm16 {
280             alu_op: ALUOp::Add32,
281             rd: writable_gpr(4),
282             rn: gpr(5),
283             imm: -32768,
284         },
285         "EC45800000D8",
286         "ahik %r4, %r5, -32768",
287     ));
288     insns.push((
289         Inst::AluRRSImm16 {
290             alu_op: ALUOp::Add32,
291             rd: writable_gpr(4),
292             rn: gpr(5),
293             imm: 32767,
294         },
295         "EC457FFF00D8",
296         "ahik %r4, %r5, 32767",
297     ));
298     insns.push((
299         Inst::AluRRSImm16 {
300             alu_op: ALUOp::Add64,
301             rd: writable_gpr(4),
302             rn: gpr(5),
303             imm: -32768,
304         },
305         "EC45800000D9",
306         "aghik %r4, %r5, -32768",
307     ));
308     insns.push((
309         Inst::AluRRSImm16 {
310             alu_op: ALUOp::Add64,
311             rd: writable_gpr(4),
312             rn: gpr(5),
313             imm: 32767,
314         },
315         "EC457FFF00D9",
316         "aghik %r4, %r5, 32767",
317     ));
318 
319     insns.push((
320         Inst::AluRR {
321             alu_op: ALUOp::Add32,
322             rd: writable_gpr(1),
323             ri: gpr(1),
324             rm: gpr(2),
325         },
326         "1A12",
327         "ar %r1, %r2",
328     ));
329     insns.push((
330         Inst::AluRR {
331             alu_op: ALUOp::Add64,
332             rd: writable_gpr(4),
333             ri: gpr(4),
334             rm: gpr(5),
335         },
336         "B9080045",
337         "agr %r4, %r5",
338     ));
339     insns.push((
340         Inst::AluRR {
341             alu_op: ALUOp::Add64Ext32,
342             rd: writable_gpr(4),
343             ri: gpr(4),
344             rm: gpr(5),
345         },
346         "B9180045",
347         "agfr %r4, %r5",
348     ));
349     insns.push((
350         Inst::AluRR {
351             alu_op: ALUOp::AddLogical32,
352             rd: writable_gpr(1),
353             ri: gpr(1),
354             rm: gpr(2),
355         },
356         "1E12",
357         "alr %r1, %r2",
358     ));
359     insns.push((
360         Inst::AluRR {
361             alu_op: ALUOp::AddLogical64,
362             rd: writable_gpr(4),
363             ri: gpr(4),
364             rm: gpr(5),
365         },
366         "B90A0045",
367         "algr %r4, %r5",
368     ));
369     insns.push((
370         Inst::AluRR {
371             alu_op: ALUOp::AddLogical64Ext32,
372             rd: writable_gpr(4),
373             ri: gpr(4),
374             rm: gpr(5),
375         },
376         "B91A0045",
377         "algfr %r4, %r5",
378     ));
379     insns.push((
380         Inst::AluRR {
381             alu_op: ALUOp::Sub32,
382             rd: writable_gpr(1),
383             ri: gpr(1),
384             rm: gpr(2),
385         },
386         "1B12",
387         "sr %r1, %r2",
388     ));
389     insns.push((
390         Inst::AluRR {
391             alu_op: ALUOp::Sub64,
392             rd: writable_gpr(4),
393             ri: gpr(4),
394             rm: gpr(5),
395         },
396         "B9090045",
397         "sgr %r4, %r5",
398     ));
399     insns.push((
400         Inst::AluRR {
401             alu_op: ALUOp::Sub64Ext32,
402             rd: writable_gpr(4),
403             ri: gpr(4),
404             rm: gpr(5),
405         },
406         "B9190045",
407         "sgfr %r4, %r5",
408     ));
409     insns.push((
410         Inst::AluRR {
411             alu_op: ALUOp::SubLogical32,
412             rd: writable_gpr(1),
413             ri: gpr(1),
414             rm: gpr(2),
415         },
416         "1F12",
417         "slr %r1, %r2",
418     ));
419     insns.push((
420         Inst::AluRR {
421             alu_op: ALUOp::SubLogical64,
422             rd: writable_gpr(4),
423             ri: gpr(4),
424             rm: gpr(5),
425         },
426         "B90B0045",
427         "slgr %r4, %r5",
428     ));
429     insns.push((
430         Inst::AluRR {
431             alu_op: ALUOp::SubLogical64Ext32,
432             rd: writable_gpr(4),
433             ri: gpr(4),
434             rm: gpr(5),
435         },
436         "B91B0045",
437         "slgfr %r4, %r5",
438     ));
439     insns.push((
440         Inst::AluRR {
441             alu_op: ALUOp::Mul32,
442             rd: writable_gpr(1),
443             ri: gpr(1),
444             rm: gpr(2),
445         },
446         "B2520012",
447         "msr %r1, %r2",
448     ));
449     insns.push((
450         Inst::AluRR {
451             alu_op: ALUOp::Mul64,
452             rd: writable_gpr(4),
453             ri: gpr(4),
454             rm: gpr(5),
455         },
456         "B90C0045",
457         "msgr %r4, %r5",
458     ));
459     insns.push((
460         Inst::AluRR {
461             alu_op: ALUOp::Mul64Ext32,
462             rd: writable_gpr(4),
463             ri: gpr(4),
464             rm: gpr(5),
465         },
466         "B91C0045",
467         "msgfr %r4, %r5",
468     ));
469     insns.push((
470         Inst::AluRR {
471             alu_op: ALUOp::And32,
472             rd: writable_gpr(1),
473             ri: gpr(1),
474             rm: gpr(2),
475         },
476         "1412",
477         "nr %r1, %r2",
478     ));
479     insns.push((
480         Inst::AluRR {
481             alu_op: ALUOp::And64,
482             rd: writable_gpr(4),
483             ri: gpr(4),
484             rm: gpr(5),
485         },
486         "B9800045",
487         "ngr %r4, %r5",
488     ));
489     insns.push((
490         Inst::AluRR {
491             alu_op: ALUOp::Orr32,
492             rd: writable_gpr(1),
493             ri: gpr(1),
494             rm: gpr(2),
495         },
496         "1612",
497         "or %r1, %r2",
498     ));
499     insns.push((
500         Inst::AluRR {
501             alu_op: ALUOp::Orr64,
502             rd: writable_gpr(4),
503             ri: gpr(4),
504             rm: gpr(5),
505         },
506         "B9810045",
507         "ogr %r4, %r5",
508     ));
509     insns.push((
510         Inst::AluRR {
511             alu_op: ALUOp::Xor32,
512             rd: writable_gpr(1),
513             ri: gpr(1),
514             rm: gpr(2),
515         },
516         "1712",
517         "xr %r1, %r2",
518     ));
519     insns.push((
520         Inst::AluRR {
521             alu_op: ALUOp::Xor64,
522             rd: writable_gpr(4),
523             ri: gpr(4),
524             rm: gpr(5),
525         },
526         "B9820045",
527         "xgr %r4, %r5",
528     ));
529 
530     insns.push((
531         Inst::AluRX {
532             alu_op: ALUOp::Add32,
533             rd: writable_gpr(1),
534             ri: gpr(1),
535             mem: MemArg::BXD12 {
536                 base: gpr(2),
537                 index: zero_reg(),
538                 disp: UImm12::zero(),
539                 flags: MemFlags::trusted(),
540             },
541         },
542         "5A102000",
543         "a %r1, 0(%r2)",
544     ));
545     insns.push((
546         Inst::AluRX {
547             alu_op: ALUOp::Add32Ext16,
548             rd: writable_gpr(1),
549             ri: gpr(1),
550             mem: MemArg::BXD12 {
551                 base: gpr(2),
552                 index: zero_reg(),
553                 disp: UImm12::zero(),
554                 flags: MemFlags::trusted(),
555             },
556         },
557         "4A102000",
558         "ah %r1, 0(%r2)",
559     ));
560     insns.push((
561         Inst::AluRX {
562             alu_op: ALUOp::Add32,
563             rd: writable_gpr(1),
564             ri: gpr(1),
565             mem: MemArg::BXD20 {
566                 base: gpr(2),
567                 index: zero_reg(),
568                 disp: simm20_zero(),
569                 flags: MemFlags::trusted(),
570             },
571         },
572         "E3102000005A",
573         "ay %r1, 0(%r2)",
574     ));
575     insns.push((
576         Inst::AluRX {
577             alu_op: ALUOp::Add32Ext16,
578             rd: writable_gpr(1),
579             ri: gpr(1),
580             mem: MemArg::BXD20 {
581                 base: gpr(2),
582                 index: zero_reg(),
583                 disp: simm20_zero(),
584                 flags: MemFlags::trusted(),
585             },
586         },
587         "E3102000007A",
588         "ahy %r1, 0(%r2)",
589     ));
590     insns.push((
591         Inst::AluRX {
592             alu_op: ALUOp::Add64,
593             rd: writable_gpr(1),
594             ri: gpr(1),
595             mem: MemArg::BXD12 {
596                 base: gpr(2),
597                 index: zero_reg(),
598                 disp: UImm12::zero(),
599                 flags: MemFlags::trusted(),
600             },
601         },
602         "E31020000008",
603         "ag %r1, 0(%r2)",
604     ));
605     insns.push((
606         Inst::AluRX {
607             alu_op: ALUOp::Add64Ext16,
608             rd: writable_gpr(1),
609             ri: gpr(1),
610             mem: MemArg::BXD12 {
611                 base: gpr(2),
612                 index: zero_reg(),
613                 disp: UImm12::zero(),
614                 flags: MemFlags::trusted(),
615             },
616         },
617         "E31020000038",
618         "agh %r1, 0(%r2)",
619     ));
620     insns.push((
621         Inst::AluRX {
622             alu_op: ALUOp::Add64Ext32,
623             rd: writable_gpr(1),
624             ri: gpr(1),
625             mem: MemArg::BXD12 {
626                 base: gpr(2),
627                 index: zero_reg(),
628                 disp: UImm12::zero(),
629                 flags: MemFlags::trusted(),
630             },
631         },
632         "E31020000018",
633         "agf %r1, 0(%r2)",
634     ));
635     insns.push((
636         Inst::AluRX {
637             alu_op: ALUOp::AddLogical32,
638             rd: writable_gpr(1),
639             ri: gpr(1),
640             mem: MemArg::BXD12 {
641                 base: gpr(2),
642                 index: zero_reg(),
643                 disp: UImm12::zero(),
644                 flags: MemFlags::trusted(),
645             },
646         },
647         "5E102000",
648         "al %r1, 0(%r2)",
649     ));
650     insns.push((
651         Inst::AluRX {
652             alu_op: ALUOp::AddLogical32,
653             rd: writable_gpr(1),
654             ri: gpr(1),
655             mem: MemArg::BXD20 {
656                 base: gpr(2),
657                 index: zero_reg(),
658                 disp: simm20_zero(),
659                 flags: MemFlags::trusted(),
660             },
661         },
662         "E3102000005E",
663         "aly %r1, 0(%r2)",
664     ));
665     insns.push((
666         Inst::AluRX {
667             alu_op: ALUOp::AddLogical64,
668             rd: writable_gpr(1),
669             ri: gpr(1),
670             mem: MemArg::BXD12 {
671                 base: gpr(2),
672                 index: zero_reg(),
673                 disp: UImm12::zero(),
674                 flags: MemFlags::trusted(),
675             },
676         },
677         "E3102000000A",
678         "alg %r1, 0(%r2)",
679     ));
680     insns.push((
681         Inst::AluRX {
682             alu_op: ALUOp::AddLogical64Ext32,
683             rd: writable_gpr(1),
684             ri: gpr(1),
685             mem: MemArg::BXD12 {
686                 base: gpr(2),
687                 index: zero_reg(),
688                 disp: UImm12::zero(),
689                 flags: MemFlags::trusted(),
690             },
691         },
692         "E3102000001A",
693         "algf %r1, 0(%r2)",
694     ));
695     insns.push((
696         Inst::AluRX {
697             alu_op: ALUOp::Sub32,
698             rd: writable_gpr(1),
699             ri: gpr(1),
700             mem: MemArg::BXD12 {
701                 base: gpr(2),
702                 index: zero_reg(),
703                 disp: UImm12::zero(),
704                 flags: MemFlags::trusted(),
705             },
706         },
707         "5B102000",
708         "s %r1, 0(%r2)",
709     ));
710     insns.push((
711         Inst::AluRX {
712             alu_op: ALUOp::Sub32Ext16,
713             rd: writable_gpr(1),
714             ri: gpr(1),
715             mem: MemArg::BXD12 {
716                 base: gpr(2),
717                 index: zero_reg(),
718                 disp: UImm12::zero(),
719                 flags: MemFlags::trusted(),
720             },
721         },
722         "4B102000",
723         "sh %r1, 0(%r2)",
724     ));
725     insns.push((
726         Inst::AluRX {
727             alu_op: ALUOp::Sub32,
728             rd: writable_gpr(1),
729             ri: gpr(1),
730             mem: MemArg::BXD20 {
731                 base: gpr(2),
732                 index: zero_reg(),
733                 disp: simm20_zero(),
734                 flags: MemFlags::trusted(),
735             },
736         },
737         "E3102000005B",
738         "sy %r1, 0(%r2)",
739     ));
740     insns.push((
741         Inst::AluRX {
742             alu_op: ALUOp::Sub32Ext16,
743             rd: writable_gpr(1),
744             ri: gpr(1),
745             mem: MemArg::BXD20 {
746                 base: gpr(2),
747                 index: zero_reg(),
748                 disp: simm20_zero(),
749                 flags: MemFlags::trusted(),
750             },
751         },
752         "E3102000007B",
753         "shy %r1, 0(%r2)",
754     ));
755     insns.push((
756         Inst::AluRX {
757             alu_op: ALUOp::Sub64,
758             rd: writable_gpr(1),
759             ri: gpr(1),
760             mem: MemArg::BXD12 {
761                 base: gpr(2),
762                 index: zero_reg(),
763                 disp: UImm12::zero(),
764                 flags: MemFlags::trusted(),
765             },
766         },
767         "E31020000009",
768         "sg %r1, 0(%r2)",
769     ));
770     insns.push((
771         Inst::AluRX {
772             alu_op: ALUOp::Sub64Ext16,
773             rd: writable_gpr(1),
774             ri: gpr(1),
775             mem: MemArg::BXD12 {
776                 base: gpr(2),
777                 index: zero_reg(),
778                 disp: UImm12::zero(),
779                 flags: MemFlags::trusted(),
780             },
781         },
782         "E31020000039",
783         "sgh %r1, 0(%r2)",
784     ));
785     insns.push((
786         Inst::AluRX {
787             alu_op: ALUOp::Sub64Ext32,
788             rd: writable_gpr(1),
789             ri: gpr(1),
790             mem: MemArg::BXD12 {
791                 base: gpr(2),
792                 index: zero_reg(),
793                 disp: UImm12::zero(),
794                 flags: MemFlags::trusted(),
795             },
796         },
797         "E31020000019",
798         "sgf %r1, 0(%r2)",
799     ));
800     insns.push((
801         Inst::AluRX {
802             alu_op: ALUOp::SubLogical32,
803             rd: writable_gpr(1),
804             ri: gpr(1),
805             mem: MemArg::BXD12 {
806                 base: gpr(2),
807                 index: zero_reg(),
808                 disp: UImm12::zero(),
809                 flags: MemFlags::trusted(),
810             },
811         },
812         "5F102000",
813         "sl %r1, 0(%r2)",
814     ));
815     insns.push((
816         Inst::AluRX {
817             alu_op: ALUOp::SubLogical32,
818             rd: writable_gpr(1),
819             ri: gpr(1),
820             mem: MemArg::BXD20 {
821                 base: gpr(2),
822                 index: zero_reg(),
823                 disp: simm20_zero(),
824                 flags: MemFlags::trusted(),
825             },
826         },
827         "E3102000005F",
828         "sly %r1, 0(%r2)",
829     ));
830     insns.push((
831         Inst::AluRX {
832             alu_op: ALUOp::SubLogical64,
833             rd: writable_gpr(1),
834             ri: gpr(1),
835             mem: MemArg::BXD12 {
836                 base: gpr(2),
837                 index: zero_reg(),
838                 disp: UImm12::zero(),
839                 flags: MemFlags::trusted(),
840             },
841         },
842         "E3102000000B",
843         "slg %r1, 0(%r2)",
844     ));
845     insns.push((
846         Inst::AluRX {
847             alu_op: ALUOp::SubLogical64Ext32,
848             rd: writable_gpr(1),
849             ri: gpr(1),
850             mem: MemArg::BXD12 {
851                 base: gpr(2),
852                 index: zero_reg(),
853                 disp: UImm12::zero(),
854                 flags: MemFlags::trusted(),
855             },
856         },
857         "E3102000001B",
858         "slgf %r1, 0(%r2)",
859     ));
860     insns.push((
861         Inst::AluRX {
862             alu_op: ALUOp::Mul32,
863             rd: writable_gpr(1),
864             ri: gpr(1),
865             mem: MemArg::BXD12 {
866                 base: gpr(2),
867                 index: zero_reg(),
868                 disp: UImm12::zero(),
869                 flags: MemFlags::trusted(),
870             },
871         },
872         "71102000",
873         "ms %r1, 0(%r2)",
874     ));
875     insns.push((
876         Inst::AluRX {
877             alu_op: ALUOp::Mul32Ext16,
878             rd: writable_gpr(1),
879             ri: gpr(1),
880             mem: MemArg::BXD12 {
881                 base: gpr(2),
882                 index: zero_reg(),
883                 disp: UImm12::zero(),
884                 flags: MemFlags::trusted(),
885             },
886         },
887         "4C102000",
888         "mh %r1, 0(%r2)",
889     ));
890     insns.push((
891         Inst::AluRX {
892             alu_op: ALUOp::Mul32,
893             rd: writable_gpr(1),
894             ri: gpr(1),
895             mem: MemArg::BXD20 {
896                 base: gpr(2),
897                 index: zero_reg(),
898                 disp: simm20_zero(),
899                 flags: MemFlags::trusted(),
900             },
901         },
902         "E31020000051",
903         "msy %r1, 0(%r2)",
904     ));
905     insns.push((
906         Inst::AluRX {
907             alu_op: ALUOp::Mul32Ext16,
908             rd: writable_gpr(1),
909             ri: gpr(1),
910             mem: MemArg::BXD20 {
911                 base: gpr(2),
912                 index: zero_reg(),
913                 disp: simm20_zero(),
914                 flags: MemFlags::trusted(),
915             },
916         },
917         "E3102000007C",
918         "mhy %r1, 0(%r2)",
919     ));
920     insns.push((
921         Inst::AluRX {
922             alu_op: ALUOp::Mul64,
923             rd: writable_gpr(1),
924             ri: gpr(1),
925             mem: MemArg::BXD12 {
926                 base: gpr(2),
927                 index: zero_reg(),
928                 disp: UImm12::zero(),
929                 flags: MemFlags::trusted(),
930             },
931         },
932         "E3102000000C",
933         "msg %r1, 0(%r2)",
934     ));
935     insns.push((
936         Inst::AluRX {
937             alu_op: ALUOp::Mul64Ext16,
938             rd: writable_gpr(1),
939             ri: gpr(1),
940             mem: MemArg::BXD12 {
941                 base: gpr(2),
942                 index: zero_reg(),
943                 disp: UImm12::zero(),
944                 flags: MemFlags::trusted(),
945             },
946         },
947         "E3102000003C",
948         "mgh %r1, 0(%r2)",
949     ));
950     insns.push((
951         Inst::AluRX {
952             alu_op: ALUOp::Mul64Ext32,
953             rd: writable_gpr(1),
954             ri: gpr(1),
955             mem: MemArg::BXD12 {
956                 base: gpr(2),
957                 index: zero_reg(),
958                 disp: UImm12::zero(),
959                 flags: MemFlags::trusted(),
960             },
961         },
962         "E3102000001C",
963         "msgf %r1, 0(%r2)",
964     ));
965     insns.push((
966         Inst::AluRX {
967             alu_op: ALUOp::And32,
968             rd: writable_gpr(1),
969             ri: gpr(1),
970             mem: MemArg::BXD12 {
971                 base: gpr(2),
972                 index: zero_reg(),
973                 disp: UImm12::zero(),
974                 flags: MemFlags::trusted(),
975             },
976         },
977         "54102000",
978         "n %r1, 0(%r2)",
979     ));
980     insns.push((
981         Inst::AluRX {
982             alu_op: ALUOp::And32,
983             rd: writable_gpr(1),
984             ri: gpr(1),
985             mem: MemArg::BXD20 {
986                 base: gpr(2),
987                 index: zero_reg(),
988                 disp: simm20_zero(),
989                 flags: MemFlags::trusted(),
990             },
991         },
992         "E31020000054",
993         "ny %r1, 0(%r2)",
994     ));
995     insns.push((
996         Inst::AluRX {
997             alu_op: ALUOp::And64,
998             rd: writable_gpr(1),
999             ri: gpr(1),
1000             mem: MemArg::BXD12 {
1001                 base: gpr(2),
1002                 index: zero_reg(),
1003                 disp: UImm12::zero(),
1004                 flags: MemFlags::trusted(),
1005             },
1006         },
1007         "E31020000080",
1008         "ng %r1, 0(%r2)",
1009     ));
1010     insns.push((
1011         Inst::AluRX {
1012             alu_op: ALUOp::Orr32,
1013             rd: writable_gpr(1),
1014             ri: gpr(1),
1015             mem: MemArg::BXD12 {
1016                 base: gpr(2),
1017                 index: zero_reg(),
1018                 disp: UImm12::zero(),
1019                 flags: MemFlags::trusted(),
1020             },
1021         },
1022         "56102000",
1023         "o %r1, 0(%r2)",
1024     ));
1025     insns.push((
1026         Inst::AluRX {
1027             alu_op: ALUOp::Orr32,
1028             rd: writable_gpr(1),
1029             ri: gpr(1),
1030             mem: MemArg::BXD20 {
1031                 base: gpr(2),
1032                 index: zero_reg(),
1033                 disp: simm20_zero(),
1034                 flags: MemFlags::trusted(),
1035             },
1036         },
1037         "E31020000056",
1038         "oy %r1, 0(%r2)",
1039     ));
1040     insns.push((
1041         Inst::AluRX {
1042             alu_op: ALUOp::Orr64,
1043             rd: writable_gpr(1),
1044             ri: gpr(1),
1045             mem: MemArg::BXD12 {
1046                 base: gpr(2),
1047                 index: zero_reg(),
1048                 disp: UImm12::zero(),
1049                 flags: MemFlags::trusted(),
1050             },
1051         },
1052         "E31020000081",
1053         "og %r1, 0(%r2)",
1054     ));
1055     insns.push((
1056         Inst::AluRX {
1057             alu_op: ALUOp::Xor32,
1058             rd: writable_gpr(1),
1059             ri: gpr(1),
1060             mem: MemArg::BXD12 {
1061                 base: gpr(2),
1062                 index: zero_reg(),
1063                 disp: UImm12::zero(),
1064                 flags: MemFlags::trusted(),
1065             },
1066         },
1067         "57102000",
1068         "x %r1, 0(%r2)",
1069     ));
1070     insns.push((
1071         Inst::AluRX {
1072             alu_op: ALUOp::Xor32,
1073             rd: writable_gpr(1),
1074             ri: gpr(1),
1075             mem: MemArg::BXD20 {
1076                 base: gpr(2),
1077                 index: zero_reg(),
1078                 disp: simm20_zero(),
1079                 flags: MemFlags::trusted(),
1080             },
1081         },
1082         "E31020000057",
1083         "xy %r1, 0(%r2)",
1084     ));
1085     insns.push((
1086         Inst::AluRX {
1087             alu_op: ALUOp::Xor64,
1088             rd: writable_gpr(1),
1089             ri: gpr(1),
1090             mem: MemArg::BXD12 {
1091                 base: gpr(2),
1092                 index: zero_reg(),
1093                 disp: UImm12::zero(),
1094                 flags: MemFlags::trusted(),
1095             },
1096         },
1097         "E31020000082",
1098         "xg %r1, 0(%r2)",
1099     ));
1100 
1101     insns.push((
1102         Inst::AluRSImm16 {
1103             alu_op: ALUOp::Add32,
1104             rd: writable_gpr(7),
1105             ri: gpr(7),
1106             imm: -32768,
1107         },
1108         "A77A8000",
1109         "ahi %r7, -32768",
1110     ));
1111     insns.push((
1112         Inst::AluRSImm16 {
1113             alu_op: ALUOp::Add32,
1114             rd: writable_gpr(7),
1115             ri: gpr(7),
1116             imm: 32767,
1117         },
1118         "A77A7FFF",
1119         "ahi %r7, 32767",
1120     ));
1121     insns.push((
1122         Inst::AluRSImm16 {
1123             alu_op: ALUOp::Add64,
1124             rd: writable_gpr(7),
1125             ri: gpr(7),
1126             imm: -32768,
1127         },
1128         "A77B8000",
1129         "aghi %r7, -32768",
1130     ));
1131     insns.push((
1132         Inst::AluRSImm16 {
1133             alu_op: ALUOp::Add64,
1134             rd: writable_gpr(7),
1135             ri: gpr(7),
1136             imm: 32767,
1137         },
1138         "A77B7FFF",
1139         "aghi %r7, 32767",
1140     ));
1141     insns.push((
1142         Inst::AluRSImm16 {
1143             alu_op: ALUOp::Mul32,
1144             rd: writable_gpr(7),
1145             ri: gpr(7),
1146             imm: -32768,
1147         },
1148         "A77C8000",
1149         "mhi %r7, -32768",
1150     ));
1151     insns.push((
1152         Inst::AluRSImm16 {
1153             alu_op: ALUOp::Mul32,
1154             rd: writable_gpr(7),
1155             ri: gpr(7),
1156             imm: 32767,
1157         },
1158         "A77C7FFF",
1159         "mhi %r7, 32767",
1160     ));
1161     insns.push((
1162         Inst::AluRSImm16 {
1163             alu_op: ALUOp::Mul64,
1164             rd: writable_gpr(7),
1165             ri: gpr(7),
1166             imm: -32768,
1167         },
1168         "A77D8000",
1169         "mghi %r7, -32768",
1170     ));
1171     insns.push((
1172         Inst::AluRSImm16 {
1173             alu_op: ALUOp::Mul64,
1174             rd: writable_gpr(7),
1175             ri: gpr(7),
1176             imm: 32767,
1177         },
1178         "A77D7FFF",
1179         "mghi %r7, 32767",
1180     ));
1181 
1182     insns.push((
1183         Inst::AluRSImm32 {
1184             alu_op: ALUOp::Add32,
1185             rd: writable_gpr(7),
1186             ri: gpr(7),
1187             imm: -2147483648,
1188         },
1189         "C27980000000",
1190         "afi %r7, -2147483648",
1191     ));
1192     insns.push((
1193         Inst::AluRSImm32 {
1194             alu_op: ALUOp::Add32,
1195             rd: writable_gpr(7),
1196             ri: gpr(7),
1197             imm: 2147483647,
1198         },
1199         "C2797FFFFFFF",
1200         "afi %r7, 2147483647",
1201     ));
1202     insns.push((
1203         Inst::AluRSImm32 {
1204             alu_op: ALUOp::Mul32,
1205             rd: writable_gpr(7),
1206             ri: gpr(7),
1207             imm: -2147483648,
1208         },
1209         "C27180000000",
1210         "msfi %r7, -2147483648",
1211     ));
1212     insns.push((
1213         Inst::AluRSImm32 {
1214             alu_op: ALUOp::Mul32,
1215             rd: writable_gpr(7),
1216             ri: gpr(7),
1217             imm: 2147483647,
1218         },
1219         "C2717FFFFFFF",
1220         "msfi %r7, 2147483647",
1221     ));
1222     insns.push((
1223         Inst::AluRSImm32 {
1224             alu_op: ALUOp::Add64,
1225             rd: writable_gpr(7),
1226             ri: gpr(7),
1227             imm: -2147483648,
1228         },
1229         "C27880000000",
1230         "agfi %r7, -2147483648",
1231     ));
1232     insns.push((
1233         Inst::AluRSImm32 {
1234             alu_op: ALUOp::Add64,
1235             rd: writable_gpr(7),
1236             ri: gpr(7),
1237             imm: 2147483647,
1238         },
1239         "C2787FFFFFFF",
1240         "agfi %r7, 2147483647",
1241     ));
1242     insns.push((
1243         Inst::AluRSImm32 {
1244             alu_op: ALUOp::Mul64,
1245             rd: writable_gpr(7),
1246             ri: gpr(7),
1247             imm: -2147483648,
1248         },
1249         "C27080000000",
1250         "msgfi %r7, -2147483648",
1251     ));
1252     insns.push((
1253         Inst::AluRSImm32 {
1254             alu_op: ALUOp::Mul64,
1255             rd: writable_gpr(7),
1256             ri: gpr(7),
1257             imm: 2147483647,
1258         },
1259         "C2707FFFFFFF",
1260         "msgfi %r7, 2147483647",
1261     ));
1262 
1263     insns.push((
1264         Inst::AluRUImm32 {
1265             alu_op: ALUOp::AddLogical32,
1266             rd: writable_gpr(7),
1267             ri: gpr(7),
1268             imm: 0,
1269         },
1270         "C27B00000000",
1271         "alfi %r7, 0",
1272     ));
1273     insns.push((
1274         Inst::AluRUImm32 {
1275             alu_op: ALUOp::AddLogical32,
1276             rd: writable_gpr(7),
1277             ri: gpr(7),
1278             imm: 4294967295,
1279         },
1280         "C27BFFFFFFFF",
1281         "alfi %r7, 4294967295",
1282     ));
1283     insns.push((
1284         Inst::AluRUImm32 {
1285             alu_op: ALUOp::SubLogical32,
1286             rd: writable_gpr(7),
1287             ri: gpr(7),
1288             imm: 0,
1289         },
1290         "C27500000000",
1291         "slfi %r7, 0",
1292     ));
1293     insns.push((
1294         Inst::AluRUImm32 {
1295             alu_op: ALUOp::SubLogical32,
1296             rd: writable_gpr(7),
1297             ri: gpr(7),
1298             imm: 4294967295,
1299         },
1300         "C275FFFFFFFF",
1301         "slfi %r7, 4294967295",
1302     ));
1303     insns.push((
1304         Inst::AluRUImm32 {
1305             alu_op: ALUOp::AddLogical64,
1306             rd: writable_gpr(7),
1307             ri: gpr(7),
1308             imm: 0,
1309         },
1310         "C27A00000000",
1311         "algfi %r7, 0",
1312     ));
1313     insns.push((
1314         Inst::AluRUImm32 {
1315             alu_op: ALUOp::AddLogical64,
1316             rd: writable_gpr(7),
1317             ri: gpr(7),
1318             imm: 4294967295,
1319         },
1320         "C27AFFFFFFFF",
1321         "algfi %r7, 4294967295",
1322     ));
1323     insns.push((
1324         Inst::AluRUImm32 {
1325             alu_op: ALUOp::SubLogical64,
1326             rd: writable_gpr(7),
1327             ri: gpr(7),
1328             imm: 0,
1329         },
1330         "C27400000000",
1331         "slgfi %r7, 0",
1332     ));
1333     insns.push((
1334         Inst::AluRUImm32 {
1335             alu_op: ALUOp::SubLogical64,
1336             rd: writable_gpr(7),
1337             ri: gpr(7),
1338             imm: 4294967295,
1339         },
1340         "C274FFFFFFFF",
1341         "slgfi %r7, 4294967295",
1342     ));
1343 
1344     insns.push((
1345         Inst::AluRUImm16Shifted {
1346             alu_op: ALUOp::And32,
1347             rd: writable_gpr(8),
1348             ri: gpr(8),
1349             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff).unwrap(),
1350         },
1351         "A587FFFF",
1352         "nill %r8, 65535",
1353     ));
1354     insns.push((
1355         Inst::AluRUImm16Shifted {
1356             alu_op: ALUOp::And32,
1357             rd: writable_gpr(8),
1358             ri: gpr(8),
1359             imm: UImm16Shifted::maybe_from_u64(0xffff_0000).unwrap(),
1360         },
1361         "A586FFFF",
1362         "nilh %r8, 65535",
1363     ));
1364     insns.push((
1365         Inst::AluRUImm16Shifted {
1366             alu_op: ALUOp::And64,
1367             rd: writable_gpr(8),
1368             ri: gpr(8),
1369             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_0000_ffff).unwrap(),
1370         },
1371         "A587FFFF",
1372         "nill %r8, 65535",
1373     ));
1374     insns.push((
1375         Inst::AluRUImm16Shifted {
1376             alu_op: ALUOp::And64,
1377             rd: writable_gpr(8),
1378             ri: gpr(8),
1379             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_ffff_0000).unwrap(),
1380         },
1381         "A586FFFF",
1382         "nilh %r8, 65535",
1383     ));
1384     insns.push((
1385         Inst::AluRUImm16Shifted {
1386             alu_op: ALUOp::And64,
1387             rd: writable_gpr(8),
1388             ri: gpr(8),
1389             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff_0000_0000).unwrap(),
1390         },
1391         "A585FFFF",
1392         "nihl %r8, 65535",
1393     ));
1394     insns.push((
1395         Inst::AluRUImm16Shifted {
1396             alu_op: ALUOp::And64,
1397             rd: writable_gpr(8),
1398             ri: gpr(8),
1399             imm: UImm16Shifted::maybe_from_u64(0xffff_0000_0000_0000).unwrap(),
1400         },
1401         "A584FFFF",
1402         "nihh %r8, 65535",
1403     ));
1404     insns.push((
1405         Inst::AluRUImm16Shifted {
1406             alu_op: ALUOp::Orr32,
1407             rd: writable_gpr(8),
1408             ri: gpr(8),
1409             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff).unwrap(),
1410         },
1411         "A58BFFFF",
1412         "oill %r8, 65535",
1413     ));
1414     insns.push((
1415         Inst::AluRUImm16Shifted {
1416             alu_op: ALUOp::Orr32,
1417             rd: writable_gpr(8),
1418             ri: gpr(8),
1419             imm: UImm16Shifted::maybe_from_u64(0xffff_0000).unwrap(),
1420         },
1421         "A58AFFFF",
1422         "oilh %r8, 65535",
1423     ));
1424     insns.push((
1425         Inst::AluRUImm16Shifted {
1426             alu_op: ALUOp::Orr64,
1427             rd: writable_gpr(8),
1428             ri: gpr(8),
1429             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_0000_ffff).unwrap(),
1430         },
1431         "A58BFFFF",
1432         "oill %r8, 65535",
1433     ));
1434     insns.push((
1435         Inst::AluRUImm16Shifted {
1436             alu_op: ALUOp::Orr64,
1437             rd: writable_gpr(8),
1438             ri: gpr(8),
1439             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_ffff_0000).unwrap(),
1440         },
1441         "A58AFFFF",
1442         "oilh %r8, 65535",
1443     ));
1444     insns.push((
1445         Inst::AluRUImm16Shifted {
1446             alu_op: ALUOp::Orr64,
1447             rd: writable_gpr(8),
1448             ri: gpr(8),
1449             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff_0000_0000).unwrap(),
1450         },
1451         "A589FFFF",
1452         "oihl %r8, 65535",
1453     ));
1454     insns.push((
1455         Inst::AluRUImm16Shifted {
1456             alu_op: ALUOp::Orr64,
1457             rd: writable_gpr(8),
1458             ri: gpr(8),
1459             imm: UImm16Shifted::maybe_from_u64(0xffff_0000_0000_0000).unwrap(),
1460         },
1461         "A588FFFF",
1462         "oihh %r8, 65535",
1463     ));
1464 
1465     insns.push((
1466         Inst::AluRUImm32Shifted {
1467             alu_op: ALUOp::And32,
1468             rd: writable_gpr(8),
1469             ri: gpr(8),
1470             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff).unwrap(),
1471         },
1472         "C08BFFFFFFFF",
1473         "nilf %r8, 4294967295",
1474     ));
1475     insns.push((
1476         Inst::AluRUImm32Shifted {
1477             alu_op: ALUOp::And64,
1478             rd: writable_gpr(8),
1479             ri: gpr(8),
1480             imm: UImm32Shifted::maybe_from_u64(0x0000_0000_ffff_ffff).unwrap(),
1481         },
1482         "C08BFFFFFFFF",
1483         "nilf %r8, 4294967295",
1484     ));
1485     insns.push((
1486         Inst::AluRUImm32Shifted {
1487             alu_op: ALUOp::And64,
1488             rd: writable_gpr(8),
1489             ri: gpr(8),
1490             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff_0000_0000).unwrap(),
1491         },
1492         "C08AFFFFFFFF",
1493         "nihf %r8, 4294967295",
1494     ));
1495     insns.push((
1496         Inst::AluRUImm32Shifted {
1497             alu_op: ALUOp::Orr32,
1498             rd: writable_gpr(8),
1499             ri: gpr(8),
1500             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff).unwrap(),
1501         },
1502         "C08DFFFFFFFF",
1503         "oilf %r8, 4294967295",
1504     ));
1505     insns.push((
1506         Inst::AluRUImm32Shifted {
1507             alu_op: ALUOp::Orr64,
1508             rd: writable_gpr(8),
1509             ri: gpr(8),
1510             imm: UImm32Shifted::maybe_from_u64(0x0000_0000_ffff_ffff).unwrap(),
1511         },
1512         "C08DFFFFFFFF",
1513         "oilf %r8, 4294967295",
1514     ));
1515     insns.push((
1516         Inst::AluRUImm32Shifted {
1517             alu_op: ALUOp::Orr64,
1518             rd: writable_gpr(8),
1519             ri: gpr(8),
1520             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff_0000_0000).unwrap(),
1521         },
1522         "C08CFFFFFFFF",
1523         "oihf %r8, 4294967295",
1524     ));
1525     insns.push((
1526         Inst::AluRUImm32Shifted {
1527             alu_op: ALUOp::Xor32,
1528             rd: writable_gpr(8),
1529             ri: gpr(8),
1530             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff).unwrap(),
1531         },
1532         "C087FFFFFFFF",
1533         "xilf %r8, 4294967295",
1534     ));
1535     insns.push((
1536         Inst::AluRUImm32Shifted {
1537             alu_op: ALUOp::Xor64,
1538             rd: writable_gpr(8),
1539             ri: gpr(8),
1540             imm: UImm32Shifted::maybe_from_u64(0x0000_0000_ffff_ffff).unwrap(),
1541         },
1542         "C087FFFFFFFF",
1543         "xilf %r8, 4294967295",
1544     ));
1545     insns.push((
1546         Inst::AluRUImm32Shifted {
1547             alu_op: ALUOp::Xor64,
1548             rd: writable_gpr(8),
1549             ri: gpr(8),
1550             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff_0000_0000).unwrap(),
1551         },
1552         "C086FFFFFFFF",
1553         "xihf %r8, 4294967295",
1554     ));
1555 
1556     insns.push((
1557         Inst::UnaryRR {
1558             op: UnaryOp::Abs32,
1559             rd: writable_gpr(1),
1560             rn: gpr(10),
1561         },
1562         "101A",
1563         "lpr %r1, %r10",
1564     ));
1565     insns.push((
1566         Inst::UnaryRR {
1567             op: UnaryOp::Abs64,
1568             rd: writable_gpr(1),
1569             rn: gpr(10),
1570         },
1571         "B900001A",
1572         "lpgr %r1, %r10",
1573     ));
1574     insns.push((
1575         Inst::UnaryRR {
1576             op: UnaryOp::Abs64Ext32,
1577             rd: writable_gpr(1),
1578             rn: gpr(10),
1579         },
1580         "B910001A",
1581         "lpgfr %r1, %r10",
1582     ));
1583     insns.push((
1584         Inst::UnaryRR {
1585             op: UnaryOp::Neg32,
1586             rd: writable_gpr(1),
1587             rn: gpr(10),
1588         },
1589         "131A",
1590         "lcr %r1, %r10",
1591     ));
1592     insns.push((
1593         Inst::UnaryRR {
1594             op: UnaryOp::Neg64,
1595             rd: writable_gpr(1),
1596             rn: gpr(10),
1597         },
1598         "B903001A",
1599         "lcgr %r1, %r10",
1600     ));
1601     insns.push((
1602         Inst::UnaryRR {
1603             op: UnaryOp::Neg64Ext32,
1604             rd: writable_gpr(1),
1605             rn: gpr(10),
1606         },
1607         "B913001A",
1608         "lcgfr %r1, %r10",
1609     ));
1610     insns.push((
1611         Inst::UnaryRR {
1612             op: UnaryOp::PopcntByte,
1613             rd: writable_gpr(1),
1614             rn: gpr(10),
1615         },
1616         "B9E1001A",
1617         "popcnt %r1, %r10",
1618     ));
1619     insns.push((
1620         Inst::UnaryRR {
1621             op: UnaryOp::PopcntReg,
1622             rd: writable_gpr(1),
1623             rn: gpr(10),
1624         },
1625         "B9E1801A",
1626         "popcnt %r1, %r10, 8",
1627     ));
1628     insns.push((
1629         Inst::UnaryRR {
1630             op: UnaryOp::BSwap32,
1631             rd: writable_gpr(1),
1632             rn: gpr(10),
1633         },
1634         "B91F001A",
1635         "lrvr %r1, %r10",
1636     ));
1637     insns.push((
1638         Inst::UnaryRR {
1639             op: UnaryOp::BSwap64,
1640             rd: writable_gpr(1),
1641             rn: gpr(10),
1642         },
1643         "B90F001A",
1644         "lrvgr %r1, %r10",
1645     ));
1646     insns.push((
1647         Inst::UnaryRR {
1648             op: UnaryOp::Clz64,
1649             rd: writable_gpr(1),
1650             rn: gpr(10),
1651         },
1652         "B968001A",
1653         "clzg %r1, %r10",
1654     ));
1655     insns.push((
1656         Inst::UnaryRR {
1657             op: UnaryOp::Ctz64,
1658             rd: writable_gpr(1),
1659             rn: gpr(10),
1660         },
1661         "B969001A",
1662         "ctzg %r1, %r10",
1663     ));
1664 
1665     insns.push((
1666         Inst::CmpRR {
1667             op: CmpOp::CmpS32,
1668             rn: gpr(5),
1669             rm: gpr(6),
1670         },
1671         "1956",
1672         "cr %r5, %r6",
1673     ));
1674     insns.push((
1675         Inst::CmpRR {
1676             op: CmpOp::CmpS64,
1677             rn: gpr(5),
1678             rm: gpr(6),
1679         },
1680         "B9200056",
1681         "cgr %r5, %r6",
1682     ));
1683     insns.push((
1684         Inst::CmpRR {
1685             op: CmpOp::CmpS64Ext32,
1686             rn: gpr(5),
1687             rm: gpr(6),
1688         },
1689         "B9300056",
1690         "cgfr %r5, %r6",
1691     ));
1692     insns.push((
1693         Inst::CmpRR {
1694             op: CmpOp::CmpL32,
1695             rn: gpr(5),
1696             rm: gpr(6),
1697         },
1698         "1556",
1699         "clr %r5, %r6",
1700     ));
1701     insns.push((
1702         Inst::CmpRR {
1703             op: CmpOp::CmpL64,
1704             rn: gpr(5),
1705             rm: gpr(6),
1706         },
1707         "B9210056",
1708         "clgr %r5, %r6",
1709     ));
1710     insns.push((
1711         Inst::CmpRR {
1712             op: CmpOp::CmpL64Ext32,
1713             rn: gpr(5),
1714             rm: gpr(6),
1715         },
1716         "B9310056",
1717         "clgfr %r5, %r6",
1718     ));
1719 
1720     insns.push((
1721         Inst::CmpRX {
1722             op: CmpOp::CmpS32,
1723             rn: gpr(1),
1724             mem: MemArg::BXD12 {
1725                 base: gpr(2),
1726                 index: zero_reg(),
1727                 disp: UImm12::zero(),
1728                 flags: MemFlags::trusted(),
1729             },
1730         },
1731         "59102000",
1732         "c %r1, 0(%r2)",
1733     ));
1734     insns.push((
1735         Inst::CmpRX {
1736             op: CmpOp::CmpS32,
1737             rn: gpr(1),
1738             mem: MemArg::BXD20 {
1739                 base: gpr(2),
1740                 index: zero_reg(),
1741                 disp: simm20_zero(),
1742                 flags: MemFlags::trusted(),
1743             },
1744         },
1745         "E31020000059",
1746         "cy %r1, 0(%r2)",
1747     ));
1748     insns.push((
1749         Inst::CmpRX {
1750             op: CmpOp::CmpS32,
1751             rn: gpr(1),
1752             mem: MemArg::Label {
1753                 target: MachLabel::from_block(BlockIndex::new(1)),
1754             },
1755         },
1756         "C61D00000003",
1757         "crl %r1, label1",
1758     ));
1759     insns.push((
1760         Inst::CmpRX {
1761             op: CmpOp::CmpS32Ext16,
1762             rn: gpr(1),
1763             mem: MemArg::BXD12 {
1764                 base: gpr(2),
1765                 index: zero_reg(),
1766                 disp: UImm12::zero(),
1767                 flags: MemFlags::trusted(),
1768             },
1769         },
1770         "49102000",
1771         "ch %r1, 0(%r2)",
1772     ));
1773     insns.push((
1774         Inst::CmpRX {
1775             op: CmpOp::CmpS32Ext16,
1776             rn: gpr(1),
1777             mem: MemArg::BXD20 {
1778                 base: gpr(2),
1779                 index: zero_reg(),
1780                 disp: simm20_zero(),
1781                 flags: MemFlags::trusted(),
1782             },
1783         },
1784         "E31020000079",
1785         "chy %r1, 0(%r2)",
1786     ));
1787     insns.push((
1788         Inst::CmpRX {
1789             op: CmpOp::CmpS32Ext16,
1790             rn: gpr(1),
1791             mem: MemArg::Label {
1792                 target: MachLabel::from_block(BlockIndex::new(1)),
1793             },
1794         },
1795         "C61500000003",
1796         "chrl %r1, label1",
1797     ));
1798     insns.push((
1799         Inst::CmpRX {
1800             op: CmpOp::CmpS64,
1801             rn: gpr(1),
1802             mem: MemArg::BXD12 {
1803                 base: gpr(2),
1804                 index: zero_reg(),
1805                 disp: UImm12::zero(),
1806                 flags: MemFlags::trusted(),
1807             },
1808         },
1809         "E31020000020",
1810         "cg %r1, 0(%r2)",
1811     ));
1812     insns.push((
1813         Inst::CmpRX {
1814             op: CmpOp::CmpS64,
1815             rn: gpr(1),
1816             mem: MemArg::Label {
1817                 target: MachLabel::from_block(BlockIndex::new(1)),
1818             },
1819         },
1820         "C61800000003",
1821         "cgrl %r1, label1",
1822     ));
1823     insns.push((
1824         Inst::CmpRX {
1825             op: CmpOp::CmpS64Ext16,
1826             rn: gpr(1),
1827             mem: MemArg::BXD12 {
1828                 base: gpr(2),
1829                 index: zero_reg(),
1830                 disp: UImm12::zero(),
1831                 flags: MemFlags::trusted(),
1832             },
1833         },
1834         "E31020000034",
1835         "cgh %r1, 0(%r2)",
1836     ));
1837     insns.push((
1838         Inst::CmpRX {
1839             op: CmpOp::CmpS64Ext16,
1840             rn: gpr(1),
1841             mem: MemArg::Label {
1842                 target: MachLabel::from_block(BlockIndex::new(1)),
1843             },
1844         },
1845         "C61400000003",
1846         "cghrl %r1, label1",
1847     ));
1848     insns.push((
1849         Inst::CmpRX {
1850             op: CmpOp::CmpS64Ext32,
1851             rn: gpr(1),
1852             mem: MemArg::BXD12 {
1853                 base: gpr(2),
1854                 index: zero_reg(),
1855                 disp: UImm12::zero(),
1856                 flags: MemFlags::trusted(),
1857             },
1858         },
1859         "E31020000030",
1860         "cgf %r1, 0(%r2)",
1861     ));
1862     insns.push((
1863         Inst::CmpRX {
1864             op: CmpOp::CmpS64Ext32,
1865             rn: gpr(1),
1866             mem: MemArg::Label {
1867                 target: MachLabel::from_block(BlockIndex::new(1)),
1868             },
1869         },
1870         "C61C00000003",
1871         "cgfrl %r1, label1",
1872     ));
1873     insns.push((
1874         Inst::CmpRX {
1875             op: CmpOp::CmpL32,
1876             rn: gpr(1),
1877             mem: MemArg::BXD12 {
1878                 base: gpr(2),
1879                 index: zero_reg(),
1880                 disp: UImm12::zero(),
1881                 flags: MemFlags::trusted(),
1882             },
1883         },
1884         "55102000",
1885         "cl %r1, 0(%r2)",
1886     ));
1887     insns.push((
1888         Inst::CmpRX {
1889             op: CmpOp::CmpL32,
1890             rn: gpr(1),
1891             mem: MemArg::BXD20 {
1892                 base: gpr(2),
1893                 index: zero_reg(),
1894                 disp: simm20_zero(),
1895                 flags: MemFlags::trusted(),
1896             },
1897         },
1898         "E31020000055",
1899         "cly %r1, 0(%r2)",
1900     ));
1901     insns.push((
1902         Inst::CmpRX {
1903             op: CmpOp::CmpL32,
1904             rn: gpr(1),
1905             mem: MemArg::Label {
1906                 target: MachLabel::from_block(BlockIndex::new(1)),
1907             },
1908         },
1909         "C61F00000003",
1910         "clrl %r1, label1",
1911     ));
1912     insns.push((
1913         Inst::CmpRX {
1914             op: CmpOp::CmpL32Ext16,
1915             rn: gpr(1),
1916             mem: MemArg::Label {
1917                 target: MachLabel::from_block(BlockIndex::new(1)),
1918             },
1919         },
1920         "C61700000003",
1921         "clhrl %r1, label1",
1922     ));
1923     insns.push((
1924         Inst::CmpRX {
1925             op: CmpOp::CmpL64,
1926             rn: gpr(1),
1927             mem: MemArg::BXD12 {
1928                 base: gpr(2),
1929                 index: zero_reg(),
1930                 disp: UImm12::zero(),
1931                 flags: MemFlags::trusted(),
1932             },
1933         },
1934         "E31020000021",
1935         "clg %r1, 0(%r2)",
1936     ));
1937     insns.push((
1938         Inst::CmpRX {
1939             op: CmpOp::CmpL64,
1940             rn: gpr(1),
1941             mem: MemArg::Label {
1942                 target: MachLabel::from_block(BlockIndex::new(1)),
1943             },
1944         },
1945         "C61A00000003",
1946         "clgrl %r1, label1",
1947     ));
1948     insns.push((
1949         Inst::CmpRX {
1950             op: CmpOp::CmpL64Ext16,
1951             rn: gpr(1),
1952             mem: MemArg::Label {
1953                 target: MachLabel::from_block(BlockIndex::new(1)),
1954             },
1955         },
1956         "C61600000003",
1957         "clghrl %r1, label1",
1958     ));
1959     insns.push((
1960         Inst::CmpRX {
1961             op: CmpOp::CmpL64Ext32,
1962             rn: gpr(1),
1963             mem: MemArg::BXD12 {
1964                 base: gpr(2),
1965                 index: zero_reg(),
1966                 disp: UImm12::zero(),
1967                 flags: MemFlags::trusted(),
1968             },
1969         },
1970         "E31020000031",
1971         "clgf %r1, 0(%r2)",
1972     ));
1973     insns.push((
1974         Inst::CmpRX {
1975             op: CmpOp::CmpL64Ext32,
1976             rn: gpr(1),
1977             mem: MemArg::Label {
1978                 target: MachLabel::from_block(BlockIndex::new(1)),
1979             },
1980         },
1981         "C61E00000003",
1982         "clgfrl %r1, label1",
1983     ));
1984 
1985     insns.push((
1986         Inst::CmpRSImm16 {
1987             op: CmpOp::CmpS32,
1988             rn: gpr(7),
1989             imm: -32768,
1990         },
1991         "A77E8000",
1992         "chi %r7, -32768",
1993     ));
1994     insns.push((
1995         Inst::CmpRSImm16 {
1996             op: CmpOp::CmpS32,
1997             rn: gpr(7),
1998             imm: 32767,
1999         },
2000         "A77E7FFF",
2001         "chi %r7, 32767",
2002     ));
2003     insns.push((
2004         Inst::CmpRSImm16 {
2005             op: CmpOp::CmpS64,
2006             rn: gpr(7),
2007             imm: -32768,
2008         },
2009         "A77F8000",
2010         "cghi %r7, -32768",
2011     ));
2012     insns.push((
2013         Inst::CmpRSImm16 {
2014             op: CmpOp::CmpS64,
2015             rn: gpr(7),
2016             imm: 32767,
2017         },
2018         "A77F7FFF",
2019         "cghi %r7, 32767",
2020     ));
2021     insns.push((
2022         Inst::CmpRSImm32 {
2023             op: CmpOp::CmpS32,
2024             rn: gpr(7),
2025             imm: -2147483648,
2026         },
2027         "C27D80000000",
2028         "cfi %r7, -2147483648",
2029     ));
2030     insns.push((
2031         Inst::CmpRSImm32 {
2032             op: CmpOp::CmpS32,
2033             rn: gpr(7),
2034             imm: 2147483647,
2035         },
2036         "C27D7FFFFFFF",
2037         "cfi %r7, 2147483647",
2038     ));
2039     insns.push((
2040         Inst::CmpRSImm32 {
2041             op: CmpOp::CmpS64,
2042             rn: gpr(7),
2043             imm: -2147483648,
2044         },
2045         "C27C80000000",
2046         "cgfi %r7, -2147483648",
2047     ));
2048     insns.push((
2049         Inst::CmpRSImm32 {
2050             op: CmpOp::CmpS64,
2051             rn: gpr(7),
2052             imm: 2147483647,
2053         },
2054         "C27C7FFFFFFF",
2055         "cgfi %r7, 2147483647",
2056     ));
2057     insns.push((
2058         Inst::CmpRUImm32 {
2059             op: CmpOp::CmpL32,
2060             rn: gpr(7),
2061             imm: 0,
2062         },
2063         "C27F00000000",
2064         "clfi %r7, 0",
2065     ));
2066     insns.push((
2067         Inst::CmpRUImm32 {
2068             op: CmpOp::CmpL32,
2069             rn: gpr(7),
2070             imm: 4294967295,
2071         },
2072         "C27FFFFFFFFF",
2073         "clfi %r7, 4294967295",
2074     ));
2075     insns.push((
2076         Inst::CmpRUImm32 {
2077             op: CmpOp::CmpL64,
2078             rn: gpr(7),
2079             imm: 0,
2080         },
2081         "C27E00000000",
2082         "clgfi %r7, 0",
2083     ));
2084     insns.push((
2085         Inst::CmpRUImm32 {
2086             op: CmpOp::CmpL64,
2087             rn: gpr(7),
2088             imm: 4294967295,
2089         },
2090         "C27EFFFFFFFF",
2091         "clgfi %r7, 4294967295",
2092     ));
2093 
2094     insns.push((
2095         Inst::CmpTrapRR {
2096             op: CmpOp::CmpS32,
2097             rn: gpr(5),
2098             rm: gpr(6),
2099             cond: Cond::from_mask(8),
2100             trap_code: TrapCode::STACK_OVERFLOW,
2101         },
2102         "B9728056",
2103         "crte %r5, %r6",
2104     ));
2105     insns.push((
2106         Inst::CmpTrapRR {
2107             op: CmpOp::CmpS64,
2108             rn: gpr(5),
2109             rm: gpr(6),
2110             cond: Cond::from_mask(8),
2111             trap_code: TrapCode::STACK_OVERFLOW,
2112         },
2113         "B9608056",
2114         "cgrte %r5, %r6",
2115     ));
2116     insns.push((
2117         Inst::CmpTrapRR {
2118             op: CmpOp::CmpL32,
2119             rn: gpr(5),
2120             rm: gpr(6),
2121             cond: Cond::from_mask(8),
2122             trap_code: TrapCode::STACK_OVERFLOW,
2123         },
2124         "B9738056",
2125         "clrte %r5, %r6",
2126     ));
2127     insns.push((
2128         Inst::CmpTrapRR {
2129             op: CmpOp::CmpL64,
2130             rn: gpr(5),
2131             rm: gpr(6),
2132             cond: Cond::from_mask(8),
2133             trap_code: TrapCode::STACK_OVERFLOW,
2134         },
2135         "B9618056",
2136         "clgrte %r5, %r6",
2137     ));
2138     insns.push((
2139         Inst::CmpTrapRSImm16 {
2140             op: CmpOp::CmpS32,
2141             rn: gpr(7),
2142             imm: -32768,
2143             cond: Cond::from_mask(8),
2144             trap_code: TrapCode::STACK_OVERFLOW,
2145         },
2146         "EC7080008072",
2147         "cite %r7, -32768",
2148     ));
2149     insns.push((
2150         Inst::CmpTrapRSImm16 {
2151             op: CmpOp::CmpS32,
2152             rn: gpr(7),
2153             imm: 32767,
2154             cond: Cond::from_mask(8),
2155             trap_code: TrapCode::STACK_OVERFLOW,
2156         },
2157         "EC707FFF8072",
2158         "cite %r7, 32767",
2159     ));
2160     insns.push((
2161         Inst::CmpTrapRSImm16 {
2162             op: CmpOp::CmpS64,
2163             rn: gpr(7),
2164             imm: -32768,
2165             cond: Cond::from_mask(8),
2166             trap_code: TrapCode::STACK_OVERFLOW,
2167         },
2168         "EC7080008070",
2169         "cgite %r7, -32768",
2170     ));
2171     insns.push((
2172         Inst::CmpTrapRSImm16 {
2173             op: CmpOp::CmpS64,
2174             rn: gpr(7),
2175             imm: 32767,
2176             cond: Cond::from_mask(8),
2177             trap_code: TrapCode::STACK_OVERFLOW,
2178         },
2179         "EC707FFF8070",
2180         "cgite %r7, 32767",
2181     ));
2182     insns.push((
2183         Inst::CmpTrapRUImm16 {
2184             op: CmpOp::CmpL32,
2185             rn: gpr(7),
2186             imm: 0,
2187             cond: Cond::from_mask(8),
2188             trap_code: TrapCode::STACK_OVERFLOW,
2189         },
2190         "EC7000008073",
2191         "clfite %r7, 0",
2192     ));
2193     insns.push((
2194         Inst::CmpTrapRUImm16 {
2195             op: CmpOp::CmpL32,
2196             rn: gpr(7),
2197             imm: 65535,
2198             cond: Cond::from_mask(8),
2199             trap_code: TrapCode::STACK_OVERFLOW,
2200         },
2201         "EC70FFFF8073",
2202         "clfite %r7, 65535",
2203     ));
2204     insns.push((
2205         Inst::CmpTrapRUImm16 {
2206             op: CmpOp::CmpL64,
2207             rn: gpr(7),
2208             imm: 0,
2209             cond: Cond::from_mask(8),
2210             trap_code: TrapCode::STACK_OVERFLOW,
2211         },
2212         "EC7000008071",
2213         "clgite %r7, 0",
2214     ));
2215     insns.push((
2216         Inst::CmpTrapRUImm16 {
2217             op: CmpOp::CmpL64,
2218             rn: gpr(7),
2219             imm: 65535,
2220             cond: Cond::from_mask(8),
2221             trap_code: TrapCode::STACK_OVERFLOW,
2222         },
2223         "EC70FFFF8071",
2224         "clgite %r7, 65535",
2225     ));
2226 
2227     let w_regpair = WritableRegPair {
2228         hi: writable_gpr(2),
2229         lo: writable_gpr(3),
2230     };
2231     let regpair = RegPair {
2232         hi: gpr(2),
2233         lo: gpr(3),
2234     };
2235 
2236     insns.push((
2237         Inst::SMulWide {
2238             rd: w_regpair,
2239             rn: gpr(5),
2240             rm: gpr(6),
2241         },
2242         "B9EC6025",
2243         "mgrk %r2, %r5, %r6",
2244     ));
2245     insns.push((
2246         Inst::UMulWide {
2247             rd: w_regpair,
2248             ri: gpr(3),
2249             rn: gpr(5),
2250         },
2251         "B9860025",
2252         "mlgr %r2, %r5",
2253     ));
2254     insns.push((
2255         Inst::SDivMod32 {
2256             rd: w_regpair,
2257             ri: gpr(3),
2258             rn: gpr(5),
2259         },
2260         "B91D0025",
2261         "dsgfr %r2, %r5",
2262     ));
2263     insns.push((
2264         Inst::SDivMod64 {
2265             rd: w_regpair,
2266             ri: gpr(3),
2267             rn: gpr(5),
2268         },
2269         "B90D0025",
2270         "dsgr %r2, %r5",
2271     ));
2272     insns.push((
2273         Inst::UDivMod32 {
2274             rd: w_regpair,
2275             ri: regpair,
2276             rn: gpr(5),
2277         },
2278         "B9970025",
2279         "dlr %r2, %r5",
2280     ));
2281     insns.push((
2282         Inst::UDivMod64 {
2283             rd: w_regpair,
2284             ri: regpair,
2285             rn: gpr(5),
2286         },
2287         "B9870025",
2288         "dlgr %r2, %r5",
2289     ));
2290 
2291     insns.push((
2292         Inst::Flogr {
2293             rd: w_regpair,
2294             rn: gpr(5),
2295         },
2296         "B9830025",
2297         "flogr %r2, %r5",
2298     ));
2299 
2300     insns.push((
2301         Inst::ShiftRR {
2302             shift_op: ShiftOp::RotL32,
2303             rd: writable_gpr(4),
2304             rn: gpr(5),
2305             shift_imm: 0,
2306             shift_reg: zero_reg(),
2307         },
2308         "EB450000001D",
2309         "rll %r4, %r5, 0",
2310     ));
2311     insns.push((
2312         Inst::ShiftRR {
2313             shift_op: ShiftOp::RotL32,
2314             rd: writable_gpr(4),
2315             rn: gpr(5),
2316             shift_imm: 63,
2317             shift_reg: zero_reg(),
2318         },
2319         "EB45003F001D",
2320         "rll %r4, %r5, 63",
2321     ));
2322     insns.push((
2323         Inst::ShiftRR {
2324             shift_op: ShiftOp::RotL32,
2325             rd: writable_gpr(4),
2326             rn: gpr(5),
2327             shift_imm: 0,
2328             shift_reg: gpr(6),
2329         },
2330         "EB456000001D",
2331         "rll %r4, %r5, 0(%r6)",
2332     ));
2333     insns.push((
2334         Inst::ShiftRR {
2335             shift_op: ShiftOp::RotL32,
2336             rd: writable_gpr(4),
2337             rn: gpr(5),
2338             shift_imm: 63,
2339             shift_reg: gpr(6),
2340         },
2341         "EB45603F001D",
2342         "rll %r4, %r5, 63(%r6)",
2343     ));
2344     insns.push((
2345         Inst::ShiftRR {
2346             shift_op: ShiftOp::RotL64,
2347             rd: writable_gpr(4),
2348             rn: gpr(5),
2349             shift_imm: 0,
2350             shift_reg: zero_reg(),
2351         },
2352         "EB450000001C",
2353         "rllg %r4, %r5, 0",
2354     ));
2355     insns.push((
2356         Inst::ShiftRR {
2357             shift_op: ShiftOp::RotL64,
2358             rd: writable_gpr(4),
2359             rn: gpr(5),
2360             shift_imm: 63,
2361             shift_reg: zero_reg(),
2362         },
2363         "EB45003F001C",
2364         "rllg %r4, %r5, 63",
2365     ));
2366     insns.push((
2367         Inst::ShiftRR {
2368             shift_op: ShiftOp::RotL64,
2369             rd: writable_gpr(4),
2370             rn: gpr(5),
2371             shift_imm: 0,
2372             shift_reg: gpr(6),
2373         },
2374         "EB456000001C",
2375         "rllg %r4, %r5, 0(%r6)",
2376     ));
2377     insns.push((
2378         Inst::ShiftRR {
2379             shift_op: ShiftOp::RotL64,
2380             rd: writable_gpr(4),
2381             rn: gpr(5),
2382             shift_imm: 63,
2383             shift_reg: gpr(6),
2384         },
2385         "EB45603F001C",
2386         "rllg %r4, %r5, 63(%r6)",
2387     ));
2388     insns.push((
2389         Inst::ShiftRR {
2390             shift_op: ShiftOp::LShL32,
2391             rd: writable_gpr(4),
2392             rn: gpr(5),
2393             shift_imm: 0,
2394             shift_reg: zero_reg(),
2395         },
2396         "EB45000000DF",
2397         "sllk %r4, %r5, 0",
2398     ));
2399     insns.push((
2400         Inst::ShiftRR {
2401             shift_op: ShiftOp::LShL32,
2402             rd: writable_gpr(4),
2403             rn: gpr(5),
2404             shift_imm: 63,
2405             shift_reg: zero_reg(),
2406         },
2407         "EB45003F00DF",
2408         "sllk %r4, %r5, 63",
2409     ));
2410     insns.push((
2411         Inst::ShiftRR {
2412             shift_op: ShiftOp::LShL32,
2413             rd: writable_gpr(4),
2414             rn: gpr(5),
2415             shift_imm: 0,
2416             shift_reg: gpr(6),
2417         },
2418         "EB45600000DF",
2419         "sllk %r4, %r5, 0(%r6)",
2420     ));
2421     insns.push((
2422         Inst::ShiftRR {
2423             shift_op: ShiftOp::LShL32,
2424             rd: writable_gpr(4),
2425             rn: gpr(5),
2426             shift_imm: 63,
2427             shift_reg: gpr(6),
2428         },
2429         "EB45603F00DF",
2430         "sllk %r4, %r5, 63(%r6)",
2431     ));
2432     insns.push((
2433         Inst::ShiftRR {
2434             shift_op: ShiftOp::LShL64,
2435             rd: writable_gpr(4),
2436             rn: gpr(5),
2437             shift_imm: 0,
2438             shift_reg: zero_reg(),
2439         },
2440         "EB450000000D",
2441         "sllg %r4, %r5, 0",
2442     ));
2443     insns.push((
2444         Inst::ShiftRR {
2445             shift_op: ShiftOp::LShL64,
2446             rd: writable_gpr(4),
2447             rn: gpr(5),
2448             shift_imm: 63,
2449             shift_reg: zero_reg(),
2450         },
2451         "EB45003F000D",
2452         "sllg %r4, %r5, 63",
2453     ));
2454     insns.push((
2455         Inst::ShiftRR {
2456             shift_op: ShiftOp::LShL64,
2457             rd: writable_gpr(4),
2458             rn: gpr(5),
2459             shift_imm: 0,
2460             shift_reg: gpr(6),
2461         },
2462         "EB456000000D",
2463         "sllg %r4, %r5, 0(%r6)",
2464     ));
2465     insns.push((
2466         Inst::ShiftRR {
2467             shift_op: ShiftOp::LShL64,
2468             rd: writable_gpr(4),
2469             rn: gpr(5),
2470             shift_imm: 63,
2471             shift_reg: gpr(6),
2472         },
2473         "EB45603F000D",
2474         "sllg %r4, %r5, 63(%r6)",
2475     ));
2476     insns.push((
2477         Inst::ShiftRR {
2478             shift_op: ShiftOp::LShR32,
2479             rd: writable_gpr(4),
2480             rn: gpr(5),
2481             shift_imm: 0,
2482             shift_reg: zero_reg(),
2483         },
2484         "EB45000000DE",
2485         "srlk %r4, %r5, 0",
2486     ));
2487     insns.push((
2488         Inst::ShiftRR {
2489             shift_op: ShiftOp::LShR32,
2490             rd: writable_gpr(4),
2491             rn: gpr(5),
2492             shift_imm: 63,
2493             shift_reg: zero_reg(),
2494         },
2495         "EB45003F00DE",
2496         "srlk %r4, %r5, 63",
2497     ));
2498     insns.push((
2499         Inst::ShiftRR {
2500             shift_op: ShiftOp::LShR32,
2501             rd: writable_gpr(4),
2502             rn: gpr(5),
2503             shift_imm: 0,
2504             shift_reg: gpr(6),
2505         },
2506         "EB45600000DE",
2507         "srlk %r4, %r5, 0(%r6)",
2508     ));
2509     insns.push((
2510         Inst::ShiftRR {
2511             shift_op: ShiftOp::LShR32,
2512             rd: writable_gpr(4),
2513             rn: gpr(5),
2514             shift_imm: 63,
2515             shift_reg: gpr(6),
2516         },
2517         "EB45603F00DE",
2518         "srlk %r4, %r5, 63(%r6)",
2519     ));
2520     insns.push((
2521         Inst::ShiftRR {
2522             shift_op: ShiftOp::LShR64,
2523             rd: writable_gpr(4),
2524             rn: gpr(5),
2525             shift_imm: 0,
2526             shift_reg: zero_reg(),
2527         },
2528         "EB450000000C",
2529         "srlg %r4, %r5, 0",
2530     ));
2531     insns.push((
2532         Inst::ShiftRR {
2533             shift_op: ShiftOp::LShR64,
2534             rd: writable_gpr(4),
2535             rn: gpr(5),
2536             shift_imm: 63,
2537             shift_reg: zero_reg(),
2538         },
2539         "EB45003F000C",
2540         "srlg %r4, %r5, 63",
2541     ));
2542     insns.push((
2543         Inst::ShiftRR {
2544             shift_op: ShiftOp::LShR64,
2545             rd: writable_gpr(4),
2546             rn: gpr(5),
2547             shift_imm: 0,
2548             shift_reg: gpr(6),
2549         },
2550         "EB456000000C",
2551         "srlg %r4, %r5, 0(%r6)",
2552     ));
2553     insns.push((
2554         Inst::ShiftRR {
2555             shift_op: ShiftOp::LShR64,
2556             rd: writable_gpr(4),
2557             rn: gpr(5),
2558             shift_imm: 63,
2559             shift_reg: gpr(6),
2560         },
2561         "EB45603F000C",
2562         "srlg %r4, %r5, 63(%r6)",
2563     ));
2564     insns.push((
2565         Inst::ShiftRR {
2566             shift_op: ShiftOp::AShR32,
2567             rd: writable_gpr(4),
2568             rn: gpr(5),
2569             shift_imm: 0,
2570             shift_reg: zero_reg(),
2571         },
2572         "EB45000000DC",
2573         "srak %r4, %r5, 0",
2574     ));
2575     insns.push((
2576         Inst::ShiftRR {
2577             shift_op: ShiftOp::AShR32,
2578             rd: writable_gpr(4),
2579             rn: gpr(5),
2580             shift_imm: 63,
2581             shift_reg: zero_reg(),
2582         },
2583         "EB45003F00DC",
2584         "srak %r4, %r5, 63",
2585     ));
2586     insns.push((
2587         Inst::ShiftRR {
2588             shift_op: ShiftOp::AShR32,
2589             rd: writable_gpr(4),
2590             rn: gpr(5),
2591             shift_imm: 0,
2592             shift_reg: gpr(6),
2593         },
2594         "EB45600000DC",
2595         "srak %r4, %r5, 0(%r6)",
2596     ));
2597     insns.push((
2598         Inst::ShiftRR {
2599             shift_op: ShiftOp::AShR32,
2600             rd: writable_gpr(4),
2601             rn: gpr(5),
2602             shift_imm: 63,
2603             shift_reg: gpr(6),
2604         },
2605         "EB45603F00DC",
2606         "srak %r4, %r5, 63(%r6)",
2607     ));
2608     insns.push((
2609         Inst::ShiftRR {
2610             shift_op: ShiftOp::AShR64,
2611             rd: writable_gpr(4),
2612             rn: gpr(5),
2613             shift_imm: 0,
2614             shift_reg: zero_reg(),
2615         },
2616         "EB450000000A",
2617         "srag %r4, %r5, 0",
2618     ));
2619     insns.push((
2620         Inst::ShiftRR {
2621             shift_op: ShiftOp::AShR64,
2622             rd: writable_gpr(4),
2623             rn: gpr(5),
2624             shift_imm: 63,
2625             shift_reg: zero_reg(),
2626         },
2627         "EB45003F000A",
2628         "srag %r4, %r5, 63",
2629     ));
2630     insns.push((
2631         Inst::ShiftRR {
2632             shift_op: ShiftOp::AShR64,
2633             rd: writable_gpr(4),
2634             rn: gpr(5),
2635             shift_imm: 0,
2636             shift_reg: gpr(6),
2637         },
2638         "EB456000000A",
2639         "srag %r4, %r5, 0(%r6)",
2640     ));
2641     insns.push((
2642         Inst::ShiftRR {
2643             shift_op: ShiftOp::AShR64,
2644             rd: writable_gpr(4),
2645             rn: gpr(5),
2646             shift_imm: 63,
2647             shift_reg: gpr(6),
2648         },
2649         "EB45603F000A",
2650         "srag %r4, %r5, 63(%r6)",
2651     ));
2652 
2653     insns.push((
2654         Inst::RxSBG {
2655             op: RxSBGOp::Insert,
2656             rd: writable_gpr(4),
2657             ri: gpr(4),
2658             rn: gpr(5),
2659             start_bit: 8,
2660             end_bit: 32,
2661             rotate_amt: -16,
2662         },
2663         "EC4508203059",
2664         "risbgn %r4, %r5, 8, 32, 48",
2665     ));
2666     insns.push((
2667         Inst::RxSBG {
2668             op: RxSBGOp::And,
2669             rd: writable_gpr(4),
2670             ri: gpr(4),
2671             rn: gpr(5),
2672             start_bit: 8,
2673             end_bit: 32,
2674             rotate_amt: 63,
2675         },
2676         "EC4508203F54",
2677         "rnsbg %r4, %r5, 8, 32, 63",
2678     ));
2679     insns.push((
2680         Inst::RxSBG {
2681             op: RxSBGOp::Or,
2682             rd: writable_gpr(4),
2683             ri: gpr(4),
2684             rn: gpr(5),
2685             start_bit: 8,
2686             end_bit: 32,
2687             rotate_amt: 63,
2688         },
2689         "EC4508203F56",
2690         "rosbg %r4, %r5, 8, 32, 63",
2691     ));
2692     insns.push((
2693         Inst::RxSBG {
2694             op: RxSBGOp::Xor,
2695             rd: writable_gpr(4),
2696             ri: gpr(4),
2697             rn: gpr(5),
2698             start_bit: 8,
2699             end_bit: 32,
2700             rotate_amt: 63,
2701         },
2702         "EC4508203F57",
2703         "rxsbg %r4, %r5, 8, 32, 63",
2704     ));
2705     insns.push((
2706         Inst::RxSBGTest {
2707             op: RxSBGOp::And,
2708             rd: gpr(4),
2709             rn: gpr(5),
2710             start_bit: 8,
2711             end_bit: 32,
2712             rotate_amt: 63,
2713         },
2714         "EC4588203F54",
2715         "rnsbg %r4, %r5, 136, 32, 63",
2716     ));
2717     insns.push((
2718         Inst::RxSBGTest {
2719             op: RxSBGOp::Or,
2720             rd: gpr(4),
2721             rn: gpr(5),
2722             start_bit: 8,
2723             end_bit: 32,
2724             rotate_amt: 63,
2725         },
2726         "EC4588203F56",
2727         "rosbg %r4, %r5, 136, 32, 63",
2728     ));
2729     insns.push((
2730         Inst::RxSBGTest {
2731             op: RxSBGOp::Xor,
2732             rd: gpr(4),
2733             rn: gpr(5),
2734             start_bit: 8,
2735             end_bit: 32,
2736             rotate_amt: 63,
2737         },
2738         "EC4588203F57",
2739         "rxsbg %r4, %r5, 136, 32, 63",
2740     ));
2741 
2742     insns.push((
2743         Inst::AtomicRmw {
2744             alu_op: ALUOp::Add32,
2745             rd: writable_gpr(4),
2746             rn: gpr(5),
2747             mem: MemArg::BXD20 {
2748                 base: zero_reg(),
2749                 index: zero_reg(),
2750                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2751                 flags: MemFlags::trusted(),
2752             },
2753         },
2754         "EB45000080F8",
2755         "laa %r4, %r5, -524288",
2756     ));
2757     insns.push((
2758         Inst::AtomicRmw {
2759             alu_op: ALUOp::Add32,
2760             rd: writable_gpr(4),
2761             rn: gpr(5),
2762             mem: MemArg::BXD20 {
2763                 base: zero_reg(),
2764                 index: zero_reg(),
2765                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2766                 flags: MemFlags::trusted(),
2767             },
2768         },
2769         "EB450FFF7FF8",
2770         "laa %r4, %r5, 524287",
2771     ));
2772     insns.push((
2773         Inst::AtomicRmw {
2774             alu_op: ALUOp::Add32,
2775             rd: writable_gpr(4),
2776             rn: gpr(5),
2777             mem: MemArg::BXD20 {
2778                 base: gpr(6),
2779                 index: zero_reg(),
2780                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2781                 flags: MemFlags::trusted(),
2782             },
2783         },
2784         "EB45600080F8",
2785         "laa %r4, %r5, -524288(%r6)",
2786     ));
2787     insns.push((
2788         Inst::AtomicRmw {
2789             alu_op: ALUOp::Add32,
2790             rd: writable_gpr(4),
2791             rn: gpr(5),
2792             mem: MemArg::BXD20 {
2793                 base: gpr(6),
2794                 index: zero_reg(),
2795                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2796                 flags: MemFlags::trusted(),
2797             },
2798         },
2799         "EB456FFF7FF8",
2800         "laa %r4, %r5, 524287(%r6)",
2801     ));
2802     insns.push((
2803         Inst::AtomicRmw {
2804             alu_op: ALUOp::Add64,
2805             rd: writable_gpr(4),
2806             rn: gpr(5),
2807             mem: MemArg::BXD20 {
2808                 base: zero_reg(),
2809                 index: zero_reg(),
2810                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2811                 flags: MemFlags::trusted(),
2812             },
2813         },
2814         "EB45000080E8",
2815         "laag %r4, %r5, -524288",
2816     ));
2817     insns.push((
2818         Inst::AtomicRmw {
2819             alu_op: ALUOp::Add64,
2820             rd: writable_gpr(4),
2821             rn: gpr(5),
2822             mem: MemArg::BXD20 {
2823                 base: zero_reg(),
2824                 index: zero_reg(),
2825                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2826                 flags: MemFlags::trusted(),
2827             },
2828         },
2829         "EB450FFF7FE8",
2830         "laag %r4, %r5, 524287",
2831     ));
2832     insns.push((
2833         Inst::AtomicRmw {
2834             alu_op: ALUOp::Add64,
2835             rd: writable_gpr(4),
2836             rn: gpr(5),
2837             mem: MemArg::BXD20 {
2838                 base: gpr(6),
2839                 index: zero_reg(),
2840                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2841                 flags: MemFlags::trusted(),
2842             },
2843         },
2844         "EB45600080E8",
2845         "laag %r4, %r5, -524288(%r6)",
2846     ));
2847     insns.push((
2848         Inst::AtomicRmw {
2849             alu_op: ALUOp::Add64,
2850             rd: writable_gpr(4),
2851             rn: gpr(5),
2852             mem: MemArg::BXD20 {
2853                 base: gpr(6),
2854                 index: zero_reg(),
2855                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2856                 flags: MemFlags::trusted(),
2857             },
2858         },
2859         "EB456FFF7FE8",
2860         "laag %r4, %r5, 524287(%r6)",
2861     ));
2862     insns.push((
2863         Inst::AtomicRmw {
2864             alu_op: ALUOp::AddLogical32,
2865             rd: writable_gpr(4),
2866             rn: gpr(5),
2867             mem: MemArg::BXD20 {
2868                 base: zero_reg(),
2869                 index: zero_reg(),
2870                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2871                 flags: MemFlags::trusted(),
2872             },
2873         },
2874         "EB45000080FA",
2875         "laal %r4, %r5, -524288",
2876     ));
2877     insns.push((
2878         Inst::AtomicRmw {
2879             alu_op: ALUOp::AddLogical32,
2880             rd: writable_gpr(4),
2881             rn: gpr(5),
2882             mem: MemArg::BXD20 {
2883                 base: zero_reg(),
2884                 index: zero_reg(),
2885                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2886                 flags: MemFlags::trusted(),
2887             },
2888         },
2889         "EB450FFF7FFA",
2890         "laal %r4, %r5, 524287",
2891     ));
2892     insns.push((
2893         Inst::AtomicRmw {
2894             alu_op: ALUOp::AddLogical32,
2895             rd: writable_gpr(4),
2896             rn: gpr(5),
2897             mem: MemArg::BXD20 {
2898                 base: gpr(6),
2899                 index: zero_reg(),
2900                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2901                 flags: MemFlags::trusted(),
2902             },
2903         },
2904         "EB45600080FA",
2905         "laal %r4, %r5, -524288(%r6)",
2906     ));
2907     insns.push((
2908         Inst::AtomicRmw {
2909             alu_op: ALUOp::AddLogical32,
2910             rd: writable_gpr(4),
2911             rn: gpr(5),
2912             mem: MemArg::BXD20 {
2913                 base: gpr(6),
2914                 index: zero_reg(),
2915                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2916                 flags: MemFlags::trusted(),
2917             },
2918         },
2919         "EB456FFF7FFA",
2920         "laal %r4, %r5, 524287(%r6)",
2921     ));
2922     insns.push((
2923         Inst::AtomicRmw {
2924             alu_op: ALUOp::AddLogical64,
2925             rd: writable_gpr(4),
2926             rn: gpr(5),
2927             mem: MemArg::BXD20 {
2928                 base: zero_reg(),
2929                 index: zero_reg(),
2930                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2931                 flags: MemFlags::trusted(),
2932             },
2933         },
2934         "EB45000080EA",
2935         "laalg %r4, %r5, -524288",
2936     ));
2937     insns.push((
2938         Inst::AtomicRmw {
2939             alu_op: ALUOp::AddLogical64,
2940             rd: writable_gpr(4),
2941             rn: gpr(5),
2942             mem: MemArg::BXD20 {
2943                 base: zero_reg(),
2944                 index: zero_reg(),
2945                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2946                 flags: MemFlags::trusted(),
2947             },
2948         },
2949         "EB450FFF7FEA",
2950         "laalg %r4, %r5, 524287",
2951     ));
2952     insns.push((
2953         Inst::AtomicRmw {
2954             alu_op: ALUOp::AddLogical64,
2955             rd: writable_gpr(4),
2956             rn: gpr(5),
2957             mem: MemArg::BXD20 {
2958                 base: gpr(6),
2959                 index: zero_reg(),
2960                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2961                 flags: MemFlags::trusted(),
2962             },
2963         },
2964         "EB45600080EA",
2965         "laalg %r4, %r5, -524288(%r6)",
2966     ));
2967     insns.push((
2968         Inst::AtomicRmw {
2969             alu_op: ALUOp::AddLogical64,
2970             rd: writable_gpr(4),
2971             rn: gpr(5),
2972             mem: MemArg::BXD20 {
2973                 base: gpr(6),
2974                 index: zero_reg(),
2975                 disp: SImm20::maybe_from_i64(524287).unwrap(),
2976                 flags: MemFlags::trusted(),
2977             },
2978         },
2979         "EB456FFF7FEA",
2980         "laalg %r4, %r5, 524287(%r6)",
2981     ));
2982     insns.push((
2983         Inst::AtomicRmw {
2984             alu_op: ALUOp::And32,
2985             rd: writable_gpr(4),
2986             rn: gpr(5),
2987             mem: MemArg::BXD20 {
2988                 base: zero_reg(),
2989                 index: zero_reg(),
2990                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
2991                 flags: MemFlags::trusted(),
2992             },
2993         },
2994         "EB45000080F4",
2995         "lan %r4, %r5, -524288",
2996     ));
2997     insns.push((
2998         Inst::AtomicRmw {
2999             alu_op: ALUOp::And32,
3000             rd: writable_gpr(4),
3001             rn: gpr(5),
3002             mem: MemArg::BXD20 {
3003                 base: zero_reg(),
3004                 index: zero_reg(),
3005                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3006                 flags: MemFlags::trusted(),
3007             },
3008         },
3009         "EB450FFF7FF4",
3010         "lan %r4, %r5, 524287",
3011     ));
3012     insns.push((
3013         Inst::AtomicRmw {
3014             alu_op: ALUOp::And32,
3015             rd: writable_gpr(4),
3016             rn: gpr(5),
3017             mem: MemArg::BXD20 {
3018                 base: gpr(6),
3019                 index: zero_reg(),
3020                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3021                 flags: MemFlags::trusted(),
3022             },
3023         },
3024         "EB45600080F4",
3025         "lan %r4, %r5, -524288(%r6)",
3026     ));
3027     insns.push((
3028         Inst::AtomicRmw {
3029             alu_op: ALUOp::And32,
3030             rd: writable_gpr(4),
3031             rn: gpr(5),
3032             mem: MemArg::BXD20 {
3033                 base: gpr(6),
3034                 index: zero_reg(),
3035                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3036                 flags: MemFlags::trusted(),
3037             },
3038         },
3039         "EB456FFF7FF4",
3040         "lan %r4, %r5, 524287(%r6)",
3041     ));
3042     insns.push((
3043         Inst::AtomicRmw {
3044             alu_op: ALUOp::And64,
3045             rd: writable_gpr(4),
3046             rn: gpr(5),
3047             mem: MemArg::BXD20 {
3048                 base: zero_reg(),
3049                 index: zero_reg(),
3050                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3051                 flags: MemFlags::trusted(),
3052             },
3053         },
3054         "EB45000080E4",
3055         "lang %r4, %r5, -524288",
3056     ));
3057     insns.push((
3058         Inst::AtomicRmw {
3059             alu_op: ALUOp::And64,
3060             rd: writable_gpr(4),
3061             rn: gpr(5),
3062             mem: MemArg::BXD20 {
3063                 base: zero_reg(),
3064                 index: zero_reg(),
3065                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3066                 flags: MemFlags::trusted(),
3067             },
3068         },
3069         "EB450FFF7FE4",
3070         "lang %r4, %r5, 524287",
3071     ));
3072     insns.push((
3073         Inst::AtomicRmw {
3074             alu_op: ALUOp::And64,
3075             rd: writable_gpr(4),
3076             rn: gpr(5),
3077             mem: MemArg::BXD20 {
3078                 base: gpr(6),
3079                 index: zero_reg(),
3080                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3081                 flags: MemFlags::trusted(),
3082             },
3083         },
3084         "EB45600080E4",
3085         "lang %r4, %r5, -524288(%r6)",
3086     ));
3087     insns.push((
3088         Inst::AtomicRmw {
3089             alu_op: ALUOp::And64,
3090             rd: writable_gpr(4),
3091             rn: gpr(5),
3092             mem: MemArg::BXD20 {
3093                 base: gpr(6),
3094                 index: zero_reg(),
3095                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3096                 flags: MemFlags::trusted(),
3097             },
3098         },
3099         "EB456FFF7FE4",
3100         "lang %r4, %r5, 524287(%r6)",
3101     ));
3102     insns.push((
3103         Inst::AtomicRmw {
3104             alu_op: ALUOp::Orr32,
3105             rd: writable_gpr(4),
3106             rn: gpr(5),
3107             mem: MemArg::BXD20 {
3108                 base: zero_reg(),
3109                 index: zero_reg(),
3110                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3111                 flags: MemFlags::trusted(),
3112             },
3113         },
3114         "EB45000080F6",
3115         "lao %r4, %r5, -524288",
3116     ));
3117     insns.push((
3118         Inst::AtomicRmw {
3119             alu_op: ALUOp::Orr32,
3120             rd: writable_gpr(4),
3121             rn: gpr(5),
3122             mem: MemArg::BXD20 {
3123                 base: zero_reg(),
3124                 index: zero_reg(),
3125                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3126                 flags: MemFlags::trusted(),
3127             },
3128         },
3129         "EB450FFF7FF6",
3130         "lao %r4, %r5, 524287",
3131     ));
3132     insns.push((
3133         Inst::AtomicRmw {
3134             alu_op: ALUOp::Orr32,
3135             rd: writable_gpr(4),
3136             rn: gpr(5),
3137             mem: MemArg::BXD20 {
3138                 base: gpr(6),
3139                 index: zero_reg(),
3140                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3141                 flags: MemFlags::trusted(),
3142             },
3143         },
3144         "EB45600080F6",
3145         "lao %r4, %r5, -524288(%r6)",
3146     ));
3147     insns.push((
3148         Inst::AtomicRmw {
3149             alu_op: ALUOp::Orr32,
3150             rd: writable_gpr(4),
3151             rn: gpr(5),
3152             mem: MemArg::BXD20 {
3153                 base: gpr(6),
3154                 index: zero_reg(),
3155                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3156                 flags: MemFlags::trusted(),
3157             },
3158         },
3159         "EB456FFF7FF6",
3160         "lao %r4, %r5, 524287(%r6)",
3161     ));
3162     insns.push((
3163         Inst::AtomicRmw {
3164             alu_op: ALUOp::Orr64,
3165             rd: writable_gpr(4),
3166             rn: gpr(5),
3167             mem: MemArg::BXD20 {
3168                 base: zero_reg(),
3169                 index: zero_reg(),
3170                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3171                 flags: MemFlags::trusted(),
3172             },
3173         },
3174         "EB45000080E6",
3175         "laog %r4, %r5, -524288",
3176     ));
3177     insns.push((
3178         Inst::AtomicRmw {
3179             alu_op: ALUOp::Orr64,
3180             rd: writable_gpr(4),
3181             rn: gpr(5),
3182             mem: MemArg::BXD20 {
3183                 base: zero_reg(),
3184                 index: zero_reg(),
3185                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3186                 flags: MemFlags::trusted(),
3187             },
3188         },
3189         "EB450FFF7FE6",
3190         "laog %r4, %r5, 524287",
3191     ));
3192     insns.push((
3193         Inst::AtomicRmw {
3194             alu_op: ALUOp::Orr64,
3195             rd: writable_gpr(4),
3196             rn: gpr(5),
3197             mem: MemArg::BXD20 {
3198                 base: gpr(6),
3199                 index: zero_reg(),
3200                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3201                 flags: MemFlags::trusted(),
3202             },
3203         },
3204         "EB45600080E6",
3205         "laog %r4, %r5, -524288(%r6)",
3206     ));
3207     insns.push((
3208         Inst::AtomicRmw {
3209             alu_op: ALUOp::Orr64,
3210             rd: writable_gpr(4),
3211             rn: gpr(5),
3212             mem: MemArg::BXD20 {
3213                 base: gpr(6),
3214                 index: zero_reg(),
3215                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3216                 flags: MemFlags::trusted(),
3217             },
3218         },
3219         "EB456FFF7FE6",
3220         "laog %r4, %r5, 524287(%r6)",
3221     ));
3222     insns.push((
3223         Inst::AtomicRmw {
3224             alu_op: ALUOp::Xor32,
3225             rd: writable_gpr(4),
3226             rn: gpr(5),
3227             mem: MemArg::BXD20 {
3228                 base: zero_reg(),
3229                 index: zero_reg(),
3230                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3231                 flags: MemFlags::trusted(),
3232             },
3233         },
3234         "EB45000080F7",
3235         "lax %r4, %r5, -524288",
3236     ));
3237     insns.push((
3238         Inst::AtomicRmw {
3239             alu_op: ALUOp::Xor32,
3240             rd: writable_gpr(4),
3241             rn: gpr(5),
3242             mem: MemArg::BXD20 {
3243                 base: zero_reg(),
3244                 index: zero_reg(),
3245                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3246                 flags: MemFlags::trusted(),
3247             },
3248         },
3249         "EB450FFF7FF7",
3250         "lax %r4, %r5, 524287",
3251     ));
3252     insns.push((
3253         Inst::AtomicRmw {
3254             alu_op: ALUOp::Xor32,
3255             rd: writable_gpr(4),
3256             rn: gpr(5),
3257             mem: MemArg::BXD20 {
3258                 base: gpr(6),
3259                 index: zero_reg(),
3260                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3261                 flags: MemFlags::trusted(),
3262             },
3263         },
3264         "EB45600080F7",
3265         "lax %r4, %r5, -524288(%r6)",
3266     ));
3267     insns.push((
3268         Inst::AtomicRmw {
3269             alu_op: ALUOp::Xor32,
3270             rd: writable_gpr(4),
3271             rn: gpr(5),
3272             mem: MemArg::BXD20 {
3273                 base: gpr(6),
3274                 index: zero_reg(),
3275                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3276                 flags: MemFlags::trusted(),
3277             },
3278         },
3279         "EB456FFF7FF7",
3280         "lax %r4, %r5, 524287(%r6)",
3281     ));
3282     insns.push((
3283         Inst::AtomicRmw {
3284             alu_op: ALUOp::Xor64,
3285             rd: writable_gpr(4),
3286             rn: gpr(5),
3287             mem: MemArg::BXD20 {
3288                 base: zero_reg(),
3289                 index: zero_reg(),
3290                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3291                 flags: MemFlags::trusted(),
3292             },
3293         },
3294         "EB45000080E7",
3295         "laxg %r4, %r5, -524288",
3296     ));
3297     insns.push((
3298         Inst::AtomicRmw {
3299             alu_op: ALUOp::Xor64,
3300             rd: writable_gpr(4),
3301             rn: gpr(5),
3302             mem: MemArg::BXD20 {
3303                 base: zero_reg(),
3304                 index: zero_reg(),
3305                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3306                 flags: MemFlags::trusted(),
3307             },
3308         },
3309         "EB450FFF7FE7",
3310         "laxg %r4, %r5, 524287",
3311     ));
3312     insns.push((
3313         Inst::AtomicRmw {
3314             alu_op: ALUOp::Xor64,
3315             rd: writable_gpr(4),
3316             rn: gpr(5),
3317             mem: MemArg::BXD20 {
3318                 base: gpr(6),
3319                 index: zero_reg(),
3320                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3321                 flags: MemFlags::trusted(),
3322             },
3323         },
3324         "EB45600080E7",
3325         "laxg %r4, %r5, -524288(%r6)",
3326     ));
3327     insns.push((
3328         Inst::AtomicRmw {
3329             alu_op: ALUOp::Xor64,
3330             rd: writable_gpr(4),
3331             rn: gpr(5),
3332             mem: MemArg::BXD20 {
3333                 base: gpr(6),
3334                 index: zero_reg(),
3335                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3336                 flags: MemFlags::trusted(),
3337             },
3338         },
3339         "EB456FFF7FE7",
3340         "laxg %r4, %r5, 524287(%r6)",
3341     ));
3342     insns.push((
3343         Inst::AtomicCas32 {
3344             rd: writable_gpr(4),
3345             ri: gpr(4),
3346             rn: gpr(5),
3347             mem: MemArg::BXD12 {
3348                 base: zero_reg(),
3349                 index: zero_reg(),
3350                 disp: UImm12::maybe_from_u64(0).unwrap(),
3351                 flags: MemFlags::trusted(),
3352             },
3353         },
3354         "BA450000",
3355         "cs %r4, %r5, 0",
3356     ));
3357     insns.push((
3358         Inst::AtomicCas32 {
3359             rd: writable_gpr(4),
3360             ri: gpr(4),
3361             rn: gpr(5),
3362             mem: MemArg::BXD12 {
3363                 base: zero_reg(),
3364                 index: zero_reg(),
3365                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3366                 flags: MemFlags::trusted(),
3367             },
3368         },
3369         "BA450FFF",
3370         "cs %r4, %r5, 4095",
3371     ));
3372     insns.push((
3373         Inst::AtomicCas32 {
3374             rd: writable_gpr(4),
3375             ri: gpr(4),
3376             rn: gpr(5),
3377             mem: MemArg::BXD20 {
3378                 base: zero_reg(),
3379                 index: zero_reg(),
3380                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3381                 flags: MemFlags::trusted(),
3382             },
3383         },
3384         "EB4500008014",
3385         "csy %r4, %r5, -524288",
3386     ));
3387     insns.push((
3388         Inst::AtomicCas32 {
3389             rd: writable_gpr(4),
3390             ri: gpr(4),
3391             rn: gpr(5),
3392             mem: MemArg::BXD20 {
3393                 base: zero_reg(),
3394                 index: zero_reg(),
3395                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3396                 flags: MemFlags::trusted(),
3397             },
3398         },
3399         "EB450FFF7F14",
3400         "csy %r4, %r5, 524287",
3401     ));
3402     insns.push((
3403         Inst::AtomicCas32 {
3404             rd: writable_gpr(4),
3405             ri: gpr(4),
3406             rn: gpr(5),
3407             mem: MemArg::BXD12 {
3408                 base: gpr(6),
3409                 index: zero_reg(),
3410                 disp: UImm12::maybe_from_u64(0).unwrap(),
3411                 flags: MemFlags::trusted(),
3412             },
3413         },
3414         "BA456000",
3415         "cs %r4, %r5, 0(%r6)",
3416     ));
3417     insns.push((
3418         Inst::AtomicCas32 {
3419             rd: writable_gpr(4),
3420             ri: gpr(4),
3421             rn: gpr(5),
3422             mem: MemArg::BXD12 {
3423                 base: gpr(6),
3424                 index: zero_reg(),
3425                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3426                 flags: MemFlags::trusted(),
3427             },
3428         },
3429         "BA456FFF",
3430         "cs %r4, %r5, 4095(%r6)",
3431     ));
3432     insns.push((
3433         Inst::AtomicCas32 {
3434             rd: writable_gpr(4),
3435             ri: gpr(4),
3436             rn: gpr(5),
3437             mem: MemArg::BXD20 {
3438                 base: gpr(6),
3439                 index: zero_reg(),
3440                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3441                 flags: MemFlags::trusted(),
3442             },
3443         },
3444         "EB4560008014",
3445         "csy %r4, %r5, -524288(%r6)",
3446     ));
3447     insns.push((
3448         Inst::AtomicCas32 {
3449             rd: writable_gpr(4),
3450             ri: gpr(4),
3451             rn: gpr(5),
3452             mem: MemArg::BXD20 {
3453                 base: gpr(6),
3454                 index: zero_reg(),
3455                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3456                 flags: MemFlags::trusted(),
3457             },
3458         },
3459         "EB456FFF7F14",
3460         "csy %r4, %r5, 524287(%r6)",
3461     ));
3462     insns.push((
3463         Inst::AtomicCas64 {
3464             rd: writable_gpr(4),
3465             ri: gpr(4),
3466             rn: gpr(5),
3467             mem: MemArg::BXD20 {
3468                 base: zero_reg(),
3469                 index: zero_reg(),
3470                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3471                 flags: MemFlags::trusted(),
3472             },
3473         },
3474         "EB4500008030",
3475         "csg %r4, %r5, -524288",
3476     ));
3477     insns.push((
3478         Inst::AtomicCas64 {
3479             rd: writable_gpr(4),
3480             ri: gpr(4),
3481             rn: gpr(5),
3482             mem: MemArg::BXD20 {
3483                 base: zero_reg(),
3484                 index: zero_reg(),
3485                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3486                 flags: MemFlags::trusted(),
3487             },
3488         },
3489         "EB450FFF7F30",
3490         "csg %r4, %r5, 524287",
3491     ));
3492     insns.push((
3493         Inst::AtomicCas64 {
3494             rd: writable_gpr(4),
3495             ri: gpr(4),
3496             rn: gpr(5),
3497             mem: MemArg::BXD20 {
3498                 base: gpr(6),
3499                 index: zero_reg(),
3500                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3501                 flags: MemFlags::trusted(),
3502             },
3503         },
3504         "EB4560008030",
3505         "csg %r4, %r5, -524288(%r6)",
3506     ));
3507     insns.push((
3508         Inst::AtomicCas64 {
3509             rd: writable_gpr(4),
3510             ri: gpr(4),
3511             rn: gpr(5),
3512             mem: MemArg::BXD20 {
3513                 base: gpr(6),
3514                 index: zero_reg(),
3515                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3516                 flags: MemFlags::trusted(),
3517             },
3518         },
3519         "EB456FFF7F30",
3520         "csg %r4, %r5, 524287(%r6)",
3521     ));
3522     insns.push((Inst::Fence, "07E0", "bcr 14, 0"));
3523 
3524     insns.push((
3525         Inst::Load32 {
3526             rd: writable_gpr(1),
3527             mem: MemArg::BXD12 {
3528                 base: gpr(2),
3529                 index: zero_reg(),
3530                 disp: UImm12::zero(),
3531                 flags: MemFlags::trusted(),
3532             },
3533         },
3534         "58102000",
3535         "l %r1, 0(%r2)",
3536     ));
3537     insns.push((
3538         Inst::Load32 {
3539             rd: writable_gpr(1),
3540             mem: MemArg::BXD12 {
3541                 base: gpr(2),
3542                 index: zero_reg(),
3543                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3544                 flags: MemFlags::trusted(),
3545             },
3546         },
3547         "58102FFF",
3548         "l %r1, 4095(%r2)",
3549     ));
3550     insns.push((
3551         Inst::Load32 {
3552             rd: writable_gpr(1),
3553             mem: MemArg::BXD20 {
3554                 base: gpr(2),
3555                 index: zero_reg(),
3556                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3557                 flags: MemFlags::trusted(),
3558             },
3559         },
3560         "E31020008058",
3561         "ly %r1, -524288(%r2)",
3562     ));
3563     insns.push((
3564         Inst::Load32 {
3565             rd: writable_gpr(1),
3566             mem: MemArg::BXD20 {
3567                 base: gpr(2),
3568                 index: zero_reg(),
3569                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3570                 flags: MemFlags::trusted(),
3571             },
3572         },
3573         "E3102FFF7F58",
3574         "ly %r1, 524287(%r2)",
3575     ));
3576     insns.push((
3577         Inst::Load32 {
3578             rd: writable_gpr(1),
3579             mem: MemArg::BXD12 {
3580                 base: gpr(3),
3581                 index: gpr(2),
3582                 disp: UImm12::zero(),
3583                 flags: MemFlags::trusted(),
3584             },
3585         },
3586         "58123000",
3587         "l %r1, 0(%r2,%r3)",
3588     ));
3589     insns.push((
3590         Inst::Load32 {
3591             rd: writable_gpr(1),
3592             mem: MemArg::BXD12 {
3593                 base: gpr(3),
3594                 index: gpr(2),
3595                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3596                 flags: MemFlags::trusted(),
3597             },
3598         },
3599         "58123FFF",
3600         "l %r1, 4095(%r2,%r3)",
3601     ));
3602     insns.push((
3603         Inst::Load32 {
3604             rd: writable_gpr(1),
3605             mem: MemArg::BXD20 {
3606                 base: gpr(3),
3607                 index: gpr(2),
3608                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3609                 flags: MemFlags::trusted(),
3610             },
3611         },
3612         "E31230008058",
3613         "ly %r1, -524288(%r2,%r3)",
3614     ));
3615     insns.push((
3616         Inst::Load32 {
3617             rd: writable_gpr(1),
3618             mem: MemArg::BXD20 {
3619                 base: gpr(3),
3620                 index: gpr(2),
3621                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3622                 flags: MemFlags::trusted(),
3623             },
3624         },
3625         "E3123FFF7F58",
3626         "ly %r1, 524287(%r2,%r3)",
3627     ));
3628     insns.push((
3629         Inst::Load32ZExt8 {
3630             rd: writable_gpr(1),
3631             mem: MemArg::BXD12 {
3632                 base: gpr(2),
3633                 index: zero_reg(),
3634                 disp: UImm12::zero(),
3635                 flags: MemFlags::trusted(),
3636             },
3637         },
3638         "E31020000094",
3639         "llc %r1, 0(%r2)",
3640     ));
3641     insns.push((
3642         Inst::Load32ZExt8 {
3643             rd: writable_gpr(1),
3644             mem: MemArg::BXD12 {
3645                 base: gpr(2),
3646                 index: zero_reg(),
3647                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3648                 flags: MemFlags::trusted(),
3649             },
3650         },
3651         "E3102FFF0094",
3652         "llc %r1, 4095(%r2)",
3653     ));
3654     insns.push((
3655         Inst::Load32ZExt8 {
3656             rd: writable_gpr(1),
3657             mem: MemArg::BXD20 {
3658                 base: gpr(2),
3659                 index: zero_reg(),
3660                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3661                 flags: MemFlags::trusted(),
3662             },
3663         },
3664         "E31020008094",
3665         "llc %r1, -524288(%r2)",
3666     ));
3667     insns.push((
3668         Inst::Load32ZExt8 {
3669             rd: writable_gpr(1),
3670             mem: MemArg::BXD20 {
3671                 base: gpr(2),
3672                 index: zero_reg(),
3673                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3674                 flags: MemFlags::trusted(),
3675             },
3676         },
3677         "E3102FFF7F94",
3678         "llc %r1, 524287(%r2)",
3679     ));
3680     insns.push((
3681         Inst::Load32ZExt8 {
3682             rd: writable_gpr(1),
3683             mem: MemArg::BXD12 {
3684                 base: gpr(3),
3685                 index: gpr(2),
3686                 disp: UImm12::zero(),
3687                 flags: MemFlags::trusted(),
3688             },
3689         },
3690         "E31230000094",
3691         "llc %r1, 0(%r2,%r3)",
3692     ));
3693     insns.push((
3694         Inst::Load32ZExt8 {
3695             rd: writable_gpr(1),
3696             mem: MemArg::BXD12 {
3697                 base: gpr(3),
3698                 index: gpr(2),
3699                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3700                 flags: MemFlags::trusted(),
3701             },
3702         },
3703         "E3123FFF0094",
3704         "llc %r1, 4095(%r2,%r3)",
3705     ));
3706     insns.push((
3707         Inst::Load32ZExt8 {
3708             rd: writable_gpr(1),
3709             mem: MemArg::BXD20 {
3710                 base: gpr(3),
3711                 index: gpr(2),
3712                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3713                 flags: MemFlags::trusted(),
3714             },
3715         },
3716         "E31230008094",
3717         "llc %r1, -524288(%r2,%r3)",
3718     ));
3719     insns.push((
3720         Inst::Load32ZExt8 {
3721             rd: writable_gpr(1),
3722             mem: MemArg::BXD20 {
3723                 base: gpr(3),
3724                 index: gpr(2),
3725                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3726                 flags: MemFlags::trusted(),
3727             },
3728         },
3729         "E3123FFF7F94",
3730         "llc %r1, 524287(%r2,%r3)",
3731     ));
3732     insns.push((
3733         Inst::Load32SExt8 {
3734             rd: writable_gpr(1),
3735             mem: MemArg::BXD12 {
3736                 base: gpr(2),
3737                 index: zero_reg(),
3738                 disp: UImm12::zero(),
3739                 flags: MemFlags::trusted(),
3740             },
3741         },
3742         "E31020000076",
3743         "lb %r1, 0(%r2)",
3744     ));
3745     insns.push((
3746         Inst::Load32SExt8 {
3747             rd: writable_gpr(1),
3748             mem: MemArg::BXD12 {
3749                 base: gpr(2),
3750                 index: zero_reg(),
3751                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3752                 flags: MemFlags::trusted(),
3753             },
3754         },
3755         "E3102FFF0076",
3756         "lb %r1, 4095(%r2)",
3757     ));
3758     insns.push((
3759         Inst::Load32SExt8 {
3760             rd: writable_gpr(1),
3761             mem: MemArg::BXD20 {
3762                 base: gpr(2),
3763                 index: zero_reg(),
3764                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3765                 flags: MemFlags::trusted(),
3766             },
3767         },
3768         "E31020008076",
3769         "lb %r1, -524288(%r2)",
3770     ));
3771     insns.push((
3772         Inst::Load32SExt8 {
3773             rd: writable_gpr(1),
3774             mem: MemArg::BXD20 {
3775                 base: gpr(2),
3776                 index: zero_reg(),
3777                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3778                 flags: MemFlags::trusted(),
3779             },
3780         },
3781         "E3102FFF7F76",
3782         "lb %r1, 524287(%r2)",
3783     ));
3784     insns.push((
3785         Inst::Load32SExt8 {
3786             rd: writable_gpr(1),
3787             mem: MemArg::BXD12 {
3788                 base: gpr(3),
3789                 index: gpr(2),
3790                 disp: UImm12::zero(),
3791                 flags: MemFlags::trusted(),
3792             },
3793         },
3794         "E31230000076",
3795         "lb %r1, 0(%r2,%r3)",
3796     ));
3797     insns.push((
3798         Inst::Load32SExt8 {
3799             rd: writable_gpr(1),
3800             mem: MemArg::BXD12 {
3801                 base: gpr(3),
3802                 index: gpr(2),
3803                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3804                 flags: MemFlags::trusted(),
3805             },
3806         },
3807         "E3123FFF0076",
3808         "lb %r1, 4095(%r2,%r3)",
3809     ));
3810     insns.push((
3811         Inst::Load32SExt8 {
3812             rd: writable_gpr(1),
3813             mem: MemArg::BXD20 {
3814                 base: gpr(3),
3815                 index: gpr(2),
3816                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3817                 flags: MemFlags::trusted(),
3818             },
3819         },
3820         "E31230008076",
3821         "lb %r1, -524288(%r2,%r3)",
3822     ));
3823     insns.push((
3824         Inst::Load32SExt8 {
3825             rd: writable_gpr(1),
3826             mem: MemArg::BXD20 {
3827                 base: gpr(3),
3828                 index: gpr(2),
3829                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3830                 flags: MemFlags::trusted(),
3831             },
3832         },
3833         "E3123FFF7F76",
3834         "lb %r1, 524287(%r2,%r3)",
3835     ));
3836     insns.push((
3837         Inst::Load32ZExt16 {
3838             rd: writable_gpr(1),
3839             mem: MemArg::BXD12 {
3840                 base: gpr(2),
3841                 index: zero_reg(),
3842                 disp: UImm12::zero(),
3843                 flags: MemFlags::trusted(),
3844             },
3845         },
3846         "E31020000095",
3847         "llh %r1, 0(%r2)",
3848     ));
3849     insns.push((
3850         Inst::Load32ZExt16 {
3851             rd: writable_gpr(1),
3852             mem: MemArg::BXD12 {
3853                 base: gpr(2),
3854                 index: zero_reg(),
3855                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3856                 flags: MemFlags::trusted(),
3857             },
3858         },
3859         "E3102FFF0095",
3860         "llh %r1, 4095(%r2)",
3861     ));
3862     insns.push((
3863         Inst::Load32ZExt16 {
3864             rd: writable_gpr(1),
3865             mem: MemArg::BXD20 {
3866                 base: gpr(2),
3867                 index: zero_reg(),
3868                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3869                 flags: MemFlags::trusted(),
3870             },
3871         },
3872         "E31020008095",
3873         "llh %r1, -524288(%r2)",
3874     ));
3875     insns.push((
3876         Inst::Load32ZExt16 {
3877             rd: writable_gpr(1),
3878             mem: MemArg::BXD20 {
3879                 base: gpr(2),
3880                 index: zero_reg(),
3881                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3882                 flags: MemFlags::trusted(),
3883             },
3884         },
3885         "E3102FFF7F95",
3886         "llh %r1, 524287(%r2)",
3887     ));
3888     insns.push((
3889         Inst::Load32ZExt16 {
3890             rd: writable_gpr(1),
3891             mem: MemArg::BXD12 {
3892                 base: gpr(3),
3893                 index: gpr(2),
3894                 disp: UImm12::zero(),
3895                 flags: MemFlags::trusted(),
3896             },
3897         },
3898         "E31230000095",
3899         "llh %r1, 0(%r2,%r3)",
3900     ));
3901     insns.push((
3902         Inst::Load32ZExt16 {
3903             rd: writable_gpr(1),
3904             mem: MemArg::BXD12 {
3905                 base: gpr(3),
3906                 index: gpr(2),
3907                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3908                 flags: MemFlags::trusted(),
3909             },
3910         },
3911         "E3123FFF0095",
3912         "llh %r1, 4095(%r2,%r3)",
3913     ));
3914     insns.push((
3915         Inst::Load32ZExt16 {
3916             rd: writable_gpr(1),
3917             mem: MemArg::BXD20 {
3918                 base: gpr(3),
3919                 index: gpr(2),
3920                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3921                 flags: MemFlags::trusted(),
3922             },
3923         },
3924         "E31230008095",
3925         "llh %r1, -524288(%r2,%r3)",
3926     ));
3927     insns.push((
3928         Inst::Load32ZExt16 {
3929             rd: writable_gpr(1),
3930             mem: MemArg::BXD20 {
3931                 base: gpr(3),
3932                 index: gpr(2),
3933                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3934                 flags: MemFlags::trusted(),
3935             },
3936         },
3937         "E3123FFF7F95",
3938         "llh %r1, 524287(%r2,%r3)",
3939     ));
3940     insns.push((
3941         Inst::Load32SExt16 {
3942             rd: writable_gpr(1),
3943             mem: MemArg::BXD12 {
3944                 base: gpr(2),
3945                 index: zero_reg(),
3946                 disp: UImm12::zero(),
3947                 flags: MemFlags::trusted(),
3948             },
3949         },
3950         "48102000",
3951         "lh %r1, 0(%r2)",
3952     ));
3953     insns.push((
3954         Inst::Load32SExt16 {
3955             rd: writable_gpr(1),
3956             mem: MemArg::BXD12 {
3957                 base: gpr(2),
3958                 index: zero_reg(),
3959                 disp: UImm12::maybe_from_u64(4095).unwrap(),
3960                 flags: MemFlags::trusted(),
3961             },
3962         },
3963         "48102FFF",
3964         "lh %r1, 4095(%r2)",
3965     ));
3966     insns.push((
3967         Inst::Load32SExt16 {
3968             rd: writable_gpr(1),
3969             mem: MemArg::BXD20 {
3970                 base: gpr(2),
3971                 index: zero_reg(),
3972                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
3973                 flags: MemFlags::trusted(),
3974             },
3975         },
3976         "E31020008078",
3977         "lhy %r1, -524288(%r2)",
3978     ));
3979     insns.push((
3980         Inst::Load32SExt16 {
3981             rd: writable_gpr(1),
3982             mem: MemArg::BXD20 {
3983                 base: gpr(2),
3984                 index: zero_reg(),
3985                 disp: SImm20::maybe_from_i64(524287).unwrap(),
3986                 flags: MemFlags::trusted(),
3987             },
3988         },
3989         "E3102FFF7F78",
3990         "lhy %r1, 524287(%r2)",
3991     ));
3992     insns.push((
3993         Inst::Load32SExt16 {
3994             rd: writable_gpr(1),
3995             mem: MemArg::BXD12 {
3996                 base: gpr(3),
3997                 index: gpr(2),
3998                 disp: UImm12::zero(),
3999                 flags: MemFlags::trusted(),
4000             },
4001         },
4002         "48123000",
4003         "lh %r1, 0(%r2,%r3)",
4004     ));
4005     insns.push((
4006         Inst::Load32SExt16 {
4007             rd: writable_gpr(1),
4008             mem: MemArg::BXD12 {
4009                 base: gpr(3),
4010                 index: gpr(2),
4011                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4012                 flags: MemFlags::trusted(),
4013             },
4014         },
4015         "48123FFF",
4016         "lh %r1, 4095(%r2,%r3)",
4017     ));
4018     insns.push((
4019         Inst::Load32SExt16 {
4020             rd: writable_gpr(1),
4021             mem: MemArg::BXD20 {
4022                 base: gpr(3),
4023                 index: gpr(2),
4024                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4025                 flags: MemFlags::trusted(),
4026             },
4027         },
4028         "E31230008078",
4029         "lhy %r1, -524288(%r2,%r3)",
4030     ));
4031     insns.push((
4032         Inst::Load32SExt16 {
4033             rd: writable_gpr(1),
4034             mem: MemArg::BXD20 {
4035                 base: gpr(3),
4036                 index: gpr(2),
4037                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4038                 flags: MemFlags::trusted(),
4039             },
4040         },
4041         "E3123FFF7F78",
4042         "lhy %r1, 524287(%r2,%r3)",
4043     ));
4044     insns.push((
4045         Inst::Load64 {
4046             rd: writable_gpr(1),
4047             mem: MemArg::BXD12 {
4048                 base: gpr(2),
4049                 index: zero_reg(),
4050                 disp: UImm12::zero(),
4051                 flags: MemFlags::trusted(),
4052             },
4053         },
4054         "E31020000004",
4055         "lg %r1, 0(%r2)",
4056     ));
4057     insns.push((
4058         Inst::Load64 {
4059             rd: writable_gpr(1),
4060             mem: MemArg::BXD12 {
4061                 base: gpr(2),
4062                 index: zero_reg(),
4063                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4064                 flags: MemFlags::trusted(),
4065             },
4066         },
4067         "E3102FFF0004",
4068         "lg %r1, 4095(%r2)",
4069     ));
4070     insns.push((
4071         Inst::Load64 {
4072             rd: writable_gpr(1),
4073             mem: MemArg::BXD20 {
4074                 base: gpr(2),
4075                 index: zero_reg(),
4076                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4077                 flags: MemFlags::trusted(),
4078             },
4079         },
4080         "E31020008004",
4081         "lg %r1, -524288(%r2)",
4082     ));
4083     insns.push((
4084         Inst::Load64 {
4085             rd: writable_gpr(1),
4086             mem: MemArg::BXD20 {
4087                 base: gpr(2),
4088                 index: zero_reg(),
4089                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4090                 flags: MemFlags::trusted(),
4091             },
4092         },
4093         "E3102FFF7F04",
4094         "lg %r1, 524287(%r2)",
4095     ));
4096     insns.push((
4097         Inst::Load64 {
4098             rd: writable_gpr(1),
4099             mem: MemArg::BXD12 {
4100                 base: gpr(3),
4101                 index: gpr(2),
4102                 disp: UImm12::zero(),
4103                 flags: MemFlags::trusted(),
4104             },
4105         },
4106         "E31230000004",
4107         "lg %r1, 0(%r2,%r3)",
4108     ));
4109     insns.push((
4110         Inst::Load64 {
4111             rd: writable_gpr(1),
4112             mem: MemArg::BXD12 {
4113                 base: gpr(3),
4114                 index: gpr(2),
4115                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4116                 flags: MemFlags::trusted(),
4117             },
4118         },
4119         "E3123FFF0004",
4120         "lg %r1, 4095(%r2,%r3)",
4121     ));
4122     insns.push((
4123         Inst::Load64 {
4124             rd: writable_gpr(1),
4125             mem: MemArg::BXD20 {
4126                 base: gpr(3),
4127                 index: gpr(2),
4128                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4129                 flags: MemFlags::trusted(),
4130             },
4131         },
4132         "E31230008004",
4133         "lg %r1, -524288(%r2,%r3)",
4134     ));
4135     insns.push((
4136         Inst::Load64 {
4137             rd: writable_gpr(1),
4138             mem: MemArg::BXD20 {
4139                 base: gpr(3),
4140                 index: gpr(2),
4141                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4142                 flags: MemFlags::trusted(),
4143             },
4144         },
4145         "E3123FFF7F04",
4146         "lg %r1, 524287(%r2,%r3)",
4147     ));
4148     insns.push((
4149         Inst::Load64ZExt8 {
4150             rd: writable_gpr(1),
4151             mem: MemArg::BXD12 {
4152                 base: gpr(2),
4153                 index: zero_reg(),
4154                 disp: UImm12::zero(),
4155                 flags: MemFlags::trusted(),
4156             },
4157         },
4158         "E31020000090",
4159         "llgc %r1, 0(%r2)",
4160     ));
4161     insns.push((
4162         Inst::Load64ZExt8 {
4163             rd: writable_gpr(1),
4164             mem: MemArg::BXD12 {
4165                 base: gpr(2),
4166                 index: zero_reg(),
4167                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4168                 flags: MemFlags::trusted(),
4169             },
4170         },
4171         "E3102FFF0090",
4172         "llgc %r1, 4095(%r2)",
4173     ));
4174     insns.push((
4175         Inst::Load64ZExt8 {
4176             rd: writable_gpr(1),
4177             mem: MemArg::BXD20 {
4178                 base: gpr(2),
4179                 index: zero_reg(),
4180                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4181                 flags: MemFlags::trusted(),
4182             },
4183         },
4184         "E31020008090",
4185         "llgc %r1, -524288(%r2)",
4186     ));
4187     insns.push((
4188         Inst::Load64ZExt8 {
4189             rd: writable_gpr(1),
4190             mem: MemArg::BXD20 {
4191                 base: gpr(2),
4192                 index: zero_reg(),
4193                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4194                 flags: MemFlags::trusted(),
4195             },
4196         },
4197         "E3102FFF7F90",
4198         "llgc %r1, 524287(%r2)",
4199     ));
4200     insns.push((
4201         Inst::Load64ZExt8 {
4202             rd: writable_gpr(1),
4203             mem: MemArg::BXD12 {
4204                 base: gpr(3),
4205                 index: gpr(2),
4206                 disp: UImm12::zero(),
4207                 flags: MemFlags::trusted(),
4208             },
4209         },
4210         "E31230000090",
4211         "llgc %r1, 0(%r2,%r3)",
4212     ));
4213     insns.push((
4214         Inst::Load64ZExt8 {
4215             rd: writable_gpr(1),
4216             mem: MemArg::BXD12 {
4217                 base: gpr(3),
4218                 index: gpr(2),
4219                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4220                 flags: MemFlags::trusted(),
4221             },
4222         },
4223         "E3123FFF0090",
4224         "llgc %r1, 4095(%r2,%r3)",
4225     ));
4226     insns.push((
4227         Inst::Load64ZExt8 {
4228             rd: writable_gpr(1),
4229             mem: MemArg::BXD20 {
4230                 base: gpr(3),
4231                 index: gpr(2),
4232                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4233                 flags: MemFlags::trusted(),
4234             },
4235         },
4236         "E31230008090",
4237         "llgc %r1, -524288(%r2,%r3)",
4238     ));
4239     insns.push((
4240         Inst::Load64ZExt8 {
4241             rd: writable_gpr(1),
4242             mem: MemArg::BXD20 {
4243                 base: gpr(3),
4244                 index: gpr(2),
4245                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4246                 flags: MemFlags::trusted(),
4247             },
4248         },
4249         "E3123FFF7F90",
4250         "llgc %r1, 524287(%r2,%r3)",
4251     ));
4252     insns.push((
4253         Inst::Load64SExt8 {
4254             rd: writable_gpr(1),
4255             mem: MemArg::BXD12 {
4256                 base: gpr(2),
4257                 index: zero_reg(),
4258                 disp: UImm12::zero(),
4259                 flags: MemFlags::trusted(),
4260             },
4261         },
4262         "E31020000077",
4263         "lgb %r1, 0(%r2)",
4264     ));
4265     insns.push((
4266         Inst::Load64SExt8 {
4267             rd: writable_gpr(1),
4268             mem: MemArg::BXD12 {
4269                 base: gpr(2),
4270                 index: zero_reg(),
4271                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4272                 flags: MemFlags::trusted(),
4273             },
4274         },
4275         "E3102FFF0077",
4276         "lgb %r1, 4095(%r2)",
4277     ));
4278     insns.push((
4279         Inst::Load64SExt8 {
4280             rd: writable_gpr(1),
4281             mem: MemArg::BXD20 {
4282                 base: gpr(2),
4283                 index: zero_reg(),
4284                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4285                 flags: MemFlags::trusted(),
4286             },
4287         },
4288         "E31020008077",
4289         "lgb %r1, -524288(%r2)",
4290     ));
4291     insns.push((
4292         Inst::Load64SExt8 {
4293             rd: writable_gpr(1),
4294             mem: MemArg::BXD20 {
4295                 base: gpr(2),
4296                 index: zero_reg(),
4297                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4298                 flags: MemFlags::trusted(),
4299             },
4300         },
4301         "E3102FFF7F77",
4302         "lgb %r1, 524287(%r2)",
4303     ));
4304     insns.push((
4305         Inst::Load64SExt8 {
4306             rd: writable_gpr(1),
4307             mem: MemArg::BXD12 {
4308                 base: gpr(3),
4309                 index: gpr(2),
4310                 disp: UImm12::zero(),
4311                 flags: MemFlags::trusted(),
4312             },
4313         },
4314         "E31230000077",
4315         "lgb %r1, 0(%r2,%r3)",
4316     ));
4317     insns.push((
4318         Inst::Load64SExt8 {
4319             rd: writable_gpr(1),
4320             mem: MemArg::BXD12 {
4321                 base: gpr(3),
4322                 index: gpr(2),
4323                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4324                 flags: MemFlags::trusted(),
4325             },
4326         },
4327         "E3123FFF0077",
4328         "lgb %r1, 4095(%r2,%r3)",
4329     ));
4330     insns.push((
4331         Inst::Load64SExt8 {
4332             rd: writable_gpr(1),
4333             mem: MemArg::BXD20 {
4334                 base: gpr(3),
4335                 index: gpr(2),
4336                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4337                 flags: MemFlags::trusted(),
4338             },
4339         },
4340         "E31230008077",
4341         "lgb %r1, -524288(%r2,%r3)",
4342     ));
4343     insns.push((
4344         Inst::Load64SExt8 {
4345             rd: writable_gpr(1),
4346             mem: MemArg::BXD20 {
4347                 base: gpr(3),
4348                 index: gpr(2),
4349                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4350                 flags: MemFlags::trusted(),
4351             },
4352         },
4353         "E3123FFF7F77",
4354         "lgb %r1, 524287(%r2,%r3)",
4355     ));
4356     insns.push((
4357         Inst::Load64ZExt16 {
4358             rd: writable_gpr(1),
4359             mem: MemArg::BXD12 {
4360                 base: gpr(2),
4361                 index: zero_reg(),
4362                 disp: UImm12::zero(),
4363                 flags: MemFlags::trusted(),
4364             },
4365         },
4366         "E31020000091",
4367         "llgh %r1, 0(%r2)",
4368     ));
4369     insns.push((
4370         Inst::Load64ZExt16 {
4371             rd: writable_gpr(1),
4372             mem: MemArg::BXD12 {
4373                 base: gpr(2),
4374                 index: zero_reg(),
4375                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4376                 flags: MemFlags::trusted(),
4377             },
4378         },
4379         "E3102FFF0091",
4380         "llgh %r1, 4095(%r2)",
4381     ));
4382     insns.push((
4383         Inst::Load64ZExt16 {
4384             rd: writable_gpr(1),
4385             mem: MemArg::BXD20 {
4386                 base: gpr(2),
4387                 index: zero_reg(),
4388                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4389                 flags: MemFlags::trusted(),
4390             },
4391         },
4392         "E31020008091",
4393         "llgh %r1, -524288(%r2)",
4394     ));
4395     insns.push((
4396         Inst::Load64ZExt16 {
4397             rd: writable_gpr(1),
4398             mem: MemArg::BXD20 {
4399                 base: gpr(2),
4400                 index: zero_reg(),
4401                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4402                 flags: MemFlags::trusted(),
4403             },
4404         },
4405         "E3102FFF7F91",
4406         "llgh %r1, 524287(%r2)",
4407     ));
4408     insns.push((
4409         Inst::Load64ZExt16 {
4410             rd: writable_gpr(1),
4411             mem: MemArg::BXD12 {
4412                 base: gpr(3),
4413                 index: gpr(2),
4414                 disp: UImm12::zero(),
4415                 flags: MemFlags::trusted(),
4416             },
4417         },
4418         "E31230000091",
4419         "llgh %r1, 0(%r2,%r3)",
4420     ));
4421     insns.push((
4422         Inst::Load64ZExt16 {
4423             rd: writable_gpr(1),
4424             mem: MemArg::BXD12 {
4425                 base: gpr(3),
4426                 index: gpr(2),
4427                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4428                 flags: MemFlags::trusted(),
4429             },
4430         },
4431         "E3123FFF0091",
4432         "llgh %r1, 4095(%r2,%r3)",
4433     ));
4434     insns.push((
4435         Inst::Load64ZExt16 {
4436             rd: writable_gpr(1),
4437             mem: MemArg::BXD20 {
4438                 base: gpr(3),
4439                 index: gpr(2),
4440                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4441                 flags: MemFlags::trusted(),
4442             },
4443         },
4444         "E31230008091",
4445         "llgh %r1, -524288(%r2,%r3)",
4446     ));
4447     insns.push((
4448         Inst::Load64ZExt16 {
4449             rd: writable_gpr(1),
4450             mem: MemArg::BXD20 {
4451                 base: gpr(3),
4452                 index: gpr(2),
4453                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4454                 flags: MemFlags::trusted(),
4455             },
4456         },
4457         "E3123FFF7F91",
4458         "llgh %r1, 524287(%r2,%r3)",
4459     ));
4460     insns.push((
4461         Inst::Load64SExt16 {
4462             rd: writable_gpr(1),
4463             mem: MemArg::BXD12 {
4464                 base: gpr(2),
4465                 index: zero_reg(),
4466                 disp: UImm12::zero(),
4467                 flags: MemFlags::trusted(),
4468             },
4469         },
4470         "E31020000015",
4471         "lgh %r1, 0(%r2)",
4472     ));
4473     insns.push((
4474         Inst::Load64SExt16 {
4475             rd: writable_gpr(1),
4476             mem: MemArg::BXD12 {
4477                 base: gpr(2),
4478                 index: zero_reg(),
4479                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4480                 flags: MemFlags::trusted(),
4481             },
4482         },
4483         "E3102FFF0015",
4484         "lgh %r1, 4095(%r2)",
4485     ));
4486     insns.push((
4487         Inst::Load64SExt16 {
4488             rd: writable_gpr(1),
4489             mem: MemArg::BXD20 {
4490                 base: gpr(2),
4491                 index: zero_reg(),
4492                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4493                 flags: MemFlags::trusted(),
4494             },
4495         },
4496         "E31020008015",
4497         "lgh %r1, -524288(%r2)",
4498     ));
4499     insns.push((
4500         Inst::Load64SExt16 {
4501             rd: writable_gpr(1),
4502             mem: MemArg::BXD20 {
4503                 base: gpr(2),
4504                 index: zero_reg(),
4505                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4506                 flags: MemFlags::trusted(),
4507             },
4508         },
4509         "E3102FFF7F15",
4510         "lgh %r1, 524287(%r2)",
4511     ));
4512     insns.push((
4513         Inst::Load64SExt16 {
4514             rd: writable_gpr(1),
4515             mem: MemArg::BXD12 {
4516                 base: gpr(3),
4517                 index: gpr(2),
4518                 disp: UImm12::zero(),
4519                 flags: MemFlags::trusted(),
4520             },
4521         },
4522         "E31230000015",
4523         "lgh %r1, 0(%r2,%r3)",
4524     ));
4525     insns.push((
4526         Inst::Load64SExt16 {
4527             rd: writable_gpr(1),
4528             mem: MemArg::BXD12 {
4529                 base: gpr(3),
4530                 index: gpr(2),
4531                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4532                 flags: MemFlags::trusted(),
4533             },
4534         },
4535         "E3123FFF0015",
4536         "lgh %r1, 4095(%r2,%r3)",
4537     ));
4538     insns.push((
4539         Inst::Load64SExt16 {
4540             rd: writable_gpr(1),
4541             mem: MemArg::BXD20 {
4542                 base: gpr(3),
4543                 index: gpr(2),
4544                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4545                 flags: MemFlags::trusted(),
4546             },
4547         },
4548         "E31230008015",
4549         "lgh %r1, -524288(%r2,%r3)",
4550     ));
4551     insns.push((
4552         Inst::Load64SExt16 {
4553             rd: writable_gpr(1),
4554             mem: MemArg::BXD20 {
4555                 base: gpr(3),
4556                 index: gpr(2),
4557                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4558                 flags: MemFlags::trusted(),
4559             },
4560         },
4561         "E3123FFF7F15",
4562         "lgh %r1, 524287(%r2,%r3)",
4563     ));
4564     insns.push((
4565         Inst::Load64ZExt32 {
4566             rd: writable_gpr(1),
4567             mem: MemArg::BXD12 {
4568                 base: gpr(2),
4569                 index: zero_reg(),
4570                 disp: UImm12::zero(),
4571                 flags: MemFlags::trusted(),
4572             },
4573         },
4574         "E31020000016",
4575         "llgf %r1, 0(%r2)",
4576     ));
4577     insns.push((
4578         Inst::Load64ZExt32 {
4579             rd: writable_gpr(1),
4580             mem: MemArg::BXD12 {
4581                 base: gpr(2),
4582                 index: zero_reg(),
4583                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4584                 flags: MemFlags::trusted(),
4585             },
4586         },
4587         "E3102FFF0016",
4588         "llgf %r1, 4095(%r2)",
4589     ));
4590     insns.push((
4591         Inst::Load64ZExt32 {
4592             rd: writable_gpr(1),
4593             mem: MemArg::BXD20 {
4594                 base: gpr(2),
4595                 index: zero_reg(),
4596                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4597                 flags: MemFlags::trusted(),
4598             },
4599         },
4600         "E31020008016",
4601         "llgf %r1, -524288(%r2)",
4602     ));
4603     insns.push((
4604         Inst::Load64ZExt32 {
4605             rd: writable_gpr(1),
4606             mem: MemArg::BXD20 {
4607                 base: gpr(2),
4608                 index: zero_reg(),
4609                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4610                 flags: MemFlags::trusted(),
4611             },
4612         },
4613         "E3102FFF7F16",
4614         "llgf %r1, 524287(%r2)",
4615     ));
4616     insns.push((
4617         Inst::Load64ZExt32 {
4618             rd: writable_gpr(1),
4619             mem: MemArg::BXD12 {
4620                 base: gpr(3),
4621                 index: gpr(2),
4622                 disp: UImm12::zero(),
4623                 flags: MemFlags::trusted(),
4624             },
4625         },
4626         "E31230000016",
4627         "llgf %r1, 0(%r2,%r3)",
4628     ));
4629     insns.push((
4630         Inst::Load64ZExt32 {
4631             rd: writable_gpr(1),
4632             mem: MemArg::BXD12 {
4633                 base: gpr(3),
4634                 index: gpr(2),
4635                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4636                 flags: MemFlags::trusted(),
4637             },
4638         },
4639         "E3123FFF0016",
4640         "llgf %r1, 4095(%r2,%r3)",
4641     ));
4642     insns.push((
4643         Inst::Load64ZExt32 {
4644             rd: writable_gpr(1),
4645             mem: MemArg::BXD20 {
4646                 base: gpr(3),
4647                 index: gpr(2),
4648                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4649                 flags: MemFlags::trusted(),
4650             },
4651         },
4652         "E31230008016",
4653         "llgf %r1, -524288(%r2,%r3)",
4654     ));
4655     insns.push((
4656         Inst::Load64ZExt32 {
4657             rd: writable_gpr(1),
4658             mem: MemArg::BXD20 {
4659                 base: gpr(3),
4660                 index: gpr(2),
4661                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4662                 flags: MemFlags::trusted(),
4663             },
4664         },
4665         "E3123FFF7F16",
4666         "llgf %r1, 524287(%r2,%r3)",
4667     ));
4668     insns.push((
4669         Inst::Load64SExt32 {
4670             rd: writable_gpr(1),
4671             mem: MemArg::BXD12 {
4672                 base: gpr(2),
4673                 index: zero_reg(),
4674                 disp: UImm12::zero(),
4675                 flags: MemFlags::trusted(),
4676             },
4677         },
4678         "E31020000014",
4679         "lgf %r1, 0(%r2)",
4680     ));
4681     insns.push((
4682         Inst::Load64SExt32 {
4683             rd: writable_gpr(1),
4684             mem: MemArg::BXD12 {
4685                 base: gpr(2),
4686                 index: zero_reg(),
4687                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4688                 flags: MemFlags::trusted(),
4689             },
4690         },
4691         "E3102FFF0014",
4692         "lgf %r1, 4095(%r2)",
4693     ));
4694     insns.push((
4695         Inst::Load64SExt32 {
4696             rd: writable_gpr(1),
4697             mem: MemArg::BXD20 {
4698                 base: gpr(2),
4699                 index: zero_reg(),
4700                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4701                 flags: MemFlags::trusted(),
4702             },
4703         },
4704         "E31020008014",
4705         "lgf %r1, -524288(%r2)",
4706     ));
4707     insns.push((
4708         Inst::Load64SExt32 {
4709             rd: writable_gpr(1),
4710             mem: MemArg::BXD20 {
4711                 base: gpr(2),
4712                 index: zero_reg(),
4713                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4714                 flags: MemFlags::trusted(),
4715             },
4716         },
4717         "E3102FFF7F14",
4718         "lgf %r1, 524287(%r2)",
4719     ));
4720     insns.push((
4721         Inst::Load64SExt32 {
4722             rd: writable_gpr(1),
4723             mem: MemArg::BXD12 {
4724                 base: gpr(3),
4725                 index: gpr(2),
4726                 disp: UImm12::zero(),
4727                 flags: MemFlags::trusted(),
4728             },
4729         },
4730         "E31230000014",
4731         "lgf %r1, 0(%r2,%r3)",
4732     ));
4733     insns.push((
4734         Inst::Load64SExt32 {
4735             rd: writable_gpr(1),
4736             mem: MemArg::BXD12 {
4737                 base: gpr(3),
4738                 index: gpr(2),
4739                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4740                 flags: MemFlags::trusted(),
4741             },
4742         },
4743         "E3123FFF0014",
4744         "lgf %r1, 4095(%r2,%r3)",
4745     ));
4746     insns.push((
4747         Inst::Load64SExt32 {
4748             rd: writable_gpr(1),
4749             mem: MemArg::BXD20 {
4750                 base: gpr(3),
4751                 index: gpr(2),
4752                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4753                 flags: MemFlags::trusted(),
4754             },
4755         },
4756         "E31230008014",
4757         "lgf %r1, -524288(%r2,%r3)",
4758     ));
4759     insns.push((
4760         Inst::Load64SExt32 {
4761             rd: writable_gpr(1),
4762             mem: MemArg::BXD20 {
4763                 base: gpr(3),
4764                 index: gpr(2),
4765                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4766                 flags: MemFlags::trusted(),
4767             },
4768         },
4769         "E3123FFF7F14",
4770         "lgf %r1, 524287(%r2,%r3)",
4771     ));
4772 
4773     insns.push((
4774         Inst::Load32 {
4775             rd: writable_gpr(1),
4776             mem: MemArg::Label {
4777                 target: MachLabel::from_block(BlockIndex::new(1)),
4778             },
4779         },
4780         "C41D00000003",
4781         "lrl %r1, label1",
4782     ));
4783     insns.push((
4784         Inst::Load32SExt16 {
4785             rd: writable_gpr(1),
4786             mem: MemArg::Label {
4787                 target: MachLabel::from_block(BlockIndex::new(1)),
4788             },
4789         },
4790         "C41500000003",
4791         "lhrl %r1, label1",
4792     ));
4793     insns.push((
4794         Inst::Load32ZExt16 {
4795             rd: writable_gpr(1),
4796             mem: MemArg::Label {
4797                 target: MachLabel::from_block(BlockIndex::new(1)),
4798             },
4799         },
4800         "C41200000003",
4801         "llhrl %r1, label1",
4802     ));
4803     insns.push((
4804         Inst::Load64 {
4805             rd: writable_gpr(1),
4806             mem: MemArg::Label {
4807                 target: MachLabel::from_block(BlockIndex::new(1)),
4808             },
4809         },
4810         "C41800000003",
4811         "lgrl %r1, label1",
4812     ));
4813     insns.push((
4814         Inst::Load64SExt16 {
4815             rd: writable_gpr(1),
4816             mem: MemArg::Label {
4817                 target: MachLabel::from_block(BlockIndex::new(1)),
4818             },
4819         },
4820         "C41400000003",
4821         "lghrl %r1, label1",
4822     ));
4823     insns.push((
4824         Inst::Load64ZExt16 {
4825             rd: writable_gpr(1),
4826             mem: MemArg::Label {
4827                 target: MachLabel::from_block(BlockIndex::new(1)),
4828             },
4829         },
4830         "C41600000003",
4831         "llghrl %r1, label1",
4832     ));
4833     insns.push((
4834         Inst::Load64SExt32 {
4835             rd: writable_gpr(1),
4836             mem: MemArg::Label {
4837                 target: MachLabel::from_block(BlockIndex::new(1)),
4838             },
4839         },
4840         "C41C00000003",
4841         "lgfrl %r1, label1",
4842     ));
4843     insns.push((
4844         Inst::Load64ZExt32 {
4845             rd: writable_gpr(1),
4846             mem: MemArg::Label {
4847                 target: MachLabel::from_block(BlockIndex::new(1)),
4848             },
4849         },
4850         "C41E00000003",
4851         "llgfrl %r1, label1",
4852     ));
4853     insns.push((
4854         Inst::LoadRev16 {
4855             rd: writable_gpr(1),
4856             mem: MemArg::BXD12 {
4857                 base: gpr(2),
4858                 index: zero_reg(),
4859                 disp: UImm12::zero(),
4860                 flags: MemFlags::trusted(),
4861             },
4862         },
4863         "E3102000001F",
4864         "lrvh %r1, 0(%r2)",
4865     ));
4866     insns.push((
4867         Inst::LoadRev16 {
4868             rd: writable_gpr(1),
4869             mem: MemArg::BXD12 {
4870                 base: gpr(2),
4871                 index: zero_reg(),
4872                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4873                 flags: MemFlags::trusted(),
4874             },
4875         },
4876         "E3102FFF001F",
4877         "lrvh %r1, 4095(%r2)",
4878     ));
4879     insns.push((
4880         Inst::LoadRev16 {
4881             rd: writable_gpr(1),
4882             mem: MemArg::BXD20 {
4883                 base: gpr(2),
4884                 index: zero_reg(),
4885                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4886                 flags: MemFlags::trusted(),
4887             },
4888         },
4889         "E3102000801F",
4890         "lrvh %r1, -524288(%r2)",
4891     ));
4892     insns.push((
4893         Inst::LoadRev16 {
4894             rd: writable_gpr(1),
4895             mem: MemArg::BXD20 {
4896                 base: gpr(2),
4897                 index: zero_reg(),
4898                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4899                 flags: MemFlags::trusted(),
4900             },
4901         },
4902         "E3102FFF7F1F",
4903         "lrvh %r1, 524287(%r2)",
4904     ));
4905     insns.push((
4906         Inst::LoadRev16 {
4907             rd: writable_gpr(1),
4908             mem: MemArg::BXD12 {
4909                 base: gpr(3),
4910                 index: gpr(2),
4911                 disp: UImm12::zero(),
4912                 flags: MemFlags::trusted(),
4913             },
4914         },
4915         "E3123000001F",
4916         "lrvh %r1, 0(%r2,%r3)",
4917     ));
4918     insns.push((
4919         Inst::LoadRev16 {
4920             rd: writable_gpr(1),
4921             mem: MemArg::BXD12 {
4922                 base: gpr(3),
4923                 index: gpr(2),
4924                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4925                 flags: MemFlags::trusted(),
4926             },
4927         },
4928         "E3123FFF001F",
4929         "lrvh %r1, 4095(%r2,%r3)",
4930     ));
4931     insns.push((
4932         Inst::LoadRev16 {
4933             rd: writable_gpr(1),
4934             mem: MemArg::BXD20 {
4935                 base: gpr(3),
4936                 index: gpr(2),
4937                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4938                 flags: MemFlags::trusted(),
4939             },
4940         },
4941         "E3123000801F",
4942         "lrvh %r1, -524288(%r2,%r3)",
4943     ));
4944     insns.push((
4945         Inst::LoadRev16 {
4946             rd: writable_gpr(1),
4947             mem: MemArg::BXD20 {
4948                 base: gpr(3),
4949                 index: gpr(2),
4950                 disp: SImm20::maybe_from_i64(524287).unwrap(),
4951                 flags: MemFlags::trusted(),
4952             },
4953         },
4954         "E3123FFF7F1F",
4955         "lrvh %r1, 524287(%r2,%r3)",
4956     ));
4957     insns.push((
4958         Inst::LoadRev32 {
4959             rd: writable_gpr(1),
4960             mem: MemArg::BXD12 {
4961                 base: gpr(2),
4962                 index: zero_reg(),
4963                 disp: UImm12::zero(),
4964                 flags: MemFlags::trusted(),
4965             },
4966         },
4967         "E3102000001E",
4968         "lrv %r1, 0(%r2)",
4969     ));
4970     insns.push((
4971         Inst::LoadRev32 {
4972             rd: writable_gpr(1),
4973             mem: MemArg::BXD12 {
4974                 base: gpr(2),
4975                 index: zero_reg(),
4976                 disp: UImm12::maybe_from_u64(4095).unwrap(),
4977                 flags: MemFlags::trusted(),
4978             },
4979         },
4980         "E3102FFF001E",
4981         "lrv %r1, 4095(%r2)",
4982     ));
4983     insns.push((
4984         Inst::LoadRev32 {
4985             rd: writable_gpr(1),
4986             mem: MemArg::BXD20 {
4987                 base: gpr(2),
4988                 index: zero_reg(),
4989                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
4990                 flags: MemFlags::trusted(),
4991             },
4992         },
4993         "E3102000801E",
4994         "lrv %r1, -524288(%r2)",
4995     ));
4996     insns.push((
4997         Inst::LoadRev32 {
4998             rd: writable_gpr(1),
4999             mem: MemArg::BXD20 {
5000                 base: gpr(2),
5001                 index: zero_reg(),
5002                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5003                 flags: MemFlags::trusted(),
5004             },
5005         },
5006         "E3102FFF7F1E",
5007         "lrv %r1, 524287(%r2)",
5008     ));
5009     insns.push((
5010         Inst::LoadRev32 {
5011             rd: writable_gpr(1),
5012             mem: MemArg::BXD12 {
5013                 base: gpr(3),
5014                 index: gpr(2),
5015                 disp: UImm12::zero(),
5016                 flags: MemFlags::trusted(),
5017             },
5018         },
5019         "E3123000001E",
5020         "lrv %r1, 0(%r2,%r3)",
5021     ));
5022     insns.push((
5023         Inst::LoadRev32 {
5024             rd: writable_gpr(1),
5025             mem: MemArg::BXD12 {
5026                 base: gpr(3),
5027                 index: gpr(2),
5028                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5029                 flags: MemFlags::trusted(),
5030             },
5031         },
5032         "E3123FFF001E",
5033         "lrv %r1, 4095(%r2,%r3)",
5034     ));
5035     insns.push((
5036         Inst::LoadRev32 {
5037             rd: writable_gpr(1),
5038             mem: MemArg::BXD20 {
5039                 base: gpr(3),
5040                 index: gpr(2),
5041                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5042                 flags: MemFlags::trusted(),
5043             },
5044         },
5045         "E3123000801E",
5046         "lrv %r1, -524288(%r2,%r3)",
5047     ));
5048     insns.push((
5049         Inst::LoadRev32 {
5050             rd: writable_gpr(1),
5051             mem: MemArg::BXD20 {
5052                 base: gpr(3),
5053                 index: gpr(2),
5054                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5055                 flags: MemFlags::trusted(),
5056             },
5057         },
5058         "E3123FFF7F1E",
5059         "lrv %r1, 524287(%r2,%r3)",
5060     ));
5061     insns.push((
5062         Inst::LoadRev64 {
5063             rd: writable_gpr(1),
5064             mem: MemArg::BXD12 {
5065                 base: gpr(2),
5066                 index: zero_reg(),
5067                 disp: UImm12::zero(),
5068                 flags: MemFlags::trusted(),
5069             },
5070         },
5071         "E3102000000F",
5072         "lrvg %r1, 0(%r2)",
5073     ));
5074     insns.push((
5075         Inst::LoadRev64 {
5076             rd: writable_gpr(1),
5077             mem: MemArg::BXD12 {
5078                 base: gpr(2),
5079                 index: zero_reg(),
5080                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5081                 flags: MemFlags::trusted(),
5082             },
5083         },
5084         "E3102FFF000F",
5085         "lrvg %r1, 4095(%r2)",
5086     ));
5087     insns.push((
5088         Inst::LoadRev64 {
5089             rd: writable_gpr(1),
5090             mem: MemArg::BXD20 {
5091                 base: gpr(2),
5092                 index: zero_reg(),
5093                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5094                 flags: MemFlags::trusted(),
5095             },
5096         },
5097         "E3102000800F",
5098         "lrvg %r1, -524288(%r2)",
5099     ));
5100     insns.push((
5101         Inst::LoadRev64 {
5102             rd: writable_gpr(1),
5103             mem: MemArg::BXD20 {
5104                 base: gpr(2),
5105                 index: zero_reg(),
5106                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5107                 flags: MemFlags::trusted(),
5108             },
5109         },
5110         "E3102FFF7F0F",
5111         "lrvg %r1, 524287(%r2)",
5112     ));
5113     insns.push((
5114         Inst::LoadRev64 {
5115             rd: writable_gpr(1),
5116             mem: MemArg::BXD12 {
5117                 base: gpr(3),
5118                 index: gpr(2),
5119                 disp: UImm12::zero(),
5120                 flags: MemFlags::trusted(),
5121             },
5122         },
5123         "E3123000000F",
5124         "lrvg %r1, 0(%r2,%r3)",
5125     ));
5126     insns.push((
5127         Inst::LoadRev64 {
5128             rd: writable_gpr(1),
5129             mem: MemArg::BXD12 {
5130                 base: gpr(3),
5131                 index: gpr(2),
5132                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5133                 flags: MemFlags::trusted(),
5134             },
5135         },
5136         "E3123FFF000F",
5137         "lrvg %r1, 4095(%r2,%r3)",
5138     ));
5139     insns.push((
5140         Inst::LoadRev64 {
5141             rd: writable_gpr(1),
5142             mem: MemArg::BXD20 {
5143                 base: gpr(3),
5144                 index: gpr(2),
5145                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5146                 flags: MemFlags::trusted(),
5147             },
5148         },
5149         "E3123000800F",
5150         "lrvg %r1, -524288(%r2,%r3)",
5151     ));
5152     insns.push((
5153         Inst::LoadRev64 {
5154             rd: writable_gpr(1),
5155             mem: MemArg::BXD20 {
5156                 base: gpr(3),
5157                 index: gpr(2),
5158                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5159                 flags: MemFlags::trusted(),
5160             },
5161         },
5162         "E3123FFF7F0F",
5163         "lrvg %r1, 524287(%r2,%r3)",
5164     ));
5165 
5166     insns.push((
5167         Inst::Store8 {
5168             rd: gpr(1),
5169             mem: MemArg::BXD12 {
5170                 base: gpr(2),
5171                 index: zero_reg(),
5172                 disp: UImm12::zero(),
5173                 flags: MemFlags::trusted(),
5174             },
5175         },
5176         "42102000",
5177         "stc %r1, 0(%r2)",
5178     ));
5179     insns.push((
5180         Inst::Store8 {
5181             rd: gpr(1),
5182             mem: MemArg::BXD12 {
5183                 base: gpr(2),
5184                 index: zero_reg(),
5185                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5186                 flags: MemFlags::trusted(),
5187             },
5188         },
5189         "42102FFF",
5190         "stc %r1, 4095(%r2)",
5191     ));
5192     insns.push((
5193         Inst::Store8 {
5194             rd: gpr(1),
5195             mem: MemArg::BXD20 {
5196                 base: gpr(2),
5197                 index: zero_reg(),
5198                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5199                 flags: MemFlags::trusted(),
5200             },
5201         },
5202         "E31020008072",
5203         "stcy %r1, -524288(%r2)",
5204     ));
5205     insns.push((
5206         Inst::Store8 {
5207             rd: gpr(1),
5208             mem: MemArg::BXD20 {
5209                 base: gpr(2),
5210                 index: zero_reg(),
5211                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5212                 flags: MemFlags::trusted(),
5213             },
5214         },
5215         "E3102FFF7F72",
5216         "stcy %r1, 524287(%r2)",
5217     ));
5218     insns.push((
5219         Inst::Store8 {
5220             rd: gpr(1),
5221             mem: MemArg::BXD12 {
5222                 base: gpr(3),
5223                 index: gpr(2),
5224                 disp: UImm12::zero(),
5225                 flags: MemFlags::trusted(),
5226             },
5227         },
5228         "42123000",
5229         "stc %r1, 0(%r2,%r3)",
5230     ));
5231     insns.push((
5232         Inst::Store8 {
5233             rd: gpr(1),
5234             mem: MemArg::BXD12 {
5235                 base: gpr(3),
5236                 index: gpr(2),
5237                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5238                 flags: MemFlags::trusted(),
5239             },
5240         },
5241         "42123FFF",
5242         "stc %r1, 4095(%r2,%r3)",
5243     ));
5244     insns.push((
5245         Inst::Store8 {
5246             rd: gpr(1),
5247             mem: MemArg::BXD20 {
5248                 base: gpr(3),
5249                 index: gpr(2),
5250                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5251                 flags: MemFlags::trusted(),
5252             },
5253         },
5254         "E31230008072",
5255         "stcy %r1, -524288(%r2,%r3)",
5256     ));
5257     insns.push((
5258         Inst::Store8 {
5259             rd: gpr(1),
5260             mem: MemArg::BXD20 {
5261                 base: gpr(3),
5262                 index: gpr(2),
5263                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5264                 flags: MemFlags::trusted(),
5265             },
5266         },
5267         "E3123FFF7F72",
5268         "stcy %r1, 524287(%r2,%r3)",
5269     ));
5270     insns.push((
5271         Inst::Store16 {
5272             rd: gpr(1),
5273             mem: MemArg::BXD12 {
5274                 base: gpr(2),
5275                 index: zero_reg(),
5276                 disp: UImm12::zero(),
5277                 flags: MemFlags::trusted(),
5278             },
5279         },
5280         "40102000",
5281         "sth %r1, 0(%r2)",
5282     ));
5283     insns.push((
5284         Inst::Store16 {
5285             rd: gpr(1),
5286             mem: MemArg::BXD12 {
5287                 base: gpr(2),
5288                 index: zero_reg(),
5289                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5290                 flags: MemFlags::trusted(),
5291             },
5292         },
5293         "40102FFF",
5294         "sth %r1, 4095(%r2)",
5295     ));
5296     insns.push((
5297         Inst::Store16 {
5298             rd: gpr(1),
5299             mem: MemArg::BXD20 {
5300                 base: gpr(2),
5301                 index: zero_reg(),
5302                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5303                 flags: MemFlags::trusted(),
5304             },
5305         },
5306         "E31020008070",
5307         "sthy %r1, -524288(%r2)",
5308     ));
5309     insns.push((
5310         Inst::Store16 {
5311             rd: gpr(1),
5312             mem: MemArg::BXD20 {
5313                 base: gpr(2),
5314                 index: zero_reg(),
5315                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5316                 flags: MemFlags::trusted(),
5317             },
5318         },
5319         "E3102FFF7F70",
5320         "sthy %r1, 524287(%r2)",
5321     ));
5322     insns.push((
5323         Inst::Store16 {
5324             rd: gpr(1),
5325             mem: MemArg::BXD12 {
5326                 base: gpr(3),
5327                 index: gpr(2),
5328                 disp: UImm12::zero(),
5329                 flags: MemFlags::trusted(),
5330             },
5331         },
5332         "40123000",
5333         "sth %r1, 0(%r2,%r3)",
5334     ));
5335     insns.push((
5336         Inst::Store16 {
5337             rd: gpr(1),
5338             mem: MemArg::BXD12 {
5339                 base: gpr(3),
5340                 index: gpr(2),
5341                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5342                 flags: MemFlags::trusted(),
5343             },
5344         },
5345         "40123FFF",
5346         "sth %r1, 4095(%r2,%r3)",
5347     ));
5348     insns.push((
5349         Inst::Store16 {
5350             rd: gpr(1),
5351             mem: MemArg::BXD20 {
5352                 base: gpr(3),
5353                 index: gpr(2),
5354                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5355                 flags: MemFlags::trusted(),
5356             },
5357         },
5358         "E31230008070",
5359         "sthy %r1, -524288(%r2,%r3)",
5360     ));
5361     insns.push((
5362         Inst::Store16 {
5363             rd: gpr(1),
5364             mem: MemArg::BXD20 {
5365                 base: gpr(3),
5366                 index: gpr(2),
5367                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5368                 flags: MemFlags::trusted(),
5369             },
5370         },
5371         "E3123FFF7F70",
5372         "sthy %r1, 524287(%r2,%r3)",
5373     ));
5374     insns.push((
5375         Inst::Store32 {
5376             rd: gpr(1),
5377             mem: MemArg::BXD12 {
5378                 base: gpr(2),
5379                 index: zero_reg(),
5380                 disp: UImm12::zero(),
5381                 flags: MemFlags::trusted(),
5382             },
5383         },
5384         "50102000",
5385         "st %r1, 0(%r2)",
5386     ));
5387     insns.push((
5388         Inst::Store32 {
5389             rd: gpr(1),
5390             mem: MemArg::BXD12 {
5391                 base: gpr(2),
5392                 index: zero_reg(),
5393                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5394                 flags: MemFlags::trusted(),
5395             },
5396         },
5397         "50102FFF",
5398         "st %r1, 4095(%r2)",
5399     ));
5400     insns.push((
5401         Inst::Store32 {
5402             rd: gpr(1),
5403             mem: MemArg::BXD20 {
5404                 base: gpr(2),
5405                 index: zero_reg(),
5406                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5407                 flags: MemFlags::trusted(),
5408             },
5409         },
5410         "E31020008050",
5411         "sty %r1, -524288(%r2)",
5412     ));
5413     insns.push((
5414         Inst::Store32 {
5415             rd: gpr(1),
5416             mem: MemArg::BXD20 {
5417                 base: gpr(2),
5418                 index: zero_reg(),
5419                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5420                 flags: MemFlags::trusted(),
5421             },
5422         },
5423         "E3102FFF7F50",
5424         "sty %r1, 524287(%r2)",
5425     ));
5426     insns.push((
5427         Inst::Store32 {
5428             rd: gpr(1),
5429             mem: MemArg::BXD12 {
5430                 base: gpr(3),
5431                 index: gpr(2),
5432                 disp: UImm12::zero(),
5433                 flags: MemFlags::trusted(),
5434             },
5435         },
5436         "50123000",
5437         "st %r1, 0(%r2,%r3)",
5438     ));
5439     insns.push((
5440         Inst::Store32 {
5441             rd: gpr(1),
5442             mem: MemArg::BXD12 {
5443                 base: gpr(3),
5444                 index: gpr(2),
5445                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5446                 flags: MemFlags::trusted(),
5447             },
5448         },
5449         "50123FFF",
5450         "st %r1, 4095(%r2,%r3)",
5451     ));
5452     insns.push((
5453         Inst::Store32 {
5454             rd: gpr(1),
5455             mem: MemArg::BXD20 {
5456                 base: gpr(3),
5457                 index: gpr(2),
5458                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5459                 flags: MemFlags::trusted(),
5460             },
5461         },
5462         "E31230008050",
5463         "sty %r1, -524288(%r2,%r3)",
5464     ));
5465     insns.push((
5466         Inst::Store32 {
5467             rd: gpr(1),
5468             mem: MemArg::BXD20 {
5469                 base: gpr(3),
5470                 index: gpr(2),
5471                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5472                 flags: MemFlags::trusted(),
5473             },
5474         },
5475         "E3123FFF7F50",
5476         "sty %r1, 524287(%r2,%r3)",
5477     ));
5478     insns.push((
5479         Inst::Store64 {
5480             rd: gpr(1),
5481             mem: MemArg::BXD12 {
5482                 base: gpr(2),
5483                 index: zero_reg(),
5484                 disp: UImm12::zero(),
5485                 flags: MemFlags::trusted(),
5486             },
5487         },
5488         "E31020000024",
5489         "stg %r1, 0(%r2)",
5490     ));
5491     insns.push((
5492         Inst::Store64 {
5493             rd: gpr(1),
5494             mem: MemArg::BXD12 {
5495                 base: gpr(2),
5496                 index: zero_reg(),
5497                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5498                 flags: MemFlags::trusted(),
5499             },
5500         },
5501         "E3102FFF0024",
5502         "stg %r1, 4095(%r2)",
5503     ));
5504     insns.push((
5505         Inst::Store64 {
5506             rd: gpr(1),
5507             mem: MemArg::BXD20 {
5508                 base: gpr(2),
5509                 index: zero_reg(),
5510                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5511                 flags: MemFlags::trusted(),
5512             },
5513         },
5514         "E31020008024",
5515         "stg %r1, -524288(%r2)",
5516     ));
5517     insns.push((
5518         Inst::Store64 {
5519             rd: gpr(1),
5520             mem: MemArg::BXD20 {
5521                 base: gpr(2),
5522                 index: zero_reg(),
5523                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5524                 flags: MemFlags::trusted(),
5525             },
5526         },
5527         "E3102FFF7F24",
5528         "stg %r1, 524287(%r2)",
5529     ));
5530     insns.push((
5531         Inst::Store64 {
5532             rd: gpr(1),
5533             mem: MemArg::BXD12 {
5534                 base: gpr(3),
5535                 index: gpr(2),
5536                 disp: UImm12::zero(),
5537                 flags: MemFlags::trusted(),
5538             },
5539         },
5540         "E31230000024",
5541         "stg %r1, 0(%r2,%r3)",
5542     ));
5543     insns.push((
5544         Inst::Store64 {
5545             rd: gpr(1),
5546             mem: MemArg::BXD12 {
5547                 base: gpr(3),
5548                 index: gpr(2),
5549                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5550                 flags: MemFlags::trusted(),
5551             },
5552         },
5553         "E3123FFF0024",
5554         "stg %r1, 4095(%r2,%r3)",
5555     ));
5556     insns.push((
5557         Inst::Store64 {
5558             rd: gpr(1),
5559             mem: MemArg::BXD20 {
5560                 base: gpr(3),
5561                 index: gpr(2),
5562                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5563                 flags: MemFlags::trusted(),
5564             },
5565         },
5566         "E31230008024",
5567         "stg %r1, -524288(%r2,%r3)",
5568     ));
5569     insns.push((
5570         Inst::Store64 {
5571             rd: gpr(1),
5572             mem: MemArg::BXD20 {
5573                 base: gpr(3),
5574                 index: gpr(2),
5575                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5576                 flags: MemFlags::trusted(),
5577             },
5578         },
5579         "E3123FFF7F24",
5580         "stg %r1, 524287(%r2,%r3)",
5581     ));
5582 
5583     insns.push((
5584         Inst::StoreImm8 {
5585             imm: 255,
5586             mem: MemArg::BXD12 {
5587                 base: gpr(2),
5588                 index: zero_reg(),
5589                 disp: UImm12::zero(),
5590                 flags: MemFlags::trusted(),
5591             },
5592         },
5593         "92FF2000",
5594         "mvi 0(%r2), 255",
5595     ));
5596     insns.push((
5597         Inst::StoreImm8 {
5598             imm: 0,
5599             mem: MemArg::BXD12 {
5600                 base: gpr(2),
5601                 index: zero_reg(),
5602                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5603                 flags: MemFlags::trusted(),
5604             },
5605         },
5606         "92002FFF",
5607         "mvi 4095(%r2), 0",
5608     ));
5609     insns.push((
5610         Inst::StoreImm8 {
5611             imm: 255,
5612             mem: MemArg::BXD20 {
5613                 base: gpr(2),
5614                 index: zero_reg(),
5615                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5616                 flags: MemFlags::trusted(),
5617             },
5618         },
5619         "EBFF20008052",
5620         "mviy -524288(%r2), 255",
5621     ));
5622     insns.push((
5623         Inst::StoreImm8 {
5624             imm: 0,
5625             mem: MemArg::BXD20 {
5626                 base: gpr(2),
5627                 index: zero_reg(),
5628                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5629                 flags: MemFlags::trusted(),
5630             },
5631         },
5632         "EB002FFF7F52",
5633         "mviy 524287(%r2), 0",
5634     ));
5635     insns.push((
5636         Inst::StoreImm16 {
5637             imm: -32768,
5638             mem: MemArg::BXD12 {
5639                 base: gpr(2),
5640                 index: zero_reg(),
5641                 disp: UImm12::zero(),
5642                 flags: MemFlags::trusted(),
5643             },
5644         },
5645         "E54420008000",
5646         "mvhhi 0(%r2), -32768",
5647     ));
5648     insns.push((
5649         Inst::StoreImm16 {
5650             imm: 32767,
5651             mem: MemArg::BXD12 {
5652                 base: gpr(2),
5653                 index: zero_reg(),
5654                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5655                 flags: MemFlags::trusted(),
5656             },
5657         },
5658         "E5442FFF7FFF",
5659         "mvhhi 4095(%r2), 32767",
5660     ));
5661     insns.push((
5662         Inst::StoreImm32SExt16 {
5663             imm: -32768,
5664             mem: MemArg::BXD12 {
5665                 base: gpr(2),
5666                 index: zero_reg(),
5667                 disp: UImm12::zero(),
5668                 flags: MemFlags::trusted(),
5669             },
5670         },
5671         "E54C20008000",
5672         "mvhi 0(%r2), -32768",
5673     ));
5674     insns.push((
5675         Inst::StoreImm32SExt16 {
5676             imm: 32767,
5677             mem: MemArg::BXD12 {
5678                 base: gpr(2),
5679                 index: zero_reg(),
5680                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5681                 flags: MemFlags::trusted(),
5682             },
5683         },
5684         "E54C2FFF7FFF",
5685         "mvhi 4095(%r2), 32767",
5686     ));
5687     insns.push((
5688         Inst::StoreImm64SExt16 {
5689             imm: -32768,
5690             mem: MemArg::BXD12 {
5691                 base: gpr(2),
5692                 index: zero_reg(),
5693                 disp: UImm12::zero(),
5694                 flags: MemFlags::trusted(),
5695             },
5696         },
5697         "E54820008000",
5698         "mvghi 0(%r2), -32768",
5699     ));
5700     insns.push((
5701         Inst::StoreImm64SExt16 {
5702             imm: 32767,
5703             mem: MemArg::BXD12 {
5704                 base: gpr(2),
5705                 index: zero_reg(),
5706                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5707                 flags: MemFlags::trusted(),
5708             },
5709         },
5710         "E5482FFF7FFF",
5711         "mvghi 4095(%r2), 32767",
5712     ));
5713 
5714     insns.push((
5715         Inst::StoreRev16 {
5716             rd: gpr(1),
5717             mem: MemArg::BXD12 {
5718                 base: gpr(2),
5719                 index: zero_reg(),
5720                 disp: UImm12::zero(),
5721                 flags: MemFlags::trusted(),
5722             },
5723         },
5724         "E3102000003F",
5725         "strvh %r1, 0(%r2)",
5726     ));
5727     insns.push((
5728         Inst::StoreRev16 {
5729             rd: gpr(1),
5730             mem: MemArg::BXD12 {
5731                 base: gpr(2),
5732                 index: zero_reg(),
5733                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5734                 flags: MemFlags::trusted(),
5735             },
5736         },
5737         "E3102FFF003F",
5738         "strvh %r1, 4095(%r2)",
5739     ));
5740     insns.push((
5741         Inst::StoreRev16 {
5742             rd: gpr(1),
5743             mem: MemArg::BXD20 {
5744                 base: gpr(2),
5745                 index: zero_reg(),
5746                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5747                 flags: MemFlags::trusted(),
5748             },
5749         },
5750         "E3102000803F",
5751         "strvh %r1, -524288(%r2)",
5752     ));
5753     insns.push((
5754         Inst::StoreRev16 {
5755             rd: gpr(1),
5756             mem: MemArg::BXD20 {
5757                 base: gpr(2),
5758                 index: zero_reg(),
5759                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5760                 flags: MemFlags::trusted(),
5761             },
5762         },
5763         "E3102FFF7F3F",
5764         "strvh %r1, 524287(%r2)",
5765     ));
5766     insns.push((
5767         Inst::StoreRev16 {
5768             rd: gpr(1),
5769             mem: MemArg::BXD12 {
5770                 base: gpr(3),
5771                 index: gpr(2),
5772                 disp: UImm12::zero(),
5773                 flags: MemFlags::trusted(),
5774             },
5775         },
5776         "E3123000003F",
5777         "strvh %r1, 0(%r2,%r3)",
5778     ));
5779     insns.push((
5780         Inst::StoreRev16 {
5781             rd: gpr(1),
5782             mem: MemArg::BXD12 {
5783                 base: gpr(3),
5784                 index: gpr(2),
5785                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5786                 flags: MemFlags::trusted(),
5787             },
5788         },
5789         "E3123FFF003F",
5790         "strvh %r1, 4095(%r2,%r3)",
5791     ));
5792     insns.push((
5793         Inst::StoreRev16 {
5794             rd: gpr(1),
5795             mem: MemArg::BXD20 {
5796                 base: gpr(3),
5797                 index: gpr(2),
5798                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5799                 flags: MemFlags::trusted(),
5800             },
5801         },
5802         "E3123000803F",
5803         "strvh %r1, -524288(%r2,%r3)",
5804     ));
5805     insns.push((
5806         Inst::StoreRev16 {
5807             rd: gpr(1),
5808             mem: MemArg::BXD20 {
5809                 base: gpr(3),
5810                 index: gpr(2),
5811                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5812                 flags: MemFlags::trusted(),
5813             },
5814         },
5815         "E3123FFF7F3F",
5816         "strvh %r1, 524287(%r2,%r3)",
5817     ));
5818     insns.push((
5819         Inst::StoreRev32 {
5820             rd: gpr(1),
5821             mem: MemArg::BXD12 {
5822                 base: gpr(2),
5823                 index: zero_reg(),
5824                 disp: UImm12::zero(),
5825                 flags: MemFlags::trusted(),
5826             },
5827         },
5828         "E3102000003E",
5829         "strv %r1, 0(%r2)",
5830     ));
5831     insns.push((
5832         Inst::StoreRev32 {
5833             rd: gpr(1),
5834             mem: MemArg::BXD12 {
5835                 base: gpr(2),
5836                 index: zero_reg(),
5837                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5838                 flags: MemFlags::trusted(),
5839             },
5840         },
5841         "E3102FFF003E",
5842         "strv %r1, 4095(%r2)",
5843     ));
5844     insns.push((
5845         Inst::StoreRev32 {
5846             rd: gpr(1),
5847             mem: MemArg::BXD20 {
5848                 base: gpr(2),
5849                 index: zero_reg(),
5850                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5851                 flags: MemFlags::trusted(),
5852             },
5853         },
5854         "E3102000803E",
5855         "strv %r1, -524288(%r2)",
5856     ));
5857     insns.push((
5858         Inst::StoreRev32 {
5859             rd: gpr(1),
5860             mem: MemArg::BXD20 {
5861                 base: gpr(2),
5862                 index: zero_reg(),
5863                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5864                 flags: MemFlags::trusted(),
5865             },
5866         },
5867         "E3102FFF7F3E",
5868         "strv %r1, 524287(%r2)",
5869     ));
5870     insns.push((
5871         Inst::StoreRev32 {
5872             rd: gpr(1),
5873             mem: MemArg::BXD12 {
5874                 base: gpr(3),
5875                 index: gpr(2),
5876                 disp: UImm12::zero(),
5877                 flags: MemFlags::trusted(),
5878             },
5879         },
5880         "E3123000003E",
5881         "strv %r1, 0(%r2,%r3)",
5882     ));
5883     insns.push((
5884         Inst::StoreRev32 {
5885             rd: gpr(1),
5886             mem: MemArg::BXD12 {
5887                 base: gpr(3),
5888                 index: gpr(2),
5889                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5890                 flags: MemFlags::trusted(),
5891             },
5892         },
5893         "E3123FFF003E",
5894         "strv %r1, 4095(%r2,%r3)",
5895     ));
5896     insns.push((
5897         Inst::StoreRev32 {
5898             rd: gpr(1),
5899             mem: MemArg::BXD20 {
5900                 base: gpr(3),
5901                 index: gpr(2),
5902                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5903                 flags: MemFlags::trusted(),
5904             },
5905         },
5906         "E3123000803E",
5907         "strv %r1, -524288(%r2,%r3)",
5908     ));
5909     insns.push((
5910         Inst::StoreRev32 {
5911             rd: gpr(1),
5912             mem: MemArg::BXD20 {
5913                 base: gpr(3),
5914                 index: gpr(2),
5915                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5916                 flags: MemFlags::trusted(),
5917             },
5918         },
5919         "E3123FFF7F3E",
5920         "strv %r1, 524287(%r2,%r3)",
5921     ));
5922     insns.push((
5923         Inst::StoreRev64 {
5924             rd: gpr(1),
5925             mem: MemArg::BXD12 {
5926                 base: gpr(2),
5927                 index: zero_reg(),
5928                 disp: UImm12::zero(),
5929                 flags: MemFlags::trusted(),
5930             },
5931         },
5932         "E3102000002F",
5933         "strvg %r1, 0(%r2)",
5934     ));
5935     insns.push((
5936         Inst::StoreRev64 {
5937             rd: gpr(1),
5938             mem: MemArg::BXD12 {
5939                 base: gpr(2),
5940                 index: zero_reg(),
5941                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5942                 flags: MemFlags::trusted(),
5943             },
5944         },
5945         "E3102FFF002F",
5946         "strvg %r1, 4095(%r2)",
5947     ));
5948     insns.push((
5949         Inst::StoreRev64 {
5950             rd: gpr(1),
5951             mem: MemArg::BXD20 {
5952                 base: gpr(2),
5953                 index: zero_reg(),
5954                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
5955                 flags: MemFlags::trusted(),
5956             },
5957         },
5958         "E3102000802F",
5959         "strvg %r1, -524288(%r2)",
5960     ));
5961     insns.push((
5962         Inst::StoreRev64 {
5963             rd: gpr(1),
5964             mem: MemArg::BXD20 {
5965                 base: gpr(2),
5966                 index: zero_reg(),
5967                 disp: SImm20::maybe_from_i64(524287).unwrap(),
5968                 flags: MemFlags::trusted(),
5969             },
5970         },
5971         "E3102FFF7F2F",
5972         "strvg %r1, 524287(%r2)",
5973     ));
5974     insns.push((
5975         Inst::StoreRev64 {
5976             rd: gpr(1),
5977             mem: MemArg::BXD12 {
5978                 base: gpr(3),
5979                 index: gpr(2),
5980                 disp: UImm12::zero(),
5981                 flags: MemFlags::trusted(),
5982             },
5983         },
5984         "E3123000002F",
5985         "strvg %r1, 0(%r2,%r3)",
5986     ));
5987     insns.push((
5988         Inst::StoreRev64 {
5989             rd: gpr(1),
5990             mem: MemArg::BXD12 {
5991                 base: gpr(3),
5992                 index: gpr(2),
5993                 disp: UImm12::maybe_from_u64(4095).unwrap(),
5994                 flags: MemFlags::trusted(),
5995             },
5996         },
5997         "E3123FFF002F",
5998         "strvg %r1, 4095(%r2,%r3)",
5999     ));
6000     insns.push((
6001         Inst::StoreRev64 {
6002             rd: gpr(1),
6003             mem: MemArg::BXD20 {
6004                 base: gpr(3),
6005                 index: gpr(2),
6006                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6007                 flags: MemFlags::trusted(),
6008             },
6009         },
6010         "E3123000802F",
6011         "strvg %r1, -524288(%r2,%r3)",
6012     ));
6013     insns.push((
6014         Inst::StoreRev64 {
6015             rd: gpr(1),
6016             mem: MemArg::BXD20 {
6017                 base: gpr(3),
6018                 index: gpr(2),
6019                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6020                 flags: MemFlags::trusted(),
6021             },
6022         },
6023         "E3123FFF7F2F",
6024         "strvg %r1, 524287(%r2,%r3)",
6025     ));
6026 
6027     insns.push((
6028         Inst::Store16 {
6029             rd: gpr(1),
6030             mem: MemArg::Label {
6031                 target: MachLabel::from_block(BlockIndex::new(1)),
6032             },
6033         },
6034         "C41700000003",
6035         "sthrl %r1, label1",
6036     ));
6037     insns.push((
6038         Inst::Store32 {
6039             rd: gpr(1),
6040             mem: MemArg::Label {
6041                 target: MachLabel::from_block(BlockIndex::new(1)),
6042             },
6043         },
6044         "C41F00000003",
6045         "strl %r1, label1",
6046     ));
6047     insns.push((
6048         Inst::Store64 {
6049             rd: gpr(1),
6050             mem: MemArg::Label {
6051                 target: MachLabel::from_block(BlockIndex::new(1)),
6052             },
6053         },
6054         "C41B00000003",
6055         "stgrl %r1, label1",
6056     ));
6057 
6058     insns.push((
6059         Inst::LoadMultiple64 {
6060             rt: writable_gpr(8),
6061             rt2: writable_gpr(12),
6062             mem: MemArg::BXD20 {
6063                 base: gpr(15),
6064                 index: zero_reg(),
6065                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6066                 flags: MemFlags::trusted(),
6067             },
6068         },
6069         "EB8CF0008004",
6070         "lmg %r8, %r12, -524288(%r15)",
6071     ));
6072     insns.push((
6073         Inst::LoadMultiple64 {
6074             rt: writable_gpr(8),
6075             rt2: writable_gpr(12),
6076             mem: MemArg::BXD20 {
6077                 base: gpr(15),
6078                 index: zero_reg(),
6079                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6080                 flags: MemFlags::trusted(),
6081             },
6082         },
6083         "EB8CFFFF7F04",
6084         "lmg %r8, %r12, 524287(%r15)",
6085     ));
6086 
6087     insns.push((
6088         Inst::StoreMultiple64 {
6089             rt: gpr(8),
6090             rt2: gpr(12),
6091             mem: MemArg::BXD20 {
6092                 base: gpr(15),
6093                 index: zero_reg(),
6094                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6095                 flags: MemFlags::trusted(),
6096             },
6097         },
6098         "EB8CF0008024",
6099         "stmg %r8, %r12, -524288(%r15)",
6100     ));
6101     insns.push((
6102         Inst::StoreMultiple64 {
6103             rt: gpr(8),
6104             rt2: gpr(12),
6105             mem: MemArg::BXD20 {
6106                 base: gpr(15),
6107                 index: zero_reg(),
6108                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6109                 flags: MemFlags::trusted(),
6110             },
6111         },
6112         "EB8CFFFF7F24",
6113         "stmg %r8, %r12, 524287(%r15)",
6114     ));
6115 
6116     insns.push((
6117         Inst::LoadAddr {
6118             rd: writable_gpr(1),
6119             mem: MemArg::BXD12 {
6120                 base: zero_reg(),
6121                 index: zero_reg(),
6122                 disp: UImm12::zero(),
6123                 flags: MemFlags::trusted(),
6124             },
6125         },
6126         "41100000",
6127         "la %r1, 0",
6128     ));
6129     insns.push((
6130         Inst::LoadAddr {
6131             rd: writable_gpr(1),
6132             mem: MemArg::BXD12 {
6133                 base: zero_reg(),
6134                 index: zero_reg(),
6135                 disp: UImm12::maybe_from_u64(4095).unwrap(),
6136                 flags: MemFlags::trusted(),
6137             },
6138         },
6139         "41100FFF",
6140         "la %r1, 4095",
6141     ));
6142     insns.push((
6143         Inst::LoadAddr {
6144             rd: writable_gpr(1),
6145             mem: MemArg::BXD20 {
6146                 base: zero_reg(),
6147                 index: zero_reg(),
6148                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6149                 flags: MemFlags::trusted(),
6150             },
6151         },
6152         "E31000008071",
6153         "lay %r1, -524288",
6154     ));
6155     insns.push((
6156         Inst::LoadAddr {
6157             rd: writable_gpr(1),
6158             mem: MemArg::BXD20 {
6159                 base: zero_reg(),
6160                 index: zero_reg(),
6161                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6162                 flags: MemFlags::trusted(),
6163             },
6164         },
6165         "E3100FFF7F71",
6166         "lay %r1, 524287",
6167     ));
6168     insns.push((
6169         Inst::LoadAddr {
6170             rd: writable_gpr(1),
6171             mem: MemArg::BXD12 {
6172                 base: gpr(2),
6173                 index: zero_reg(),
6174                 disp: UImm12::zero(),
6175                 flags: MemFlags::trusted(),
6176             },
6177         },
6178         "41102000",
6179         "la %r1, 0(%r2)",
6180     ));
6181     insns.push((
6182         Inst::LoadAddr {
6183             rd: writable_gpr(1),
6184             mem: MemArg::BXD12 {
6185                 base: gpr(2),
6186                 index: zero_reg(),
6187                 disp: UImm12::maybe_from_u64(4095).unwrap(),
6188                 flags: MemFlags::trusted(),
6189             },
6190         },
6191         "41102FFF",
6192         "la %r1, 4095(%r2)",
6193     ));
6194     insns.push((
6195         Inst::LoadAddr {
6196             rd: writable_gpr(1),
6197             mem: MemArg::BXD20 {
6198                 base: gpr(2),
6199                 index: zero_reg(),
6200                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6201                 flags: MemFlags::trusted(),
6202             },
6203         },
6204         "E31020008071",
6205         "lay %r1, -524288(%r2)",
6206     ));
6207     insns.push((
6208         Inst::LoadAddr {
6209             rd: writable_gpr(1),
6210             mem: MemArg::BXD20 {
6211                 base: gpr(2),
6212                 index: zero_reg(),
6213                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6214                 flags: MemFlags::trusted(),
6215             },
6216         },
6217         "E3102FFF7F71",
6218         "lay %r1, 524287(%r2)",
6219     ));
6220     insns.push((
6221         Inst::LoadAddr {
6222             rd: writable_gpr(1),
6223             mem: MemArg::BXD12 {
6224                 base: gpr(3),
6225                 index: gpr(2),
6226                 disp: UImm12::zero(),
6227                 flags: MemFlags::trusted(),
6228             },
6229         },
6230         "41123000",
6231         "la %r1, 0(%r2,%r3)",
6232     ));
6233     insns.push((
6234         Inst::LoadAddr {
6235             rd: writable_gpr(1),
6236             mem: MemArg::BXD12 {
6237                 base: gpr(3),
6238                 index: gpr(2),
6239                 disp: UImm12::maybe_from_u64(4095).unwrap(),
6240                 flags: MemFlags::trusted(),
6241             },
6242         },
6243         "41123FFF",
6244         "la %r1, 4095(%r2,%r3)",
6245     ));
6246     insns.push((
6247         Inst::LoadAddr {
6248             rd: writable_gpr(1),
6249             mem: MemArg::BXD20 {
6250                 base: gpr(3),
6251                 index: gpr(2),
6252                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
6253                 flags: MemFlags::trusted(),
6254             },
6255         },
6256         "E31230008071",
6257         "lay %r1, -524288(%r2,%r3)",
6258     ));
6259     insns.push((
6260         Inst::LoadAddr {
6261             rd: writable_gpr(1),
6262             mem: MemArg::BXD20 {
6263                 base: gpr(3),
6264                 index: gpr(2),
6265                 disp: SImm20::maybe_from_i64(524287).unwrap(),
6266                 flags: MemFlags::trusted(),
6267             },
6268         },
6269         "E3123FFF7F71",
6270         "lay %r1, 524287(%r2,%r3)",
6271     ));
6272     insns.push((
6273         Inst::LoadAddr {
6274             rd: writable_gpr(1),
6275             mem: MemArg::Label {
6276                 target: MachLabel::from_block(BlockIndex::new(1)),
6277             },
6278         },
6279         "C01000000003",
6280         "larl %r1, label1",
6281     ));
6282     insns.push((
6283         Inst::LoadAddr {
6284             rd: writable_gpr(1),
6285             mem: MemArg::Symbol {
6286                 name: Box::new(ExternalName::testcase("test0")),
6287                 offset: 64,
6288                 flags: MemFlags::trusted(),
6289             },
6290         },
6291         "C01000000000",
6292         "larl %r1, %test0 + 64",
6293     ));
6294 
6295     insns.push((
6296         Inst::LoadAddr {
6297             rd: writable_gpr(1),
6298             mem: MemArg::RegOffset {
6299                 reg: gpr(2),
6300                 off: 0,
6301                 flags: MemFlags::trusted(),
6302             },
6303         },
6304         "41102000",
6305         "la %r1, 0(%r2)",
6306     ));
6307     insns.push((
6308         Inst::LoadAddr {
6309             rd: writable_gpr(1),
6310             mem: MemArg::RegOffset {
6311                 reg: gpr(2),
6312                 off: 4095,
6313                 flags: MemFlags::trusted(),
6314             },
6315         },
6316         "41102FFF",
6317         "la %r1, 4095(%r2)",
6318     ));
6319     insns.push((
6320         Inst::LoadAddr {
6321             rd: writable_gpr(1),
6322             mem: MemArg::RegOffset {
6323                 reg: gpr(2),
6324                 off: -524288,
6325                 flags: MemFlags::trusted(),
6326             },
6327         },
6328         "E31020008071",
6329         "lay %r1, -524288(%r2)",
6330     ));
6331     insns.push((
6332         Inst::LoadAddr {
6333             rd: writable_gpr(1),
6334             mem: MemArg::RegOffset {
6335                 reg: gpr(2),
6336                 off: 524287,
6337                 flags: MemFlags::trusted(),
6338             },
6339         },
6340         "E3102FFF7F71",
6341         "lay %r1, 524287(%r2)",
6342     ));
6343     insns.push((
6344         Inst::LoadAddr {
6345             rd: writable_gpr(1),
6346             mem: MemArg::RegOffset {
6347                 reg: gpr(2),
6348                 off: -2147483648,
6349                 flags: MemFlags::trusted(),
6350             },
6351         },
6352         "C0118000000041112000",
6353         "lgfi %r1, -2147483648 ; la %r1, 0(%r1,%r2)",
6354     ));
6355     insns.push((
6356         Inst::LoadAddr {
6357             rd: writable_gpr(1),
6358             mem: MemArg::RegOffset {
6359                 reg: gpr(2),
6360                 off: 2147483647,
6361                 flags: MemFlags::trusted(),
6362             },
6363         },
6364         "C0117FFFFFFF41112000",
6365         "lgfi %r1, 2147483647 ; la %r1, 0(%r1,%r2)",
6366     ));
6367 
6368     insns.push((
6369         Inst::Mov64 {
6370             rd: writable_gpr(8),
6371             rm: gpr(9),
6372         },
6373         "B9040089",
6374         "lgr %r8, %r9",
6375     ));
6376     insns.push((
6377         Inst::Mov32 {
6378             rd: writable_gpr(8),
6379             rm: gpr(9),
6380         },
6381         "1889",
6382         "lr %r8, %r9",
6383     ));
6384 
6385     insns.push((
6386         Inst::Mov32SImm16 {
6387             rd: writable_gpr(8),
6388             imm: -32768,
6389         },
6390         "A7888000",
6391         "lhi %r8, -32768",
6392     ));
6393     insns.push((
6394         Inst::Mov32SImm16 {
6395             rd: writable_gpr(8),
6396             imm: 32767,
6397         },
6398         "A7887FFF",
6399         "lhi %r8, 32767",
6400     ));
6401     insns.push((
6402         Inst::Mov32Imm {
6403             rd: writable_gpr(8),
6404             imm: 2147483648,
6405         },
6406         "C08980000000",
6407         "iilf %r8, 2147483648",
6408     ));
6409     insns.push((
6410         Inst::Mov32Imm {
6411             rd: writable_gpr(8),
6412             imm: 2147483647,
6413         },
6414         "C0897FFFFFFF",
6415         "iilf %r8, 2147483647",
6416     ));
6417     insns.push((
6418         Inst::Mov64SImm16 {
6419             rd: writable_gpr(8),
6420             imm: -32768,
6421         },
6422         "A7898000",
6423         "lghi %r8, -32768",
6424     ));
6425     insns.push((
6426         Inst::Mov64SImm16 {
6427             rd: writable_gpr(8),
6428             imm: 32767,
6429         },
6430         "A7897FFF",
6431         "lghi %r8, 32767",
6432     ));
6433     insns.push((
6434         Inst::Mov64SImm32 {
6435             rd: writable_gpr(8),
6436             imm: -2147483648,
6437         },
6438         "C08180000000",
6439         "lgfi %r8, -2147483648",
6440     ));
6441     insns.push((
6442         Inst::Mov64SImm32 {
6443             rd: writable_gpr(8),
6444             imm: 2147483647,
6445         },
6446         "C0817FFFFFFF",
6447         "lgfi %r8, 2147483647",
6448     ));
6449     insns.push((
6450         Inst::Mov64UImm16Shifted {
6451             rd: writable_gpr(8),
6452             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_0000_ffff).unwrap(),
6453         },
6454         "A58FFFFF",
6455         "llill %r8, 65535",
6456     ));
6457     insns.push((
6458         Inst::Mov64UImm16Shifted {
6459             rd: writable_gpr(8),
6460             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_ffff_0000).unwrap(),
6461         },
6462         "A58EFFFF",
6463         "llilh %r8, 65535",
6464     ));
6465     insns.push((
6466         Inst::Mov64UImm16Shifted {
6467             rd: writable_gpr(8),
6468             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff_0000_0000).unwrap(),
6469         },
6470         "A58DFFFF",
6471         "llihl %r8, 65535",
6472     ));
6473     insns.push((
6474         Inst::Mov64UImm16Shifted {
6475             rd: writable_gpr(8),
6476             imm: UImm16Shifted::maybe_from_u64(0xffff_0000_0000_0000).unwrap(),
6477         },
6478         "A58CFFFF",
6479         "llihh %r8, 65535",
6480     ));
6481     insns.push((
6482         Inst::Mov64UImm32Shifted {
6483             rd: writable_gpr(8),
6484             imm: UImm32Shifted::maybe_from_u64(0x0000_0000_ffff_ffff).unwrap(),
6485         },
6486         "C08FFFFFFFFF",
6487         "llilf %r8, 4294967295",
6488     ));
6489     insns.push((
6490         Inst::Mov64UImm32Shifted {
6491             rd: writable_gpr(8),
6492             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff_0000_0000).unwrap(),
6493         },
6494         "C08EFFFFFFFF",
6495         "llihf %r8, 4294967295",
6496     ));
6497 
6498     insns.push((
6499         Inst::Insert64UImm16Shifted {
6500             rd: writable_gpr(8),
6501             ri: gpr(8),
6502             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_0000_ffff).unwrap(),
6503         },
6504         "A583FFFF",
6505         "iill %r8, 65535",
6506     ));
6507     insns.push((
6508         Inst::Insert64UImm16Shifted {
6509             rd: writable_gpr(8),
6510             ri: gpr(8),
6511             imm: UImm16Shifted::maybe_from_u64(0x0000_0000_ffff_0000).unwrap(),
6512         },
6513         "A582FFFF",
6514         "iilh %r8, 65535",
6515     ));
6516     insns.push((
6517         Inst::Insert64UImm16Shifted {
6518             rd: writable_gpr(8),
6519             ri: gpr(8),
6520             imm: UImm16Shifted::maybe_from_u64(0x0000_ffff_0000_0000).unwrap(),
6521         },
6522         "A581FFFF",
6523         "iihl %r8, 65535",
6524     ));
6525     insns.push((
6526         Inst::Insert64UImm16Shifted {
6527             rd: writable_gpr(8),
6528             ri: gpr(8),
6529             imm: UImm16Shifted::maybe_from_u64(0xffff_0000_0000_0000).unwrap(),
6530         },
6531         "A580FFFF",
6532         "iihh %r8, 65535",
6533     ));
6534     insns.push((
6535         Inst::Insert64UImm32Shifted {
6536             rd: writable_gpr(8),
6537             ri: gpr(8),
6538             imm: UImm32Shifted::maybe_from_u64(0x0000_0000_ffff_ffff).unwrap(),
6539         },
6540         "C089FFFFFFFF",
6541         "iilf %r8, 4294967295",
6542     ));
6543     insns.push((
6544         Inst::Insert64UImm32Shifted {
6545             rd: writable_gpr(8),
6546             ri: gpr(8),
6547             imm: UImm32Shifted::maybe_from_u64(0xffff_ffff_0000_0000).unwrap(),
6548         },
6549         "C088FFFFFFFF",
6550         "iihf %r8, 4294967295",
6551     ));
6552 
6553     insns.push((
6554         Inst::CMov32 {
6555             rd: writable_gpr(8),
6556             cond: Cond::from_mask(1),
6557             ri: gpr(8),
6558             rm: gpr(9),
6559         },
6560         "B9F21089",
6561         "locro %r8, %r9",
6562     ));
6563     insns.push((
6564         Inst::CMov64 {
6565             rd: writable_gpr(8),
6566             cond: Cond::from_mask(1),
6567             ri: gpr(8),
6568             rm: gpr(9),
6569         },
6570         "B9E21089",
6571         "locgro %r8, %r9",
6572     ));
6573 
6574     insns.push((
6575         Inst::CMov32SImm16 {
6576             rd: writable_gpr(8),
6577             cond: Cond::from_mask(1),
6578             imm: -32768,
6579             ri: gpr(8),
6580         },
6581         "EC8180000042",
6582         "lochio %r8, -32768",
6583     ));
6584     insns.push((
6585         Inst::CMov32SImm16 {
6586             rd: writable_gpr(8),
6587             cond: Cond::from_mask(1),
6588             imm: 32767,
6589             ri: gpr(8),
6590         },
6591         "EC817FFF0042",
6592         "lochio %r8, 32767",
6593     ));
6594     insns.push((
6595         Inst::CMov64SImm16 {
6596             rd: writable_gpr(8),
6597             cond: Cond::from_mask(1),
6598             imm: -32768,
6599             ri: gpr(8),
6600         },
6601         "EC8180000046",
6602         "locghio %r8, -32768",
6603     ));
6604     insns.push((
6605         Inst::CMov64SImm16 {
6606             rd: writable_gpr(8),
6607             cond: Cond::from_mask(1),
6608             imm: 32767,
6609             ri: gpr(8),
6610         },
6611         "EC817FFF0046",
6612         "locghio %r8, 32767",
6613     ));
6614 
6615     insns.push((
6616         Inst::Extend {
6617             rd: writable_gpr(1),
6618             rn: gpr(2),
6619             signed: false,
6620             from_bits: 8,
6621             to_bits: 32,
6622         },
6623         "B9940012",
6624         "llcr %r1, %r2",
6625     ));
6626     insns.push((
6627         Inst::Extend {
6628             rd: writable_gpr(1),
6629             rn: gpr(2),
6630             signed: true,
6631             from_bits: 8,
6632             to_bits: 32,
6633         },
6634         "B9260012",
6635         "lbr %r1, %r2",
6636     ));
6637     insns.push((
6638         Inst::Extend {
6639             rd: writable_gpr(1),
6640             rn: gpr(2),
6641             signed: false,
6642             from_bits: 16,
6643             to_bits: 32,
6644         },
6645         "B9950012",
6646         "llhr %r1, %r2",
6647     ));
6648     insns.push((
6649         Inst::Extend {
6650             rd: writable_gpr(1),
6651             rn: gpr(2),
6652             signed: true,
6653             from_bits: 16,
6654             to_bits: 32,
6655         },
6656         "B9270012",
6657         "lhr %r1, %r2",
6658     ));
6659     insns.push((
6660         Inst::Extend {
6661             rd: writable_gpr(1),
6662             rn: gpr(2),
6663             signed: false,
6664             from_bits: 8,
6665             to_bits: 64,
6666         },
6667         "B9840012",
6668         "llgcr %r1, %r2",
6669     ));
6670     insns.push((
6671         Inst::Extend {
6672             rd: writable_gpr(1),
6673             rn: gpr(2),
6674             signed: true,
6675             from_bits: 8,
6676             to_bits: 64,
6677         },
6678         "B9060012",
6679         "lgbr %r1, %r2",
6680     ));
6681     insns.push((
6682         Inst::Extend {
6683             rd: writable_gpr(1),
6684             rn: gpr(2),
6685             signed: false,
6686             from_bits: 16,
6687             to_bits: 64,
6688         },
6689         "B9850012",
6690         "llghr %r1, %r2",
6691     ));
6692     insns.push((
6693         Inst::Extend {
6694             rd: writable_gpr(1),
6695             rn: gpr(2),
6696             signed: true,
6697             from_bits: 16,
6698             to_bits: 64,
6699         },
6700         "B9070012",
6701         "lghr %r1, %r2",
6702     ));
6703     insns.push((
6704         Inst::Extend {
6705             rd: writable_gpr(1),
6706             rn: gpr(2),
6707             signed: false,
6708             from_bits: 32,
6709             to_bits: 64,
6710         },
6711         "B9160012",
6712         "llgfr %r1, %r2",
6713     ));
6714     insns.push((
6715         Inst::Extend {
6716             rd: writable_gpr(1),
6717             rn: gpr(2),
6718             signed: true,
6719             from_bits: 32,
6720             to_bits: 64,
6721         },
6722         "B9140012",
6723         "lgfr %r1, %r2",
6724     ));
6725 
6726     insns.push((
6727         Inst::Jump {
6728             dest: MachLabel::from_block(BlockIndex::new(0)),
6729         },
6730         "C0F400000000",
6731         "jg label0",
6732     ));
6733 
6734     insns.push((
6735         Inst::CondBr {
6736             taken: MachLabel::from_block(BlockIndex::new(0)),
6737             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6738             cond: Cond::from_mask(1),
6739         },
6740         "C01400000000C0F4FFFFFFFD",
6741         "jgo label0 ; jg label0",
6742     ));
6743     insns.push((
6744         Inst::CondBr {
6745             taken: MachLabel::from_block(BlockIndex::new(0)),
6746             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6747             cond: Cond::from_mask(2),
6748         },
6749         "C02400000000C0F4FFFFFFFD",
6750         "jgh label0 ; jg label0",
6751     ));
6752     insns.push((
6753         Inst::CondBr {
6754             taken: MachLabel::from_block(BlockIndex::new(0)),
6755             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6756             cond: Cond::from_mask(3),
6757         },
6758         "C03400000000C0F4FFFFFFFD",
6759         "jgnle label0 ; jg label0",
6760     ));
6761     insns.push((
6762         Inst::CondBr {
6763             taken: MachLabel::from_block(BlockIndex::new(0)),
6764             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6765             cond: Cond::from_mask(4),
6766         },
6767         "C04400000000C0F4FFFFFFFD",
6768         "jgl label0 ; jg label0",
6769     ));
6770     insns.push((
6771         Inst::CondBr {
6772             taken: MachLabel::from_block(BlockIndex::new(0)),
6773             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6774             cond: Cond::from_mask(5),
6775         },
6776         "C05400000000C0F4FFFFFFFD",
6777         "jgnhe label0 ; jg label0",
6778     ));
6779     insns.push((
6780         Inst::CondBr {
6781             taken: MachLabel::from_block(BlockIndex::new(0)),
6782             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6783             cond: Cond::from_mask(6),
6784         },
6785         "C06400000000C0F4FFFFFFFD",
6786         "jglh label0 ; jg label0",
6787     ));
6788     insns.push((
6789         Inst::CondBr {
6790             taken: MachLabel::from_block(BlockIndex::new(0)),
6791             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6792             cond: Cond::from_mask(7),
6793         },
6794         "C07400000000C0F4FFFFFFFD",
6795         "jgne label0 ; jg label0",
6796     ));
6797     insns.push((
6798         Inst::CondBr {
6799             taken: MachLabel::from_block(BlockIndex::new(0)),
6800             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6801             cond: Cond::from_mask(8),
6802         },
6803         "C08400000000C0F4FFFFFFFD",
6804         "jge label0 ; jg label0",
6805     ));
6806     insns.push((
6807         Inst::CondBr {
6808             taken: MachLabel::from_block(BlockIndex::new(0)),
6809             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6810             cond: Cond::from_mask(9),
6811         },
6812         "C09400000000C0F4FFFFFFFD",
6813         "jgnlh label0 ; jg label0",
6814     ));
6815     insns.push((
6816         Inst::CondBr {
6817             taken: MachLabel::from_block(BlockIndex::new(0)),
6818             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6819             cond: Cond::from_mask(10),
6820         },
6821         "C0A400000000C0F4FFFFFFFD",
6822         "jghe label0 ; jg label0",
6823     ));
6824     insns.push((
6825         Inst::CondBr {
6826             taken: MachLabel::from_block(BlockIndex::new(0)),
6827             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6828             cond: Cond::from_mask(11),
6829         },
6830         "C0B400000000C0F4FFFFFFFD",
6831         "jgnl label0 ; jg label0",
6832     ));
6833     insns.push((
6834         Inst::CondBr {
6835             taken: MachLabel::from_block(BlockIndex::new(0)),
6836             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6837             cond: Cond::from_mask(12),
6838         },
6839         "C0C400000000C0F4FFFFFFFD",
6840         "jgle label0 ; jg label0",
6841     ));
6842     insns.push((
6843         Inst::CondBr {
6844             taken: MachLabel::from_block(BlockIndex::new(0)),
6845             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6846             cond: Cond::from_mask(13),
6847         },
6848         "C0D400000000C0F4FFFFFFFD",
6849         "jgnh label0 ; jg label0",
6850     ));
6851     insns.push((
6852         Inst::CondBr {
6853             taken: MachLabel::from_block(BlockIndex::new(0)),
6854             not_taken: MachLabel::from_block(BlockIndex::new(0)),
6855             cond: Cond::from_mask(14),
6856         },
6857         "C0E400000000C0F4FFFFFFFD",
6858         "jgno label0 ; jg label0",
6859     ));
6860 
6861     insns.push((
6862         Inst::IndirectBr {
6863             rn: gpr(3),
6864             targets: vec![],
6865         },
6866         "07F3",
6867         "br %r3",
6868     ));
6869 
6870     insns.push((
6871         Inst::Call {
6872             link: writable_gpr(14),
6873             info: Box::new(CallInfo::empty(
6874                 CallInstDest::Direct {
6875                     name: ExternalName::testcase("test0"),
6876                 },
6877                 CallConv::SystemV,
6878             )),
6879         },
6880         "C0E500000000",
6881         "brasl %r14, %test0",
6882     ));
6883 
6884     insns.push((
6885         Inst::Call {
6886             link: writable_gpr(14),
6887             info: Box::new(CallInfo::empty(
6888                 CallInstDest::Indirect { reg: gpr(1) },
6889                 CallConv::SystemV,
6890             )),
6891         },
6892         "0DE1",
6893         "basr %r14, %r1",
6894     ));
6895 
6896     insns.push((Inst::Ret { link: gpr(14) }, "07FE", "br %r14"));
6897 
6898     insns.push((Inst::Debugtrap, "0001", ".word 0x0001 # debugtrap"));
6899 
6900     insns.push((
6901         Inst::Trap {
6902             trap_code: TrapCode::STACK_OVERFLOW,
6903         },
6904         "0000",
6905         ".word 0x0000 # trap=stk_ovf",
6906     ));
6907     insns.push((
6908         Inst::TrapIf {
6909             cond: Cond::from_mask(1),
6910             trap_code: TrapCode::STACK_OVERFLOW,
6911         },
6912         "C01400000001",
6913         "jgo .+2 # trap=stk_ovf",
6914     ));
6915 
6916     insns.push((
6917         Inst::Loop {
6918             body: vec![
6919                 Inst::CmpRR {
6920                     op: CmpOp::CmpS32,
6921                     rn: gpr(2),
6922                     rm: gpr(3),
6923                 },
6924                 Inst::CondBreak {
6925                     cond: Cond::from_mask(13),
6926                 },
6927                 Inst::AtomicCas32 {
6928                     rd: writable_gpr(4),
6929                     ri: gpr(4),
6930                     rn: gpr(5),
6931                     mem: MemArg::BXD12 {
6932                         base: gpr(6),
6933                         index: zero_reg(),
6934                         disp: UImm12::maybe_from_u64(0).unwrap(),
6935                         flags: MemFlags::trusted(),
6936                     },
6937                 },
6938             ],
6939             cond: Cond::from_mask(6),
6940         },
6941         "1923C0D400000008BA456000C064FFFFFFFA",
6942         "0: cr %r2, %r3 ; jgnh 1f ; cs %r4, %r5, 0(%r6) ; jglh 0b ; 1:",
6943     ));
6944 
6945     insns.push((
6946         Inst::StackProbeLoop {
6947             probe_count: writable_gpr(1),
6948             guard_size: 4096,
6949         },
6950         "A7FBF0009200F000A716FFFC",
6951         "0: aghi %r15, -4096 ; mvi 0(%r15), 0 ; brct %r1, 0b",
6952     ));
6953 
6954     insns.push((
6955         Inst::FpuMove32 {
6956             rd: writable_vr(8),
6957             rn: vr(4),
6958         },
6959         "3884",
6960         "ler %f8, %f4",
6961     ));
6962     insns.push((
6963         Inst::FpuMove32 {
6964             rd: writable_vr(8),
6965             rn: vr(20),
6966         },
6967         "E78400000456",
6968         "vlr %v8, %v20",
6969     ));
6970     insns.push((
6971         Inst::FpuMove64 {
6972             rd: writable_vr(8),
6973             rn: vr(4),
6974         },
6975         "2884",
6976         "ldr %f8, %f4",
6977     ));
6978     insns.push((
6979         Inst::FpuMove64 {
6980             rd: writable_vr(8),
6981             rn: vr(20),
6982         },
6983         "E78400000456",
6984         "vlr %v8, %v20",
6985     ));
6986     insns.push((
6987         Inst::FpuCMov32 {
6988             rd: writable_vr(8),
6989             ri: vr(8),
6990             rm: vr(4),
6991             cond: Cond::from_mask(1),
6992         },
6993         "A7E400033884",
6994         "jno 6 ; ler %f8, %f4",
6995     ));
6996     insns.push((
6997         Inst::FpuCMov32 {
6998             rd: writable_vr(8),
6999             ri: vr(8),
7000             rm: vr(20),
7001             cond: Cond::from_mask(1),
7002         },
7003         "A7E40005E78400000456",
7004         "jno 10 ; vlr %v8, %v20",
7005     ));
7006     insns.push((
7007         Inst::FpuCMov64 {
7008             rd: writable_vr(8),
7009             ri: vr(8),
7010             rm: vr(4),
7011             cond: Cond::from_mask(1),
7012         },
7013         "A7E400032884",
7014         "jno 6 ; ldr %f8, %f4",
7015     ));
7016     insns.push((
7017         Inst::FpuCMov64 {
7018             rd: writable_vr(8),
7019             ri: vr(8),
7020             rm: vr(20),
7021             cond: Cond::from_mask(1),
7022         },
7023         "A7E40005E78400000456",
7024         "jno 10 ; vlr %v8, %v20",
7025     ));
7026 
7027     insns.push((
7028         Inst::FpuRR {
7029             fpu_op: FPUOp1::Abs32,
7030             rd: writable_vr(8),
7031             rn: vr(12),
7032         },
7033         "B300008C",
7034         "lpebr %f8, %f12",
7035     ));
7036     insns.push((
7037         Inst::FpuRR {
7038             fpu_op: FPUOp1::Abs32,
7039             rd: writable_vr(24),
7040             rn: vr(12),
7041         },
7042         "E78C002828CC",
7043         "wflpsb %v24, %f12",
7044     ));
7045     insns.push((
7046         Inst::FpuRR {
7047             fpu_op: FPUOp1::Abs32x4,
7048             rd: writable_vr(24),
7049             rn: vr(12),
7050         },
7051         "E78C002028CC",
7052         "vflpsb %v24, %v12",
7053     ));
7054     insns.push((
7055         Inst::FpuRR {
7056             fpu_op: FPUOp1::Abs64,
7057             rd: writable_vr(8),
7058             rn: vr(12),
7059         },
7060         "B310008C",
7061         "lpdbr %f8, %f12",
7062     ));
7063     insns.push((
7064         Inst::FpuRR {
7065             fpu_op: FPUOp1::Abs64,
7066             rd: writable_vr(24),
7067             rn: vr(12),
7068         },
7069         "E78C002838CC",
7070         "wflpdb %v24, %f12",
7071     ));
7072     insns.push((
7073         Inst::FpuRR {
7074             fpu_op: FPUOp1::Abs64x2,
7075             rd: writable_vr(24),
7076             rn: vr(12),
7077         },
7078         "E78C002038CC",
7079         "vflpdb %v24, %v12",
7080     ));
7081     insns.push((
7082         Inst::FpuRR {
7083             fpu_op: FPUOp1::Abs128,
7084             rd: writable_vr(24),
7085             rn: vr(12),
7086         },
7087         "E78C002848CC",
7088         "wflpxb %v24, %f12",
7089     ));
7090     insns.push((
7091         Inst::FpuRR {
7092             fpu_op: FPUOp1::Neg32,
7093             rd: writable_vr(8),
7094             rn: vr(12),
7095         },
7096         "B303008C",
7097         "lcebr %f8, %f12",
7098     ));
7099     insns.push((
7100         Inst::FpuRR {
7101             fpu_op: FPUOp1::Neg32,
7102             rd: writable_vr(24),
7103             rn: vr(12),
7104         },
7105         "E78C000828CC",
7106         "wflcsb %v24, %f12",
7107     ));
7108     insns.push((
7109         Inst::FpuRR {
7110             fpu_op: FPUOp1::Neg32x4,
7111             rd: writable_vr(24),
7112             rn: vr(12),
7113         },
7114         "E78C000028CC",
7115         "vflcsb %v24, %v12",
7116     ));
7117     insns.push((
7118         Inst::FpuRR {
7119             fpu_op: FPUOp1::Neg64,
7120             rd: writable_vr(8),
7121             rn: vr(12),
7122         },
7123         "B313008C",
7124         "lcdbr %f8, %f12",
7125     ));
7126     insns.push((
7127         Inst::FpuRR {
7128             fpu_op: FPUOp1::Neg64,
7129             rd: writable_vr(24),
7130             rn: vr(12),
7131         },
7132         "E78C000838CC",
7133         "wflcdb %v24, %f12",
7134     ));
7135     insns.push((
7136         Inst::FpuRR {
7137             fpu_op: FPUOp1::Neg64x2,
7138             rd: writable_vr(24),
7139             rn: vr(12),
7140         },
7141         "E78C000038CC",
7142         "vflcdb %v24, %v12",
7143     ));
7144     insns.push((
7145         Inst::FpuRR {
7146             fpu_op: FPUOp1::Neg128,
7147             rd: writable_vr(24),
7148             rn: vr(12),
7149         },
7150         "E78C000848CC",
7151         "wflcxb %v24, %f12",
7152     ));
7153     insns.push((
7154         Inst::FpuRR {
7155             fpu_op: FPUOp1::NegAbs32,
7156             rd: writable_vr(8),
7157             rn: vr(12),
7158         },
7159         "B301008C",
7160         "lnebr %f8, %f12",
7161     ));
7162     insns.push((
7163         Inst::FpuRR {
7164             fpu_op: FPUOp1::NegAbs32,
7165             rd: writable_vr(24),
7166             rn: vr(12),
7167         },
7168         "E78C001828CC",
7169         "wflnsb %v24, %f12",
7170     ));
7171     insns.push((
7172         Inst::FpuRR {
7173             fpu_op: FPUOp1::NegAbs32x4,
7174             rd: writable_vr(24),
7175             rn: vr(12),
7176         },
7177         "E78C001028CC",
7178         "vflnsb %v24, %v12",
7179     ));
7180     insns.push((
7181         Inst::FpuRR {
7182             fpu_op: FPUOp1::NegAbs64,
7183             rd: writable_vr(8),
7184             rn: vr(12),
7185         },
7186         "B311008C",
7187         "lndbr %f8, %f12",
7188     ));
7189     insns.push((
7190         Inst::FpuRR {
7191             fpu_op: FPUOp1::NegAbs64,
7192             rd: writable_vr(24),
7193             rn: vr(12),
7194         },
7195         "E78C001838CC",
7196         "wflndb %v24, %f12",
7197     ));
7198     insns.push((
7199         Inst::FpuRR {
7200             fpu_op: FPUOp1::NegAbs64x2,
7201             rd: writable_vr(24),
7202             rn: vr(12),
7203         },
7204         "E78C001038CC",
7205         "vflndb %v24, %v12",
7206     ));
7207     insns.push((
7208         Inst::FpuRR {
7209             fpu_op: FPUOp1::NegAbs128,
7210             rd: writable_vr(24),
7211             rn: vr(12),
7212         },
7213         "E78C001848CC",
7214         "wflnxb %v24, %f12",
7215     ));
7216     insns.push((
7217         Inst::FpuRR {
7218             fpu_op: FPUOp1::Sqrt32,
7219             rd: writable_vr(8),
7220             rn: vr(12),
7221         },
7222         "B314008C",
7223         "sqebr %f8, %f12",
7224     ));
7225     insns.push((
7226         Inst::FpuRR {
7227             fpu_op: FPUOp1::Sqrt32,
7228             rd: writable_vr(24),
7229             rn: vr(12),
7230         },
7231         "E78C000828CE",
7232         "wfsqsb %v24, %f12",
7233     ));
7234     insns.push((
7235         Inst::FpuRR {
7236             fpu_op: FPUOp1::Sqrt32x4,
7237             rd: writable_vr(24),
7238             rn: vr(12),
7239         },
7240         "E78C000028CE",
7241         "vfsqsb %v24, %v12",
7242     ));
7243     insns.push((
7244         Inst::FpuRR {
7245             fpu_op: FPUOp1::Sqrt64,
7246             rd: writable_vr(8),
7247             rn: vr(12),
7248         },
7249         "B315008C",
7250         "sqdbr %f8, %f12",
7251     ));
7252     insns.push((
7253         Inst::FpuRR {
7254             fpu_op: FPUOp1::Sqrt64,
7255             rd: writable_vr(24),
7256             rn: vr(12),
7257         },
7258         "E78C000838CE",
7259         "wfsqdb %v24, %f12",
7260     ));
7261     insns.push((
7262         Inst::FpuRR {
7263             fpu_op: FPUOp1::Sqrt64x2,
7264             rd: writable_vr(24),
7265             rn: vr(12),
7266         },
7267         "E78C000038CE",
7268         "vfsqdb %v24, %v12",
7269     ));
7270     insns.push((
7271         Inst::FpuRR {
7272             fpu_op: FPUOp1::Sqrt128,
7273             rd: writable_vr(24),
7274             rn: vr(12),
7275         },
7276         "E78C000848CE",
7277         "wfsqxb %v24, %f12",
7278     ));
7279     insns.push((
7280         Inst::FpuRR {
7281             fpu_op: FPUOp1::Cvt32To64,
7282             rd: writable_vr(8),
7283             rn: vr(12),
7284         },
7285         "B304008C",
7286         "ldebr %f8, %f12",
7287     ));
7288     insns.push((
7289         Inst::FpuRR {
7290             fpu_op: FPUOp1::Cvt32To64,
7291             rd: writable_vr(24),
7292             rn: vr(12),
7293         },
7294         "E78C000828C4",
7295         "wldeb %v24, %f12",
7296     ));
7297     insns.push((
7298         Inst::FpuRR {
7299             fpu_op: FPUOp1::Cvt32x4To64x2,
7300             rd: writable_vr(24),
7301             rn: vr(12),
7302         },
7303         "E78C000028C4",
7304         "vldeb %v24, %v12",
7305     ));
7306     insns.push((
7307         Inst::FpuRR {
7308             fpu_op: FPUOp1::Cvt64To128,
7309             rd: writable_vr(24),
7310             rn: vr(12),
7311         },
7312         "E78C000838C4",
7313         "wflld %v24, %f12",
7314     ));
7315 
7316     insns.push((
7317         Inst::FpuRRR {
7318             fpu_op: FPUOp2::Add32,
7319             rd: writable_vr(8),
7320             rn: vr(8),
7321             rm: vr(12),
7322         },
7323         "B30A008C",
7324         "aebr %f8, %f12",
7325     ));
7326     insns.push((
7327         Inst::FpuRRR {
7328             fpu_op: FPUOp2::Add32,
7329             rd: writable_vr(20),
7330             rn: vr(8),
7331             rm: vr(12),
7332         },
7333         "E748C00828E3",
7334         "wfasb %v20, %f8, %f12",
7335     ));
7336     insns.push((
7337         Inst::FpuRRR {
7338             fpu_op: FPUOp2::Add32x4,
7339             rd: writable_vr(20),
7340             rn: vr(8),
7341             rm: vr(12),
7342         },
7343         "E748C00028E3",
7344         "vfasb %v20, %v8, %v12",
7345     ));
7346     insns.push((
7347         Inst::FpuRRR {
7348             fpu_op: FPUOp2::Add64,
7349             rd: writable_vr(8),
7350             rn: vr(8),
7351             rm: vr(12),
7352         },
7353         "B31A008C",
7354         "adbr %f8, %f12",
7355     ));
7356     insns.push((
7357         Inst::FpuRRR {
7358             fpu_op: FPUOp2::Add64,
7359             rd: writable_vr(20),
7360             rn: vr(8),
7361             rm: vr(12),
7362         },
7363         "E748C00838E3",
7364         "wfadb %v20, %f8, %f12",
7365     ));
7366     insns.push((
7367         Inst::FpuRRR {
7368             fpu_op: FPUOp2::Add64x2,
7369             rd: writable_vr(20),
7370             rn: vr(8),
7371             rm: vr(12),
7372         },
7373         "E748C00038E3",
7374         "vfadb %v20, %v8, %v12",
7375     ));
7376     insns.push((
7377         Inst::FpuRRR {
7378             fpu_op: FPUOp2::Add128,
7379             rd: writable_vr(20),
7380             rn: vr(8),
7381             rm: vr(12),
7382         },
7383         "E748C00848E3",
7384         "wfaxb %v20, %f8, %f12",
7385     ));
7386     insns.push((
7387         Inst::FpuRRR {
7388             fpu_op: FPUOp2::Sub32,
7389             rd: writable_vr(8),
7390             rn: vr(8),
7391             rm: vr(12),
7392         },
7393         "B30B008C",
7394         "sebr %f8, %f12",
7395     ));
7396     insns.push((
7397         Inst::FpuRRR {
7398             fpu_op: FPUOp2::Sub32,
7399             rd: writable_vr(20),
7400             rn: vr(8),
7401             rm: vr(12),
7402         },
7403         "E748C00828E2",
7404         "wfssb %v20, %f8, %f12",
7405     ));
7406     insns.push((
7407         Inst::FpuRRR {
7408             fpu_op: FPUOp2::Sub32x4,
7409             rd: writable_vr(20),
7410             rn: vr(8),
7411             rm: vr(12),
7412         },
7413         "E748C00028E2",
7414         "vfssb %v20, %v8, %v12",
7415     ));
7416     insns.push((
7417         Inst::FpuRRR {
7418             fpu_op: FPUOp2::Sub64,
7419             rd: writable_vr(8),
7420             rn: vr(8),
7421             rm: vr(12),
7422         },
7423         "B31B008C",
7424         "sdbr %f8, %f12",
7425     ));
7426     insns.push((
7427         Inst::FpuRRR {
7428             fpu_op: FPUOp2::Sub64,
7429             rd: writable_vr(20),
7430             rn: vr(8),
7431             rm: vr(12),
7432         },
7433         "E748C00838E2",
7434         "wfsdb %v20, %f8, %f12",
7435     ));
7436     insns.push((
7437         Inst::FpuRRR {
7438             fpu_op: FPUOp2::Sub64x2,
7439             rd: writable_vr(20),
7440             rn: vr(8),
7441             rm: vr(12),
7442         },
7443         "E748C00038E2",
7444         "vfsdb %v20, %v8, %v12",
7445     ));
7446     insns.push((
7447         Inst::FpuRRR {
7448             fpu_op: FPUOp2::Sub128,
7449             rd: writable_vr(20),
7450             rn: vr(8),
7451             rm: vr(12),
7452         },
7453         "E748C00848E2",
7454         "wfsxb %v20, %f8, %f12",
7455     ));
7456     insns.push((
7457         Inst::FpuRRR {
7458             fpu_op: FPUOp2::Mul32,
7459             rd: writable_vr(8),
7460             rn: vr(8),
7461             rm: vr(12),
7462         },
7463         "B317008C",
7464         "meebr %f8, %f12",
7465     ));
7466     insns.push((
7467         Inst::FpuRRR {
7468             fpu_op: FPUOp2::Mul32,
7469             rd: writable_vr(20),
7470             rn: vr(8),
7471             rm: vr(12),
7472         },
7473         "E748C00828E7",
7474         "wfmsb %v20, %f8, %f12",
7475     ));
7476     insns.push((
7477         Inst::FpuRRR {
7478             fpu_op: FPUOp2::Mul32x4,
7479             rd: writable_vr(20),
7480             rn: vr(8),
7481             rm: vr(12),
7482         },
7483         "E748C00028E7",
7484         "vfmsb %v20, %v8, %v12",
7485     ));
7486     insns.push((
7487         Inst::FpuRRR {
7488             fpu_op: FPUOp2::Mul64,
7489             rd: writable_vr(8),
7490             rn: vr(8),
7491             rm: vr(12),
7492         },
7493         "B31C008C",
7494         "mdbr %f8, %f12",
7495     ));
7496     insns.push((
7497         Inst::FpuRRR {
7498             fpu_op: FPUOp2::Mul64,
7499             rd: writable_vr(20),
7500             rn: vr(8),
7501             rm: vr(12),
7502         },
7503         "E748C00838E7",
7504         "wfmdb %v20, %f8, %f12",
7505     ));
7506     insns.push((
7507         Inst::FpuRRR {
7508             fpu_op: FPUOp2::Mul64x2,
7509             rd: writable_vr(20),
7510             rn: vr(8),
7511             rm: vr(12),
7512         },
7513         "E748C00038E7",
7514         "vfmdb %v20, %v8, %v12",
7515     ));
7516     insns.push((
7517         Inst::FpuRRR {
7518             fpu_op: FPUOp2::Mul128,
7519             rd: writable_vr(20),
7520             rn: vr(8),
7521             rm: vr(12),
7522         },
7523         "E748C00848E7",
7524         "wfmxb %v20, %f8, %f12",
7525     ));
7526     insns.push((
7527         Inst::FpuRRR {
7528             fpu_op: FPUOp2::Div32,
7529             rd: writable_vr(8),
7530             rn: vr(8),
7531             rm: vr(12),
7532         },
7533         "B30D008C",
7534         "debr %f8, %f12",
7535     ));
7536     insns.push((
7537         Inst::FpuRRR {
7538             fpu_op: FPUOp2::Div32,
7539             rd: writable_vr(20),
7540             rn: vr(8),
7541             rm: vr(12),
7542         },
7543         "E748C00828E5",
7544         "wfdsb %v20, %f8, %f12",
7545     ));
7546     insns.push((
7547         Inst::FpuRRR {
7548             fpu_op: FPUOp2::Div32x4,
7549             rd: writable_vr(20),
7550             rn: vr(8),
7551             rm: vr(12),
7552         },
7553         "E748C00028E5",
7554         "vfdsb %v20, %v8, %v12",
7555     ));
7556     insns.push((
7557         Inst::FpuRRR {
7558             fpu_op: FPUOp2::Div64,
7559             rd: writable_vr(8),
7560             rn: vr(8),
7561             rm: vr(12),
7562         },
7563         "B31D008C",
7564         "ddbr %f8, %f12",
7565     ));
7566     insns.push((
7567         Inst::FpuRRR {
7568             fpu_op: FPUOp2::Div64,
7569             rd: writable_vr(20),
7570             rn: vr(8),
7571             rm: vr(12),
7572         },
7573         "E748C00838E5",
7574         "wfddb %v20, %f8, %f12",
7575     ));
7576     insns.push((
7577         Inst::FpuRRR {
7578             fpu_op: FPUOp2::Div64x2,
7579             rd: writable_vr(20),
7580             rn: vr(8),
7581             rm: vr(12),
7582         },
7583         "E748C00038E5",
7584         "vfddb %v20, %v8, %v12",
7585     ));
7586     insns.push((
7587         Inst::FpuRRR {
7588             fpu_op: FPUOp2::Div128,
7589             rd: writable_vr(20),
7590             rn: vr(8),
7591             rm: vr(12),
7592         },
7593         "E748C00848E5",
7594         "wfdxb %v20, %f8, %f12",
7595     ));
7596     insns.push((
7597         Inst::FpuRRR {
7598             fpu_op: FPUOp2::Max32,
7599             rd: writable_vr(4),
7600             rn: vr(6),
7601             rm: vr(8),
7602         },
7603         "E746801820EF",
7604         "wfmaxsb %f4, %f6, %f8, 1",
7605     ));
7606     insns.push((
7607         Inst::FpuRRR {
7608             fpu_op: FPUOp2::Max32x4,
7609             rd: writable_vr(4),
7610             rn: vr(6),
7611             rm: vr(8),
7612         },
7613         "E746801020EF",
7614         "vfmaxsb %v4, %v6, %v8, 1",
7615     ));
7616     insns.push((
7617         Inst::FpuRRR {
7618             fpu_op: FPUOp2::Max64,
7619             rd: writable_vr(4),
7620             rn: vr(6),
7621             rm: vr(24),
7622         },
7623         "E746801832EF",
7624         "wfmaxdb %f4, %f6, %v24, 1",
7625     ));
7626     insns.push((
7627         Inst::FpuRRR {
7628             fpu_op: FPUOp2::Max64x2,
7629             rd: writable_vr(4),
7630             rn: vr(6),
7631             rm: vr(24),
7632         },
7633         "E746801032EF",
7634         "vfmaxdb %v4, %v6, %v24, 1",
7635     ));
7636     insns.push((
7637         Inst::FpuRRR {
7638             fpu_op: FPUOp2::Max128,
7639             rd: writable_vr(4),
7640             rn: vr(6),
7641             rm: vr(24),
7642         },
7643         "E746801842EF",
7644         "wfmaxxb %f4, %f6, %v24, 1",
7645     ));
7646     insns.push((
7647         Inst::FpuRRR {
7648             fpu_op: FPUOp2::Min32,
7649             rd: writable_vr(4),
7650             rn: vr(6),
7651             rm: vr(8),
7652         },
7653         "E746801820EE",
7654         "wfminsb %f4, %f6, %f8, 1",
7655     ));
7656     insns.push((
7657         Inst::FpuRRR {
7658             fpu_op: FPUOp2::Min32x4,
7659             rd: writable_vr(4),
7660             rn: vr(6),
7661             rm: vr(8),
7662         },
7663         "E746801020EE",
7664         "vfminsb %v4, %v6, %v8, 1",
7665     ));
7666     insns.push((
7667         Inst::FpuRRR {
7668             fpu_op: FPUOp2::Min64,
7669             rd: writable_vr(4),
7670             rn: vr(6),
7671             rm: vr(8),
7672         },
7673         "E746801830EE",
7674         "wfmindb %f4, %f6, %f8, 1",
7675     ));
7676     insns.push((
7677         Inst::FpuRRR {
7678             fpu_op: FPUOp2::Min64x2,
7679             rd: writable_vr(4),
7680             rn: vr(6),
7681             rm: vr(8),
7682         },
7683         "E746801030EE",
7684         "vfmindb %v4, %v6, %v8, 1",
7685     ));
7686     insns.push((
7687         Inst::FpuRRR {
7688             fpu_op: FPUOp2::Min128,
7689             rd: writable_vr(4),
7690             rn: vr(6),
7691             rm: vr(8),
7692         },
7693         "E746801840EE",
7694         "wfminxb %f4, %f6, %f8, 1",
7695     ));
7696     insns.push((
7697         Inst::FpuRRR {
7698             fpu_op: FPUOp2::MaxPseudo32,
7699             rd: writable_vr(4),
7700             rn: vr(6),
7701             rm: vr(8),
7702         },
7703         "E746803820EF",
7704         "wfmaxsb %f4, %f6, %f8, 3",
7705     ));
7706     insns.push((
7707         Inst::FpuRRR {
7708             fpu_op: FPUOp2::MaxPseudo32x4,
7709             rd: writable_vr(4),
7710             rn: vr(6),
7711             rm: vr(8),
7712         },
7713         "E746803020EF",
7714         "vfmaxsb %v4, %v6, %v8, 3",
7715     ));
7716     insns.push((
7717         Inst::FpuRRR {
7718             fpu_op: FPUOp2::MaxPseudo64,
7719             rd: writable_vr(4),
7720             rn: vr(6),
7721             rm: vr(24),
7722         },
7723         "E746803832EF",
7724         "wfmaxdb %f4, %f6, %v24, 3",
7725     ));
7726     insns.push((
7727         Inst::FpuRRR {
7728             fpu_op: FPUOp2::MaxPseudo64x2,
7729             rd: writable_vr(4),
7730             rn: vr(6),
7731             rm: vr(24),
7732         },
7733         "E746803032EF",
7734         "vfmaxdb %v4, %v6, %v24, 3",
7735     ));
7736     insns.push((
7737         Inst::FpuRRR {
7738             fpu_op: FPUOp2::MaxPseudo128,
7739             rd: writable_vr(4),
7740             rn: vr(6),
7741             rm: vr(24),
7742         },
7743         "E746803842EF",
7744         "wfmaxxb %f4, %f6, %v24, 3",
7745     ));
7746     insns.push((
7747         Inst::FpuRRR {
7748             fpu_op: FPUOp2::MinPseudo32,
7749             rd: writable_vr(4),
7750             rn: vr(6),
7751             rm: vr(8),
7752         },
7753         "E746803820EE",
7754         "wfminsb %f4, %f6, %f8, 3",
7755     ));
7756     insns.push((
7757         Inst::FpuRRR {
7758             fpu_op: FPUOp2::MinPseudo32x4,
7759             rd: writable_vr(4),
7760             rn: vr(6),
7761             rm: vr(8),
7762         },
7763         "E746803020EE",
7764         "vfminsb %v4, %v6, %v8, 3",
7765     ));
7766     insns.push((
7767         Inst::FpuRRR {
7768             fpu_op: FPUOp2::MinPseudo64,
7769             rd: writable_vr(4),
7770             rn: vr(6),
7771             rm: vr(8),
7772         },
7773         "E746803830EE",
7774         "wfmindb %f4, %f6, %f8, 3",
7775     ));
7776     insns.push((
7777         Inst::FpuRRR {
7778             fpu_op: FPUOp2::MinPseudo64x2,
7779             rd: writable_vr(4),
7780             rn: vr(6),
7781             rm: vr(8),
7782         },
7783         "E746803030EE",
7784         "vfmindb %v4, %v6, %v8, 3",
7785     ));
7786     insns.push((
7787         Inst::FpuRRR {
7788             fpu_op: FPUOp2::MinPseudo128,
7789             rd: writable_vr(4),
7790             rn: vr(6),
7791             rm: vr(8),
7792         },
7793         "E746803840EE",
7794         "wfminxb %f4, %f6, %f8, 3",
7795     ));
7796 
7797     insns.push((
7798         Inst::FpuRRRR {
7799             fpu_op: FPUOp3::MAdd32,
7800             rd: writable_vr(8),
7801             rn: vr(12),
7802             rm: vr(13),
7803             ra: vr(8),
7804         },
7805         "B30E80CD",
7806         "maebr %f8, %f12, %f13",
7807     ));
7808     insns.push((
7809         Inst::FpuRRRR {
7810             fpu_op: FPUOp3::MAdd32,
7811             rd: writable_vr(8),
7812             rn: vr(12),
7813             rm: vr(13),
7814             ra: vr(20),
7815         },
7816         "E78CD208418F",
7817         "wfmasb %f8, %f12, %f13, %v20",
7818     ));
7819     insns.push((
7820         Inst::FpuRRRR {
7821             fpu_op: FPUOp3::MAdd32x4,
7822             rd: writable_vr(8),
7823             rn: vr(12),
7824             rm: vr(13),
7825             ra: vr(20),
7826         },
7827         "E78CD200418F",
7828         "vfmasb %v8, %v12, %v13, %v20",
7829     ));
7830     insns.push((
7831         Inst::FpuRRRR {
7832             fpu_op: FPUOp3::MAdd64,
7833             rd: writable_vr(8),
7834             rn: vr(12),
7835             rm: vr(13),
7836             ra: vr(8),
7837         },
7838         "B31E80CD",
7839         "madbr %f8, %f12, %f13",
7840     ));
7841     insns.push((
7842         Inst::FpuRRRR {
7843             fpu_op: FPUOp3::MAdd64,
7844             rd: writable_vr(8),
7845             rn: vr(12),
7846             rm: vr(13),
7847             ra: vr(20),
7848         },
7849         "E78CD308418F",
7850         "wfmadb %f8, %f12, %f13, %v20",
7851     ));
7852     insns.push((
7853         Inst::FpuRRRR {
7854             fpu_op: FPUOp3::MAdd64x2,
7855             rd: writable_vr(8),
7856             rn: vr(12),
7857             rm: vr(13),
7858             ra: vr(20),
7859         },
7860         "E78CD300418F",
7861         "vfmadb %v8, %v12, %v13, %v20",
7862     ));
7863     insns.push((
7864         Inst::FpuRRRR {
7865             fpu_op: FPUOp3::MAdd128,
7866             rd: writable_vr(8),
7867             rn: vr(12),
7868             rm: vr(13),
7869             ra: vr(20),
7870         },
7871         "E78CD408418F",
7872         "wfmaxb %f8, %f12, %f13, %v20",
7873     ));
7874     insns.push((
7875         Inst::FpuRRRR {
7876             fpu_op: FPUOp3::MSub32,
7877             rd: writable_vr(8),
7878             rn: vr(12),
7879             rm: vr(13),
7880             ra: vr(8),
7881         },
7882         "B30F80CD",
7883         "msebr %f8, %f12, %f13",
7884     ));
7885     insns.push((
7886         Inst::FpuRRRR {
7887             fpu_op: FPUOp3::MSub32,
7888             rd: writable_vr(8),
7889             rn: vr(12),
7890             rm: vr(13),
7891             ra: vr(20),
7892         },
7893         "E78CD208418E",
7894         "wfmssb %f8, %f12, %f13, %v20",
7895     ));
7896     insns.push((
7897         Inst::FpuRRRR {
7898             fpu_op: FPUOp3::MSub32x4,
7899             rd: writable_vr(8),
7900             rn: vr(12),
7901             rm: vr(13),
7902             ra: vr(20),
7903         },
7904         "E78CD200418E",
7905         "vfmssb %v8, %v12, %v13, %v20",
7906     ));
7907     insns.push((
7908         Inst::FpuRRRR {
7909             fpu_op: FPUOp3::MSub64,
7910             rd: writable_vr(8),
7911             rn: vr(12),
7912             rm: vr(13),
7913             ra: vr(8),
7914         },
7915         "B31F80CD",
7916         "msdbr %f8, %f12, %f13",
7917     ));
7918     insns.push((
7919         Inst::FpuRRRR {
7920             fpu_op: FPUOp3::MSub64,
7921             rd: writable_vr(8),
7922             rn: vr(12),
7923             rm: vr(13),
7924             ra: vr(20),
7925         },
7926         "E78CD308418E",
7927         "wfmsdb %f8, %f12, %f13, %v20",
7928     ));
7929     insns.push((
7930         Inst::FpuRRRR {
7931             fpu_op: FPUOp3::MSub64x2,
7932             rd: writable_vr(8),
7933             rn: vr(12),
7934             rm: vr(13),
7935             ra: vr(20),
7936         },
7937         "E78CD300418E",
7938         "vfmsdb %v8, %v12, %v13, %v20",
7939     ));
7940     insns.push((
7941         Inst::FpuRRRR {
7942             fpu_op: FPUOp3::MSub128,
7943             rd: writable_vr(8),
7944             rn: vr(12),
7945             rm: vr(13),
7946             ra: vr(20),
7947         },
7948         "E78CD408418E",
7949         "wfmsxb %f8, %f12, %f13, %v20",
7950     ));
7951 
7952     insns.push((
7953         Inst::FpuCmp32 {
7954             rn: vr(8),
7955             rm: vr(12),
7956         },
7957         "B309008C",
7958         "cebr %f8, %f12",
7959     ));
7960     insns.push((
7961         Inst::FpuCmp32 {
7962             rn: vr(24),
7963             rm: vr(12),
7964         },
7965         "E78C000028CB",
7966         "wfcsb %v24, %f12",
7967     ));
7968     insns.push((
7969         Inst::FpuCmp64 {
7970             rn: vr(8),
7971             rm: vr(12),
7972         },
7973         "B319008C",
7974         "cdbr %f8, %f12",
7975     ));
7976     insns.push((
7977         Inst::FpuCmp64 {
7978             rn: vr(24),
7979             rm: vr(12),
7980         },
7981         "E78C000038CB",
7982         "wfcdb %v24, %f12",
7983     ));
7984     insns.push((
7985         Inst::FpuCmp128 {
7986             rn: vr(24),
7987             rm: vr(12),
7988         },
7989         "E78C000048CB",
7990         "wfcxb %v24, %f12",
7991     ));
7992 
7993     insns.push((
7994         Inst::FpuRound {
7995             op: FpuRoundOp::Cvt64To32,
7996             mode: FpuRoundMode::Current,
7997             rd: writable_vr(8),
7998             rn: vr(12),
7999         },
8000         "B344008C",
8001         "ledbra %f8, 0, %f12, 0",
8002     ));
8003     insns.push((
8004         Inst::FpuRound {
8005             op: FpuRoundOp::Cvt64To32,
8006             mode: FpuRoundMode::ToNearest,
8007             rd: writable_vr(24),
8008             rn: vr(12),
8009         },
8010         "E78C001838C5",
8011         "wledb %v24, %f12, 0, 1",
8012     ));
8013     insns.push((
8014         Inst::FpuRound {
8015             op: FpuRoundOp::Cvt64x2To32x4,
8016             mode: FpuRoundMode::ToNearest,
8017             rd: writable_vr(24),
8018             rn: vr(12),
8019         },
8020         "E78C001038C5",
8021         "vledb %v24, %v12, 0, 1",
8022     ));
8023     insns.push((
8024         Inst::FpuRound {
8025             op: FpuRoundOp::Cvt128To64,
8026             mode: FpuRoundMode::ToNearest,
8027             rd: writable_vr(24),
8028             rn: vr(12),
8029         },
8030         "E78C001848C5",
8031         "wflrx %v24, %f12, 0, 1",
8032     ));
8033     insns.push((
8034         Inst::FpuRound {
8035             op: FpuRoundOp::Round32,
8036             mode: FpuRoundMode::ToNegInfinity,
8037             rd: writable_vr(8),
8038             rn: vr(12),
8039         },
8040         "B357708C",
8041         "fiebr %f8, 7, %f12",
8042     ));
8043     insns.push((
8044         Inst::FpuRound {
8045             op: FpuRoundOp::Round64,
8046             mode: FpuRoundMode::ToNegInfinity,
8047             rd: writable_vr(8),
8048             rn: vr(12),
8049         },
8050         "B35F708C",
8051         "fidbr %f8, 7, %f12",
8052     ));
8053     insns.push((
8054         Inst::FpuRound {
8055             op: FpuRoundOp::Round32,
8056             mode: FpuRoundMode::ToPosInfinity,
8057             rd: writable_vr(8),
8058             rn: vr(12),
8059         },
8060         "B357608C",
8061         "fiebr %f8, 6, %f12",
8062     ));
8063     insns.push((
8064         Inst::FpuRound {
8065             op: FpuRoundOp::Round64,
8066             mode: FpuRoundMode::ToPosInfinity,
8067             rd: writable_vr(8),
8068             rn: vr(12),
8069         },
8070         "B35F608C",
8071         "fidbr %f8, 6, %f12",
8072     ));
8073     insns.push((
8074         Inst::FpuRound {
8075             op: FpuRoundOp::Round32,
8076             mode: FpuRoundMode::ToZero,
8077             rd: writable_vr(8),
8078             rn: vr(12),
8079         },
8080         "B357508C",
8081         "fiebr %f8, 5, %f12",
8082     ));
8083     insns.push((
8084         Inst::FpuRound {
8085             op: FpuRoundOp::Round64,
8086             mode: FpuRoundMode::ToZero,
8087             rd: writable_vr(8),
8088             rn: vr(12),
8089         },
8090         "B35F508C",
8091         "fidbr %f8, 5, %f12",
8092     ));
8093     insns.push((
8094         Inst::FpuRound {
8095             op: FpuRoundOp::Round32,
8096             mode: FpuRoundMode::ToNearestTiesToEven,
8097             rd: writable_vr(8),
8098             rn: vr(12),
8099         },
8100         "B357408C",
8101         "fiebr %f8, 4, %f12",
8102     ));
8103     insns.push((
8104         Inst::FpuRound {
8105             op: FpuRoundOp::Round64,
8106             mode: FpuRoundMode::ToNearestTiesToEven,
8107             rd: writable_vr(8),
8108             rn: vr(12),
8109         },
8110         "B35F408C",
8111         "fidbr %f8, 4, %f12",
8112     ));
8113     insns.push((
8114         Inst::FpuRound {
8115             op: FpuRoundOp::Round32,
8116             mode: FpuRoundMode::ToNearest,
8117             rd: writable_vr(24),
8118             rn: vr(12),
8119         },
8120         "E78C001828C7",
8121         "wfisb %v24, %f12, 0, 1",
8122     ));
8123     insns.push((
8124         Inst::FpuRound {
8125             op: FpuRoundOp::Round32x4,
8126             mode: FpuRoundMode::ToNearest,
8127             rd: writable_vr(24),
8128             rn: vr(12),
8129         },
8130         "E78C001028C7",
8131         "vfisb %v24, %v12, 0, 1",
8132     ));
8133     insns.push((
8134         Inst::FpuRound {
8135             op: FpuRoundOp::Round64,
8136             mode: FpuRoundMode::ToNearest,
8137             rd: writable_vr(24),
8138             rn: vr(12),
8139         },
8140         "E78C001838C7",
8141         "wfidb %v24, %f12, 0, 1",
8142     ));
8143     insns.push((
8144         Inst::FpuRound {
8145             op: FpuRoundOp::Round64x2,
8146             mode: FpuRoundMode::ToNearest,
8147             rd: writable_vr(24),
8148             rn: vr(12),
8149         },
8150         "E78C001038C7",
8151         "vfidb %v24, %v12, 0, 1",
8152     ));
8153     insns.push((
8154         Inst::FpuRound {
8155             op: FpuRoundOp::Round128,
8156             mode: FpuRoundMode::ToNearest,
8157             rd: writable_vr(24),
8158             rn: vr(12),
8159         },
8160         "E78C001848C7",
8161         "wfixb %v24, %f12, 0, 1",
8162     ));
8163     insns.push((
8164         Inst::FpuRound {
8165             op: FpuRoundOp::ToSInt32,
8166             mode: FpuRoundMode::ToNearest,
8167             rd: writable_vr(24),
8168             rn: vr(12),
8169         },
8170         "E78C001828C2",
8171         "wcfeb %v24, %f12, 0, 1",
8172     ));
8173     insns.push((
8174         Inst::FpuRound {
8175             op: FpuRoundOp::ToSInt32x4,
8176             mode: FpuRoundMode::ToNearest,
8177             rd: writable_vr(24),
8178             rn: vr(12),
8179         },
8180         "E78C001028C2",
8181         "vcfeb %v24, %v12, 0, 1",
8182     ));
8183     insns.push((
8184         Inst::FpuRound {
8185             op: FpuRoundOp::ToSInt64,
8186             mode: FpuRoundMode::ToNearest,
8187             rd: writable_vr(24),
8188             rn: vr(12),
8189         },
8190         "E78C001838C2",
8191         "wcgdb %v24, %f12, 0, 1",
8192     ));
8193     insns.push((
8194         Inst::FpuRound {
8195             op: FpuRoundOp::ToSInt64x2,
8196             mode: FpuRoundMode::ToNearest,
8197             rd: writable_vr(24),
8198             rn: vr(12),
8199         },
8200         "E78C001038C2",
8201         "vcgdb %v24, %v12, 0, 1",
8202     ));
8203     insns.push((
8204         Inst::FpuRound {
8205             op: FpuRoundOp::ToUInt32,
8206             mode: FpuRoundMode::ToNearest,
8207             rd: writable_vr(24),
8208             rn: vr(12),
8209         },
8210         "E78C001828C0",
8211         "wclfeb %v24, %f12, 0, 1",
8212     ));
8213     insns.push((
8214         Inst::FpuRound {
8215             op: FpuRoundOp::ToUInt32x4,
8216             mode: FpuRoundMode::ToNearest,
8217             rd: writable_vr(24),
8218             rn: vr(12),
8219         },
8220         "E78C001028C0",
8221         "vclfeb %v24, %v12, 0, 1",
8222     ));
8223     insns.push((
8224         Inst::FpuRound {
8225             op: FpuRoundOp::ToUInt64,
8226             mode: FpuRoundMode::ToNearest,
8227             rd: writable_vr(24),
8228             rn: vr(12),
8229         },
8230         "E78C001838C0",
8231         "wclgdb %v24, %f12, 0, 1",
8232     ));
8233     insns.push((
8234         Inst::FpuRound {
8235             op: FpuRoundOp::ToUInt64x2,
8236             mode: FpuRoundMode::ToNearest,
8237             rd: writable_vr(24),
8238             rn: vr(12),
8239         },
8240         "E78C001038C0",
8241         "vclgdb %v24, %v12, 0, 1",
8242     ));
8243     insns.push((
8244         Inst::FpuRound {
8245             op: FpuRoundOp::FromSInt32,
8246             mode: FpuRoundMode::ToNearest,
8247             rd: writable_vr(24),
8248             rn: vr(12),
8249         },
8250         "E78C001828C3",
8251         "wcefb %v24, %f12, 0, 1",
8252     ));
8253     insns.push((
8254         Inst::FpuRound {
8255             op: FpuRoundOp::FromSInt32x4,
8256             mode: FpuRoundMode::ToNearest,
8257             rd: writable_vr(24),
8258             rn: vr(12),
8259         },
8260         "E78C001028C3",
8261         "vcefb %v24, %v12, 0, 1",
8262     ));
8263     insns.push((
8264         Inst::FpuRound {
8265             op: FpuRoundOp::FromSInt64,
8266             mode: FpuRoundMode::ToNearest,
8267             rd: writable_vr(24),
8268             rn: vr(12),
8269         },
8270         "E78C001838C3",
8271         "wcdgb %v24, %f12, 0, 1",
8272     ));
8273     insns.push((
8274         Inst::FpuRound {
8275             op: FpuRoundOp::FromSInt64x2,
8276             mode: FpuRoundMode::ToNearest,
8277             rd: writable_vr(24),
8278             rn: vr(12),
8279         },
8280         "E78C001038C3",
8281         "vcdgb %v24, %v12, 0, 1",
8282     ));
8283     insns.push((
8284         Inst::FpuRound {
8285             op: FpuRoundOp::FromUInt32,
8286             mode: FpuRoundMode::ToNearest,
8287             rd: writable_vr(24),
8288             rn: vr(12),
8289         },
8290         "E78C001828C1",
8291         "wcelfb %v24, %f12, 0, 1",
8292     ));
8293     insns.push((
8294         Inst::FpuRound {
8295             op: FpuRoundOp::FromUInt32x4,
8296             mode: FpuRoundMode::ToNearest,
8297             rd: writable_vr(24),
8298             rn: vr(12),
8299         },
8300         "E78C001028C1",
8301         "vcelfb %v24, %v12, 0, 1",
8302     ));
8303     insns.push((
8304         Inst::FpuRound {
8305             op: FpuRoundOp::FromUInt64,
8306             mode: FpuRoundMode::ToNearest,
8307             rd: writable_vr(24),
8308             rn: vr(12),
8309         },
8310         "E78C001838C1",
8311         "wcdlgb %v24, %f12, 0, 1",
8312     ));
8313     insns.push((
8314         Inst::FpuRound {
8315             op: FpuRoundOp::FromUInt64x2,
8316             mode: FpuRoundMode::ToNearest,
8317             rd: writable_vr(24),
8318             rn: vr(12),
8319         },
8320         "E78C001038C1",
8321         "vcdlgb %v24, %v12, 0, 1",
8322     ));
8323 
8324     let w_fp_regpair = WritableRegPair {
8325         hi: writable_vr(1),
8326         lo: writable_vr(3),
8327     };
8328     let fp_regpair = RegPair {
8329         hi: vr(1),
8330         lo: vr(3),
8331     };
8332     insns.push((
8333         Inst::FpuConv128FromInt {
8334             op: FpuConv128Op::SInt32,
8335             mode: FpuRoundMode::ToZero,
8336             rd: w_fp_regpair,
8337             rn: gpr(8),
8338         },
8339         "B3965018",
8340         "cxfbra %f1, 5, %r8, 0",
8341     ));
8342     insns.push((
8343         Inst::FpuConv128FromInt {
8344             op: FpuConv128Op::SInt64,
8345             mode: FpuRoundMode::ToZero,
8346             rd: w_fp_regpair,
8347             rn: gpr(8),
8348         },
8349         "B3A65018",
8350         "cxgbra %f1, 5, %r8, 0",
8351     ));
8352     insns.push((
8353         Inst::FpuConv128FromInt {
8354             op: FpuConv128Op::UInt32,
8355             mode: FpuRoundMode::ToZero,
8356             rd: w_fp_regpair,
8357             rn: gpr(8),
8358         },
8359         "B3925018",
8360         "cxlfbr %f1, 5, %r8, 0",
8361     ));
8362     insns.push((
8363         Inst::FpuConv128FromInt {
8364             op: FpuConv128Op::UInt64,
8365             mode: FpuRoundMode::ToZero,
8366             rd: w_fp_regpair,
8367             rn: gpr(8),
8368         },
8369         "B3A25018",
8370         "cxlgbr %f1, 5, %r8, 0",
8371     ));
8372     insns.push((
8373         Inst::FpuConv128ToInt {
8374             op: FpuConv128Op::SInt32,
8375             mode: FpuRoundMode::ToZero,
8376             rd: writable_gpr(8),
8377             rn: fp_regpair,
8378         },
8379         "B39A5081",
8380         "cfxbra %r8, 5, %f1, 0",
8381     ));
8382     insns.push((
8383         Inst::FpuConv128ToInt {
8384             op: FpuConv128Op::SInt64,
8385             mode: FpuRoundMode::ToZero,
8386             rd: writable_gpr(8),
8387             rn: fp_regpair,
8388         },
8389         "B3AA5081",
8390         "cgxbra %r8, 5, %f1, 0",
8391     ));
8392     insns.push((
8393         Inst::FpuConv128ToInt {
8394             op: FpuConv128Op::UInt32,
8395             mode: FpuRoundMode::ToZero,
8396             rd: writable_gpr(8),
8397             rn: fp_regpair,
8398         },
8399         "B39E5081",
8400         "clfxbr %r8, 5, %f1, 0",
8401     ));
8402     insns.push((
8403         Inst::FpuConv128ToInt {
8404             op: FpuConv128Op::UInt64,
8405             mode: FpuRoundMode::ToZero,
8406             rd: writable_gpr(8),
8407             rn: fp_regpair,
8408         },
8409         "B3AE5081",
8410         "clgxbr %r8, 5, %f1, 0",
8411     ));
8412 
8413     insns.push((
8414         Inst::VecRRR {
8415             op: VecBinaryOp::Add8x16,
8416             rd: writable_vr(20),
8417             rn: vr(8),
8418             rm: vr(12),
8419         },
8420         "E748C00008F3",
8421         "vab %v20, %v8, %v12",
8422     ));
8423     insns.push((
8424         Inst::VecRRR {
8425             op: VecBinaryOp::Add16x8,
8426             rd: writable_vr(20),
8427             rn: vr(8),
8428             rm: vr(12),
8429         },
8430         "E748C00018F3",
8431         "vah %v20, %v8, %v12",
8432     ));
8433     insns.push((
8434         Inst::VecRRR {
8435             op: VecBinaryOp::Add32x4,
8436             rd: writable_vr(20),
8437             rn: vr(8),
8438             rm: vr(12),
8439         },
8440         "E748C00028F3",
8441         "vaf %v20, %v8, %v12",
8442     ));
8443     insns.push((
8444         Inst::VecRRR {
8445             op: VecBinaryOp::Add64x2,
8446             rd: writable_vr(20),
8447             rn: vr(8),
8448             rm: vr(12),
8449         },
8450         "E748C00038F3",
8451         "vag %v20, %v8, %v12",
8452     ));
8453     insns.push((
8454         Inst::VecRRR {
8455             op: VecBinaryOp::Add128,
8456             rd: writable_vr(20),
8457             rn: vr(8),
8458             rm: vr(12),
8459         },
8460         "E748C00048F3",
8461         "vaq %v20, %v8, %v12",
8462     ));
8463     insns.push((
8464         Inst::VecRRR {
8465             op: VecBinaryOp::Sub8x16,
8466             rd: writable_vr(20),
8467             rn: vr(8),
8468             rm: vr(12),
8469         },
8470         "E748C00008F7",
8471         "vsb %v20, %v8, %v12",
8472     ));
8473     insns.push((
8474         Inst::VecRRR {
8475             op: VecBinaryOp::Sub16x8,
8476             rd: writable_vr(20),
8477             rn: vr(8),
8478             rm: vr(12),
8479         },
8480         "E748C00018F7",
8481         "vsh %v20, %v8, %v12",
8482     ));
8483     insns.push((
8484         Inst::VecRRR {
8485             op: VecBinaryOp::Sub32x4,
8486             rd: writable_vr(20),
8487             rn: vr(8),
8488             rm: vr(12),
8489         },
8490         "E748C00028F7",
8491         "vsf %v20, %v8, %v12",
8492     ));
8493     insns.push((
8494         Inst::VecRRR {
8495             op: VecBinaryOp::Sub64x2,
8496             rd: writable_vr(20),
8497             rn: vr(8),
8498             rm: vr(12),
8499         },
8500         "E748C00038F7",
8501         "vsg %v20, %v8, %v12",
8502     ));
8503     insns.push((
8504         Inst::VecRRR {
8505             op: VecBinaryOp::Sub128,
8506             rd: writable_vr(20),
8507             rn: vr(8),
8508             rm: vr(12),
8509         },
8510         "E748C00048F7",
8511         "vsq %v20, %v8, %v12",
8512     ));
8513     insns.push((
8514         Inst::VecRRR {
8515             op: VecBinaryOp::Mul8x16,
8516             rd: writable_vr(20),
8517             rn: vr(8),
8518             rm: vr(12),
8519         },
8520         "E748C00008A2",
8521         "vmlb %v20, %v8, %v12",
8522     ));
8523     insns.push((
8524         Inst::VecRRR {
8525             op: VecBinaryOp::Mul16x8,
8526             rd: writable_vr(20),
8527             rn: vr(8),
8528             rm: vr(12),
8529         },
8530         "E748C00018A2",
8531         "vmlhw %v20, %v8, %v12",
8532     ));
8533     insns.push((
8534         Inst::VecRRR {
8535             op: VecBinaryOp::Mul32x4,
8536             rd: writable_vr(20),
8537             rn: vr(8),
8538             rm: vr(12),
8539         },
8540         "E748C00028A2",
8541         "vmlf %v20, %v8, %v12",
8542     ));
8543     insns.push((
8544         Inst::VecRRR {
8545             op: VecBinaryOp::Mul64x2,
8546             rd: writable_vr(20),
8547             rn: vr(8),
8548             rm: vr(12),
8549         },
8550         "E748C00038A2",
8551         "vmlg %v20, %v8, %v12",
8552     ));
8553     insns.push((
8554         Inst::VecRRR {
8555             op: VecBinaryOp::Mul128,
8556             rd: writable_vr(20),
8557             rn: vr(8),
8558             rm: vr(12),
8559         },
8560         "E748C00048A2",
8561         "vmlq %v20, %v8, %v12",
8562     ));
8563     insns.push((
8564         Inst::VecRRR {
8565             op: VecBinaryOp::UMulHi8x16,
8566             rd: writable_vr(20),
8567             rn: vr(8),
8568             rm: vr(12),
8569         },
8570         "E748C00008A1",
8571         "vmlhb %v20, %v8, %v12",
8572     ));
8573     insns.push((
8574         Inst::VecRRR {
8575             op: VecBinaryOp::UMulHi16x8,
8576             rd: writable_vr(20),
8577             rn: vr(8),
8578             rm: vr(12),
8579         },
8580         "E748C00018A1",
8581         "vmlhh %v20, %v8, %v12",
8582     ));
8583     insns.push((
8584         Inst::VecRRR {
8585             op: VecBinaryOp::UMulHi32x4,
8586             rd: writable_vr(20),
8587             rn: vr(8),
8588             rm: vr(12),
8589         },
8590         "E748C00028A1",
8591         "vmlhf %v20, %v8, %v12",
8592     ));
8593     insns.push((
8594         Inst::VecRRR {
8595             op: VecBinaryOp::UMulHi64x2,
8596             rd: writable_vr(20),
8597             rn: vr(8),
8598             rm: vr(12),
8599         },
8600         "E748C00038A1",
8601         "vmlhg %v20, %v8, %v12",
8602     ));
8603     insns.push((
8604         Inst::VecRRR {
8605             op: VecBinaryOp::UMulHi128,
8606             rd: writable_vr(20),
8607             rn: vr(8),
8608             rm: vr(12),
8609         },
8610         "E748C00048A1",
8611         "vmlhq %v20, %v8, %v12",
8612     ));
8613     insns.push((
8614         Inst::VecRRR {
8615             op: VecBinaryOp::SMulHi8x16,
8616             rd: writable_vr(20),
8617             rn: vr(8),
8618             rm: vr(12),
8619         },
8620         "E748C00008A3",
8621         "vmhb %v20, %v8, %v12",
8622     ));
8623     insns.push((
8624         Inst::VecRRR {
8625             op: VecBinaryOp::SMulHi16x8,
8626             rd: writable_vr(20),
8627             rn: vr(8),
8628             rm: vr(12),
8629         },
8630         "E748C00018A3",
8631         "vmhh %v20, %v8, %v12",
8632     ));
8633     insns.push((
8634         Inst::VecRRR {
8635             op: VecBinaryOp::SMulHi32x4,
8636             rd: writable_vr(20),
8637             rn: vr(8),
8638             rm: vr(12),
8639         },
8640         "E748C00028A3",
8641         "vmhf %v20, %v8, %v12",
8642     ));
8643     insns.push((
8644         Inst::VecRRR {
8645             op: VecBinaryOp::SMulHi64x2,
8646             rd: writable_vr(20),
8647             rn: vr(8),
8648             rm: vr(12),
8649         },
8650         "E748C00038A3",
8651         "vmhg %v20, %v8, %v12",
8652     ));
8653     insns.push((
8654         Inst::VecRRR {
8655             op: VecBinaryOp::SMulHi128,
8656             rd: writable_vr(20),
8657             rn: vr(8),
8658             rm: vr(12),
8659         },
8660         "E748C00048A3",
8661         "vmhq %v20, %v8, %v12",
8662     ));
8663     insns.push((
8664         Inst::VecRRR {
8665             op: VecBinaryOp::UMulEven8x16,
8666             rd: writable_vr(20),
8667             rn: vr(8),
8668             rm: vr(12),
8669         },
8670         "E748C00008A4",
8671         "vmleb %v20, %v8, %v12",
8672     ));
8673     insns.push((
8674         Inst::VecRRR {
8675             op: VecBinaryOp::UMulEven16x8,
8676             rd: writable_vr(20),
8677             rn: vr(8),
8678             rm: vr(12),
8679         },
8680         "E748C00018A4",
8681         "vmleh %v20, %v8, %v12",
8682     ));
8683     insns.push((
8684         Inst::VecRRR {
8685             op: VecBinaryOp::UMulEven32x4,
8686             rd: writable_vr(20),
8687             rn: vr(8),
8688             rm: vr(12),
8689         },
8690         "E748C00028A4",
8691         "vmlef %v20, %v8, %v12",
8692     ));
8693     insns.push((
8694         Inst::VecRRR {
8695             op: VecBinaryOp::UMulEven64x2,
8696             rd: writable_vr(20),
8697             rn: vr(8),
8698             rm: vr(12),
8699         },
8700         "E748C00038A4",
8701         "vmleg %v20, %v8, %v12",
8702     ));
8703     insns.push((
8704         Inst::VecRRR {
8705             op: VecBinaryOp::SMulEven8x16,
8706             rd: writable_vr(20),
8707             rn: vr(8),
8708             rm: vr(12),
8709         },
8710         "E748C00008A6",
8711         "vmeb %v20, %v8, %v12",
8712     ));
8713     insns.push((
8714         Inst::VecRRR {
8715             op: VecBinaryOp::SMulEven16x8,
8716             rd: writable_vr(20),
8717             rn: vr(8),
8718             rm: vr(12),
8719         },
8720         "E748C00018A6",
8721         "vmeh %v20, %v8, %v12",
8722     ));
8723     insns.push((
8724         Inst::VecRRR {
8725             op: VecBinaryOp::SMulEven32x4,
8726             rd: writable_vr(20),
8727             rn: vr(8),
8728             rm: vr(12),
8729         },
8730         "E748C00028A6",
8731         "vmef %v20, %v8, %v12",
8732     ));
8733     insns.push((
8734         Inst::VecRRR {
8735             op: VecBinaryOp::SMulEven64x2,
8736             rd: writable_vr(20),
8737             rn: vr(8),
8738             rm: vr(12),
8739         },
8740         "E748C00038A6",
8741         "vmeg %v20, %v8, %v12",
8742     ));
8743     insns.push((
8744         Inst::VecRRR {
8745             op: VecBinaryOp::UMulOdd8x16,
8746             rd: writable_vr(20),
8747             rn: vr(8),
8748             rm: vr(12),
8749         },
8750         "E748C00008A5",
8751         "vmlob %v20, %v8, %v12",
8752     ));
8753     insns.push((
8754         Inst::VecRRR {
8755             op: VecBinaryOp::UMulOdd16x8,
8756             rd: writable_vr(20),
8757             rn: vr(8),
8758             rm: vr(12),
8759         },
8760         "E748C00018A5",
8761         "vmloh %v20, %v8, %v12",
8762     ));
8763     insns.push((
8764         Inst::VecRRR {
8765             op: VecBinaryOp::UMulOdd32x4,
8766             rd: writable_vr(20),
8767             rn: vr(8),
8768             rm: vr(12),
8769         },
8770         "E748C00028A5",
8771         "vmlof %v20, %v8, %v12",
8772     ));
8773     insns.push((
8774         Inst::VecRRR {
8775             op: VecBinaryOp::UMulOdd64x2,
8776             rd: writable_vr(20),
8777             rn: vr(8),
8778             rm: vr(12),
8779         },
8780         "E748C00038A5",
8781         "vmlog %v20, %v8, %v12",
8782     ));
8783     insns.push((
8784         Inst::VecRRR {
8785             op: VecBinaryOp::SMulOdd8x16,
8786             rd: writable_vr(20),
8787             rn: vr(8),
8788             rm: vr(12),
8789         },
8790         "E748C00008A7",
8791         "vmob %v20, %v8, %v12",
8792     ));
8793     insns.push((
8794         Inst::VecRRR {
8795             op: VecBinaryOp::SMulOdd16x8,
8796             rd: writable_vr(20),
8797             rn: vr(8),
8798             rm: vr(12),
8799         },
8800         "E748C00018A7",
8801         "vmoh %v20, %v8, %v12",
8802     ));
8803     insns.push((
8804         Inst::VecRRR {
8805             op: VecBinaryOp::SMulOdd32x4,
8806             rd: writable_vr(20),
8807             rn: vr(8),
8808             rm: vr(12),
8809         },
8810         "E748C00028A7",
8811         "vmof %v20, %v8, %v12",
8812     ));
8813     insns.push((
8814         Inst::VecRRR {
8815             op: VecBinaryOp::SMulOdd64x2,
8816             rd: writable_vr(20),
8817             rn: vr(8),
8818             rm: vr(12),
8819         },
8820         "E748C00038A7",
8821         "vmog %v20, %v8, %v12",
8822     ));
8823     insns.push((
8824         Inst::VecRRR {
8825             op: VecBinaryOp::UDiv32x4,
8826             rd: writable_vr(20),
8827             rn: vr(8),
8828             rm: vr(12),
8829         },
8830         "E748C00028B0",
8831         "vdlf %v20, %v8, %v12, 0",
8832     ));
8833     insns.push((
8834         Inst::VecRRR {
8835             op: VecBinaryOp::UDiv64x2,
8836             rd: writable_vr(20),
8837             rn: vr(8),
8838             rm: vr(12),
8839         },
8840         "E748C00038B0",
8841         "vdlg %v20, %v8, %v12, 0",
8842     ));
8843     insns.push((
8844         Inst::VecRRR {
8845             op: VecBinaryOp::UDiv128,
8846             rd: writable_vr(20),
8847             rn: vr(8),
8848             rm: vr(12),
8849         },
8850         "E748C00048B0",
8851         "vdlq %v20, %v8, %v12, 0",
8852     ));
8853     insns.push((
8854         Inst::VecRRR {
8855             op: VecBinaryOp::SDiv32x4,
8856             rd: writable_vr(20),
8857             rn: vr(8),
8858             rm: vr(12),
8859         },
8860         "E748C00028B2",
8861         "vdf %v20, %v8, %v12, 0",
8862     ));
8863     insns.push((
8864         Inst::VecRRR {
8865             op: VecBinaryOp::SDiv64x2,
8866             rd: writable_vr(20),
8867             rn: vr(8),
8868             rm: vr(12),
8869         },
8870         "E748C00038B2",
8871         "vdg %v20, %v8, %v12, 0",
8872     ));
8873     insns.push((
8874         Inst::VecRRR {
8875             op: VecBinaryOp::SDiv128,
8876             rd: writable_vr(20),
8877             rn: vr(8),
8878             rm: vr(12),
8879         },
8880         "E748C00048B2",
8881         "vdq %v20, %v8, %v12, 0",
8882     ));
8883     insns.push((
8884         Inst::VecRRR {
8885             op: VecBinaryOp::URem32x4,
8886             rd: writable_vr(20),
8887             rn: vr(8),
8888             rm: vr(12),
8889         },
8890         "E748C00028B1",
8891         "vrlf %v20, %v8, %v12, 0",
8892     ));
8893     insns.push((
8894         Inst::VecRRR {
8895             op: VecBinaryOp::URem64x2,
8896             rd: writable_vr(20),
8897             rn: vr(8),
8898             rm: vr(12),
8899         },
8900         "E748C00038B1",
8901         "vrlg %v20, %v8, %v12, 0",
8902     ));
8903     insns.push((
8904         Inst::VecRRR {
8905             op: VecBinaryOp::URem128,
8906             rd: writable_vr(20),
8907             rn: vr(8),
8908             rm: vr(12),
8909         },
8910         "E748C00048B1",
8911         "vrlq %v20, %v8, %v12, 0",
8912     ));
8913     insns.push((
8914         Inst::VecRRR {
8915             op: VecBinaryOp::SRem32x4,
8916             rd: writable_vr(20),
8917             rn: vr(8),
8918             rm: vr(12),
8919         },
8920         "E748C00028B3",
8921         "vrf %v20, %v8, %v12, 0",
8922     ));
8923     insns.push((
8924         Inst::VecRRR {
8925             op: VecBinaryOp::SRem64x2,
8926             rd: writable_vr(20),
8927             rn: vr(8),
8928             rm: vr(12),
8929         },
8930         "E748C00038B3",
8931         "vrg %v20, %v8, %v12, 0",
8932     ));
8933     insns.push((
8934         Inst::VecRRR {
8935             op: VecBinaryOp::SRem128,
8936             rd: writable_vr(20),
8937             rn: vr(8),
8938             rm: vr(12),
8939         },
8940         "E748C00048B3",
8941         "vrq %v20, %v8, %v12, 0",
8942     ));
8943     insns.push((
8944         Inst::VecRRR {
8945             op: VecBinaryOp::UMax8x16,
8946             rd: writable_vr(20),
8947             rn: vr(8),
8948             rm: vr(12),
8949         },
8950         "E748C00008FD",
8951         "vmxlb %v20, %v8, %v12",
8952     ));
8953     insns.push((
8954         Inst::VecRRR {
8955             op: VecBinaryOp::UMax16x8,
8956             rd: writable_vr(20),
8957             rn: vr(8),
8958             rm: vr(12),
8959         },
8960         "E748C00018FD",
8961         "vmxlh %v20, %v8, %v12",
8962     ));
8963     insns.push((
8964         Inst::VecRRR {
8965             op: VecBinaryOp::UMax32x4,
8966             rd: writable_vr(20),
8967             rn: vr(8),
8968             rm: vr(12),
8969         },
8970         "E748C00028FD",
8971         "vmxlf %v20, %v8, %v12",
8972     ));
8973     insns.push((
8974         Inst::VecRRR {
8975             op: VecBinaryOp::UMax64x2,
8976             rd: writable_vr(20),
8977             rn: vr(8),
8978             rm: vr(12),
8979         },
8980         "E748C00038FD",
8981         "vmxlg %v20, %v8, %v12",
8982     ));
8983     insns.push((
8984         Inst::VecRRR {
8985             op: VecBinaryOp::UMax128,
8986             rd: writable_vr(20),
8987             rn: vr(8),
8988             rm: vr(12),
8989         },
8990         "E748C00048FD",
8991         "vmxlq %v20, %v8, %v12",
8992     ));
8993     insns.push((
8994         Inst::VecRRR {
8995             op: VecBinaryOp::SMax8x16,
8996             rd: writable_vr(20),
8997             rn: vr(8),
8998             rm: vr(12),
8999         },
9000         "E748C00008FF",
9001         "vmxb %v20, %v8, %v12",
9002     ));
9003     insns.push((
9004         Inst::VecRRR {
9005             op: VecBinaryOp::SMax16x8,
9006             rd: writable_vr(20),
9007             rn: vr(8),
9008             rm: vr(12),
9009         },
9010         "E748C00018FF",
9011         "vmxh %v20, %v8, %v12",
9012     ));
9013     insns.push((
9014         Inst::VecRRR {
9015             op: VecBinaryOp::SMax32x4,
9016             rd: writable_vr(20),
9017             rn: vr(8),
9018             rm: vr(12),
9019         },
9020         "E748C00028FF",
9021         "vmxf %v20, %v8, %v12",
9022     ));
9023     insns.push((
9024         Inst::VecRRR {
9025             op: VecBinaryOp::SMax64x2,
9026             rd: writable_vr(20),
9027             rn: vr(8),
9028             rm: vr(12),
9029         },
9030         "E748C00038FF",
9031         "vmxg %v20, %v8, %v12",
9032     ));
9033     insns.push((
9034         Inst::VecRRR {
9035             op: VecBinaryOp::SMax128,
9036             rd: writable_vr(20),
9037             rn: vr(8),
9038             rm: vr(12),
9039         },
9040         "E748C00048FF",
9041         "vmxq %v20, %v8, %v12",
9042     ));
9043     insns.push((
9044         Inst::VecRRR {
9045             op: VecBinaryOp::UMin8x16,
9046             rd: writable_vr(20),
9047             rn: vr(8),
9048             rm: vr(12),
9049         },
9050         "E748C00008FC",
9051         "vmnlb %v20, %v8, %v12",
9052     ));
9053     insns.push((
9054         Inst::VecRRR {
9055             op: VecBinaryOp::UMin16x8,
9056             rd: writable_vr(20),
9057             rn: vr(8),
9058             rm: vr(12),
9059         },
9060         "E748C00018FC",
9061         "vmnlh %v20, %v8, %v12",
9062     ));
9063     insns.push((
9064         Inst::VecRRR {
9065             op: VecBinaryOp::UMin32x4,
9066             rd: writable_vr(20),
9067             rn: vr(8),
9068             rm: vr(12),
9069         },
9070         "E748C00028FC",
9071         "vmnlf %v20, %v8, %v12",
9072     ));
9073     insns.push((
9074         Inst::VecRRR {
9075             op: VecBinaryOp::UMin64x2,
9076             rd: writable_vr(20),
9077             rn: vr(8),
9078             rm: vr(12),
9079         },
9080         "E748C00038FC",
9081         "vmnlg %v20, %v8, %v12",
9082     ));
9083     insns.push((
9084         Inst::VecRRR {
9085             op: VecBinaryOp::UMin128,
9086             rd: writable_vr(20),
9087             rn: vr(8),
9088             rm: vr(12),
9089         },
9090         "E748C00048FC",
9091         "vmnlq %v20, %v8, %v12",
9092     ));
9093     insns.push((
9094         Inst::VecRRR {
9095             op: VecBinaryOp::SMin8x16,
9096             rd: writable_vr(20),
9097             rn: vr(8),
9098             rm: vr(12),
9099         },
9100         "E748C00008FE",
9101         "vmnb %v20, %v8, %v12",
9102     ));
9103     insns.push((
9104         Inst::VecRRR {
9105             op: VecBinaryOp::SMin16x8,
9106             rd: writable_vr(20),
9107             rn: vr(8),
9108             rm: vr(12),
9109         },
9110         "E748C00018FE",
9111         "vmnh %v20, %v8, %v12",
9112     ));
9113     insns.push((
9114         Inst::VecRRR {
9115             op: VecBinaryOp::SMin32x4,
9116             rd: writable_vr(20),
9117             rn: vr(8),
9118             rm: vr(12),
9119         },
9120         "E748C00028FE",
9121         "vmnf %v20, %v8, %v12",
9122     ));
9123     insns.push((
9124         Inst::VecRRR {
9125             op: VecBinaryOp::SMin64x2,
9126             rd: writable_vr(20),
9127             rn: vr(8),
9128             rm: vr(12),
9129         },
9130         "E748C00038FE",
9131         "vmng %v20, %v8, %v12",
9132     ));
9133     insns.push((
9134         Inst::VecRRR {
9135             op: VecBinaryOp::SMin128,
9136             rd: writable_vr(20),
9137             rn: vr(8),
9138             rm: vr(12),
9139         },
9140         "E748C00048FE",
9141         "vmnq %v20, %v8, %v12",
9142     ));
9143     insns.push((
9144         Inst::VecRRR {
9145             op: VecBinaryOp::UAvg8x16,
9146             rd: writable_vr(20),
9147             rn: vr(8),
9148             rm: vr(12),
9149         },
9150         "E748C00008F0",
9151         "vavglb %v20, %v8, %v12",
9152     ));
9153     insns.push((
9154         Inst::VecRRR {
9155             op: VecBinaryOp::UAvg16x8,
9156             rd: writable_vr(20),
9157             rn: vr(8),
9158             rm: vr(12),
9159         },
9160         "E748C00018F0",
9161         "vavglh %v20, %v8, %v12",
9162     ));
9163     insns.push((
9164         Inst::VecRRR {
9165             op: VecBinaryOp::UAvg32x4,
9166             rd: writable_vr(20),
9167             rn: vr(8),
9168             rm: vr(12),
9169         },
9170         "E748C00028F0",
9171         "vavglf %v20, %v8, %v12",
9172     ));
9173     insns.push((
9174         Inst::VecRRR {
9175             op: VecBinaryOp::UAvg64x2,
9176             rd: writable_vr(20),
9177             rn: vr(8),
9178             rm: vr(12),
9179         },
9180         "E748C00038F0",
9181         "vavglg %v20, %v8, %v12",
9182     ));
9183     insns.push((
9184         Inst::VecRRR {
9185             op: VecBinaryOp::UAvg128,
9186             rd: writable_vr(20),
9187             rn: vr(8),
9188             rm: vr(12),
9189         },
9190         "E748C00048F0",
9191         "vavglq %v20, %v8, %v12",
9192     ));
9193     insns.push((
9194         Inst::VecRRR {
9195             op: VecBinaryOp::SAvg8x16,
9196             rd: writable_vr(20),
9197             rn: vr(8),
9198             rm: vr(12),
9199         },
9200         "E748C00008F2",
9201         "vavgb %v20, %v8, %v12",
9202     ));
9203     insns.push((
9204         Inst::VecRRR {
9205             op: VecBinaryOp::SAvg16x8,
9206             rd: writable_vr(20),
9207             rn: vr(8),
9208             rm: vr(12),
9209         },
9210         "E748C00018F2",
9211         "vavgh %v20, %v8, %v12",
9212     ));
9213     insns.push((
9214         Inst::VecRRR {
9215             op: VecBinaryOp::SAvg32x4,
9216             rd: writable_vr(20),
9217             rn: vr(8),
9218             rm: vr(12),
9219         },
9220         "E748C00028F2",
9221         "vavgf %v20, %v8, %v12",
9222     ));
9223     insns.push((
9224         Inst::VecRRR {
9225             op: VecBinaryOp::SAvg64x2,
9226             rd: writable_vr(20),
9227             rn: vr(8),
9228             rm: vr(12),
9229         },
9230         "E748C00038F2",
9231         "vavgg %v20, %v8, %v12",
9232     ));
9233     insns.push((
9234         Inst::VecRRR {
9235             op: VecBinaryOp::SAvg128,
9236             rd: writable_vr(20),
9237             rn: vr(8),
9238             rm: vr(12),
9239         },
9240         "E748C00048F2",
9241         "vavgq %v20, %v8, %v12",
9242     ));
9243     insns.push((
9244         Inst::VecRRR {
9245             op: VecBinaryOp::And128,
9246             rd: writable_vr(20),
9247             rn: vr(8),
9248             rm: vr(12),
9249         },
9250         "E748C0000868",
9251         "vn %v20, %v8, %v12",
9252     ));
9253     insns.push((
9254         Inst::VecRRR {
9255             op: VecBinaryOp::Orr128,
9256             rd: writable_vr(20),
9257             rn: vr(8),
9258             rm: vr(12),
9259         },
9260         "E748C000086A",
9261         "vo %v20, %v8, %v12",
9262     ));
9263     insns.push((
9264         Inst::VecRRR {
9265             op: VecBinaryOp::Xor128,
9266             rd: writable_vr(20),
9267             rn: vr(8),
9268             rm: vr(12),
9269         },
9270         "E748C000086D",
9271         "vx %v20, %v8, %v12",
9272     ));
9273     insns.push((
9274         Inst::VecRRR {
9275             op: VecBinaryOp::NotAnd128,
9276             rd: writable_vr(20),
9277             rn: vr(8),
9278             rm: vr(12),
9279         },
9280         "E748C000086E",
9281         "vnn %v20, %v8, %v12",
9282     ));
9283     insns.push((
9284         Inst::VecRRR {
9285             op: VecBinaryOp::NotOrr128,
9286             rd: writable_vr(20),
9287             rn: vr(8),
9288             rm: vr(12),
9289         },
9290         "E748C000086B",
9291         "vno %v20, %v8, %v12",
9292     ));
9293     insns.push((
9294         Inst::VecRRR {
9295             op: VecBinaryOp::NotXor128,
9296             rd: writable_vr(20),
9297             rn: vr(8),
9298             rm: vr(12),
9299         },
9300         "E748C000086C",
9301         "vnx %v20, %v8, %v12",
9302     ));
9303     insns.push((
9304         Inst::VecRRR {
9305             op: VecBinaryOp::AndNot128,
9306             rd: writable_vr(20),
9307             rn: vr(8),
9308             rm: vr(12),
9309         },
9310         "E748C0000869",
9311         "vnc %v20, %v8, %v12",
9312     ));
9313     insns.push((
9314         Inst::VecRRR {
9315             op: VecBinaryOp::OrrNot128,
9316             rd: writable_vr(20),
9317             rn: vr(8),
9318             rm: vr(12),
9319         },
9320         "E748C000086F",
9321         "voc %v20, %v8, %v12",
9322     ));
9323     insns.push((
9324         Inst::VecRRR {
9325             op: VecBinaryOp::BitPermute128,
9326             rd: writable_vr(20),
9327             rn: vr(8),
9328             rm: vr(12),
9329         },
9330         "E748C0000885",
9331         "vbperm %v20, %v8, %v12",
9332     ));
9333     insns.push((
9334         Inst::VecRRR {
9335             op: VecBinaryOp::LShLByByte128,
9336             rd: writable_vr(20),
9337             rn: vr(8),
9338             rm: vr(12),
9339         },
9340         "E748C0000875",
9341         "vslb %v20, %v8, %v12",
9342     ));
9343     insns.push((
9344         Inst::VecRRR {
9345             op: VecBinaryOp::LShRByByte128,
9346             rd: writable_vr(20),
9347             rn: vr(8),
9348             rm: vr(12),
9349         },
9350         "E748C000087D",
9351         "vsrlb %v20, %v8, %v12",
9352     ));
9353     insns.push((
9354         Inst::VecRRR {
9355             op: VecBinaryOp::AShRByByte128,
9356             rd: writable_vr(20),
9357             rn: vr(8),
9358             rm: vr(12),
9359         },
9360         "E748C000087F",
9361         "vsrab %v20, %v8, %v12",
9362     ));
9363     insns.push((
9364         Inst::VecRRR {
9365             op: VecBinaryOp::LShLByBit128,
9366             rd: writable_vr(20),
9367             rn: vr(8),
9368             rm: vr(12),
9369         },
9370         "E748C0000874",
9371         "vsl %v20, %v8, %v12",
9372     ));
9373     insns.push((
9374         Inst::VecRRR {
9375             op: VecBinaryOp::LShRByBit128,
9376             rd: writable_vr(20),
9377             rn: vr(8),
9378             rm: vr(12),
9379         },
9380         "E748C000087C",
9381         "vsrl %v20, %v8, %v12",
9382     ));
9383     insns.push((
9384         Inst::VecRRR {
9385             op: VecBinaryOp::AShRByBit128,
9386             rd: writable_vr(20),
9387             rn: vr(8),
9388             rm: vr(12),
9389         },
9390         "E748C000087E",
9391         "vsra %v20, %v8, %v12",
9392     ));
9393     insns.push((
9394         Inst::VecRRR {
9395             op: VecBinaryOp::Pack16x8,
9396             rd: writable_vr(20),
9397             rn: vr(8),
9398             rm: vr(12),
9399         },
9400         "E748C0001894",
9401         "vpkh %v20, %v8, %v12",
9402     ));
9403     insns.push((
9404         Inst::VecRRR {
9405             op: VecBinaryOp::Pack32x4,
9406             rd: writable_vr(20),
9407             rn: vr(8),
9408             rm: vr(12),
9409         },
9410         "E748C0002894",
9411         "vpkf %v20, %v8, %v12",
9412     ));
9413     insns.push((
9414         Inst::VecRRR {
9415             op: VecBinaryOp::Pack64x2,
9416             rd: writable_vr(20),
9417             rn: vr(8),
9418             rm: vr(12),
9419         },
9420         "E748C0003894",
9421         "vpkg %v20, %v8, %v12",
9422     ));
9423     insns.push((
9424         Inst::VecRRR {
9425             op: VecBinaryOp::PackUSat16x8,
9426             rd: writable_vr(20),
9427             rn: vr(8),
9428             rm: vr(12),
9429         },
9430         "E748C0001895",
9431         "vpklsh %v20, %v8, %v12",
9432     ));
9433     insns.push((
9434         Inst::VecRRR {
9435             op: VecBinaryOp::PackUSat32x4,
9436             rd: writable_vr(20),
9437             rn: vr(8),
9438             rm: vr(12),
9439         },
9440         "E748C0002895",
9441         "vpklsf %v20, %v8, %v12",
9442     ));
9443     insns.push((
9444         Inst::VecRRR {
9445             op: VecBinaryOp::PackUSat64x2,
9446             rd: writable_vr(20),
9447             rn: vr(8),
9448             rm: vr(12),
9449         },
9450         "E748C0003895",
9451         "vpklsg %v20, %v8, %v12",
9452     ));
9453     insns.push((
9454         Inst::VecRRR {
9455             op: VecBinaryOp::PackSSat16x8,
9456             rd: writable_vr(20),
9457             rn: vr(8),
9458             rm: vr(12),
9459         },
9460         "E748C0001897",
9461         "vpksh %v20, %v8, %v12",
9462     ));
9463     insns.push((
9464         Inst::VecRRR {
9465             op: VecBinaryOp::PackSSat32x4,
9466             rd: writable_vr(20),
9467             rn: vr(8),
9468             rm: vr(12),
9469         },
9470         "E748C0002897",
9471         "vpksf %v20, %v8, %v12",
9472     ));
9473     insns.push((
9474         Inst::VecRRR {
9475             op: VecBinaryOp::PackSSat64x2,
9476             rd: writable_vr(20),
9477             rn: vr(8),
9478             rm: vr(12),
9479         },
9480         "E748C0003897",
9481         "vpksg %v20, %v8, %v12",
9482     ));
9483     insns.push((
9484         Inst::VecRRR {
9485             op: VecBinaryOp::MergeLow8x16,
9486             rd: writable_vr(20),
9487             rn: vr(8),
9488             rm: vr(12),
9489         },
9490         "E748C0000860",
9491         "vmrlb %v20, %v8, %v12",
9492     ));
9493     insns.push((
9494         Inst::VecRRR {
9495             op: VecBinaryOp::MergeLow16x8,
9496             rd: writable_vr(20),
9497             rn: vr(8),
9498             rm: vr(12),
9499         },
9500         "E748C0001860",
9501         "vmrlh %v20, %v8, %v12",
9502     ));
9503     insns.push((
9504         Inst::VecRRR {
9505             op: VecBinaryOp::MergeLow32x4,
9506             rd: writable_vr(20),
9507             rn: vr(8),
9508             rm: vr(12),
9509         },
9510         "E748C0002860",
9511         "vmrlf %v20, %v8, %v12",
9512     ));
9513     insns.push((
9514         Inst::VecRRR {
9515             op: VecBinaryOp::MergeLow64x2,
9516             rd: writable_vr(20),
9517             rn: vr(8),
9518             rm: vr(12),
9519         },
9520         "E748C0003860",
9521         "vmrlg %v20, %v8, %v12",
9522     ));
9523     insns.push((
9524         Inst::VecRRR {
9525             op: VecBinaryOp::MergeHigh8x16,
9526             rd: writable_vr(20),
9527             rn: vr(8),
9528             rm: vr(12),
9529         },
9530         "E748C0000861",
9531         "vmrhb %v20, %v8, %v12",
9532     ));
9533     insns.push((
9534         Inst::VecRRR {
9535             op: VecBinaryOp::MergeHigh16x8,
9536             rd: writable_vr(20),
9537             rn: vr(8),
9538             rm: vr(12),
9539         },
9540         "E748C0001861",
9541         "vmrhh %v20, %v8, %v12",
9542     ));
9543     insns.push((
9544         Inst::VecRRR {
9545             op: VecBinaryOp::MergeHigh32x4,
9546             rd: writable_vr(20),
9547             rn: vr(8),
9548             rm: vr(12),
9549         },
9550         "E748C0002861",
9551         "vmrhf %v20, %v8, %v12",
9552     ));
9553     insns.push((
9554         Inst::VecRRR {
9555             op: VecBinaryOp::MergeHigh64x2,
9556             rd: writable_vr(20),
9557             rn: vr(8),
9558             rm: vr(12),
9559         },
9560         "E748C0003861",
9561         "vmrhg %v20, %v8, %v12",
9562     ));
9563 
9564     insns.push((
9565         Inst::VecRR {
9566             op: VecUnaryOp::Abs8x16,
9567             rd: writable_vr(20),
9568             rn: vr(8),
9569         },
9570         "E748000008DF",
9571         "vlpb %v20, %v8",
9572     ));
9573     insns.push((
9574         Inst::VecRR {
9575             op: VecUnaryOp::Abs16x8,
9576             rd: writable_vr(20),
9577             rn: vr(8),
9578         },
9579         "E748000018DF",
9580         "vlph %v20, %v8",
9581     ));
9582     insns.push((
9583         Inst::VecRR {
9584             op: VecUnaryOp::Abs32x4,
9585             rd: writable_vr(20),
9586             rn: vr(8),
9587         },
9588         "E748000028DF",
9589         "vlpf %v20, %v8",
9590     ));
9591     insns.push((
9592         Inst::VecRR {
9593             op: VecUnaryOp::Abs64x2,
9594             rd: writable_vr(20),
9595             rn: vr(8),
9596         },
9597         "E748000038DF",
9598         "vlpg %v20, %v8",
9599     ));
9600     insns.push((
9601         Inst::VecRR {
9602             op: VecUnaryOp::Abs128,
9603             rd: writable_vr(20),
9604             rn: vr(8),
9605         },
9606         "E748000048DF",
9607         "vlpq %v20, %v8",
9608     ));
9609     insns.push((
9610         Inst::VecRR {
9611             op: VecUnaryOp::Neg8x16,
9612             rd: writable_vr(20),
9613             rn: vr(8),
9614         },
9615         "E748000008DE",
9616         "vlcb %v20, %v8",
9617     ));
9618     insns.push((
9619         Inst::VecRR {
9620             op: VecUnaryOp::Neg16x8,
9621             rd: writable_vr(20),
9622             rn: vr(8),
9623         },
9624         "E748000018DE",
9625         "vlch %v20, %v8",
9626     ));
9627     insns.push((
9628         Inst::VecRR {
9629             op: VecUnaryOp::Neg32x4,
9630             rd: writable_vr(20),
9631             rn: vr(8),
9632         },
9633         "E748000028DE",
9634         "vlcf %v20, %v8",
9635     ));
9636     insns.push((
9637         Inst::VecRR {
9638             op: VecUnaryOp::Neg64x2,
9639             rd: writable_vr(20),
9640             rn: vr(8),
9641         },
9642         "E748000038DE",
9643         "vlcg %v20, %v8",
9644     ));
9645     insns.push((
9646         Inst::VecRR {
9647             op: VecUnaryOp::Neg128,
9648             rd: writable_vr(20),
9649             rn: vr(8),
9650         },
9651         "E748000048DE",
9652         "vlcq %v20, %v8",
9653     ));
9654     insns.push((
9655         Inst::VecRR {
9656             op: VecUnaryOp::Popcnt8x16,
9657             rd: writable_vr(20),
9658             rn: vr(8),
9659         },
9660         "E74800000850",
9661         "vpopctb %v20, %v8",
9662     ));
9663     insns.push((
9664         Inst::VecRR {
9665             op: VecUnaryOp::Popcnt16x8,
9666             rd: writable_vr(20),
9667             rn: vr(8),
9668         },
9669         "E74800001850",
9670         "vpopcth %v20, %v8",
9671     ));
9672     insns.push((
9673         Inst::VecRR {
9674             op: VecUnaryOp::Popcnt32x4,
9675             rd: writable_vr(20),
9676             rn: vr(8),
9677         },
9678         "E74800002850",
9679         "vpopctf %v20, %v8",
9680     ));
9681     insns.push((
9682         Inst::VecRR {
9683             op: VecUnaryOp::Popcnt64x2,
9684             rd: writable_vr(20),
9685             rn: vr(8),
9686         },
9687         "E74800003850",
9688         "vpopctg %v20, %v8",
9689     ));
9690     insns.push((
9691         Inst::VecRR {
9692             op: VecUnaryOp::Clz8x16,
9693             rd: writable_vr(20),
9694             rn: vr(8),
9695         },
9696         "E74800000853",
9697         "vclzb %v20, %v8",
9698     ));
9699     insns.push((
9700         Inst::VecRR {
9701             op: VecUnaryOp::Clz16x8,
9702             rd: writable_vr(20),
9703             rn: vr(8),
9704         },
9705         "E74800001853",
9706         "vclzh %v20, %v8",
9707     ));
9708     insns.push((
9709         Inst::VecRR {
9710             op: VecUnaryOp::Clz32x4,
9711             rd: writable_vr(20),
9712             rn: vr(8),
9713         },
9714         "E74800002853",
9715         "vclzf %v20, %v8",
9716     ));
9717     insns.push((
9718         Inst::VecRR {
9719             op: VecUnaryOp::Clz64x2,
9720             rd: writable_vr(20),
9721             rn: vr(8),
9722         },
9723         "E74800003853",
9724         "vclzg %v20, %v8",
9725     ));
9726     insns.push((
9727         Inst::VecRR {
9728             op: VecUnaryOp::Clz128,
9729             rd: writable_vr(20),
9730             rn: vr(8),
9731         },
9732         "E74800004853",
9733         "vclzq %v20, %v8",
9734     ));
9735     insns.push((
9736         Inst::VecRR {
9737             op: VecUnaryOp::Ctz8x16,
9738             rd: writable_vr(20),
9739             rn: vr(8),
9740         },
9741         "E74800000852",
9742         "vctzb %v20, %v8",
9743     ));
9744     insns.push((
9745         Inst::VecRR {
9746             op: VecUnaryOp::Ctz16x8,
9747             rd: writable_vr(20),
9748             rn: vr(8),
9749         },
9750         "E74800001852",
9751         "vctzh %v20, %v8",
9752     ));
9753     insns.push((
9754         Inst::VecRR {
9755             op: VecUnaryOp::Ctz32x4,
9756             rd: writable_vr(20),
9757             rn: vr(8),
9758         },
9759         "E74800002852",
9760         "vctzf %v20, %v8",
9761     ));
9762     insns.push((
9763         Inst::VecRR {
9764             op: VecUnaryOp::Ctz64x2,
9765             rd: writable_vr(20),
9766             rn: vr(8),
9767         },
9768         "E74800003852",
9769         "vctzg %v20, %v8",
9770     ));
9771     insns.push((
9772         Inst::VecRR {
9773             op: VecUnaryOp::Ctz128,
9774             rd: writable_vr(20),
9775             rn: vr(8),
9776         },
9777         "E74800004852",
9778         "vctzq %v20, %v8",
9779     ));
9780     insns.push((
9781         Inst::VecRR {
9782             op: VecUnaryOp::UnpackULow8x16,
9783             rd: writable_vr(20),
9784             rn: vr(8),
9785         },
9786         "E748000008D4",
9787         "vupllb %v20, %v8",
9788     ));
9789     insns.push((
9790         Inst::VecRR {
9791             op: VecUnaryOp::UnpackULow16x8,
9792             rd: writable_vr(20),
9793             rn: vr(8),
9794         },
9795         "E748000018D4",
9796         "vupllh %v20, %v8",
9797     ));
9798     insns.push((
9799         Inst::VecRR {
9800             op: VecUnaryOp::UnpackULow32x4,
9801             rd: writable_vr(20),
9802             rn: vr(8),
9803         },
9804         "E748000028D4",
9805         "vupllf %v20, %v8",
9806     ));
9807     insns.push((
9808         Inst::VecRR {
9809             op: VecUnaryOp::UnpackULow64x2,
9810             rd: writable_vr(20),
9811             rn: vr(8),
9812         },
9813         "E748000038D4",
9814         "vupllg %v20, %v8",
9815     ));
9816     insns.push((
9817         Inst::VecRR {
9818             op: VecUnaryOp::UnpackUHigh8x16,
9819             rd: writable_vr(20),
9820             rn: vr(8),
9821         },
9822         "E748000008D5",
9823         "vuplhb %v20, %v8",
9824     ));
9825     insns.push((
9826         Inst::VecRR {
9827             op: VecUnaryOp::UnpackUHigh16x8,
9828             rd: writable_vr(20),
9829             rn: vr(8),
9830         },
9831         "E748000018D5",
9832         "vuplhh %v20, %v8",
9833     ));
9834     insns.push((
9835         Inst::VecRR {
9836             op: VecUnaryOp::UnpackUHigh32x4,
9837             rd: writable_vr(20),
9838             rn: vr(8),
9839         },
9840         "E748000028D5",
9841         "vuplhf %v20, %v8",
9842     ));
9843     insns.push((
9844         Inst::VecRR {
9845             op: VecUnaryOp::UnpackUHigh64x2,
9846             rd: writable_vr(20),
9847             rn: vr(8),
9848         },
9849         "E748000038D5",
9850         "vuplhg %v20, %v8",
9851     ));
9852     insns.push((
9853         Inst::VecRR {
9854             op: VecUnaryOp::UnpackSLow8x16,
9855             rd: writable_vr(20),
9856             rn: vr(8),
9857         },
9858         "E748000008D6",
9859         "vuplb %v20, %v8",
9860     ));
9861     insns.push((
9862         Inst::VecRR {
9863             op: VecUnaryOp::UnpackSLow16x8,
9864             rd: writable_vr(20),
9865             rn: vr(8),
9866         },
9867         "E748000018D6",
9868         "vuplh %v20, %v8",
9869     ));
9870     insns.push((
9871         Inst::VecRR {
9872             op: VecUnaryOp::UnpackSLow32x4,
9873             rd: writable_vr(20),
9874             rn: vr(8),
9875         },
9876         "E748000028D6",
9877         "vuplf %v20, %v8",
9878     ));
9879     insns.push((
9880         Inst::VecRR {
9881             op: VecUnaryOp::UnpackSLow64x2,
9882             rd: writable_vr(20),
9883             rn: vr(8),
9884         },
9885         "E748000038D6",
9886         "vuplg %v20, %v8",
9887     ));
9888     insns.push((
9889         Inst::VecRR {
9890             op: VecUnaryOp::UnpackSHigh8x16,
9891             rd: writable_vr(20),
9892             rn: vr(8),
9893         },
9894         "E748000008D7",
9895         "vuphb %v20, %v8",
9896     ));
9897     insns.push((
9898         Inst::VecRR {
9899             op: VecUnaryOp::UnpackSHigh16x8,
9900             rd: writable_vr(20),
9901             rn: vr(8),
9902         },
9903         "E748000018D7",
9904         "vuphh %v20, %v8",
9905     ));
9906     insns.push((
9907         Inst::VecRR {
9908             op: VecUnaryOp::UnpackSHigh32x4,
9909             rd: writable_vr(20),
9910             rn: vr(8),
9911         },
9912         "E748000028D7",
9913         "vuphf %v20, %v8",
9914     ));
9915     insns.push((
9916         Inst::VecRR {
9917             op: VecUnaryOp::UnpackSHigh64x2,
9918             rd: writable_vr(20),
9919             rn: vr(8),
9920         },
9921         "E748000038D7",
9922         "vuphg %v20, %v8",
9923     ));
9924 
9925     insns.push((
9926         Inst::VecShiftRR {
9927             shift_op: VecShiftOp::RotL8x16,
9928             rd: writable_vr(20),
9929             rn: vr(5),
9930             shift_imm: 3,
9931             shift_reg: gpr(6),
9932         },
9933         "E74560030833",
9934         "verllb %v20, %v5, 3(%r6)",
9935     ));
9936     insns.push((
9937         Inst::VecShiftRR {
9938             shift_op: VecShiftOp::RotL16x8,
9939             rd: writable_vr(20),
9940             rn: vr(5),
9941             shift_imm: 3,
9942             shift_reg: gpr(6),
9943         },
9944         "E74560031833",
9945         "verllh %v20, %v5, 3(%r6)",
9946     ));
9947     insns.push((
9948         Inst::VecShiftRR {
9949             shift_op: VecShiftOp::RotL32x4,
9950             rd: writable_vr(20),
9951             rn: vr(5),
9952             shift_imm: 3,
9953             shift_reg: gpr(6),
9954         },
9955         "E74560032833",
9956         "verllf %v20, %v5, 3(%r6)",
9957     ));
9958     insns.push((
9959         Inst::VecShiftRR {
9960             shift_op: VecShiftOp::RotL64x2,
9961             rd: writable_vr(20),
9962             rn: vr(5),
9963             shift_imm: 3,
9964             shift_reg: gpr(6),
9965         },
9966         "E74560033833",
9967         "verllg %v20, %v5, 3(%r6)",
9968     ));
9969     insns.push((
9970         Inst::VecShiftRR {
9971             shift_op: VecShiftOp::LShL8x16,
9972             rd: writable_vr(20),
9973             rn: vr(5),
9974             shift_imm: 3,
9975             shift_reg: gpr(6),
9976         },
9977         "E74560030830",
9978         "veslb %v20, %v5, 3(%r6)",
9979     ));
9980     insns.push((
9981         Inst::VecShiftRR {
9982             shift_op: VecShiftOp::LShL16x8,
9983             rd: writable_vr(20),
9984             rn: vr(5),
9985             shift_imm: 3,
9986             shift_reg: gpr(6),
9987         },
9988         "E74560031830",
9989         "veslh %v20, %v5, 3(%r6)",
9990     ));
9991     insns.push((
9992         Inst::VecShiftRR {
9993             shift_op: VecShiftOp::LShL32x4,
9994             rd: writable_vr(20),
9995             rn: vr(5),
9996             shift_imm: 3,
9997             shift_reg: gpr(6),
9998         },
9999         "E74560032830",
10000         "veslf %v20, %v5, 3(%r6)",
10001     ));
10002     insns.push((
10003         Inst::VecShiftRR {
10004             shift_op: VecShiftOp::LShL64x2,
10005             rd: writable_vr(20),
10006             rn: vr(5),
10007             shift_imm: 3,
10008             shift_reg: gpr(6),
10009         },
10010         "E74560033830",
10011         "veslg %v20, %v5, 3(%r6)",
10012     ));
10013     insns.push((
10014         Inst::VecShiftRR {
10015             shift_op: VecShiftOp::LShR8x16,
10016             rd: writable_vr(20),
10017             rn: vr(5),
10018             shift_imm: 3,
10019             shift_reg: gpr(6),
10020         },
10021         "E74560030838",
10022         "vesrlb %v20, %v5, 3(%r6)",
10023     ));
10024     insns.push((
10025         Inst::VecShiftRR {
10026             shift_op: VecShiftOp::LShR16x8,
10027             rd: writable_vr(20),
10028             rn: vr(5),
10029             shift_imm: 3,
10030             shift_reg: gpr(6),
10031         },
10032         "E74560031838",
10033         "vesrlh %v20, %v5, 3(%r6)",
10034     ));
10035     insns.push((
10036         Inst::VecShiftRR {
10037             shift_op: VecShiftOp::LShR32x4,
10038             rd: writable_vr(20),
10039             rn: vr(5),
10040             shift_imm: 3,
10041             shift_reg: gpr(6),
10042         },
10043         "E74560032838",
10044         "vesrlf %v20, %v5, 3(%r6)",
10045     ));
10046     insns.push((
10047         Inst::VecShiftRR {
10048             shift_op: VecShiftOp::LShR64x2,
10049             rd: writable_vr(20),
10050             rn: vr(5),
10051             shift_imm: 3,
10052             shift_reg: gpr(6),
10053         },
10054         "E74560033838",
10055         "vesrlg %v20, %v5, 3(%r6)",
10056     ));
10057     insns.push((
10058         Inst::VecShiftRR {
10059             shift_op: VecShiftOp::AShR8x16,
10060             rd: writable_vr(20),
10061             rn: vr(5),
10062             shift_imm: 3,
10063             shift_reg: gpr(6),
10064         },
10065         "E7456003083A",
10066         "vesrab %v20, %v5, 3(%r6)",
10067     ));
10068     insns.push((
10069         Inst::VecShiftRR {
10070             shift_op: VecShiftOp::AShR16x8,
10071             rd: writable_vr(20),
10072             rn: vr(5),
10073             shift_imm: 3,
10074             shift_reg: gpr(6),
10075         },
10076         "E7456003183A",
10077         "vesrah %v20, %v5, 3(%r6)",
10078     ));
10079     insns.push((
10080         Inst::VecShiftRR {
10081             shift_op: VecShiftOp::AShR32x4,
10082             rd: writable_vr(20),
10083             rn: vr(5),
10084             shift_imm: 3,
10085             shift_reg: gpr(6),
10086         },
10087         "E7456003283A",
10088         "vesraf %v20, %v5, 3(%r6)",
10089     ));
10090     insns.push((
10091         Inst::VecShiftRR {
10092             shift_op: VecShiftOp::AShR64x2,
10093             rd: writable_vr(20),
10094             rn: vr(5),
10095             shift_imm: 3,
10096             shift_reg: gpr(6),
10097         },
10098         "E7456003383A",
10099         "vesrag %v20, %v5, 3(%r6)",
10100     ));
10101 
10102     insns.push((
10103         Inst::VecSelect {
10104             rd: writable_vr(4),
10105             rn: vr(6),
10106             rm: vr(8),
10107             ra: vr(10),
10108         },
10109         "E7468000A08D",
10110         "vsel %v4, %v6, %v8, %v10",
10111     ));
10112     insns.push((
10113         Inst::VecSelect {
10114             rd: writable_vr(20),
10115             rn: vr(6),
10116             rm: vr(8),
10117             ra: vr(10),
10118         },
10119         "E7468000A88D",
10120         "vsel %v20, %v6, %v8, %v10",
10121     ));
10122     insns.push((
10123         Inst::VecSelect {
10124             rd: writable_vr(4),
10125             rn: vr(22),
10126             rm: vr(8),
10127             ra: vr(10),
10128         },
10129         "E7468000A48D",
10130         "vsel %v4, %v22, %v8, %v10",
10131     ));
10132     insns.push((
10133         Inst::VecSelect {
10134             rd: writable_vr(4),
10135             rn: vr(6),
10136             rm: vr(24),
10137             ra: vr(10),
10138         },
10139         "E7468000A28D",
10140         "vsel %v4, %v6, %v24, %v10",
10141     ));
10142     insns.push((
10143         Inst::VecSelect {
10144             rd: writable_vr(4),
10145             rn: vr(6),
10146             rm: vr(8),
10147             ra: vr(26),
10148         },
10149         "E7468000A18D",
10150         "vsel %v4, %v6, %v8, %v26",
10151     ));
10152     insns.push((
10153         Inst::VecSelect {
10154             rd: writable_vr(20),
10155             rn: vr(22),
10156             rm: vr(24),
10157             ra: vr(26),
10158         },
10159         "E7468000AF8D",
10160         "vsel %v20, %v22, %v24, %v26",
10161     ));
10162     insns.push((
10163         Inst::VecPermute {
10164             rd: writable_vr(4),
10165             rn: vr(6),
10166             rm: vr(8),
10167             ra: vr(10),
10168         },
10169         "E7468000A08C",
10170         "vperm %v4, %v6, %v8, %v10",
10171     ));
10172     insns.push((
10173         Inst::VecPermute {
10174             rd: writable_vr(20),
10175             rn: vr(6),
10176             rm: vr(8),
10177             ra: vr(10),
10178         },
10179         "E7468000A88C",
10180         "vperm %v20, %v6, %v8, %v10",
10181     ));
10182     insns.push((
10183         Inst::VecPermute {
10184             rd: writable_vr(4),
10185             rn: vr(22),
10186             rm: vr(8),
10187             ra: vr(10),
10188         },
10189         "E7468000A48C",
10190         "vperm %v4, %v22, %v8, %v10",
10191     ));
10192     insns.push((
10193         Inst::VecPermute {
10194             rd: writable_vr(4),
10195             rn: vr(6),
10196             rm: vr(24),
10197             ra: vr(10),
10198         },
10199         "E7468000A28C",
10200         "vperm %v4, %v6, %v24, %v10",
10201     ));
10202     insns.push((
10203         Inst::VecPermute {
10204             rd: writable_vr(4),
10205             rn: vr(6),
10206             rm: vr(8),
10207             ra: vr(26),
10208         },
10209         "E7468000A18C",
10210         "vperm %v4, %v6, %v8, %v26",
10211     ));
10212     insns.push((
10213         Inst::VecPermute {
10214             rd: writable_vr(20),
10215             rn: vr(22),
10216             rm: vr(24),
10217             ra: vr(26),
10218         },
10219         "E7468000AF8C",
10220         "vperm %v20, %v22, %v24, %v26",
10221     ));
10222     insns.push((
10223         Inst::VecPermuteDWImm {
10224             rd: writable_vr(20),
10225             rn: vr(6),
10226             rm: vr(8),
10227             idx1: 0,
10228             idx2: 0,
10229         },
10230         "E74680000884",
10231         "vpdi %v20, %v6, %v8, 0",
10232     ));
10233     insns.push((
10234         Inst::VecPermuteDWImm {
10235             rd: writable_vr(20),
10236             rn: vr(6),
10237             rm: vr(8),
10238             idx1: 0,
10239             idx2: 1,
10240         },
10241         "E74680001884",
10242         "vpdi %v20, %v6, %v8, 1",
10243     ));
10244     insns.push((
10245         Inst::VecPermuteDWImm {
10246             rd: writable_vr(20),
10247             rn: vr(6),
10248             rm: vr(8),
10249             idx1: 1,
10250             idx2: 0,
10251         },
10252         "E74680004884",
10253         "vpdi %v20, %v6, %v8, 4",
10254     ));
10255     insns.push((
10256         Inst::VecPermuteDWImm {
10257             rd: writable_vr(20),
10258             rn: vr(6),
10259             rm: vr(8),
10260             idx1: 1,
10261             idx2: 1,
10262         },
10263         "E74680005884",
10264         "vpdi %v20, %v6, %v8, 5",
10265     ));
10266 
10267     insns.push((
10268         Inst::VecIntCmp {
10269             op: VecIntCmpOp::CmpEq8x16,
10270             rd: writable_vr(20),
10271             rn: vr(8),
10272             rm: vr(12),
10273         },
10274         "E748C00008F8",
10275         "vceqb %v20, %v8, %v12",
10276     ));
10277     insns.push((
10278         Inst::VecIntCmp {
10279             op: VecIntCmpOp::CmpEq16x8,
10280             rd: writable_vr(20),
10281             rn: vr(8),
10282             rm: vr(12),
10283         },
10284         "E748C00018F8",
10285         "vceqh %v20, %v8, %v12",
10286     ));
10287     insns.push((
10288         Inst::VecIntCmp {
10289             op: VecIntCmpOp::CmpEq32x4,
10290             rd: writable_vr(20),
10291             rn: vr(8),
10292             rm: vr(12),
10293         },
10294         "E748C00028F8",
10295         "vceqf %v20, %v8, %v12",
10296     ));
10297     insns.push((
10298         Inst::VecIntCmp {
10299             op: VecIntCmpOp::CmpEq64x2,
10300             rd: writable_vr(20),
10301             rn: vr(8),
10302             rm: vr(12),
10303         },
10304         "E748C00038F8",
10305         "vceqg %v20, %v8, %v12",
10306     ));
10307     insns.push((
10308         Inst::VecIntCmp {
10309             op: VecIntCmpOp::CmpEq128,
10310             rd: writable_vr(20),
10311             rn: vr(8),
10312             rm: vr(12),
10313         },
10314         "E748C00048F8",
10315         "vceqq %v20, %v8, %v12",
10316     ));
10317     insns.push((
10318         Inst::VecIntCmp {
10319             op: VecIntCmpOp::SCmpHi8x16,
10320             rd: writable_vr(20),
10321             rn: vr(8),
10322             rm: vr(12),
10323         },
10324         "E748C00008FB",
10325         "vchb %v20, %v8, %v12",
10326     ));
10327     insns.push((
10328         Inst::VecIntCmp {
10329             op: VecIntCmpOp::SCmpHi16x8,
10330             rd: writable_vr(20),
10331             rn: vr(8),
10332             rm: vr(12),
10333         },
10334         "E748C00018FB",
10335         "vchh %v20, %v8, %v12",
10336     ));
10337     insns.push((
10338         Inst::VecIntCmp {
10339             op: VecIntCmpOp::SCmpHi32x4,
10340             rd: writable_vr(20),
10341             rn: vr(8),
10342             rm: vr(12),
10343         },
10344         "E748C00028FB",
10345         "vchf %v20, %v8, %v12",
10346     ));
10347     insns.push((
10348         Inst::VecIntCmp {
10349             op: VecIntCmpOp::SCmpHi64x2,
10350             rd: writable_vr(20),
10351             rn: vr(8),
10352             rm: vr(12),
10353         },
10354         "E748C00038FB",
10355         "vchg %v20, %v8, %v12",
10356     ));
10357     insns.push((
10358         Inst::VecIntCmp {
10359             op: VecIntCmpOp::SCmpHi128,
10360             rd: writable_vr(20),
10361             rn: vr(8),
10362             rm: vr(12),
10363         },
10364         "E748C00048FB",
10365         "vchq %v20, %v8, %v12",
10366     ));
10367     insns.push((
10368         Inst::VecIntCmp {
10369             op: VecIntCmpOp::UCmpHi8x16,
10370             rd: writable_vr(20),
10371             rn: vr(8),
10372             rm: vr(12),
10373         },
10374         "E748C00008F9",
10375         "vchlb %v20, %v8, %v12",
10376     ));
10377     insns.push((
10378         Inst::VecIntCmp {
10379             op: VecIntCmpOp::UCmpHi16x8,
10380             rd: writable_vr(20),
10381             rn: vr(8),
10382             rm: vr(12),
10383         },
10384         "E748C00018F9",
10385         "vchlh %v20, %v8, %v12",
10386     ));
10387     insns.push((
10388         Inst::VecIntCmp {
10389             op: VecIntCmpOp::UCmpHi32x4,
10390             rd: writable_vr(20),
10391             rn: vr(8),
10392             rm: vr(12),
10393         },
10394         "E748C00028F9",
10395         "vchlf %v20, %v8, %v12",
10396     ));
10397     insns.push((
10398         Inst::VecIntCmp {
10399             op: VecIntCmpOp::UCmpHi64x2,
10400             rd: writable_vr(20),
10401             rn: vr(8),
10402             rm: vr(12),
10403         },
10404         "E748C00038F9",
10405         "vchlg %v20, %v8, %v12",
10406     ));
10407     insns.push((
10408         Inst::VecIntCmp {
10409             op: VecIntCmpOp::UCmpHi128,
10410             rd: writable_vr(20),
10411             rn: vr(8),
10412             rm: vr(12),
10413         },
10414         "E748C00048F9",
10415         "vchlq %v20, %v8, %v12",
10416     ));
10417     insns.push((
10418         Inst::VecIntCmpS {
10419             op: VecIntCmpOp::CmpEq8x16,
10420             rd: writable_vr(20),
10421             rn: vr(8),
10422             rm: vr(12),
10423         },
10424         "E748C01008F8",
10425         "vceqbs %v20, %v8, %v12",
10426     ));
10427     insns.push((
10428         Inst::VecIntCmpS {
10429             op: VecIntCmpOp::CmpEq16x8,
10430             rd: writable_vr(20),
10431             rn: vr(8),
10432             rm: vr(12),
10433         },
10434         "E748C01018F8",
10435         "vceqhs %v20, %v8, %v12",
10436     ));
10437     insns.push((
10438         Inst::VecIntCmpS {
10439             op: VecIntCmpOp::CmpEq32x4,
10440             rd: writable_vr(20),
10441             rn: vr(8),
10442             rm: vr(12),
10443         },
10444         "E748C01028F8",
10445         "vceqfs %v20, %v8, %v12",
10446     ));
10447     insns.push((
10448         Inst::VecIntCmpS {
10449             op: VecIntCmpOp::CmpEq64x2,
10450             rd: writable_vr(20),
10451             rn: vr(8),
10452             rm: vr(12),
10453         },
10454         "E748C01038F8",
10455         "vceqgs %v20, %v8, %v12",
10456     ));
10457     insns.push((
10458         Inst::VecIntCmpS {
10459             op: VecIntCmpOp::CmpEq128,
10460             rd: writable_vr(20),
10461             rn: vr(8),
10462             rm: vr(12),
10463         },
10464         "E748C01048F8",
10465         "vceqqs %v20, %v8, %v12",
10466     ));
10467     insns.push((
10468         Inst::VecIntCmpS {
10469             op: VecIntCmpOp::SCmpHi8x16,
10470             rd: writable_vr(20),
10471             rn: vr(8),
10472             rm: vr(12),
10473         },
10474         "E748C01008FB",
10475         "vchbs %v20, %v8, %v12",
10476     ));
10477     insns.push((
10478         Inst::VecIntCmpS {
10479             op: VecIntCmpOp::SCmpHi16x8,
10480             rd: writable_vr(20),
10481             rn: vr(8),
10482             rm: vr(12),
10483         },
10484         "E748C01018FB",
10485         "vchhs %v20, %v8, %v12",
10486     ));
10487     insns.push((
10488         Inst::VecIntCmpS {
10489             op: VecIntCmpOp::SCmpHi32x4,
10490             rd: writable_vr(20),
10491             rn: vr(8),
10492             rm: vr(12),
10493         },
10494         "E748C01028FB",
10495         "vchfs %v20, %v8, %v12",
10496     ));
10497     insns.push((
10498         Inst::VecIntCmpS {
10499             op: VecIntCmpOp::SCmpHi64x2,
10500             rd: writable_vr(20),
10501             rn: vr(8),
10502             rm: vr(12),
10503         },
10504         "E748C01038FB",
10505         "vchgs %v20, %v8, %v12",
10506     ));
10507     insns.push((
10508         Inst::VecIntCmpS {
10509             op: VecIntCmpOp::SCmpHi128,
10510             rd: writable_vr(20),
10511             rn: vr(8),
10512             rm: vr(12),
10513         },
10514         "E748C01048FB",
10515         "vchqs %v20, %v8, %v12",
10516     ));
10517     insns.push((
10518         Inst::VecIntCmpS {
10519             op: VecIntCmpOp::UCmpHi8x16,
10520             rd: writable_vr(20),
10521             rn: vr(8),
10522             rm: vr(12),
10523         },
10524         "E748C01008F9",
10525         "vchlbs %v20, %v8, %v12",
10526     ));
10527     insns.push((
10528         Inst::VecIntCmpS {
10529             op: VecIntCmpOp::UCmpHi16x8,
10530             rd: writable_vr(20),
10531             rn: vr(8),
10532             rm: vr(12),
10533         },
10534         "E748C01018F9",
10535         "vchlhs %v20, %v8, %v12",
10536     ));
10537     insns.push((
10538         Inst::VecIntCmpS {
10539             op: VecIntCmpOp::UCmpHi32x4,
10540             rd: writable_vr(20),
10541             rn: vr(8),
10542             rm: vr(12),
10543         },
10544         "E748C01028F9",
10545         "vchlfs %v20, %v8, %v12",
10546     ));
10547     insns.push((
10548         Inst::VecIntCmpS {
10549             op: VecIntCmpOp::UCmpHi64x2,
10550             rd: writable_vr(20),
10551             rn: vr(8),
10552             rm: vr(12),
10553         },
10554         "E748C01038F9",
10555         "vchlgs %v20, %v8, %v12",
10556     ));
10557     insns.push((
10558         Inst::VecIntCmpS {
10559             op: VecIntCmpOp::UCmpHi128,
10560             rd: writable_vr(20),
10561             rn: vr(8),
10562             rm: vr(12),
10563         },
10564         "E748C01048F9",
10565         "vchlqs %v20, %v8, %v12",
10566     ));
10567     insns.push((
10568         Inst::VecIntEltCmp {
10569             op: VecIntEltCmpOp::SCmp128,
10570             rn: vr(20),
10571             rm: vr(12),
10572         },
10573         "E74C000048DB",
10574         "vecq %v20, %v12",
10575     ));
10576     insns.push((
10577         Inst::VecIntEltCmp {
10578             op: VecIntEltCmpOp::UCmp128,
10579             rn: vr(20),
10580             rm: vr(12),
10581         },
10582         "E74C000048D9",
10583         "veclq %v20, %v12",
10584     ));
10585     insns.push((
10586         Inst::VecEvaluate {
10587             imm: 0x02,
10588             rd: writable_vr(12),
10589             rn: vr(20),
10590             rm: vr(21),
10591             ra: vr(22),
10592         },
10593         "E7C450026788",
10594         "veval %v12, %v20, %v21, %v22, 2",
10595     ));
10596     insns.push((
10597         Inst::VecBlend {
10598             rd: writable_vr(12),
10599             rn: vr(20),
10600             rm: vr(21),
10601             ra: vr(22),
10602         },
10603         "E7C450006789",
10604         "vblend %v12, %v20, %v21, %v22",
10605     ));
10606     insns.push((
10607         Inst::VecInt128SCmpHi {
10608             tmp: writable_vr(20),
10609             rn: vr(8),
10610             rm: vr(12),
10611         },
10612         "E7C8000030DBA7740005E748C01038F9",
10613         "vecg %v12, %v8 ; jne 10 ; vchlgs %v20, %v8, %v12",
10614     ));
10615     insns.push((
10616         Inst::VecInt128UCmpHi {
10617             tmp: writable_vr(20),
10618             rn: vr(8),
10619             rm: vr(12),
10620         },
10621         "E7C8000030D9A7740005E748C01038F9",
10622         "veclg %v12, %v8 ; jne 10 ; vchlgs %v20, %v8, %v12",
10623     ));
10624 
10625     insns.push((
10626         Inst::VecFloatCmp {
10627             op: VecFloatCmpOp::CmpEq32x4,
10628             rd: writable_vr(20),
10629             rn: vr(8),
10630             rm: vr(12),
10631         },
10632         "E748C00028E8",
10633         "vfcesb %v20, %v8, %v12",
10634     ));
10635     insns.push((
10636         Inst::VecFloatCmp {
10637             op: VecFloatCmpOp::CmpEq64x2,
10638             rd: writable_vr(20),
10639             rn: vr(8),
10640             rm: vr(12),
10641         },
10642         "E748C00038E8",
10643         "vfcedb %v20, %v8, %v12",
10644     ));
10645     insns.push((
10646         Inst::VecFloatCmp {
10647             op: VecFloatCmpOp::CmpHi32x4,
10648             rd: writable_vr(20),
10649             rn: vr(8),
10650             rm: vr(12),
10651         },
10652         "E748C00028EB",
10653         "vfchsb %v20, %v8, %v12",
10654     ));
10655     insns.push((
10656         Inst::VecFloatCmp {
10657             op: VecFloatCmpOp::CmpHi64x2,
10658             rd: writable_vr(20),
10659             rn: vr(8),
10660             rm: vr(12),
10661         },
10662         "E748C00038EB",
10663         "vfchdb %v20, %v8, %v12",
10664     ));
10665     insns.push((
10666         Inst::VecFloatCmp {
10667             op: VecFloatCmpOp::CmpHiEq32x4,
10668             rd: writable_vr(20),
10669             rn: vr(8),
10670             rm: vr(12),
10671         },
10672         "E748C00028EA",
10673         "vfchesb %v20, %v8, %v12",
10674     ));
10675     insns.push((
10676         Inst::VecFloatCmp {
10677             op: VecFloatCmpOp::CmpHiEq64x2,
10678             rd: writable_vr(20),
10679             rn: vr(8),
10680             rm: vr(12),
10681         },
10682         "E748C00038EA",
10683         "vfchedb %v20, %v8, %v12",
10684     ));
10685     insns.push((
10686         Inst::VecFloatCmpS {
10687             op: VecFloatCmpOp::CmpEq32x4,
10688             rd: writable_vr(20),
10689             rn: vr(8),
10690             rm: vr(12),
10691         },
10692         "E748C01028E8",
10693         "vfcesbs %v20, %v8, %v12",
10694     ));
10695     insns.push((
10696         Inst::VecFloatCmpS {
10697             op: VecFloatCmpOp::CmpEq64x2,
10698             rd: writable_vr(20),
10699             rn: vr(8),
10700             rm: vr(12),
10701         },
10702         "E748C01038E8",
10703         "vfcedbs %v20, %v8, %v12",
10704     ));
10705     insns.push((
10706         Inst::VecFloatCmpS {
10707             op: VecFloatCmpOp::CmpHi32x4,
10708             rd: writable_vr(20),
10709             rn: vr(8),
10710             rm: vr(12),
10711         },
10712         "E748C01028EB",
10713         "vfchsbs %v20, %v8, %v12",
10714     ));
10715     insns.push((
10716         Inst::VecFloatCmpS {
10717             op: VecFloatCmpOp::CmpHi64x2,
10718             rd: writable_vr(20),
10719             rn: vr(8),
10720             rm: vr(12),
10721         },
10722         "E748C01038EB",
10723         "vfchdbs %v20, %v8, %v12",
10724     ));
10725     insns.push((
10726         Inst::VecFloatCmpS {
10727             op: VecFloatCmpOp::CmpHiEq32x4,
10728             rd: writable_vr(20),
10729             rn: vr(8),
10730             rm: vr(12),
10731         },
10732         "E748C01028EA",
10733         "vfchesbs %v20, %v8, %v12",
10734     ));
10735     insns.push((
10736         Inst::VecFloatCmpS {
10737             op: VecFloatCmpOp::CmpHiEq64x2,
10738             rd: writable_vr(20),
10739             rn: vr(8),
10740             rm: vr(12),
10741         },
10742         "E748C01038EA",
10743         "vfchedbs %v20, %v8, %v12",
10744     ));
10745 
10746     insns.push((
10747         Inst::VecLoad {
10748             rd: writable_vr(17),
10749             mem: MemArg::BXD12 {
10750                 base: gpr(2),
10751                 index: zero_reg(),
10752                 disp: UImm12::zero(),
10753                 flags: MemFlags::trusted(),
10754             },
10755         },
10756         "E71020000806",
10757         "vl %v17, 0(%r2)",
10758     ));
10759     insns.push((
10760         Inst::VecLoad {
10761             rd: writable_vr(17),
10762             mem: MemArg::BXD12 {
10763                 base: gpr(2),
10764                 index: zero_reg(),
10765                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10766                 flags: MemFlags::trusted(),
10767             },
10768         },
10769         "E7102FFF0806",
10770         "vl %v17, 4095(%r2)",
10771     ));
10772     insns.push((
10773         Inst::VecLoad {
10774             rd: writable_vr(17),
10775             mem: MemArg::BXD12 {
10776                 base: gpr(3),
10777                 index: gpr(2),
10778                 disp: UImm12::zero(),
10779                 flags: MemFlags::trusted(),
10780             },
10781         },
10782         "E71230000806",
10783         "vl %v17, 0(%r2,%r3)",
10784     ));
10785     insns.push((
10786         Inst::VecLoadRev {
10787             rd: writable_vr(17),
10788             mem: MemArg::BXD12 {
10789                 base: gpr(2),
10790                 index: zero_reg(),
10791                 disp: UImm12::zero(),
10792                 flags: MemFlags::trusted(),
10793             },
10794         },
10795         "E61020004806",
10796         "vlbrq %v17, 0(%r2)",
10797     ));
10798     insns.push((
10799         Inst::VecLoadRev {
10800             rd: writable_vr(17),
10801             mem: MemArg::BXD12 {
10802                 base: gpr(2),
10803                 index: zero_reg(),
10804                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10805                 flags: MemFlags::trusted(),
10806             },
10807         },
10808         "E6102FFF4806",
10809         "vlbrq %v17, 4095(%r2)",
10810     ));
10811     insns.push((
10812         Inst::VecLoadRev {
10813             rd: writable_vr(17),
10814             mem: MemArg::BXD12 {
10815                 base: gpr(3),
10816                 index: gpr(2),
10817                 disp: UImm12::zero(),
10818                 flags: MemFlags::trusted(),
10819             },
10820         },
10821         "E61230004806",
10822         "vlbrq %v17, 0(%r2,%r3)",
10823     ));
10824     insns.push((
10825         Inst::VecLoadByte16Rev {
10826             rd: writable_vr(17),
10827             mem: MemArg::BXD12 {
10828                 base: gpr(2),
10829                 index: zero_reg(),
10830                 disp: UImm12::zero(),
10831                 flags: MemFlags::trusted(),
10832             },
10833         },
10834         "E61020001806",
10835         "vlbrh %v17, 0(%r2)",
10836     ));
10837     insns.push((
10838         Inst::VecLoadByte16Rev {
10839             rd: writable_vr(17),
10840             mem: MemArg::BXD12 {
10841                 base: gpr(2),
10842                 index: zero_reg(),
10843                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10844                 flags: MemFlags::trusted(),
10845             },
10846         },
10847         "E6102FFF1806",
10848         "vlbrh %v17, 4095(%r2)",
10849     ));
10850     insns.push((
10851         Inst::VecLoadByte16Rev {
10852             rd: writable_vr(17),
10853             mem: MemArg::BXD12 {
10854                 base: gpr(3),
10855                 index: gpr(2),
10856                 disp: UImm12::zero(),
10857                 flags: MemFlags::trusted(),
10858             },
10859         },
10860         "E61230001806",
10861         "vlbrh %v17, 0(%r2,%r3)",
10862     ));
10863     insns.push((
10864         Inst::VecLoadByte32Rev {
10865             rd: writable_vr(17),
10866             mem: MemArg::BXD12 {
10867                 base: gpr(2),
10868                 index: zero_reg(),
10869                 disp: UImm12::zero(),
10870                 flags: MemFlags::trusted(),
10871             },
10872         },
10873         "E61020002806",
10874         "vlbrf %v17, 0(%r2)",
10875     ));
10876     insns.push((
10877         Inst::VecLoadByte32Rev {
10878             rd: writable_vr(17),
10879             mem: MemArg::BXD12 {
10880                 base: gpr(2),
10881                 index: zero_reg(),
10882                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10883                 flags: MemFlags::trusted(),
10884             },
10885         },
10886         "E6102FFF2806",
10887         "vlbrf %v17, 4095(%r2)",
10888     ));
10889     insns.push((
10890         Inst::VecLoadByte32Rev {
10891             rd: writable_vr(17),
10892             mem: MemArg::BXD12 {
10893                 base: gpr(3),
10894                 index: gpr(2),
10895                 disp: UImm12::zero(),
10896                 flags: MemFlags::trusted(),
10897             },
10898         },
10899         "E61230002806",
10900         "vlbrf %v17, 0(%r2,%r3)",
10901     ));
10902     insns.push((
10903         Inst::VecLoadByte64Rev {
10904             rd: writable_vr(17),
10905             mem: MemArg::BXD12 {
10906                 base: gpr(2),
10907                 index: zero_reg(),
10908                 disp: UImm12::zero(),
10909                 flags: MemFlags::trusted(),
10910             },
10911         },
10912         "E61020003806",
10913         "vlbrg %v17, 0(%r2)",
10914     ));
10915     insns.push((
10916         Inst::VecLoadByte64Rev {
10917             rd: writable_vr(17),
10918             mem: MemArg::BXD12 {
10919                 base: gpr(2),
10920                 index: zero_reg(),
10921                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10922                 flags: MemFlags::trusted(),
10923             },
10924         },
10925         "E6102FFF3806",
10926         "vlbrg %v17, 4095(%r2)",
10927     ));
10928     insns.push((
10929         Inst::VecLoadByte64Rev {
10930             rd: writable_vr(17),
10931             mem: MemArg::BXD12 {
10932                 base: gpr(3),
10933                 index: gpr(2),
10934                 disp: UImm12::zero(),
10935                 flags: MemFlags::trusted(),
10936             },
10937         },
10938         "E61230003806",
10939         "vlbrg %v17, 0(%r2,%r3)",
10940     ));
10941     insns.push((
10942         Inst::VecLoadElt16Rev {
10943             rd: writable_vr(17),
10944             mem: MemArg::BXD12 {
10945                 base: gpr(2),
10946                 index: zero_reg(),
10947                 disp: UImm12::zero(),
10948                 flags: MemFlags::trusted(),
10949             },
10950         },
10951         "E61020001807",
10952         "vlerh %v17, 0(%r2)",
10953     ));
10954     insns.push((
10955         Inst::VecLoadElt16Rev {
10956             rd: writable_vr(17),
10957             mem: MemArg::BXD12 {
10958                 base: gpr(2),
10959                 index: zero_reg(),
10960                 disp: UImm12::maybe_from_u64(4095).unwrap(),
10961                 flags: MemFlags::trusted(),
10962             },
10963         },
10964         "E6102FFF1807",
10965         "vlerh %v17, 4095(%r2)",
10966     ));
10967     insns.push((
10968         Inst::VecLoadElt16Rev {
10969             rd: writable_vr(17),
10970             mem: MemArg::BXD12 {
10971                 base: gpr(3),
10972                 index: gpr(2),
10973                 disp: UImm12::zero(),
10974                 flags: MemFlags::trusted(),
10975             },
10976         },
10977         "E61230001807",
10978         "vlerh %v17, 0(%r2,%r3)",
10979     ));
10980     insns.push((
10981         Inst::VecLoadElt32Rev {
10982             rd: writable_vr(17),
10983             mem: MemArg::BXD12 {
10984                 base: gpr(2),
10985                 index: zero_reg(),
10986                 disp: UImm12::zero(),
10987                 flags: MemFlags::trusted(),
10988             },
10989         },
10990         "E61020002807",
10991         "vlerf %v17, 0(%r2)",
10992     ));
10993     insns.push((
10994         Inst::VecLoadElt32Rev {
10995             rd: writable_vr(17),
10996             mem: MemArg::BXD12 {
10997                 base: gpr(2),
10998                 index: zero_reg(),
10999                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11000                 flags: MemFlags::trusted(),
11001             },
11002         },
11003         "E6102FFF2807",
11004         "vlerf %v17, 4095(%r2)",
11005     ));
11006     insns.push((
11007         Inst::VecLoadElt32Rev {
11008             rd: writable_vr(17),
11009             mem: MemArg::BXD12 {
11010                 base: gpr(3),
11011                 index: gpr(2),
11012                 disp: UImm12::zero(),
11013                 flags: MemFlags::trusted(),
11014             },
11015         },
11016         "E61230002807",
11017         "vlerf %v17, 0(%r2,%r3)",
11018     ));
11019     insns.push((
11020         Inst::VecLoadElt64Rev {
11021             rd: writable_vr(17),
11022             mem: MemArg::BXD12 {
11023                 base: gpr(2),
11024                 index: zero_reg(),
11025                 disp: UImm12::zero(),
11026                 flags: MemFlags::trusted(),
11027             },
11028         },
11029         "E61020003807",
11030         "vlerg %v17, 0(%r2)",
11031     ));
11032     insns.push((
11033         Inst::VecLoadElt64Rev {
11034             rd: writable_vr(17),
11035             mem: MemArg::BXD12 {
11036                 base: gpr(2),
11037                 index: zero_reg(),
11038                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11039                 flags: MemFlags::trusted(),
11040             },
11041         },
11042         "E6102FFF3807",
11043         "vlerg %v17, 4095(%r2)",
11044     ));
11045     insns.push((
11046         Inst::VecLoadElt64Rev {
11047             rd: writable_vr(17),
11048             mem: MemArg::BXD12 {
11049                 base: gpr(3),
11050                 index: gpr(2),
11051                 disp: UImm12::zero(),
11052                 flags: MemFlags::trusted(),
11053             },
11054         },
11055         "E61230003807",
11056         "vlerg %v17, 0(%r2,%r3)",
11057     ));
11058     insns.push((
11059         Inst::VecStore {
11060             rd: vr(17),
11061             mem: MemArg::BXD12 {
11062                 base: gpr(2),
11063                 index: zero_reg(),
11064                 disp: UImm12::zero(),
11065                 flags: MemFlags::trusted(),
11066             },
11067         },
11068         "E7102000080E",
11069         "vst %v17, 0(%r2)",
11070     ));
11071     insns.push((
11072         Inst::VecStore {
11073             rd: vr(17),
11074             mem: MemArg::BXD12 {
11075                 base: gpr(2),
11076                 index: zero_reg(),
11077                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11078                 flags: MemFlags::trusted(),
11079             },
11080         },
11081         "E7102FFF080E",
11082         "vst %v17, 4095(%r2)",
11083     ));
11084     insns.push((
11085         Inst::VecStore {
11086             rd: vr(17),
11087             mem: MemArg::BXD12 {
11088                 base: gpr(3),
11089                 index: gpr(2),
11090                 disp: UImm12::zero(),
11091                 flags: MemFlags::trusted(),
11092             },
11093         },
11094         "E7123000080E",
11095         "vst %v17, 0(%r2,%r3)",
11096     ));
11097     insns.push((
11098         Inst::VecStoreRev {
11099             rd: vr(17),
11100             mem: MemArg::BXD12 {
11101                 base: gpr(2),
11102                 index: zero_reg(),
11103                 disp: UImm12::zero(),
11104                 flags: MemFlags::trusted(),
11105             },
11106         },
11107         "E6102000480E",
11108         "vstbrq %v17, 0(%r2)",
11109     ));
11110     insns.push((
11111         Inst::VecStoreRev {
11112             rd: vr(17),
11113             mem: MemArg::BXD12 {
11114                 base: gpr(2),
11115                 index: zero_reg(),
11116                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11117                 flags: MemFlags::trusted(),
11118             },
11119         },
11120         "E6102FFF480E",
11121         "vstbrq %v17, 4095(%r2)",
11122     ));
11123     insns.push((
11124         Inst::VecStoreRev {
11125             rd: vr(17),
11126             mem: MemArg::BXD12 {
11127                 base: gpr(3),
11128                 index: gpr(2),
11129                 disp: UImm12::zero(),
11130                 flags: MemFlags::trusted(),
11131             },
11132         },
11133         "E6123000480E",
11134         "vstbrq %v17, 0(%r2,%r3)",
11135     ));
11136     insns.push((
11137         Inst::VecStoreByte16Rev {
11138             rd: vr(17),
11139             mem: MemArg::BXD12 {
11140                 base: gpr(2),
11141                 index: zero_reg(),
11142                 disp: UImm12::zero(),
11143                 flags: MemFlags::trusted(),
11144             },
11145         },
11146         "E6102000180E",
11147         "vstbrh %v17, 0(%r2)",
11148     ));
11149     insns.push((
11150         Inst::VecStoreByte16Rev {
11151             rd: vr(17),
11152             mem: MemArg::BXD12 {
11153                 base: gpr(2),
11154                 index: zero_reg(),
11155                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11156                 flags: MemFlags::trusted(),
11157             },
11158         },
11159         "E6102FFF180E",
11160         "vstbrh %v17, 4095(%r2)",
11161     ));
11162     insns.push((
11163         Inst::VecStoreByte16Rev {
11164             rd: vr(17),
11165             mem: MemArg::BXD12 {
11166                 base: gpr(3),
11167                 index: gpr(2),
11168                 disp: UImm12::zero(),
11169                 flags: MemFlags::trusted(),
11170             },
11171         },
11172         "E6123000180E",
11173         "vstbrh %v17, 0(%r2,%r3)",
11174     ));
11175     insns.push((
11176         Inst::VecStoreByte32Rev {
11177             rd: vr(17),
11178             mem: MemArg::BXD12 {
11179                 base: gpr(2),
11180                 index: zero_reg(),
11181                 disp: UImm12::zero(),
11182                 flags: MemFlags::trusted(),
11183             },
11184         },
11185         "E6102000280E",
11186         "vstbrf %v17, 0(%r2)",
11187     ));
11188     insns.push((
11189         Inst::VecStoreByte32Rev {
11190             rd: vr(17),
11191             mem: MemArg::BXD12 {
11192                 base: gpr(2),
11193                 index: zero_reg(),
11194                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11195                 flags: MemFlags::trusted(),
11196             },
11197         },
11198         "E6102FFF280E",
11199         "vstbrf %v17, 4095(%r2)",
11200     ));
11201     insns.push((
11202         Inst::VecStoreByte32Rev {
11203             rd: vr(17),
11204             mem: MemArg::BXD12 {
11205                 base: gpr(3),
11206                 index: gpr(2),
11207                 disp: UImm12::zero(),
11208                 flags: MemFlags::trusted(),
11209             },
11210         },
11211         "E6123000280E",
11212         "vstbrf %v17, 0(%r2,%r3)",
11213     ));
11214     insns.push((
11215         Inst::VecStoreByte64Rev {
11216             rd: vr(17),
11217             mem: MemArg::BXD12 {
11218                 base: gpr(2),
11219                 index: zero_reg(),
11220                 disp: UImm12::zero(),
11221                 flags: MemFlags::trusted(),
11222             },
11223         },
11224         "E6102000380E",
11225         "vstbrg %v17, 0(%r2)",
11226     ));
11227     insns.push((
11228         Inst::VecStoreByte64Rev {
11229             rd: vr(17),
11230             mem: MemArg::BXD12 {
11231                 base: gpr(2),
11232                 index: zero_reg(),
11233                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11234                 flags: MemFlags::trusted(),
11235             },
11236         },
11237         "E6102FFF380E",
11238         "vstbrg %v17, 4095(%r2)",
11239     ));
11240     insns.push((
11241         Inst::VecStoreByte64Rev {
11242             rd: vr(17),
11243             mem: MemArg::BXD12 {
11244                 base: gpr(3),
11245                 index: gpr(2),
11246                 disp: UImm12::zero(),
11247                 flags: MemFlags::trusted(),
11248             },
11249         },
11250         "E6123000380E",
11251         "vstbrg %v17, 0(%r2,%r3)",
11252     ));
11253     insns.push((
11254         Inst::VecStoreElt16Rev {
11255             rd: vr(17),
11256             mem: MemArg::BXD12 {
11257                 base: gpr(2),
11258                 index: zero_reg(),
11259                 disp: UImm12::zero(),
11260                 flags: MemFlags::trusted(),
11261             },
11262         },
11263         "E6102000180F",
11264         "vsterh %v17, 0(%r2)",
11265     ));
11266     insns.push((
11267         Inst::VecStoreElt16Rev {
11268             rd: vr(17),
11269             mem: MemArg::BXD12 {
11270                 base: gpr(2),
11271                 index: zero_reg(),
11272                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11273                 flags: MemFlags::trusted(),
11274             },
11275         },
11276         "E6102FFF180F",
11277         "vsterh %v17, 4095(%r2)",
11278     ));
11279     insns.push((
11280         Inst::VecStoreElt16Rev {
11281             rd: vr(17),
11282             mem: MemArg::BXD12 {
11283                 base: gpr(3),
11284                 index: gpr(2),
11285                 disp: UImm12::zero(),
11286                 flags: MemFlags::trusted(),
11287             },
11288         },
11289         "E6123000180F",
11290         "vsterh %v17, 0(%r2,%r3)",
11291     ));
11292     insns.push((
11293         Inst::VecStoreElt32Rev {
11294             rd: vr(17),
11295             mem: MemArg::BXD12 {
11296                 base: gpr(2),
11297                 index: zero_reg(),
11298                 disp: UImm12::zero(),
11299                 flags: MemFlags::trusted(),
11300             },
11301         },
11302         "E6102000280F",
11303         "vsterf %v17, 0(%r2)",
11304     ));
11305     insns.push((
11306         Inst::VecStoreElt32Rev {
11307             rd: vr(17),
11308             mem: MemArg::BXD12 {
11309                 base: gpr(2),
11310                 index: zero_reg(),
11311                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11312                 flags: MemFlags::trusted(),
11313             },
11314         },
11315         "E6102FFF280F",
11316         "vsterf %v17, 4095(%r2)",
11317     ));
11318     insns.push((
11319         Inst::VecStoreElt32Rev {
11320             rd: vr(17),
11321             mem: MemArg::BXD12 {
11322                 base: gpr(3),
11323                 index: gpr(2),
11324                 disp: UImm12::zero(),
11325                 flags: MemFlags::trusted(),
11326             },
11327         },
11328         "E6123000280F",
11329         "vsterf %v17, 0(%r2,%r3)",
11330     ));
11331     insns.push((
11332         Inst::VecStoreElt64Rev {
11333             rd: vr(17),
11334             mem: MemArg::BXD12 {
11335                 base: gpr(2),
11336                 index: zero_reg(),
11337                 disp: UImm12::zero(),
11338                 flags: MemFlags::trusted(),
11339             },
11340         },
11341         "E6102000380F",
11342         "vsterg %v17, 0(%r2)",
11343     ));
11344     insns.push((
11345         Inst::VecStoreElt64Rev {
11346             rd: vr(17),
11347             mem: MemArg::BXD12 {
11348                 base: gpr(2),
11349                 index: zero_reg(),
11350                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11351                 flags: MemFlags::trusted(),
11352             },
11353         },
11354         "E6102FFF380F",
11355         "vsterg %v17, 4095(%r2)",
11356     ));
11357     insns.push((
11358         Inst::VecStoreElt64Rev {
11359             rd: vr(17),
11360             mem: MemArg::BXD12 {
11361                 base: gpr(3),
11362                 index: gpr(2),
11363                 disp: UImm12::zero(),
11364                 flags: MemFlags::trusted(),
11365             },
11366         },
11367         "E6123000380F",
11368         "vsterg %v17, 0(%r2,%r3)",
11369     ));
11370     insns.push((
11371         Inst::VecLoadReplicate {
11372             size: 8,
11373             rd: writable_vr(17),
11374             mem: MemArg::BXD12 {
11375                 base: gpr(2),
11376                 index: zero_reg(),
11377                 disp: UImm12::maybe_from_u64(128).unwrap(),
11378                 flags: MemFlags::trusted(),
11379             },
11380         },
11381         "E71020800805",
11382         "vlrepb %v17, 128(%r2)",
11383     ));
11384     insns.push((
11385         Inst::VecLoadReplicate {
11386             size: 16,
11387             rd: writable_vr(17),
11388             mem: MemArg::BXD12 {
11389                 base: gpr(2),
11390                 index: zero_reg(),
11391                 disp: UImm12::maybe_from_u64(128).unwrap(),
11392                 flags: MemFlags::trusted(),
11393             },
11394         },
11395         "E71020801805",
11396         "vlreph %v17, 128(%r2)",
11397     ));
11398     insns.push((
11399         Inst::VecLoadReplicate {
11400             size: 32,
11401             rd: writable_vr(17),
11402             mem: MemArg::BXD12 {
11403                 base: gpr(2),
11404                 index: zero_reg(),
11405                 disp: UImm12::maybe_from_u64(128).unwrap(),
11406                 flags: MemFlags::trusted(),
11407             },
11408         },
11409         "E71020802805",
11410         "vlrepf %v17, 128(%r2)",
11411     ));
11412     insns.push((
11413         Inst::VecLoadReplicate {
11414             size: 64,
11415             rd: writable_vr(17),
11416             mem: MemArg::BXD12 {
11417                 base: gpr(2),
11418                 index: zero_reg(),
11419                 disp: UImm12::maybe_from_u64(128).unwrap(),
11420                 flags: MemFlags::trusted(),
11421             },
11422         },
11423         "E71020803805",
11424         "vlrepg %v17, 128(%r2)",
11425     ));
11426     insns.push((
11427         Inst::VecLoadReplicateRev {
11428             size: 16,
11429             rd: writable_vr(17),
11430             mem: MemArg::BXD12 {
11431                 base: gpr(2),
11432                 index: zero_reg(),
11433                 disp: UImm12::maybe_from_u64(128).unwrap(),
11434                 flags: MemFlags::trusted(),
11435             },
11436         },
11437         "E61020801805",
11438         "vlbrreph %v17, 128(%r2)",
11439     ));
11440     insns.push((
11441         Inst::VecLoadReplicateRev {
11442             size: 32,
11443             rd: writable_vr(17),
11444             mem: MemArg::BXD12 {
11445                 base: gpr(2),
11446                 index: zero_reg(),
11447                 disp: UImm12::maybe_from_u64(128).unwrap(),
11448                 flags: MemFlags::trusted(),
11449             },
11450         },
11451         "E61020802805",
11452         "vlbrrepf %v17, 128(%r2)",
11453     ));
11454     insns.push((
11455         Inst::VecLoadReplicateRev {
11456             size: 64,
11457             rd: writable_vr(17),
11458             mem: MemArg::BXD12 {
11459                 base: gpr(2),
11460                 index: zero_reg(),
11461                 disp: UImm12::maybe_from_u64(128).unwrap(),
11462                 flags: MemFlags::trusted(),
11463             },
11464         },
11465         "E61020803805",
11466         "vlbrrepg %v17, 128(%r2)",
11467     ));
11468 
11469     insns.push((
11470         Inst::VecMov {
11471             rd: writable_vr(8),
11472             rn: vr(20),
11473         },
11474         "E78400000456",
11475         "vlr %v8, %v20",
11476     ));
11477     insns.push((
11478         Inst::VecCMov {
11479             rd: writable_vr(8),
11480             ri: vr(8),
11481             rm: vr(20),
11482             cond: Cond::from_mask(1),
11483         },
11484         "A7E40005E78400000456",
11485         "jno 10 ; vlr %v8, %v20",
11486     ));
11487     insns.push((
11488         Inst::MovToVec128 {
11489             rd: writable_vr(20),
11490             rn: gpr(5),
11491             rm: gpr(6),
11492         },
11493         "E74560000862",
11494         "vlvgp %v20, %r5, %r6",
11495     ));
11496 
11497     insns.push((
11498         Inst::VecImmByteMask {
11499             rd: writable_vr(20),
11500             mask: 0x1234,
11501         },
11502         "E74012340844",
11503         "vgbm %v20, 4660",
11504     ));
11505     insns.push((
11506         Inst::VecImmBitMask {
11507             size: 8,
11508             rd: writable_vr(20),
11509             start_bit: 1,
11510             end_bit: 7,
11511         },
11512         "E74001070846",
11513         "vgmb %v20, 1, 7",
11514     ));
11515     insns.push((
11516         Inst::VecImmBitMask {
11517             size: 16,
11518             rd: writable_vr(20),
11519             start_bit: 1,
11520             end_bit: 7,
11521         },
11522         "E74001071846",
11523         "vgmh %v20, 1, 7",
11524     ));
11525     insns.push((
11526         Inst::VecImmBitMask {
11527             size: 32,
11528             rd: writable_vr(20),
11529             start_bit: 1,
11530             end_bit: 7,
11531         },
11532         "E74001072846",
11533         "vgmf %v20, 1, 7",
11534     ));
11535     insns.push((
11536         Inst::VecImmBitMask {
11537             size: 64,
11538             rd: writable_vr(20),
11539             start_bit: 1,
11540             end_bit: 7,
11541         },
11542         "E74001073846",
11543         "vgmg %v20, 1, 7",
11544     ));
11545     insns.push((
11546         Inst::VecImmReplicate {
11547             size: 8,
11548             rd: writable_vr(20),
11549             imm: 0x1234,
11550         },
11551         "E74012340845",
11552         "vrepib %v20, 4660",
11553     ));
11554     insns.push((
11555         Inst::VecImmReplicate {
11556             size: 16,
11557             rd: writable_vr(20),
11558             imm: 0x1234,
11559         },
11560         "E74012341845",
11561         "vrepih %v20, 4660",
11562     ));
11563     insns.push((
11564         Inst::VecImmReplicate {
11565             size: 32,
11566             rd: writable_vr(20),
11567             imm: 0x1234,
11568         },
11569         "E74012342845",
11570         "vrepif %v20, 4660",
11571     ));
11572     insns.push((
11573         Inst::VecImmReplicate {
11574             size: 64,
11575             rd: writable_vr(20),
11576             imm: 0x1234,
11577         },
11578         "E74012343845",
11579         "vrepig %v20, 4660",
11580     ));
11581 
11582     insns.push((
11583         Inst::VecLoadLane {
11584             size: 8,
11585             rd: writable_vr(17),
11586             ri: vr(17),
11587             mem: MemArg::BXD12 {
11588                 base: gpr(2),
11589                 index: zero_reg(),
11590                 disp: UImm12::zero(),
11591                 flags: MemFlags::trusted(),
11592             },
11593             lane_imm: 15,
11594         },
11595         "E7102000F800",
11596         "vleb %v17, 0(%r2), 15",
11597     ));
11598     insns.push((
11599         Inst::VecLoadLane {
11600             size: 8,
11601             rd: writable_vr(17),
11602             ri: vr(17),
11603             mem: MemArg::BXD12 {
11604                 base: gpr(2),
11605                 index: zero_reg(),
11606                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11607                 flags: MemFlags::trusted(),
11608             },
11609             lane_imm: 0,
11610         },
11611         "E7102FFF0800",
11612         "vleb %v17, 4095(%r2), 0",
11613     ));
11614     insns.push((
11615         Inst::VecLoadLane {
11616             size: 8,
11617             rd: writable_vr(17),
11618             ri: vr(17),
11619             mem: MemArg::BXD12 {
11620                 base: gpr(3),
11621                 index: gpr(2),
11622                 disp: UImm12::zero(),
11623                 flags: MemFlags::trusted(),
11624             },
11625             lane_imm: 15,
11626         },
11627         "E7123000F800",
11628         "vleb %v17, 0(%r2,%r3), 15",
11629     ));
11630     insns.push((
11631         Inst::VecLoadLane {
11632             size: 8,
11633             rd: writable_vr(17),
11634             ri: vr(17),
11635             mem: MemArg::BXD12 {
11636                 base: gpr(3),
11637                 index: gpr(2),
11638                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11639                 flags: MemFlags::trusted(),
11640             },
11641             lane_imm: 0,
11642         },
11643         "E7123FFF0800",
11644         "vleb %v17, 4095(%r2,%r3), 0",
11645     ));
11646     insns.push((
11647         Inst::VecLoadLane {
11648             size: 16,
11649             rd: writable_vr(17),
11650             ri: vr(17),
11651             mem: MemArg::BXD12 {
11652                 base: gpr(2),
11653                 index: zero_reg(),
11654                 disp: UImm12::zero(),
11655                 flags: MemFlags::trusted(),
11656             },
11657             lane_imm: 7,
11658         },
11659         "E71020007801",
11660         "vleh %v17, 0(%r2), 7",
11661     ));
11662     insns.push((
11663         Inst::VecLoadLane {
11664             size: 16,
11665             rd: writable_vr(17),
11666             ri: vr(17),
11667             mem: MemArg::BXD12 {
11668                 base: gpr(2),
11669                 index: zero_reg(),
11670                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11671                 flags: MemFlags::trusted(),
11672             },
11673             lane_imm: 0,
11674         },
11675         "E7102FFF0801",
11676         "vleh %v17, 4095(%r2), 0",
11677     ));
11678     insns.push((
11679         Inst::VecLoadLane {
11680             size: 16,
11681             rd: writable_vr(17),
11682             ri: vr(17),
11683             mem: MemArg::BXD12 {
11684                 base: gpr(3),
11685                 index: gpr(2),
11686                 disp: UImm12::zero(),
11687                 flags: MemFlags::trusted(),
11688             },
11689             lane_imm: 7,
11690         },
11691         "E71230007801",
11692         "vleh %v17, 0(%r2,%r3), 7",
11693     ));
11694     insns.push((
11695         Inst::VecLoadLane {
11696             size: 16,
11697             rd: writable_vr(17),
11698             ri: vr(17),
11699             mem: MemArg::BXD12 {
11700                 base: gpr(3),
11701                 index: gpr(2),
11702                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11703                 flags: MemFlags::trusted(),
11704             },
11705             lane_imm: 0,
11706         },
11707         "E7123FFF0801",
11708         "vleh %v17, 4095(%r2,%r3), 0",
11709     ));
11710     insns.push((
11711         Inst::VecLoadLane {
11712             size: 32,
11713             rd: writable_vr(17),
11714             ri: vr(17),
11715             mem: MemArg::BXD12 {
11716                 base: gpr(2),
11717                 index: zero_reg(),
11718                 disp: UImm12::zero(),
11719                 flags: MemFlags::trusted(),
11720             },
11721             lane_imm: 3,
11722         },
11723         "E71020003803",
11724         "vlef %v17, 0(%r2), 3",
11725     ));
11726     insns.push((
11727         Inst::VecLoadLane {
11728             size: 32,
11729             rd: writable_vr(17),
11730             ri: vr(17),
11731             mem: MemArg::BXD12 {
11732                 base: gpr(2),
11733                 index: zero_reg(),
11734                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11735                 flags: MemFlags::trusted(),
11736             },
11737             lane_imm: 0,
11738         },
11739         "E7102FFF0803",
11740         "vlef %v17, 4095(%r2), 0",
11741     ));
11742     insns.push((
11743         Inst::VecLoadLane {
11744             size: 32,
11745             rd: writable_vr(17),
11746             ri: vr(17),
11747             mem: MemArg::BXD12 {
11748                 base: gpr(3),
11749                 index: gpr(2),
11750                 disp: UImm12::zero(),
11751                 flags: MemFlags::trusted(),
11752             },
11753             lane_imm: 3,
11754         },
11755         "E71230003803",
11756         "vlef %v17, 0(%r2,%r3), 3",
11757     ));
11758     insns.push((
11759         Inst::VecLoadLane {
11760             size: 32,
11761             rd: writable_vr(17),
11762             ri: vr(17),
11763             mem: MemArg::BXD12 {
11764                 base: gpr(3),
11765                 index: gpr(2),
11766                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11767                 flags: MemFlags::trusted(),
11768             },
11769             lane_imm: 0,
11770         },
11771         "E7123FFF0803",
11772         "vlef %v17, 4095(%r2,%r3), 0",
11773     ));
11774     insns.push((
11775         Inst::VecLoadLane {
11776             size: 64,
11777             rd: writable_vr(17),
11778             ri: vr(17),
11779             mem: MemArg::BXD12 {
11780                 base: gpr(2),
11781                 index: zero_reg(),
11782                 disp: UImm12::zero(),
11783                 flags: MemFlags::trusted(),
11784             },
11785             lane_imm: 1,
11786         },
11787         "E71020001802",
11788         "vleg %v17, 0(%r2), 1",
11789     ));
11790     insns.push((
11791         Inst::VecLoadLane {
11792             size: 64,
11793             rd: writable_vr(17),
11794             ri: vr(17),
11795             mem: MemArg::BXD12 {
11796                 base: gpr(2),
11797                 index: zero_reg(),
11798                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11799                 flags: MemFlags::trusted(),
11800             },
11801             lane_imm: 0,
11802         },
11803         "E7102FFF0802",
11804         "vleg %v17, 4095(%r2), 0",
11805     ));
11806     insns.push((
11807         Inst::VecLoadLane {
11808             size: 64,
11809             rd: writable_vr(17),
11810             ri: vr(17),
11811             mem: MemArg::BXD12 {
11812                 base: gpr(3),
11813                 index: gpr(2),
11814                 disp: UImm12::zero(),
11815                 flags: MemFlags::trusted(),
11816             },
11817             lane_imm: 1,
11818         },
11819         "E71230001802",
11820         "vleg %v17, 0(%r2,%r3), 1",
11821     ));
11822     insns.push((
11823         Inst::VecLoadLane {
11824             size: 64,
11825             rd: writable_vr(17),
11826             ri: vr(17),
11827             mem: MemArg::BXD12 {
11828                 base: gpr(3),
11829                 index: gpr(2),
11830                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11831                 flags: MemFlags::trusted(),
11832             },
11833             lane_imm: 0,
11834         },
11835         "E7123FFF0802",
11836         "vleg %v17, 4095(%r2,%r3), 0",
11837     ));
11838     insns.push((
11839         Inst::VecLoadLaneUndef {
11840             size: 32,
11841             rd: writable_vr(1),
11842             mem: MemArg::BXD12 {
11843                 base: gpr(2),
11844                 index: zero_reg(),
11845                 disp: UImm12::zero(),
11846                 flags: MemFlags::trusted(),
11847             },
11848             lane_imm: 0,
11849         },
11850         "78102000",
11851         "le %f1, 0(%r2)",
11852     ));
11853     insns.push((
11854         Inst::VecLoadLaneUndef {
11855             size: 32,
11856             rd: writable_vr(1),
11857             mem: MemArg::BXD12 {
11858                 base: gpr(2),
11859                 index: zero_reg(),
11860                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11861                 flags: MemFlags::trusted(),
11862             },
11863             lane_imm: 0,
11864         },
11865         "78102FFF",
11866         "le %f1, 4095(%r2)",
11867     ));
11868     insns.push((
11869         Inst::VecLoadLaneUndef {
11870             size: 32,
11871             rd: writable_vr(1),
11872             mem: MemArg::BXD20 {
11873                 base: gpr(2),
11874                 index: zero_reg(),
11875                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
11876                 flags: MemFlags::trusted(),
11877             },
11878             lane_imm: 0,
11879         },
11880         "ED1020008064",
11881         "ley %f1, -524288(%r2)",
11882     ));
11883     insns.push((
11884         Inst::VecLoadLaneUndef {
11885             size: 32,
11886             rd: writable_vr(1),
11887             mem: MemArg::BXD20 {
11888                 base: gpr(2),
11889                 index: zero_reg(),
11890                 disp: SImm20::maybe_from_i64(524287).unwrap(),
11891                 flags: MemFlags::trusted(),
11892             },
11893             lane_imm: 0,
11894         },
11895         "ED102FFF7F64",
11896         "ley %f1, 524287(%r2)",
11897     ));
11898     insns.push((
11899         Inst::VecLoadLaneUndef {
11900             size: 32,
11901             rd: writable_vr(17),
11902             mem: MemArg::BXD12 {
11903                 base: gpr(2),
11904                 index: zero_reg(),
11905                 disp: UImm12::zero(),
11906                 flags: MemFlags::trusted(),
11907             },
11908             lane_imm: 0,
11909         },
11910         "E71020000803",
11911         "vlef %v17, 0(%r2), 0",
11912     ));
11913     insns.push((
11914         Inst::VecLoadLaneUndef {
11915             size: 32,
11916             rd: writable_vr(17),
11917             mem: MemArg::BXD12 {
11918                 base: gpr(2),
11919                 index: zero_reg(),
11920                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11921                 flags: MemFlags::trusted(),
11922             },
11923             lane_imm: 0,
11924         },
11925         "E7102FFF0803",
11926         "vlef %v17, 4095(%r2), 0",
11927     ));
11928     insns.push((
11929         Inst::VecLoadLaneUndef {
11930             size: 32,
11931             rd: writable_vr(1),
11932             mem: MemArg::BXD12 {
11933                 base: gpr(3),
11934                 index: gpr(2),
11935                 disp: UImm12::zero(),
11936                 flags: MemFlags::trusted(),
11937             },
11938             lane_imm: 0,
11939         },
11940         "78123000",
11941         "le %f1, 0(%r2,%r3)",
11942     ));
11943     insns.push((
11944         Inst::VecLoadLaneUndef {
11945             size: 32,
11946             rd: writable_vr(1),
11947             mem: MemArg::BXD12 {
11948                 base: gpr(3),
11949                 index: gpr(2),
11950                 disp: UImm12::maybe_from_u64(4095).unwrap(),
11951                 flags: MemFlags::trusted(),
11952             },
11953             lane_imm: 0,
11954         },
11955         "78123FFF",
11956         "le %f1, 4095(%r2,%r3)",
11957     ));
11958     insns.push((
11959         Inst::VecLoadLaneUndef {
11960             size: 32,
11961             rd: writable_vr(1),
11962             mem: MemArg::BXD20 {
11963                 base: gpr(3),
11964                 index: gpr(2),
11965                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
11966                 flags: MemFlags::trusted(),
11967             },
11968             lane_imm: 0,
11969         },
11970         "ED1230008064",
11971         "ley %f1, -524288(%r2,%r3)",
11972     ));
11973     insns.push((
11974         Inst::VecLoadLaneUndef {
11975             size: 32,
11976             rd: writable_vr(1),
11977             mem: MemArg::BXD20 {
11978                 base: gpr(3),
11979                 index: gpr(2),
11980                 disp: SImm20::maybe_from_i64(524287).unwrap(),
11981                 flags: MemFlags::trusted(),
11982             },
11983             lane_imm: 0,
11984         },
11985         "ED123FFF7F64",
11986         "ley %f1, 524287(%r2,%r3)",
11987     ));
11988     insns.push((
11989         Inst::VecLoadLaneUndef {
11990             size: 32,
11991             rd: writable_vr(17),
11992             mem: MemArg::BXD12 {
11993                 base: gpr(3),
11994                 index: gpr(2),
11995                 disp: UImm12::zero(),
11996                 flags: MemFlags::trusted(),
11997             },
11998             lane_imm: 0,
11999         },
12000         "E71230000803",
12001         "vlef %v17, 0(%r2,%r3), 0",
12002     ));
12003     insns.push((
12004         Inst::VecLoadLaneUndef {
12005             size: 32,
12006             rd: writable_vr(17),
12007             mem: MemArg::BXD12 {
12008                 base: gpr(3),
12009                 index: gpr(2),
12010                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12011                 flags: MemFlags::trusted(),
12012             },
12013             lane_imm: 0,
12014         },
12015         "E7123FFF0803",
12016         "vlef %v17, 4095(%r2,%r3), 0",
12017     ));
12018     insns.push((
12019         Inst::VecLoadLaneUndef {
12020             size: 64,
12021             rd: writable_vr(1),
12022             mem: MemArg::BXD12 {
12023                 base: gpr(2),
12024                 index: zero_reg(),
12025                 disp: UImm12::zero(),
12026                 flags: MemFlags::trusted(),
12027             },
12028             lane_imm: 0,
12029         },
12030         "68102000",
12031         "ld %f1, 0(%r2)",
12032     ));
12033     insns.push((
12034         Inst::VecLoadLaneUndef {
12035             size: 64,
12036             rd: writable_vr(1),
12037             mem: MemArg::BXD12 {
12038                 base: gpr(2),
12039                 index: zero_reg(),
12040                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12041                 flags: MemFlags::trusted(),
12042             },
12043             lane_imm: 0,
12044         },
12045         "68102FFF",
12046         "ld %f1, 4095(%r2)",
12047     ));
12048     insns.push((
12049         Inst::VecLoadLaneUndef {
12050             size: 64,
12051             rd: writable_vr(1),
12052             mem: MemArg::BXD20 {
12053                 base: gpr(2),
12054                 index: zero_reg(),
12055                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12056                 flags: MemFlags::trusted(),
12057             },
12058             lane_imm: 0,
12059         },
12060         "ED1020008065",
12061         "ldy %f1, -524288(%r2)",
12062     ));
12063     insns.push((
12064         Inst::VecLoadLaneUndef {
12065             size: 64,
12066             rd: writable_vr(1),
12067             mem: MemArg::BXD20 {
12068                 base: gpr(2),
12069                 index: zero_reg(),
12070                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12071                 flags: MemFlags::trusted(),
12072             },
12073             lane_imm: 0,
12074         },
12075         "ED102FFF7F65",
12076         "ldy %f1, 524287(%r2)",
12077     ));
12078     insns.push((
12079         Inst::VecLoadLaneUndef {
12080             size: 64,
12081             rd: writable_vr(17),
12082             mem: MemArg::BXD12 {
12083                 base: gpr(2),
12084                 index: zero_reg(),
12085                 disp: UImm12::zero(),
12086                 flags: MemFlags::trusted(),
12087             },
12088             lane_imm: 0,
12089         },
12090         "E71020000802",
12091         "vleg %v17, 0(%r2), 0",
12092     ));
12093     insns.push((
12094         Inst::VecLoadLaneUndef {
12095             size: 64,
12096             rd: writable_vr(17),
12097             mem: MemArg::BXD12 {
12098                 base: gpr(2),
12099                 index: zero_reg(),
12100                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12101                 flags: MemFlags::trusted(),
12102             },
12103             lane_imm: 0,
12104         },
12105         "E7102FFF0802",
12106         "vleg %v17, 4095(%r2), 0",
12107     ));
12108     insns.push((
12109         Inst::VecLoadLaneUndef {
12110             size: 64,
12111             rd: writable_vr(1),
12112             mem: MemArg::BXD12 {
12113                 base: gpr(3),
12114                 index: gpr(2),
12115                 disp: UImm12::zero(),
12116                 flags: MemFlags::trusted(),
12117             },
12118             lane_imm: 0,
12119         },
12120         "68123000",
12121         "ld %f1, 0(%r2,%r3)",
12122     ));
12123     insns.push((
12124         Inst::VecLoadLaneUndef {
12125             size: 64,
12126             rd: writable_vr(1),
12127             mem: MemArg::BXD12 {
12128                 base: gpr(3),
12129                 index: gpr(2),
12130                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12131                 flags: MemFlags::trusted(),
12132             },
12133             lane_imm: 0,
12134         },
12135         "68123FFF",
12136         "ld %f1, 4095(%r2,%r3)",
12137     ));
12138     insns.push((
12139         Inst::VecLoadLaneUndef {
12140             size: 64,
12141             rd: writable_vr(1),
12142             mem: MemArg::BXD20 {
12143                 base: gpr(3),
12144                 index: gpr(2),
12145                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12146                 flags: MemFlags::trusted(),
12147             },
12148             lane_imm: 0,
12149         },
12150         "ED1230008065",
12151         "ldy %f1, -524288(%r2,%r3)",
12152     ));
12153     insns.push((
12154         Inst::VecLoadLaneUndef {
12155             size: 64,
12156             rd: writable_vr(1),
12157             mem: MemArg::BXD20 {
12158                 base: gpr(3),
12159                 index: gpr(2),
12160                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12161                 flags: MemFlags::trusted(),
12162             },
12163             lane_imm: 0,
12164         },
12165         "ED123FFF7F65",
12166         "ldy %f1, 524287(%r2,%r3)",
12167     ));
12168     insns.push((
12169         Inst::VecLoadLaneUndef {
12170             size: 64,
12171             rd: writable_vr(17),
12172             mem: MemArg::BXD12 {
12173                 base: gpr(3),
12174                 index: gpr(2),
12175                 disp: UImm12::zero(),
12176                 flags: MemFlags::trusted(),
12177             },
12178             lane_imm: 0,
12179         },
12180         "E71230000802",
12181         "vleg %v17, 0(%r2,%r3), 0",
12182     ));
12183     insns.push((
12184         Inst::VecLoadLaneUndef {
12185             size: 64,
12186             rd: writable_vr(17),
12187             mem: MemArg::BXD12 {
12188                 base: gpr(3),
12189                 index: gpr(2),
12190                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12191                 flags: MemFlags::trusted(),
12192             },
12193             lane_imm: 0,
12194         },
12195         "E7123FFF0802",
12196         "vleg %v17, 4095(%r2,%r3), 0",
12197     ));
12198     insns.push((
12199         Inst::VecStoreLane {
12200             size: 8,
12201             rd: vr(17),
12202             mem: MemArg::BXD12 {
12203                 base: gpr(2),
12204                 index: zero_reg(),
12205                 disp: UImm12::zero(),
12206                 flags: MemFlags::trusted(),
12207             },
12208             lane_imm: 15,
12209         },
12210         "E7102000F808",
12211         "vsteb %v17, 0(%r2), 15",
12212     ));
12213     insns.push((
12214         Inst::VecStoreLane {
12215             size: 8,
12216             rd: vr(17),
12217             mem: MemArg::BXD12 {
12218                 base: gpr(2),
12219                 index: zero_reg(),
12220                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12221                 flags: MemFlags::trusted(),
12222             },
12223             lane_imm: 0,
12224         },
12225         "E7102FFF0808",
12226         "vsteb %v17, 4095(%r2), 0",
12227     ));
12228     insns.push((
12229         Inst::VecStoreLane {
12230             size: 8,
12231             rd: vr(17),
12232             mem: MemArg::BXD12 {
12233                 base: gpr(3),
12234                 index: gpr(2),
12235                 disp: UImm12::zero(),
12236                 flags: MemFlags::trusted(),
12237             },
12238             lane_imm: 15,
12239         },
12240         "E7123000F808",
12241         "vsteb %v17, 0(%r2,%r3), 15",
12242     ));
12243     insns.push((
12244         Inst::VecStoreLane {
12245             size: 8,
12246             rd: vr(17),
12247             mem: MemArg::BXD12 {
12248                 base: gpr(3),
12249                 index: gpr(2),
12250                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12251                 flags: MemFlags::trusted(),
12252             },
12253             lane_imm: 0,
12254         },
12255         "E7123FFF0808",
12256         "vsteb %v17, 4095(%r2,%r3), 0",
12257     ));
12258     insns.push((
12259         Inst::VecStoreLane {
12260             size: 16,
12261             rd: vr(17),
12262             mem: MemArg::BXD12 {
12263                 base: gpr(2),
12264                 index: zero_reg(),
12265                 disp: UImm12::zero(),
12266                 flags: MemFlags::trusted(),
12267             },
12268             lane_imm: 7,
12269         },
12270         "E71020007809",
12271         "vsteh %v17, 0(%r2), 7",
12272     ));
12273     insns.push((
12274         Inst::VecStoreLane {
12275             size: 16,
12276             rd: vr(17),
12277             mem: MemArg::BXD12 {
12278                 base: gpr(2),
12279                 index: zero_reg(),
12280                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12281                 flags: MemFlags::trusted(),
12282             },
12283             lane_imm: 0,
12284         },
12285         "E7102FFF0809",
12286         "vsteh %v17, 4095(%r2), 0",
12287     ));
12288     insns.push((
12289         Inst::VecStoreLane {
12290             size: 16,
12291             rd: vr(17),
12292             mem: MemArg::BXD12 {
12293                 base: gpr(3),
12294                 index: gpr(2),
12295                 disp: UImm12::zero(),
12296                 flags: MemFlags::trusted(),
12297             },
12298             lane_imm: 7,
12299         },
12300         "E71230007809",
12301         "vsteh %v17, 0(%r2,%r3), 7",
12302     ));
12303     insns.push((
12304         Inst::VecStoreLane {
12305             size: 16,
12306             rd: vr(17),
12307             mem: MemArg::BXD12 {
12308                 base: gpr(3),
12309                 index: gpr(2),
12310                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12311                 flags: MemFlags::trusted(),
12312             },
12313             lane_imm: 0,
12314         },
12315         "E7123FFF0809",
12316         "vsteh %v17, 4095(%r2,%r3), 0",
12317     ));
12318     insns.push((
12319         Inst::VecStoreLane {
12320             size: 32,
12321             rd: vr(1),
12322             mem: MemArg::BXD12 {
12323                 base: gpr(2),
12324                 index: zero_reg(),
12325                 disp: UImm12::zero(),
12326                 flags: MemFlags::trusted(),
12327             },
12328             lane_imm: 0,
12329         },
12330         "70102000",
12331         "ste %f1, 0(%r2)",
12332     ));
12333     insns.push((
12334         Inst::VecStoreLane {
12335             size: 32,
12336             rd: vr(1),
12337             mem: MemArg::BXD12 {
12338                 base: gpr(2),
12339                 index: zero_reg(),
12340                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12341                 flags: MemFlags::trusted(),
12342             },
12343             lane_imm: 0,
12344         },
12345         "70102FFF",
12346         "ste %f1, 4095(%r2)",
12347     ));
12348     insns.push((
12349         Inst::VecStoreLane {
12350             size: 32,
12351             rd: vr(1),
12352             mem: MemArg::BXD20 {
12353                 base: gpr(2),
12354                 index: zero_reg(),
12355                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12356                 flags: MemFlags::trusted(),
12357             },
12358             lane_imm: 0,
12359         },
12360         "ED1020008066",
12361         "stey %f1, -524288(%r2)",
12362     ));
12363     insns.push((
12364         Inst::VecStoreLane {
12365             size: 32,
12366             rd: vr(1),
12367             mem: MemArg::BXD20 {
12368                 base: gpr(2),
12369                 index: zero_reg(),
12370                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12371                 flags: MemFlags::trusted(),
12372             },
12373             lane_imm: 0,
12374         },
12375         "ED102FFF7F66",
12376         "stey %f1, 524287(%r2)",
12377     ));
12378     insns.push((
12379         Inst::VecStoreLane {
12380             size: 32,
12381             rd: vr(17),
12382             mem: MemArg::BXD12 {
12383                 base: gpr(2),
12384                 index: zero_reg(),
12385                 disp: UImm12::zero(),
12386                 flags: MemFlags::trusted(),
12387             },
12388             lane_imm: 0,
12389         },
12390         "E7102000080B",
12391         "vstef %v17, 0(%r2), 0",
12392     ));
12393     insns.push((
12394         Inst::VecStoreLane {
12395             size: 32,
12396             rd: vr(17),
12397             mem: MemArg::BXD12 {
12398                 base: gpr(2),
12399                 index: zero_reg(),
12400                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12401                 flags: MemFlags::trusted(),
12402             },
12403             lane_imm: 0,
12404         },
12405         "E7102FFF080B",
12406         "vstef %v17, 4095(%r2), 0",
12407     ));
12408     insns.push((
12409         Inst::VecStoreLane {
12410             size: 32,
12411             rd: vr(1),
12412             mem: MemArg::BXD12 {
12413                 base: gpr(3),
12414                 index: gpr(2),
12415                 disp: UImm12::zero(),
12416                 flags: MemFlags::trusted(),
12417             },
12418             lane_imm: 0,
12419         },
12420         "70123000",
12421         "ste %f1, 0(%r2,%r3)",
12422     ));
12423     insns.push((
12424         Inst::VecStoreLane {
12425             size: 32,
12426             rd: vr(1),
12427             mem: MemArg::BXD12 {
12428                 base: gpr(3),
12429                 index: gpr(2),
12430                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12431                 flags: MemFlags::trusted(),
12432             },
12433             lane_imm: 0,
12434         },
12435         "70123FFF",
12436         "ste %f1, 4095(%r2,%r3)",
12437     ));
12438     insns.push((
12439         Inst::VecStoreLane {
12440             size: 32,
12441             rd: vr(1),
12442             mem: MemArg::BXD20 {
12443                 base: gpr(3),
12444                 index: gpr(2),
12445                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12446                 flags: MemFlags::trusted(),
12447             },
12448             lane_imm: 0,
12449         },
12450         "ED1230008066",
12451         "stey %f1, -524288(%r2,%r3)",
12452     ));
12453     insns.push((
12454         Inst::VecStoreLane {
12455             size: 32,
12456             rd: vr(1),
12457             mem: MemArg::BXD20 {
12458                 base: gpr(3),
12459                 index: gpr(2),
12460                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12461                 flags: MemFlags::trusted(),
12462             },
12463             lane_imm: 0,
12464         },
12465         "ED123FFF7F66",
12466         "stey %f1, 524287(%r2,%r3)",
12467     ));
12468     insns.push((
12469         Inst::VecStoreLane {
12470             size: 32,
12471             rd: vr(17),
12472             mem: MemArg::BXD12 {
12473                 base: gpr(3),
12474                 index: gpr(2),
12475                 disp: UImm12::zero(),
12476                 flags: MemFlags::trusted(),
12477             },
12478             lane_imm: 0,
12479         },
12480         "E7123000080B",
12481         "vstef %v17, 0(%r2,%r3), 0",
12482     ));
12483     insns.push((
12484         Inst::VecStoreLane {
12485             size: 32,
12486             rd: vr(17),
12487             mem: MemArg::BXD12 {
12488                 base: gpr(3),
12489                 index: gpr(2),
12490                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12491                 flags: MemFlags::trusted(),
12492             },
12493             lane_imm: 0,
12494         },
12495         "E7123FFF080B",
12496         "vstef %v17, 4095(%r2,%r3), 0",
12497     ));
12498     insns.push((
12499         Inst::VecStoreLane {
12500             size: 64,
12501             rd: vr(1),
12502             mem: MemArg::BXD12 {
12503                 base: gpr(2),
12504                 index: zero_reg(),
12505                 disp: UImm12::zero(),
12506                 flags: MemFlags::trusted(),
12507             },
12508             lane_imm: 0,
12509         },
12510         "60102000",
12511         "std %f1, 0(%r2)",
12512     ));
12513     insns.push((
12514         Inst::VecStoreLane {
12515             size: 64,
12516             rd: vr(1),
12517             mem: MemArg::BXD12 {
12518                 base: gpr(2),
12519                 index: zero_reg(),
12520                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12521                 flags: MemFlags::trusted(),
12522             },
12523             lane_imm: 0,
12524         },
12525         "60102FFF",
12526         "std %f1, 4095(%r2)",
12527     ));
12528     insns.push((
12529         Inst::VecStoreLane {
12530             size: 64,
12531             rd: vr(1),
12532             mem: MemArg::BXD20 {
12533                 base: gpr(2),
12534                 index: zero_reg(),
12535                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12536                 flags: MemFlags::trusted(),
12537             },
12538             lane_imm: 0,
12539         },
12540         "ED1020008067",
12541         "stdy %f1, -524288(%r2)",
12542     ));
12543     insns.push((
12544         Inst::VecStoreLane {
12545             size: 64,
12546             rd: vr(1),
12547             mem: MemArg::BXD20 {
12548                 base: gpr(2),
12549                 index: zero_reg(),
12550                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12551                 flags: MemFlags::trusted(),
12552             },
12553             lane_imm: 0,
12554         },
12555         "ED102FFF7F67",
12556         "stdy %f1, 524287(%r2)",
12557     ));
12558     insns.push((
12559         Inst::VecStoreLane {
12560             size: 64,
12561             rd: vr(17),
12562             mem: MemArg::BXD12 {
12563                 base: gpr(2),
12564                 index: zero_reg(),
12565                 disp: UImm12::zero(),
12566                 flags: MemFlags::trusted(),
12567             },
12568             lane_imm: 0,
12569         },
12570         "E7102000080A",
12571         "vsteg %v17, 0(%r2), 0",
12572     ));
12573     insns.push((
12574         Inst::VecStoreLane {
12575             size: 64,
12576             rd: vr(17),
12577             mem: MemArg::BXD12 {
12578                 base: gpr(2),
12579                 index: zero_reg(),
12580                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12581                 flags: MemFlags::trusted(),
12582             },
12583             lane_imm: 0,
12584         },
12585         "E7102FFF080A",
12586         "vsteg %v17, 4095(%r2), 0",
12587     ));
12588     insns.push((
12589         Inst::VecStoreLane {
12590             size: 64,
12591             rd: vr(1),
12592             mem: MemArg::BXD12 {
12593                 base: gpr(3),
12594                 index: gpr(2),
12595                 disp: UImm12::zero(),
12596                 flags: MemFlags::trusted(),
12597             },
12598             lane_imm: 0,
12599         },
12600         "60123000",
12601         "std %f1, 0(%r2,%r3)",
12602     ));
12603     insns.push((
12604         Inst::VecStoreLane {
12605             size: 64,
12606             rd: vr(1),
12607             mem: MemArg::BXD12 {
12608                 base: gpr(3),
12609                 index: gpr(2),
12610                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12611                 flags: MemFlags::trusted(),
12612             },
12613             lane_imm: 0,
12614         },
12615         "60123FFF",
12616         "std %f1, 4095(%r2,%r3)",
12617     ));
12618     insns.push((
12619         Inst::VecStoreLane {
12620             size: 64,
12621             rd: vr(1),
12622             mem: MemArg::BXD20 {
12623                 base: gpr(3),
12624                 index: gpr(2),
12625                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12626                 flags: MemFlags::trusted(),
12627             },
12628             lane_imm: 0,
12629         },
12630         "ED1230008067",
12631         "stdy %f1, -524288(%r2,%r3)",
12632     ));
12633     insns.push((
12634         Inst::VecStoreLane {
12635             size: 64,
12636             rd: vr(1),
12637             mem: MemArg::BXD20 {
12638                 base: gpr(3),
12639                 index: gpr(2),
12640                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12641                 flags: MemFlags::trusted(),
12642             },
12643             lane_imm: 0,
12644         },
12645         "ED123FFF7F67",
12646         "stdy %f1, 524287(%r2,%r3)",
12647     ));
12648     insns.push((
12649         Inst::VecStoreLane {
12650             size: 64,
12651             rd: vr(17),
12652             mem: MemArg::BXD12 {
12653                 base: gpr(3),
12654                 index: gpr(2),
12655                 disp: UImm12::zero(),
12656                 flags: MemFlags::trusted(),
12657             },
12658             lane_imm: 0,
12659         },
12660         "E7123000080A",
12661         "vsteg %v17, 0(%r2,%r3), 0",
12662     ));
12663     insns.push((
12664         Inst::VecStoreLane {
12665             size: 64,
12666             rd: vr(17),
12667             mem: MemArg::BXD12 {
12668                 base: gpr(3),
12669                 index: gpr(2),
12670                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12671                 flags: MemFlags::trusted(),
12672             },
12673             lane_imm: 0,
12674         },
12675         "E7123FFF080A",
12676         "vsteg %v17, 4095(%r2,%r3), 0",
12677     ));
12678     insns.push((
12679         Inst::VecLoadLaneRev {
12680             size: 16,
12681             rd: writable_vr(1),
12682             ri: vr(1),
12683             mem: MemArg::BXD12 {
12684                 base: gpr(2),
12685                 index: zero_reg(),
12686                 disp: UImm12::zero(),
12687                 flags: MemFlags::trusted(),
12688             },
12689             lane_imm: 0,
12690         },
12691         "E61020000001",
12692         "vlebrh %v1, 0(%r2), 0",
12693     ));
12694     insns.push((
12695         Inst::VecLoadLaneRev {
12696             size: 16,
12697             rd: writable_vr(1),
12698             ri: vr(1),
12699             mem: MemArg::BXD12 {
12700                 base: gpr(2),
12701                 index: zero_reg(),
12702                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12703                 flags: MemFlags::trusted(),
12704             },
12705             lane_imm: 0,
12706         },
12707         "E6102FFF0001",
12708         "vlebrh %v1, 4095(%r2), 0",
12709     ));
12710     insns.push((
12711         Inst::VecLoadLaneRev {
12712             size: 16,
12713             rd: writable_vr(1),
12714             ri: vr(1),
12715             mem: MemArg::BXD12 {
12716                 base: gpr(3),
12717                 index: gpr(2),
12718                 disp: UImm12::zero(),
12719                 flags: MemFlags::trusted(),
12720             },
12721             lane_imm: 0,
12722         },
12723         "E61230000001",
12724         "vlebrh %v1, 0(%r2,%r3), 0",
12725     ));
12726     insns.push((
12727         Inst::VecLoadLaneRev {
12728             size: 16,
12729             rd: writable_vr(1),
12730             ri: vr(1),
12731             mem: MemArg::BXD12 {
12732                 base: gpr(3),
12733                 index: gpr(2),
12734                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12735                 flags: MemFlags::trusted(),
12736             },
12737             lane_imm: 0,
12738         },
12739         "E6123FFF0001",
12740         "vlebrh %v1, 4095(%r2,%r3), 0",
12741     ));
12742     insns.push((
12743         Inst::VecLoadLaneRev {
12744             size: 32,
12745             rd: writable_vr(1),
12746             ri: vr(1),
12747             mem: MemArg::BXD12 {
12748                 base: gpr(2),
12749                 index: zero_reg(),
12750                 disp: UImm12::zero(),
12751                 flags: MemFlags::trusted(),
12752             },
12753             lane_imm: 0,
12754         },
12755         "E61020000003",
12756         "vlebrf %v1, 0(%r2), 0",
12757     ));
12758     insns.push((
12759         Inst::VecLoadLaneRev {
12760             size: 32,
12761             rd: writable_vr(1),
12762             ri: vr(1),
12763             mem: MemArg::BXD12 {
12764                 base: gpr(2),
12765                 index: zero_reg(),
12766                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12767                 flags: MemFlags::trusted(),
12768             },
12769             lane_imm: 0,
12770         },
12771         "E6102FFF0003",
12772         "vlebrf %v1, 4095(%r2), 0",
12773     ));
12774     insns.push((
12775         Inst::VecLoadLaneRev {
12776             size: 32,
12777             rd: writable_vr(1),
12778             ri: vr(1),
12779             mem: MemArg::BXD12 {
12780                 base: gpr(3),
12781                 index: gpr(2),
12782                 disp: UImm12::zero(),
12783                 flags: MemFlags::trusted(),
12784             },
12785             lane_imm: 0,
12786         },
12787         "E61230000003",
12788         "vlebrf %v1, 0(%r2,%r3), 0",
12789     ));
12790     insns.push((
12791         Inst::VecLoadLaneRev {
12792             size: 32,
12793             rd: writable_vr(1),
12794             ri: vr(1),
12795             mem: MemArg::BXD12 {
12796                 base: gpr(3),
12797                 index: gpr(2),
12798                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12799                 flags: MemFlags::trusted(),
12800             },
12801             lane_imm: 0,
12802         },
12803         "E6123FFF0003",
12804         "vlebrf %v1, 4095(%r2,%r3), 0",
12805     ));
12806     insns.push((
12807         Inst::VecLoadLaneRev {
12808             size: 64,
12809             rd: writable_vr(1),
12810             ri: vr(1),
12811             mem: MemArg::BXD12 {
12812                 base: gpr(2),
12813                 index: zero_reg(),
12814                 disp: UImm12::zero(),
12815                 flags: MemFlags::trusted(),
12816             },
12817             lane_imm: 0,
12818         },
12819         "E61020000002",
12820         "vlebrg %v1, 0(%r2), 0",
12821     ));
12822     insns.push((
12823         Inst::VecLoadLaneRev {
12824             size: 64,
12825             rd: writable_vr(1),
12826             ri: vr(1),
12827             mem: MemArg::BXD12 {
12828                 base: gpr(2),
12829                 index: zero_reg(),
12830                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12831                 flags: MemFlags::trusted(),
12832             },
12833             lane_imm: 0,
12834         },
12835         "E6102FFF0002",
12836         "vlebrg %v1, 4095(%r2), 0",
12837     ));
12838     insns.push((
12839         Inst::VecLoadLaneRev {
12840             size: 64,
12841             rd: writable_vr(1),
12842             ri: vr(1),
12843             mem: MemArg::BXD12 {
12844                 base: gpr(3),
12845                 index: gpr(2),
12846                 disp: UImm12::zero(),
12847                 flags: MemFlags::trusted(),
12848             },
12849             lane_imm: 0,
12850         },
12851         "E61230000002",
12852         "vlebrg %v1, 0(%r2,%r3), 0",
12853     ));
12854     insns.push((
12855         Inst::VecLoadLaneRev {
12856             size: 64,
12857             rd: writable_vr(1),
12858             ri: vr(1),
12859             mem: MemArg::BXD12 {
12860                 base: gpr(3),
12861                 index: gpr(2),
12862                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12863                 flags: MemFlags::trusted(),
12864             },
12865             lane_imm: 0,
12866         },
12867         "E6123FFF0002",
12868         "vlebrg %v1, 4095(%r2,%r3), 0",
12869     ));
12870     insns.push((
12871         Inst::VecLoadLaneRevUndef {
12872             size: 32,
12873             rd: writable_vr(1),
12874             mem: MemArg::BXD12 {
12875                 base: gpr(2),
12876                 index: zero_reg(),
12877                 disp: UImm12::zero(),
12878                 flags: MemFlags::trusted(),
12879             },
12880             lane_imm: 0,
12881         },
12882         "E61020000003",
12883         "vlebrf %v1, 0(%r2), 0",
12884     ));
12885     insns.push((
12886         Inst::VecLoadLaneRevUndef {
12887             size: 32,
12888             rd: writable_vr(1),
12889             mem: MemArg::BXD12 {
12890                 base: gpr(2),
12891                 index: zero_reg(),
12892                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12893                 flags: MemFlags::trusted(),
12894             },
12895             lane_imm: 0,
12896         },
12897         "E6102FFF0003",
12898         "vlebrf %v1, 4095(%r2), 0",
12899     ));
12900     insns.push((
12901         Inst::VecLoadLaneRevUndef {
12902             size: 32,
12903             rd: writable_vr(1),
12904             mem: MemArg::BXD20 {
12905                 base: gpr(2),
12906                 index: zero_reg(),
12907                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12908                 flags: MemFlags::trusted(),
12909             },
12910             lane_imm: 0,
12911         },
12912         "E31020008071E61010000003",
12913         "lay %r1, -524288(%r2) ; vlebrf %v1, 0(%r1), 0",
12914     ));
12915     insns.push((
12916         Inst::VecLoadLaneRevUndef {
12917             size: 32,
12918             rd: writable_vr(1),
12919             mem: MemArg::BXD20 {
12920                 base: gpr(2),
12921                 index: zero_reg(),
12922                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12923                 flags: MemFlags::trusted(),
12924             },
12925             lane_imm: 0,
12926         },
12927         "E3102FFF7F71E61010000003",
12928         "lay %r1, 524287(%r2) ; vlebrf %v1, 0(%r1), 0",
12929     ));
12930     insns.push((
12931         Inst::VecLoadLaneRevUndef {
12932             size: 32,
12933             rd: writable_vr(1),
12934             mem: MemArg::BXD12 {
12935                 base: gpr(3),
12936                 index: gpr(2),
12937                 disp: UImm12::zero(),
12938                 flags: MemFlags::trusted(),
12939             },
12940             lane_imm: 0,
12941         },
12942         "E61230000003",
12943         "vlebrf %v1, 0(%r2,%r3), 0",
12944     ));
12945     insns.push((
12946         Inst::VecLoadLaneRevUndef {
12947             size: 32,
12948             rd: writable_vr(1),
12949             mem: MemArg::BXD12 {
12950                 base: gpr(3),
12951                 index: gpr(2),
12952                 disp: UImm12::maybe_from_u64(4095).unwrap(),
12953                 flags: MemFlags::trusted(),
12954             },
12955             lane_imm: 0,
12956         },
12957         "E6123FFF0003",
12958         "vlebrf %v1, 4095(%r2,%r3), 0",
12959     ));
12960     insns.push((
12961         Inst::VecLoadLaneRevUndef {
12962             size: 32,
12963             rd: writable_vr(1),
12964             mem: MemArg::BXD20 {
12965                 base: gpr(3),
12966                 index: gpr(2),
12967                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
12968                 flags: MemFlags::trusted(),
12969             },
12970             lane_imm: 0,
12971         },
12972         "E31230008071E61010000003",
12973         "lay %r1, -524288(%r2,%r3) ; vlebrf %v1, 0(%r1), 0",
12974     ));
12975     insns.push((
12976         Inst::VecLoadLaneRevUndef {
12977             size: 32,
12978             rd: writable_vr(1),
12979             mem: MemArg::BXD20 {
12980                 base: gpr(3),
12981                 index: gpr(2),
12982                 disp: SImm20::maybe_from_i64(524287).unwrap(),
12983                 flags: MemFlags::trusted(),
12984             },
12985             lane_imm: 0,
12986         },
12987         "E3123FFF7F71E61010000003",
12988         "lay %r1, 524287(%r2,%r3) ; vlebrf %v1, 0(%r1), 0",
12989     ));
12990     insns.push((
12991         Inst::VecLoadLaneRevUndef {
12992             size: 64,
12993             rd: writable_vr(1),
12994             mem: MemArg::BXD12 {
12995                 base: gpr(2),
12996                 index: zero_reg(),
12997                 disp: UImm12::zero(),
12998                 flags: MemFlags::trusted(),
12999             },
13000             lane_imm: 0,
13001         },
13002         "E61020000002",
13003         "vlebrg %v1, 0(%r2), 0",
13004     ));
13005     insns.push((
13006         Inst::VecLoadLaneRevUndef {
13007             size: 64,
13008             rd: writable_vr(1),
13009             mem: MemArg::BXD12 {
13010                 base: gpr(2),
13011                 index: zero_reg(),
13012                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13013                 flags: MemFlags::trusted(),
13014             },
13015             lane_imm: 0,
13016         },
13017         "E6102FFF0002",
13018         "vlebrg %v1, 4095(%r2), 0",
13019     ));
13020     insns.push((
13021         Inst::VecLoadLaneRevUndef {
13022             size: 64,
13023             rd: writable_vr(1),
13024             mem: MemArg::BXD20 {
13025                 base: gpr(2),
13026                 index: zero_reg(),
13027                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13028                 flags: MemFlags::trusted(),
13029             },
13030             lane_imm: 0,
13031         },
13032         "E31020008071E61010000002",
13033         "lay %r1, -524288(%r2) ; vlebrg %v1, 0(%r1), 0",
13034     ));
13035     insns.push((
13036         Inst::VecLoadLaneRevUndef {
13037             size: 64,
13038             rd: writable_vr(1),
13039             mem: MemArg::BXD20 {
13040                 base: gpr(2),
13041                 index: zero_reg(),
13042                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13043                 flags: MemFlags::trusted(),
13044             },
13045             lane_imm: 0,
13046         },
13047         "E3102FFF7F71E61010000002",
13048         "lay %r1, 524287(%r2) ; vlebrg %v1, 0(%r1), 0",
13049     ));
13050     insns.push((
13051         Inst::VecLoadLaneRevUndef {
13052             size: 64,
13053             rd: writable_vr(1),
13054             mem: MemArg::BXD12 {
13055                 base: gpr(3),
13056                 index: gpr(2),
13057                 disp: UImm12::zero(),
13058                 flags: MemFlags::trusted(),
13059             },
13060             lane_imm: 0,
13061         },
13062         "E61230000002",
13063         "vlebrg %v1, 0(%r2,%r3), 0",
13064     ));
13065     insns.push((
13066         Inst::VecLoadLaneRevUndef {
13067             size: 64,
13068             rd: writable_vr(1),
13069             mem: MemArg::BXD12 {
13070                 base: gpr(3),
13071                 index: gpr(2),
13072                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13073                 flags: MemFlags::trusted(),
13074             },
13075             lane_imm: 0,
13076         },
13077         "E6123FFF0002",
13078         "vlebrg %v1, 4095(%r2,%r3), 0",
13079     ));
13080     insns.push((
13081         Inst::VecLoadLaneRevUndef {
13082             size: 64,
13083             rd: writable_vr(1),
13084             mem: MemArg::BXD20 {
13085                 base: gpr(3),
13086                 index: gpr(2),
13087                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13088                 flags: MemFlags::trusted(),
13089             },
13090             lane_imm: 0,
13091         },
13092         "E31230008071E61010000002",
13093         "lay %r1, -524288(%r2,%r3) ; vlebrg %v1, 0(%r1), 0",
13094     ));
13095     insns.push((
13096         Inst::VecLoadLaneRevUndef {
13097             size: 64,
13098             rd: writable_vr(1),
13099             mem: MemArg::BXD20 {
13100                 base: gpr(3),
13101                 index: gpr(2),
13102                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13103                 flags: MemFlags::trusted(),
13104             },
13105             lane_imm: 0,
13106         },
13107         "E3123FFF7F71E61010000002",
13108         "lay %r1, 524287(%r2,%r3) ; vlebrg %v1, 0(%r1), 0",
13109     ));
13110     insns.push((
13111         Inst::VecStoreLaneRev {
13112             size: 16,
13113             rd: vr(1),
13114             mem: MemArg::BXD12 {
13115                 base: gpr(2),
13116                 index: zero_reg(),
13117                 disp: UImm12::zero(),
13118                 flags: MemFlags::trusted(),
13119             },
13120             lane_imm: 7,
13121         },
13122         "E61020007009",
13123         "vstebrh %v1, 0(%r2), 7",
13124     ));
13125     insns.push((
13126         Inst::VecStoreLaneRev {
13127             size: 16,
13128             rd: vr(1),
13129             mem: MemArg::BXD12 {
13130                 base: gpr(2),
13131                 index: zero_reg(),
13132                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13133                 flags: MemFlags::trusted(),
13134             },
13135             lane_imm: 0,
13136         },
13137         "E6102FFF0009",
13138         "vstebrh %v1, 4095(%r2), 0",
13139     ));
13140     insns.push((
13141         Inst::VecStoreLaneRev {
13142             size: 16,
13143             rd: vr(1),
13144             mem: MemArg::BXD12 {
13145                 base: gpr(3),
13146                 index: gpr(2),
13147                 disp: UImm12::zero(),
13148                 flags: MemFlags::trusted(),
13149             },
13150             lane_imm: 7,
13151         },
13152         "E61230007009",
13153         "vstebrh %v1, 0(%r2,%r3), 7",
13154     ));
13155     insns.push((
13156         Inst::VecStoreLaneRev {
13157             size: 16,
13158             rd: vr(1),
13159             mem: MemArg::BXD12 {
13160                 base: gpr(3),
13161                 index: gpr(2),
13162                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13163                 flags: MemFlags::trusted(),
13164             },
13165             lane_imm: 0,
13166         },
13167         "E6123FFF0009",
13168         "vstebrh %v1, 4095(%r2,%r3), 0",
13169     ));
13170     insns.push((
13171         Inst::VecStoreLaneRev {
13172             size: 32,
13173             rd: vr(1),
13174             mem: MemArg::BXD12 {
13175                 base: gpr(2),
13176                 index: zero_reg(),
13177                 disp: UImm12::zero(),
13178                 flags: MemFlags::trusted(),
13179             },
13180             lane_imm: 0,
13181         },
13182         "E6102000000B",
13183         "vstebrf %v1, 0(%r2), 0",
13184     ));
13185     insns.push((
13186         Inst::VecStoreLaneRev {
13187             size: 32,
13188             rd: vr(1),
13189             mem: MemArg::BXD12 {
13190                 base: gpr(2),
13191                 index: zero_reg(),
13192                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13193                 flags: MemFlags::trusted(),
13194             },
13195             lane_imm: 0,
13196         },
13197         "E6102FFF000B",
13198         "vstebrf %v1, 4095(%r2), 0",
13199     ));
13200     insns.push((
13201         Inst::VecStoreLaneRev {
13202             size: 32,
13203             rd: vr(1),
13204             mem: MemArg::BXD20 {
13205                 base: gpr(2),
13206                 index: zero_reg(),
13207                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13208                 flags: MemFlags::trusted(),
13209             },
13210             lane_imm: 0,
13211         },
13212         "E31020008071E6101000000B",
13213         "lay %r1, -524288(%r2) ; vstebrf %v1, 0(%r1), 0",
13214     ));
13215     insns.push((
13216         Inst::VecStoreLaneRev {
13217             size: 32,
13218             rd: vr(1),
13219             mem: MemArg::BXD20 {
13220                 base: gpr(2),
13221                 index: zero_reg(),
13222                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13223                 flags: MemFlags::trusted(),
13224             },
13225             lane_imm: 0,
13226         },
13227         "E3102FFF7F71E6101000000B",
13228         "lay %r1, 524287(%r2) ; vstebrf %v1, 0(%r1), 0",
13229     ));
13230     insns.push((
13231         Inst::VecStoreLaneRev {
13232             size: 32,
13233             rd: vr(1),
13234             mem: MemArg::BXD12 {
13235                 base: gpr(3),
13236                 index: gpr(2),
13237                 disp: UImm12::zero(),
13238                 flags: MemFlags::trusted(),
13239             },
13240             lane_imm: 0,
13241         },
13242         "E6123000000B",
13243         "vstebrf %v1, 0(%r2,%r3), 0",
13244     ));
13245     insns.push((
13246         Inst::VecStoreLaneRev {
13247             size: 32,
13248             rd: vr(1),
13249             mem: MemArg::BXD12 {
13250                 base: gpr(3),
13251                 index: gpr(2),
13252                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13253                 flags: MemFlags::trusted(),
13254             },
13255             lane_imm: 0,
13256         },
13257         "E6123FFF000B",
13258         "vstebrf %v1, 4095(%r2,%r3), 0",
13259     ));
13260     insns.push((
13261         Inst::VecStoreLaneRev {
13262             size: 32,
13263             rd: vr(1),
13264             mem: MemArg::BXD20 {
13265                 base: gpr(3),
13266                 index: gpr(2),
13267                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13268                 flags: MemFlags::trusted(),
13269             },
13270             lane_imm: 0,
13271         },
13272         "E31230008071E6101000000B",
13273         "lay %r1, -524288(%r2,%r3) ; vstebrf %v1, 0(%r1), 0",
13274     ));
13275     insns.push((
13276         Inst::VecStoreLaneRev {
13277             size: 32,
13278             rd: vr(1),
13279             mem: MemArg::BXD20 {
13280                 base: gpr(3),
13281                 index: gpr(2),
13282                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13283                 flags: MemFlags::trusted(),
13284             },
13285             lane_imm: 0,
13286         },
13287         "E3123FFF7F71E6101000000B",
13288         "lay %r1, 524287(%r2,%r3) ; vstebrf %v1, 0(%r1), 0",
13289     ));
13290     insns.push((
13291         Inst::VecStoreLaneRev {
13292             size: 64,
13293             rd: vr(1),
13294             mem: MemArg::BXD12 {
13295                 base: gpr(2),
13296                 index: zero_reg(),
13297                 disp: UImm12::zero(),
13298                 flags: MemFlags::trusted(),
13299             },
13300             lane_imm: 0,
13301         },
13302         "E6102000000A",
13303         "vstebrg %v1, 0(%r2), 0",
13304     ));
13305     insns.push((
13306         Inst::VecStoreLaneRev {
13307             size: 64,
13308             rd: vr(1),
13309             mem: MemArg::BXD12 {
13310                 base: gpr(2),
13311                 index: zero_reg(),
13312                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13313                 flags: MemFlags::trusted(),
13314             },
13315             lane_imm: 0,
13316         },
13317         "E6102FFF000A",
13318         "vstebrg %v1, 4095(%r2), 0",
13319     ));
13320     insns.push((
13321         Inst::VecStoreLaneRev {
13322             size: 64,
13323             rd: vr(1),
13324             mem: MemArg::BXD20 {
13325                 base: gpr(2),
13326                 index: zero_reg(),
13327                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13328                 flags: MemFlags::trusted(),
13329             },
13330             lane_imm: 0,
13331         },
13332         "E31020008071E6101000000A",
13333         "lay %r1, -524288(%r2) ; vstebrg %v1, 0(%r1), 0",
13334     ));
13335     insns.push((
13336         Inst::VecStoreLaneRev {
13337             size: 64,
13338             rd: vr(1),
13339             mem: MemArg::BXD20 {
13340                 base: gpr(2),
13341                 index: zero_reg(),
13342                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13343                 flags: MemFlags::trusted(),
13344             },
13345             lane_imm: 0,
13346         },
13347         "E3102FFF7F71E6101000000A",
13348         "lay %r1, 524287(%r2) ; vstebrg %v1, 0(%r1), 0",
13349     ));
13350     insns.push((
13351         Inst::VecStoreLaneRev {
13352             size: 64,
13353             rd: vr(1),
13354             mem: MemArg::BXD12 {
13355                 base: gpr(3),
13356                 index: gpr(2),
13357                 disp: UImm12::zero(),
13358                 flags: MemFlags::trusted(),
13359             },
13360             lane_imm: 0,
13361         },
13362         "E6123000000A",
13363         "vstebrg %v1, 0(%r2,%r3), 0",
13364     ));
13365     insns.push((
13366         Inst::VecStoreLaneRev {
13367             size: 64,
13368             rd: vr(1),
13369             mem: MemArg::BXD12 {
13370                 base: gpr(3),
13371                 index: gpr(2),
13372                 disp: UImm12::maybe_from_u64(4095).unwrap(),
13373                 flags: MemFlags::trusted(),
13374             },
13375             lane_imm: 0,
13376         },
13377         "E6123FFF000A",
13378         "vstebrg %v1, 4095(%r2,%r3), 0",
13379     ));
13380     insns.push((
13381         Inst::VecStoreLaneRev {
13382             size: 64,
13383             rd: vr(1),
13384             mem: MemArg::BXD20 {
13385                 base: gpr(3),
13386                 index: gpr(2),
13387                 disp: SImm20::maybe_from_i64(-524288).unwrap(),
13388                 flags: MemFlags::trusted(),
13389             },
13390             lane_imm: 0,
13391         },
13392         "E31230008071E6101000000A",
13393         "lay %r1, -524288(%r2,%r3) ; vstebrg %v1, 0(%r1), 0",
13394     ));
13395     insns.push((
13396         Inst::VecStoreLaneRev {
13397             size: 64,
13398             rd: vr(1),
13399             mem: MemArg::BXD20 {
13400                 base: gpr(3),
13401                 index: gpr(2),
13402                 disp: SImm20::maybe_from_i64(524287).unwrap(),
13403                 flags: MemFlags::trusted(),
13404             },
13405             lane_imm: 0,
13406         },
13407         "E3123FFF7F71E6101000000A",
13408         "lay %r1, 524287(%r2,%r3) ; vstebrg %v1, 0(%r1), 0",
13409     ));
13410 
13411     insns.push((
13412         Inst::VecInsertLane {
13413             size: 8,
13414             rd: writable_vr(8),
13415             ri: vr(8),
13416             rn: gpr(4),
13417             lane_imm: 0,
13418             lane_reg: zero_reg(),
13419         },
13420         "E78400000022",
13421         "vlvgb %v8, %r4, 0",
13422     ));
13423     insns.push((
13424         Inst::VecInsertLane {
13425             size: 8,
13426             rd: writable_vr(8),
13427             ri: vr(8),
13428             rn: gpr(4),
13429             lane_imm: 255,
13430             lane_reg: zero_reg(),
13431         },
13432         "E78400FF0022",
13433         "vlvgb %v8, %r4, 255",
13434     ));
13435     insns.push((
13436         Inst::VecInsertLane {
13437             size: 8,
13438             rd: writable_vr(24),
13439             ri: vr(24),
13440             rn: gpr(4),
13441             lane_imm: 0,
13442             lane_reg: gpr(3),
13443         },
13444         "E78430000822",
13445         "vlvgb %v24, %r4, 0(%r3)",
13446     ));
13447     insns.push((
13448         Inst::VecInsertLane {
13449             size: 16,
13450             rd: writable_vr(8),
13451             ri: vr(8),
13452             rn: gpr(4),
13453             lane_imm: 0,
13454             lane_reg: zero_reg(),
13455         },
13456         "E78400001022",
13457         "vlvgh %v8, %r4, 0",
13458     ));
13459     insns.push((
13460         Inst::VecInsertLane {
13461             size: 16,
13462             rd: writable_vr(8),
13463             ri: vr(8),
13464             rn: gpr(4),
13465             lane_imm: 255,
13466             lane_reg: zero_reg(),
13467         },
13468         "E78400FF1022",
13469         "vlvgh %v8, %r4, 255",
13470     ));
13471     insns.push((
13472         Inst::VecInsertLane {
13473             size: 16,
13474             rd: writable_vr(24),
13475             ri: vr(24),
13476             rn: gpr(4),
13477             lane_imm: 0,
13478             lane_reg: gpr(3),
13479         },
13480         "E78430001822",
13481         "vlvgh %v24, %r4, 0(%r3)",
13482     ));
13483     insns.push((
13484         Inst::VecInsertLane {
13485             size: 32,
13486             rd: writable_vr(8),
13487             ri: vr(8),
13488             rn: gpr(4),
13489             lane_imm: 0,
13490             lane_reg: zero_reg(),
13491         },
13492         "E78400002022",
13493         "vlvgf %v8, %r4, 0",
13494     ));
13495     insns.push((
13496         Inst::VecInsertLane {
13497             size: 32,
13498             rd: writable_vr(8),
13499             ri: vr(8),
13500             rn: gpr(4),
13501             lane_imm: 255,
13502             lane_reg: zero_reg(),
13503         },
13504         "E78400FF2022",
13505         "vlvgf %v8, %r4, 255",
13506     ));
13507     insns.push((
13508         Inst::VecInsertLane {
13509             size: 32,
13510             rd: writable_vr(24),
13511             ri: vr(24),
13512             rn: gpr(4),
13513             lane_imm: 0,
13514             lane_reg: gpr(3),
13515         },
13516         "E78430002822",
13517         "vlvgf %v24, %r4, 0(%r3)",
13518     ));
13519     insns.push((
13520         Inst::VecInsertLane {
13521             size: 64,
13522             rd: writable_vr(8),
13523             ri: vr(8),
13524             rn: gpr(4),
13525             lane_imm: 0,
13526             lane_reg: zero_reg(),
13527         },
13528         "E78400003022",
13529         "vlvgg %v8, %r4, 0",
13530     ));
13531     insns.push((
13532         Inst::VecInsertLane {
13533             size: 64,
13534             rd: writable_vr(8),
13535             ri: vr(8),
13536             rn: gpr(4),
13537             lane_imm: 255,
13538             lane_reg: zero_reg(),
13539         },
13540         "E78400FF3022",
13541         "vlvgg %v8, %r4, 255",
13542     ));
13543     insns.push((
13544         Inst::VecInsertLane {
13545             size: 64,
13546             rd: writable_vr(24),
13547             ri: vr(24),
13548             rn: gpr(4),
13549             lane_imm: 0,
13550             lane_reg: gpr(3),
13551         },
13552         "E78430003822",
13553         "vlvgg %v24, %r4, 0(%r3)",
13554     ));
13555     insns.push((
13556         Inst::VecInsertLaneUndef {
13557             size: 8,
13558             rd: writable_vr(8),
13559             rn: gpr(4),
13560             lane_imm: 0,
13561             lane_reg: zero_reg(),
13562         },
13563         "E78400000022",
13564         "vlvgb %v8, %r4, 0",
13565     ));
13566     insns.push((
13567         Inst::VecInsertLaneUndef {
13568             size: 8,
13569             rd: writable_vr(8),
13570             rn: gpr(4),
13571             lane_imm: 255,
13572             lane_reg: zero_reg(),
13573         },
13574         "E78400FF0022",
13575         "vlvgb %v8, %r4, 255",
13576     ));
13577     insns.push((
13578         Inst::VecInsertLaneUndef {
13579             size: 8,
13580             rd: writable_vr(24),
13581             rn: gpr(4),
13582             lane_imm: 0,
13583             lane_reg: gpr(3),
13584         },
13585         "E78430000822",
13586         "vlvgb %v24, %r4, 0(%r3)",
13587     ));
13588     insns.push((
13589         Inst::VecInsertLaneUndef {
13590             size: 16,
13591             rd: writable_vr(8),
13592             rn: gpr(4),
13593             lane_imm: 0,
13594             lane_reg: zero_reg(),
13595         },
13596         "E78400001022",
13597         "vlvgh %v8, %r4, 0",
13598     ));
13599     insns.push((
13600         Inst::VecInsertLaneUndef {
13601             size: 16,
13602             rd: writable_vr(8),
13603             rn: gpr(4),
13604             lane_imm: 255,
13605             lane_reg: zero_reg(),
13606         },
13607         "E78400FF1022",
13608         "vlvgh %v8, %r4, 255",
13609     ));
13610     insns.push((
13611         Inst::VecInsertLaneUndef {
13612             size: 16,
13613             rd: writable_vr(24),
13614             rn: gpr(4),
13615             lane_imm: 0,
13616             lane_reg: gpr(3),
13617         },
13618         "E78430001822",
13619         "vlvgh %v24, %r4, 0(%r3)",
13620     ));
13621     insns.push((
13622         Inst::VecInsertLaneUndef {
13623             size: 32,
13624             rd: writable_vr(8),
13625             rn: gpr(4),
13626             lane_imm: 0,
13627             lane_reg: zero_reg(),
13628         },
13629         "E78400002022",
13630         "vlvgf %v8, %r4, 0",
13631     ));
13632     insns.push((
13633         Inst::VecInsertLaneUndef {
13634             size: 32,
13635             rd: writable_vr(8),
13636             rn: gpr(4),
13637             lane_imm: 255,
13638             lane_reg: zero_reg(),
13639         },
13640         "E78400FF2022",
13641         "vlvgf %v8, %r4, 255",
13642     ));
13643     insns.push((
13644         Inst::VecInsertLaneUndef {
13645             size: 32,
13646             rd: writable_vr(24),
13647             rn: gpr(4),
13648             lane_imm: 0,
13649             lane_reg: gpr(3),
13650         },
13651         "E78430002822",
13652         "vlvgf %v24, %r4, 0(%r3)",
13653     ));
13654     insns.push((
13655         Inst::VecInsertLaneUndef {
13656             size: 64,
13657             rd: writable_vr(8),
13658             rn: gpr(4),
13659             lane_imm: 0,
13660             lane_reg: zero_reg(),
13661         },
13662         "B3C10084",
13663         "ldgr %f8, %r4",
13664     ));
13665     insns.push((
13666         Inst::VecInsertLaneUndef {
13667             size: 64,
13668             rd: writable_vr(8),
13669             rn: gpr(4),
13670             lane_imm: 255,
13671             lane_reg: zero_reg(),
13672         },
13673         "E78400FF3022",
13674         "vlvgg %v8, %r4, 255",
13675     ));
13676     insns.push((
13677         Inst::VecInsertLaneUndef {
13678             size: 64,
13679             rd: writable_vr(8),
13680             rn: gpr(4),
13681             lane_imm: 0,
13682             lane_reg: gpr(3),
13683         },
13684         "E78430003022",
13685         "vlvgg %v8, %r4, 0(%r3)",
13686     ));
13687     insns.push((
13688         Inst::VecExtractLane {
13689             size: 8,
13690             rd: writable_gpr(8),
13691             rn: vr(4),
13692             lane_imm: 255,
13693             lane_reg: zero_reg(),
13694         },
13695         "E78400FF0021",
13696         "vlgvb %r8, %v4, 255",
13697     ));
13698     insns.push((
13699         Inst::VecExtractLane {
13700             size: 8,
13701             rd: writable_gpr(8),
13702             rn: vr(20),
13703             lane_imm: 0,
13704             lane_reg: gpr(3),
13705         },
13706         "E78430000421",
13707         "vlgvb %r8, %v20, 0(%r3)",
13708     ));
13709     insns.push((
13710         Inst::VecExtractLane {
13711             size: 16,
13712             rd: writable_gpr(8),
13713             rn: vr(4),
13714             lane_imm: 0,
13715             lane_reg: zero_reg(),
13716         },
13717         "E78400001021",
13718         "vlgvh %r8, %v4, 0",
13719     ));
13720     insns.push((
13721         Inst::VecExtractLane {
13722             size: 16,
13723             rd: writable_gpr(8),
13724             rn: vr(4),
13725             lane_imm: 255,
13726             lane_reg: zero_reg(),
13727         },
13728         "E78400FF1021",
13729         "vlgvh %r8, %v4, 255",
13730     ));
13731     insns.push((
13732         Inst::VecExtractLane {
13733             size: 16,
13734             rd: writable_gpr(8),
13735             rn: vr(20),
13736             lane_imm: 0,
13737             lane_reg: gpr(3),
13738         },
13739         "E78430001421",
13740         "vlgvh %r8, %v20, 0(%r3)",
13741     ));
13742     insns.push((
13743         Inst::VecExtractLane {
13744             size: 32,
13745             rd: writable_gpr(8),
13746             rn: vr(4),
13747             lane_imm: 0,
13748             lane_reg: zero_reg(),
13749         },
13750         "E78400002021",
13751         "vlgvf %r8, %v4, 0",
13752     ));
13753     insns.push((
13754         Inst::VecExtractLane {
13755             size: 32,
13756             rd: writable_gpr(8),
13757             rn: vr(4),
13758             lane_imm: 255,
13759             lane_reg: zero_reg(),
13760         },
13761         "E78400FF2021",
13762         "vlgvf %r8, %v4, 255",
13763     ));
13764     insns.push((
13765         Inst::VecExtractLane {
13766             size: 32,
13767             rd: writable_gpr(8),
13768             rn: vr(20),
13769             lane_imm: 0,
13770             lane_reg: gpr(3),
13771         },
13772         "E78430002421",
13773         "vlgvf %r8, %v20, 0(%r3)",
13774     ));
13775     insns.push((
13776         Inst::VecExtractLane {
13777             size: 64,
13778             rd: writable_gpr(8),
13779             rn: vr(4),
13780             lane_imm: 0,
13781             lane_reg: zero_reg(),
13782         },
13783         "B3CD0084",
13784         "lgdr %r8, %f4",
13785     ));
13786     insns.push((
13787         Inst::VecExtractLane {
13788             size: 64,
13789             rd: writable_gpr(8),
13790             rn: vr(4),
13791             lane_imm: 255,
13792             lane_reg: zero_reg(),
13793         },
13794         "E78400FF3021",
13795         "vlgvg %r8, %v4, 255",
13796     ));
13797     insns.push((
13798         Inst::VecExtractLane {
13799             size: 64,
13800             rd: writable_gpr(8),
13801             rn: vr(4),
13802             lane_imm: 0,
13803             lane_reg: gpr(3),
13804         },
13805         "E78430003021",
13806         "vlgvg %r8, %v4, 0(%r3)",
13807     ));
13808     insns.push((
13809         Inst::VecInsertLaneImm {
13810             size: 8,
13811             rd: writable_vr(20),
13812             ri: vr(20),
13813             imm: 0x1234,
13814             lane_imm: 15,
13815         },
13816         "E7401234F840",
13817         "vleib %v20, 4660, 15",
13818     ));
13819     insns.push((
13820         Inst::VecInsertLaneImm {
13821             size: 16,
13822             rd: writable_vr(20),
13823             ri: vr(20),
13824             imm: 0x1234,
13825             lane_imm: 7,
13826         },
13827         "E74012347841",
13828         "vleih %v20, 4660, 7",
13829     ));
13830     insns.push((
13831         Inst::VecInsertLaneImm {
13832             size: 32,
13833             rd: writable_vr(20),
13834             ri: vr(20),
13835             imm: 0x1234,
13836             lane_imm: 3,
13837         },
13838         "E74012343843",
13839         "vleif %v20, 4660, 3",
13840     ));
13841     insns.push((
13842         Inst::VecInsertLaneImm {
13843             size: 64,
13844             rd: writable_vr(20),
13845             ri: vr(20),
13846             imm: 0x1234,
13847             lane_imm: 1,
13848         },
13849         "E74012341842",
13850         "vleig %v20, 4660, 1",
13851     ));
13852     insns.push((
13853         Inst::VecInsertLaneImmUndef {
13854             size: 8,
13855             rd: writable_vr(20),
13856             imm: 0x1234,
13857             lane_imm: 15,
13858         },
13859         "E7401234F840",
13860         "vleib %v20, 4660, 15",
13861     ));
13862     insns.push((
13863         Inst::VecInsertLaneImmUndef {
13864             size: 16,
13865             rd: writable_vr(20),
13866             imm: 0x1234,
13867             lane_imm: 7,
13868         },
13869         "E74012347841",
13870         "vleih %v20, 4660, 7",
13871     ));
13872     insns.push((
13873         Inst::VecInsertLaneImmUndef {
13874             size: 32,
13875             rd: writable_vr(20),
13876             imm: 0x1234,
13877             lane_imm: 3,
13878         },
13879         "E74012343843",
13880         "vleif %v20, 4660, 3",
13881     ));
13882     insns.push((
13883         Inst::VecInsertLaneImmUndef {
13884             size: 64,
13885             rd: writable_vr(20),
13886             imm: 0x1234,
13887             lane_imm: 1,
13888         },
13889         "E74012341842",
13890         "vleig %v20, 4660, 1",
13891     ));
13892     insns.push((
13893         Inst::VecReplicateLane {
13894             size: 8,
13895             rd: writable_vr(20),
13896             rn: vr(8),
13897             lane_imm: 15,
13898         },
13899         "E748000F084D",
13900         "vrepb %v20, %v8, 15",
13901     ));
13902     insns.push((
13903         Inst::VecReplicateLane {
13904             size: 16,
13905             rd: writable_vr(20),
13906             rn: vr(8),
13907             lane_imm: 7,
13908         },
13909         "E7480007184D",
13910         "vreph %v20, %v8, 7",
13911     ));
13912     insns.push((
13913         Inst::VecReplicateLane {
13914             size: 32,
13915             rd: writable_vr(20),
13916             rn: vr(8),
13917             lane_imm: 3,
13918         },
13919         "E7480003284D",
13920         "vrepf %v20, %v8, 3",
13921     ));
13922     insns.push((
13923         Inst::VecReplicateLane {
13924             size: 64,
13925             rd: writable_vr(20),
13926             rn: vr(8),
13927             lane_imm: 1,
13928         },
13929         "E7480001384D",
13930         "vrepg %v20, %v8, 1",
13931     ));
13932 
13933     let flags = settings::Flags::new(settings::builder());
13934 
13935     use crate::settings::Configurable;
13936     let mut isa_flag_builder = s390x_settings::builder();
13937     isa_flag_builder.enable("arch15").unwrap();
13938     let isa_flags = s390x_settings::Flags::new(&flags, &isa_flag_builder);
13939     let ctrl_plane = &mut Default::default();
13940     let constants = Default::default();
13941 
13942     let emit_info = EmitInfo::new(isa_flags);
13943     for (insn, expected_encoding, expected_printing) in insns {
13944         println!("S390x: {insn:?}, {expected_encoding}, {expected_printing}");
13945 
13946         // Check the printed text is as expected.
13947         let actual_printing = insn.print_with_state(&mut EmitState::default());
13948         assert_eq!(expected_printing, actual_printing);
13949 
13950         let mut buffer = MachBuffer::new();
13951 
13952         // Label 0 before the instruction.
13953         let label0 = buffer.get_label();
13954         buffer.bind_label(label0, ctrl_plane);
13955 
13956         // Emit the instruction.
13957         insn.emit(&mut buffer, &emit_info, &mut Default::default());
13958 
13959         // Label 1 after the instruction.
13960         let label1 = buffer.get_label();
13961         buffer.bind_label(label1, ctrl_plane);
13962 
13963         let buffer = buffer.finish(&constants, ctrl_plane);
13964         let actual_encoding = &buffer.stringify_code_bytes();
13965         assert_eq!(expected_encoding, actual_encoding);
13966     }
13967 }
13968