1 // GENERATED BY ISLE. DO NOT EDIT!
2 //
3 // Generated automatically from the instruction-selection DSL code in:
4 // - src/clif.isle
5 // - src/prelude.isle
6 // - src/isa/x64/inst.isle
7 // - src/isa/x64/lower.isle
8 
9 #![allow(dead_code, unreachable_code, unreachable_patterns)]
10 #![allow(unused_imports, unused_variables, non_snake_case)]
11 #![allow(irrefutable_let_patterns)]
12 
13 use super::*; // Pulls in all external types.
14 
15 /// Context during lowering: an implementation of this trait
16 /// must be provided with all external constructors and extractors.
17 /// A mutable borrow is passed along through all lowering logic.
18 pub trait Context {
19     fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
20     fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
21     fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
22     fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
23     fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
24     fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
25     fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
26     fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
27     fn value_regs_invalid(&mut self) -> ValueRegs;
28     fn output_none(&mut self) -> InstOutput;
29     fn output(&mut self, arg0: ValueRegs) -> InstOutput;
30     fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
31     fn output_builder_new(&mut self) -> InstOutputBuilder;
32     fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;
33     fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;
34     fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
35     fn invalid_reg(&mut self) -> Reg;
36     fn put_in_reg(&mut self, arg0: Value) -> Reg;
37     fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
38     fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
39     fn u8_as_u64(&mut self, arg0: u8) -> u64;
40     fn u16_as_u64(&mut self, arg0: u16) -> u64;
41     fn u32_as_u64(&mut self, arg0: u32) -> u64;
42     fn i64_as_u64(&mut self, arg0: i64) -> u64;
43     fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
44     fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
45     fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
46     fn ty_bits(&mut self, arg0: Type) -> u8;
47     fn ty_bits_u16(&mut self, arg0: Type) -> u16;
48     fn ty_bits_u64(&mut self, arg0: Type) -> u64;
49     fn ty_mask(&mut self, arg0: Type) -> u64;
50     fn ty_bytes(&mut self, arg0: Type) -> u16;
51     fn lane_type(&mut self, arg0: Type) -> Type;
52     fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
53     fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
54     fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
55     fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
56     fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
57     fn ty_int_bool_64(&mut self, arg0: Type) -> Option<Type>;
58     fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option<Type>;
59     fn ty_int_bool_128(&mut self, arg0: Type) -> Option<Type>;
60     fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
61     fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
62     fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
63     fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
64     fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
65     fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
66     fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
67     fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
68     fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
69     fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
70     fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
71     fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
72     fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64;
73     fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
74     fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
75     fn first_result(&mut self, arg0: Inst) -> Option<Value>;
76     fn inst_data(&mut self, arg0: Inst) -> InstructionData;
77     fn value_type(&mut self, arg0: Value) -> Type;
78     fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>;
79     fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
80     fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
81     fn emit(&mut self, arg0: &MInst) -> Unit;
82     fn emit_safepoint(&mut self, arg0: &MInst) -> Unit;
83     fn trap_code_division_by_zero(&mut self) -> TrapCode;
84     fn trap_code_integer_overflow(&mut self) -> TrapCode;
85     fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
86     fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>;
87     fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
88     fn symbol_value_data(
89         &mut self,
90         arg0: GlobalValue,
91     ) -> Option<(ExternalName, RelocDistance, i64)>;
92     fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
93     fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
94     fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
95     fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
96     fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
97     fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
98     fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
99     fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode;
100     fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode;
101     fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode;
102     fn const_shift_lt_eq_3(&mut self, arg0: Value) -> Option<u8>;
103     fn sum_extend_fits_in_32_bits(
104         &mut self,
105         arg0: Offset32,
106         arg1: Type,
107         arg2: Imm64,
108     ) -> Option<u32>;
109     fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr;
110     fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
111     fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
112     fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
113     fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
114     fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
115     fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
116     fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
117     fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
118     fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
119     fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
120     fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
121     fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
122     fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
123     fn temp_writable_gpr(&mut self) -> WritableGpr;
124     fn temp_writable_xmm(&mut self) -> WritableXmm;
125     fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
126     fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
127     fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
128     fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
129     fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
130     fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
131     fn xmm_new(&mut self, arg0: Reg) -> Xmm;
132     fn gpr_new(&mut self, arg0: Reg) -> Gpr;
133     fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
134     fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
135     fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
136     fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
137     fn xmm0(&mut self) -> WritableXmm;
138     fn is_xmm_type(&mut self, arg0: Type) -> Option<Type>;
139     fn is_gpr_type(&mut self, arg0: Type) -> Option<Type>;
140     fn is_single_register_type(&mut self, arg0: Type) -> Option<Type>;
141     fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>;
142     fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>;
143     fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>;
144     fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>;
145     fn use_lzcnt(&mut self, arg0: Type) -> Option<()>;
146     fn use_bmi1(&mut self, arg0: Type) -> Option<()>;
147     fn use_popcnt(&mut self, arg0: Type) -> Option<()>;
148     fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
149     fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
150     fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
151     fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
152     fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
153     fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm;
154     fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
155     fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
156     fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
157     fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
158     fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
159     fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
160     fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
161     fn popcount_4bit_table(&mut self) -> VCodeConstant;
162     fn popcount_low_mask(&mut self) -> VCodeConstant;
163 }
164 
165 /// Internal type SideEffectNoResult: defined at src/prelude.isle line 405.
166 #[derive(Clone, Debug)]
167 pub enum SideEffectNoResult {
168     Inst { inst: MInst },
169 }
170 
171 /// Internal type ProducesFlags: defined at src/prelude.isle line 427.
172 #[derive(Clone, Debug)]
173 pub enum ProducesFlags {
174     ProducesFlagsSideEffect { inst: MInst },
175     ProducesFlagsReturnsReg { inst: MInst, result: Reg },
176     ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
177 }
178 
179 /// Internal type ConsumesFlags: defined at src/prelude.isle line 438.
180 #[derive(Clone, Debug)]
181 pub enum ConsumesFlags {
182     ConsumesFlagsReturnsResultWithProducer {
183         inst: MInst,
184         result: Reg,
185     },
186     ConsumesFlagsReturnsReg {
187         inst: MInst,
188         result: Reg,
189     },
190     ConsumesFlagsTwiceReturnsValueRegs {
191         inst1: MInst,
192         inst2: MInst,
193         result: ValueRegs,
194     },
195     ConsumesFlagsFourTimesReturnsValueRegs {
196         inst1: MInst,
197         inst2: MInst,
198         inst3: MInst,
199         inst4: MInst,
200         result: ValueRegs,
201     },
202 }
203 
204 /// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
205 #[derive(Clone)]
206 pub enum MInst {
207     Nop {
208         len: u8,
209     },
210     AluRmiR {
211         size: OperandSize,
212         op: AluRmiROpcode,
213         src1: Gpr,
214         src2: GprMemImm,
215         dst: WritableGpr,
216     },
217     UnaryRmR {
218         size: OperandSize,
219         op: UnaryRmROpcode,
220         src: GprMem,
221         dst: WritableGpr,
222     },
223     Not {
224         size: OperandSize,
225         src: Gpr,
226         dst: WritableGpr,
227     },
228     Neg {
229         size: OperandSize,
230         src: Gpr,
231         dst: WritableGpr,
232     },
233     Div {
234         size: OperandSize,
235         signed: bool,
236         divisor: GprMem,
237         dividend: Gpr,
238         dst_quotient: WritableGpr,
239         dst_remainder: WritableGpr,
240     },
241     MulHi {
242         size: OperandSize,
243         signed: bool,
244         src1: Gpr,
245         src2: GprMem,
246         dst_lo: WritableGpr,
247         dst_hi: WritableGpr,
248     },
249     CheckedDivOrRemSeq {
250         kind: DivOrRemKind,
251         size: OperandSize,
252         dividend: Gpr,
253         divisor: WritableGpr,
254         dst_quotient: WritableGpr,
255         dst_remainder: WritableGpr,
256         tmp: OptionWritableGpr,
257     },
258     SignExtendData {
259         size: OperandSize,
260         src: Gpr,
261         dst: WritableGpr,
262     },
263     Imm {
264         dst_size: OperandSize,
265         simm64: u64,
266         dst: WritableGpr,
267     },
268     MovRR {
269         size: OperandSize,
270         src: Gpr,
271         dst: WritableGpr,
272     },
273     MovzxRmR {
274         ext_mode: ExtMode,
275         src: GprMem,
276         dst: WritableGpr,
277     },
278     Mov64MR {
279         src: SyntheticAmode,
280         dst: WritableGpr,
281     },
282     LoadEffectiveAddress {
283         addr: SyntheticAmode,
284         dst: WritableGpr,
285     },
286     MovsxRmR {
287         ext_mode: ExtMode,
288         src: GprMem,
289         dst: WritableGpr,
290     },
291     MovRM {
292         size: OperandSize,
293         src: Gpr,
294         dst: SyntheticAmode,
295     },
296     ShiftR {
297         size: OperandSize,
298         kind: ShiftKind,
299         src: Gpr,
300         num_bits: Imm8Gpr,
301         dst: WritableGpr,
302     },
303     XmmRmiReg {
304         opcode: SseOpcode,
305         src1: Xmm,
306         src2: XmmMemImm,
307         dst: WritableXmm,
308     },
309     CmpRmiR {
310         size: OperandSize,
311         opcode: CmpOpcode,
312         src: GprMemImm,
313         dst: Gpr,
314     },
315     Setcc {
316         cc: CC,
317         dst: WritableGpr,
318     },
319     Cmove {
320         size: OperandSize,
321         cc: CC,
322         consequent: GprMem,
323         alternative: Gpr,
324         dst: WritableGpr,
325     },
326     XmmCmove {
327         size: OperandSize,
328         cc: CC,
329         consequent: XmmMem,
330         alternative: Xmm,
331         dst: WritableXmm,
332     },
333     Push64 {
334         src: GprMemImm,
335     },
336     Pop64 {
337         dst: WritableGpr,
338     },
339     XmmRmR {
340         op: SseOpcode,
341         src1: Xmm,
342         src2: XmmMem,
343         dst: WritableXmm,
344     },
345     XmmRmREvex {
346         op: Avx512Opcode,
347         src1: XmmMem,
348         src2: Xmm,
349         dst: WritableXmm,
350     },
351     XmmUnaryRmR {
352         op: SseOpcode,
353         src: XmmMem,
354         dst: WritableXmm,
355     },
356     XmmUnaryRmREvex {
357         op: Avx512Opcode,
358         src: XmmMem,
359         dst: WritableXmm,
360     },
361     XmmMovRM {
362         op: SseOpcode,
363         src: Reg,
364         dst: SyntheticAmode,
365     },
366     XmmLoadConst {
367         src: VCodeConstant,
368         dst: WritableReg,
369         ty: Type,
370     },
371     XmmToGpr {
372         op: SseOpcode,
373         src: Xmm,
374         dst: WritableGpr,
375         dst_size: OperandSize,
376     },
377     GprToXmm {
378         op: SseOpcode,
379         src: GprMem,
380         dst: WritableXmm,
381         src_size: OperandSize,
382     },
383     CvtUint64ToFloatSeq {
384         dst_size: OperandSize,
385         src: WritableGpr,
386         dst: WritableXmm,
387         tmp_gpr1: WritableGpr,
388         tmp_gpr2: WritableGpr,
389     },
390     CvtFloatToSintSeq {
391         dst_size: OperandSize,
392         src_size: OperandSize,
393         is_saturating: bool,
394         src: WritableXmm,
395         dst: WritableGpr,
396         tmp_gpr: WritableGpr,
397         tmp_xmm: WritableXmm,
398     },
399     CvtFloatToUintSeq {
400         dst_size: OperandSize,
401         src_size: OperandSize,
402         is_saturating: bool,
403         src: WritableXmm,
404         dst: WritableGpr,
405         tmp_gpr: WritableGpr,
406         tmp_xmm: WritableXmm,
407     },
408     XmmMinMaxSeq {
409         size: OperandSize,
410         is_min: bool,
411         lhs: Xmm,
412         rhs: Xmm,
413         dst: WritableXmm,
414     },
415     XmmCmpRmR {
416         op: SseOpcode,
417         src: XmmMem,
418         dst: Xmm,
419     },
420     XmmRmRImm {
421         op: SseOpcode,
422         src1: Reg,
423         src2: RegMem,
424         dst: WritableReg,
425         imm: u8,
426         size: OperandSize,
427     },
428     CallKnown {
429         dest: ExternalName,
430         uses: VecReg,
431         defs: VecWritableReg,
432         opcode: Opcode,
433     },
434     CallUnknown {
435         dest: RegMem,
436         uses: VecReg,
437         defs: VecWritableReg,
438         opcode: Opcode,
439     },
440     Ret,
441     EpiloguePlaceholder,
442     JmpKnown {
443         dst: MachLabel,
444     },
445     JmpIf {
446         cc: CC,
447         taken: MachLabel,
448     },
449     JmpCond {
450         cc: CC,
451         taken: MachLabel,
452         not_taken: MachLabel,
453     },
454     JmpTableSeq {
455         idx: Reg,
456         tmp1: WritableReg,
457         tmp2: WritableReg,
458         default_target: MachLabel,
459         targets: VecMachLabel,
460         targets_for_term: VecMachLabel,
461     },
462     JmpUnknown {
463         target: RegMem,
464     },
465     TrapIf {
466         cc: CC,
467         trap_code: TrapCode,
468     },
469     Hlt,
470     Ud2 {
471         trap_code: TrapCode,
472     },
473     LoadExtName {
474         dst: WritableReg,
475         name: BoxExternalName,
476         offset: i64,
477     },
478     LockCmpxchg {
479         ty: Type,
480         replacement: Reg,
481         expected: Reg,
482         mem: SyntheticAmode,
483         dst_old: WritableReg,
484     },
485     AtomicRmwSeq {
486         ty: Type,
487         op: AtomicRmwOp,
488         address: Reg,
489         operand: Reg,
490         temp: WritableReg,
491         dst_old: WritableReg,
492     },
493     Fence {
494         kind: FenceKind,
495     },
496     VirtualSPOffsetAdj {
497         offset: i64,
498     },
499     XmmUninitializedValue {
500         dst: WritableXmm,
501     },
502     ElfTlsGetAddr {
503         symbol: ExternalName,
504     },
505     MachOTlsGetAddr {
506         symbol: ExternalName,
507     },
508     ValueLabelMarker {
509         reg: Reg,
510         label: ValueLabel,
511     },
512     Unwind {
513         inst: UnwindInst,
514     },
515 }
516 
517 /// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1201.
518 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
519 pub enum ExtendKind {
520     Sign,
521     Zero,
522 }
523 
524 // Generated as internal constructor for term output_reg.
525 pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
526     let pattern0_0 = arg0;
527     // Rule at src/prelude.isle line 86.
528     let expr0_0 = C::value_reg(ctx, pattern0_0);
529     let expr1_0 = C::output(ctx, expr0_0);
530     return Some(expr1_0);
531 }
532 
533 // Generated as internal constructor for term output_value.
534 pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> Option<InstOutput> {
535     let pattern0_0 = arg0;
536     // Rule at src/prelude.isle line 90.
537     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
538     let expr1_0 = C::output(ctx, expr0_0);
539     return Some(expr1_0);
540 }
541 
542 // Generated as internal constructor for term temp_reg.
543 pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Option<Reg> {
544     let pattern0_0 = arg0;
545     // Rule at src/prelude.isle line 110.
546     let expr0_0 = C::temp_writable_reg(ctx, pattern0_0);
547     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
548     return Some(expr1_0);
549 }
550 
551 // Generated as internal constructor for term lo_reg.
552 pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Option<Reg> {
553     let pattern0_0 = arg0;
554     // Rule at src/prelude.isle line 145.
555     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
556     let expr1_0: usize = 0;
557     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
558     return Some(expr2_0);
559 }
560 
561 // Generated as internal constructor for term side_effect.
562 pub fn constructor_side_effect<C: Context>(
563     ctx: &mut C,
564     arg0: &SideEffectNoResult,
565 ) -> Option<InstOutput> {
566     let pattern0_0 = arg0;
567     if let &SideEffectNoResult::Inst {
568         inst: ref pattern1_0,
569     } = pattern0_0
570     {
571         // Rule at src/prelude.isle line 410.
572         let expr0_0 = C::emit(ctx, pattern1_0);
573         let expr1_0 = C::output_none(ctx);
574         return Some(expr1_0);
575     }
576     return None;
577 }
578 
579 // Generated as internal constructor for term safepoint.
580 pub fn constructor_safepoint<C: Context>(
581     ctx: &mut C,
582     arg0: &SideEffectNoResult,
583 ) -> Option<InstOutput> {
584     let pattern0_0 = arg0;
585     if let &SideEffectNoResult::Inst {
586         inst: ref pattern1_0,
587     } = pattern0_0
588     {
589         // Rule at src/prelude.isle line 416.
590         let expr0_0 = C::emit_safepoint(ctx, pattern1_0);
591         let expr1_0 = C::output_none(ctx);
592         return Some(expr1_0);
593     }
594     return None;
595 }
596 
597 // Generated as internal constructor for term produces_flags_get_reg.
598 pub fn constructor_produces_flags_get_reg<C: Context>(
599     ctx: &mut C,
600     arg0: &ProducesFlags,
601 ) -> Option<Reg> {
602     let pattern0_0 = arg0;
603     if let &ProducesFlags::ProducesFlagsReturnsReg {
604         inst: ref pattern1_0,
605         result: pattern1_1,
606     } = pattern0_0
607     {
608         // Rule at src/prelude.isle line 454.
609         return Some(pattern1_1);
610     }
611     return None;
612 }
613 
614 // Generated as internal constructor for term produces_flags_ignore.
615 pub fn constructor_produces_flags_ignore<C: Context>(
616     ctx: &mut C,
617     arg0: &ProducesFlags,
618 ) -> Option<ProducesFlags> {
619     let pattern0_0 = arg0;
620     match pattern0_0 {
621         &ProducesFlags::ProducesFlagsReturnsReg {
622             inst: ref pattern1_0,
623             result: pattern1_1,
624         } => {
625             // Rule at src/prelude.isle line 459.
626             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
627                 inst: pattern1_0.clone(),
628             };
629             return Some(expr0_0);
630         }
631         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
632             inst: ref pattern1_0,
633             result: pattern1_1,
634         } => {
635             // Rule at src/prelude.isle line 461.
636             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
637                 inst: pattern1_0.clone(),
638             };
639             return Some(expr0_0);
640         }
641         _ => {}
642     }
643     return None;
644 }
645 
646 // Generated as internal constructor for term consumes_flags_concat.
647 pub fn constructor_consumes_flags_concat<C: Context>(
648     ctx: &mut C,
649     arg0: &ConsumesFlags,
650     arg1: &ConsumesFlags,
651 ) -> Option<ConsumesFlags> {
652     let pattern0_0 = arg0;
653     if let &ConsumesFlags::ConsumesFlagsReturnsReg {
654         inst: ref pattern1_0,
655         result: pattern1_1,
656     } = pattern0_0
657     {
658         let pattern2_0 = arg1;
659         if let &ConsumesFlags::ConsumesFlagsReturnsReg {
660             inst: ref pattern3_0,
661             result: pattern3_1,
662         } = pattern2_0
663         {
664             // Rule at src/prelude.isle line 468.
665             let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
666             let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
667                 inst1: pattern1_0.clone(),
668                 inst2: pattern3_0.clone(),
669                 result: expr0_0,
670             };
671             return Some(expr1_0);
672         }
673     }
674     return None;
675 }
676 
677 // Generated as internal constructor for term with_flags.
678 pub fn constructor_with_flags<C: Context>(
679     ctx: &mut C,
680     arg0: &ProducesFlags,
681     arg1: &ConsumesFlags,
682 ) -> Option<ValueRegs> {
683     let pattern0_0 = arg0;
684     match pattern0_0 {
685         &ProducesFlags::ProducesFlagsSideEffect {
686             inst: ref pattern1_0,
687         } => {
688             let pattern2_0 = arg1;
689             match pattern2_0 {
690                 &ConsumesFlags::ConsumesFlagsReturnsReg {
691                     inst: ref pattern3_0,
692                     result: pattern3_1,
693                 } => {
694                     // Rule at src/prelude.isle line 493.
695                     let expr0_0 = C::emit(ctx, pattern1_0);
696                     let expr1_0 = C::emit(ctx, pattern3_0);
697                     let expr2_0 = C::value_reg(ctx, pattern3_1);
698                     return Some(expr2_0);
699                 }
700                 &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
701                     inst1: ref pattern3_0,
702                     inst2: ref pattern3_1,
703                     result: pattern3_2,
704                 } => {
705                     // Rule at src/prelude.isle line 499.
706                     let expr0_0 = C::emit(ctx, pattern1_0);
707                     let expr1_0 = C::emit(ctx, pattern3_0);
708                     let expr2_0 = C::emit(ctx, pattern3_1);
709                     return Some(pattern3_2);
710                 }
711                 &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
712                     inst1: ref pattern3_0,
713                     inst2: ref pattern3_1,
714                     inst3: ref pattern3_2,
715                     inst4: ref pattern3_3,
716                     result: pattern3_4,
717                 } => {
718                     // Rule at src/prelude.isle line 511.
719                     let expr0_0 = C::emit(ctx, pattern1_0);
720                     let expr1_0 = C::emit(ctx, pattern3_0);
721                     let expr2_0 = C::emit(ctx, pattern3_1);
722                     let expr3_0 = C::emit(ctx, pattern3_2);
723                     let expr4_0 = C::emit(ctx, pattern3_3);
724                     return Some(pattern3_4);
725                 }
726                 _ => {}
727             }
728         }
729         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
730             inst: ref pattern1_0,
731             result: pattern1_1,
732         } => {
733             let pattern2_0 = arg1;
734             if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
735                 inst: ref pattern3_0,
736                 result: pattern3_1,
737             } = pattern2_0
738             {
739                 // Rule at src/prelude.isle line 487.
740                 let expr0_0 = C::emit(ctx, pattern1_0);
741                 let expr1_0 = C::emit(ctx, pattern3_0);
742                 let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
743                 return Some(expr2_0);
744             }
745         }
746         _ => {}
747     }
748     return None;
749 }
750 
751 // Generated as internal constructor for term with_flags_reg.
752 pub fn constructor_with_flags_reg<C: Context>(
753     ctx: &mut C,
754     arg0: &ProducesFlags,
755     arg1: &ConsumesFlags,
756 ) -> Option<Reg> {
757     let pattern0_0 = arg0;
758     let pattern1_0 = arg1;
759     // Rule at src/prelude.isle line 528.
760     let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?;
761     let expr1_0: usize = 0;
762     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
763     return Some(expr2_0);
764 }
765 
766 // Generated as internal constructor for term operand_size_bits.
767 pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> Option<u16> {
768     let pattern0_0 = arg0;
769     match pattern0_0 {
770         &OperandSize::Size8 => {
771             // Rule at src/isa/x64/inst.isle line 510.
772             let expr0_0: u16 = 8;
773             return Some(expr0_0);
774         }
775         &OperandSize::Size16 => {
776             // Rule at src/isa/x64/inst.isle line 511.
777             let expr0_0: u16 = 16;
778             return Some(expr0_0);
779         }
780         &OperandSize::Size32 => {
781             // Rule at src/isa/x64/inst.isle line 512.
782             let expr0_0: u16 = 32;
783             return Some(expr0_0);
784         }
785         &OperandSize::Size64 => {
786             // Rule at src/isa/x64/inst.isle line 513.
787             let expr0_0: u16 = 64;
788             return Some(expr0_0);
789         }
790         _ => {}
791     }
792     return None;
793 }
794 
795 // Generated as internal constructor for term amode_imm_reg_flags.
796 pub fn constructor_amode_imm_reg_flags<C: Context>(
797     ctx: &mut C,
798     arg0: u32,
799     arg1: Gpr,
800     arg2: MemFlags,
801 ) -> Option<Amode> {
802     let pattern0_0 = arg0;
803     let pattern1_0 = arg1;
804     let pattern2_0 = arg2;
805     // Rule at src/isa/x64/inst.isle line 770.
806     let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0);
807     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0);
808     return Some(expr1_0);
809 }
810 
811 // Generated as internal constructor for term amode_imm_reg_reg_shift_flags.
812 pub fn constructor_amode_imm_reg_reg_shift_flags<C: Context>(
813     ctx: &mut C,
814     arg0: u32,
815     arg1: Gpr,
816     arg2: Gpr,
817     arg3: u8,
818     arg4: MemFlags,
819 ) -> Option<Amode> {
820     let pattern0_0 = arg0;
821     let pattern1_0 = arg1;
822     let pattern2_0 = arg2;
823     let pattern3_0 = arg3;
824     let pattern4_0 = arg4;
825     // Rule at src/isa/x64/inst.isle line 777.
826     let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0);
827     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0);
828     return Some(expr1_0);
829 }
830 
831 // Generated as internal constructor for term to_amode.
832 pub fn constructor_to_amode<C: Context>(
833     ctx: &mut C,
834     arg0: MemFlags,
835     arg1: Value,
836     arg2: Offset32,
837 ) -> Option<Amode> {
838     let pattern0_0 = arg0;
839     let pattern1_0 = arg1;
840     if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) {
841         let pattern3_0 = C::inst_data(ctx, pattern2_0);
842         if let &InstructionData::Binary {
843             opcode: ref pattern4_0,
844             args: ref pattern4_1,
845         } = &pattern3_0
846         {
847             if let &Opcode::Iadd = pattern4_0 {
848                 let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
849                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
850                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
851                     match &pattern8_0 {
852                         &InstructionData::UnaryImm {
853                             opcode: ref pattern9_0,
854                             imm: pattern9_1,
855                         } => {
856                             if let &Opcode::Iconst = pattern9_0 {
857                                 let pattern11_0 = arg2;
858                                 let closure12 = || {
859                                     let expr0_0: Type = I64;
860                                     return Some(expr0_0);
861                                 };
862                                 if let Some(pattern12_0) = closure12() {
863                                     let closure13 = || {
864                                         return Some(pattern9_1);
865                                     };
866                                     if let Some(pattern13_0) = closure13() {
867                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
868                                             ctx,
869                                             pattern11_0,
870                                             pattern12_0,
871                                             pattern13_0,
872                                         ) {
873                                             // Rule at src/isa/x64/inst.isle line 824.
874                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
875                                             let expr1_0 = constructor_amode_imm_reg_flags(
876                                                 ctx,
877                                                 pattern14_0,
878                                                 expr0_0,
879                                                 pattern0_0,
880                                             )?;
881                                             return Some(expr1_0);
882                                         }
883                                     }
884                                 }
885                             }
886                         }
887                         &InstructionData::Binary {
888                             opcode: ref pattern9_0,
889                             args: ref pattern9_1,
890                         } => {
891                             if let &Opcode::Ishl = pattern9_0 {
892                                 let (pattern11_0, pattern11_1) =
893                                     C::unpack_value_array_2(ctx, pattern9_1);
894                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
895                                 {
896                                     let pattern13_0 = arg2;
897                                     // Rule at src/isa/x64/inst.isle line 816.
898                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
899                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
900                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
901                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
902                                         ctx,
903                                         expr0_0,
904                                         expr1_0,
905                                         expr2_0,
906                                         pattern12_0,
907                                         pattern0_0,
908                                     )?;
909                                     return Some(expr3_0);
910                                 }
911                             }
912                         }
913                         _ => {}
914                     }
915                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
916                         let pattern9_0 = C::value_type(ctx, pattern8_0);
917                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
918                         if let &InstructionData::Unary {
919                             opcode: ref pattern11_0,
920                             arg: pattern11_1,
921                         } = &pattern10_0
922                         {
923                             if let &Opcode::Uextend = pattern11_0 {
924                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
925                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
926                                     if let &InstructionData::UnaryImm {
927                                         opcode: ref pattern15_0,
928                                         imm: pattern15_1,
929                                     } = &pattern14_0
930                                     {
931                                         if let &Opcode::Iconst = pattern15_0 {
932                                             let pattern17_0 = arg2;
933                                             let closure18 = || {
934                                                 return Some(pattern9_0);
935                                             };
936                                             if let Some(pattern18_0) = closure18() {
937                                                 let closure19 = || {
938                                                     return Some(pattern15_1);
939                                                 };
940                                                 if let Some(pattern19_0) = closure19() {
941                                                     if let Some(pattern20_0) =
942                                                         C::sum_extend_fits_in_32_bits(
943                                                             ctx,
944                                                             pattern17_0,
945                                                             pattern18_0,
946                                                             pattern19_0,
947                                                         )
948                                                     {
949                                                         // Rule at src/isa/x64/inst.isle line 829.
950                                                         let expr0_0 = constructor_put_in_gpr(
951                                                             ctx, pattern6_1,
952                                                         )?;
953                                                         let expr1_0 =
954                                                             constructor_amode_imm_reg_flags(
955                                                                 ctx,
956                                                                 pattern20_0,
957                                                                 expr0_0,
958                                                                 pattern0_0,
959                                                             )?;
960                                                         return Some(expr1_0);
961                                                     }
962                                                 }
963                                             }
964                                         }
965                                     }
966                                 }
967                             }
968                         }
969                     }
970                 }
971                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_1) {
972                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
973                     match &pattern8_0 {
974                         &InstructionData::UnaryImm {
975                             opcode: ref pattern9_0,
976                             imm: pattern9_1,
977                         } => {
978                             if let &Opcode::Iconst = pattern9_0 {
979                                 let pattern11_0 = arg2;
980                                 let closure12 = || {
981                                     let expr0_0: Type = I64;
982                                     return Some(expr0_0);
983                                 };
984                                 if let Some(pattern12_0) = closure12() {
985                                     let closure13 = || {
986                                         return Some(pattern9_1);
987                                     };
988                                     if let Some(pattern13_0) = closure13() {
989                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
990                                             ctx,
991                                             pattern11_0,
992                                             pattern12_0,
993                                             pattern13_0,
994                                         ) {
995                                             // Rule at src/isa/x64/inst.isle line 826.
996                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
997                                             let expr1_0 = constructor_amode_imm_reg_flags(
998                                                 ctx,
999                                                 pattern14_0,
1000                                                 expr0_0,
1001                                                 pattern0_0,
1002                                             )?;
1003                                             return Some(expr1_0);
1004                                         }
1005                                     }
1006                                 }
1007                             }
1008                         }
1009                         &InstructionData::Binary {
1010                             opcode: ref pattern9_0,
1011                             args: ref pattern9_1,
1012                         } => {
1013                             if let &Opcode::Ishl = pattern9_0 {
1014                                 let (pattern11_0, pattern11_1) =
1015                                     C::unpack_value_array_2(ctx, pattern9_1);
1016                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
1017                                 {
1018                                     let pattern13_0 = arg2;
1019                                     // Rule at src/isa/x64/inst.isle line 818.
1020                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
1021                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1022                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
1023                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
1024                                         ctx,
1025                                         expr0_0,
1026                                         expr1_0,
1027                                         expr2_0,
1028                                         pattern12_0,
1029                                         pattern0_0,
1030                                     )?;
1031                                     return Some(expr3_0);
1032                                 }
1033                             }
1034                         }
1035                         _ => {}
1036                     }
1037                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
1038                         let pattern9_0 = C::value_type(ctx, pattern8_0);
1039                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
1040                         if let &InstructionData::Unary {
1041                             opcode: ref pattern11_0,
1042                             arg: pattern11_1,
1043                         } = &pattern10_0
1044                         {
1045                             if let &Opcode::Uextend = pattern11_0 {
1046                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
1047                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
1048                                     if let &InstructionData::UnaryImm {
1049                                         opcode: ref pattern15_0,
1050                                         imm: pattern15_1,
1051                                     } = &pattern14_0
1052                                     {
1053                                         if let &Opcode::Iconst = pattern15_0 {
1054                                             let pattern17_0 = arg2;
1055                                             let closure18 = || {
1056                                                 return Some(pattern9_0);
1057                                             };
1058                                             if let Some(pattern18_0) = closure18() {
1059                                                 let closure19 = || {
1060                                                     return Some(pattern15_1);
1061                                                 };
1062                                                 if let Some(pattern19_0) = closure19() {
1063                                                     if let Some(pattern20_0) =
1064                                                         C::sum_extend_fits_in_32_bits(
1065                                                             ctx,
1066                                                             pattern17_0,
1067                                                             pattern18_0,
1068                                                             pattern19_0,
1069                                                         )
1070                                                     {
1071                                                         // Rule at src/isa/x64/inst.isle line 831.
1072                                                         let expr0_0 = constructor_put_in_gpr(
1073                                                             ctx, pattern6_0,
1074                                                         )?;
1075                                                         let expr1_0 =
1076                                                             constructor_amode_imm_reg_flags(
1077                                                                 ctx,
1078                                                                 pattern20_0,
1079                                                                 expr0_0,
1080                                                                 pattern0_0,
1081                                                             )?;
1082                                                         return Some(expr1_0);
1083                                                     }
1084                                                 }
1085                                             }
1086                                         }
1087                                     }
1088                                 }
1089                             }
1090                         }
1091                     }
1092                 }
1093                 let pattern7_0 = arg2;
1094                 // Rule at src/isa/x64/inst.isle line 834.
1095                 let expr0_0 = C::offset32_to_u32(ctx, pattern7_0);
1096                 let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1097                 let expr2_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
1098                 let expr3_0: u8 = 0;
1099                 let expr4_0 = constructor_amode_imm_reg_reg_shift_flags(
1100                     ctx, expr0_0, expr1_0, expr2_0, expr3_0, pattern0_0,
1101                 )?;
1102                 return Some(expr4_0);
1103             }
1104         }
1105     }
1106     let pattern2_0 = arg2;
1107     // Rule at src/isa/x64/inst.isle line 837.
1108     let expr0_0 = C::offset32_to_u32(ctx, pattern2_0);
1109     let expr1_0 = constructor_put_in_gpr(ctx, pattern1_0)?;
1110     let expr2_0 = constructor_amode_imm_reg_flags(ctx, expr0_0, expr1_0, pattern0_0)?;
1111     return Some(expr2_0);
1112 }
1113 
1114 // Generated as internal constructor for term reg_to_gpr_mem_imm.
1115 pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> Option<GprMemImm> {
1116     let pattern0_0 = arg0;
1117     // Rule at src/isa/x64/inst.isle line 1031.
1118     let expr0_0 = C::gpr_new(ctx, pattern0_0);
1119     let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
1120     return Some(expr1_0);
1121 }
1122 
1123 // Generated as internal constructor for term put_in_gpr.
1124 pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1125     let pattern0_0 = arg0;
1126     // Rule at src/isa/x64/inst.isle line 1038.
1127     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1128     let expr1_0 = C::gpr_new(ctx, expr0_0);
1129     return Some(expr1_0);
1130 }
1131 
1132 // Generated as internal constructor for term put_in_gpr_mem.
1133 pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMem> {
1134     let pattern0_0 = arg0;
1135     // Rule at src/isa/x64/inst.isle line 1045.
1136     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1137     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
1138     return Some(expr1_0);
1139 }
1140 
1141 // Generated as internal constructor for term put_in_gpr_mem_imm.
1142 pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMemImm> {
1143     let pattern0_0 = arg0;
1144     // Rule at src/isa/x64/inst.isle line 1052.
1145     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1146     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1147     return Some(expr1_0);
1148 }
1149 
1150 // Generated as internal constructor for term put_in_xmm.
1151 pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Option<Xmm> {
1152     let pattern0_0 = arg0;
1153     // Rule at src/isa/x64/inst.isle line 1059.
1154     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1155     let expr1_0 = C::xmm_new(ctx, expr0_0);
1156     return Some(expr1_0);
1157 }
1158 
1159 // Generated as internal constructor for term put_in_xmm_mem.
1160 pub fn constructor_put_in_xmm_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMem> {
1161     let pattern0_0 = arg0;
1162     // Rule at src/isa/x64/inst.isle line 1066.
1163     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1164     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
1165     return Some(expr1_0);
1166 }
1167 
1168 // Generated as internal constructor for term put_in_xmm_mem_imm.
1169 pub fn constructor_put_in_xmm_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMemImm> {
1170     let pattern0_0 = arg0;
1171     // Rule at src/isa/x64/inst.isle line 1073.
1172     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1173     let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0);
1174     return Some(expr1_0);
1175 }
1176 
1177 // Generated as internal constructor for term output_gpr.
1178 pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<InstOutput> {
1179     let pattern0_0 = arg0;
1180     // Rule at src/isa/x64/inst.isle line 1078.
1181     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1182     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1183     return Some(expr1_0);
1184 }
1185 
1186 // Generated as internal constructor for term value_gprs.
1187 pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option<ValueRegs> {
1188     let pattern0_0 = arg0;
1189     let pattern1_0 = arg1;
1190     // Rule at src/isa/x64/inst.isle line 1083.
1191     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1192     let expr1_0 = C::gpr_to_reg(ctx, pattern1_0);
1193     let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0);
1194     return Some(expr2_0);
1195 }
1196 
1197 // Generated as internal constructor for term output_xmm.
1198 pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<InstOutput> {
1199     let pattern0_0 = arg0;
1200     // Rule at src/isa/x64/inst.isle line 1088.
1201     let expr0_0 = C::xmm_to_reg(ctx, pattern0_0);
1202     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1203     return Some(expr1_0);
1204 }
1205 
1206 // Generated as internal constructor for term value_regs_get_gpr.
1207 pub fn constructor_value_regs_get_gpr<C: Context>(
1208     ctx: &mut C,
1209     arg0: ValueRegs,
1210     arg1: usize,
1211 ) -> Option<Gpr> {
1212     let pattern0_0 = arg0;
1213     let pattern1_0 = arg1;
1214     // Rule at src/isa/x64/inst.isle line 1095.
1215     let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0);
1216     let expr1_0 = C::gpr_new(ctx, expr0_0);
1217     return Some(expr1_0);
1218 }
1219 
1220 // Generated as internal constructor for term lo_gpr.
1221 pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1222     let pattern0_0 = arg0;
1223     // Rule at src/isa/x64/inst.isle line 1108.
1224     let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?;
1225     let expr1_0 = C::gpr_new(ctx, expr0_0);
1226     return Some(expr1_0);
1227 }
1228 
1229 // Generated as internal constructor for term sink_load_to_gpr_mem_imm.
1230 pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
1231     ctx: &mut C,
1232     arg0: &SinkableLoad,
1233 ) -> Option<GprMemImm> {
1234     let pattern0_0 = arg0;
1235     // Rule at src/isa/x64/inst.isle line 1191.
1236     let expr0_0 = C::sink_load(ctx, pattern0_0);
1237     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1238     return Some(expr1_0);
1239 }
1240 
1241 // Generated as internal constructor for term extend_to_gpr.
1242 pub fn constructor_extend_to_gpr<C: Context>(
1243     ctx: &mut C,
1244     arg0: Value,
1245     arg1: Type,
1246     arg2: &ExtendKind,
1247 ) -> Option<Gpr> {
1248     let pattern0_0 = arg0;
1249     let pattern1_0 = C::value_type(ctx, pattern0_0);
1250     let pattern2_0 = arg1;
1251     if pattern2_0 == pattern1_0 {
1252         let pattern4_0 = arg2;
1253         // Rule at src/isa/x64/inst.isle line 1213.
1254         let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
1255         return Some(expr0_0);
1256     }
1257     let pattern3_0 = arg2;
1258     // Rule at src/isa/x64/inst.isle line 1216.
1259     let expr0_0 = C::ty_bits_u16(ctx, pattern1_0);
1260     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0);
1261     let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?;
1262     let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0);
1263     let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?;
1264     let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?;
1265     return Some(expr5_0);
1266 }
1267 
1268 // Generated as internal constructor for term extend.
1269 pub fn constructor_extend<C: Context>(
1270     ctx: &mut C,
1271     arg0: &ExtendKind,
1272     arg1: Type,
1273     arg2: &ExtMode,
1274     arg3: &GprMem,
1275 ) -> Option<Gpr> {
1276     let pattern0_0 = arg0;
1277     match pattern0_0 {
1278         &ExtendKind::Sign => {
1279             let pattern2_0 = arg1;
1280             let pattern3_0 = arg2;
1281             let pattern4_0 = arg3;
1282             // Rule at src/isa/x64/inst.isle line 1236.
1283             let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?;
1284             return Some(expr0_0);
1285         }
1286         &ExtendKind::Zero => {
1287             let pattern2_0 = arg1;
1288             let pattern3_0 = arg2;
1289             let pattern4_0 = arg3;
1290             // Rule at src/isa/x64/inst.isle line 1232.
1291             let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?;
1292             return Some(expr0_0);
1293         }
1294         _ => {}
1295     }
1296     return None;
1297 }
1298 
1299 // Generated as internal constructor for term sse_xor_op.
1300 pub fn constructor_sse_xor_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1301     let pattern0_0 = arg0;
1302     if pattern0_0 == F32X4 {
1303         // Rule at src/isa/x64/inst.isle line 1243.
1304         let expr0_0 = SseOpcode::Xorps;
1305         return Some(expr0_0);
1306     }
1307     if pattern0_0 == F64X2 {
1308         // Rule at src/isa/x64/inst.isle line 1244.
1309         let expr0_0 = SseOpcode::Xorpd;
1310         return Some(expr0_0);
1311     }
1312     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1313         // Rule at src/isa/x64/inst.isle line 1245.
1314         let expr0_0 = SseOpcode::Pxor;
1315         return Some(expr0_0);
1316     }
1317     return None;
1318 }
1319 
1320 // Generated as internal constructor for term sse_xor.
1321 pub fn constructor_sse_xor<C: Context>(
1322     ctx: &mut C,
1323     arg0: Type,
1324     arg1: Xmm,
1325     arg2: &XmmMem,
1326 ) -> Option<Xmm> {
1327     let pattern0_0 = arg0;
1328     let pattern1_0 = arg1;
1329     let pattern2_0 = arg2;
1330     // Rule at src/isa/x64/inst.isle line 1249.
1331     let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
1332     let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1333     return Some(expr1_0);
1334 }
1335 
1336 // Generated as internal constructor for term sse_cmp_op.
1337 pub fn constructor_sse_cmp_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1338     let pattern0_0 = arg0;
1339     if pattern0_0 == F32X4 {
1340         // Rule at src/isa/x64/inst.isle line 1258.
1341         let expr0_0 = SseOpcode::Cmpps;
1342         return Some(expr0_0);
1343     }
1344     if pattern0_0 == F64X2 {
1345         // Rule at src/isa/x64/inst.isle line 1259.
1346         let expr0_0 = SseOpcode::Cmppd;
1347         return Some(expr0_0);
1348     }
1349     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1350         if pattern1_0 == 8 {
1351             if pattern1_1 == 16 {
1352                 // Rule at src/isa/x64/inst.isle line 1254.
1353                 let expr0_0 = SseOpcode::Pcmpeqb;
1354                 return Some(expr0_0);
1355             }
1356         }
1357         if pattern1_0 == 16 {
1358             if pattern1_1 == 8 {
1359                 // Rule at src/isa/x64/inst.isle line 1255.
1360                 let expr0_0 = SseOpcode::Pcmpeqw;
1361                 return Some(expr0_0);
1362             }
1363         }
1364         if pattern1_0 == 32 {
1365             if pattern1_1 == 4 {
1366                 // Rule at src/isa/x64/inst.isle line 1256.
1367                 let expr0_0 = SseOpcode::Pcmpeqd;
1368                 return Some(expr0_0);
1369             }
1370         }
1371         if pattern1_0 == 64 {
1372             if pattern1_1 == 2 {
1373                 // Rule at src/isa/x64/inst.isle line 1257.
1374                 let expr0_0 = SseOpcode::Pcmpeqq;
1375                 return Some(expr0_0);
1376             }
1377         }
1378     }
1379     return None;
1380 }
1381 
1382 // Generated as internal constructor for term vector_all_ones.
1383 pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C, arg0: Type) -> Option<Xmm> {
1384     let pattern0_0 = arg0;
1385     // Rule at src/isa/x64/inst.isle line 1273.
1386     let expr0_0 = C::temp_writable_xmm(ctx);
1387     let expr1_0: Type = I32X4;
1388     let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?;
1389     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1390     let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?;
1391     let expr5_0 = MInst::XmmRmR {
1392         op: expr2_0,
1393         src1: expr3_0,
1394         src2: expr4_0,
1395         dst: expr0_0,
1396     };
1397     let expr6_0 = C::emit(ctx, &expr5_0);
1398     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1399     return Some(expr7_0);
1400 }
1401 
1402 // Generated as internal constructor for term make_i64x2_from_lanes.
1403 pub fn constructor_make_i64x2_from_lanes<C: Context>(
1404     ctx: &mut C,
1405     arg0: &GprMem,
1406     arg1: &GprMem,
1407 ) -> Option<Xmm> {
1408     let pattern0_0 = arg0;
1409     let pattern1_0 = arg1;
1410     // Rule at src/isa/x64/inst.isle line 1283.
1411     let expr0_0 = C::temp_writable_xmm(ctx);
1412     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1413     let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 };
1414     let expr3_0 = C::emit(ctx, &expr2_0);
1415     let expr4_0 = SseOpcode::Pinsrd;
1416     let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0);
1417     let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0);
1418     let expr7_0: u8 = 0;
1419     let expr8_0 = OperandSize::Size64;
1420     let expr9_0 = MInst::XmmRmRImm {
1421         op: expr4_0,
1422         src1: expr5_0,
1423         src2: expr6_0,
1424         dst: expr1_0,
1425         imm: expr7_0,
1426         size: expr8_0,
1427     };
1428     let expr10_0 = C::emit(ctx, &expr9_0);
1429     let expr11_0 = SseOpcode::Pinsrd;
1430     let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0);
1431     let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
1432     let expr14_0: u8 = 1;
1433     let expr15_0 = OperandSize::Size64;
1434     let expr16_0 = MInst::XmmRmRImm {
1435         op: expr11_0,
1436         src1: expr12_0,
1437         src2: expr13_0,
1438         dst: expr1_0,
1439         imm: expr14_0,
1440         size: expr15_0,
1441     };
1442     let expr17_0 = C::emit(ctx, &expr16_0);
1443     let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1444     return Some(expr18_0);
1445 }
1446 
1447 // Generated as internal constructor for term mov_rmi_to_xmm.
1448 pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> Option<XmmMemImm> {
1449     let pattern0_0 = arg0;
1450     match pattern0_0 {
1451         &RegMemImm::Imm { simm32: pattern1_0 } => {
1452             // Rule at src/isa/x64/inst.isle line 1304.
1453             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1454             return Some(expr0_0);
1455         }
1456         &RegMemImm::Reg { reg: pattern1_0 } => {
1457             // Rule at src/isa/x64/inst.isle line 1305.
1458             let expr0_0 = SseOpcode::Movd;
1459             let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0);
1460             let expr2_0 = OperandSize::Size32;
1461             let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?;
1462             let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0);
1463             return Some(expr4_0);
1464         }
1465         &RegMemImm::Mem {
1466             addr: ref pattern1_0,
1467         } => {
1468             // Rule at src/isa/x64/inst.isle line 1303.
1469             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1470             return Some(expr0_0);
1471         }
1472         _ => {}
1473     }
1474     return None;
1475 }
1476 
1477 // Generated as internal constructor for term x64_load.
1478 pub fn constructor_x64_load<C: Context>(
1479     ctx: &mut C,
1480     arg0: Type,
1481     arg1: &SyntheticAmode,
1482     arg2: &ExtKind,
1483 ) -> Option<Reg> {
1484     let pattern0_0 = arg0;
1485     if pattern0_0 == I64 {
1486         let pattern2_0 = arg1;
1487         let pattern3_0 = arg2;
1488         // Rule at src/isa/x64/inst.isle line 1319.
1489         let expr0_0 = C::temp_writable_gpr(ctx);
1490         let expr1_0 = MInst::Mov64MR {
1491             src: pattern2_0.clone(),
1492             dst: expr0_0,
1493         };
1494         let expr2_0 = C::emit(ctx, &expr1_0);
1495         let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1496         return Some(expr3_0);
1497     }
1498     if pattern0_0 == F32 {
1499         let pattern2_0 = arg1;
1500         let pattern3_0 = arg2;
1501         // Rule at src/isa/x64/inst.isle line 1324.
1502         let expr0_0 = SseOpcode::Movss;
1503         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1504         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1505         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1506         return Some(expr3_0);
1507     }
1508     if pattern0_0 == F64 {
1509         let pattern2_0 = arg1;
1510         let pattern3_0 = arg2;
1511         // Rule at src/isa/x64/inst.isle line 1328.
1512         let expr0_0 = SseOpcode::Movsd;
1513         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1514         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1515         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1516         return Some(expr3_0);
1517     }
1518     if pattern0_0 == F32X4 {
1519         let pattern2_0 = arg1;
1520         let pattern3_0 = arg2;
1521         // Rule at src/isa/x64/inst.isle line 1332.
1522         let expr0_0 = SseOpcode::Movups;
1523         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1524         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1525         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1526         return Some(expr3_0);
1527     }
1528     if pattern0_0 == F64X2 {
1529         let pattern2_0 = arg1;
1530         let pattern3_0 = arg2;
1531         // Rule at src/isa/x64/inst.isle line 1336.
1532         let expr0_0 = SseOpcode::Movupd;
1533         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1534         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1535         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1536         return Some(expr3_0);
1537     }
1538     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1539         let pattern2_0 = arg1;
1540         let pattern3_0 = arg2;
1541         // Rule at src/isa/x64/inst.isle line 1340.
1542         let expr0_0 = SseOpcode::Movdqu;
1543         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1544         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1545         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1546         return Some(expr3_0);
1547     }
1548     if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) {
1549         let pattern2_0 = arg1;
1550         let pattern3_0 = arg2;
1551         if let &ExtKind::SignExtend = pattern3_0 {
1552             // Rule at src/isa/x64/inst.isle line 1315.
1553             let expr0_0 = C::ty_bytes(ctx, pattern1_0);
1554             let expr1_0: u16 = 8;
1555             let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
1556             let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?;
1557             let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?;
1558             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
1559             return Some(expr5_0);
1560         }
1561     }
1562     return None;
1563 }
1564 
1565 // Generated as internal constructor for term x64_mov.
1566 pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<Reg> {
1567     let pattern0_0 = arg0;
1568     // Rule at src/isa/x64/inst.isle line 1345.
1569     let expr0_0 = C::temp_writable_gpr(ctx);
1570     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
1571     let expr2_0 = MInst::Mov64MR {
1572         src: expr1_0,
1573         dst: expr0_0,
1574     };
1575     let expr3_0 = C::emit(ctx, &expr2_0);
1576     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1577     return Some(expr4_0);
1578 }
1579 
1580 // Generated as internal constructor for term x64_movzx.
1581 pub fn constructor_x64_movzx<C: Context>(
1582     ctx: &mut C,
1583     arg0: &ExtMode,
1584     arg1: &GprMem,
1585 ) -> Option<Gpr> {
1586     let pattern0_0 = arg0;
1587     let pattern1_0 = arg1;
1588     // Rule at src/isa/x64/inst.isle line 1351.
1589     let expr0_0 = C::temp_writable_gpr(ctx);
1590     let expr1_0 = MInst::MovzxRmR {
1591         ext_mode: pattern0_0.clone(),
1592         src: pattern1_0.clone(),
1593         dst: expr0_0,
1594     };
1595     let expr2_0 = C::emit(ctx, &expr1_0);
1596     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1597     return Some(expr3_0);
1598 }
1599 
1600 // Generated as internal constructor for term x64_movsx.
1601 pub fn constructor_x64_movsx<C: Context>(
1602     ctx: &mut C,
1603     arg0: &ExtMode,
1604     arg1: &GprMem,
1605 ) -> Option<Gpr> {
1606     let pattern0_0 = arg0;
1607     let pattern1_0 = arg1;
1608     // Rule at src/isa/x64/inst.isle line 1357.
1609     let expr0_0 = C::temp_writable_gpr(ctx);
1610     let expr1_0 = MInst::MovsxRmR {
1611         ext_mode: pattern0_0.clone(),
1612         src: pattern1_0.clone(),
1613         dst: expr0_0,
1614     };
1615     let expr2_0 = C::emit(ctx, &expr1_0);
1616     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1617     return Some(expr3_0);
1618 }
1619 
1620 // Generated as internal constructor for term x64_movss_load.
1621 pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1622     let pattern0_0 = arg0;
1623     // Rule at src/isa/x64/inst.isle line 1363.
1624     let expr0_0 = SseOpcode::Movss;
1625     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1626     return Some(expr1_0);
1627 }
1628 
1629 // Generated as internal constructor for term x64_movsd_load.
1630 pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1631     let pattern0_0 = arg0;
1632     // Rule at src/isa/x64/inst.isle line 1367.
1633     let expr0_0 = SseOpcode::Movsd;
1634     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1635     return Some(expr1_0);
1636 }
1637 
1638 // Generated as internal constructor for term x64_movups.
1639 pub fn constructor_x64_movups<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1640     let pattern0_0 = arg0;
1641     // Rule at src/isa/x64/inst.isle line 1371.
1642     let expr0_0 = SseOpcode::Movups;
1643     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1644     return Some(expr1_0);
1645 }
1646 
1647 // Generated as internal constructor for term x64_movupd.
1648 pub fn constructor_x64_movupd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1649     let pattern0_0 = arg0;
1650     // Rule at src/isa/x64/inst.isle line 1375.
1651     let expr0_0 = SseOpcode::Movupd;
1652     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1653     return Some(expr1_0);
1654 }
1655 
1656 // Generated as internal constructor for term x64_movdqu.
1657 pub fn constructor_x64_movdqu<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1658     let pattern0_0 = arg0;
1659     // Rule at src/isa/x64/inst.isle line 1379.
1660     let expr0_0 = SseOpcode::Movdqu;
1661     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1662     return Some(expr1_0);
1663 }
1664 
1665 // Generated as internal constructor for term x64_pmovsxbw.
1666 pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1667     let pattern0_0 = arg0;
1668     // Rule at src/isa/x64/inst.isle line 1383.
1669     let expr0_0 = SseOpcode::Pmovsxbw;
1670     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1671     return Some(expr1_0);
1672 }
1673 
1674 // Generated as internal constructor for term x64_pmovzxbw.
1675 pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1676     let pattern0_0 = arg0;
1677     // Rule at src/isa/x64/inst.isle line 1387.
1678     let expr0_0 = SseOpcode::Pmovzxbw;
1679     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1680     return Some(expr1_0);
1681 }
1682 
1683 // Generated as internal constructor for term x64_pmovsxwd.
1684 pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1685     let pattern0_0 = arg0;
1686     // Rule at src/isa/x64/inst.isle line 1391.
1687     let expr0_0 = SseOpcode::Pmovsxwd;
1688     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1689     return Some(expr1_0);
1690 }
1691 
1692 // Generated as internal constructor for term x64_pmovzxwd.
1693 pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1694     let pattern0_0 = arg0;
1695     // Rule at src/isa/x64/inst.isle line 1395.
1696     let expr0_0 = SseOpcode::Pmovzxwd;
1697     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1698     return Some(expr1_0);
1699 }
1700 
1701 // Generated as internal constructor for term x64_pmovsxdq.
1702 pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1703     let pattern0_0 = arg0;
1704     // Rule at src/isa/x64/inst.isle line 1399.
1705     let expr0_0 = SseOpcode::Pmovsxdq;
1706     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1707     return Some(expr1_0);
1708 }
1709 
1710 // Generated as internal constructor for term x64_pmovzxdq.
1711 pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1712     let pattern0_0 = arg0;
1713     // Rule at src/isa/x64/inst.isle line 1403.
1714     let expr0_0 = SseOpcode::Pmovzxdq;
1715     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1716     return Some(expr1_0);
1717 }
1718 
1719 // Generated as internal constructor for term x64_xmm_load_const.
1720 pub fn constructor_x64_xmm_load_const<C: Context>(
1721     ctx: &mut C,
1722     arg0: Type,
1723     arg1: VCodeConstant,
1724 ) -> Option<Xmm> {
1725     let pattern0_0 = arg0;
1726     let pattern1_0 = arg1;
1727     // Rule at src/isa/x64/inst.isle line 1408.
1728     let expr0_0 = C::temp_writable_xmm(ctx);
1729     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1730     let expr2_0 = MInst::XmmLoadConst {
1731         src: pattern1_0,
1732         dst: expr1_0,
1733         ty: pattern0_0,
1734     };
1735     let expr3_0 = C::emit(ctx, &expr2_0);
1736     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1737     return Some(expr4_0);
1738 }
1739 
1740 // Generated as internal constructor for term alu_rmi_r.
1741 pub fn constructor_alu_rmi_r<C: Context>(
1742     ctx: &mut C,
1743     arg0: Type,
1744     arg1: &AluRmiROpcode,
1745     arg2: Gpr,
1746     arg3: &GprMemImm,
1747 ) -> Option<Gpr> {
1748     let pattern0_0 = arg0;
1749     let pattern1_0 = arg1;
1750     let pattern2_0 = arg2;
1751     let pattern3_0 = arg3;
1752     // Rule at src/isa/x64/inst.isle line 1421.
1753     let expr0_0 = C::temp_writable_gpr(ctx);
1754     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1755     let expr2_0 = MInst::AluRmiR {
1756         size: expr1_0,
1757         op: pattern1_0.clone(),
1758         src1: pattern2_0,
1759         src2: pattern3_0.clone(),
1760         dst: expr0_0,
1761     };
1762     let expr3_0 = C::emit(ctx, &expr2_0);
1763     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1764     return Some(expr4_0);
1765 }
1766 
1767 // Generated as internal constructor for term x64_add.
1768 pub fn constructor_x64_add<C: Context>(
1769     ctx: &mut C,
1770     arg0: Type,
1771     arg1: Gpr,
1772     arg2: &GprMemImm,
1773 ) -> Option<Gpr> {
1774     let pattern0_0 = arg0;
1775     let pattern1_0 = arg1;
1776     let pattern2_0 = arg2;
1777     // Rule at src/isa/x64/inst.isle line 1429.
1778     let expr0_0 = AluRmiROpcode::Add;
1779     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1780     return Some(expr1_0);
1781 }
1782 
1783 // Generated as internal constructor for term x64_add_with_flags_paired.
1784 pub fn constructor_x64_add_with_flags_paired<C: Context>(
1785     ctx: &mut C,
1786     arg0: Type,
1787     arg1: Gpr,
1788     arg2: &GprMemImm,
1789 ) -> Option<ProducesFlags> {
1790     let pattern0_0 = arg0;
1791     let pattern1_0 = arg1;
1792     let pattern2_0 = arg2;
1793     // Rule at src/isa/x64/inst.isle line 1437.
1794     let expr0_0 = C::temp_writable_gpr(ctx);
1795     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1796     let expr2_0 = AluRmiROpcode::Add;
1797     let expr3_0 = MInst::AluRmiR {
1798         size: expr1_0,
1799         op: expr2_0,
1800         src1: pattern1_0,
1801         src2: pattern2_0.clone(),
1802         dst: expr0_0,
1803     };
1804     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1805     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1806         inst: expr3_0,
1807         result: expr4_0,
1808     };
1809     return Some(expr5_0);
1810 }
1811 
1812 // Generated as internal constructor for term x64_adc_paired.
1813 pub fn constructor_x64_adc_paired<C: Context>(
1814     ctx: &mut C,
1815     arg0: Type,
1816     arg1: Gpr,
1817     arg2: &GprMemImm,
1818 ) -> Option<ConsumesFlags> {
1819     let pattern0_0 = arg0;
1820     let pattern1_0 = arg1;
1821     let pattern2_0 = arg2;
1822     // Rule at src/isa/x64/inst.isle line 1449.
1823     let expr0_0 = C::temp_writable_gpr(ctx);
1824     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1825     let expr2_0 = AluRmiROpcode::Adc;
1826     let expr3_0 = MInst::AluRmiR {
1827         size: expr1_0,
1828         op: expr2_0,
1829         src1: pattern1_0,
1830         src2: pattern2_0.clone(),
1831         dst: expr0_0,
1832     };
1833     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1834     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1835         inst: expr3_0,
1836         result: expr4_0,
1837     };
1838     return Some(expr5_0);
1839 }
1840 
1841 // Generated as internal constructor for term x64_sub.
1842 pub fn constructor_x64_sub<C: Context>(
1843     ctx: &mut C,
1844     arg0: Type,
1845     arg1: Gpr,
1846     arg2: &GprMemImm,
1847 ) -> Option<Gpr> {
1848     let pattern0_0 = arg0;
1849     let pattern1_0 = arg1;
1850     let pattern2_0 = arg2;
1851     // Rule at src/isa/x64/inst.isle line 1461.
1852     let expr0_0 = AluRmiROpcode::Sub;
1853     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1854     return Some(expr1_0);
1855 }
1856 
1857 // Generated as internal constructor for term x64_sub_with_flags_paired.
1858 pub fn constructor_x64_sub_with_flags_paired<C: Context>(
1859     ctx: &mut C,
1860     arg0: Type,
1861     arg1: Gpr,
1862     arg2: &GprMemImm,
1863 ) -> Option<ProducesFlags> {
1864     let pattern0_0 = arg0;
1865     let pattern1_0 = arg1;
1866     let pattern2_0 = arg2;
1867     // Rule at src/isa/x64/inst.isle line 1469.
1868     let expr0_0 = C::temp_writable_gpr(ctx);
1869     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1870     let expr2_0 = AluRmiROpcode::Sub;
1871     let expr3_0 = MInst::AluRmiR {
1872         size: expr1_0,
1873         op: expr2_0,
1874         src1: pattern1_0,
1875         src2: pattern2_0.clone(),
1876         dst: expr0_0,
1877     };
1878     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1879     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1880         inst: expr3_0,
1881         result: expr4_0,
1882     };
1883     return Some(expr5_0);
1884 }
1885 
1886 // Generated as internal constructor for term x64_sbb_paired.
1887 pub fn constructor_x64_sbb_paired<C: Context>(
1888     ctx: &mut C,
1889     arg0: Type,
1890     arg1: Gpr,
1891     arg2: &GprMemImm,
1892 ) -> Option<ConsumesFlags> {
1893     let pattern0_0 = arg0;
1894     let pattern1_0 = arg1;
1895     let pattern2_0 = arg2;
1896     // Rule at src/isa/x64/inst.isle line 1481.
1897     let expr0_0 = C::temp_writable_gpr(ctx);
1898     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1899     let expr2_0 = AluRmiROpcode::Sbb;
1900     let expr3_0 = MInst::AluRmiR {
1901         size: expr1_0,
1902         op: expr2_0,
1903         src1: pattern1_0,
1904         src2: pattern2_0.clone(),
1905         dst: expr0_0,
1906     };
1907     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1908     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1909         inst: expr3_0,
1910         result: expr4_0,
1911     };
1912     return Some(expr5_0);
1913 }
1914 
1915 // Generated as internal constructor for term x64_mul.
1916 pub fn constructor_x64_mul<C: Context>(
1917     ctx: &mut C,
1918     arg0: Type,
1919     arg1: Gpr,
1920     arg2: &GprMemImm,
1921 ) -> Option<Gpr> {
1922     let pattern0_0 = arg0;
1923     let pattern1_0 = arg1;
1924     let pattern2_0 = arg2;
1925     // Rule at src/isa/x64/inst.isle line 1493.
1926     let expr0_0 = AluRmiROpcode::Mul;
1927     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1928     return Some(expr1_0);
1929 }
1930 
1931 // Generated as internal constructor for term x64_and.
1932 pub fn constructor_x64_and<C: Context>(
1933     ctx: &mut C,
1934     arg0: Type,
1935     arg1: Gpr,
1936     arg2: &GprMemImm,
1937 ) -> Option<Gpr> {
1938     let pattern0_0 = arg0;
1939     let pattern1_0 = arg1;
1940     let pattern2_0 = arg2;
1941     // Rule at src/isa/x64/inst.isle line 1501.
1942     let expr0_0 = AluRmiROpcode::And;
1943     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1944     return Some(expr1_0);
1945 }
1946 
1947 // Generated as internal constructor for term x64_and_with_flags_paired.
1948 pub fn constructor_x64_and_with_flags_paired<C: Context>(
1949     ctx: &mut C,
1950     arg0: Type,
1951     arg1: Gpr,
1952     arg2: &GprMemImm,
1953 ) -> Option<ProducesFlags> {
1954     let pattern0_0 = arg0;
1955     let pattern1_0 = arg1;
1956     let pattern2_0 = arg2;
1957     // Rule at src/isa/x64/inst.isle line 1508.
1958     let expr0_0 = C::temp_writable_gpr(ctx);
1959     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1960     let expr2_0 = AluRmiROpcode::And;
1961     let expr3_0 = MInst::AluRmiR {
1962         size: expr1_0,
1963         op: expr2_0,
1964         src1: pattern1_0,
1965         src2: pattern2_0.clone(),
1966         dst: expr0_0,
1967     };
1968     let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 };
1969     return Some(expr4_0);
1970 }
1971 
1972 // Generated as internal constructor for term x64_or.
1973 pub fn constructor_x64_or<C: Context>(
1974     ctx: &mut C,
1975     arg0: Type,
1976     arg1: Gpr,
1977     arg2: &GprMemImm,
1978 ) -> Option<Gpr> {
1979     let pattern0_0 = arg0;
1980     let pattern1_0 = arg1;
1981     let pattern2_0 = arg2;
1982     // Rule at src/isa/x64/inst.isle line 1519.
1983     let expr0_0 = AluRmiROpcode::Or;
1984     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1985     return Some(expr1_0);
1986 }
1987 
1988 // Generated as internal constructor for term x64_xor.
1989 pub fn constructor_x64_xor<C: Context>(
1990     ctx: &mut C,
1991     arg0: Type,
1992     arg1: Gpr,
1993     arg2: &GprMemImm,
1994 ) -> Option<Gpr> {
1995     let pattern0_0 = arg0;
1996     let pattern1_0 = arg1;
1997     let pattern2_0 = arg2;
1998     // Rule at src/isa/x64/inst.isle line 1527.
1999     let expr0_0 = AluRmiROpcode::Xor;
2000     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2001     return Some(expr1_0);
2002 }
2003 
2004 // Generated as internal constructor for term imm.
2005 pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Option<Reg> {
2006     let pattern0_0 = arg0;
2007     if pattern0_0 == I64 {
2008         let pattern2_0 = arg1;
2009         if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) {
2010             // Rule at src/isa/x64/inst.isle line 1567.
2011             let expr0_0 = C::temp_writable_gpr(ctx);
2012             let expr1_0 = OperandSize::Size32;
2013             let expr2_0 = MInst::Imm {
2014                 dst_size: expr1_0,
2015                 simm64: pattern3_0,
2016                 dst: expr0_0,
2017             };
2018             let expr3_0 = C::emit(ctx, &expr2_0);
2019             let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2020             return Some(expr4_0);
2021         }
2022     }
2023     if pattern0_0 == F32 {
2024         let pattern2_0 = arg1;
2025         if pattern2_0 == 0 {
2026             // Rule at src/isa/x64/inst.isle line 1596.
2027             let expr0_0 = C::temp_writable_xmm(ctx);
2028             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2029             let expr2_0 = SseOpcode::Xorps;
2030             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2031             let expr4_0 = MInst::XmmRmR {
2032                 op: expr2_0,
2033                 src1: expr1_0,
2034                 src2: expr3_0,
2035                 dst: expr0_0,
2036             };
2037             let expr5_0 = C::emit(ctx, &expr4_0);
2038             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2039             return Some(expr6_0);
2040         }
2041         // Rule at src/isa/x64/inst.isle line 1544.
2042         let expr0_0 = SseOpcode::Movd;
2043         let expr1_0: Type = I32;
2044         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2045         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2046         let expr4_0 = OperandSize::Size32;
2047         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2048         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2049         return Some(expr6_0);
2050     }
2051     if pattern0_0 == F64 {
2052         let pattern2_0 = arg1;
2053         if pattern2_0 == 0 {
2054             // Rule at src/isa/x64/inst.isle line 1608.
2055             let expr0_0 = C::temp_writable_xmm(ctx);
2056             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2057             let expr2_0 = SseOpcode::Xorpd;
2058             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2059             let expr4_0 = MInst::XmmRmR {
2060                 op: expr2_0,
2061                 src1: expr1_0,
2062                 src2: expr3_0,
2063                 dst: expr0_0,
2064             };
2065             let expr5_0 = C::emit(ctx, &expr4_0);
2066             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2067             return Some(expr6_0);
2068         }
2069         // Rule at src/isa/x64/inst.isle line 1550.
2070         let expr0_0 = SseOpcode::Movq;
2071         let expr1_0: Type = I64;
2072         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2073         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2074         let expr4_0 = OperandSize::Size64;
2075         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2076         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2077         return Some(expr6_0);
2078     }
2079     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
2080         let pattern2_0 = arg1;
2081         if pattern2_0 == 0 {
2082             // Rule at src/isa/x64/inst.isle line 1586.
2083             let expr0_0 = C::temp_writable_xmm(ctx);
2084             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2085             let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
2086             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2087             let expr4_0 = MInst::XmmRmR {
2088                 op: expr2_0,
2089                 src1: expr1_0,
2090                 src2: expr3_0,
2091                 dst: expr0_0,
2092             };
2093             let expr5_0 = C::emit(ctx, &expr4_0);
2094             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2095             return Some(expr6_0);
2096         }
2097     }
2098     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
2099         let pattern2_0 = arg1;
2100         if pattern2_0 == 0 {
2101             // Rule at src/isa/x64/inst.isle line 1573.
2102             let expr0_0 = C::temp_writable_gpr(ctx);
2103             let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2104             let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2105             let expr3_0 = AluRmiROpcode::Xor;
2106             let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
2107             let expr5_0 = MInst::AluRmiR {
2108                 size: expr2_0,
2109                 op: expr3_0,
2110                 src1: expr1_0,
2111                 src2: expr4_0,
2112                 dst: expr0_0,
2113             };
2114             let expr6_0 = C::emit(ctx, &expr5_0);
2115             let expr7_0 = C::gpr_to_reg(ctx, expr1_0);
2116             return Some(expr7_0);
2117         }
2118         // Rule at src/isa/x64/inst.isle line 1537.
2119         let expr0_0 = C::temp_writable_gpr(ctx);
2120         let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2121         let expr2_0 = MInst::Imm {
2122             dst_size: expr1_0,
2123             simm64: pattern2_0,
2124             dst: expr0_0,
2125         };
2126         let expr3_0 = C::emit(ctx, &expr2_0);
2127         let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2128         return Some(expr4_0);
2129     }
2130     return None;
2131 }
2132 
2133 // Generated as internal constructor for term imm_i64.
2134 pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Option<Reg> {
2135     let pattern0_0 = arg0;
2136     let pattern1_0 = arg1;
2137     // Rule at src/isa/x64/inst.isle line 1559.
2138     let expr0_0 = C::i64_as_u64(ctx, pattern1_0);
2139     let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
2140     return Some(expr1_0);
2141 }
2142 
2143 // Generated as internal constructor for term shift_r.
2144 pub fn constructor_shift_r<C: Context>(
2145     ctx: &mut C,
2146     arg0: Type,
2147     arg1: &ShiftKind,
2148     arg2: Gpr,
2149     arg3: &Imm8Gpr,
2150 ) -> Option<Gpr> {
2151     let pattern0_0 = arg0;
2152     let pattern1_0 = arg1;
2153     let pattern2_0 = arg2;
2154     let pattern3_0 = arg3;
2155     // Rule at src/isa/x64/inst.isle line 1621.
2156     let expr0_0 = C::temp_writable_gpr(ctx);
2157     let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2158     let expr2_0 = MInst::ShiftR {
2159         size: expr1_0,
2160         kind: pattern1_0.clone(),
2161         src: pattern2_0,
2162         num_bits: pattern3_0.clone(),
2163         dst: expr0_0,
2164     };
2165     let expr3_0 = C::emit(ctx, &expr2_0);
2166     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2167     return Some(expr4_0);
2168 }
2169 
2170 // Generated as internal constructor for term x64_rotl.
2171 pub fn constructor_x64_rotl<C: Context>(
2172     ctx: &mut C,
2173     arg0: Type,
2174     arg1: Gpr,
2175     arg2: &Imm8Gpr,
2176 ) -> Option<Gpr> {
2177     let pattern0_0 = arg0;
2178     let pattern1_0 = arg1;
2179     let pattern2_0 = arg2;
2180     // Rule at src/isa/x64/inst.isle line 1631.
2181     let expr0_0 = ShiftKind::RotateLeft;
2182     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2183     return Some(expr1_0);
2184 }
2185 
2186 // Generated as internal constructor for term x64_rotr.
2187 pub fn constructor_x64_rotr<C: Context>(
2188     ctx: &mut C,
2189     arg0: Type,
2190     arg1: Gpr,
2191     arg2: &Imm8Gpr,
2192 ) -> Option<Gpr> {
2193     let pattern0_0 = arg0;
2194     let pattern1_0 = arg1;
2195     let pattern2_0 = arg2;
2196     // Rule at src/isa/x64/inst.isle line 1636.
2197     let expr0_0 = ShiftKind::RotateRight;
2198     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2199     return Some(expr1_0);
2200 }
2201 
2202 // Generated as internal constructor for term x64_shl.
2203 pub fn constructor_x64_shl<C: Context>(
2204     ctx: &mut C,
2205     arg0: Type,
2206     arg1: Gpr,
2207     arg2: &Imm8Gpr,
2208 ) -> Option<Gpr> {
2209     let pattern0_0 = arg0;
2210     let pattern1_0 = arg1;
2211     let pattern2_0 = arg2;
2212     // Rule at src/isa/x64/inst.isle line 1641.
2213     let expr0_0 = ShiftKind::ShiftLeft;
2214     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2215     return Some(expr1_0);
2216 }
2217 
2218 // Generated as internal constructor for term x64_shr.
2219 pub fn constructor_x64_shr<C: Context>(
2220     ctx: &mut C,
2221     arg0: Type,
2222     arg1: Gpr,
2223     arg2: &Imm8Gpr,
2224 ) -> Option<Gpr> {
2225     let pattern0_0 = arg0;
2226     let pattern1_0 = arg1;
2227     let pattern2_0 = arg2;
2228     // Rule at src/isa/x64/inst.isle line 1646.
2229     let expr0_0 = ShiftKind::ShiftRightLogical;
2230     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2231     return Some(expr1_0);
2232 }
2233 
2234 // Generated as internal constructor for term x64_sar.
2235 pub fn constructor_x64_sar<C: Context>(
2236     ctx: &mut C,
2237     arg0: Type,
2238     arg1: Gpr,
2239     arg2: &Imm8Gpr,
2240 ) -> Option<Gpr> {
2241     let pattern0_0 = arg0;
2242     let pattern1_0 = arg1;
2243     let pattern2_0 = arg2;
2244     // Rule at src/isa/x64/inst.isle line 1651.
2245     let expr0_0 = ShiftKind::ShiftRightArithmetic;
2246     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2247     return Some(expr1_0);
2248 }
2249 
2250 // Generated as internal constructor for term cmp_rmi_r.
2251 pub fn constructor_cmp_rmi_r<C: Context>(
2252     ctx: &mut C,
2253     arg0: &OperandSize,
2254     arg1: &CmpOpcode,
2255     arg2: &GprMemImm,
2256     arg3: Gpr,
2257 ) -> Option<ProducesFlags> {
2258     let pattern0_0 = arg0;
2259     let pattern1_0 = arg1;
2260     let pattern2_0 = arg2;
2261     let pattern3_0 = arg3;
2262     // Rule at src/isa/x64/inst.isle line 1656.
2263     let expr0_0 = MInst::CmpRmiR {
2264         size: pattern0_0.clone(),
2265         opcode: pattern1_0.clone(),
2266         src: pattern2_0.clone(),
2267         dst: pattern3_0,
2268     };
2269     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2270     return Some(expr1_0);
2271 }
2272 
2273 // Generated as internal constructor for term x64_cmp.
2274 pub fn constructor_x64_cmp<C: Context>(
2275     ctx: &mut C,
2276     arg0: &OperandSize,
2277     arg1: &GprMemImm,
2278     arg2: Gpr,
2279 ) -> Option<ProducesFlags> {
2280     let pattern0_0 = arg0;
2281     let pattern1_0 = arg1;
2282     let pattern2_0 = arg2;
2283     // Rule at src/isa/x64/inst.isle line 1665.
2284     let expr0_0 = CmpOpcode::Cmp;
2285     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2286     return Some(expr1_0);
2287 }
2288 
2289 // Generated as internal constructor for term x64_cmp_imm.
2290 pub fn constructor_x64_cmp_imm<C: Context>(
2291     ctx: &mut C,
2292     arg0: &OperandSize,
2293     arg1: u32,
2294     arg2: Gpr,
2295 ) -> Option<ProducesFlags> {
2296     let pattern0_0 = arg0;
2297     let pattern1_0 = arg1;
2298     let pattern2_0 = arg2;
2299     // Rule at src/isa/x64/inst.isle line 1670.
2300     let expr0_0 = CmpOpcode::Cmp;
2301     let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 };
2302     let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0);
2303     let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?;
2304     return Some(expr3_0);
2305 }
2306 
2307 // Generated as internal constructor for term xmm_cmp_rm_r.
2308 pub fn constructor_xmm_cmp_rm_r<C: Context>(
2309     ctx: &mut C,
2310     arg0: &SseOpcode,
2311     arg1: &XmmMem,
2312     arg2: Xmm,
2313 ) -> Option<ProducesFlags> {
2314     let pattern0_0 = arg0;
2315     let pattern1_0 = arg1;
2316     let pattern2_0 = arg2;
2317     // Rule at src/isa/x64/inst.isle line 1675.
2318     let expr0_0 = MInst::XmmCmpRmR {
2319         op: pattern0_0.clone(),
2320         src: pattern1_0.clone(),
2321         dst: pattern2_0,
2322     };
2323     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2324     return Some(expr1_0);
2325 }
2326 
2327 // Generated as internal constructor for term x64_ucomis.
2328 pub fn constructor_x64_ucomis<C: Context>(
2329     ctx: &mut C,
2330     arg0: Value,
2331     arg1: Value,
2332 ) -> Option<ProducesFlags> {
2333     let pattern0_0 = arg0;
2334     let pattern1_0 = C::value_type(ctx, pattern0_0);
2335     if pattern1_0 == F32 {
2336         let pattern3_0 = arg1;
2337         // Rule at src/isa/x64/inst.isle line 1681.
2338         let expr0_0 = SseOpcode::Ucomiss;
2339         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2340         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2341         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2342         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2343         return Some(expr4_0);
2344     }
2345     if pattern1_0 == F64 {
2346         let pattern3_0 = arg1;
2347         // Rule at src/isa/x64/inst.isle line 1685.
2348         let expr0_0 = SseOpcode::Ucomisd;
2349         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2350         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2351         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2352         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2353         return Some(expr4_0);
2354     }
2355     return None;
2356 }
2357 
2358 // Generated as internal constructor for term x64_test.
2359 pub fn constructor_x64_test<C: Context>(
2360     ctx: &mut C,
2361     arg0: &OperandSize,
2362     arg1: &GprMemImm,
2363     arg2: Gpr,
2364 ) -> Option<ProducesFlags> {
2365     let pattern0_0 = arg0;
2366     let pattern1_0 = arg1;
2367     let pattern2_0 = arg2;
2368     // Rule at src/isa/x64/inst.isle line 1690.
2369     let expr0_0 = CmpOpcode::Test;
2370     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2371     return Some(expr1_0);
2372 }
2373 
2374 // Generated as internal constructor for term cmove.
2375 pub fn constructor_cmove<C: Context>(
2376     ctx: &mut C,
2377     arg0: Type,
2378     arg1: &CC,
2379     arg2: &GprMem,
2380     arg3: Gpr,
2381 ) -> Option<ConsumesFlags> {
2382     let pattern0_0 = arg0;
2383     let pattern1_0 = arg1;
2384     let pattern2_0 = arg2;
2385     let pattern3_0 = arg3;
2386     // Rule at src/isa/x64/inst.isle line 1697.
2387     let expr0_0 = C::temp_writable_gpr(ctx);
2388     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2389     let expr2_0 = MInst::Cmove {
2390         size: expr1_0,
2391         cc: pattern1_0.clone(),
2392         consequent: pattern2_0.clone(),
2393         alternative: pattern3_0,
2394         dst: expr0_0,
2395     };
2396     let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2397     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2398         inst: expr2_0,
2399         result: expr3_0,
2400     };
2401     return Some(expr4_0);
2402 }
2403 
2404 // Generated as internal constructor for term cmove_xmm.
2405 pub fn constructor_cmove_xmm<C: Context>(
2406     ctx: &mut C,
2407     arg0: Type,
2408     arg1: &CC,
2409     arg2: &XmmMem,
2410     arg3: Xmm,
2411 ) -> Option<ConsumesFlags> {
2412     let pattern0_0 = arg0;
2413     let pattern1_0 = arg1;
2414     let pattern2_0 = arg2;
2415     let pattern3_0 = arg3;
2416     // Rule at src/isa/x64/inst.isle line 1705.
2417     let expr0_0 = C::temp_writable_xmm(ctx);
2418     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2419     let expr2_0 = MInst::XmmCmove {
2420         size: expr1_0,
2421         cc: pattern1_0.clone(),
2422         consequent: pattern2_0.clone(),
2423         alternative: pattern3_0,
2424         dst: expr0_0,
2425     };
2426     let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
2427     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2428         inst: expr2_0,
2429         result: expr3_0,
2430     };
2431     return Some(expr4_0);
2432 }
2433 
2434 // Generated as internal constructor for term cmove_from_values.
2435 pub fn constructor_cmove_from_values<C: Context>(
2436     ctx: &mut C,
2437     arg0: Type,
2438     arg1: &CC,
2439     arg2: Value,
2440     arg3: Value,
2441 ) -> Option<ConsumesFlags> {
2442     let pattern0_0 = arg0;
2443     if pattern0_0 == I128 {
2444         let pattern2_0 = arg1;
2445         let pattern3_0 = arg2;
2446         let pattern4_0 = arg3;
2447         // Rule at src/isa/x64/inst.isle line 1716.
2448         let expr0_0 = C::put_in_regs(ctx, pattern3_0);
2449         let expr1_0 = C::put_in_regs(ctx, pattern4_0);
2450         let expr2_0 = C::temp_writable_gpr(ctx);
2451         let expr3_0 = C::temp_writable_gpr(ctx);
2452         let expr4_0 = OperandSize::Size64;
2453         let expr5_0: usize = 0;
2454         let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?;
2455         let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
2456         let expr8_0: usize = 0;
2457         let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?;
2458         let expr10_0 = MInst::Cmove {
2459             size: expr4_0,
2460             cc: pattern2_0.clone(),
2461             consequent: expr7_0,
2462             alternative: expr9_0,
2463             dst: expr2_0,
2464         };
2465         let expr11_0: usize = 1;
2466         let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?;
2467         let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
2468         let expr14_0: usize = 1;
2469         let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?;
2470         let expr16_0 = MInst::Cmove {
2471             size: expr4_0,
2472             cc: pattern2_0.clone(),
2473             consequent: expr13_0,
2474             alternative: expr15_0,
2475             dst: expr3_0,
2476         };
2477         let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2478         let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2479         let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0);
2480         let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2481             inst1: expr10_0,
2482             inst2: expr16_0,
2483             result: expr19_0,
2484         };
2485         return Some(expr20_0);
2486     }
2487     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2488         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2489             let pattern3_0 = arg1;
2490             let pattern4_0 = arg2;
2491             let pattern5_0 = arg3;
2492             // Rule at src/isa/x64/inst.isle line 1740.
2493             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
2494             let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?;
2495             let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2496             return Some(expr2_0);
2497         }
2498     }
2499     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2500         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2501             let pattern3_0 = arg1;
2502             let pattern4_0 = arg2;
2503             let pattern5_0 = arg3;
2504             // Rule at src/isa/x64/inst.isle line 1737.
2505             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
2506             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?;
2507             let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2508             return Some(expr2_0);
2509         }
2510     }
2511     return None;
2512 }
2513 
2514 // Generated as internal constructor for term cmove_or.
2515 pub fn constructor_cmove_or<C: Context>(
2516     ctx: &mut C,
2517     arg0: Type,
2518     arg1: &CC,
2519     arg2: &CC,
2520     arg3: &GprMem,
2521     arg4: Gpr,
2522 ) -> Option<ConsumesFlags> {
2523     let pattern0_0 = arg0;
2524     let pattern1_0 = arg1;
2525     let pattern2_0 = arg2;
2526     let pattern3_0 = arg3;
2527     let pattern4_0 = arg4;
2528     // Rule at src/isa/x64/inst.isle line 1747.
2529     let expr0_0 = C::temp_writable_gpr(ctx);
2530     let expr1_0 = C::temp_writable_gpr(ctx);
2531     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2532     let expr3_0 = MInst::Cmove {
2533         size: expr2_0,
2534         cc: pattern1_0.clone(),
2535         consequent: pattern3_0.clone(),
2536         alternative: pattern4_0,
2537         dst: expr1_0,
2538     };
2539     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
2540     let expr5_0 = MInst::Cmove {
2541         size: expr2_0,
2542         cc: pattern2_0.clone(),
2543         consequent: pattern3_0.clone(),
2544         alternative: expr4_0,
2545         dst: expr0_0,
2546     };
2547     let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?;
2548     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2549         inst1: expr3_0,
2550         inst2: expr5_0,
2551         result: expr6_0,
2552     };
2553     return Some(expr7_0);
2554 }
2555 
2556 // Generated as internal constructor for term cmove_or_xmm.
2557 pub fn constructor_cmove_or_xmm<C: Context>(
2558     ctx: &mut C,
2559     arg0: Type,
2560     arg1: &CC,
2561     arg2: &CC,
2562     arg3: &XmmMem,
2563     arg4: Xmm,
2564 ) -> Option<ConsumesFlags> {
2565     let pattern0_0 = arg0;
2566     let pattern1_0 = arg1;
2567     let pattern2_0 = arg2;
2568     let pattern3_0 = arg3;
2569     let pattern4_0 = arg4;
2570     // Rule at src/isa/x64/inst.isle line 1759.
2571     let expr0_0 = C::temp_writable_xmm(ctx);
2572     let expr1_0 = C::temp_writable_xmm(ctx);
2573     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2574     let expr3_0 = MInst::XmmCmove {
2575         size: expr2_0,
2576         cc: pattern1_0.clone(),
2577         consequent: pattern3_0.clone(),
2578         alternative: pattern4_0,
2579         dst: expr1_0,
2580     };
2581     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0);
2582     let expr5_0 = MInst::XmmCmove {
2583         size: expr2_0,
2584         cc: pattern2_0.clone(),
2585         consequent: pattern3_0.clone(),
2586         alternative: expr4_0,
2587         dst: expr0_0,
2588     };
2589     let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?;
2590     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2591         inst1: expr3_0,
2592         inst2: expr5_0,
2593         result: expr6_0,
2594     };
2595     return Some(expr7_0);
2596 }
2597 
2598 // Generated as internal constructor for term cmove_or_from_values.
2599 pub fn constructor_cmove_or_from_values<C: Context>(
2600     ctx: &mut C,
2601     arg0: Type,
2602     arg1: &CC,
2603     arg2: &CC,
2604     arg3: Value,
2605     arg4: Value,
2606 ) -> Option<ConsumesFlags> {
2607     let pattern0_0 = arg0;
2608     if pattern0_0 == I128 {
2609         let pattern2_0 = arg1;
2610         let pattern3_0 = arg2;
2611         let pattern4_0 = arg3;
2612         let pattern5_0 = arg4;
2613         // Rule at src/isa/x64/inst.isle line 1774.
2614         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
2615         let expr1_0 = C::put_in_regs(ctx, pattern5_0);
2616         let expr2_0 = C::temp_writable_gpr(ctx);
2617         let expr3_0 = C::temp_writable_gpr(ctx);
2618         let expr4_0 = C::temp_writable_gpr(ctx);
2619         let expr5_0 = C::temp_writable_gpr(ctx);
2620         let expr6_0 = OperandSize::Size64;
2621         let expr7_0: usize = 0;
2622         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?;
2623         let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0);
2624         let expr10_0: usize = 0;
2625         let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?;
2626         let expr12_0 = MInst::Cmove {
2627             size: expr6_0,
2628             cc: pattern2_0.clone(),
2629             consequent: expr9_0,
2630             alternative: expr11_0,
2631             dst: expr4_0,
2632         };
2633         let expr13_0: usize = 0;
2634         let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?;
2635         let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0);
2636         let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0);
2637         let expr17_0 = MInst::Cmove {
2638             size: expr6_0,
2639             cc: pattern2_0.clone(),
2640             consequent: expr15_0,
2641             alternative: expr16_0,
2642             dst: expr2_0,
2643         };
2644         let expr18_0: usize = 1;
2645         let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?;
2646         let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0);
2647         let expr21_0: usize = 1;
2648         let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?;
2649         let expr23_0 = MInst::Cmove {
2650             size: expr6_0,
2651             cc: pattern2_0.clone(),
2652             consequent: expr20_0,
2653             alternative: expr22_0,
2654             dst: expr5_0,
2655         };
2656         let expr24_0: usize = 1;
2657         let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?;
2658         let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0);
2659         let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0);
2660         let expr28_0 = MInst::Cmove {
2661             size: expr6_0,
2662             cc: pattern2_0.clone(),
2663             consequent: expr26_0,
2664             alternative: expr27_0,
2665             dst: expr3_0,
2666         };
2667         let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2668         let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2669         let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0);
2670         let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
2671             inst1: expr12_0,
2672             inst2: expr17_0,
2673             inst3: expr23_0,
2674             inst4: expr28_0,
2675             result: expr31_0,
2676         };
2677         return Some(expr32_0);
2678     }
2679     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2680         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2681             let pattern3_0 = arg1;
2682             let pattern4_0 = arg2;
2683             let pattern5_0 = arg3;
2684             let pattern6_0 = arg4;
2685             // Rule at src/isa/x64/inst.isle line 1796.
2686             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?;
2687             let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?;
2688             let expr2_0 = constructor_cmove_or_xmm(
2689                 ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0,
2690             )?;
2691             return Some(expr2_0);
2692         }
2693     }
2694     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2695         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2696             let pattern3_0 = arg1;
2697             let pattern4_0 = arg2;
2698             let pattern5_0 = arg3;
2699             let pattern6_0 = arg4;
2700             // Rule at src/isa/x64/inst.isle line 1793.
2701             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?;
2702             let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
2703             let expr2_0 =
2704                 constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?;
2705             return Some(expr2_0);
2706         }
2707     }
2708     return None;
2709 }
2710 
2711 // Generated as internal constructor for term x64_setcc.
2712 pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> Option<ConsumesFlags> {
2713     let pattern0_0 = arg0;
2714     // Rule at src/isa/x64/inst.isle line 1801.
2715     let expr0_0 = C::temp_writable_gpr(ctx);
2716     let expr1_0 = MInst::Setcc {
2717         cc: pattern0_0.clone(),
2718         dst: expr0_0,
2719     };
2720     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2721     let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2722         inst: expr1_0,
2723         result: expr2_0,
2724     };
2725     return Some(expr3_0);
2726 }
2727 
2728 // Generated as internal constructor for term xmm_rm_r.
2729 pub fn constructor_xmm_rm_r<C: Context>(
2730     ctx: &mut C,
2731     arg0: Type,
2732     arg1: &SseOpcode,
2733     arg2: Xmm,
2734     arg3: &XmmMem,
2735 ) -> Option<Xmm> {
2736     let pattern0_0 = arg0;
2737     let pattern1_0 = arg1;
2738     let pattern2_0 = arg2;
2739     let pattern3_0 = arg3;
2740     // Rule at src/isa/x64/inst.isle line 1809.
2741     let expr0_0 = C::temp_writable_xmm(ctx);
2742     let expr1_0 = MInst::XmmRmR {
2743         op: pattern1_0.clone(),
2744         src1: pattern2_0,
2745         src2: pattern3_0.clone(),
2746         dst: expr0_0,
2747     };
2748     let expr2_0 = C::emit(ctx, &expr1_0);
2749     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2750     return Some(expr3_0);
2751 }
2752 
2753 // Generated as internal constructor for term x64_paddb.
2754 pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2755     let pattern0_0 = arg0;
2756     let pattern1_0 = arg1;
2757     // Rule at src/isa/x64/inst.isle line 1816.
2758     let expr0_0: Type = I8X16;
2759     let expr1_0 = SseOpcode::Paddb;
2760     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2761     return Some(expr2_0);
2762 }
2763 
2764 // Generated as internal constructor for term x64_paddw.
2765 pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2766     let pattern0_0 = arg0;
2767     let pattern1_0 = arg1;
2768     // Rule at src/isa/x64/inst.isle line 1821.
2769     let expr0_0: Type = I16X8;
2770     let expr1_0 = SseOpcode::Paddw;
2771     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2772     return Some(expr2_0);
2773 }
2774 
2775 // Generated as internal constructor for term x64_paddd.
2776 pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2777     let pattern0_0 = arg0;
2778     let pattern1_0 = arg1;
2779     // Rule at src/isa/x64/inst.isle line 1826.
2780     let expr0_0: Type = I32X4;
2781     let expr1_0 = SseOpcode::Paddd;
2782     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2783     return Some(expr2_0);
2784 }
2785 
2786 // Generated as internal constructor for term x64_paddq.
2787 pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2788     let pattern0_0 = arg0;
2789     let pattern1_0 = arg1;
2790     // Rule at src/isa/x64/inst.isle line 1831.
2791     let expr0_0: Type = I64X2;
2792     let expr1_0 = SseOpcode::Paddq;
2793     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2794     return Some(expr2_0);
2795 }
2796 
2797 // Generated as internal constructor for term x64_paddsb.
2798 pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2799     let pattern0_0 = arg0;
2800     let pattern1_0 = arg1;
2801     // Rule at src/isa/x64/inst.isle line 1836.
2802     let expr0_0: Type = I8X16;
2803     let expr1_0 = SseOpcode::Paddsb;
2804     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2805     return Some(expr2_0);
2806 }
2807 
2808 // Generated as internal constructor for term x64_paddsw.
2809 pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2810     let pattern0_0 = arg0;
2811     let pattern1_0 = arg1;
2812     // Rule at src/isa/x64/inst.isle line 1841.
2813     let expr0_0: Type = I16X8;
2814     let expr1_0 = SseOpcode::Paddsw;
2815     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2816     return Some(expr2_0);
2817 }
2818 
2819 // Generated as internal constructor for term x64_paddusb.
2820 pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2821     let pattern0_0 = arg0;
2822     let pattern1_0 = arg1;
2823     // Rule at src/isa/x64/inst.isle line 1846.
2824     let expr0_0: Type = I8X16;
2825     let expr1_0 = SseOpcode::Paddusb;
2826     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2827     return Some(expr2_0);
2828 }
2829 
2830 // Generated as internal constructor for term x64_paddusw.
2831 pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2832     let pattern0_0 = arg0;
2833     let pattern1_0 = arg1;
2834     // Rule at src/isa/x64/inst.isle line 1851.
2835     let expr0_0: Type = I16X8;
2836     let expr1_0 = SseOpcode::Paddusw;
2837     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2838     return Some(expr2_0);
2839 }
2840 
2841 // Generated as internal constructor for term x64_psubb.
2842 pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2843     let pattern0_0 = arg0;
2844     let pattern1_0 = arg1;
2845     // Rule at src/isa/x64/inst.isle line 1856.
2846     let expr0_0: Type = I8X16;
2847     let expr1_0 = SseOpcode::Psubb;
2848     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2849     return Some(expr2_0);
2850 }
2851 
2852 // Generated as internal constructor for term x64_psubw.
2853 pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2854     let pattern0_0 = arg0;
2855     let pattern1_0 = arg1;
2856     // Rule at src/isa/x64/inst.isle line 1861.
2857     let expr0_0: Type = I16X8;
2858     let expr1_0 = SseOpcode::Psubw;
2859     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2860     return Some(expr2_0);
2861 }
2862 
2863 // Generated as internal constructor for term x64_psubd.
2864 pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2865     let pattern0_0 = arg0;
2866     let pattern1_0 = arg1;
2867     // Rule at src/isa/x64/inst.isle line 1866.
2868     let expr0_0: Type = I32X4;
2869     let expr1_0 = SseOpcode::Psubd;
2870     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2871     return Some(expr2_0);
2872 }
2873 
2874 // Generated as internal constructor for term x64_psubq.
2875 pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2876     let pattern0_0 = arg0;
2877     let pattern1_0 = arg1;
2878     // Rule at src/isa/x64/inst.isle line 1871.
2879     let expr0_0: Type = I64X2;
2880     let expr1_0 = SseOpcode::Psubq;
2881     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2882     return Some(expr2_0);
2883 }
2884 
2885 // Generated as internal constructor for term x64_psubsb.
2886 pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2887     let pattern0_0 = arg0;
2888     let pattern1_0 = arg1;
2889     // Rule at src/isa/x64/inst.isle line 1876.
2890     let expr0_0: Type = I8X16;
2891     let expr1_0 = SseOpcode::Psubsb;
2892     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2893     return Some(expr2_0);
2894 }
2895 
2896 // Generated as internal constructor for term x64_psubsw.
2897 pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2898     let pattern0_0 = arg0;
2899     let pattern1_0 = arg1;
2900     // Rule at src/isa/x64/inst.isle line 1881.
2901     let expr0_0: Type = I16X8;
2902     let expr1_0 = SseOpcode::Psubsw;
2903     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2904     return Some(expr2_0);
2905 }
2906 
2907 // Generated as internal constructor for term x64_psubusb.
2908 pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2909     let pattern0_0 = arg0;
2910     let pattern1_0 = arg1;
2911     // Rule at src/isa/x64/inst.isle line 1886.
2912     let expr0_0: Type = I8X16;
2913     let expr1_0 = SseOpcode::Psubusb;
2914     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2915     return Some(expr2_0);
2916 }
2917 
2918 // Generated as internal constructor for term x64_psubusw.
2919 pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2920     let pattern0_0 = arg0;
2921     let pattern1_0 = arg1;
2922     // Rule at src/isa/x64/inst.isle line 1891.
2923     let expr0_0: Type = I16X8;
2924     let expr1_0 = SseOpcode::Psubusw;
2925     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2926     return Some(expr2_0);
2927 }
2928 
2929 // Generated as internal constructor for term x64_pavgb.
2930 pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2931     let pattern0_0 = arg0;
2932     let pattern1_0 = arg1;
2933     // Rule at src/isa/x64/inst.isle line 1896.
2934     let expr0_0: Type = I8X16;
2935     let expr1_0 = SseOpcode::Pavgb;
2936     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2937     return Some(expr2_0);
2938 }
2939 
2940 // Generated as internal constructor for term x64_pavgw.
2941 pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2942     let pattern0_0 = arg0;
2943     let pattern1_0 = arg1;
2944     // Rule at src/isa/x64/inst.isle line 1901.
2945     let expr0_0: Type = I16X8;
2946     let expr1_0 = SseOpcode::Pavgw;
2947     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2948     return Some(expr2_0);
2949 }
2950 
2951 // Generated as internal constructor for term x64_pand.
2952 pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2953     let pattern0_0 = arg0;
2954     let pattern1_0 = arg1;
2955     // Rule at src/isa/x64/inst.isle line 1906.
2956     let expr0_0: Type = F32X4;
2957     let expr1_0 = SseOpcode::Pand;
2958     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2959     return Some(expr2_0);
2960 }
2961 
2962 // Generated as internal constructor for term x64_andps.
2963 pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2964     let pattern0_0 = arg0;
2965     let pattern1_0 = arg1;
2966     // Rule at src/isa/x64/inst.isle line 1911.
2967     let expr0_0: Type = F32X4;
2968     let expr1_0 = SseOpcode::Andps;
2969     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2970     return Some(expr2_0);
2971 }
2972 
2973 // Generated as internal constructor for term x64_andpd.
2974 pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2975     let pattern0_0 = arg0;
2976     let pattern1_0 = arg1;
2977     // Rule at src/isa/x64/inst.isle line 1916.
2978     let expr0_0: Type = F64X2;
2979     let expr1_0 = SseOpcode::Andpd;
2980     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2981     return Some(expr2_0);
2982 }
2983 
2984 // Generated as internal constructor for term x64_por.
2985 pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2986     let pattern0_0 = arg0;
2987     let pattern1_0 = arg1;
2988     // Rule at src/isa/x64/inst.isle line 1921.
2989     let expr0_0: Type = F32X4;
2990     let expr1_0 = SseOpcode::Por;
2991     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2992     return Some(expr2_0);
2993 }
2994 
2995 // Generated as internal constructor for term x64_orps.
2996 pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2997     let pattern0_0 = arg0;
2998     let pattern1_0 = arg1;
2999     // Rule at src/isa/x64/inst.isle line 1926.
3000     let expr0_0: Type = F32X4;
3001     let expr1_0 = SseOpcode::Orps;
3002     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3003     return Some(expr2_0);
3004 }
3005 
3006 // Generated as internal constructor for term x64_orpd.
3007 pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3008     let pattern0_0 = arg0;
3009     let pattern1_0 = arg1;
3010     // Rule at src/isa/x64/inst.isle line 1931.
3011     let expr0_0: Type = F64X2;
3012     let expr1_0 = SseOpcode::Orpd;
3013     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3014     return Some(expr2_0);
3015 }
3016 
3017 // Generated as internal constructor for term x64_pxor.
3018 pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3019     let pattern0_0 = arg0;
3020     let pattern1_0 = arg1;
3021     // Rule at src/isa/x64/inst.isle line 1936.
3022     let expr0_0: Type = I8X16;
3023     let expr1_0 = SseOpcode::Pxor;
3024     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3025     return Some(expr2_0);
3026 }
3027 
3028 // Generated as internal constructor for term x64_xorps.
3029 pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3030     let pattern0_0 = arg0;
3031     let pattern1_0 = arg1;
3032     // Rule at src/isa/x64/inst.isle line 1941.
3033     let expr0_0: Type = F32X4;
3034     let expr1_0 = SseOpcode::Xorps;
3035     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3036     return Some(expr2_0);
3037 }
3038 
3039 // Generated as internal constructor for term x64_xorpd.
3040 pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3041     let pattern0_0 = arg0;
3042     let pattern1_0 = arg1;
3043     // Rule at src/isa/x64/inst.isle line 1946.
3044     let expr0_0: Type = F64X2;
3045     let expr1_0 = SseOpcode::Xorpd;
3046     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3047     return Some(expr2_0);
3048 }
3049 
3050 // Generated as internal constructor for term x64_pmullw.
3051 pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3052     let pattern0_0 = arg0;
3053     let pattern1_0 = arg1;
3054     // Rule at src/isa/x64/inst.isle line 1951.
3055     let expr0_0: Type = I16X8;
3056     let expr1_0 = SseOpcode::Pmullw;
3057     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3058     return Some(expr2_0);
3059 }
3060 
3061 // Generated as internal constructor for term x64_pmulld.
3062 pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3063     let pattern0_0 = arg0;
3064     let pattern1_0 = arg1;
3065     // Rule at src/isa/x64/inst.isle line 1956.
3066     let expr0_0: Type = I16X8;
3067     let expr1_0 = SseOpcode::Pmulld;
3068     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3069     return Some(expr2_0);
3070 }
3071 
3072 // Generated as internal constructor for term x64_pmulhw.
3073 pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3074     let pattern0_0 = arg0;
3075     let pattern1_0 = arg1;
3076     // Rule at src/isa/x64/inst.isle line 1961.
3077     let expr0_0: Type = I16X8;
3078     let expr1_0 = SseOpcode::Pmulhw;
3079     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3080     return Some(expr2_0);
3081 }
3082 
3083 // Generated as internal constructor for term x64_pmulhuw.
3084 pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3085     let pattern0_0 = arg0;
3086     let pattern1_0 = arg1;
3087     // Rule at src/isa/x64/inst.isle line 1966.
3088     let expr0_0: Type = I16X8;
3089     let expr1_0 = SseOpcode::Pmulhuw;
3090     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3091     return Some(expr2_0);
3092 }
3093 
3094 // Generated as internal constructor for term x64_pmuldq.
3095 pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3096     let pattern0_0 = arg0;
3097     let pattern1_0 = arg1;
3098     // Rule at src/isa/x64/inst.isle line 1971.
3099     let expr0_0: Type = I16X8;
3100     let expr1_0 = SseOpcode::Pmuldq;
3101     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3102     return Some(expr2_0);
3103 }
3104 
3105 // Generated as internal constructor for term x64_pmuludq.
3106 pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3107     let pattern0_0 = arg0;
3108     let pattern1_0 = arg1;
3109     // Rule at src/isa/x64/inst.isle line 1976.
3110     let expr0_0: Type = I64X2;
3111     let expr1_0 = SseOpcode::Pmuludq;
3112     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3113     return Some(expr2_0);
3114 }
3115 
3116 // Generated as internal constructor for term x64_punpckhwd.
3117 pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3118     let pattern0_0 = arg0;
3119     let pattern1_0 = arg1;
3120     // Rule at src/isa/x64/inst.isle line 1981.
3121     let expr0_0: Type = I16X8;
3122     let expr1_0 = SseOpcode::Punpckhwd;
3123     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3124     return Some(expr2_0);
3125 }
3126 
3127 // Generated as internal constructor for term x64_punpcklwd.
3128 pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3129     let pattern0_0 = arg0;
3130     let pattern1_0 = arg1;
3131     // Rule at src/isa/x64/inst.isle line 1986.
3132     let expr0_0: Type = I16X8;
3133     let expr1_0 = SseOpcode::Punpcklwd;
3134     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3135     return Some(expr2_0);
3136 }
3137 
3138 // Generated as internal constructor for term x64_andnps.
3139 pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3140     let pattern0_0 = arg0;
3141     let pattern1_0 = arg1;
3142     // Rule at src/isa/x64/inst.isle line 1991.
3143     let expr0_0: Type = F32X4;
3144     let expr1_0 = SseOpcode::Andnps;
3145     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3146     return Some(expr2_0);
3147 }
3148 
3149 // Generated as internal constructor for term x64_andnpd.
3150 pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3151     let pattern0_0 = arg0;
3152     let pattern1_0 = arg1;
3153     // Rule at src/isa/x64/inst.isle line 1996.
3154     let expr0_0: Type = F64X2;
3155     let expr1_0 = SseOpcode::Andnpd;
3156     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3157     return Some(expr2_0);
3158 }
3159 
3160 // Generated as internal constructor for term x64_pandn.
3161 pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3162     let pattern0_0 = arg0;
3163     let pattern1_0 = arg1;
3164     // Rule at src/isa/x64/inst.isle line 2001.
3165     let expr0_0: Type = F64X2;
3166     let expr1_0 = SseOpcode::Pandn;
3167     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3168     return Some(expr2_0);
3169 }
3170 
3171 // Generated as internal constructor for term x64_addss.
3172 pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3173     let pattern0_0 = arg0;
3174     let pattern1_0 = arg1;
3175     // Rule at src/isa/x64/inst.isle line 2006.
3176     let expr0_0: Type = F32;
3177     let expr1_0 = SseOpcode::Addss;
3178     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3179     return Some(expr2_0);
3180 }
3181 
3182 // Generated as internal constructor for term x64_addsd.
3183 pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3184     let pattern0_0 = arg0;
3185     let pattern1_0 = arg1;
3186     // Rule at src/isa/x64/inst.isle line 2011.
3187     let expr0_0: Type = F64;
3188     let expr1_0 = SseOpcode::Addsd;
3189     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3190     return Some(expr2_0);
3191 }
3192 
3193 // Generated as internal constructor for term x64_addps.
3194 pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3195     let pattern0_0 = arg0;
3196     let pattern1_0 = arg1;
3197     // Rule at src/isa/x64/inst.isle line 2016.
3198     let expr0_0: Type = F32;
3199     let expr1_0 = SseOpcode::Addps;
3200     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3201     return Some(expr2_0);
3202 }
3203 
3204 // Generated as internal constructor for term x64_addpd.
3205 pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3206     let pattern0_0 = arg0;
3207     let pattern1_0 = arg1;
3208     // Rule at src/isa/x64/inst.isle line 2021.
3209     let expr0_0: Type = F32;
3210     let expr1_0 = SseOpcode::Addpd;
3211     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3212     return Some(expr2_0);
3213 }
3214 
3215 // Generated as internal constructor for term x64_subss.
3216 pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3217     let pattern0_0 = arg0;
3218     let pattern1_0 = arg1;
3219     // Rule at src/isa/x64/inst.isle line 2026.
3220     let expr0_0: Type = F32;
3221     let expr1_0 = SseOpcode::Subss;
3222     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3223     return Some(expr2_0);
3224 }
3225 
3226 // Generated as internal constructor for term x64_subsd.
3227 pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3228     let pattern0_0 = arg0;
3229     let pattern1_0 = arg1;
3230     // Rule at src/isa/x64/inst.isle line 2031.
3231     let expr0_0: Type = F64;
3232     let expr1_0 = SseOpcode::Subsd;
3233     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3234     return Some(expr2_0);
3235 }
3236 
3237 // Generated as internal constructor for term x64_subps.
3238 pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3239     let pattern0_0 = arg0;
3240     let pattern1_0 = arg1;
3241     // Rule at src/isa/x64/inst.isle line 2036.
3242     let expr0_0: Type = F32;
3243     let expr1_0 = SseOpcode::Subps;
3244     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3245     return Some(expr2_0);
3246 }
3247 
3248 // Generated as internal constructor for term x64_subpd.
3249 pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3250     let pattern0_0 = arg0;
3251     let pattern1_0 = arg1;
3252     // Rule at src/isa/x64/inst.isle line 2041.
3253     let expr0_0: Type = F32;
3254     let expr1_0 = SseOpcode::Subpd;
3255     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3256     return Some(expr2_0);
3257 }
3258 
3259 // Generated as internal constructor for term x64_mulss.
3260 pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3261     let pattern0_0 = arg0;
3262     let pattern1_0 = arg1;
3263     // Rule at src/isa/x64/inst.isle line 2046.
3264     let expr0_0: Type = F32;
3265     let expr1_0 = SseOpcode::Mulss;
3266     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3267     return Some(expr2_0);
3268 }
3269 
3270 // Generated as internal constructor for term x64_mulsd.
3271 pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3272     let pattern0_0 = arg0;
3273     let pattern1_0 = arg1;
3274     // Rule at src/isa/x64/inst.isle line 2051.
3275     let expr0_0: Type = F64;
3276     let expr1_0 = SseOpcode::Mulsd;
3277     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3278     return Some(expr2_0);
3279 }
3280 
3281 // Generated as internal constructor for term x64_mulps.
3282 pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3283     let pattern0_0 = arg0;
3284     let pattern1_0 = arg1;
3285     // Rule at src/isa/x64/inst.isle line 2056.
3286     let expr0_0: Type = F32;
3287     let expr1_0 = SseOpcode::Mulps;
3288     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3289     return Some(expr2_0);
3290 }
3291 
3292 // Generated as internal constructor for term x64_mulpd.
3293 pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3294     let pattern0_0 = arg0;
3295     let pattern1_0 = arg1;
3296     // Rule at src/isa/x64/inst.isle line 2061.
3297     let expr0_0: Type = F32;
3298     let expr1_0 = SseOpcode::Mulpd;
3299     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3300     return Some(expr2_0);
3301 }
3302 
3303 // Generated as internal constructor for term x64_divss.
3304 pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3305     let pattern0_0 = arg0;
3306     let pattern1_0 = arg1;
3307     // Rule at src/isa/x64/inst.isle line 2066.
3308     let expr0_0: Type = F32;
3309     let expr1_0 = SseOpcode::Divss;
3310     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3311     return Some(expr2_0);
3312 }
3313 
3314 // Generated as internal constructor for term x64_divsd.
3315 pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3316     let pattern0_0 = arg0;
3317     let pattern1_0 = arg1;
3318     // Rule at src/isa/x64/inst.isle line 2071.
3319     let expr0_0: Type = F64;
3320     let expr1_0 = SseOpcode::Divsd;
3321     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3322     return Some(expr2_0);
3323 }
3324 
3325 // Generated as internal constructor for term x64_divps.
3326 pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3327     let pattern0_0 = arg0;
3328     let pattern1_0 = arg1;
3329     // Rule at src/isa/x64/inst.isle line 2076.
3330     let expr0_0: Type = F32;
3331     let expr1_0 = SseOpcode::Divps;
3332     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3333     return Some(expr2_0);
3334 }
3335 
3336 // Generated as internal constructor for term x64_divpd.
3337 pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3338     let pattern0_0 = arg0;
3339     let pattern1_0 = arg1;
3340     // Rule at src/isa/x64/inst.isle line 2081.
3341     let expr0_0: Type = F32;
3342     let expr1_0 = SseOpcode::Divpd;
3343     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3344     return Some(expr2_0);
3345 }
3346 
3347 // Generated as internal constructor for term sse_blend_op.
3348 pub fn constructor_sse_blend_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3349     let pattern0_0 = arg0;
3350     if pattern0_0 == F32X4 {
3351         // Rule at src/isa/x64/inst.isle line 2085.
3352         let expr0_0 = SseOpcode::Blendvps;
3353         return Some(expr0_0);
3354     }
3355     if pattern0_0 == F64X2 {
3356         // Rule at src/isa/x64/inst.isle line 2086.
3357         let expr0_0 = SseOpcode::Blendvpd;
3358         return Some(expr0_0);
3359     }
3360     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3361         // Rule at src/isa/x64/inst.isle line 2087.
3362         let expr0_0 = SseOpcode::Pblendvb;
3363         return Some(expr0_0);
3364     }
3365     return None;
3366 }
3367 
3368 // Generated as internal constructor for term sse_mov_op.
3369 pub fn constructor_sse_mov_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3370     let pattern0_0 = arg0;
3371     if pattern0_0 == F32X4 {
3372         // Rule at src/isa/x64/inst.isle line 2090.
3373         let expr0_0 = SseOpcode::Movaps;
3374         return Some(expr0_0);
3375     }
3376     if pattern0_0 == F64X2 {
3377         // Rule at src/isa/x64/inst.isle line 2091.
3378         let expr0_0 = SseOpcode::Movapd;
3379         return Some(expr0_0);
3380     }
3381     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3382         // Rule at src/isa/x64/inst.isle line 2092.
3383         let expr0_0 = SseOpcode::Movdqa;
3384         return Some(expr0_0);
3385     }
3386     return None;
3387 }
3388 
3389 // Generated as internal constructor for term x64_blend.
3390 pub fn constructor_x64_blend<C: Context>(
3391     ctx: &mut C,
3392     arg0: Type,
3393     arg1: &XmmMem,
3394     arg2: &XmmMem,
3395     arg3: Xmm,
3396 ) -> Option<Xmm> {
3397     let pattern0_0 = arg0;
3398     let pattern1_0 = arg1;
3399     let pattern2_0 = arg2;
3400     let pattern3_0 = arg3;
3401     // Rule at src/isa/x64/inst.isle line 2096.
3402     let expr0_0 = C::xmm0(ctx);
3403     let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?;
3404     let expr2_0 = MInst::XmmUnaryRmR {
3405         op: expr1_0,
3406         src: pattern1_0.clone(),
3407         dst: expr0_0,
3408     };
3409     let expr3_0 = C::emit(ctx, &expr2_0);
3410     let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?;
3411     let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?;
3412     return Some(expr5_0);
3413 }
3414 
3415 // Generated as internal constructor for term x64_blendvpd.
3416 pub fn constructor_x64_blendvpd<C: Context>(
3417     ctx: &mut C,
3418     arg0: Xmm,
3419     arg1: &XmmMem,
3420     arg2: Xmm,
3421 ) -> Option<Xmm> {
3422     let pattern0_0 = arg0;
3423     let pattern1_0 = arg1;
3424     let pattern2_0 = arg2;
3425     // Rule at src/isa/x64/inst.isle line 2110.
3426     let expr0_0 = C::xmm0(ctx);
3427     let expr1_0 = SseOpcode::Movapd;
3428     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0);
3429     let expr3_0 = MInst::XmmUnaryRmR {
3430         op: expr1_0,
3431         src: expr2_0,
3432         dst: expr0_0,
3433     };
3434     let expr4_0 = C::emit(ctx, &expr3_0);
3435     let expr5_0: Type = F64X2;
3436     let expr6_0 = SseOpcode::Blendvpd;
3437     let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?;
3438     return Some(expr7_0);
3439 }
3440 
3441 // Generated as internal constructor for term x64_movsd_regmove.
3442 pub fn constructor_x64_movsd_regmove<C: Context>(
3443     ctx: &mut C,
3444     arg0: Xmm,
3445     arg1: &XmmMem,
3446 ) -> Option<Xmm> {
3447     let pattern0_0 = arg0;
3448     let pattern1_0 = arg1;
3449     // Rule at src/isa/x64/inst.isle line 2124.
3450     let expr0_0: Type = I8X16;
3451     let expr1_0 = SseOpcode::Movsd;
3452     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3453     return Some(expr2_0);
3454 }
3455 
3456 // Generated as internal constructor for term x64_movlhps.
3457 pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3458     let pattern0_0 = arg0;
3459     let pattern1_0 = arg1;
3460     // Rule at src/isa/x64/inst.isle line 2129.
3461     let expr0_0: Type = I8X16;
3462     let expr1_0 = SseOpcode::Movlhps;
3463     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3464     return Some(expr2_0);
3465 }
3466 
3467 // Generated as internal constructor for term x64_pmaxs.
3468 pub fn constructor_x64_pmaxs<C: Context>(
3469     ctx: &mut C,
3470     arg0: Type,
3471     arg1: Xmm,
3472     arg2: &XmmMem,
3473 ) -> Option<Xmm> {
3474     let pattern0_0 = arg0;
3475     if pattern0_0 == I8X16 {
3476         let pattern2_0 = arg1;
3477         let pattern3_0 = arg2;
3478         // Rule at src/isa/x64/inst.isle line 2134.
3479         let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?;
3480         return Some(expr0_0);
3481     }
3482     if pattern0_0 == I16X8 {
3483         let pattern2_0 = arg1;
3484         let pattern3_0 = arg2;
3485         // Rule at src/isa/x64/inst.isle line 2135.
3486         let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?;
3487         return Some(expr0_0);
3488     }
3489     if pattern0_0 == I32X4 {
3490         let pattern2_0 = arg1;
3491         let pattern3_0 = arg2;
3492         // Rule at src/isa/x64/inst.isle line 2136.
3493         let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?;
3494         return Some(expr0_0);
3495     }
3496     return None;
3497 }
3498 
3499 // Generated as internal constructor for term x64_pmaxsb.
3500 pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3501     let pattern0_0 = arg0;
3502     let pattern1_0 = arg1;
3503     // Rule at src/isa/x64/inst.isle line 2139.
3504     let expr0_0: Type = I8X16;
3505     let expr1_0 = SseOpcode::Pmaxsb;
3506     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3507     return Some(expr2_0);
3508 }
3509 
3510 // Generated as internal constructor for term x64_pmaxsw.
3511 pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3512     let pattern0_0 = arg0;
3513     let pattern1_0 = arg1;
3514     // Rule at src/isa/x64/inst.isle line 2141.
3515     let expr0_0: Type = I8X16;
3516     let expr1_0 = SseOpcode::Pmaxsw;
3517     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3518     return Some(expr2_0);
3519 }
3520 
3521 // Generated as internal constructor for term x64_pmaxsd.
3522 pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3523     let pattern0_0 = arg0;
3524     let pattern1_0 = arg1;
3525     // Rule at src/isa/x64/inst.isle line 2143.
3526     let expr0_0: Type = I8X16;
3527     let expr1_0 = SseOpcode::Pmaxsd;
3528     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3529     return Some(expr2_0);
3530 }
3531 
3532 // Generated as internal constructor for term x64_pmins.
3533 pub fn constructor_x64_pmins<C: Context>(
3534     ctx: &mut C,
3535     arg0: Type,
3536     arg1: Xmm,
3537     arg2: &XmmMem,
3538 ) -> Option<Xmm> {
3539     let pattern0_0 = arg0;
3540     if pattern0_0 == I8X16 {
3541         let pattern2_0 = arg1;
3542         let pattern3_0 = arg2;
3543         // Rule at src/isa/x64/inst.isle line 2147.
3544         let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?;
3545         return Some(expr0_0);
3546     }
3547     if pattern0_0 == I16X8 {
3548         let pattern2_0 = arg1;
3549         let pattern3_0 = arg2;
3550         // Rule at src/isa/x64/inst.isle line 2148.
3551         let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?;
3552         return Some(expr0_0);
3553     }
3554     if pattern0_0 == I32X4 {
3555         let pattern2_0 = arg1;
3556         let pattern3_0 = arg2;
3557         // Rule at src/isa/x64/inst.isle line 2149.
3558         let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?;
3559         return Some(expr0_0);
3560     }
3561     return None;
3562 }
3563 
3564 // Generated as internal constructor for term x64_pminsb.
3565 pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3566     let pattern0_0 = arg0;
3567     let pattern1_0 = arg1;
3568     // Rule at src/isa/x64/inst.isle line 2152.
3569     let expr0_0: Type = I8X16;
3570     let expr1_0 = SseOpcode::Pminsb;
3571     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3572     return Some(expr2_0);
3573 }
3574 
3575 // Generated as internal constructor for term x64_pminsw.
3576 pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3577     let pattern0_0 = arg0;
3578     let pattern1_0 = arg1;
3579     // Rule at src/isa/x64/inst.isle line 2154.
3580     let expr0_0: Type = I16X8;
3581     let expr1_0 = SseOpcode::Pminsw;
3582     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3583     return Some(expr2_0);
3584 }
3585 
3586 // Generated as internal constructor for term x64_pminsd.
3587 pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3588     let pattern0_0 = arg0;
3589     let pattern1_0 = arg1;
3590     // Rule at src/isa/x64/inst.isle line 2156.
3591     let expr0_0: Type = I32X4;
3592     let expr1_0 = SseOpcode::Pminsd;
3593     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3594     return Some(expr2_0);
3595 }
3596 
3597 // Generated as internal constructor for term x64_pmaxu.
3598 pub fn constructor_x64_pmaxu<C: Context>(
3599     ctx: &mut C,
3600     arg0: Type,
3601     arg1: Xmm,
3602     arg2: &XmmMem,
3603 ) -> Option<Xmm> {
3604     let pattern0_0 = arg0;
3605     if pattern0_0 == I8X16 {
3606         let pattern2_0 = arg1;
3607         let pattern3_0 = arg2;
3608         // Rule at src/isa/x64/inst.isle line 2160.
3609         let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?;
3610         return Some(expr0_0);
3611     }
3612     if pattern0_0 == I16X8 {
3613         let pattern2_0 = arg1;
3614         let pattern3_0 = arg2;
3615         // Rule at src/isa/x64/inst.isle line 2161.
3616         let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?;
3617         return Some(expr0_0);
3618     }
3619     if pattern0_0 == I32X4 {
3620         let pattern2_0 = arg1;
3621         let pattern3_0 = arg2;
3622         // Rule at src/isa/x64/inst.isle line 2162.
3623         let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?;
3624         return Some(expr0_0);
3625     }
3626     return None;
3627 }
3628 
3629 // Generated as internal constructor for term x64_pmaxub.
3630 pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3631     let pattern0_0 = arg0;
3632     let pattern1_0 = arg1;
3633     // Rule at src/isa/x64/inst.isle line 2165.
3634     let expr0_0: Type = I8X16;
3635     let expr1_0 = SseOpcode::Pmaxub;
3636     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3637     return Some(expr2_0);
3638 }
3639 
3640 // Generated as internal constructor for term x64_pmaxuw.
3641 pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3642     let pattern0_0 = arg0;
3643     let pattern1_0 = arg1;
3644     // Rule at src/isa/x64/inst.isle line 2167.
3645     let expr0_0: Type = I8X16;
3646     let expr1_0 = SseOpcode::Pmaxuw;
3647     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3648     return Some(expr2_0);
3649 }
3650 
3651 // Generated as internal constructor for term x64_pmaxud.
3652 pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3653     let pattern0_0 = arg0;
3654     let pattern1_0 = arg1;
3655     // Rule at src/isa/x64/inst.isle line 2169.
3656     let expr0_0: Type = I8X16;
3657     let expr1_0 = SseOpcode::Pmaxud;
3658     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3659     return Some(expr2_0);
3660 }
3661 
3662 // Generated as internal constructor for term x64_pminu.
3663 pub fn constructor_x64_pminu<C: Context>(
3664     ctx: &mut C,
3665     arg0: Type,
3666     arg1: Xmm,
3667     arg2: &XmmMem,
3668 ) -> Option<Xmm> {
3669     let pattern0_0 = arg0;
3670     if pattern0_0 == I8X16 {
3671         let pattern2_0 = arg1;
3672         let pattern3_0 = arg2;
3673         // Rule at src/isa/x64/inst.isle line 2173.
3674         let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?;
3675         return Some(expr0_0);
3676     }
3677     if pattern0_0 == I16X8 {
3678         let pattern2_0 = arg1;
3679         let pattern3_0 = arg2;
3680         // Rule at src/isa/x64/inst.isle line 2174.
3681         let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?;
3682         return Some(expr0_0);
3683     }
3684     if pattern0_0 == I32X4 {
3685         let pattern2_0 = arg1;
3686         let pattern3_0 = arg2;
3687         // Rule at src/isa/x64/inst.isle line 2175.
3688         let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?;
3689         return Some(expr0_0);
3690     }
3691     return None;
3692 }
3693 
3694 // Generated as internal constructor for term x64_pminub.
3695 pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3696     let pattern0_0 = arg0;
3697     let pattern1_0 = arg1;
3698     // Rule at src/isa/x64/inst.isle line 2178.
3699     let expr0_0: Type = I8X16;
3700     let expr1_0 = SseOpcode::Pminub;
3701     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3702     return Some(expr2_0);
3703 }
3704 
3705 // Generated as internal constructor for term x64_pminuw.
3706 pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3707     let pattern0_0 = arg0;
3708     let pattern1_0 = arg1;
3709     // Rule at src/isa/x64/inst.isle line 2180.
3710     let expr0_0: Type = I8X16;
3711     let expr1_0 = SseOpcode::Pminuw;
3712     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3713     return Some(expr2_0);
3714 }
3715 
3716 // Generated as internal constructor for term x64_pminud.
3717 pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3718     let pattern0_0 = arg0;
3719     let pattern1_0 = arg1;
3720     // Rule at src/isa/x64/inst.isle line 2182.
3721     let expr0_0: Type = I8X16;
3722     let expr1_0 = SseOpcode::Pminud;
3723     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3724     return Some(expr2_0);
3725 }
3726 
3727 // Generated as internal constructor for term x64_punpcklbw.
3728 pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3729     let pattern0_0 = arg0;
3730     let pattern1_0 = arg1;
3731     // Rule at src/isa/x64/inst.isle line 2186.
3732     let expr0_0: Type = I8X16;
3733     let expr1_0 = SseOpcode::Punpcklbw;
3734     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3735     return Some(expr2_0);
3736 }
3737 
3738 // Generated as internal constructor for term x64_punpckhbw.
3739 pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3740     let pattern0_0 = arg0;
3741     let pattern1_0 = arg1;
3742     // Rule at src/isa/x64/inst.isle line 2191.
3743     let expr0_0: Type = I8X16;
3744     let expr1_0 = SseOpcode::Punpckhbw;
3745     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3746     return Some(expr2_0);
3747 }
3748 
3749 // Generated as internal constructor for term x64_packsswb.
3750 pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3751     let pattern0_0 = arg0;
3752     let pattern1_0 = arg1;
3753     // Rule at src/isa/x64/inst.isle line 2196.
3754     let expr0_0: Type = I8X16;
3755     let expr1_0 = SseOpcode::Packsswb;
3756     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3757     return Some(expr2_0);
3758 }
3759 
3760 // Generated as internal constructor for term xmm_rm_r_imm.
3761 pub fn constructor_xmm_rm_r_imm<C: Context>(
3762     ctx: &mut C,
3763     arg0: &SseOpcode,
3764     arg1: Reg,
3765     arg2: &RegMem,
3766     arg3: u8,
3767     arg4: &OperandSize,
3768 ) -> Option<Xmm> {
3769     let pattern0_0 = arg0;
3770     let pattern1_0 = arg1;
3771     let pattern2_0 = arg2;
3772     let pattern3_0 = arg3;
3773     let pattern4_0 = arg4;
3774     // Rule at src/isa/x64/inst.isle line 2201.
3775     let expr0_0 = C::temp_writable_xmm(ctx);
3776     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3777     let expr2_0 = MInst::XmmRmRImm {
3778         op: pattern0_0.clone(),
3779         src1: pattern1_0,
3780         src2: pattern2_0.clone(),
3781         dst: expr1_0,
3782         imm: pattern3_0,
3783         size: pattern4_0.clone(),
3784     };
3785     let expr3_0 = C::emit(ctx, &expr2_0);
3786     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3787     return Some(expr4_0);
3788 }
3789 
3790 // Generated as internal constructor for term x64_palignr.
3791 pub fn constructor_x64_palignr<C: Context>(
3792     ctx: &mut C,
3793     arg0: Xmm,
3794     arg1: &XmmMem,
3795     arg2: u8,
3796     arg3: &OperandSize,
3797 ) -> Option<Xmm> {
3798     let pattern0_0 = arg0;
3799     let pattern1_0 = arg1;
3800     let pattern2_0 = arg2;
3801     let pattern3_0 = arg3;
3802     // Rule at src/isa/x64/inst.isle line 2213.
3803     let expr0_0 = SseOpcode::Palignr;
3804     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3805     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3806     let expr3_0 =
3807         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3808     return Some(expr3_0);
3809 }
3810 
3811 // Generated as internal constructor for term x64_cmpp.
3812 pub fn constructor_x64_cmpp<C: Context>(
3813     ctx: &mut C,
3814     arg0: Type,
3815     arg1: Xmm,
3816     arg2: &XmmMem,
3817     arg3: &FcmpImm,
3818 ) -> Option<Xmm> {
3819     let pattern0_0 = arg0;
3820     if pattern0_0 == F32X4 {
3821         let pattern2_0 = arg1;
3822         let pattern3_0 = arg2;
3823         let pattern4_0 = arg3;
3824         // Rule at src/isa/x64/inst.isle line 2222.
3825         let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3826         return Some(expr0_0);
3827     }
3828     if pattern0_0 == F64X2 {
3829         let pattern2_0 = arg1;
3830         let pattern3_0 = arg2;
3831         let pattern4_0 = arg3;
3832         // Rule at src/isa/x64/inst.isle line 2223.
3833         let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3834         return Some(expr0_0);
3835     }
3836     return None;
3837 }
3838 
3839 // Generated as internal constructor for term x64_cmpps.
3840 pub fn constructor_x64_cmpps<C: Context>(
3841     ctx: &mut C,
3842     arg0: Xmm,
3843     arg1: &XmmMem,
3844     arg2: &FcmpImm,
3845 ) -> Option<Xmm> {
3846     let pattern0_0 = arg0;
3847     let pattern1_0 = arg1;
3848     let pattern2_0 = arg2;
3849     // Rule at src/isa/x64/inst.isle line 2226.
3850     let expr0_0 = SseOpcode::Cmpps;
3851     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3852     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3853     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3854     let expr4_0 = OperandSize::Size32;
3855     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3856     return Some(expr5_0);
3857 }
3858 
3859 // Generated as internal constructor for term x64_cmppd.
3860 pub fn constructor_x64_cmppd<C: Context>(
3861     ctx: &mut C,
3862     arg0: Xmm,
3863     arg1: &XmmMem,
3864     arg2: &FcmpImm,
3865 ) -> Option<Xmm> {
3866     let pattern0_0 = arg0;
3867     let pattern1_0 = arg1;
3868     let pattern2_0 = arg2;
3869     // Rule at src/isa/x64/inst.isle line 2237.
3870     let expr0_0 = SseOpcode::Cmppd;
3871     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3872     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3873     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3874     let expr4_0 = OperandSize::Size32;
3875     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3876     return Some(expr5_0);
3877 }
3878 
3879 // Generated as internal constructor for term x64_pinsrb.
3880 pub fn constructor_x64_pinsrb<C: Context>(
3881     ctx: &mut C,
3882     arg0: Xmm,
3883     arg1: &GprMem,
3884     arg2: u8,
3885 ) -> Option<Xmm> {
3886     let pattern0_0 = arg0;
3887     let pattern1_0 = arg1;
3888     let pattern2_0 = arg2;
3889     // Rule at src/isa/x64/inst.isle line 2246.
3890     let expr0_0 = SseOpcode::Pinsrb;
3891     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3892     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3893     let expr3_0 = OperandSize::Size32;
3894     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3895     return Some(expr4_0);
3896 }
3897 
3898 // Generated as internal constructor for term x64_pinsrw.
3899 pub fn constructor_x64_pinsrw<C: Context>(
3900     ctx: &mut C,
3901     arg0: Xmm,
3902     arg1: &GprMem,
3903     arg2: u8,
3904 ) -> Option<Xmm> {
3905     let pattern0_0 = arg0;
3906     let pattern1_0 = arg1;
3907     let pattern2_0 = arg2;
3908     // Rule at src/isa/x64/inst.isle line 2255.
3909     let expr0_0 = SseOpcode::Pinsrw;
3910     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3911     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3912     let expr3_0 = OperandSize::Size32;
3913     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3914     return Some(expr4_0);
3915 }
3916 
3917 // Generated as internal constructor for term x64_pinsrd.
3918 pub fn constructor_x64_pinsrd<C: Context>(
3919     ctx: &mut C,
3920     arg0: Xmm,
3921     arg1: &GprMem,
3922     arg2: u8,
3923     arg3: &OperandSize,
3924 ) -> Option<Xmm> {
3925     let pattern0_0 = arg0;
3926     let pattern1_0 = arg1;
3927     let pattern2_0 = arg2;
3928     let pattern3_0 = arg3;
3929     // Rule at src/isa/x64/inst.isle line 2264.
3930     let expr0_0 = SseOpcode::Pinsrd;
3931     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3932     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3933     let expr3_0 =
3934         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3935     return Some(expr3_0);
3936 }
3937 
3938 // Generated as internal constructor for term x64_pmaddwd.
3939 pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3940     let pattern0_0 = arg0;
3941     let pattern1_0 = arg1;
3942     // Rule at src/isa/x64/inst.isle line 2273.
3943     let expr0_0 = C::temp_writable_xmm(ctx);
3944     let expr1_0 = SseOpcode::Pmaddwd;
3945     let expr2_0 = MInst::XmmRmR {
3946         op: expr1_0,
3947         src1: pattern0_0,
3948         src2: pattern1_0.clone(),
3949         dst: expr0_0,
3950     };
3951     let expr3_0 = C::emit(ctx, &expr2_0);
3952     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3953     return Some(expr4_0);
3954 }
3955 
3956 // Generated as internal constructor for term x64_insertps.
3957 pub fn constructor_x64_insertps<C: Context>(
3958     ctx: &mut C,
3959     arg0: Xmm,
3960     arg1: &XmmMem,
3961     arg2: u8,
3962 ) -> Option<Xmm> {
3963     let pattern0_0 = arg0;
3964     let pattern1_0 = arg1;
3965     let pattern2_0 = arg2;
3966     // Rule at src/isa/x64/inst.isle line 2283.
3967     let expr0_0 = SseOpcode::Insertps;
3968     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3969     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3970     let expr3_0 = OperandSize::Size32;
3971     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3972     return Some(expr4_0);
3973 }
3974 
3975 // Generated as internal constructor for term x64_pshufd.
3976 pub fn constructor_x64_pshufd<C: Context>(
3977     ctx: &mut C,
3978     arg0: &XmmMem,
3979     arg1: u8,
3980     arg2: &OperandSize,
3981 ) -> Option<Xmm> {
3982     let pattern0_0 = arg0;
3983     let pattern1_0 = arg1;
3984     let pattern2_0 = arg2;
3985     // Rule at src/isa/x64/inst.isle line 2292.
3986     let expr0_0 = C::temp_writable_xmm(ctx);
3987     let expr1_0 = SseOpcode::Pshufd;
3988     let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
3989     let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0);
3990     let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3991     let expr5_0 = MInst::XmmRmRImm {
3992         op: expr1_0,
3993         src1: expr2_0,
3994         src2: expr3_0,
3995         dst: expr4_0,
3996         imm: pattern1_0,
3997         size: pattern2_0.clone(),
3998     };
3999     let expr6_0 = C::emit(ctx, &expr5_0);
4000     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4001     return Some(expr7_0);
4002 }
4003 
4004 // Generated as internal constructor for term x64_pshufb.
4005 pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4006     let pattern0_0 = arg0;
4007     let pattern1_0 = arg1;
4008     // Rule at src/isa/x64/inst.isle line 2304.
4009     let expr0_0 = C::temp_writable_xmm(ctx);
4010     let expr1_0 = SseOpcode::Pshufb;
4011     let expr2_0 = MInst::XmmRmR {
4012         op: expr1_0,
4013         src1: pattern0_0,
4014         src2: pattern1_0.clone(),
4015         dst: expr0_0,
4016     };
4017     let expr3_0 = C::emit(ctx, &expr2_0);
4018     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4019     return Some(expr4_0);
4020 }
4021 
4022 // Generated as internal constructor for term xmm_unary_rm_r.
4023 pub fn constructor_xmm_unary_rm_r<C: Context>(
4024     ctx: &mut C,
4025     arg0: &SseOpcode,
4026     arg1: &XmmMem,
4027 ) -> Option<Xmm> {
4028     let pattern0_0 = arg0;
4029     let pattern1_0 = arg1;
4030     // Rule at src/isa/x64/inst.isle line 2314.
4031     let expr0_0 = C::temp_writable_xmm(ctx);
4032     let expr1_0 = MInst::XmmUnaryRmR {
4033         op: pattern0_0.clone(),
4034         src: pattern1_0.clone(),
4035         dst: expr0_0,
4036     };
4037     let expr2_0 = C::emit(ctx, &expr1_0);
4038     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4039     return Some(expr3_0);
4040 }
4041 
4042 // Generated as internal constructor for term x64_pabsb.
4043 pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4044     let pattern0_0 = arg0;
4045     // Rule at src/isa/x64/inst.isle line 2321.
4046     let expr0_0 = SseOpcode::Pabsb;
4047     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4048     return Some(expr1_0);
4049 }
4050 
4051 // Generated as internal constructor for term x64_pabsw.
4052 pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4053     let pattern0_0 = arg0;
4054     // Rule at src/isa/x64/inst.isle line 2326.
4055     let expr0_0 = SseOpcode::Pabsw;
4056     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4057     return Some(expr1_0);
4058 }
4059 
4060 // Generated as internal constructor for term x64_pabsd.
4061 pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4062     let pattern0_0 = arg0;
4063     // Rule at src/isa/x64/inst.isle line 2331.
4064     let expr0_0 = SseOpcode::Pabsd;
4065     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4066     return Some(expr1_0);
4067 }
4068 
4069 // Generated as internal constructor for term xmm_unary_rm_r_evex.
4070 pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
4071     ctx: &mut C,
4072     arg0: &Avx512Opcode,
4073     arg1: &XmmMem,
4074 ) -> Option<Xmm> {
4075     let pattern0_0 = arg0;
4076     let pattern1_0 = arg1;
4077     // Rule at src/isa/x64/inst.isle line 2336.
4078     let expr0_0 = C::temp_writable_xmm(ctx);
4079     let expr1_0 = MInst::XmmUnaryRmREvex {
4080         op: pattern0_0.clone(),
4081         src: pattern1_0.clone(),
4082         dst: expr0_0,
4083     };
4084     let expr2_0 = C::emit(ctx, &expr1_0);
4085     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4086     return Some(expr3_0);
4087 }
4088 
4089 // Generated as internal constructor for term x64_vpabsq.
4090 pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4091     let pattern0_0 = arg0;
4092     // Rule at src/isa/x64/inst.isle line 2343.
4093     let expr0_0 = Avx512Opcode::Vpabsq;
4094     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4095     return Some(expr1_0);
4096 }
4097 
4098 // Generated as internal constructor for term x64_vpopcntb.
4099 pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4100     let pattern0_0 = arg0;
4101     // Rule at src/isa/x64/inst.isle line 2348.
4102     let expr0_0 = Avx512Opcode::Vpopcntb;
4103     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4104     return Some(expr1_0);
4105 }
4106 
4107 // Generated as internal constructor for term xmm_rm_r_evex.
4108 pub fn constructor_xmm_rm_r_evex<C: Context>(
4109     ctx: &mut C,
4110     arg0: &Avx512Opcode,
4111     arg1: &XmmMem,
4112     arg2: Xmm,
4113 ) -> Option<Xmm> {
4114     let pattern0_0 = arg0;
4115     let pattern1_0 = arg1;
4116     let pattern2_0 = arg2;
4117     // Rule at src/isa/x64/inst.isle line 2353.
4118     let expr0_0 = C::temp_writable_xmm(ctx);
4119     let expr1_0 = MInst::XmmRmREvex {
4120         op: pattern0_0.clone(),
4121         src1: pattern1_0.clone(),
4122         src2: pattern2_0,
4123         dst: expr0_0,
4124     };
4125     let expr2_0 = C::emit(ctx, &expr1_0);
4126     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4127     return Some(expr3_0);
4128 }
4129 
4130 // Generated as internal constructor for term x64_vpmullq.
4131 pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option<Xmm> {
4132     let pattern0_0 = arg0;
4133     let pattern1_0 = arg1;
4134     // Rule at src/isa/x64/inst.isle line 2365.
4135     let expr0_0 = Avx512Opcode::Vpmullq;
4136     let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4137     return Some(expr1_0);
4138 }
4139 
4140 // Generated as internal constructor for term mul_hi.
4141 pub fn constructor_mul_hi<C: Context>(
4142     ctx: &mut C,
4143     arg0: Type,
4144     arg1: bool,
4145     arg2: Gpr,
4146     arg3: &GprMem,
4147 ) -> Option<ValueRegs> {
4148     let pattern0_0 = arg0;
4149     let pattern1_0 = arg1;
4150     let pattern2_0 = arg2;
4151     let pattern3_0 = arg3;
4152     // Rule at src/isa/x64/inst.isle line 2374.
4153     let expr0_0 = C::temp_writable_gpr(ctx);
4154     let expr1_0 = C::temp_writable_gpr(ctx);
4155     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4156     let expr3_0 = MInst::MulHi {
4157         size: expr2_0,
4158         signed: pattern1_0,
4159         src1: pattern2_0,
4160         src2: pattern3_0.clone(),
4161         dst_lo: expr0_0,
4162         dst_hi: expr1_0,
4163     };
4164     let expr4_0 = C::emit(ctx, &expr3_0);
4165     let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4166     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
4167     let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?;
4168     return Some(expr7_0);
4169 }
4170 
4171 // Generated as internal constructor for term mulhi_u.
4172 pub fn constructor_mulhi_u<C: Context>(
4173     ctx: &mut C,
4174     arg0: Type,
4175     arg1: Gpr,
4176     arg2: &GprMem,
4177 ) -> Option<ValueRegs> {
4178     let pattern0_0 = arg0;
4179     let pattern1_0 = arg1;
4180     let pattern2_0 = arg2;
4181     // Rule at src/isa/x64/inst.isle line 2389.
4182     let expr0_0: bool = false;
4183     let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?;
4184     return Some(expr1_0);
4185 }
4186 
4187 // Generated as internal constructor for term xmm_rmi_xmm.
4188 pub fn constructor_xmm_rmi_xmm<C: Context>(
4189     ctx: &mut C,
4190     arg0: &SseOpcode,
4191     arg1: Xmm,
4192     arg2: &XmmMemImm,
4193 ) -> Option<Xmm> {
4194     let pattern0_0 = arg0;
4195     let pattern1_0 = arg1;
4196     let pattern2_0 = arg2;
4197     // Rule at src/isa/x64/inst.isle line 2394.
4198     let expr0_0 = C::temp_writable_xmm(ctx);
4199     let expr1_0 = MInst::XmmRmiReg {
4200         opcode: pattern0_0.clone(),
4201         src1: pattern1_0,
4202         src2: pattern2_0.clone(),
4203         dst: expr0_0,
4204     };
4205     let expr2_0 = C::emit(ctx, &expr1_0);
4206     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4207     return Some(expr3_0);
4208 }
4209 
4210 // Generated as internal constructor for term x64_psllw.
4211 pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4212     let pattern0_0 = arg0;
4213     let pattern1_0 = arg1;
4214     // Rule at src/isa/x64/inst.isle line 2404.
4215     let expr0_0 = SseOpcode::Psllw;
4216     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4217     return Some(expr1_0);
4218 }
4219 
4220 // Generated as internal constructor for term x64_pslld.
4221 pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4222     let pattern0_0 = arg0;
4223     let pattern1_0 = arg1;
4224     // Rule at src/isa/x64/inst.isle line 2409.
4225     let expr0_0 = SseOpcode::Pslld;
4226     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4227     return Some(expr1_0);
4228 }
4229 
4230 // Generated as internal constructor for term x64_psllq.
4231 pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4232     let pattern0_0 = arg0;
4233     let pattern1_0 = arg1;
4234     // Rule at src/isa/x64/inst.isle line 2414.
4235     let expr0_0 = SseOpcode::Psllq;
4236     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4237     return Some(expr1_0);
4238 }
4239 
4240 // Generated as internal constructor for term x64_psrlw.
4241 pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4242     let pattern0_0 = arg0;
4243     let pattern1_0 = arg1;
4244     // Rule at src/isa/x64/inst.isle line 2419.
4245     let expr0_0 = SseOpcode::Psrlw;
4246     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4247     return Some(expr1_0);
4248 }
4249 
4250 // Generated as internal constructor for term x64_psrld.
4251 pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4252     let pattern0_0 = arg0;
4253     let pattern1_0 = arg1;
4254     // Rule at src/isa/x64/inst.isle line 2424.
4255     let expr0_0 = SseOpcode::Psrld;
4256     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4257     return Some(expr1_0);
4258 }
4259 
4260 // Generated as internal constructor for term x64_psrlq.
4261 pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4262     let pattern0_0 = arg0;
4263     let pattern1_0 = arg1;
4264     // Rule at src/isa/x64/inst.isle line 2429.
4265     let expr0_0 = SseOpcode::Psrlq;
4266     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4267     return Some(expr1_0);
4268 }
4269 
4270 // Generated as internal constructor for term x64_psraw.
4271 pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4272     let pattern0_0 = arg0;
4273     let pattern1_0 = arg1;
4274     // Rule at src/isa/x64/inst.isle line 2434.
4275     let expr0_0 = SseOpcode::Psraw;
4276     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4277     return Some(expr1_0);
4278 }
4279 
4280 // Generated as internal constructor for term x64_psrad.
4281 pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4282     let pattern0_0 = arg0;
4283     let pattern1_0 = arg1;
4284     // Rule at src/isa/x64/inst.isle line 2439.
4285     let expr0_0 = SseOpcode::Psrad;
4286     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4287     return Some(expr1_0);
4288 }
4289 
4290 // Generated as internal constructor for term x64_pextrd.
4291 pub fn constructor_x64_pextrd<C: Context>(
4292     ctx: &mut C,
4293     arg0: Type,
4294     arg1: Xmm,
4295     arg2: u8,
4296 ) -> Option<Gpr> {
4297     let pattern0_0 = arg0;
4298     let pattern1_0 = arg1;
4299     let pattern2_0 = arg2;
4300     // Rule at src/isa/x64/inst.isle line 2444.
4301     let expr0_0 = C::temp_writable_gpr(ctx);
4302     let expr1_0 = SseOpcode::Pextrd;
4303     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4304     let expr3_0 = C::xmm_to_reg(ctx, pattern1_0);
4305     let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?;
4306     let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0);
4307     let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0);
4308     let expr7_0 = C::lane_type(ctx, pattern0_0);
4309     let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0);
4310     let expr9_0 = MInst::XmmRmRImm {
4311         op: expr1_0,
4312         src1: expr2_0,
4313         src2: expr5_0,
4314         dst: expr6_0,
4315         imm: pattern2_0,
4316         size: expr8_0,
4317     };
4318     let expr10_0 = C::emit(ctx, &expr9_0);
4319     let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4320     return Some(expr11_0);
4321 }
4322 
4323 // Generated as internal constructor for term gpr_to_xmm.
4324 pub fn constructor_gpr_to_xmm<C: Context>(
4325     ctx: &mut C,
4326     arg0: &SseOpcode,
4327     arg1: &GprMem,
4328     arg2: &OperandSize,
4329 ) -> Option<Xmm> {
4330     let pattern0_0 = arg0;
4331     let pattern1_0 = arg1;
4332     let pattern2_0 = arg2;
4333     // Rule at src/isa/x64/inst.isle line 2456.
4334     let expr0_0 = C::temp_writable_xmm(ctx);
4335     let expr1_0 = MInst::GprToXmm {
4336         op: pattern0_0.clone(),
4337         src: pattern1_0.clone(),
4338         dst: expr0_0,
4339         src_size: pattern2_0.clone(),
4340     };
4341     let expr2_0 = C::emit(ctx, &expr1_0);
4342     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4343     return Some(expr3_0);
4344 }
4345 
4346 // Generated as internal constructor for term x64_not.
4347 pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4348     let pattern0_0 = arg0;
4349     let pattern1_0 = arg1;
4350     // Rule at src/isa/x64/inst.isle line 2463.
4351     let expr0_0 = C::temp_writable_gpr(ctx);
4352     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4353     let expr2_0 = MInst::Not {
4354         size: expr1_0,
4355         src: pattern1_0,
4356         dst: expr0_0,
4357     };
4358     let expr3_0 = C::emit(ctx, &expr2_0);
4359     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4360     return Some(expr4_0);
4361 }
4362 
4363 // Generated as internal constructor for term x64_neg.
4364 pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4365     let pattern0_0 = arg0;
4366     let pattern1_0 = arg1;
4367     // Rule at src/isa/x64/inst.isle line 2471.
4368     let expr0_0 = C::temp_writable_gpr(ctx);
4369     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4370     let expr2_0 = MInst::Neg {
4371         size: expr1_0,
4372         src: pattern1_0,
4373         dst: expr0_0,
4374     };
4375     let expr3_0 = C::emit(ctx, &expr2_0);
4376     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4377     return Some(expr4_0);
4378 }
4379 
4380 // Generated as internal constructor for term x64_lea.
4381 pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Option<Gpr> {
4382     let pattern0_0 = arg0;
4383     // Rule at src/isa/x64/inst.isle line 2478.
4384     let expr0_0 = C::temp_writable_gpr(ctx);
4385     let expr1_0 = MInst::LoadEffectiveAddress {
4386         addr: pattern0_0.clone(),
4387         dst: expr0_0,
4388     };
4389     let expr2_0 = C::emit(ctx, &expr1_0);
4390     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4391     return Some(expr3_0);
4392 }
4393 
4394 // Generated as internal constructor for term x64_ud2.
4395 pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> Option<SideEffectNoResult> {
4396     let pattern0_0 = arg0;
4397     // Rule at src/isa/x64/inst.isle line 2485.
4398     let expr0_0 = MInst::Ud2 {
4399         trap_code: pattern0_0.clone(),
4400     };
4401     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4402     return Some(expr1_0);
4403 }
4404 
4405 // Generated as internal constructor for term x64_hlt.
4406 pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> Option<SideEffectNoResult> {
4407     // Rule at src/isa/x64/inst.isle line 2490.
4408     let expr0_0 = MInst::Hlt;
4409     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4410     return Some(expr1_0);
4411 }
4412 
4413 // Generated as internal constructor for term x64_lzcnt.
4414 pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4415     let pattern0_0 = arg0;
4416     let pattern1_0 = arg1;
4417     // Rule at src/isa/x64/inst.isle line 2495.
4418     let expr0_0 = C::temp_writable_gpr(ctx);
4419     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4420     let expr2_0 = UnaryRmROpcode::Lzcnt;
4421     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4422     let expr4_0 = MInst::UnaryRmR {
4423         size: expr1_0,
4424         op: expr2_0,
4425         src: expr3_0,
4426         dst: expr0_0,
4427     };
4428     let expr5_0 = C::emit(ctx, &expr4_0);
4429     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4430     return Some(expr6_0);
4431 }
4432 
4433 // Generated as internal constructor for term x64_tzcnt.
4434 pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4435     let pattern0_0 = arg0;
4436     let pattern1_0 = arg1;
4437     // Rule at src/isa/x64/inst.isle line 2503.
4438     let expr0_0 = C::temp_writable_gpr(ctx);
4439     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4440     let expr2_0 = UnaryRmROpcode::Tzcnt;
4441     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4442     let expr4_0 = MInst::UnaryRmR {
4443         size: expr1_0,
4444         op: expr2_0,
4445         src: expr3_0,
4446         dst: expr0_0,
4447     };
4448     let expr5_0 = C::emit(ctx, &expr4_0);
4449     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4450     return Some(expr6_0);
4451 }
4452 
4453 // Generated as internal constructor for term x64_bsr.
4454 pub fn constructor_x64_bsr<C: Context>(
4455     ctx: &mut C,
4456     arg0: Type,
4457     arg1: Gpr,
4458 ) -> Option<ProducesFlags> {
4459     let pattern0_0 = arg0;
4460     let pattern1_0 = arg1;
4461     // Rule at src/isa/x64/inst.isle line 2511.
4462     let expr0_0 = C::temp_writable_gpr(ctx);
4463     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4464     let expr2_0 = UnaryRmROpcode::Bsr;
4465     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4466     let expr4_0 = MInst::UnaryRmR {
4467         size: expr1_0,
4468         op: expr2_0,
4469         src: expr3_0,
4470         dst: expr0_0,
4471     };
4472     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4473     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4474         inst: expr4_0,
4475         result: expr5_0,
4476     };
4477     return Some(expr6_0);
4478 }
4479 
4480 // Generated as internal constructor for term bsr_or_else.
4481 pub fn constructor_bsr_or_else<C: Context>(
4482     ctx: &mut C,
4483     arg0: Type,
4484     arg1: Gpr,
4485     arg2: Gpr,
4486 ) -> Option<Gpr> {
4487     let pattern0_0 = arg0;
4488     let pattern1_0 = arg1;
4489     let pattern2_0 = arg2;
4490     // Rule at src/isa/x64/inst.isle line 2520.
4491     let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?;
4492     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4493     let expr2_0 = C::gpr_new(ctx, expr1_0);
4494     let expr3_0 = CC::Z;
4495     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4496     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4497     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4498     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4499     let expr8_0 = C::gpr_new(ctx, expr7_0);
4500     return Some(expr8_0);
4501 }
4502 
4503 // Generated as internal constructor for term x64_bsf.
4504 pub fn constructor_x64_bsf<C: Context>(
4505     ctx: &mut C,
4506     arg0: Type,
4507     arg1: Gpr,
4508 ) -> Option<ProducesFlags> {
4509     let pattern0_0 = arg0;
4510     let pattern1_0 = arg1;
4511     // Rule at src/isa/x64/inst.isle line 2531.
4512     let expr0_0 = C::temp_writable_gpr(ctx);
4513     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4514     let expr2_0 = UnaryRmROpcode::Bsf;
4515     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4516     let expr4_0 = MInst::UnaryRmR {
4517         size: expr1_0,
4518         op: expr2_0,
4519         src: expr3_0,
4520         dst: expr0_0,
4521     };
4522     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4523     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4524         inst: expr4_0,
4525         result: expr5_0,
4526     };
4527     return Some(expr6_0);
4528 }
4529 
4530 // Generated as internal constructor for term bsf_or_else.
4531 pub fn constructor_bsf_or_else<C: Context>(
4532     ctx: &mut C,
4533     arg0: Type,
4534     arg1: Gpr,
4535     arg2: Gpr,
4536 ) -> Option<Gpr> {
4537     let pattern0_0 = arg0;
4538     let pattern1_0 = arg1;
4539     let pattern2_0 = arg2;
4540     // Rule at src/isa/x64/inst.isle line 2540.
4541     let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?;
4542     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4543     let expr2_0 = C::gpr_new(ctx, expr1_0);
4544     let expr3_0 = CC::Z;
4545     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4546     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4547     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4548     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4549     let expr8_0 = C::gpr_new(ctx, expr7_0);
4550     return Some(expr8_0);
4551 }
4552 
4553 // Generated as internal constructor for term x64_popcnt.
4554 pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4555     let pattern0_0 = arg0;
4556     let pattern1_0 = arg1;
4557     // Rule at src/isa/x64/inst.isle line 2551.
4558     let expr0_0 = C::temp_writable_gpr(ctx);
4559     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4560     let expr2_0 = UnaryRmROpcode::Popcnt;
4561     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4562     let expr4_0 = MInst::UnaryRmR {
4563         size: expr1_0,
4564         op: expr2_0,
4565         src: expr3_0,
4566         dst: expr0_0,
4567     };
4568     let expr5_0 = C::emit(ctx, &expr4_0);
4569     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4570     return Some(expr6_0);
4571 }
4572 
4573 // Generated as internal constructor for term xmm_min_max_seq.
4574 pub fn constructor_xmm_min_max_seq<C: Context>(
4575     ctx: &mut C,
4576     arg0: Type,
4577     arg1: bool,
4578     arg2: Xmm,
4579     arg3: Xmm,
4580 ) -> Option<Xmm> {
4581     let pattern0_0 = arg0;
4582     let pattern1_0 = arg1;
4583     let pattern2_0 = arg2;
4584     let pattern3_0 = arg3;
4585     // Rule at src/isa/x64/inst.isle line 2559.
4586     let expr0_0 = C::temp_writable_xmm(ctx);
4587     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4588     let expr2_0 = MInst::XmmMinMaxSeq {
4589         size: expr1_0,
4590         is_min: pattern1_0,
4591         lhs: pattern2_0,
4592         rhs: pattern3_0,
4593         dst: expr0_0,
4594     };
4595     let expr3_0 = C::emit(ctx, &expr2_0);
4596     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4597     return Some(expr4_0);
4598 }
4599 
4600 // Generated as internal constructor for term x64_minss.
4601 pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4602     let pattern0_0 = arg0;
4603     let pattern1_0 = arg1;
4604     // Rule at src/isa/x64/inst.isle line 2567.
4605     let expr0_0 = C::temp_writable_xmm(ctx);
4606     let expr1_0 = SseOpcode::Minss;
4607     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4608     let expr3_0 = MInst::XmmRmR {
4609         op: expr1_0,
4610         src1: pattern0_0,
4611         src2: expr2_0,
4612         dst: expr0_0,
4613     };
4614     let expr4_0 = C::emit(ctx, &expr3_0);
4615     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4616     return Some(expr5_0);
4617 }
4618 
4619 // Generated as internal constructor for term x64_minsd.
4620 pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4621     let pattern0_0 = arg0;
4622     let pattern1_0 = arg1;
4623     // Rule at src/isa/x64/inst.isle line 2574.
4624     let expr0_0 = C::temp_writable_xmm(ctx);
4625     let expr1_0 = SseOpcode::Minsd;
4626     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4627     let expr3_0 = MInst::XmmRmR {
4628         op: expr1_0,
4629         src1: pattern0_0,
4630         src2: expr2_0,
4631         dst: expr0_0,
4632     };
4633     let expr4_0 = C::emit(ctx, &expr3_0);
4634     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4635     return Some(expr5_0);
4636 }
4637 
4638 // Generated as internal constructor for term x64_minps.
4639 pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4640     let pattern0_0 = arg0;
4641     let pattern1_0 = arg1;
4642     // Rule at src/isa/x64/inst.isle line 2582.
4643     let expr0_0 = C::temp_writable_xmm(ctx);
4644     let expr1_0 = SseOpcode::Minps;
4645     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4646     let expr3_0 = MInst::XmmRmR {
4647         op: expr1_0,
4648         src1: pattern0_0,
4649         src2: expr2_0,
4650         dst: expr0_0,
4651     };
4652     let expr4_0 = C::emit(ctx, &expr3_0);
4653     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4654     return Some(expr5_0);
4655 }
4656 
4657 // Generated as internal constructor for term x64_minpd.
4658 pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4659     let pattern0_0 = arg0;
4660     let pattern1_0 = arg1;
4661     // Rule at src/isa/x64/inst.isle line 2589.
4662     let expr0_0 = C::temp_writable_xmm(ctx);
4663     let expr1_0 = SseOpcode::Minpd;
4664     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4665     let expr3_0 = MInst::XmmRmR {
4666         op: expr1_0,
4667         src1: pattern0_0,
4668         src2: expr2_0,
4669         dst: expr0_0,
4670     };
4671     let expr4_0 = C::emit(ctx, &expr3_0);
4672     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4673     return Some(expr5_0);
4674 }
4675 
4676 // Generated as internal constructor for term x64_maxss.
4677 pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4678     let pattern0_0 = arg0;
4679     let pattern1_0 = arg1;
4680     // Rule at src/isa/x64/inst.isle line 2596.
4681     let expr0_0 = C::temp_writable_xmm(ctx);
4682     let expr1_0 = SseOpcode::Maxss;
4683     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4684     let expr3_0 = MInst::XmmRmR {
4685         op: expr1_0,
4686         src1: pattern0_0,
4687         src2: expr2_0,
4688         dst: expr0_0,
4689     };
4690     let expr4_0 = C::emit(ctx, &expr3_0);
4691     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4692     return Some(expr5_0);
4693 }
4694 
4695 // Generated as internal constructor for term x64_maxsd.
4696 pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4697     let pattern0_0 = arg0;
4698     let pattern1_0 = arg1;
4699     // Rule at src/isa/x64/inst.isle line 2603.
4700     let expr0_0 = C::temp_writable_xmm(ctx);
4701     let expr1_0 = SseOpcode::Maxsd;
4702     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4703     let expr3_0 = MInst::XmmRmR {
4704         op: expr1_0,
4705         src1: pattern0_0,
4706         src2: expr2_0,
4707         dst: expr0_0,
4708     };
4709     let expr4_0 = C::emit(ctx, &expr3_0);
4710     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4711     return Some(expr5_0);
4712 }
4713 
4714 // Generated as internal constructor for term x64_maxps.
4715 pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4716     let pattern0_0 = arg0;
4717     let pattern1_0 = arg1;
4718     // Rule at src/isa/x64/inst.isle line 2610.
4719     let expr0_0 = C::temp_writable_xmm(ctx);
4720     let expr1_0 = SseOpcode::Maxps;
4721     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4722     let expr3_0 = MInst::XmmRmR {
4723         op: expr1_0,
4724         src1: pattern0_0,
4725         src2: expr2_0,
4726         dst: expr0_0,
4727     };
4728     let expr4_0 = C::emit(ctx, &expr3_0);
4729     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4730     return Some(expr5_0);
4731 }
4732 
4733 // Generated as internal constructor for term x64_maxpd.
4734 pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4735     let pattern0_0 = arg0;
4736     let pattern1_0 = arg1;
4737     // Rule at src/isa/x64/inst.isle line 2617.
4738     let expr0_0 = C::temp_writable_xmm(ctx);
4739     let expr1_0 = SseOpcode::Maxpd;
4740     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4741     let expr3_0 = MInst::XmmRmR {
4742         op: expr1_0,
4743         src1: pattern0_0,
4744         src2: expr2_0,
4745         dst: expr0_0,
4746     };
4747     let expr4_0 = C::emit(ctx, &expr3_0);
4748     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4749     return Some(expr5_0);
4750 }
4751 
4752 // Generated as internal constructor for term x64_pcmpeq.
4753 pub fn constructor_x64_pcmpeq<C: Context>(
4754     ctx: &mut C,
4755     arg0: Type,
4756     arg1: Xmm,
4757     arg2: &XmmMem,
4758 ) -> Option<Xmm> {
4759     let pattern0_0 = arg0;
4760     if pattern0_0 == I8X16 {
4761         let pattern2_0 = arg1;
4762         let pattern3_0 = arg2;
4763         // Rule at src/isa/x64/inst.isle line 2624.
4764         let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?;
4765         return Some(expr0_0);
4766     }
4767     if pattern0_0 == I16X8 {
4768         let pattern2_0 = arg1;
4769         let pattern3_0 = arg2;
4770         // Rule at src/isa/x64/inst.isle line 2625.
4771         let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?;
4772         return Some(expr0_0);
4773     }
4774     if pattern0_0 == I32X4 {
4775         let pattern2_0 = arg1;
4776         let pattern3_0 = arg2;
4777         // Rule at src/isa/x64/inst.isle line 2626.
4778         let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?;
4779         return Some(expr0_0);
4780     }
4781     if pattern0_0 == I64X2 {
4782         let pattern2_0 = arg1;
4783         let pattern3_0 = arg2;
4784         // Rule at src/isa/x64/inst.isle line 2627.
4785         let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?;
4786         return Some(expr0_0);
4787     }
4788     return None;
4789 }
4790 
4791 // Generated as internal constructor for term x64_pcmpeqb.
4792 pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4793     let pattern0_0 = arg0;
4794     let pattern1_0 = arg1;
4795     // Rule at src/isa/x64/inst.isle line 2630.
4796     let expr0_0: Type = I8X16;
4797     let expr1_0 = SseOpcode::Pcmpeqb;
4798     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4799     return Some(expr2_0);
4800 }
4801 
4802 // Generated as internal constructor for term x64_pcmpeqw.
4803 pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4804     let pattern0_0 = arg0;
4805     let pattern1_0 = arg1;
4806     // Rule at src/isa/x64/inst.isle line 2632.
4807     let expr0_0: Type = I16X8;
4808     let expr1_0 = SseOpcode::Pcmpeqw;
4809     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4810     return Some(expr2_0);
4811 }
4812 
4813 // Generated as internal constructor for term x64_pcmpeqd.
4814 pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4815     let pattern0_0 = arg0;
4816     let pattern1_0 = arg1;
4817     // Rule at src/isa/x64/inst.isle line 2634.
4818     let expr0_0: Type = I32X4;
4819     let expr1_0 = SseOpcode::Pcmpeqd;
4820     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4821     return Some(expr2_0);
4822 }
4823 
4824 // Generated as internal constructor for term x64_pcmpeqq.
4825 pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4826     let pattern0_0 = arg0;
4827     let pattern1_0 = arg1;
4828     // Rule at src/isa/x64/inst.isle line 2636.
4829     let expr0_0: Type = I64X2;
4830     let expr1_0 = SseOpcode::Pcmpeqq;
4831     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4832     return Some(expr2_0);
4833 }
4834 
4835 // Generated as internal constructor for term x64_pcmpgt.
4836 pub fn constructor_x64_pcmpgt<C: Context>(
4837     ctx: &mut C,
4838     arg0: Type,
4839     arg1: Xmm,
4840     arg2: &XmmMem,
4841 ) -> Option<Xmm> {
4842     let pattern0_0 = arg0;
4843     if pattern0_0 == I8X16 {
4844         let pattern2_0 = arg1;
4845         let pattern3_0 = arg2;
4846         // Rule at src/isa/x64/inst.isle line 2640.
4847         let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?;
4848         return Some(expr0_0);
4849     }
4850     if pattern0_0 == I16X8 {
4851         let pattern2_0 = arg1;
4852         let pattern3_0 = arg2;
4853         // Rule at src/isa/x64/inst.isle line 2641.
4854         let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?;
4855         return Some(expr0_0);
4856     }
4857     if pattern0_0 == I32X4 {
4858         let pattern2_0 = arg1;
4859         let pattern3_0 = arg2;
4860         // Rule at src/isa/x64/inst.isle line 2642.
4861         let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?;
4862         return Some(expr0_0);
4863     }
4864     if pattern0_0 == I64X2 {
4865         let pattern2_0 = arg1;
4866         let pattern3_0 = arg2;
4867         // Rule at src/isa/x64/inst.isle line 2643.
4868         let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?;
4869         return Some(expr0_0);
4870     }
4871     return None;
4872 }
4873 
4874 // Generated as internal constructor for term x64_pcmpgtb.
4875 pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4876     let pattern0_0 = arg0;
4877     let pattern1_0 = arg1;
4878     // Rule at src/isa/x64/inst.isle line 2646.
4879     let expr0_0: Type = I8X16;
4880     let expr1_0 = SseOpcode::Pcmpgtb;
4881     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4882     return Some(expr2_0);
4883 }
4884 
4885 // Generated as internal constructor for term x64_pcmpgtw.
4886 pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4887     let pattern0_0 = arg0;
4888     let pattern1_0 = arg1;
4889     // Rule at src/isa/x64/inst.isle line 2648.
4890     let expr0_0: Type = I16X8;
4891     let expr1_0 = SseOpcode::Pcmpgtw;
4892     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4893     return Some(expr2_0);
4894 }
4895 
4896 // Generated as internal constructor for term x64_pcmpgtd.
4897 pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4898     let pattern0_0 = arg0;
4899     let pattern1_0 = arg1;
4900     // Rule at src/isa/x64/inst.isle line 2650.
4901     let expr0_0: Type = I32X4;
4902     let expr1_0 = SseOpcode::Pcmpgtd;
4903     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4904     return Some(expr2_0);
4905 }
4906 
4907 // Generated as internal constructor for term x64_pcmpgtq.
4908 pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4909     let pattern0_0 = arg0;
4910     let pattern1_0 = arg1;
4911     // Rule at src/isa/x64/inst.isle line 2652.
4912     let expr0_0: Type = I64X2;
4913     let expr1_0 = SseOpcode::Pcmpgtq;
4914     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4915     return Some(expr2_0);
4916 }
4917 
4918 // Generated as internal constructor for term reg_to_xmm_mem.
4919 pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4920     let pattern0_0 = arg0;
4921     // Rule at src/isa/x64/inst.isle line 2708.
4922     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4923     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
4924     return Some(expr1_0);
4925 }
4926 
4927 // Generated as internal constructor for term xmm_to_reg_mem.
4928 pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4929     let pattern0_0 = arg0;
4930     // Rule at src/isa/x64/inst.isle line 2711.
4931     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4932     let expr1_0 = C::xmm_to_reg(ctx, expr0_0);
4933     let expr2_0 = RegMem::Reg { reg: expr1_0 };
4934     let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0);
4935     return Some(expr3_0);
4936 }
4937 
4938 // Generated as internal constructor for term writable_gpr_to_r_reg.
4939 pub fn constructor_writable_gpr_to_r_reg<C: Context>(
4940     ctx: &mut C,
4941     arg0: WritableGpr,
4942 ) -> Option<Reg> {
4943     let pattern0_0 = arg0;
4944     // Rule at src/isa/x64/inst.isle line 2715.
4945     let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0);
4946     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
4947     return Some(expr1_0);
4948 }
4949 
4950 // Generated as internal constructor for term writable_gpr_to_gpr_mem.
4951 pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
4952     ctx: &mut C,
4953     arg0: WritableGpr,
4954 ) -> Option<GprMem> {
4955     let pattern0_0 = arg0;
4956     // Rule at src/isa/x64/inst.isle line 2718.
4957     let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0);
4958     let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0);
4959     return Some(expr1_0);
4960 }
4961 
4962 // Generated as internal constructor for term writable_gpr_to_value_regs.
4963 pub fn constructor_writable_gpr_to_value_regs<C: Context>(
4964     ctx: &mut C,
4965     arg0: WritableGpr,
4966 ) -> Option<ValueRegs> {
4967     let pattern0_0 = arg0;
4968     // Rule at src/isa/x64/inst.isle line 2721.
4969     let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?;
4970     let expr1_0 = C::value_reg(ctx, expr0_0);
4971     return Some(expr1_0);
4972 }
4973 
4974 // Generated as internal constructor for term writable_xmm_to_r_reg.
4975 pub fn constructor_writable_xmm_to_r_reg<C: Context>(
4976     ctx: &mut C,
4977     arg0: WritableXmm,
4978 ) -> Option<Reg> {
4979     let pattern0_0 = arg0;
4980     // Rule at src/isa/x64/inst.isle line 2724.
4981     let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0);
4982     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
4983     return Some(expr1_0);
4984 }
4985 
4986 // Generated as internal constructor for term writable_xmm_to_xmm_mem.
4987 pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
4988     ctx: &mut C,
4989     arg0: WritableXmm,
4990 ) -> Option<XmmMem> {
4991     let pattern0_0 = arg0;
4992     // Rule at src/isa/x64/inst.isle line 2727.
4993     let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0);
4994     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
4995     return Some(expr1_0);
4996 }
4997 
4998 // Generated as internal constructor for term writable_xmm_to_value_regs.
4999 pub fn constructor_writable_xmm_to_value_regs<C: Context>(
5000     ctx: &mut C,
5001     arg0: WritableXmm,
5002 ) -> Option<ValueRegs> {
5003     let pattern0_0 = arg0;
5004     // Rule at src/isa/x64/inst.isle line 2730.
5005     let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?;
5006     let expr1_0 = C::value_reg(ctx, expr0_0);
5007     return Some(expr1_0);
5008 }
5009 
5010 // Generated as internal constructor for term synthetic_amode_to_gpr_mem.
5011 pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
5012     ctx: &mut C,
5013     arg0: &SyntheticAmode,
5014 ) -> Option<GprMem> {
5015     let pattern0_0 = arg0;
5016     // Rule at src/isa/x64/inst.isle line 2737.
5017     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5018     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
5019     return Some(expr1_0);
5020 }
5021 
5022 // Generated as internal constructor for term amode_to_gpr_mem.
5023 pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<GprMem> {
5024     let pattern0_0 = arg0;
5025     // Rule at src/isa/x64/inst.isle line 2735.
5026     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5027     let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?;
5028     return Some(expr1_0);
5029 }
5030 
5031 // Generated as internal constructor for term amode_to_xmm_mem.
5032 pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<XmmMem> {
5033     let pattern0_0 = arg0;
5034     // Rule at src/isa/x64/inst.isle line 2740.
5035     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5036     let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?;
5037     return Some(expr1_0);
5038 }
5039 
5040 // Generated as internal constructor for term synthetic_amode_to_xmm_mem.
5041 pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
5042     ctx: &mut C,
5043     arg0: &SyntheticAmode,
5044 ) -> Option<XmmMem> {
5045     let pattern0_0 = arg0;
5046     // Rule at src/isa/x64/inst.isle line 2743.
5047     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5048     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
5049     return Some(expr1_0);
5050 }
5051 
5052 // Generated as internal constructor for term lower.
5053 pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
5054     let pattern0_0 = arg0;
5055     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5056         let pattern2_0 = C::value_type(ctx, pattern1_0);
5057         if pattern2_0 == I128 {
5058             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5059                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5060                 if let &InstructionData::Unary {
5061                     opcode: ref pattern6_0,
5062                     arg: pattern6_1,
5063                 } = &pattern5_0
5064                 {
5065                     if let &Opcode::Popcnt = pattern6_0 {
5066                         // Rule at src/isa/x64/lower.isle line 1883.
5067                         let expr0_0: Type = I64;
5068                         let expr1_0 = C::put_in_regs(ctx, pattern6_1);
5069                         let expr2_0: usize = 0;
5070                         let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
5071                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5072                         let expr5_0: Type = I64;
5073                         let expr6_0 = C::put_in_regs(ctx, pattern6_1);
5074                         let expr7_0: usize = 1;
5075                         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5076                         let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?;
5077                         let expr10_0: Type = I64;
5078                         let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
5079                         let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
5080                         let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
5081                         let expr14_0: Type = I64;
5082                         let expr15_0: u64 = 0;
5083                         let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
5084                         let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
5085                         let expr18_0 = C::output(ctx, expr17_0);
5086                         return Some(expr18_0);
5087                     }
5088                 }
5089             }
5090         }
5091         if pattern2_0 == I8X16 {
5092             if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
5093                 if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) {
5094                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
5095                     if let &InstructionData::Unary {
5096                         opcode: ref pattern7_0,
5097                         arg: pattern7_1,
5098                     } = &pattern6_0
5099                     {
5100                         if let &Opcode::Popcnt = pattern7_0 {
5101                             // Rule at src/isa/x64/lower.isle line 1975.
5102                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
5103                             let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?;
5104                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
5105                             return Some(expr2_0);
5106                         }
5107                     }
5108                 }
5109             }
5110         }
5111         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
5112             if let Some(()) = C::use_lzcnt(ctx, pattern2_0) {
5113                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5114                 if let &InstructionData::Unary {
5115                     opcode: ref pattern6_0,
5116                     arg: pattern6_1,
5117                 } = &pattern5_0
5118                 {
5119                     if let &Opcode::Clz = pattern6_0 {
5120                         // Rule at src/isa/x64/lower.isle line 1791.
5121                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5122                         let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?;
5123                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5124                         return Some(expr2_0);
5125                     }
5126                 }
5127             }
5128             if let Some(()) = C::use_bmi1(ctx, pattern2_0) {
5129                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5130                 if let &InstructionData::Unary {
5131                     opcode: ref pattern6_0,
5132                     arg: pattern6_1,
5133                 } = &pattern5_0
5134                 {
5135                     if let &Opcode::Ctz = pattern6_0 {
5136                         // Rule at src/isa/x64/lower.isle line 1833.
5137                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5138                         let expr1_0 = constructor_x64_tzcnt(ctx, pattern3_0, expr0_0)?;
5139                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5140                         return Some(expr2_0);
5141                     }
5142                 }
5143             }
5144             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5145                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5146                 if let &InstructionData::Unary {
5147                     opcode: ref pattern6_0,
5148                     arg: pattern6_1,
5149                 } = &pattern5_0
5150                 {
5151                     if let &Opcode::Popcnt = pattern6_0 {
5152                         // Rule at src/isa/x64/lower.isle line 1869.
5153                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5154                         let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?;
5155                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5156                         return Some(expr2_0);
5157                     }
5158                 }
5159             }
5160         }
5161         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
5162             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5163                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5164                 if let &InstructionData::Unary {
5165                     opcode: ref pattern6_0,
5166                     arg: pattern6_1,
5167                 } = &pattern5_0
5168                 {
5169                     if let &Opcode::Popcnt = pattern6_0 {
5170                         // Rule at src/isa/x64/lower.isle line 1876.
5171                         let expr0_0: Type = I32;
5172                         let expr1_0: Type = I32;
5173                         let expr2_0 = ExtendKind::Zero;
5174                         let expr3_0 =
5175                             constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?;
5176                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5177                         let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
5178                         return Some(expr5_0);
5179                     }
5180                 }
5181             }
5182         }
5183     }
5184     let pattern0_0 = arg0;
5185     let pattern1_0 = C::inst_data(ctx, pattern0_0);
5186     match &pattern1_0 {
5187         &InstructionData::NullAry {
5188             opcode: ref pattern2_0,
5189         } => {
5190             if let &Opcode::Debugtrap = pattern2_0 {
5191                 // Rule at src/isa/x64/lower.isle line 2261.
5192                 let expr0_0 = constructor_x64_hlt(ctx)?;
5193                 let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5194                 return Some(expr1_0);
5195             }
5196         }
5197         &InstructionData::UnaryIeee32 {
5198             opcode: ref pattern2_0,
5199             imm: pattern2_1,
5200         } => {
5201             if let &Opcode::F32const = pattern2_0 {
5202                 let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1);
5203                 // Rule at src/isa/x64/lower.isle line 46.
5204                 let expr0_0: Type = F32;
5205                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5206                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5207                 return Some(expr2_0);
5208             }
5209         }
5210         &InstructionData::UnaryIeee64 {
5211             opcode: ref pattern2_0,
5212             imm: pattern2_1,
5213         } => {
5214             if let &Opcode::F64const = pattern2_0 {
5215                 let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1);
5216                 // Rule at src/isa/x64/lower.isle line 51.
5217                 let expr0_0: Type = F64;
5218                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5219                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5220                 return Some(expr2_0);
5221             }
5222         }
5223         &InstructionData::Trap {
5224             opcode: ref pattern2_0,
5225             code: ref pattern2_1,
5226         } => {
5227             match pattern2_0 {
5228                 &Opcode::Trap => {
5229                     // Rule at src/isa/x64/lower.isle line 1434.
5230                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5231                     let expr1_0 = constructor_safepoint(ctx, &expr0_0)?;
5232                     return Some(expr1_0);
5233                 }
5234                 &Opcode::ResumableTrap => {
5235                     // Rule at src/isa/x64/lower.isle line 1439.
5236                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5237                     let expr1_0 = constructor_safepoint(ctx, &expr0_0)?;
5238                     return Some(expr1_0);
5239                 }
5240                 _ => {}
5241             }
5242         }
5243         &InstructionData::TernaryImm8 {
5244             opcode: ref pattern2_0,
5245             args: ref pattern2_1,
5246             imm: pattern2_2,
5247         } => {
5248             if let &Opcode::Insertlane = pattern2_0 {
5249                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5250                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5251                 let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2);
5252                 // Rule at src/isa/x64/lower.isle line 1302.
5253                 let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5254                 let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1);
5255                 let expr2_0 =
5256                     constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?;
5257                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5258                 return Some(expr3_0);
5259             }
5260         }
5261         &InstructionData::FloatCompare {
5262             opcode: ref pattern2_0,
5263             args: ref pattern2_1,
5264             cond: ref pattern2_2,
5265         } => {
5266             if let &Opcode::Fcmp = pattern2_0 {
5267                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5268                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5269                 if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) {
5270                     match pattern2_2 {
5271                         &FloatCC::Equal => {
5272                             // Rule at src/isa/x64/lower.isle line 1571.
5273                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5274                             let expr1_0 = CC::NP;
5275                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5276                             let expr3_0 = CC::Z;
5277                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5278                             let expr5_0 =
5279                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5280                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5281                             let expr7_0: usize = 0;
5282                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5283                             let expr9_0: usize = 1;
5284                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5285                             let expr11_0: Type = I32;
5286                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5287                             let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?;
5288                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5289                             return Some(expr14_0);
5290                         }
5291                         &FloatCC::GreaterThan => {
5292                             // Rule at src/isa/x64/lower.isle line 1599.
5293                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5294                             let expr1_0 = CC::NBE;
5295                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5296                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5297                             let expr4_0 = C::output(ctx, expr3_0);
5298                             return Some(expr4_0);
5299                         }
5300                         &FloatCC::GreaterThanOrEqual => {
5301                             // Rule at src/isa/x64/lower.isle line 1601.
5302                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5303                             let expr1_0 = CC::NB;
5304                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5305                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5306                             let expr4_0 = C::output(ctx, expr3_0);
5307                             return Some(expr4_0);
5308                         }
5309                         &FloatCC::LessThan => {
5310                             // Rule at src/isa/x64/lower.isle line 1611.
5311                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5312                             let expr1_0 = CC::NBE;
5313                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5314                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5315                             let expr4_0 = C::output(ctx, expr3_0);
5316                             return Some(expr4_0);
5317                         }
5318                         &FloatCC::LessThanOrEqual => {
5319                             // Rule at src/isa/x64/lower.isle line 1614.
5320                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5321                             let expr1_0 = CC::NB;
5322                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5323                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5324                             let expr4_0 = C::output(ctx, expr3_0);
5325                             return Some(expr4_0);
5326                         }
5327                         &FloatCC::NotEqual => {
5328                             // Rule at src/isa/x64/lower.isle line 1580.
5329                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5330                             let expr1_0 = CC::P;
5331                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5332                             let expr3_0 = CC::NZ;
5333                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5334                             let expr5_0 =
5335                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5336                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5337                             let expr7_0: usize = 0;
5338                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5339                             let expr9_0: usize = 1;
5340                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5341                             let expr11_0: Type = I32;
5342                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5343                             let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?;
5344                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5345                             return Some(expr14_0);
5346                         }
5347                         &FloatCC::Ordered => {
5348                             // Rule at src/isa/x64/lower.isle line 1591.
5349                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5350                             let expr1_0 = CC::NP;
5351                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5352                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5353                             let expr4_0 = C::output(ctx, expr3_0);
5354                             return Some(expr4_0);
5355                         }
5356                         &FloatCC::OrderedNotEqual => {
5357                             // Rule at src/isa/x64/lower.isle line 1595.
5358                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5359                             let expr1_0 = CC::NZ;
5360                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5361                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5362                             let expr4_0 = C::output(ctx, expr3_0);
5363                             return Some(expr4_0);
5364                         }
5365                         &FloatCC::Unordered => {
5366                             // Rule at src/isa/x64/lower.isle line 1593.
5367                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5368                             let expr1_0 = CC::P;
5369                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5370                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5371                             let expr4_0 = C::output(ctx, expr3_0);
5372                             return Some(expr4_0);
5373                         }
5374                         &FloatCC::UnorderedOrEqual => {
5375                             // Rule at src/isa/x64/lower.isle line 1597.
5376                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5377                             let expr1_0 = CC::Z;
5378                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5379                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5380                             let expr4_0 = C::output(ctx, expr3_0);
5381                             return Some(expr4_0);
5382                         }
5383                         &FloatCC::UnorderedOrGreaterThan => {
5384                             // Rule at src/isa/x64/lower.isle line 1617.
5385                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5386                             let expr1_0 = CC::B;
5387                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5388                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5389                             let expr4_0 = C::output(ctx, expr3_0);
5390                             return Some(expr4_0);
5391                         }
5392                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5393                             // Rule at src/isa/x64/lower.isle line 1620.
5394                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5395                             let expr1_0 = CC::BE;
5396                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5397                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5398                             let expr4_0 = C::output(ctx, expr3_0);
5399                             return Some(expr4_0);
5400                         }
5401                         &FloatCC::UnorderedOrLessThan => {
5402                             // Rule at src/isa/x64/lower.isle line 1603.
5403                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5404                             let expr1_0 = CC::B;
5405                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5406                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5407                             let expr4_0 = C::output(ctx, expr3_0);
5408                             return Some(expr4_0);
5409                         }
5410                         &FloatCC::UnorderedOrLessThanOrEqual => {
5411                             // Rule at src/isa/x64/lower.isle line 1605.
5412                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5413                             let expr1_0 = CC::BE;
5414                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5415                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5416                             let expr4_0 = C::output(ctx, expr3_0);
5417                             return Some(expr4_0);
5418                         }
5419                         _ => {}
5420                     }
5421                 }
5422                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5423                     match pattern2_2 {
5424                         &FloatCC::Equal => {
5425                             // Rule at src/isa/x64/lower.isle line 1628.
5426                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5427                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5428                             let expr2_0 = FcmpImm::Equal;
5429                             let expr3_0 =
5430                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5431                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5432                             return Some(expr4_0);
5433                         }
5434                         &FloatCC::GreaterThan => {
5435                             // Rule at src/isa/x64/lower.isle line 1648.
5436                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5437                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5438                             let expr2_0 = FcmpImm::LessThan;
5439                             let expr3_0 =
5440                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5441                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5442                             return Some(expr4_0);
5443                         }
5444                         &FloatCC::GreaterThanOrEqual => {
5445                             // Rule at src/isa/x64/lower.isle line 1650.
5446                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5447                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5448                             let expr2_0 = FcmpImm::LessThanOrEqual;
5449                             let expr3_0 =
5450                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5451                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5452                             return Some(expr4_0);
5453                         }
5454                         &FloatCC::LessThan => {
5455                             // Rule at src/isa/x64/lower.isle line 1632.
5456                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5457                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5458                             let expr2_0 = FcmpImm::LessThan;
5459                             let expr3_0 =
5460                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5461                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5462                             return Some(expr4_0);
5463                         }
5464                         &FloatCC::LessThanOrEqual => {
5465                             // Rule at src/isa/x64/lower.isle line 1634.
5466                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5467                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5468                             let expr2_0 = FcmpImm::LessThanOrEqual;
5469                             let expr3_0 =
5470                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5471                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5472                             return Some(expr4_0);
5473                         }
5474                         &FloatCC::NotEqual => {
5475                             // Rule at src/isa/x64/lower.isle line 1630.
5476                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5477                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5478                             let expr2_0 = FcmpImm::NotEqual;
5479                             let expr3_0 =
5480                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5481                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5482                             return Some(expr4_0);
5483                         }
5484                         &FloatCC::Ordered => {
5485                             // Rule at src/isa/x64/lower.isle line 1636.
5486                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5487                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5488                             let expr2_0 = FcmpImm::Ordered;
5489                             let expr3_0 =
5490                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5491                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5492                             return Some(expr4_0);
5493                         }
5494                         &FloatCC::Unordered => {
5495                             // Rule at src/isa/x64/lower.isle line 1638.
5496                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5497                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5498                             let expr2_0 = FcmpImm::Unordered;
5499                             let expr3_0 =
5500                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5501                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5502                             return Some(expr4_0);
5503                         }
5504                         &FloatCC::UnorderedOrGreaterThan => {
5505                             // Rule at src/isa/x64/lower.isle line 1640.
5506                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5507                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5508                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5509                             let expr3_0 =
5510                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5511                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5512                             return Some(expr4_0);
5513                         }
5514                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5515                             // Rule at src/isa/x64/lower.isle line 1642.
5516                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5517                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5518                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5519                             let expr3_0 =
5520                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5521                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5522                             return Some(expr4_0);
5523                         }
5524                         &FloatCC::UnorderedOrLessThan => {
5525                             // Rule at src/isa/x64/lower.isle line 1652.
5526                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5527                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5528                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5529                             let expr3_0 =
5530                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5531                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5532                             return Some(expr4_0);
5533                         }
5534                         &FloatCC::UnorderedOrLessThanOrEqual => {
5535                             // Rule at src/isa/x64/lower.isle line 1654.
5536                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5537                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5538                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5539                             let expr3_0 =
5540                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5541                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5542                             return Some(expr4_0);
5543                         }
5544                         _ => {}
5545                     }
5546                 }
5547             }
5548         }
5549         &InstructionData::IntCompare {
5550             opcode: ref pattern2_0,
5551             args: ref pattern2_1,
5552             cond: ref pattern2_2,
5553         } => {
5554             if let &Opcode::Icmp = pattern2_0 {
5555                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5556                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5557                 if pattern5_0 == I128 {
5558                     match pattern2_2 {
5559                         &IntCC::Equal => {
5560                             // Rule at src/isa/x64/lower.isle line 1522.
5561                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5562                             let expr1_0: usize = 0;
5563                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5564                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5565                             let expr4_0: usize = 1;
5566                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5567                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5568                             let expr7_0: usize = 0;
5569                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5570                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5571                             let expr10_0: usize = 1;
5572                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5573                             let expr12_0 = OperandSize::Size64;
5574                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5575                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5576                             let expr15_0 = CC::Z;
5577                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5578                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5579                             let expr18_0 = OperandSize::Size64;
5580                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5581                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5582                             let expr21_0 = CC::Z;
5583                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5584                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5585                             let expr24_0: Type = I64;
5586                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5587                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5588                             let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?;
5589                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5590                             let expr29_0 = OperandSize::Size64;
5591                             let expr30_0: u32 = 1;
5592                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5593                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5594                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5595                             let expr34_0 =
5596                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5597                             let expr35_0 = CC::NZ;
5598                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5599                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5600                             let expr38_0 = C::output(ctx, expr37_0);
5601                             return Some(expr38_0);
5602                         }
5603                         &IntCC::NotEqual => {
5604                             // Rule at src/isa/x64/lower.isle line 1541.
5605                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5606                             let expr1_0: usize = 0;
5607                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5608                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5609                             let expr4_0: usize = 1;
5610                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5611                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5612                             let expr7_0: usize = 0;
5613                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5614                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5615                             let expr10_0: usize = 1;
5616                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5617                             let expr12_0 = OperandSize::Size64;
5618                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5619                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5620                             let expr15_0 = CC::NZ;
5621                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5622                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5623                             let expr18_0 = OperandSize::Size64;
5624                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5625                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5626                             let expr21_0 = CC::NZ;
5627                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5628                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5629                             let expr24_0: Type = I64;
5630                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5631                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5632                             let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?;
5633                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5634                             let expr29_0 = OperandSize::Size64;
5635                             let expr30_0: u32 = 1;
5636                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5637                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5638                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5639                             let expr34_0 =
5640                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5641                             let expr35_0 = CC::NZ;
5642                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5643                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5644                             let expr38_0 = C::output(ctx, expr37_0);
5645                             return Some(expr38_0);
5646                         }
5647                         _ => {}
5648                     }
5649                 }
5650                 if pattern5_0 == I64X2 {
5651                     match pattern2_2 {
5652                         &IntCC::SignedGreaterThanOrEqual => {
5653                             // Rule at src/isa/x64/lower.isle line 1507.
5654                             let expr0_0: Type = I64X2;
5655                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5656                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5657                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5658                             let expr4_0: Type = I64X2;
5659                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5660                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5661                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5662                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5663                             return Some(expr8_0);
5664                         }
5665                         &IntCC::SignedLessThanOrEqual => {
5666                             // Rule at src/isa/x64/lower.isle line 1511.
5667                             let expr0_0: Type = I64X2;
5668                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5669                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5670                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5671                             let expr4_0: Type = I64X2;
5672                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5673                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5674                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5675                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5676                             return Some(expr8_0);
5677                         }
5678                         _ => {}
5679                     }
5680                 }
5681                 if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) {
5682                     // Rule at src/isa/x64/lower.isle line 1447.
5683                     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0);
5684                     let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?;
5685                     let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
5686                     let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
5687                     let expr4_0 = C::intcc_to_cc(ctx, pattern2_2);
5688                     let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5689                     let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5690                     let expr7_0 = C::output(ctx, expr6_0);
5691                     return Some(expr7_0);
5692                 }
5693                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5694                     match pattern2_2 {
5695                         &IntCC::Equal => {
5696                             // Rule at src/isa/x64/lower.isle line 1456.
5697                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5698                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5699                             let expr2_0 =
5700                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5701                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5702                             return Some(expr3_0);
5703                         }
5704                         &IntCC::NotEqual => {
5705                             // Rule at src/isa/x64/lower.isle line 1460.
5706                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5707                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5708                             let expr2_0 =
5709                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5710                             let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5711                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
5712                             let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?;
5713                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5714                             return Some(expr6_0);
5715                         }
5716                         &IntCC::SignedGreaterThan => {
5717                             // Rule at src/isa/x64/lower.isle line 1467.
5718                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5719                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5720                             let expr2_0 =
5721                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5722                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5723                             return Some(expr3_0);
5724                         }
5725                         &IntCC::SignedGreaterThanOrEqual => {
5726                             // Rule at src/isa/x64/lower.isle line 1492.
5727                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5728                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5729                             let expr2_0 =
5730                                 constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?;
5731                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5732                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5733                             let expr5_0 =
5734                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5735                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5736                             return Some(expr6_0);
5737                         }
5738                         &IntCC::SignedLessThan => {
5739                             // Rule at src/isa/x64/lower.isle line 1469.
5740                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5741                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5742                             let expr2_0 =
5743                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5744                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5745                             return Some(expr3_0);
5746                         }
5747                         &IntCC::SignedLessThanOrEqual => {
5748                             // Rule at src/isa/x64/lower.isle line 1495.
5749                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5750                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5751                             let expr2_0 =
5752                                 constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?;
5753                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5754                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5755                             let expr5_0 =
5756                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5757                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5758                             return Some(expr6_0);
5759                         }
5760                         &IntCC::UnsignedGreaterThan => {
5761                             // Rule at src/isa/x64/lower.isle line 1471.
5762                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5763                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5764                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5765                             let expr3_0 =
5766                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5767                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5768                             let expr5_0 =
5769                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5770                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5771                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5772                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5773                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5774                             return Some(expr9_0);
5775                         }
5776                         &IntCC::UnsignedGreaterThanOrEqual => {
5777                             // Rule at src/isa/x64/lower.isle line 1498.
5778                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5779                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5780                             let expr2_0 =
5781                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5782                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5783                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5784                             let expr5_0 =
5785                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5786                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5787                             return Some(expr6_0);
5788                         }
5789                         &IntCC::UnsignedLessThan => {
5790                             // Rule at src/isa/x64/lower.isle line 1481.
5791                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5792                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5793                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5794                             let expr3_0 =
5795                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5796                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5797                             let expr5_0 =
5798                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5799                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5800                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5801                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5802                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5803                             return Some(expr9_0);
5804                         }
5805                         &IntCC::UnsignedLessThanOrEqual => {
5806                             // Rule at src/isa/x64/lower.isle line 1501.
5807                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5808                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5809                             let expr2_0 =
5810                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5811                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5812                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5813                             let expr5_0 =
5814                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5815                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5816                             return Some(expr6_0);
5817                         }
5818                         _ => {}
5819                     }
5820                 }
5821             }
5822         }
5823         &InstructionData::Unary {
5824             opcode: ref pattern2_0,
5825             arg: pattern2_1,
5826         } => {
5827             match pattern2_0 {
5828                 &Opcode::IsNull => {
5829                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5830                     if pattern4_0 == R64 {
5831                         // Rule at src/isa/x64/lower.isle line 2104.
5832                         let expr0_0 = OperandSize::Size64;
5833                         let expr1_0: u32 = 0;
5834                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5835                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5836                         let expr4_0 = CC::Z;
5837                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5838                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5839                         let expr7_0 = C::output(ctx, expr6_0);
5840                         return Some(expr7_0);
5841                     }
5842                 }
5843                 &Opcode::IsInvalid => {
5844                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5845                     if pattern4_0 == R64 {
5846                         // Rule at src/isa/x64/lower.isle line 2112.
5847                         let expr0_0 = OperandSize::Size64;
5848                         let expr1_0: u32 = 4294967295;
5849                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5850                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5851                         let expr4_0 = CC::Z;
5852                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5853                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5854                         let expr7_0 = C::output(ctx, expr6_0);
5855                         return Some(expr7_0);
5856                     }
5857                 }
5858                 _ => {}
5859             }
5860         }
5861         _ => {}
5862     }
5863     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5864         let pattern2_0 = C::value_type(ctx, pattern1_0);
5865         if pattern2_0 == B128 {
5866             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5867             match &pattern4_0 {
5868                 &InstructionData::UnaryBool {
5869                     opcode: ref pattern5_0,
5870                     imm: pattern5_1,
5871                 } => {
5872                     if let &Opcode::Bconst = pattern5_0 {
5873                         if pattern5_1 == true {
5874                             // Rule at src/isa/x64/lower.isle line 39.
5875                             let expr0_0: Type = B64;
5876                             let expr1_0: u64 = 1;
5877                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5878                             let expr3_0: Type = B64;
5879                             let expr4_0: u64 = 0;
5880                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5881                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5882                             let expr7_0 = C::output(ctx, expr6_0);
5883                             return Some(expr7_0);
5884                         }
5885                         if pattern5_1 == false {
5886                             // Rule at src/isa/x64/lower.isle line 34.
5887                             let expr0_0: Type = B64;
5888                             let expr1_0: u64 = 0;
5889                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5890                             let expr3_0: Type = B64;
5891                             let expr4_0: u64 = 0;
5892                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5893                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5894                             let expr7_0 = C::output(ctx, expr6_0);
5895                             return Some(expr7_0);
5896                         }
5897                     }
5898                 }
5899                 &InstructionData::Binary {
5900                     opcode: ref pattern5_0,
5901                     args: ref pattern5_1,
5902                 } => {
5903                     match pattern5_0 {
5904                         &Opcode::Band => {
5905                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5906                             // Rule at src/isa/x64/lower.isle line 344.
5907                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5908                             let expr1_0: usize = 0;
5909                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5910                             let expr3_0: usize = 1;
5911                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5912                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5913                             let expr6_0: Type = I64;
5914                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5915                             let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?;
5916                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5917                             let expr10_0 = C::output(ctx, expr9_0);
5918                             return Some(expr10_0);
5919                         }
5920                         &Opcode::Bor => {
5921                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5922                             // Rule at src/isa/x64/lower.isle line 410.
5923                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5924                             let expr1_0: usize = 0;
5925                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5926                             let expr3_0: usize = 1;
5927                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5928                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5929                             let expr6_0: Type = I64;
5930                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5931                             let expr8_0 = constructor_x64_or(ctx, expr6_0, expr2_0, &expr7_0)?;
5932                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5933                             let expr10_0 = C::output(ctx, expr9_0);
5934                             return Some(expr10_0);
5935                         }
5936                         &Opcode::Bxor => {
5937                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5938                             // Rule at src/isa/x64/lower.isle line 468.
5939                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5940                             let expr1_0: usize = 0;
5941                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5942                             let expr3_0: usize = 1;
5943                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5944                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5945                             let expr6_0: Type = I64;
5946                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5947                             let expr8_0 = constructor_x64_xor(ctx, expr6_0, expr2_0, &expr7_0)?;
5948                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5949                             let expr10_0 = C::output(ctx, expr9_0);
5950                             return Some(expr10_0);
5951                         }
5952                         _ => {}
5953                     }
5954                 }
5955                 &InstructionData::Unary {
5956                     opcode: ref pattern5_0,
5957                     arg: pattern5_1,
5958                 } => {
5959                     if let &Opcode::Bnot = pattern5_0 {
5960                         // Rule at src/isa/x64/lower.isle line 1269.
5961                         let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
5962                         let expr1_0 = C::output(ctx, expr0_0);
5963                         return Some(expr1_0);
5964                     }
5965                 }
5966                 _ => {}
5967             }
5968         }
5969         if pattern2_0 == I8 {
5970             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5971             if let &InstructionData::Unary {
5972                 opcode: ref pattern5_0,
5973                 arg: pattern5_1,
5974             } = &pattern4_0
5975             {
5976                 if let &Opcode::Bitrev = pattern5_0 {
5977                     // Rule at src/isa/x64/lower.isle line 2026.
5978                     let expr0_0: Type = I32;
5979                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
5980                     let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?;
5981                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
5982                     return Some(expr3_0);
5983                 }
5984             }
5985         }
5986         if pattern2_0 == I16 {
5987             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5988             if let &InstructionData::Unary {
5989                 opcode: ref pattern5_0,
5990                 arg: pattern5_1,
5991             } = &pattern4_0
5992             {
5993                 if let &Opcode::Bitrev = pattern5_0 {
5994                     // Rule at src/isa/x64/lower.isle line 2029.
5995                     let expr0_0: Type = I32;
5996                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
5997                     let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?;
5998                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
5999                     return Some(expr3_0);
6000                 }
6001             }
6002         }
6003         if pattern2_0 == I32 {
6004             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6005             if let &InstructionData::Unary {
6006                 opcode: ref pattern5_0,
6007                 arg: pattern5_1,
6008             } = &pattern4_0
6009             {
6010                 if let &Opcode::Bitrev = pattern5_0 {
6011                     // Rule at src/isa/x64/lower.isle line 2032.
6012                     let expr0_0: Type = I32;
6013                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6014                     let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?;
6015                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6016                     return Some(expr3_0);
6017                 }
6018             }
6019         }
6020         if pattern2_0 == I64 {
6021             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6022             if let &InstructionData::Unary {
6023                 opcode: ref pattern5_0,
6024                 arg: pattern5_1,
6025             } = &pattern4_0
6026             {
6027                 match pattern5_0 {
6028                     &Opcode::Bitrev => {
6029                         // Rule at src/isa/x64/lower.isle line 2035.
6030                         let expr0_0: Type = I64;
6031                         let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6032                         let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?;
6033                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6034                         return Some(expr3_0);
6035                     }
6036                     &Opcode::Uextend => {
6037                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
6038                             if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
6039                                 let pattern9_0 = C::value_type(ctx, pattern8_0);
6040                                 if pattern9_0 == I32 {
6041                                     let pattern11_0 = C::inst_data(ctx, pattern7_0);
6042                                     match &pattern11_0 {
6043                                         &InstructionData::Binary {
6044                                             opcode: ref pattern12_0,
6045                                             args: ref pattern12_1,
6046                                         } => {
6047                                             match pattern12_0 {
6048                                                 &Opcode::Iadd => {
6049                                                     let (pattern14_0, pattern14_1) =
6050                                                         C::unpack_value_array_2(ctx, pattern12_1);
6051                                                     // Rule at src/isa/x64/lower.isle line 2151.
6052                                                     let expr0_0 =
6053                                                         constructor_output_value(ctx, pattern5_1)?;
6054                                                     return Some(expr0_0);
6055                                                 }
6056                                                 &Opcode::Isub => {
6057                                                     let (pattern14_0, pattern14_1) =
6058                                                         C::unpack_value_array_2(ctx, pattern12_1);
6059                                                     // Rule at src/isa/x64/lower.isle line 2157.
6060                                                     let expr0_0 =
6061                                                         constructor_output_value(ctx, pattern5_1)?;
6062                                                     return Some(expr0_0);
6063                                                 }
6064                                                 &Opcode::Imul => {
6065                                                     let (pattern14_0, pattern14_1) =
6066                                                         C::unpack_value_array_2(ctx, pattern12_1);
6067                                                     // Rule at src/isa/x64/lower.isle line 2160.
6068                                                     let expr0_0 =
6069                                                         constructor_output_value(ctx, pattern5_1)?;
6070                                                     return Some(expr0_0);
6071                                                 }
6072                                                 &Opcode::IaddIfcout => {
6073                                                     let (pattern14_0, pattern14_1) =
6074                                                         C::unpack_value_array_2(ctx, pattern12_1);
6075                                                     // Rule at src/isa/x64/lower.isle line 2154.
6076                                                     let expr0_0 =
6077                                                         constructor_output_value(ctx, pattern5_1)?;
6078                                                     return Some(expr0_0);
6079                                                 }
6080                                                 &Opcode::Band => {
6081                                                     let (pattern14_0, pattern14_1) =
6082                                                         C::unpack_value_array_2(ctx, pattern12_1);
6083                                                     // Rule at src/isa/x64/lower.isle line 2163.
6084                                                     let expr0_0 =
6085                                                         constructor_output_value(ctx, pattern5_1)?;
6086                                                     return Some(expr0_0);
6087                                                 }
6088                                                 &Opcode::Bor => {
6089                                                     let (pattern14_0, pattern14_1) =
6090                                                         C::unpack_value_array_2(ctx, pattern12_1);
6091                                                     // Rule at src/isa/x64/lower.isle line 2166.
6092                                                     let expr0_0 =
6093                                                         constructor_output_value(ctx, pattern5_1)?;
6094                                                     return Some(expr0_0);
6095                                                 }
6096                                                 &Opcode::Bxor => {
6097                                                     let (pattern14_0, pattern14_1) =
6098                                                         C::unpack_value_array_2(ctx, pattern12_1);
6099                                                     // Rule at src/isa/x64/lower.isle line 2169.
6100                                                     let expr0_0 =
6101                                                         constructor_output_value(ctx, pattern5_1)?;
6102                                                     return Some(expr0_0);
6103                                                 }
6104                                                 &Opcode::Ishl => {
6105                                                     let (pattern14_0, pattern14_1) =
6106                                                         C::unpack_value_array_2(ctx, pattern12_1);
6107                                                     // Rule at src/isa/x64/lower.isle line 2172.
6108                                                     let expr0_0 =
6109                                                         constructor_output_value(ctx, pattern5_1)?;
6110                                                     return Some(expr0_0);
6111                                                 }
6112                                                 &Opcode::Ushr => {
6113                                                     let (pattern14_0, pattern14_1) =
6114                                                         C::unpack_value_array_2(ctx, pattern12_1);
6115                                                     // Rule at src/isa/x64/lower.isle line 2175.
6116                                                     let expr0_0 =
6117                                                         constructor_output_value(ctx, pattern5_1)?;
6118                                                     return Some(expr0_0);
6119                                                 }
6120                                                 _ => {}
6121                                             }
6122                                         }
6123                                         &InstructionData::Load {
6124                                             opcode: ref pattern12_0,
6125                                             arg: pattern12_1,
6126                                             flags: pattern12_2,
6127                                             offset: pattern12_3,
6128                                         } => {
6129                                             if let &Opcode::Uload32 = pattern12_0 {
6130                                                 // Rule at src/isa/x64/lower.isle line 2178.
6131                                                 let expr0_0 =
6132                                                     constructor_output_value(ctx, pattern5_1)?;
6133                                                 return Some(expr0_0);
6134                                             }
6135                                         }
6136                                         _ => {}
6137                                     }
6138                                 }
6139                             }
6140                         }
6141                         let pattern7_0 = C::value_type(ctx, pattern5_1);
6142                         if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6143                             // Rule at src/isa/x64/lower.isle line 2133.
6144                             let expr0_0: Type = I64;
6145                             let expr1_0 = ExtendKind::Zero;
6146                             let expr2_0 =
6147                                 constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6148                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6149                             return Some(expr3_0);
6150                         }
6151                     }
6152                     _ => {}
6153                 }
6154             }
6155         }
6156         if pattern2_0 == I128 {
6157             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6158             match &pattern4_0 {
6159                 &InstructionData::UnaryImm {
6160                     opcode: ref pattern5_0,
6161                     imm: pattern5_1,
6162                 } => {
6163                     if let &Opcode::Iconst = pattern5_0 {
6164                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
6165                         // Rule at src/isa/x64/lower.isle line 15.
6166                         let expr0_0: Type = I64;
6167                         let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?;
6168                         let expr2_0: Type = I64;
6169                         let expr3_0: u64 = 0;
6170                         let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?;
6171                         let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0);
6172                         let expr6_0 = C::output(ctx, expr5_0);
6173                         return Some(expr6_0);
6174                     }
6175                 }
6176                 &InstructionData::Binary {
6177                     opcode: ref pattern5_0,
6178                     args: ref pattern5_1,
6179                 } => {
6180                     match pattern5_0 {
6181                         &Opcode::Iadd => {
6182                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6183                             // Rule at src/isa/x64/lower.isle line 111.
6184                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6185                             let expr1_0: usize = 0;
6186                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6187                             let expr3_0: usize = 1;
6188                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6189                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6190                             let expr6_0: usize = 0;
6191                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6192                             let expr8_0: usize = 1;
6193                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6194                             let expr10_0: Type = I64;
6195                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6196                             let expr12_0 = constructor_x64_add_with_flags_paired(
6197                                 ctx, expr10_0, expr2_0, &expr11_0,
6198                             )?;
6199                             let expr13_0: Type = I64;
6200                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6201                             let expr15_0 =
6202                                 constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6203                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6204                             let expr17_0 = C::output(ctx, expr16_0);
6205                             return Some(expr17_0);
6206                         }
6207                         &Opcode::Isub => {
6208                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6209                             // Rule at src/isa/x64/lower.isle line 257.
6210                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6211                             let expr1_0: usize = 0;
6212                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6213                             let expr3_0: usize = 1;
6214                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6215                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6216                             let expr6_0: usize = 0;
6217                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6218                             let expr8_0: usize = 1;
6219                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6220                             let expr10_0: Type = I64;
6221                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6222                             let expr12_0 = constructor_x64_sub_with_flags_paired(
6223                                 ctx, expr10_0, expr2_0, &expr11_0,
6224                             )?;
6225                             let expr13_0: Type = I64;
6226                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6227                             let expr15_0 =
6228                                 constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6229                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6230                             let expr17_0 = C::output(ctx, expr16_0);
6231                             return Some(expr17_0);
6232                         }
6233                         &Opcode::Imul => {
6234                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6235                             // Rule at src/isa/x64/lower.isle line 957.
6236                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6237                             let expr1_0: usize = 0;
6238                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6239                             let expr3_0: usize = 1;
6240                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6241                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6242                             let expr6_0: usize = 0;
6243                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6244                             let expr8_0: usize = 1;
6245                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6246                             let expr10_0: Type = I64;
6247                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6248                             let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?;
6249                             let expr13_0: Type = I64;
6250                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6251                             let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?;
6252                             let expr16_0: Type = I64;
6253                             let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0);
6254                             let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?;
6255                             let expr19_0: Type = I64;
6256                             let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0);
6257                             let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?;
6258                             let expr22_0: usize = 0;
6259                             let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?;
6260                             let expr24_0: usize = 1;
6261                             let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?;
6262                             let expr26_0: Type = I64;
6263                             let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0);
6264                             let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?;
6265                             let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?;
6266                             let expr30_0 = C::output(ctx, expr29_0);
6267                             return Some(expr30_0);
6268                         }
6269                         &Opcode::Band => {
6270                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6271                             // Rule at src/isa/x64/lower.isle line 334.
6272                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6273                             let expr1_0: usize = 0;
6274                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6275                             let expr3_0: usize = 1;
6276                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6277                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6278                             let expr6_0: usize = 0;
6279                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6280                             let expr8_0: usize = 1;
6281                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6282                             let expr10_0: Type = I64;
6283                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6284                             let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?;
6285                             let expr13_0: Type = I64;
6286                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6287                             let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?;
6288                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6289                             let expr17_0 = C::output(ctx, expr16_0);
6290                             return Some(expr17_0);
6291                         }
6292                         &Opcode::Bor => {
6293                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6294                             // Rule at src/isa/x64/lower.isle line 407.
6295                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6296                             let expr1_0 = C::put_in_regs(ctx, pattern7_1);
6297                             let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?;
6298                             let expr3_0 = C::output(ctx, expr2_0);
6299                             return Some(expr3_0);
6300                         }
6301                         &Opcode::Bxor => {
6302                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6303                             // Rule at src/isa/x64/lower.isle line 458.
6304                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6305                             let expr1_0: usize = 0;
6306                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6307                             let expr3_0: usize = 1;
6308                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6309                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6310                             let expr6_0: usize = 0;
6311                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6312                             let expr8_0: usize = 1;
6313                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6314                             let expr10_0: Type = I64;
6315                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6316                             let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?;
6317                             let expr13_0: Type = I64;
6318                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6319                             let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?;
6320                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6321                             let expr17_0 = C::output(ctx, expr16_0);
6322                             return Some(expr17_0);
6323                         }
6324                         &Opcode::Rotl => {
6325                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6326                             // Rule at src/isa/x64/lower.isle line 830.
6327                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6328                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6329                             let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?;
6330                             let expr3_0: Type = I64;
6331                             let expr4_0: Type = I64;
6332                             let expr5_0: u64 = 128;
6333                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6334                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6335                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6336                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6337                             let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?;
6338                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6339                             let expr12_0 = C::output(ctx, expr11_0);
6340                             return Some(expr12_0);
6341                         }
6342                         &Opcode::Rotr => {
6343                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6344                             // Rule at src/isa/x64/lower.isle line 870.
6345                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6346                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6347                             let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?;
6348                             let expr3_0: Type = I64;
6349                             let expr4_0: Type = I64;
6350                             let expr5_0: u64 = 128;
6351                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6352                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6353                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6354                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6355                             let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?;
6356                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6357                             let expr12_0 = C::output(ctx, expr11_0);
6358                             return Some(expr12_0);
6359                         }
6360                         &Opcode::Ishl => {
6361                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6362                             // Rule at src/isa/x64/lower.isle line 522.
6363                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6364                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6365                             let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?;
6366                             let expr3_0 = C::output(ctx, expr2_0);
6367                             return Some(expr3_0);
6368                         }
6369                         &Opcode::Ushr => {
6370                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6371                             // Rule at src/isa/x64/lower.isle line 623.
6372                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6373                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6374                             let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?;
6375                             let expr3_0 = C::output(ctx, expr2_0);
6376                             return Some(expr3_0);
6377                         }
6378                         &Opcode::Sshr => {
6379                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6380                             // Rule at src/isa/x64/lower.isle line 728.
6381                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6382                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6383                             let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?;
6384                             let expr3_0 = C::output(ctx, expr2_0);
6385                             return Some(expr3_0);
6386                         }
6387                         _ => {}
6388                     }
6389                 }
6390                 &InstructionData::Unary {
6391                     opcode: ref pattern5_0,
6392                     arg: pattern5_1,
6393                 } => {
6394                     match pattern5_0 {
6395                         &Opcode::Bnot => {
6396                             // Rule at src/isa/x64/lower.isle line 1266.
6397                             let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
6398                             let expr1_0 = C::output(ctx, expr0_0);
6399                             return Some(expr1_0);
6400                         }
6401                         &Opcode::Bitrev => {
6402                             // Rule at src/isa/x64/lower.isle line 2038.
6403                             let expr0_0: Type = I64;
6404                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6405                             let expr2_0: usize = 1;
6406                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6407                             let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?;
6408                             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
6409                             let expr6_0: Type = I64;
6410                             let expr7_0 = C::put_in_regs(ctx, pattern5_1);
6411                             let expr8_0: usize = 0;
6412                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?;
6413                             let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?;
6414                             let expr11_0 = C::gpr_to_reg(ctx, expr10_0);
6415                             let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0);
6416                             let expr13_0 = C::output(ctx, expr12_0);
6417                             return Some(expr13_0);
6418                         }
6419                         &Opcode::Clz => {
6420                             // Rule at src/isa/x64/lower.isle line 1808.
6421                             let expr0_0: Type = I64;
6422                             let expr1_0: Type = I64;
6423                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6424                             let expr3_0: usize = 1;
6425                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6426                             let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?;
6427                             let expr6_0: Type = I64;
6428                             let expr7_0: Type = I64;
6429                             let expr8_0: Type = I64;
6430                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6431                             let expr10_0: usize = 0;
6432                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6433                             let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?;
6434                             let expr13_0: u32 = 64;
6435                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6436                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6437                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6438                             let expr17_0 = OperandSize::Size64;
6439                             let expr18_0: u32 = 64;
6440                             let expr19_0 =
6441                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6442                             let expr20_0: Type = I64;
6443                             let expr21_0 = CC::NZ;
6444                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0);
6445                             let expr23_0 =
6446                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?;
6447                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6448                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6449                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6450                             let expr27_0: Type = I64;
6451                             let expr28_0: u64 = 0;
6452                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6453                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6454                             let expr31_0 = C::output(ctx, expr30_0);
6455                             return Some(expr31_0);
6456                         }
6457                         &Opcode::Ctz => {
6458                             // Rule at src/isa/x64/lower.isle line 1850.
6459                             let expr0_0: Type = I64;
6460                             let expr1_0: Type = I64;
6461                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6462                             let expr3_0: usize = 0;
6463                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6464                             let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?;
6465                             let expr6_0: Type = I64;
6466                             let expr7_0: Type = I64;
6467                             let expr8_0: Type = I64;
6468                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6469                             let expr10_0: usize = 1;
6470                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6471                             let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?;
6472                             let expr13_0: u32 = 64;
6473                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6474                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6475                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6476                             let expr17_0 = OperandSize::Size64;
6477                             let expr18_0: u32 = 64;
6478                             let expr19_0 =
6479                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6480                             let expr20_0: Type = I64;
6481                             let expr21_0 = CC::Z;
6482                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0);
6483                             let expr23_0 =
6484                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?;
6485                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6486                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6487                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6488                             let expr27_0: Type = I64;
6489                             let expr28_0: u64 = 0;
6490                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6491                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6492                             let expr31_0 = C::output(ctx, expr30_0);
6493                             return Some(expr31_0);
6494                         }
6495                         &Opcode::Popcnt => {
6496                             // Rule at src/isa/x64/lower.isle line 1902.
6497                             let expr0_0: Type = I64;
6498                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6499                             let expr2_0: usize = 0;
6500                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6501                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
6502                             let expr5_0: Type = I64;
6503                             let expr6_0 = C::put_in_regs(ctx, pattern5_1);
6504                             let expr7_0: usize = 1;
6505                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6506                             let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?;
6507                             let expr10_0: Type = I64;
6508                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6509                             let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
6510                             let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
6511                             let expr14_0: Type = I64;
6512                             let expr15_0: u64 = 0;
6513                             let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
6514                             let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
6515                             let expr18_0 = C::output(ctx, expr17_0);
6516                             return Some(expr18_0);
6517                         }
6518                         &Opcode::Bint => {
6519                             // Rule at src/isa/x64/lower.isle line 2253.
6520                             let expr0_0: Type = I64;
6521                             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6522                             let expr2_0: u32 = 1;
6523                             let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
6524                             let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0);
6525                             let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?;
6526                             let expr6_0 = C::gpr_to_reg(ctx, expr5_0);
6527                             let expr7_0: Type = I64;
6528                             let expr8_0: u64 = 0;
6529                             let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?;
6530                             let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0);
6531                             let expr11_0 = C::output(ctx, expr10_0);
6532                             return Some(expr11_0);
6533                         }
6534                         &Opcode::Uextend => {
6535                             let pattern7_0 = C::value_type(ctx, pattern5_1);
6536                             if pattern7_0 == I64 {
6537                                 // Rule at src/isa/x64/lower.isle line 2125.
6538                                 let expr0_0 = C::put_in_reg(ctx, pattern5_1);
6539                                 let expr1_0: Type = I64;
6540                                 let expr2_0: u64 = 0;
6541                                 let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
6542                                 let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
6543                                 let expr5_0 = C::output(ctx, expr4_0);
6544                                 return Some(expr5_0);
6545                             }
6546                             if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6547                                 // Rule at src/isa/x64/lower.isle line 2129.
6548                                 let expr0_0: Type = I64;
6549                                 let expr1_0 = ExtendKind::Zero;
6550                                 let expr2_0 =
6551                                     constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6552                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
6553                                 let expr4_0: Type = I64;
6554                                 let expr5_0: u64 = 0;
6555                                 let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6556                                 let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0);
6557                                 let expr8_0 = C::output(ctx, expr7_0);
6558                                 return Some(expr8_0);
6559                             }
6560                         }
6561                         _ => {}
6562                     }
6563                 }
6564                 &InstructionData::BinaryImm64 {
6565                     opcode: ref pattern5_0,
6566                     arg: pattern5_1,
6567                     imm: pattern5_2,
6568                 } => {
6569                     if let &Opcode::IaddImm = pattern5_0 {
6570                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
6571                         // Rule at src/isa/x64/lower.isle line 210.
6572                         let expr0_0 = C::put_in_regs(ctx, pattern5_1);
6573                         let expr1_0: usize = 0;
6574                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6575                         let expr3_0: usize = 1;
6576                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6577                         let expr5_0: Type = I64;
6578                         let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?;
6579                         let expr7_0 = C::gpr_new(ctx, expr6_0);
6580                         let expr8_0: Type = I64;
6581                         let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6582                         let expr10_0 =
6583                             constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?;
6584                         let expr11_0: Type = I64;
6585                         let expr12_0: u32 = 0;
6586                         let expr13_0 = RegMemImm::Imm { simm32: expr12_0 };
6587                         let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0);
6588                         let expr15_0 =
6589                             constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?;
6590                         let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?;
6591                         let expr17_0 = C::output(ctx, expr16_0);
6592                         return Some(expr17_0);
6593                     }
6594                 }
6595                 _ => {}
6596             }
6597         }
6598         if pattern2_0 == F32 {
6599             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6600             match &pattern4_0 {
6601                 &InstructionData::Binary {
6602                     opcode: ref pattern5_0,
6603                     args: ref pattern5_1,
6604                 } => {
6605                     match pattern5_0 {
6606                         &Opcode::Fadd => {
6607                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6608                             // Rule at src/isa/x64/lower.isle line 2276.
6609                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6610                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6611                             let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?;
6612                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6613                             return Some(expr3_0);
6614                         }
6615                         &Opcode::Fsub => {
6616                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6617                             // Rule at src/isa/x64/lower.isle line 2287.
6618                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6619                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6620                             let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?;
6621                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6622                             return Some(expr3_0);
6623                         }
6624                         &Opcode::Fmul => {
6625                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6626                             // Rule at src/isa/x64/lower.isle line 2298.
6627                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6628                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6629                             let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?;
6630                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6631                             return Some(expr3_0);
6632                         }
6633                         &Opcode::Fdiv => {
6634                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6635                             // Rule at src/isa/x64/lower.isle line 2309.
6636                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6637                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6638                             let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?;
6639                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6640                             return Some(expr3_0);
6641                         }
6642                         &Opcode::Fmin => {
6643                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6644                             // Rule at src/isa/x64/lower.isle line 2320.
6645                             let expr0_0: Type = F32;
6646                             let expr1_0: bool = true;
6647                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6648                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6649                             let expr4_0 = constructor_xmm_min_max_seq(
6650                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6651                             )?;
6652                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6653                             return Some(expr5_0);
6654                         }
6655                         &Opcode::FminPseudo => {
6656                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6657                             // Rule at src/isa/x64/lower.isle line 2489.
6658                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6659                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6660                             let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?;
6661                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6662                             return Some(expr3_0);
6663                         }
6664                         &Opcode::Fmax => {
6665                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6666                             // Rule at src/isa/x64/lower.isle line 2392.
6667                             let expr0_0: Type = F32;
6668                             let expr1_0: bool = false;
6669                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6670                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6671                             let expr4_0 = constructor_xmm_min_max_seq(
6672                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6673                             )?;
6674                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6675                             return Some(expr5_0);
6676                         }
6677                         &Opcode::FmaxPseudo => {
6678                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6679                             // Rule at src/isa/x64/lower.isle line 2500.
6680                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6681                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6682                             let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?;
6683                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6684                             return Some(expr3_0);
6685                         }
6686                         _ => {}
6687                     }
6688                 }
6689                 &InstructionData::Load {
6690                     opcode: ref pattern5_0,
6691                     arg: pattern5_1,
6692                     flags: pattern5_2,
6693                     offset: pattern5_3,
6694                 } => {
6695                     if let &Opcode::Load = pattern5_0 {
6696                         // Rule at src/isa/x64/lower.isle line 2543.
6697                         let expr0_0 =
6698                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6699                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6700                         let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?;
6701                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6702                         return Some(expr3_0);
6703                     }
6704                 }
6705                 _ => {}
6706             }
6707         }
6708         if pattern2_0 == F64 {
6709             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6710             match &pattern4_0 {
6711                 &InstructionData::Binary {
6712                     opcode: ref pattern5_0,
6713                     args: ref pattern5_1,
6714                 } => {
6715                     match pattern5_0 {
6716                         &Opcode::Fadd => {
6717                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6718                             // Rule at src/isa/x64/lower.isle line 2278.
6719                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6720                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6721                             let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?;
6722                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6723                             return Some(expr3_0);
6724                         }
6725                         &Opcode::Fsub => {
6726                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6727                             // Rule at src/isa/x64/lower.isle line 2289.
6728                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6729                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6730                             let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?;
6731                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6732                             return Some(expr3_0);
6733                         }
6734                         &Opcode::Fmul => {
6735                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6736                             // Rule at src/isa/x64/lower.isle line 2300.
6737                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6738                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6739                             let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?;
6740                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6741                             return Some(expr3_0);
6742                         }
6743                         &Opcode::Fdiv => {
6744                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6745                             // Rule at src/isa/x64/lower.isle line 2311.
6746                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6747                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6748                             let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?;
6749                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6750                             return Some(expr3_0);
6751                         }
6752                         &Opcode::Fmin => {
6753                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6754                             // Rule at src/isa/x64/lower.isle line 2322.
6755                             let expr0_0: Type = F64;
6756                             let expr1_0: bool = true;
6757                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6758                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6759                             let expr4_0 = constructor_xmm_min_max_seq(
6760                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6761                             )?;
6762                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6763                             return Some(expr5_0);
6764                         }
6765                         &Opcode::FminPseudo => {
6766                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6767                             // Rule at src/isa/x64/lower.isle line 2491.
6768                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6769                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6770                             let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?;
6771                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6772                             return Some(expr3_0);
6773                         }
6774                         &Opcode::Fmax => {
6775                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6776                             // Rule at src/isa/x64/lower.isle line 2394.
6777                             let expr0_0: Type = F64;
6778                             let expr1_0: bool = false;
6779                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6780                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6781                             let expr4_0 = constructor_xmm_min_max_seq(
6782                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6783                             )?;
6784                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6785                             return Some(expr5_0);
6786                         }
6787                         &Opcode::FmaxPseudo => {
6788                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6789                             // Rule at src/isa/x64/lower.isle line 2502.
6790                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6791                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6792                             let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?;
6793                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6794                             return Some(expr3_0);
6795                         }
6796                         _ => {}
6797                     }
6798                 }
6799                 &InstructionData::Load {
6800                     opcode: ref pattern5_0,
6801                     arg: pattern5_1,
6802                     flags: pattern5_2,
6803                     offset: pattern5_3,
6804                 } => {
6805                     if let &Opcode::Load = pattern5_0 {
6806                         // Rule at src/isa/x64/lower.isle line 2545.
6807                         let expr0_0 =
6808                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6809                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6810                         let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?;
6811                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6812                         return Some(expr3_0);
6813                     }
6814                 }
6815                 _ => {}
6816             }
6817         }
6818         if pattern2_0 == I8X16 {
6819             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6820             match &pattern4_0 {
6821                 &InstructionData::Binary {
6822                     opcode: ref pattern5_0,
6823                     args: ref pattern5_1,
6824                 } => {
6825                     match pattern5_0 {
6826                         &Opcode::Imin => {
6827                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6828                             // Rule at src/isa/x64/lower.isle line 1401.
6829                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6830                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6831                             let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?;
6832                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6833                             return Some(expr3_0);
6834                         }
6835                         &Opcode::Umin => {
6836                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6837                             // Rule at src/isa/x64/lower.isle line 1423.
6838                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6839                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6840                             let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?;
6841                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6842                             return Some(expr3_0);
6843                         }
6844                         &Opcode::Imax => {
6845                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6846                             // Rule at src/isa/x64/lower.isle line 1390.
6847                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6848                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6849                             let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?;
6850                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6851                             return Some(expr3_0);
6852                         }
6853                         &Opcode::Umax => {
6854                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6855                             // Rule at src/isa/x64/lower.isle line 1412.
6856                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6857                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6858                             let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?;
6859                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6860                             return Some(expr3_0);
6861                         }
6862                         &Opcode::Ishl => {
6863                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6864                             // Rule at src/isa/x64/lower.isle line 534.
6865                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6866                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6867                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6868                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
6869                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6870                             let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?;
6871                             let expr6_0: Type = I8X16;
6872                             let expr7_0 = ExtKind::None;
6873                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6874                             let expr9_0: Type = I8X16;
6875                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6876                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6877                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6878                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6879                             return Some(expr13_0);
6880                         }
6881                         &Opcode::Ushr => {
6882                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6883                             // Rule at src/isa/x64/lower.isle line 633.
6884                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6885                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6886                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6887                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
6888                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6889                             let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?;
6890                             let expr6_0: Type = I8X16;
6891                             let expr7_0 = ExtKind::None;
6892                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6893                             let expr9_0: Type = I8X16;
6894                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6895                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6896                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6897                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6898                             return Some(expr13_0);
6899                         }
6900                         &Opcode::Sshr => {
6901                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6902                             let pattern8_0 = C::value_type(ctx, pattern7_1);
6903                             // Rule at src/isa/x64/lower.isle line 749.
6904                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6905                             let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6906                             let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?;
6907                             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6908                             let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?;
6909                             let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6910                             let expr6_0 =
6911                                 constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?;
6912                             let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?;
6913                             let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?;
6914                             let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0);
6915                             let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?;
6916                             let expr11_0 = constructor_output_xmm(ctx, expr10_0)?;
6917                             return Some(expr11_0);
6918                         }
6919                         _ => {}
6920                     }
6921                 }
6922                 &InstructionData::Unary {
6923                     opcode: ref pattern5_0,
6924                     arg: pattern5_1,
6925                 } => {
6926                     match pattern5_0 {
6927                         &Opcode::Ineg => {
6928                             // Rule at src/isa/x64/lower.isle line 889.
6929                             let expr0_0: Type = I8X16;
6930                             let expr1_0: u64 = 0;
6931                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
6932                             let expr3_0 = C::xmm_new(ctx, expr2_0);
6933                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
6934                             let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?;
6935                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6936                             return Some(expr6_0);
6937                         }
6938                         &Opcode::Iabs => {
6939                             // Rule at src/isa/x64/lower.isle line 1210.
6940                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
6941                             let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?;
6942                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
6943                             return Some(expr2_0);
6944                         }
6945                         &Opcode::Popcnt => {
6946                             // Rule at src/isa/x64/lower.isle line 2009.
6947                             let expr0_0 = C::popcount_4bit_table(ctx);
6948                             let expr1_0: Type = I8X16;
6949                             let expr2_0 = C::popcount_low_mask(ctx);
6950                             let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?;
6951                             let expr4_0: Type = I8X16;
6952                             let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6953                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6954                             let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?;
6955                             let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6956                             let expr9_0: u32 = 4;
6957                             let expr10_0 = RegMemImm::Imm { simm32: expr9_0 };
6958                             let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?;
6959                             let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?;
6960                             let expr13_0: Type = I8X16;
6961                             let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6962                             let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?;
6963                             let expr16_0: Type = I8X16;
6964                             let expr17_0 = C::popcount_4bit_table(ctx);
6965                             let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?;
6966                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
6967                             let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?;
6968                             let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0);
6969                             let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?;
6970                             let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0);
6971                             let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?;
6972                             let expr25_0 = constructor_output_xmm(ctx, expr24_0)?;
6973                             return Some(expr25_0);
6974                         }
6975                         _ => {}
6976                     }
6977                 }
6978                 _ => {}
6979             }
6980         }
6981         if pattern2_0 == I16X8 {
6982             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6983             match &pattern4_0 {
6984                 &InstructionData::Binary {
6985                     opcode: ref pattern5_0,
6986                     args: ref pattern5_1,
6987                 } => {
6988                     match pattern5_0 {
6989                         &Opcode::Imin => {
6990                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6991                             // Rule at src/isa/x64/lower.isle line 1404.
6992                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6993                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6994                             let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?;
6995                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6996                             return Some(expr3_0);
6997                         }
6998                         &Opcode::Umin => {
6999                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7000                             // Rule at src/isa/x64/lower.isle line 1426.
7001                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7002                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7003                             let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?;
7004                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7005                             return Some(expr3_0);
7006                         }
7007                         &Opcode::Imax => {
7008                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7009                             // Rule at src/isa/x64/lower.isle line 1393.
7010                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7011                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7012                             let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?;
7013                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7014                             return Some(expr3_0);
7015                         }
7016                         &Opcode::Umax => {
7017                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7018                             // Rule at src/isa/x64/lower.isle line 1415.
7019                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7020                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7021                             let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?;
7022                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7023                             return Some(expr3_0);
7024                         }
7025                         &Opcode::Ishl => {
7026                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7027                             // Rule at src/isa/x64/lower.isle line 576.
7028                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7029                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7030                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7031                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
7032                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7033                             return Some(expr4_0);
7034                         }
7035                         &Opcode::Ushr => {
7036                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7037                             // Rule at src/isa/x64/lower.isle line 678.
7038                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7039                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7040                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7041                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
7042                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7043                             return Some(expr4_0);
7044                         }
7045                         &Opcode::Sshr => {
7046                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7047                             // Rule at src/isa/x64/lower.isle line 776.
7048                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7049                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7050                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7051                             let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?;
7052                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7053                             return Some(expr4_0);
7054                         }
7055                         _ => {}
7056                     }
7057                 }
7058                 &InstructionData::Unary {
7059                     opcode: ref pattern5_0,
7060                     arg: pattern5_1,
7061                 } => {
7062                     match pattern5_0 {
7063                         &Opcode::Ineg => {
7064                             // Rule at src/isa/x64/lower.isle line 892.
7065                             let expr0_0: Type = I16X8;
7066                             let expr1_0: u64 = 0;
7067                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7068                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7069                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7070                             let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?;
7071                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7072                             return Some(expr6_0);
7073                         }
7074                         &Opcode::Iabs => {
7075                             // Rule at src/isa/x64/lower.isle line 1213.
7076                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7077                             let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?;
7078                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7079                             return Some(expr2_0);
7080                         }
7081                         _ => {}
7082                     }
7083                 }
7084                 &InstructionData::Load {
7085                     opcode: ref pattern5_0,
7086                     arg: pattern5_1,
7087                     flags: pattern5_2,
7088                     offset: pattern5_3,
7089                 } => {
7090                     match pattern5_0 {
7091                         &Opcode::Uload8x8 => {
7092                             // Rule at src/isa/x64/lower.isle line 2558.
7093                             let expr0_0 =
7094                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7095                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7096                             let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?;
7097                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7098                             return Some(expr3_0);
7099                         }
7100                         &Opcode::Sload8x8 => {
7101                             // Rule at src/isa/x64/lower.isle line 2556.
7102                             let expr0_0 =
7103                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7104                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7105                             let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?;
7106                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7107                             return Some(expr3_0);
7108                         }
7109                         _ => {}
7110                     }
7111                 }
7112                 _ => {}
7113             }
7114         }
7115         if pattern2_0 == I32X4 {
7116             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7117             match &pattern4_0 {
7118                 &InstructionData::Binary {
7119                     opcode: ref pattern5_0,
7120                     args: ref pattern5_1,
7121                 } => {
7122                     match pattern5_0 {
7123                         &Opcode::Imin => {
7124                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7125                             // Rule at src/isa/x64/lower.isle line 1407.
7126                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7127                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7128                             let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?;
7129                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7130                             return Some(expr3_0);
7131                         }
7132                         &Opcode::Umin => {
7133                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7134                             // Rule at src/isa/x64/lower.isle line 1429.
7135                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7136                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7137                             let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?;
7138                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7139                             return Some(expr3_0);
7140                         }
7141                         &Opcode::Imax => {
7142                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7143                             // Rule at src/isa/x64/lower.isle line 1396.
7144                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7145                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7146                             let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?;
7147                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7148                             return Some(expr3_0);
7149                         }
7150                         &Opcode::Umax => {
7151                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7152                             // Rule at src/isa/x64/lower.isle line 1418.
7153                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7154                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7155                             let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?;
7156                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7157                             return Some(expr3_0);
7158                         }
7159                         &Opcode::Ishl => {
7160                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7161                             // Rule at src/isa/x64/lower.isle line 579.
7162                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7163                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7164                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7165                             let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?;
7166                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7167                             return Some(expr4_0);
7168                         }
7169                         &Opcode::Ushr => {
7170                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7171                             // Rule at src/isa/x64/lower.isle line 681.
7172                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7173                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7174                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7175                             let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?;
7176                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7177                             return Some(expr4_0);
7178                         }
7179                         &Opcode::Sshr => {
7180                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7181                             // Rule at src/isa/x64/lower.isle line 779.
7182                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7183                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7184                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7185                             let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?;
7186                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7187                             return Some(expr4_0);
7188                         }
7189                         &Opcode::WideningPairwiseDotProductS => {
7190                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7191                             // Rule at src/isa/x64/lower.isle line 2266.
7192                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7193                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7194                             let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?;
7195                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7196                             return Some(expr3_0);
7197                         }
7198                         _ => {}
7199                     }
7200                 }
7201                 &InstructionData::Unary {
7202                     opcode: ref pattern5_0,
7203                     arg: pattern5_1,
7204                 } => {
7205                     match pattern5_0 {
7206                         &Opcode::Ineg => {
7207                             // Rule at src/isa/x64/lower.isle line 895.
7208                             let expr0_0: Type = I32X4;
7209                             let expr1_0: u64 = 0;
7210                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7211                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7212                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7213                             let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?;
7214                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7215                             return Some(expr6_0);
7216                         }
7217                         &Opcode::Iabs => {
7218                             // Rule at src/isa/x64/lower.isle line 1216.
7219                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7220                             let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?;
7221                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7222                             return Some(expr2_0);
7223                         }
7224                         _ => {}
7225                     }
7226                 }
7227                 &InstructionData::Load {
7228                     opcode: ref pattern5_0,
7229                     arg: pattern5_1,
7230                     flags: pattern5_2,
7231                     offset: pattern5_3,
7232                 } => {
7233                     match pattern5_0 {
7234                         &Opcode::Uload16x4 => {
7235                             // Rule at src/isa/x64/lower.isle line 2562.
7236                             let expr0_0 =
7237                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7238                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7239                             let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?;
7240                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7241                             return Some(expr3_0);
7242                         }
7243                         &Opcode::Sload16x4 => {
7244                             // Rule at src/isa/x64/lower.isle line 2560.
7245                             let expr0_0 =
7246                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7247                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7248                             let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?;
7249                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7250                             return Some(expr3_0);
7251                         }
7252                         _ => {}
7253                     }
7254                 }
7255                 _ => {}
7256             }
7257         }
7258         if pattern2_0 == I64X2 {
7259             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7260             match &pattern4_0 {
7261                 &InstructionData::Binary {
7262                     opcode: ref pattern5_0,
7263                     args: ref pattern5_1,
7264                 } => {
7265                     match pattern5_0 {
7266                         &Opcode::Ishl => {
7267                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7268                             // Rule at src/isa/x64/lower.isle line 582.
7269                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7270                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7271                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7272                             let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?;
7273                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7274                             return Some(expr4_0);
7275                         }
7276                         &Opcode::Ushr => {
7277                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7278                             // Rule at src/isa/x64/lower.isle line 684.
7279                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7280                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7281                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7282                             let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?;
7283                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7284                             return Some(expr4_0);
7285                         }
7286                         &Opcode::Sshr => {
7287                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7288                             // Rule at src/isa/x64/lower.isle line 790.
7289                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7290                             let expr1_0: Type = I64;
7291                             let expr2_0: u8 = 0;
7292                             let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?;
7293                             let expr4_0: Type = I64;
7294                             let expr5_0: u8 = 1;
7295                             let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?;
7296                             let expr7_0: Type = I64;
7297                             let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0);
7298                             let expr9_0: Type = I64;
7299                             let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?;
7300                             let expr11_0: Type = I64;
7301                             let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?;
7302                             let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0);
7303                             let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
7304                             let expr15_0 =
7305                                 constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?;
7306                             let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
7307                             return Some(expr16_0);
7308                         }
7309                         _ => {}
7310                     }
7311                 }
7312                 &InstructionData::Unary {
7313                     opcode: ref pattern5_0,
7314                     arg: pattern5_1,
7315                 } => {
7316                     match pattern5_0 {
7317                         &Opcode::Ineg => {
7318                             // Rule at src/isa/x64/lower.isle line 898.
7319                             let expr0_0: Type = I64X2;
7320                             let expr1_0: u64 = 0;
7321                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7322                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7323                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7324                             let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?;
7325                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7326                             return Some(expr6_0);
7327                         }
7328                         &Opcode::Iabs => {
7329                             // Rule at src/isa/x64/lower.isle line 1230.
7330                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7331                             let expr1_0: Type = I64X2;
7332                             let expr2_0: u64 = 0;
7333                             let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
7334                             let expr4_0 = C::xmm_new(ctx, expr3_0);
7335                             let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7336                             let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?;
7337                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7338                             let expr8_0 =
7339                                 constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?;
7340                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7341                             return Some(expr9_0);
7342                         }
7343                         _ => {}
7344                     }
7345                 }
7346                 &InstructionData::Load {
7347                     opcode: ref pattern5_0,
7348                     arg: pattern5_1,
7349                     flags: pattern5_2,
7350                     offset: pattern5_3,
7351                 } => {
7352                     match pattern5_0 {
7353                         &Opcode::Uload32x2 => {
7354                             // Rule at src/isa/x64/lower.isle line 2566.
7355                             let expr0_0 =
7356                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7357                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7358                             let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?;
7359                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7360                             return Some(expr3_0);
7361                         }
7362                         &Opcode::Sload32x2 => {
7363                             // Rule at src/isa/x64/lower.isle line 2564.
7364                             let expr0_0 =
7365                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7366                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7367                             let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?;
7368                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7369                             return Some(expr3_0);
7370                         }
7371                         _ => {}
7372                     }
7373                 }
7374                 _ => {}
7375             }
7376         }
7377         if pattern2_0 == F32X4 {
7378             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7379             match &pattern4_0 {
7380                 &InstructionData::Binary {
7381                     opcode: ref pattern5_0,
7382                     args: ref pattern5_1,
7383                 } => {
7384                     match pattern5_0 {
7385                         &Opcode::Fadd => {
7386                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7387                             // Rule at src/isa/x64/lower.isle line 2280.
7388                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7389                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7390                             let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?;
7391                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7392                             return Some(expr3_0);
7393                         }
7394                         &Opcode::Fsub => {
7395                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7396                             // Rule at src/isa/x64/lower.isle line 2291.
7397                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7398                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7399                             let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?;
7400                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7401                             return Some(expr3_0);
7402                         }
7403                         &Opcode::Fmul => {
7404                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7405                             // Rule at src/isa/x64/lower.isle line 2302.
7406                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7407                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7408                             let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?;
7409                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7410                             return Some(expr3_0);
7411                         }
7412                         &Opcode::Fdiv => {
7413                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7414                             // Rule at src/isa/x64/lower.isle line 2313.
7415                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7416                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7417                             let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?;
7418                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7419                             return Some(expr3_0);
7420                         }
7421                         &Opcode::Fmin => {
7422                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7423                             // Rule at src/isa/x64/lower.isle line 2337.
7424                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7425                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7426                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7427                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7428                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7429                             let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?;
7430                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7431                             let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?;
7432                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7433                             let expr9_0 = FcmpImm::Unordered;
7434                             let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?;
7435                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7436                             let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?;
7437                             let expr13_0: u32 = 10;
7438                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7439                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7440                             let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?;
7441                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7442                             let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?;
7443                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7444                             return Some(expr19_0);
7445                         }
7446                         &Opcode::FminPseudo => {
7447                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7448                             // Rule at src/isa/x64/lower.isle line 2493.
7449                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7450                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7451                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7452                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7453                             return Some(expr3_0);
7454                         }
7455                         &Opcode::Fmax => {
7456                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7457                             // Rule at src/isa/x64/lower.isle line 2400.
7458                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7459                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7460                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7461                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7462                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7463                             let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?;
7464                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7465                             let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?;
7466                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7467                             let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?;
7468                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7469                             let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?;
7470                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7471                             let expr13_0 = FcmpImm::Unordered;
7472                             let expr14_0 =
7473                                 constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?;
7474                             let expr15_0: u32 = 10;
7475                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7476                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7477                             let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?;
7478                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7479                             let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?;
7480                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7481                             return Some(expr21_0);
7482                         }
7483                         &Opcode::FmaxPseudo => {
7484                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7485                             // Rule at src/isa/x64/lower.isle line 2504.
7486                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7487                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7488                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7489                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7490                             return Some(expr3_0);
7491                         }
7492                         _ => {}
7493                     }
7494                 }
7495                 &InstructionData::Unary {
7496                     opcode: ref pattern5_0,
7497                     arg: pattern5_1,
7498                 } => {
7499                     if let &Opcode::Fabs = pattern5_0 {
7500                         // Rule at src/isa/x64/lower.isle line 1238.
7501                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7502                         let expr1_0: Type = F32X4;
7503                         let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7504                         let expr3_0: u32 = 1;
7505                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7506                         let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7507                         let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?;
7508                         let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7509                         let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?;
7510                         let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7511                         return Some(expr9_0);
7512                     }
7513                 }
7514                 &InstructionData::Load {
7515                     opcode: ref pattern5_0,
7516                     arg: pattern5_1,
7517                     flags: pattern5_2,
7518                     offset: pattern5_3,
7519                 } => {
7520                     if let &Opcode::Load = pattern5_0 {
7521                         // Rule at src/isa/x64/lower.isle line 2547.
7522                         let expr0_0 =
7523                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7524                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7525                         let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?;
7526                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7527                         return Some(expr3_0);
7528                     }
7529                 }
7530                 _ => {}
7531             }
7532         }
7533         if pattern2_0 == F64X2 {
7534             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7535             match &pattern4_0 {
7536                 &InstructionData::Binary {
7537                     opcode: ref pattern5_0,
7538                     args: ref pattern5_1,
7539                 } => {
7540                     match pattern5_0 {
7541                         &Opcode::Fadd => {
7542                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7543                             // Rule at src/isa/x64/lower.isle line 2282.
7544                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7545                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7546                             let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?;
7547                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7548                             return Some(expr3_0);
7549                         }
7550                         &Opcode::Fsub => {
7551                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7552                             // Rule at src/isa/x64/lower.isle line 2293.
7553                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7554                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7555                             let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?;
7556                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7557                             return Some(expr3_0);
7558                         }
7559                         &Opcode::Fmul => {
7560                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7561                             // Rule at src/isa/x64/lower.isle line 2304.
7562                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7563                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7564                             let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?;
7565                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7566                             return Some(expr3_0);
7567                         }
7568                         &Opcode::Fdiv => {
7569                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7570                             // Rule at src/isa/x64/lower.isle line 2315.
7571                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7572                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7573                             let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?;
7574                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7575                             return Some(expr3_0);
7576                         }
7577                         &Opcode::Fmin => {
7578                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7579                             // Rule at src/isa/x64/lower.isle line 2380.
7580                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7581                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7582                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7583                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7584                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7585                             let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?;
7586                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7587                             let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?;
7588                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7589                             let expr9_0 = FcmpImm::Unordered;
7590                             let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?;
7591                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7592                             let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?;
7593                             let expr13_0: u32 = 13;
7594                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7595                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7596                             let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?;
7597                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7598                             let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?;
7599                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7600                             return Some(expr19_0);
7601                         }
7602                         &Opcode::FminPseudo => {
7603                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7604                             // Rule at src/isa/x64/lower.isle line 2495.
7605                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7606                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7607                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7608                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7609                             return Some(expr3_0);
7610                         }
7611                         &Opcode::Fmax => {
7612                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7613                             // Rule at src/isa/x64/lower.isle line 2443.
7614                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7615                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7616                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7617                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7618                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7619                             let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?;
7620                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7621                             let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?;
7622                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7623                             let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?;
7624                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7625                             let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?;
7626                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7627                             let expr13_0 = FcmpImm::Unordered;
7628                             let expr14_0 =
7629                                 constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?;
7630                             let expr15_0: u32 = 13;
7631                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7632                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7633                             let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?;
7634                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7635                             let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?;
7636                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7637                             return Some(expr21_0);
7638                         }
7639                         &Opcode::FmaxPseudo => {
7640                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7641                             // Rule at src/isa/x64/lower.isle line 2506.
7642                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7643                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7644                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7645                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7646                             return Some(expr3_0);
7647                         }
7648                         _ => {}
7649                     }
7650                 }
7651                 &InstructionData::Unary {
7652                     opcode: ref pattern5_0,
7653                     arg: pattern5_1,
7654                 } => {
7655                     if let &Opcode::Fabs = pattern5_0 {
7656                         // Rule at src/isa/x64/lower.isle line 1244.
7657                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7658                         let expr1_0: Type = F64X2;
7659                         let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7660                         let expr3_0: u32 = 1;
7661                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7662                         let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7663                         let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?;
7664                         let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7665                         let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?;
7666                         let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7667                         return Some(expr9_0);
7668                     }
7669                 }
7670                 &InstructionData::Load {
7671                     opcode: ref pattern5_0,
7672                     arg: pattern5_1,
7673                     flags: pattern5_2,
7674                     offset: pattern5_3,
7675                 } => {
7676                     if let &Opcode::Load = pattern5_0 {
7677                         // Rule at src/isa/x64/lower.isle line 2549.
7678                         let expr0_0 =
7679                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7680                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7681                         let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?;
7682                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7683                         return Some(expr3_0);
7684                     }
7685                 }
7686                 _ => {}
7687             }
7688         }
7689         let pattern3_0 = C::inst_data(ctx, pattern0_0);
7690         match &pattern3_0 {
7691             &InstructionData::NullAry {
7692                 opcode: ref pattern4_0,
7693             } => {
7694                 if let &Opcode::Null = pattern4_0 {
7695                     // Rule at src/isa/x64/lower.isle line 56.
7696                     let expr0_0: u64 = 0;
7697                     let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?;
7698                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
7699                     return Some(expr2_0);
7700                 }
7701             }
7702             &InstructionData::Binary {
7703                 opcode: ref pattern4_0,
7704                 args: ref pattern4_1,
7705             } => {
7706                 if let &Opcode::BandNot = pattern4_0 {
7707                     let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
7708                     // Rule at src/isa/x64/lower.isle line 1205.
7709                     let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?;
7710                     let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?;
7711                     let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?;
7712                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7713                     return Some(expr3_0);
7714                 }
7715             }
7716             &InstructionData::Ternary {
7717                 opcode: ref pattern4_0,
7718                 args: ref pattern4_1,
7719             } => {
7720                 if let &Opcode::Select = pattern4_0 {
7721                     let (pattern6_0, pattern6_1, pattern6_2) =
7722                         C::unpack_value_array_3(ctx, pattern4_1);
7723                     if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
7724                         let pattern8_0 = C::inst_data(ctx, pattern7_0);
7725                         match &pattern8_0 {
7726                             &InstructionData::FloatCompare {
7727                                 opcode: ref pattern9_0,
7728                                 args: ref pattern9_1,
7729                                 cond: ref pattern9_2,
7730                             } => {
7731                                 if let &Opcode::Fcmp = pattern9_0 {
7732                                     let (pattern11_0, pattern11_1) =
7733                                         C::unpack_value_array_2(ctx, pattern9_1);
7734                                     match pattern9_2 {
7735                                         &FloatCC::Equal => {
7736                                             // Rule at src/isa/x64/lower.isle line 1742.
7737                                             let expr0_0 = constructor_x64_ucomis(
7738                                                 ctx,
7739                                                 pattern11_0,
7740                                                 pattern11_1,
7741                                             )?;
7742                                             let expr1_0 = CC::NZ;
7743                                             let expr2_0 = CC::P;
7744                                             let expr3_0 = constructor_cmove_or_from_values(
7745                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2,
7746                                                 pattern6_1,
7747                                             )?;
7748                                             let expr4_0 =
7749                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7750                                             let expr5_0 = C::output(ctx, expr4_0);
7751                                             return Some(expr5_0);
7752                                         }
7753                                         &FloatCC::GreaterThan => {
7754                                             // Rule at src/isa/x64/lower.isle line 1694.
7755                                             let expr0_0 = constructor_x64_ucomis(
7756                                                 ctx,
7757                                                 pattern11_1,
7758                                                 pattern11_0,
7759                                             )?;
7760                                             let expr1_0 = CC::NBE;
7761                                             let expr2_0 = constructor_cmove_from_values(
7762                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7763                                             )?;
7764                                             let expr3_0 =
7765                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7766                                             let expr4_0 = C::output(ctx, expr3_0);
7767                                             return Some(expr4_0);
7768                                         }
7769                                         &FloatCC::GreaterThanOrEqual => {
7770                                             // Rule at src/isa/x64/lower.isle line 1697.
7771                                             let expr0_0 = constructor_x64_ucomis(
7772                                                 ctx,
7773                                                 pattern11_1,
7774                                                 pattern11_0,
7775                                             )?;
7776                                             let expr1_0 = CC::NB;
7777                                             let expr2_0 = constructor_cmove_from_values(
7778                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7779                                             )?;
7780                                             let expr3_0 =
7781                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7782                                             let expr4_0 = C::output(ctx, expr3_0);
7783                                             return Some(expr4_0);
7784                                         }
7785                                         &FloatCC::LessThan => {
7786                                             // Rule at src/isa/x64/lower.isle line 1717.
7787                                             let expr0_0 = constructor_x64_ucomis(
7788                                                 ctx,
7789                                                 pattern11_0,
7790                                                 pattern11_1,
7791                                             )?;
7792                                             let expr1_0 = CC::NBE;
7793                                             let expr2_0 = constructor_cmove_from_values(
7794                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7795                                             )?;
7796                                             let expr3_0 =
7797                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7798                                             let expr4_0 = C::output(ctx, expr3_0);
7799                                             return Some(expr4_0);
7800                                         }
7801                                         &FloatCC::LessThanOrEqual => {
7802                                             // Rule at src/isa/x64/lower.isle line 1720.
7803                                             let expr0_0 = constructor_x64_ucomis(
7804                                                 ctx,
7805                                                 pattern11_0,
7806                                                 pattern11_1,
7807                                             )?;
7808                                             let expr1_0 = CC::NB;
7809                                             let expr2_0 = constructor_cmove_from_values(
7810                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7811                                             )?;
7812                                             let expr3_0 =
7813                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7814                                             let expr4_0 = C::output(ctx, expr3_0);
7815                                             return Some(expr4_0);
7816                                         }
7817                                         &FloatCC::NotEqual => {
7818                                             // Rule at src/isa/x64/lower.isle line 1745.
7819                                             let expr0_0 = constructor_x64_ucomis(
7820                                                 ctx,
7821                                                 pattern11_0,
7822                                                 pattern11_1,
7823                                             )?;
7824                                             let expr1_0 = CC::NZ;
7825                                             let expr2_0 = CC::P;
7826                                             let expr3_0 = constructor_cmove_or_from_values(
7827                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1,
7828                                                 pattern6_2,
7829                                             )?;
7830                                             let expr4_0 =
7831                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7832                                             let expr5_0 = C::output(ctx, expr4_0);
7833                                             return Some(expr5_0);
7834                                         }
7835                                         &FloatCC::Ordered => {
7836                                             // Rule at src/isa/x64/lower.isle line 1688.
7837                                             let expr0_0 = constructor_x64_ucomis(
7838                                                 ctx,
7839                                                 pattern11_1,
7840                                                 pattern11_0,
7841                                             )?;
7842                                             let expr1_0 = CC::NP;
7843                                             let expr2_0 = constructor_cmove_from_values(
7844                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7845                                             )?;
7846                                             let expr3_0 =
7847                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7848                                             let expr4_0 = C::output(ctx, expr3_0);
7849                                             return Some(expr4_0);
7850                                         }
7851                                         &FloatCC::Unordered => {
7852                                             // Rule at src/isa/x64/lower.isle line 1691.
7853                                             let expr0_0 = constructor_x64_ucomis(
7854                                                 ctx,
7855                                                 pattern11_1,
7856                                                 pattern11_0,
7857                                             )?;
7858                                             let expr1_0 = CC::P;
7859                                             let expr2_0 = constructor_cmove_from_values(
7860                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7861                                             )?;
7862                                             let expr3_0 =
7863                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7864                                             let expr4_0 = C::output(ctx, expr3_0);
7865                                             return Some(expr4_0);
7866                                         }
7867                                         &FloatCC::UnorderedOrGreaterThan => {
7868                                             // Rule at src/isa/x64/lower.isle line 1723.
7869                                             let expr0_0 = constructor_x64_ucomis(
7870                                                 ctx,
7871                                                 pattern11_0,
7872                                                 pattern11_1,
7873                                             )?;
7874                                             let expr1_0 = CC::B;
7875                                             let expr2_0 = constructor_cmove_from_values(
7876                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7877                                             )?;
7878                                             let expr3_0 =
7879                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7880                                             let expr4_0 = C::output(ctx, expr3_0);
7881                                             return Some(expr4_0);
7882                                         }
7883                                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
7884                                             // Rule at src/isa/x64/lower.isle line 1726.
7885                                             let expr0_0 = constructor_x64_ucomis(
7886                                                 ctx,
7887                                                 pattern11_0,
7888                                                 pattern11_1,
7889                                             )?;
7890                                             let expr1_0 = CC::BE;
7891                                             let expr2_0 = constructor_cmove_from_values(
7892                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7893                                             )?;
7894                                             let expr3_0 =
7895                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7896                                             let expr4_0 = C::output(ctx, expr3_0);
7897                                             return Some(expr4_0);
7898                                         }
7899                                         &FloatCC::UnorderedOrLessThan => {
7900                                             // Rule at src/isa/x64/lower.isle line 1700.
7901                                             let expr0_0 = constructor_x64_ucomis(
7902                                                 ctx,
7903                                                 pattern11_1,
7904                                                 pattern11_0,
7905                                             )?;
7906                                             let expr1_0 = CC::B;
7907                                             let expr2_0 = constructor_cmove_from_values(
7908                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7909                                             )?;
7910                                             let expr3_0 =
7911                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7912                                             let expr4_0 = C::output(ctx, expr3_0);
7913                                             return Some(expr4_0);
7914                                         }
7915                                         &FloatCC::UnorderedOrLessThanOrEqual => {
7916                                             // Rule at src/isa/x64/lower.isle line 1703.
7917                                             let expr0_0 = constructor_x64_ucomis(
7918                                                 ctx,
7919                                                 pattern11_1,
7920                                                 pattern11_0,
7921                                             )?;
7922                                             let expr1_0 = CC::BE;
7923                                             let expr2_0 = constructor_cmove_from_values(
7924                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7925                                             )?;
7926                                             let expr3_0 =
7927                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7928                                             let expr4_0 = C::output(ctx, expr3_0);
7929                                             return Some(expr4_0);
7930                                         }
7931                                         _ => {}
7932                                     }
7933                                 }
7934                             }
7935                             &InstructionData::IntCompare {
7936                                 opcode: ref pattern9_0,
7937                                 args: ref pattern9_1,
7938                                 cond: ref pattern9_2,
7939                             } => {
7940                                 if let &Opcode::Icmp = pattern9_0 {
7941                                     let (pattern11_0, pattern11_1) =
7942                                         C::unpack_value_array_2(ctx, pattern9_1);
7943                                     let pattern12_0 = C::value_type(ctx, pattern11_0);
7944                                     if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) {
7945                                         // Rule at src/isa/x64/lower.isle line 1753.
7946                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
7947                                         let expr1_0 = constructor_put_in_gpr(ctx, pattern11_1)?;
7948                                         let expr2_0 = C::raw_operand_size_of_type(ctx, pattern13_0);
7949                                         let expr3_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7950                                         let expr4_0 =
7951                                             constructor_x64_cmp(ctx, &expr2_0, &expr3_0, expr0_0)?;
7952                                         let expr5_0 = C::intcc_to_cc(ctx, pattern9_2);
7953                                         let expr6_0 = constructor_cmove_from_values(
7954                                             ctx, pattern2_0, &expr5_0, pattern6_1, pattern6_2,
7955                                         )?;
7956                                         let expr7_0 =
7957                                             constructor_with_flags(ctx, &expr4_0, &expr6_0)?;
7958                                         let expr8_0 = C::output(ctx, expr7_0);
7959                                         return Some(expr8_0);
7960                                     }
7961                                 }
7962                             }
7963                             _ => {}
7964                         }
7965                     }
7966                     let pattern7_0 = C::value_type(ctx, pattern6_0);
7967                     if pattern7_0 == B1 {
7968                         // Rule at src/isa/x64/lower.isle line 1771.
7969                         let expr0_0: Type = B1;
7970                         let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0);
7971                         let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
7972                         let expr3_0: u32 = 1;
7973                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7974                         let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0);
7975                         let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?;
7976                         let expr7_0 = CC::NZ;
7977                         let expr8_0 = constructor_cmove_from_values(
7978                             ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2,
7979                         )?;
7980                         let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?;
7981                         let expr10_0 = C::output(ctx, expr9_0);
7982                         return Some(expr10_0);
7983                     }
7984                     if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) {
7985                         // Rule at src/isa/x64/lower.isle line 1778.
7986                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0);
7987                         let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
7988                         let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7989                         let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?;
7990                         let expr4_0 = CC::NZ;
7991                         let expr5_0 = constructor_cmove_from_values(
7992                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
7993                         )?;
7994                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
7995                         let expr7_0 = C::output(ctx, expr6_0);
7996                         return Some(expr7_0);
7997                     }
7998                 }
7999             }
8000             &InstructionData::Unary {
8001                 opcode: ref pattern4_0,
8002                 arg: pattern4_1,
8003             } => {
8004                 match pattern4_0 {
8005                     &Opcode::Breduce => {
8006                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8007                         if pattern6_0 == pattern2_0 {
8008                             // Rule at src/isa/x64/lower.isle line 2239.
8009                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8010                             return Some(expr0_0);
8011                         }
8012                     }
8013                     &Opcode::Bextend => {
8014                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8015                         // Rule at src/isa/x64/lower.isle line 2220.
8016                         let expr0_0 =
8017                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8018                         return Some(expr0_0);
8019                     }
8020                     &Opcode::Ireduce => {
8021                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8022                         if pattern6_0 == pattern2_0 {
8023                             // Rule at src/isa/x64/lower.isle line 2228.
8024                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8025                             return Some(expr0_0);
8026                         }
8027                     }
8028                     &Opcode::Uextend => {
8029                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8030                         if pattern6_0 == pattern2_0 {
8031                             // Rule at src/isa/x64/lower.isle line 2121.
8032                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8033                             return Some(expr0_0);
8034                         }
8035                     }
8036                     &Opcode::Sextend => {
8037                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8038                         // Rule at src/isa/x64/lower.isle line 2214.
8039                         let expr0_0 =
8040                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8041                         return Some(expr0_0);
8042                     }
8043                     _ => {}
8044                 }
8045             }
8046             _ => {}
8047         }
8048         if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
8049             if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) {
8050                 if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) {
8051                     if pattern5_0 == 64 {
8052                         if pattern5_1 == 2 {
8053                             let pattern8_0 = C::inst_data(ctx, pattern0_0);
8054                             if let &InstructionData::Binary {
8055                                 opcode: ref pattern9_0,
8056                                 args: ref pattern9_1,
8057                             } = &pattern8_0
8058                             {
8059                                 if let &Opcode::Imul = pattern9_0 {
8060                                     let (pattern11_0, pattern11_1) =
8061                                         C::unpack_value_array_2(ctx, pattern9_1);
8062                                     // Rule at src/isa/x64/lower.isle line 992.
8063                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?;
8064                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?;
8065                                     let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?;
8066                                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8067                                     return Some(expr3_0);
8068                                 }
8069                             }
8070                         }
8071                     }
8072                 }
8073             }
8074             if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) {
8075                 if pattern2_0 == I64X2 {
8076                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8077                     if let &InstructionData::Unary {
8078                         opcode: ref pattern7_0,
8079                         arg: pattern7_1,
8080                     } = &pattern6_0
8081                     {
8082                         if let &Opcode::Iabs = pattern7_0 {
8083                             // Rule at src/isa/x64/lower.isle line 1220.
8084                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8085                             let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?;
8086                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8087                             return Some(expr2_0);
8088                         }
8089                     }
8090                 }
8091             }
8092         }
8093         if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) {
8094             if pattern3_0 == 8 {
8095                 if pattern3_1 == 16 {
8096                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8097                     if let &InstructionData::Binary {
8098                         opcode: ref pattern7_0,
8099                         args: ref pattern7_1,
8100                     } = &pattern6_0
8101                     {
8102                         match pattern7_0 {
8103                             &Opcode::AvgRound => {
8104                                 let (pattern9_0, pattern9_1) =
8105                                     C::unpack_value_array_2(ctx, pattern7_1);
8106                                 // Rule at src/isa/x64/lower.isle line 903.
8107                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8108                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8109                                 let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?;
8110                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8111                                 return Some(expr3_0);
8112                             }
8113                             &Opcode::UaddSat => {
8114                                 let (pattern9_0, pattern9_1) =
8115                                     C::unpack_value_array_2(ctx, pattern7_1);
8116                                 // Rule at src/isa/x64/lower.isle line 136.
8117                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8118                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8119                                 let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?;
8120                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8121                                 return Some(expr3_0);
8122                             }
8123                             &Opcode::SaddSat => {
8124                                 let (pattern9_0, pattern9_1) =
8125                                     C::unpack_value_array_2(ctx, pattern7_1);
8126                                 // Rule at src/isa/x64/lower.isle line 126.
8127                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8128                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8129                                 let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?;
8130                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8131                                 return Some(expr3_0);
8132                             }
8133                             &Opcode::UsubSat => {
8134                                 let (pattern9_0, pattern9_1) =
8135                                     C::unpack_value_array_2(ctx, pattern7_1);
8136                                 // Rule at src/isa/x64/lower.isle line 282.
8137                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8138                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8139                                 let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?;
8140                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8141                                 return Some(expr3_0);
8142                             }
8143                             &Opcode::SsubSat => {
8144                                 let (pattern9_0, pattern9_1) =
8145                                     C::unpack_value_array_2(ctx, pattern7_1);
8146                                 // Rule at src/isa/x64/lower.isle line 272.
8147                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8148                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8149                                 let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?;
8150                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8151                                 return Some(expr3_0);
8152                             }
8153                             &Opcode::Iadd => {
8154                                 let (pattern9_0, pattern9_1) =
8155                                     C::unpack_value_array_2(ctx, pattern7_1);
8156                                 // Rule at src/isa/x64/lower.isle line 94.
8157                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8158                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8159                                 let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?;
8160                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8161                                 return Some(expr3_0);
8162                             }
8163                             &Opcode::Isub => {
8164                                 let (pattern9_0, pattern9_1) =
8165                                     C::unpack_value_array_2(ctx, pattern7_1);
8166                                 // Rule at src/isa/x64/lower.isle line 240.
8167                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8168                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8169                                 let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?;
8170                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8171                                 return Some(expr3_0);
8172                             }
8173                             _ => {}
8174                         }
8175                     }
8176                 }
8177             }
8178             if pattern3_0 == 16 {
8179                 if pattern3_1 == 8 {
8180                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8181                     if let &InstructionData::Binary {
8182                         opcode: ref pattern7_0,
8183                         args: ref pattern7_1,
8184                     } = &pattern6_0
8185                     {
8186                         match pattern7_0 {
8187                             &Opcode::AvgRound => {
8188                                 let (pattern9_0, pattern9_1) =
8189                                     C::unpack_value_array_2(ctx, pattern7_1);
8190                                 // Rule at src/isa/x64/lower.isle line 907.
8191                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8192                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8193                                 let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?;
8194                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8195                                 return Some(expr3_0);
8196                             }
8197                             &Opcode::UaddSat => {
8198                                 let (pattern9_0, pattern9_1) =
8199                                     C::unpack_value_array_2(ctx, pattern7_1);
8200                                 // Rule at src/isa/x64/lower.isle line 140.
8201                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8202                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8203                                 let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?;
8204                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8205                                 return Some(expr3_0);
8206                             }
8207                             &Opcode::SaddSat => {
8208                                 let (pattern9_0, pattern9_1) =
8209                                     C::unpack_value_array_2(ctx, pattern7_1);
8210                                 // Rule at src/isa/x64/lower.isle line 130.
8211                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8212                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8213                                 let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?;
8214                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8215                                 return Some(expr3_0);
8216                             }
8217                             &Opcode::UsubSat => {
8218                                 let (pattern9_0, pattern9_1) =
8219                                     C::unpack_value_array_2(ctx, pattern7_1);
8220                                 // Rule at src/isa/x64/lower.isle line 286.
8221                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8222                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8223                                 let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?;
8224                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8225                                 return Some(expr3_0);
8226                             }
8227                             &Opcode::SsubSat => {
8228                                 let (pattern9_0, pattern9_1) =
8229                                     C::unpack_value_array_2(ctx, pattern7_1);
8230                                 // Rule at src/isa/x64/lower.isle line 276.
8231                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8232                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8233                                 let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?;
8234                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8235                                 return Some(expr3_0);
8236                             }
8237                             &Opcode::Iadd => {
8238                                 let (pattern9_0, pattern9_1) =
8239                                     C::unpack_value_array_2(ctx, pattern7_1);
8240                                 // Rule at src/isa/x64/lower.isle line 98.
8241                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8242                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8243                                 let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?;
8244                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8245                                 return Some(expr3_0);
8246                             }
8247                             &Opcode::Isub => {
8248                                 let (pattern9_0, pattern9_1) =
8249                                     C::unpack_value_array_2(ctx, pattern7_1);
8250                                 // Rule at src/isa/x64/lower.isle line 244.
8251                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8252                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8253                                 let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?;
8254                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8255                                 return Some(expr3_0);
8256                             }
8257                             &Opcode::Imul => {
8258                                 let (pattern9_0, pattern9_1) =
8259                                     C::unpack_value_array_2(ctx, pattern7_1);
8260                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8261                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8262                                     if let &InstructionData::Unary {
8263                                         opcode: ref pattern12_0,
8264                                         arg: pattern12_1,
8265                                     } = &pattern11_0
8266                                     {
8267                                         match pattern12_0 {
8268                                             &Opcode::SwidenLow => {
8269                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8270                                                 if let Some((pattern15_0, pattern15_1)) =
8271                                                     C::multi_lane(ctx, pattern14_0)
8272                                                 {
8273                                                     if pattern15_0 == 8 {
8274                                                         if pattern15_1 == 16 {
8275                                                             if let Some(pattern18_0) =
8276                                                                 C::def_inst(ctx, pattern9_1)
8277                                                             {
8278                                                                 let pattern19_0 =
8279                                                                     C::inst_data(ctx, pattern18_0);
8280                                                                 if let &InstructionData::Unary {
8281                                                                     opcode: ref pattern20_0,
8282                                                                     arg: pattern20_1,
8283                                                                 } = &pattern19_0
8284                                                                 {
8285                                                                     if let &Opcode::SwidenLow =
8286                                                                         pattern20_0
8287                                                                     {
8288                                                                         let pattern22_0 =
8289                                                                             C::value_type(
8290                                                                                 ctx,
8291                                                                                 pattern20_1,
8292                                                                             );
8293                                                                         if let Some((
8294                                                                             pattern23_0,
8295                                                                             pattern23_1,
8296                                                                         )) = C::multi_lane(
8297                                                                             ctx,
8298                                                                             pattern22_0,
8299                                                                         ) {
8300                                                                             if pattern23_0 == 8 {
8301                                                                                 if pattern23_1 == 16
8302                                                                                 {
8303                                                                                     // Rule at src/isa/x64/lower.isle line 1080.
8304                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8305                                                                                     let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?;
8306                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8307                                                                                     let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?;
8308                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8309                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8310                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8311                                                                                     return Some(
8312                                                                                         expr6_0,
8313                                                                                     );
8314                                                                                 }
8315                                                                             }
8316                                                                         }
8317                                                                     }
8318                                                                 }
8319                                                             }
8320                                                         }
8321                                                     }
8322                                                 }
8323                                             }
8324                                             &Opcode::SwidenHigh => {
8325                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8326                                                 if let Some((pattern15_0, pattern15_1)) =
8327                                                     C::multi_lane(ctx, pattern14_0)
8328                                                 {
8329                                                     if pattern15_0 == 8 {
8330                                                         if pattern15_1 == 16 {
8331                                                             if let Some(pattern18_0) =
8332                                                                 C::def_inst(ctx, pattern9_1)
8333                                                             {
8334                                                                 let pattern19_0 =
8335                                                                     C::inst_data(ctx, pattern18_0);
8336                                                                 if let &InstructionData::Unary {
8337                                                                     opcode: ref pattern20_0,
8338                                                                     arg: pattern20_1,
8339                                                                 } = &pattern19_0
8340                                                                 {
8341                                                                     if let &Opcode::SwidenHigh =
8342                                                                         pattern20_0
8343                                                                     {
8344                                                                         let pattern22_0 =
8345                                                                             C::value_type(
8346                                                                                 ctx,
8347                                                                                 pattern20_1,
8348                                                                             );
8349                                                                         if let Some((
8350                                                                             pattern23_0,
8351                                                                             pattern23_1,
8352                                                                         )) = C::multi_lane(
8353                                                                             ctx,
8354                                                                             pattern22_0,
8355                                                                         ) {
8356                                                                             if pattern23_0 == 8 {
8357                                                                                 if pattern23_1 == 16
8358                                                                                 {
8359                                                                                     // Rule at src/isa/x64/lower.isle line 1040.
8360                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8361                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8362                                                                                     let expr2_0: u8 = 8;
8363                                                                                     let expr3_0 = OperandSize::Size32;
8364                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8365                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8366                                                                                     let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?;
8367                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8368                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8369                                                                                     let expr9_0: u8 = 8;
8370                                                                                     let expr10_0 = OperandSize::Size32;
8371                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8372                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8373                                                                                     let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?;
8374                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8375                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8376                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8377                                                                                     return Some(
8378                                                                                         expr16_0,
8379                                                                                     );
8380                                                                                 }
8381                                                                             }
8382                                                                         }
8383                                                                     }
8384                                                                 }
8385                                                             }
8386                                                         }
8387                                                     }
8388                                                 }
8389                                             }
8390                                             &Opcode::UwidenLow => {
8391                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8392                                                 if let Some((pattern15_0, pattern15_1)) =
8393                                                     C::multi_lane(ctx, pattern14_0)
8394                                                 {
8395                                                     if pattern15_0 == 8 {
8396                                                         if pattern15_1 == 16 {
8397                                                             if let Some(pattern18_0) =
8398                                                                 C::def_inst(ctx, pattern9_1)
8399                                                             {
8400                                                                 let pattern19_0 =
8401                                                                     C::inst_data(ctx, pattern18_0);
8402                                                                 if let &InstructionData::Unary {
8403                                                                     opcode: ref pattern20_0,
8404                                                                     arg: pattern20_1,
8405                                                                 } = &pattern19_0
8406                                                                 {
8407                                                                     if let &Opcode::UwidenLow =
8408                                                                         pattern20_0
8409                                                                     {
8410                                                                         let pattern22_0 =
8411                                                                             C::value_type(
8412                                                                                 ctx,
8413                                                                                 pattern20_1,
8414                                                                             );
8415                                                                         if let Some((
8416                                                                             pattern23_0,
8417                                                                             pattern23_1,
8418                                                                         )) = C::multi_lane(
8419                                                                             ctx,
8420                                                                             pattern22_0,
8421                                                                         ) {
8422                                                                             if pattern23_0 == 8 {
8423                                                                                 if pattern23_1 == 16
8424                                                                                 {
8425                                                                                     // Rule at src/isa/x64/lower.isle line 1156.
8426                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8427                                                                                     let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?;
8428                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8429                                                                                     let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?;
8430                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8431                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8432                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8433                                                                                     return Some(
8434                                                                                         expr6_0,
8435                                                                                     );
8436                                                                                 }
8437                                                                             }
8438                                                                         }
8439                                                                     }
8440                                                                 }
8441                                                             }
8442                                                         }
8443                                                     }
8444                                                 }
8445                                             }
8446                                             &Opcode::UwidenHigh => {
8447                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8448                                                 if let Some((pattern15_0, pattern15_1)) =
8449                                                     C::multi_lane(ctx, pattern14_0)
8450                                                 {
8451                                                     if pattern15_0 == 8 {
8452                                                         if pattern15_1 == 16 {
8453                                                             if let Some(pattern18_0) =
8454                                                                 C::def_inst(ctx, pattern9_1)
8455                                                             {
8456                                                                 let pattern19_0 =
8457                                                                     C::inst_data(ctx, pattern18_0);
8458                                                                 if let &InstructionData::Unary {
8459                                                                     opcode: ref pattern20_0,
8460                                                                     arg: pattern20_1,
8461                                                                 } = &pattern19_0
8462                                                                 {
8463                                                                     if let &Opcode::UwidenHigh =
8464                                                                         pattern20_0
8465                                                                     {
8466                                                                         let pattern22_0 =
8467                                                                             C::value_type(
8468                                                                                 ctx,
8469                                                                                 pattern20_1,
8470                                                                             );
8471                                                                         if let Some((
8472                                                                             pattern23_0,
8473                                                                             pattern23_1,
8474                                                                         )) = C::multi_lane(
8475                                                                             ctx,
8476                                                                             pattern22_0,
8477                                                                         ) {
8478                                                                             if pattern23_0 == 8 {
8479                                                                                 if pattern23_1 == 16
8480                                                                                 {
8481                                                                                     // Rule at src/isa/x64/lower.isle line 1116.
8482                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8483                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8484                                                                                     let expr2_0: u8 = 8;
8485                                                                                     let expr3_0 = OperandSize::Size32;
8486                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8487                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8488                                                                                     let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?;
8489                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8490                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8491                                                                                     let expr9_0: u8 = 8;
8492                                                                                     let expr10_0 = OperandSize::Size32;
8493                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8494                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8495                                                                                     let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?;
8496                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8497                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8498                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8499                                                                                     return Some(
8500                                                                                         expr16_0,
8501                                                                                     );
8502                                                                                 }
8503                                                                             }
8504                                                                         }
8505                                                                     }
8506                                                                 }
8507                                                             }
8508                                                         }
8509                                                     }
8510                                                 }
8511                                             }
8512                                             _ => {}
8513                                         }
8514                                     }
8515                                 }
8516                                 // Rule at src/isa/x64/lower.isle line 984.
8517                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8518                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8519                                 let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?;
8520                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8521                                 return Some(expr3_0);
8522                             }
8523                             _ => {}
8524                         }
8525                     }
8526                 }
8527             }
8528             if pattern3_0 == 32 {
8529                 if pattern3_1 == 4 {
8530                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8531                     if let &InstructionData::Binary {
8532                         opcode: ref pattern7_0,
8533                         args: ref pattern7_1,
8534                     } = &pattern6_0
8535                     {
8536                         match pattern7_0 {
8537                             &Opcode::Iadd => {
8538                                 let (pattern9_0, pattern9_1) =
8539                                     C::unpack_value_array_2(ctx, pattern7_1);
8540                                 // Rule at src/isa/x64/lower.isle line 102.
8541                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8542                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8543                                 let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?;
8544                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8545                                 return Some(expr3_0);
8546                             }
8547                             &Opcode::Isub => {
8548                                 let (pattern9_0, pattern9_1) =
8549                                     C::unpack_value_array_2(ctx, pattern7_1);
8550                                 // Rule at src/isa/x64/lower.isle line 248.
8551                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8552                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8553                                 let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?;
8554                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8555                                 return Some(expr3_0);
8556                             }
8557                             &Opcode::Imul => {
8558                                 let (pattern9_0, pattern9_1) =
8559                                     C::unpack_value_array_2(ctx, pattern7_1);
8560                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8561                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8562                                     if let &InstructionData::Unary {
8563                                         opcode: ref pattern12_0,
8564                                         arg: pattern12_1,
8565                                     } = &pattern11_0
8566                                     {
8567                                         match pattern12_0 {
8568                                             &Opcode::SwidenLow => {
8569                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8570                                                 if let Some((pattern15_0, pattern15_1)) =
8571                                                     C::multi_lane(ctx, pattern14_0)
8572                                                 {
8573                                                     if pattern15_0 == 16 {
8574                                                         if pattern15_1 == 8 {
8575                                                             if let Some(pattern18_0) =
8576                                                                 C::def_inst(ctx, pattern9_1)
8577                                                             {
8578                                                                 let pattern19_0 =
8579                                                                     C::inst_data(ctx, pattern18_0);
8580                                                                 if let &InstructionData::Unary {
8581                                                                     opcode: ref pattern20_0,
8582                                                                     arg: pattern20_1,
8583                                                                 } = &pattern19_0
8584                                                                 {
8585                                                                     if let &Opcode::SwidenLow =
8586                                                                         pattern20_0
8587                                                                     {
8588                                                                         let pattern22_0 =
8589                                                                             C::value_type(
8590                                                                                 ctx,
8591                                                                                 pattern20_1,
8592                                                                             );
8593                                                                         if let Some((
8594                                                                             pattern23_0,
8595                                                                             pattern23_1,
8596                                                                         )) = C::multi_lane(
8597                                                                             ctx,
8598                                                                             pattern22_0,
8599                                                                         ) {
8600                                                                             if pattern23_0 == 16 {
8601                                                                                 if pattern23_1 == 8
8602                                                                                 {
8603                                                                                     // Rule at src/isa/x64/lower.isle line 1090.
8604                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8605                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8606                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8607                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8608                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8609                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8610                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8611                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8612                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8613                                                                                     return Some(
8614                                                                                         expr8_0,
8615                                                                                     );
8616                                                                                 }
8617                                                                             }
8618                                                                         }
8619                                                                     }
8620                                                                 }
8621                                                             }
8622                                                         }
8623                                                     }
8624                                                 }
8625                                             }
8626                                             &Opcode::SwidenHigh => {
8627                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8628                                                 if let Some((pattern15_0, pattern15_1)) =
8629                                                     C::multi_lane(ctx, pattern14_0)
8630                                                 {
8631                                                     if pattern15_0 == 16 {
8632                                                         if pattern15_1 == 8 {
8633                                                             if let Some(pattern18_0) =
8634                                                                 C::def_inst(ctx, pattern9_1)
8635                                                             {
8636                                                                 let pattern19_0 =
8637                                                                     C::inst_data(ctx, pattern18_0);
8638                                                                 if let &InstructionData::Unary {
8639                                                                     opcode: ref pattern20_0,
8640                                                                     arg: pattern20_1,
8641                                                                 } = &pattern19_0
8642                                                                 {
8643                                                                     if let &Opcode::SwidenHigh =
8644                                                                         pattern20_0
8645                                                                     {
8646                                                                         let pattern22_0 =
8647                                                                             C::value_type(
8648                                                                                 ctx,
8649                                                                                 pattern20_1,
8650                                                                             );
8651                                                                         if let Some((
8652                                                                             pattern23_0,
8653                                                                             pattern23_1,
8654                                                                         )) = C::multi_lane(
8655                                                                             ctx,
8656                                                                             pattern22_0,
8657                                                                         ) {
8658                                                                             if pattern23_0 == 16 {
8659                                                                                 if pattern23_1 == 8
8660                                                                                 {
8661                                                                                     // Rule at src/isa/x64/lower.isle line 1054.
8662                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8663                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8664                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8665                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8666                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8667                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8668                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8669                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8670                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8671                                                                                     return Some(
8672                                                                                         expr8_0,
8673                                                                                     );
8674                                                                                 }
8675                                                                             }
8676                                                                         }
8677                                                                     }
8678                                                                 }
8679                                                             }
8680                                                         }
8681                                                     }
8682                                                 }
8683                                             }
8684                                             &Opcode::UwidenLow => {
8685                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8686                                                 if let Some((pattern15_0, pattern15_1)) =
8687                                                     C::multi_lane(ctx, pattern14_0)
8688                                                 {
8689                                                     if pattern15_0 == 16 {
8690                                                         if pattern15_1 == 8 {
8691                                                             if let Some(pattern18_0) =
8692                                                                 C::def_inst(ctx, pattern9_1)
8693                                                             {
8694                                                                 let pattern19_0 =
8695                                                                     C::inst_data(ctx, pattern18_0);
8696                                                                 if let &InstructionData::Unary {
8697                                                                     opcode: ref pattern20_0,
8698                                                                     arg: pattern20_1,
8699                                                                 } = &pattern19_0
8700                                                                 {
8701                                                                     if let &Opcode::UwidenLow =
8702                                                                         pattern20_0
8703                                                                     {
8704                                                                         let pattern22_0 =
8705                                                                             C::value_type(
8706                                                                                 ctx,
8707                                                                                 pattern20_1,
8708                                                                             );
8709                                                                         if let Some((
8710                                                                             pattern23_0,
8711                                                                             pattern23_1,
8712                                                                         )) = C::multi_lane(
8713                                                                             ctx,
8714                                                                             pattern22_0,
8715                                                                         ) {
8716                                                                             if pattern23_0 == 16 {
8717                                                                                 if pattern23_1 == 8
8718                                                                                 {
8719                                                                                     // Rule at src/isa/x64/lower.isle line 1166.
8720                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8721                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8722                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8723                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8724                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8725                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8726                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8727                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8728                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8729                                                                                     return Some(
8730                                                                                         expr8_0,
8731                                                                                     );
8732                                                                                 }
8733                                                                             }
8734                                                                         }
8735                                                                     }
8736                                                                 }
8737                                                             }
8738                                                         }
8739                                                     }
8740                                                 }
8741                                             }
8742                                             &Opcode::UwidenHigh => {
8743                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8744                                                 if let Some((pattern15_0, pattern15_1)) =
8745                                                     C::multi_lane(ctx, pattern14_0)
8746                                                 {
8747                                                     if pattern15_0 == 16 {
8748                                                         if pattern15_1 == 8 {
8749                                                             if let Some(pattern18_0) =
8750                                                                 C::def_inst(ctx, pattern9_1)
8751                                                             {
8752                                                                 let pattern19_0 =
8753                                                                     C::inst_data(ctx, pattern18_0);
8754                                                                 if let &InstructionData::Unary {
8755                                                                     opcode: ref pattern20_0,
8756                                                                     arg: pattern20_1,
8757                                                                 } = &pattern19_0
8758                                                                 {
8759                                                                     if let &Opcode::UwidenHigh =
8760                                                                         pattern20_0
8761                                                                     {
8762                                                                         let pattern22_0 =
8763                                                                             C::value_type(
8764                                                                                 ctx,
8765                                                                                 pattern20_1,
8766                                                                             );
8767                                                                         if let Some((
8768                                                                             pattern23_0,
8769                                                                             pattern23_1,
8770                                                                         )) = C::multi_lane(
8771                                                                             ctx,
8772                                                                             pattern22_0,
8773                                                                         ) {
8774                                                                             if pattern23_0 == 16 {
8775                                                                                 if pattern23_1 == 8
8776                                                                                 {
8777                                                                                     // Rule at src/isa/x64/lower.isle line 1130.
8778                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8779                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8780                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8781                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8782                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8783                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8784                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8785                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8786                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8787                                                                                     return Some(
8788                                                                                         expr8_0,
8789                                                                                     );
8790                                                                                 }
8791                                                                             }
8792                                                                         }
8793                                                                     }
8794                                                                 }
8795                                                             }
8796                                                         }
8797                                                     }
8798                                                 }
8799                                             }
8800                                             _ => {}
8801                                         }
8802                                     }
8803                                 }
8804                                 // Rule at src/isa/x64/lower.isle line 987.
8805                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8806                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8807                                 let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?;
8808                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8809                                 return Some(expr3_0);
8810                             }
8811                             _ => {}
8812                         }
8813                     }
8814                 }
8815             }
8816             if pattern3_0 == 64 {
8817                 if pattern3_1 == 2 {
8818                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8819                     if let &InstructionData::Binary {
8820                         opcode: ref pattern7_0,
8821                         args: ref pattern7_1,
8822                     } = &pattern6_0
8823                     {
8824                         match pattern7_0 {
8825                             &Opcode::Iadd => {
8826                                 let (pattern9_0, pattern9_1) =
8827                                     C::unpack_value_array_2(ctx, pattern7_1);
8828                                 // Rule at src/isa/x64/lower.isle line 106.
8829                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8830                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8831                                 let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?;
8832                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8833                                 return Some(expr3_0);
8834                             }
8835                             &Opcode::Isub => {
8836                                 let (pattern9_0, pattern9_1) =
8837                                     C::unpack_value_array_2(ctx, pattern7_1);
8838                                 // Rule at src/isa/x64/lower.isle line 252.
8839                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8840                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8841                                 let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?;
8842                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8843                                 return Some(expr3_0);
8844                             }
8845                             &Opcode::Imul => {
8846                                 let (pattern9_0, pattern9_1) =
8847                                     C::unpack_value_array_2(ctx, pattern7_1);
8848                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8849                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8850                                     if let &InstructionData::Unary {
8851                                         opcode: ref pattern12_0,
8852                                         arg: pattern12_1,
8853                                     } = &pattern11_0
8854                                     {
8855                                         match pattern12_0 {
8856                                             &Opcode::SwidenLow => {
8857                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8858                                                 if let Some((pattern15_0, pattern15_1)) =
8859                                                     C::multi_lane(ctx, pattern14_0)
8860                                                 {
8861                                                     if pattern15_0 == 32 {
8862                                                         if pattern15_1 == 4 {
8863                                                             if let Some(pattern18_0) =
8864                                                                 C::def_inst(ctx, pattern9_1)
8865                                                             {
8866                                                                 let pattern19_0 =
8867                                                                     C::inst_data(ctx, pattern18_0);
8868                                                                 if let &InstructionData::Unary {
8869                                                                     opcode: ref pattern20_0,
8870                                                                     arg: pattern20_1,
8871                                                                 } = &pattern19_0
8872                                                                 {
8873                                                                     if let &Opcode::SwidenLow =
8874                                                                         pattern20_0
8875                                                                     {
8876                                                                         let pattern22_0 =
8877                                                                             C::value_type(
8878                                                                                 ctx,
8879                                                                                 pattern20_1,
8880                                                                             );
8881                                                                         if let Some((
8882                                                                             pattern23_0,
8883                                                                             pattern23_1,
8884                                                                         )) = C::multi_lane(
8885                                                                             ctx,
8886                                                                             pattern22_0,
8887                                                                         ) {
8888                                                                             if pattern23_0 == 32 {
8889                                                                                 if pattern23_1 == 4
8890                                                                                 {
8891                                                                                     // Rule at src/isa/x64/lower.isle line 1102.
8892                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8893                                                                                     let expr1_0: u8 = 80;
8894                                                                                     let expr2_0 = OperandSize::Size32;
8895                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
8896                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8897                                                                                     let expr5_0: u8 = 80;
8898                                                                                     let expr6_0 = OperandSize::Size32;
8899                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
8900                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8901                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
8902                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
8903                                                                                     return Some(
8904                                                                                         expr10_0,
8905                                                                                     );
8906                                                                                 }
8907                                                                             }
8908                                                                         }
8909                                                                     }
8910                                                                 }
8911                                                             }
8912                                                         }
8913                                                     }
8914                                                 }
8915                                             }
8916                                             &Opcode::SwidenHigh => {
8917                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8918                                                 if let Some((pattern15_0, pattern15_1)) =
8919                                                     C::multi_lane(ctx, pattern14_0)
8920                                                 {
8921                                                     if pattern15_0 == 32 {
8922                                                         if pattern15_1 == 4 {
8923                                                             if let Some(pattern18_0) =
8924                                                                 C::def_inst(ctx, pattern9_1)
8925                                                             {
8926                                                                 let pattern19_0 =
8927                                                                     C::inst_data(ctx, pattern18_0);
8928                                                                 if let &InstructionData::Unary {
8929                                                                     opcode: ref pattern20_0,
8930                                                                     arg: pattern20_1,
8931                                                                 } = &pattern19_0
8932                                                                 {
8933                                                                     if let &Opcode::SwidenHigh =
8934                                                                         pattern20_0
8935                                                                     {
8936                                                                         let pattern22_0 =
8937                                                                             C::value_type(
8938                                                                                 ctx,
8939                                                                                 pattern20_1,
8940                                                                             );
8941                                                                         if let Some((
8942                                                                             pattern23_0,
8943                                                                             pattern23_1,
8944                                                                         )) = C::multi_lane(
8945                                                                             ctx,
8946                                                                             pattern22_0,
8947                                                                         ) {
8948                                                                             if pattern23_0 == 32 {
8949                                                                                 if pattern23_1 == 4
8950                                                                                 {
8951                                                                                     // Rule at src/isa/x64/lower.isle line 1066.
8952                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8953                                                                                     let expr1_0: u8 = 250;
8954                                                                                     let expr2_0 = OperandSize::Size32;
8955                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
8956                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8957                                                                                     let expr5_0: u8 = 250;
8958                                                                                     let expr6_0 = OperandSize::Size32;
8959                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
8960                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8961                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
8962                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
8963                                                                                     return Some(
8964                                                                                         expr10_0,
8965                                                                                     );
8966                                                                                 }
8967                                                                             }
8968                                                                         }
8969                                                                     }
8970                                                                 }
8971                                                             }
8972                                                         }
8973                                                     }
8974                                                 }
8975                                             }
8976                                             &Opcode::UwidenLow => {
8977                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8978                                                 if let Some((pattern15_0, pattern15_1)) =
8979                                                     C::multi_lane(ctx, pattern14_0)
8980                                                 {
8981                                                     if pattern15_0 == 32 {
8982                                                         if pattern15_1 == 4 {
8983                                                             if let Some(pattern18_0) =
8984                                                                 C::def_inst(ctx, pattern9_1)
8985                                                             {
8986                                                                 let pattern19_0 =
8987                                                                     C::inst_data(ctx, pattern18_0);
8988                                                                 if let &InstructionData::Unary {
8989                                                                     opcode: ref pattern20_0,
8990                                                                     arg: pattern20_1,
8991                                                                 } = &pattern19_0
8992                                                                 {
8993                                                                     if let &Opcode::UwidenLow =
8994                                                                         pattern20_0
8995                                                                     {
8996                                                                         let pattern22_0 =
8997                                                                             C::value_type(
8998                                                                                 ctx,
8999                                                                                 pattern20_1,
9000                                                                             );
9001                                                                         if let Some((
9002                                                                             pattern23_0,
9003                                                                             pattern23_1,
9004                                                                         )) = C::multi_lane(
9005                                                                             ctx,
9006                                                                             pattern22_0,
9007                                                                         ) {
9008                                                                             if pattern23_0 == 32 {
9009                                                                                 if pattern23_1 == 4
9010                                                                                 {
9011                                                                                     // Rule at src/isa/x64/lower.isle line 1178.
9012                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9013                                                                                     let expr1_0: u8 = 80;
9014                                                                                     let expr2_0 = OperandSize::Size32;
9015                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9016                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9017                                                                                     let expr5_0: u8 = 80;
9018                                                                                     let expr6_0 = OperandSize::Size32;
9019                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9020                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9021                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9022                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9023                                                                                     return Some(
9024                                                                                         expr10_0,
9025                                                                                     );
9026                                                                                 }
9027                                                                             }
9028                                                                         }
9029                                                                     }
9030                                                                 }
9031                                                             }
9032                                                         }
9033                                                     }
9034                                                 }
9035                                             }
9036                                             &Opcode::UwidenHigh => {
9037                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9038                                                 if let Some((pattern15_0, pattern15_1)) =
9039                                                     C::multi_lane(ctx, pattern14_0)
9040                                                 {
9041                                                     if pattern15_0 == 32 {
9042                                                         if pattern15_1 == 4 {
9043                                                             if let Some(pattern18_0) =
9044                                                                 C::def_inst(ctx, pattern9_1)
9045                                                             {
9046                                                                 let pattern19_0 =
9047                                                                     C::inst_data(ctx, pattern18_0);
9048                                                                 if let &InstructionData::Unary {
9049                                                                     opcode: ref pattern20_0,
9050                                                                     arg: pattern20_1,
9051                                                                 } = &pattern19_0
9052                                                                 {
9053                                                                     if let &Opcode::UwidenHigh =
9054                                                                         pattern20_0
9055                                                                     {
9056                                                                         let pattern22_0 =
9057                                                                             C::value_type(
9058                                                                                 ctx,
9059                                                                                 pattern20_1,
9060                                                                             );
9061                                                                         if let Some((
9062                                                                             pattern23_0,
9063                                                                             pattern23_1,
9064                                                                         )) = C::multi_lane(
9065                                                                             ctx,
9066                                                                             pattern22_0,
9067                                                                         ) {
9068                                                                             if pattern23_0 == 32 {
9069                                                                                 if pattern23_1 == 4
9070                                                                                 {
9071                                                                                     // Rule at src/isa/x64/lower.isle line 1142.
9072                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9073                                                                                     let expr1_0: u8 = 250;
9074                                                                                     let expr2_0 = OperandSize::Size32;
9075                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9076                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9077                                                                                     let expr5_0: u8 = 250;
9078                                                                                     let expr6_0 = OperandSize::Size32;
9079                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9080                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9081                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9082                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9083                                                                                     return Some(
9084                                                                                         expr10_0,
9085                                                                                     );
9086                                                                                 }
9087                                                                             }
9088                                                                         }
9089                                                                     }
9090                                                                 }
9091                                                             }
9092                                                         }
9093                                                     }
9094                                                 }
9095                                             }
9096                                             _ => {}
9097                                         }
9098                                     }
9099                                 }
9100                                 // Rule at src/isa/x64/lower.isle line 1018.
9101                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9102                                 let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?;
9103                                 let expr2_0: u32 = 32;
9104                                 let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
9105                                 let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?;
9106                                 let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?;
9107                                 let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9108                                 let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?;
9109                                 let expr8_0: u32 = 32;
9110                                 let expr9_0 = RegMemImm::Imm { simm32: expr8_0 };
9111                                 let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?;
9112                                 let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?;
9113                                 let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9114                                 let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?;
9115                                 let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9116                                 let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?;
9117                                 let expr16_0: u32 = 32;
9118                                 let expr17_0 = RegMemImm::Imm { simm32: expr16_0 };
9119                                 let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?;
9120                                 let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?;
9121                                 let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9122                                 let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?;
9123                                 let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0);
9124                                 let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?;
9125                                 let expr24_0 = constructor_output_xmm(ctx, expr23_0)?;
9126                                 return Some(expr24_0);
9127                             }
9128                             _ => {}
9129                         }
9130                     }
9131                 }
9132             }
9133             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9134             match &pattern4_0 {
9135                 &InstructionData::Binary {
9136                     opcode: ref pattern5_0,
9137                     args: ref pattern5_1,
9138                 } => {
9139                     match pattern5_0 {
9140                         &Opcode::Band => {
9141                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9142                             // Rule at src/isa/x64/lower.isle line 328.
9143                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9144                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9145                             let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?;
9146                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9147                             return Some(expr3_0);
9148                         }
9149                         &Opcode::Bor => {
9150                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9151                             // Rule at src/isa/x64/lower.isle line 392.
9152                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9153                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9154                             let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?;
9155                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9156                             return Some(expr3_0);
9157                         }
9158                         &Opcode::Bxor => {
9159                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9160                             // Rule at src/isa/x64/lower.isle line 453.
9161                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9162                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9163                             let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?;
9164                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9165                             return Some(expr3_0);
9166                         }
9167                         _ => {}
9168                     }
9169                 }
9170                 &InstructionData::Ternary {
9171                     opcode: ref pattern5_0,
9172                     args: ref pattern5_1,
9173                 } => {
9174                     match pattern5_0 {
9175                         &Opcode::Bitselect => {
9176                             let (pattern7_0, pattern7_1, pattern7_2) =
9177                                 C::unpack_value_array_3(ctx, pattern5_1);
9178                             // Rule at src/isa/x64/lower.isle line 1279.
9179                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9180                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
9181                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9182                             let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?;
9183                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?;
9184                             let expr5_0 =
9185                                 constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?;
9186                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9187                             let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?;
9188                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9189                             return Some(expr8_0);
9190                         }
9191                         &Opcode::Vselect => {
9192                             let (pattern7_0, pattern7_1, pattern7_2) =
9193                                 C::unpack_value_array_3(ctx, pattern5_1);
9194                             // Rule at src/isa/x64/lower.isle line 1293.
9195                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?;
9196                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9197                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?;
9198                             let expr3_0 = constructor_x64_blend(
9199                                 ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0,
9200                             )?;
9201                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9202                             return Some(expr4_0);
9203                         }
9204                         _ => {}
9205                     }
9206                 }
9207                 &InstructionData::Unary {
9208                     opcode: ref pattern5_0,
9209                     arg: pattern5_1,
9210                 } => {
9211                     if let &Opcode::Bnot = pattern5_0 {
9212                         // Rule at src/isa/x64/lower.isle line 1274.
9213                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
9214                         let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?;
9215                         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9216                         let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?;
9217                         let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9218                         return Some(expr4_0);
9219                     }
9220                 }
9221                 _ => {}
9222             }
9223         }
9224         if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) {
9225             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9226             if let &InstructionData::Unary {
9227                 opcode: ref pattern5_0,
9228                 arg: pattern5_1,
9229             } = &pattern4_0
9230             {
9231                 if let &Opcode::Uextend = pattern5_0 {
9232                     let pattern7_0 = C::value_type(ctx, pattern5_1);
9233                     if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
9234                         // Rule at src/isa/x64/lower.isle line 2137.
9235                         let expr0_0: Type = I32;
9236                         let expr1_0 = ExtendKind::Zero;
9237                         let expr2_0 =
9238                             constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
9239                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9240                         return Some(expr3_0);
9241                     }
9242                 }
9243             }
9244             if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) {
9245                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
9246                 if let &InstructionData::Load {
9247                     opcode: ref pattern6_0,
9248                     arg: pattern6_1,
9249                     flags: pattern6_2,
9250                     offset: pattern6_3,
9251                 } = &pattern5_0
9252                 {
9253                     if let &Opcode::Load = pattern6_0 {
9254                         // Rule at src/isa/x64/lower.isle line 2517.
9255                         let expr0_0 = C::ty_bits_u16(ctx, pattern3_0);
9256                         let expr1_0: u16 = 64;
9257                         let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
9258                         let expr3_0 =
9259                             constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?;
9260                         let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?;
9261                         let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?;
9262                         let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9263                         return Some(expr6_0);
9264                     }
9265                 }
9266             }
9267         }
9268         if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) {
9269             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9270             match &pattern4_0 {
9271                 &InstructionData::UnaryImm {
9272                     opcode: ref pattern5_0,
9273                     imm: pattern5_1,
9274                 } => {
9275                     if let &Opcode::Iconst = pattern5_0 {
9276                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
9277                         // Rule at src/isa/x64/lower.isle line 10.
9278                         let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9279                         let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
9280                         return Some(expr1_0);
9281                     }
9282                 }
9283                 &InstructionData::UnaryBool {
9284                     opcode: ref pattern5_0,
9285                     imm: pattern5_1,
9286                 } => {
9287                     if let &Opcode::Bconst = pattern5_0 {
9288                         if pattern5_1 == true {
9289                             // Rule at src/isa/x64/lower.isle line 28.
9290                             let expr0_0: u64 = 1;
9291                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9292                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9293                             return Some(expr2_0);
9294                         }
9295                         if pattern5_1 == false {
9296                             // Rule at src/isa/x64/lower.isle line 24.
9297                             let expr0_0: u64 = 0;
9298                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9299                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9300                             return Some(expr2_0);
9301                         }
9302                     }
9303                 }
9304                 &InstructionData::Binary {
9305                     opcode: ref pattern5_0,
9306                     args: ref pattern5_1,
9307                 } => {
9308                     match pattern5_0 {
9309                         &Opcode::Imin => {
9310                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9311                             // Rule at src/isa/x64/lower.isle line 1382.
9312                             let expr0_0 = CC::L;
9313                             let expr1_0 = constructor_cmp_and_choose(
9314                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9315                             )?;
9316                             let expr2_0 = C::output(ctx, expr1_0);
9317                             return Some(expr2_0);
9318                         }
9319                         &Opcode::Umin => {
9320                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9321                             // Rule at src/isa/x64/lower.isle line 1376.
9322                             let expr0_0 = CC::B;
9323                             let expr1_0 = constructor_cmp_and_choose(
9324                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9325                             )?;
9326                             let expr2_0 = C::output(ctx, expr1_0);
9327                             return Some(expr2_0);
9328                         }
9329                         &Opcode::Imax => {
9330                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9331                             // Rule at src/isa/x64/lower.isle line 1385.
9332                             let expr0_0 = CC::NL;
9333                             let expr1_0 = constructor_cmp_and_choose(
9334                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9335                             )?;
9336                             let expr2_0 = C::output(ctx, expr1_0);
9337                             return Some(expr2_0);
9338                         }
9339                         &Opcode::Umax => {
9340                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9341                             // Rule at src/isa/x64/lower.isle line 1379.
9342                             let expr0_0 = CC::NB;
9343                             let expr1_0 = constructor_cmp_and_choose(
9344                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9345                             )?;
9346                             let expr2_0 = C::output(ctx, expr1_0);
9347                             return Some(expr2_0);
9348                         }
9349                         &Opcode::Iadd => {
9350                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9351                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9352                                 // Rule at src/isa/x64/lower.isle line 74.
9353                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9354                                 let expr1_0 =
9355                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9356                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9357                                 return Some(expr2_0);
9358                             }
9359                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9360                                 // Rule at src/isa/x64/lower.isle line 86.
9361                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9362                                 let expr1_0 =
9363                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9364                                 let expr2_0 =
9365                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9366                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9367                                 return Some(expr3_0);
9368                             }
9369                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9370                                 // Rule at src/isa/x64/lower.isle line 70.
9371                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9372                                 let expr1_0 =
9373                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9374                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9375                                 return Some(expr2_0);
9376                             }
9377                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9378                                 // Rule at src/isa/x64/lower.isle line 80.
9379                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9380                                 let expr1_0 =
9381                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9382                                 let expr2_0 =
9383                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9384                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9385                                 return Some(expr3_0);
9386                             }
9387                             // Rule at src/isa/x64/lower.isle line 64.
9388                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9389                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9390                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9391                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9392                             return Some(expr3_0);
9393                         }
9394                         &Opcode::Isub => {
9395                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9396                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9397                                 // Rule at src/isa/x64/lower.isle line 228.
9398                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9399                                 let expr1_0 =
9400                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9401                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9402                                 return Some(expr2_0);
9403                             }
9404                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9405                                 // Rule at src/isa/x64/lower.isle line 233.
9406                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9407                                 let expr1_0 =
9408                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9409                                 let expr2_0 =
9410                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9411                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9412                                 return Some(expr3_0);
9413                             }
9414                             // Rule at src/isa/x64/lower.isle line 223.
9415                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9416                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9417                             let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9418                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9419                             return Some(expr3_0);
9420                         }
9421                         &Opcode::Imul => {
9422                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9423                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9424                                 // Rule at src/isa/x64/lower.isle line 925.
9425                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9426                                 let expr1_0 =
9427                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9428                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9429                                 return Some(expr2_0);
9430                             }
9431                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9432                                 // Rule at src/isa/x64/lower.isle line 937.
9433                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9434                                 let expr1_0 =
9435                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9436                                 let expr2_0 =
9437                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9438                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9439                                 return Some(expr3_0);
9440                             }
9441                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9442                                 // Rule at src/isa/x64/lower.isle line 921.
9443                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9444                                 let expr1_0 =
9445                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9446                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9447                                 return Some(expr2_0);
9448                             }
9449                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9450                                 // Rule at src/isa/x64/lower.isle line 931.
9451                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9452                                 let expr1_0 =
9453                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9454                                 let expr2_0 =
9455                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9456                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9457                                 return Some(expr3_0);
9458                             }
9459                             // Rule at src/isa/x64/lower.isle line 916.
9460                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9461                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9462                             let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9463                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9464                             return Some(expr3_0);
9465                         }
9466                         &Opcode::IaddIfcout => {
9467                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9468                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9469                                 // Rule at src/isa/x64/lower.isle line 171.
9470                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9471                                 let expr1_0 =
9472                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9473                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9474                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9475                                 return Some(expr3_0);
9476                             }
9477                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9478                                 // Rule at src/isa/x64/lower.isle line 181.
9479                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9480                                 let expr1_0 =
9481                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9482                                 let expr2_0 =
9483                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9484                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9485                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9486                                 return Some(expr4_0);
9487                             }
9488                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9489                                 // Rule at src/isa/x64/lower.isle line 167.
9490                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9491                                 let expr1_0 =
9492                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9493                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9494                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9495                                 return Some(expr3_0);
9496                             }
9497                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9498                                 // Rule at src/isa/x64/lower.isle line 177.
9499                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9500                                 let expr1_0 =
9501                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9502                                 let expr2_0 =
9503                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9504                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9505                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9506                                 return Some(expr4_0);
9507                             }
9508                             // Rule at src/isa/x64/lower.isle line 161.
9509                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9510                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9511                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9512                             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9513                             let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9514                             return Some(expr4_0);
9515                         }
9516                         &Opcode::Band => {
9517                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9518                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9519                                 // Rule at src/isa/x64/lower.isle line 317.
9520                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9521                                 let expr1_0 =
9522                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9523                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9524                                 return Some(expr2_0);
9525                             }
9526                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9527                                 // Rule at src/isa/x64/lower.isle line 305.
9528                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9529                                 let expr1_0 =
9530                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9531                                 let expr2_0 =
9532                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9533                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9534                                 return Some(expr3_0);
9535                             }
9536                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9537                                 // Rule at src/isa/x64/lower.isle line 313.
9538                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9539                                 let expr1_0 =
9540                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9541                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9542                                 return Some(expr2_0);
9543                             }
9544                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9545                                 // Rule at src/isa/x64/lower.isle line 300.
9546                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9547                                 let expr1_0 =
9548                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9549                                 let expr2_0 =
9550                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9551                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9552                                 return Some(expr3_0);
9553                             }
9554                             // Rule at src/isa/x64/lower.isle line 295.
9555                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9556                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9557                             let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9558                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9559                             return Some(expr3_0);
9560                         }
9561                         &Opcode::Bor => {
9562                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9563                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9564                                 // Rule at src/isa/x64/lower.isle line 381.
9565                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9566                                 let expr1_0 =
9567                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9568                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9569                                 return Some(expr2_0);
9570                             }
9571                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9572                                 // Rule at src/isa/x64/lower.isle line 370.
9573                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9574                                 let expr1_0 =
9575                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9576                                 let expr2_0 =
9577                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9578                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9579                                 return Some(expr3_0);
9580                             }
9581                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9582                                 // Rule at src/isa/x64/lower.isle line 377.
9583                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9584                                 let expr1_0 =
9585                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9586                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9587                                 return Some(expr2_0);
9588                             }
9589                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9590                                 // Rule at src/isa/x64/lower.isle line 365.
9591                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9592                                 let expr1_0 =
9593                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9594                                 let expr2_0 =
9595                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9596                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9597                                 return Some(expr3_0);
9598                             }
9599                             // Rule at src/isa/x64/lower.isle line 360.
9600                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9601                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9602                             let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9603                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9604                             return Some(expr3_0);
9605                         }
9606                         &Opcode::Bxor => {
9607                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9608                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9609                                 // Rule at src/isa/x64/lower.isle line 447.
9610                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9611                                 let expr1_0 =
9612                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9613                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9614                                 return Some(expr2_0);
9615                             }
9616                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9617                                 // Rule at src/isa/x64/lower.isle line 436.
9618                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9619                                 let expr1_0 =
9620                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9621                                 let expr2_0 =
9622                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9623                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9624                                 return Some(expr3_0);
9625                             }
9626                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9627                                 // Rule at src/isa/x64/lower.isle line 443.
9628                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9629                                 let expr1_0 =
9630                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9631                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9632                                 return Some(expr2_0);
9633                             }
9634                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9635                                 // Rule at src/isa/x64/lower.isle line 431.
9636                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9637                                 let expr1_0 =
9638                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9639                                 let expr2_0 =
9640                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9641                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9642                                 return Some(expr3_0);
9643                             }
9644                             // Rule at src/isa/x64/lower.isle line 426.
9645                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9646                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9647                             let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9648                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9649                             return Some(expr3_0);
9650                         }
9651                         &Opcode::Ishl => {
9652                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9653                             // Rule at src/isa/x64/lower.isle line 483.
9654                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9655                             let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9656                             let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?;
9657                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9658                             return Some(expr3_0);
9659                         }
9660                         &Opcode::Ushr => {
9661                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9662                             // Rule at src/isa/x64/lower.isle line 589.
9663                             let expr0_0 = ExtendKind::Zero;
9664                             let expr1_0 =
9665                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9666                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9667                             let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9668                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9669                             return Some(expr4_0);
9670                         }
9671                         &Opcode::Sshr => {
9672                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9673                             // Rule at src/isa/x64/lower.isle line 691.
9674                             let expr0_0 = ExtendKind::Sign;
9675                             let expr1_0 =
9676                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9677                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9678                             let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?;
9679                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9680                             return Some(expr4_0);
9681                         }
9682                         _ => {}
9683                     }
9684                 }
9685                 &InstructionData::Unary {
9686                     opcode: ref pattern5_0,
9687                     arg: pattern5_1,
9688                 } => {
9689                     match pattern5_0 {
9690                         &Opcode::Ineg => {
9691                             // Rule at src/isa/x64/lower.isle line 884.
9692                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9693                             let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?;
9694                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9695                             return Some(expr2_0);
9696                         }
9697                         &Opcode::Bnot => {
9698                             // Rule at src/isa/x64/lower.isle line 1253.
9699                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9700                             let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?;
9701                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9702                             return Some(expr2_0);
9703                         }
9704                         &Opcode::Breduce => {
9705                             // Rule at src/isa/x64/lower.isle line 2242.
9706                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9707                             let expr1_0: usize = 0;
9708                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9709                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9710                             return Some(expr3_0);
9711                         }
9712                         &Opcode::Bint => {
9713                             // Rule at src/isa/x64/lower.isle line 2250.
9714                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9715                             let expr1_0: u32 = 1;
9716                             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
9717                             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
9718                             let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?;
9719                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9720                             return Some(expr5_0);
9721                         }
9722                         &Opcode::Ireduce => {
9723                             // Rule at src/isa/x64/lower.isle line 2234.
9724                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9725                             let expr1_0: usize = 0;
9726                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9727                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9728                             return Some(expr3_0);
9729                         }
9730                         _ => {}
9731                     }
9732                 }
9733                 &InstructionData::BinaryImm64 {
9734                     opcode: ref pattern5_0,
9735                     arg: pattern5_1,
9736                     imm: pattern5_2,
9737                 } => {
9738                     if let &Opcode::IaddImm = pattern5_0 {
9739                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
9740                         // Rule at src/isa/x64/lower.isle line 196.
9741                         let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9742                         let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9743                         let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
9744                         let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?;
9745                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9746                         return Some(expr4_0);
9747                     }
9748                 }
9749                 _ => {}
9750             }
9751         }
9752         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
9753             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9754             match &pattern4_0 {
9755                 &InstructionData::Binary {
9756                     opcode: ref pattern5_0,
9757                     args: ref pattern5_1,
9758                 } => {
9759                     match pattern5_0 {
9760                         &Opcode::Rotl => {
9761                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9762                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9763                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9764                                 if let &InstructionData::UnaryImm {
9765                                     opcode: ref pattern10_0,
9766                                     imm: pattern10_1,
9767                                 } = &pattern9_0
9768                                 {
9769                                     if let &Opcode::Iconst = pattern10_0 {
9770                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9771                                         // Rule at src/isa/x64/lower.isle line 823.
9772                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9773                                         let expr1_0 = C::const_to_type_masked_imm8(
9774                                             ctx,
9775                                             pattern12_0,
9776                                             pattern3_0,
9777                                         );
9778                                         let expr2_0 = constructor_x64_rotl(
9779                                             ctx, pattern3_0, expr0_0, &expr1_0,
9780                                         )?;
9781                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9782                                         return Some(expr3_0);
9783                                     }
9784                                 }
9785                             }
9786                             // Rule at src/isa/x64/lower.isle line 817.
9787                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9788                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9789                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9790                             let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?;
9791                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9792                             return Some(expr4_0);
9793                         }
9794                         &Opcode::Rotr => {
9795                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9796                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9797                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9798                                 if let &InstructionData::UnaryImm {
9799                                     opcode: ref pattern10_0,
9800                                     imm: pattern10_1,
9801                                 } = &pattern9_0
9802                                 {
9803                                     if let &Opcode::Iconst = pattern10_0 {
9804                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9805                                         // Rule at src/isa/x64/lower.isle line 863.
9806                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9807                                         let expr1_0 = C::const_to_type_masked_imm8(
9808                                             ctx,
9809                                             pattern12_0,
9810                                             pattern3_0,
9811                                         );
9812                                         let expr2_0 = constructor_x64_rotr(
9813                                             ctx, pattern3_0, expr0_0, &expr1_0,
9814                                         )?;
9815                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9816                                         return Some(expr3_0);
9817                                     }
9818                                 }
9819                             }
9820                             // Rule at src/isa/x64/lower.isle line 857.
9821                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9822                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9823                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9824                             let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9825                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9826                             return Some(expr4_0);
9827                         }
9828                         _ => {}
9829                     }
9830                 }
9831                 &InstructionData::Unary {
9832                     opcode: ref pattern5_0,
9833                     arg: pattern5_1,
9834                 } => {
9835                     match pattern5_0 {
9836                         &Opcode::Clz => {
9837                             // Rule at src/isa/x64/lower.isle line 1798.
9838                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9839                             let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9840                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9841                             return Some(expr2_0);
9842                         }
9843                         &Opcode::Ctz => {
9844                             // Rule at src/isa/x64/lower.isle line 1840.
9845                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9846                             let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9847                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9848                             return Some(expr2_0);
9849                         }
9850                         &Opcode::Popcnt => {
9851                             // Rule at src/isa/x64/lower.isle line 1892.
9852                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9853                             let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?;
9854                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9855                             return Some(expr2_0);
9856                         }
9857                         _ => {}
9858                     }
9859                 }
9860                 _ => {}
9861             }
9862         }
9863         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
9864             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9865             match &pattern4_0 {
9866                 &InstructionData::Binary {
9867                     opcode: ref pattern5_0,
9868                     args: ref pattern5_1,
9869                 } => {
9870                     match pattern5_0 {
9871                         &Opcode::Rotl => {
9872                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9873                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9874                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9875                                 if let &InstructionData::UnaryImm {
9876                                     opcode: ref pattern10_0,
9877                                     imm: pattern10_1,
9878                                 } = &pattern9_0
9879                                 {
9880                                     if let &Opcode::Iconst = pattern10_0 {
9881                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9882                                         // Rule at src/isa/x64/lower.isle line 809.
9883                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9884                                         let expr1_0 = C::const_to_type_masked_imm8(
9885                                             ctx,
9886                                             pattern12_0,
9887                                             pattern3_0,
9888                                         );
9889                                         let expr2_0 = constructor_x64_rotl(
9890                                             ctx, pattern3_0, expr0_0, &expr1_0,
9891                                         )?;
9892                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9893                                         return Some(expr3_0);
9894                                     }
9895                                 }
9896                             }
9897                             // Rule at src/isa/x64/lower.isle line 805.
9898                             let expr0_0: Type = I32;
9899                             let expr1_0 = ExtendKind::Zero;
9900                             let expr2_0 =
9901                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
9902                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9903                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
9904                             let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?;
9905                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9906                             return Some(expr6_0);
9907                         }
9908                         &Opcode::Rotr => {
9909                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9910                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9911                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9912                                 if let &InstructionData::UnaryImm {
9913                                     opcode: ref pattern10_0,
9914                                     imm: pattern10_1,
9915                                 } = &pattern9_0
9916                                 {
9917                                     if let &Opcode::Iconst = pattern10_0 {
9918                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9919                                         // Rule at src/isa/x64/lower.isle line 849.
9920                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9921                                         let expr1_0 = C::const_to_type_masked_imm8(
9922                                             ctx,
9923                                             pattern12_0,
9924                                             pattern3_0,
9925                                         );
9926                                         let expr2_0 = constructor_x64_rotr(
9927                                             ctx, pattern3_0, expr0_0, &expr1_0,
9928                                         )?;
9929                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9930                                         return Some(expr3_0);
9931                                     }
9932                                 }
9933                             }
9934                             // Rule at src/isa/x64/lower.isle line 845.
9935                             let expr0_0: Type = I32;
9936                             let expr1_0 = ExtendKind::Zero;
9937                             let expr2_0 =
9938                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
9939                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9940                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
9941                             let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?;
9942                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9943                             return Some(expr6_0);
9944                         }
9945                         _ => {}
9946                     }
9947                 }
9948                 &InstructionData::Unary {
9949                     opcode: ref pattern5_0,
9950                     arg: pattern5_1,
9951                 } => {
9952                     match pattern5_0 {
9953                         &Opcode::Clz => {
9954                             // Rule at src/isa/x64/lower.isle line 1803.
9955                             let expr0_0: Type = I32;
9956                             let expr1_0: Type = I32;
9957                             let expr2_0 = ExtendKind::Zero;
9958                             let expr3_0 =
9959                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9960                             let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?;
9961                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9962                             return Some(expr5_0);
9963                         }
9964                         &Opcode::Ctz => {
9965                             // Rule at src/isa/x64/lower.isle line 1845.
9966                             let expr0_0: Type = I32;
9967                             let expr1_0: Type = I32;
9968                             let expr2_0 = ExtendKind::Zero;
9969                             let expr3_0 =
9970                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9971                             let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?;
9972                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9973                             return Some(expr5_0);
9974                         }
9975                         &Opcode::Popcnt => {
9976                             // Rule at src/isa/x64/lower.isle line 1897.
9977                             let expr0_0: Type = I32;
9978                             let expr1_0: Type = I32;
9979                             let expr2_0 = ExtendKind::Zero;
9980                             let expr3_0 =
9981                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9982                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
9983                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9984                             return Some(expr5_0);
9985                         }
9986                         _ => {}
9987                     }
9988                 }
9989                 _ => {}
9990             }
9991         }
9992         if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) {
9993             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9994             if let &InstructionData::Load {
9995                 opcode: ref pattern5_0,
9996                 arg: pattern5_1,
9997                 flags: pattern5_2,
9998                 offset: pattern5_3,
9999             } = &pattern4_0
10000             {
10001                 if let &Opcode::Load = pattern5_0 {
10002                     // Rule at src/isa/x64/lower.isle line 2521.
10003                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10004                     let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?;
10005                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10006                     return Some(expr2_0);
10007                 }
10008             }
10009         }
10010         if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) {
10011             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10012             if let &InstructionData::Load {
10013                 opcode: ref pattern5_0,
10014                 arg: pattern5_1,
10015                 flags: pattern5_2,
10016                 offset: pattern5_3,
10017             } = &pattern4_0
10018             {
10019                 if let &Opcode::Load = pattern5_0 {
10020                     // Rule at src/isa/x64/lower.isle line 2551.
10021                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10022                     let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
10023                     let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?;
10024                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10025                     return Some(expr3_0);
10026                 }
10027             }
10028         }
10029         if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) {
10030             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10031             if let &InstructionData::Load {
10032                 opcode: ref pattern5_0,
10033                 arg: pattern5_1,
10034                 flags: pattern5_2,
10035                 offset: pattern5_3,
10036             } = &pattern4_0
10037             {
10038                 match pattern5_0 {
10039                     &Opcode::Uload8 => {
10040                         // Rule at src/isa/x64/lower.isle line 2526.
10041                         let expr0_0 = ExtMode::BQ;
10042                         let expr1_0 =
10043                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10044                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10045                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10046                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10047                         return Some(expr4_0);
10048                     }
10049                     &Opcode::Sload8 => {
10050                         // Rule at src/isa/x64/lower.isle line 2528.
10051                         let expr0_0 = ExtMode::BQ;
10052                         let expr1_0 =
10053                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10054                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10055                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10056                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10057                         return Some(expr4_0);
10058                     }
10059                     &Opcode::Uload16 => {
10060                         // Rule at src/isa/x64/lower.isle line 2530.
10061                         let expr0_0 = ExtMode::WQ;
10062                         let expr1_0 =
10063                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10064                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10065                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10066                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10067                         return Some(expr4_0);
10068                     }
10069                     &Opcode::Sload16 => {
10070                         // Rule at src/isa/x64/lower.isle line 2532.
10071                         let expr0_0 = ExtMode::WQ;
10072                         let expr1_0 =
10073                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10074                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10075                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10076                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10077                         return Some(expr4_0);
10078                     }
10079                     &Opcode::Uload32 => {
10080                         // Rule at src/isa/x64/lower.isle line 2534.
10081                         let expr0_0 = ExtMode::LQ;
10082                         let expr1_0 =
10083                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10084                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10085                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10086                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10087                         return Some(expr4_0);
10088                     }
10089                     &Opcode::Sload32 => {
10090                         // Rule at src/isa/x64/lower.isle line 2536.
10091                         let expr0_0 = ExtMode::LQ;
10092                         let expr1_0 =
10093                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10094                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10095                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10096                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10097                         return Some(expr4_0);
10098                     }
10099                     _ => {}
10100                 }
10101             }
10102         }
10103     }
10104     return None;
10105 }
10106 
10107 // Generated as internal constructor for term output_ifcout.
10108 pub fn constructor_output_ifcout<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
10109     let pattern0_0 = arg0;
10110     // Rule at src/isa/x64/lower.isle line 157.
10111     let expr0_0 = C::value_reg(ctx, pattern0_0);
10112     let expr1_0 = C::value_regs_invalid(ctx);
10113     let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0);
10114     return Some(expr2_0);
10115 }
10116 
10117 // Generated as internal constructor for term sse_and.
10118 pub fn constructor_sse_and<C: Context>(
10119     ctx: &mut C,
10120     arg0: Type,
10121     arg1: Xmm,
10122     arg2: &XmmMem,
10123 ) -> Option<Xmm> {
10124     let pattern0_0 = arg0;
10125     if pattern0_0 == F32X4 {
10126         let pattern2_0 = arg1;
10127         let pattern3_0 = arg2;
10128         // Rule at src/isa/x64/lower.isle line 324.
10129         let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?;
10130         return Some(expr0_0);
10131     }
10132     if pattern0_0 == F64X2 {
10133         let pattern2_0 = arg1;
10134         let pattern3_0 = arg2;
10135         // Rule at src/isa/x64/lower.isle line 325.
10136         let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?;
10137         return Some(expr0_0);
10138     }
10139     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10140         let pattern2_0 = arg1;
10141         let pattern3_0 = arg2;
10142         // Rule at src/isa/x64/lower.isle line 326.
10143         let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?;
10144         return Some(expr0_0);
10145     }
10146     return None;
10147 }
10148 
10149 // Generated as internal constructor for term sse_or.
10150 pub fn constructor_sse_or<C: Context>(
10151     ctx: &mut C,
10152     arg0: Type,
10153     arg1: Xmm,
10154     arg2: &XmmMem,
10155 ) -> Option<Xmm> {
10156     let pattern0_0 = arg0;
10157     if pattern0_0 == F32X4 {
10158         let pattern2_0 = arg1;
10159         let pattern3_0 = arg2;
10160         // Rule at src/isa/x64/lower.isle line 388.
10161         let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?;
10162         return Some(expr0_0);
10163     }
10164     if pattern0_0 == F64X2 {
10165         let pattern2_0 = arg1;
10166         let pattern3_0 = arg2;
10167         // Rule at src/isa/x64/lower.isle line 389.
10168         let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?;
10169         return Some(expr0_0);
10170     }
10171     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10172         let pattern2_0 = arg1;
10173         let pattern3_0 = arg2;
10174         // Rule at src/isa/x64/lower.isle line 390.
10175         let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?;
10176         return Some(expr0_0);
10177     }
10178     return None;
10179 }
10180 
10181 // Generated as internal constructor for term or_i128.
10182 pub fn constructor_or_i128<C: Context>(
10183     ctx: &mut C,
10184     arg0: ValueRegs,
10185     arg1: ValueRegs,
10186 ) -> Option<ValueRegs> {
10187     let pattern0_0 = arg0;
10188     let pattern1_0 = arg1;
10189     // Rule at src/isa/x64/lower.isle line 399.
10190     let expr0_0: usize = 0;
10191     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10192     let expr2_0: usize = 1;
10193     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10194     let expr4_0: usize = 0;
10195     let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?;
10196     let expr6_0: usize = 1;
10197     let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?;
10198     let expr8_0: Type = I64;
10199     let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10200     let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?;
10201     let expr11_0: Type = I64;
10202     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
10203     let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?;
10204     let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?;
10205     return Some(expr14_0);
10206 }
10207 
10208 // Generated as internal constructor for term shl_i128.
10209 pub fn constructor_shl_i128<C: Context>(
10210     ctx: &mut C,
10211     arg0: ValueRegs,
10212     arg1: Gpr,
10213 ) -> Option<ValueRegs> {
10214     let pattern0_0 = arg0;
10215     let pattern1_0 = arg1;
10216     // Rule at src/isa/x64/lower.isle line 489.
10217     let expr0_0: usize = 0;
10218     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10219     let expr2_0: usize = 1;
10220     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10221     let expr4_0: Type = I64;
10222     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10223     let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?;
10224     let expr7_0: Type = I64;
10225     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10226     let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?;
10227     let expr10_0: Type = I64;
10228     let expr11_0: Type = I64;
10229     let expr12_0: Type = I64;
10230     let expr13_0: u64 = 64;
10231     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10232     let expr15_0 = C::gpr_new(ctx, expr14_0);
10233     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10234     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10235     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10236     let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?;
10237     let expr20_0: Type = I64;
10238     let expr21_0: u64 = 0;
10239     let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?;
10240     let expr23_0 = C::gpr_new(ctx, expr22_0);
10241     let expr24_0 = OperandSize::Size64;
10242     let expr25_0: u32 = 127;
10243     let expr26_0 = RegMemImm::Imm { simm32: expr25_0 };
10244     let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0);
10245     let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?;
10246     let expr29_0: Type = I64;
10247     let expr30_0 = CC::Z;
10248     let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0);
10249     let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?;
10250     let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?;
10251     let expr34_0 = C::gpr_new(ctx, expr33_0);
10252     let expr35_0: Type = I64;
10253     let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
10254     let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?;
10255     let expr38_0 = OperandSize::Size64;
10256     let expr39_0: u32 = 64;
10257     let expr40_0 = RegMemImm::Imm { simm32: expr39_0 };
10258     let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0);
10259     let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?;
10260     let expr43_0: Type = I64;
10261     let expr44_0 = CC::Z;
10262     let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
10263     let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?;
10264     let expr47_0: Type = I64;
10265     let expr48_0 = CC::Z;
10266     let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0);
10267     let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?;
10268     let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?;
10269     let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?;
10270     return Some(expr52_0);
10271 }
10272 
10273 // Generated as internal constructor for term ishl_i8x16_mask.
10274 pub fn constructor_ishl_i8x16_mask<C: Context>(
10275     ctx: &mut C,
10276     arg0: &RegMemImm,
10277 ) -> Option<SyntheticAmode> {
10278     let pattern0_0 = arg0;
10279     match pattern0_0 {
10280         &RegMemImm::Imm { simm32: pattern1_0 } => {
10281             // Rule at src/isa/x64/lower.isle line 552.
10282             let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0);
10283             return Some(expr0_0);
10284         }
10285         &RegMemImm::Reg { reg: pattern1_0 } => {
10286             // Rule at src/isa/x64/lower.isle line 561.
10287             let expr0_0 = C::ishl_i8x16_mask_table(ctx);
10288             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10289             let expr2_0: Type = I64;
10290             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10291             let expr4_0: u8 = 4;
10292             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10293             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10294             let expr7_0: u32 = 0;
10295             let expr8_0: u8 = 0;
10296             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10297             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10298             return Some(expr10_0);
10299         }
10300         &RegMemImm::Mem {
10301             addr: ref pattern1_0,
10302         } => {
10303             // Rule at src/isa/x64/lower.isle line 571.
10304             let expr0_0: Type = I64;
10305             let expr1_0 = ExtKind::None;
10306             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10307             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10308             let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?;
10309             return Some(expr4_0);
10310         }
10311         _ => {}
10312     }
10313     return None;
10314 }
10315 
10316 // Generated as internal constructor for term shr_i128.
10317 pub fn constructor_shr_i128<C: Context>(
10318     ctx: &mut C,
10319     arg0: ValueRegs,
10320     arg1: Gpr,
10321 ) -> Option<ValueRegs> {
10322     let pattern0_0 = arg0;
10323     let pattern1_0 = arg1;
10324     // Rule at src/isa/x64/lower.isle line 596.
10325     let expr0_0: usize = 0;
10326     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10327     let expr2_0: usize = 1;
10328     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10329     let expr4_0: Type = I64;
10330     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10331     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10332     let expr7_0: Type = I64;
10333     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10334     let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?;
10335     let expr10_0: Type = I64;
10336     let expr11_0: Type = I64;
10337     let expr12_0: Type = I64;
10338     let expr13_0: u64 = 64;
10339     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10340     let expr15_0 = C::gpr_new(ctx, expr14_0);
10341     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10342     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10343     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10344     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10345     let expr20_0 = OperandSize::Size64;
10346     let expr21_0: u32 = 127;
10347     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10348     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10349     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10350     let expr25_0: Type = I64;
10351     let expr26_0 = CC::Z;
10352     let expr27_0: Type = I64;
10353     let expr28_0: u64 = 0;
10354     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10355     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10356     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10357     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10358     let expr33_0 = C::gpr_new(ctx, expr32_0);
10359     let expr34_0: Type = I64;
10360     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0);
10361     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?;
10362     let expr37_0 = OperandSize::Size64;
10363     let expr38_0: u32 = 64;
10364     let expr39_0 = RegMemImm::Imm { simm32: expr38_0 };
10365     let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0);
10366     let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?;
10367     let expr42_0: Type = I64;
10368     let expr43_0 = CC::Z;
10369     let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10370     let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?;
10371     let expr46_0: Type = I64;
10372     let expr47_0 = CC::Z;
10373     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10374     let expr49_0: Type = I64;
10375     let expr50_0: u64 = 0;
10376     let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?;
10377     let expr52_0 = C::gpr_new(ctx, expr51_0);
10378     let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?;
10379     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?;
10380     let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?;
10381     return Some(expr55_0);
10382 }
10383 
10384 // Generated as internal constructor for term ushr_i8x16_mask.
10385 pub fn constructor_ushr_i8x16_mask<C: Context>(
10386     ctx: &mut C,
10387     arg0: &RegMemImm,
10388 ) -> Option<SyntheticAmode> {
10389     let pattern0_0 = arg0;
10390     match pattern0_0 {
10391         &RegMemImm::Imm { simm32: pattern1_0 } => {
10392             // Rule at src/isa/x64/lower.isle line 653.
10393             let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0);
10394             return Some(expr0_0);
10395         }
10396         &RegMemImm::Reg { reg: pattern1_0 } => {
10397             // Rule at src/isa/x64/lower.isle line 662.
10398             let expr0_0 = C::ushr_i8x16_mask_table(ctx);
10399             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10400             let expr2_0: Type = I64;
10401             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10402             let expr4_0: u8 = 4;
10403             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10404             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10405             let expr7_0: u32 = 0;
10406             let expr8_0: u8 = 0;
10407             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10408             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10409             return Some(expr10_0);
10410         }
10411         &RegMemImm::Mem {
10412             addr: ref pattern1_0,
10413         } => {
10414             // Rule at src/isa/x64/lower.isle line 673.
10415             let expr0_0: Type = I64;
10416             let expr1_0 = ExtKind::None;
10417             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10418             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10419             let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?;
10420             return Some(expr4_0);
10421         }
10422         _ => {}
10423     }
10424     return None;
10425 }
10426 
10427 // Generated as internal constructor for term sar_i128.
10428 pub fn constructor_sar_i128<C: Context>(
10429     ctx: &mut C,
10430     arg0: ValueRegs,
10431     arg1: Gpr,
10432 ) -> Option<ValueRegs> {
10433     let pattern0_0 = arg0;
10434     let pattern1_0 = arg1;
10435     // Rule at src/isa/x64/lower.isle line 698.
10436     let expr0_0: usize = 0;
10437     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10438     let expr2_0: usize = 1;
10439     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10440     let expr4_0: Type = I64;
10441     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10442     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10443     let expr7_0: Type = I64;
10444     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10445     let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?;
10446     let expr10_0: Type = I64;
10447     let expr11_0: Type = I64;
10448     let expr12_0: Type = I64;
10449     let expr13_0: u64 = 64;
10450     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10451     let expr15_0 = C::gpr_new(ctx, expr14_0);
10452     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10453     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10454     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10455     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10456     let expr20_0 = OperandSize::Size64;
10457     let expr21_0: u32 = 127;
10458     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10459     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10460     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10461     let expr25_0: Type = I64;
10462     let expr26_0 = CC::Z;
10463     let expr27_0: Type = I64;
10464     let expr28_0: u64 = 0;
10465     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10466     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10467     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10468     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10469     let expr33_0 = C::gpr_new(ctx, expr32_0);
10470     let expr34_0: Type = I64;
10471     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10472     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?;
10473     let expr37_0: Type = I64;
10474     let expr38_0: u8 = 63;
10475     let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0);
10476     let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?;
10477     let expr41_0 = OperandSize::Size64;
10478     let expr42_0: u32 = 64;
10479     let expr43_0 = RegMemImm::Imm { simm32: expr42_0 };
10480     let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0);
10481     let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?;
10482     let expr46_0: Type = I64;
10483     let expr47_0 = CC::Z;
10484     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10485     let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?;
10486     let expr50_0: Type = I64;
10487     let expr51_0 = CC::Z;
10488     let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10489     let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?;
10490     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?;
10491     let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?;
10492     return Some(expr55_0);
10493 }
10494 
10495 // Generated as internal constructor for term sshr_i8x16_bigger_shift.
10496 pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
10497     ctx: &mut C,
10498     arg0: Type,
10499     arg1: &RegMemImm,
10500 ) -> Option<XmmMemImm> {
10501     let pattern0_0 = arg0;
10502     let pattern1_0 = arg1;
10503     match pattern1_0 {
10504         &RegMemImm::Imm { simm32: pattern2_0 } => {
10505             // Rule at src/isa/x64/lower.isle line 762.
10506             let expr0_0: u32 = 8;
10507             let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0);
10508             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10509             let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0);
10510             return Some(expr3_0);
10511         }
10512         &RegMemImm::Reg { reg: pattern2_0 } => {
10513             // Rule at src/isa/x64/lower.isle line 764.
10514             let expr0_0 = C::gpr_new(ctx, pattern2_0);
10515             let expr1_0: u32 = 8;
10516             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10517             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
10518             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?;
10519             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10520             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10521             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10522             return Some(expr7_0);
10523         }
10524         &RegMemImm::Mem {
10525             addr: ref pattern2_0,
10526         } => {
10527             // Rule at src/isa/x64/lower.isle line 768.
10528             let expr0_0: u64 = 8;
10529             let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
10530             let expr2_0 = C::gpr_new(ctx, expr1_0);
10531             let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0);
10532             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?;
10533             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10534             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10535             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10536             return Some(expr7_0);
10537         }
10538         _ => {}
10539     }
10540     return None;
10541 }
10542 
10543 // Generated as internal constructor for term sse_and_not.
10544 pub fn constructor_sse_and_not<C: Context>(
10545     ctx: &mut C,
10546     arg0: Type,
10547     arg1: Xmm,
10548     arg2: &XmmMem,
10549 ) -> Option<Xmm> {
10550     let pattern0_0 = arg0;
10551     if pattern0_0 == F32X4 {
10552         let pattern2_0 = arg1;
10553         let pattern3_0 = arg2;
10554         // Rule at src/isa/x64/lower.isle line 1194.
10555         let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?;
10556         return Some(expr0_0);
10557     }
10558     if pattern0_0 == F64X2 {
10559         let pattern2_0 = arg1;
10560         let pattern3_0 = arg2;
10561         // Rule at src/isa/x64/lower.isle line 1195.
10562         let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?;
10563         return Some(expr0_0);
10564     }
10565     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10566         let pattern2_0 = arg1;
10567         let pattern3_0 = arg2;
10568         // Rule at src/isa/x64/lower.isle line 1196.
10569         let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?;
10570         return Some(expr0_0);
10571     }
10572     return None;
10573 }
10574 
10575 // Generated as internal constructor for term i128_not.
10576 pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> Option<ValueRegs> {
10577     let pattern0_0 = arg0;
10578     // Rule at src/isa/x64/lower.isle line 1259.
10579     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
10580     let expr1_0: usize = 0;
10581     let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10582     let expr3_0: usize = 1;
10583     let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
10584     let expr5_0: Type = I64;
10585     let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?;
10586     let expr7_0: Type = I64;
10587     let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?;
10588     let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?;
10589     return Some(expr9_0);
10590 }
10591 
10592 // Generated as internal constructor for term vec_insert_lane.
10593 pub fn constructor_vec_insert_lane<C: Context>(
10594     ctx: &mut C,
10595     arg0: Type,
10596     arg1: Xmm,
10597     arg2: &RegMem,
10598     arg3: u8,
10599 ) -> Option<Xmm> {
10600     let pattern0_0 = arg0;
10601     if pattern0_0 == I8X16 {
10602         let pattern2_0 = arg1;
10603         let pattern3_0 = arg2;
10604         let pattern4_0 = arg3;
10605         // Rule at src/isa/x64/lower.isle line 1313.
10606         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10607         let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10608         return Some(expr1_0);
10609     }
10610     if pattern0_0 == I16X8 {
10611         let pattern2_0 = arg1;
10612         let pattern3_0 = arg2;
10613         let pattern4_0 = arg3;
10614         // Rule at src/isa/x64/lower.isle line 1317.
10615         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10616         let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10617         return Some(expr1_0);
10618     }
10619     if pattern0_0 == I32X4 {
10620         let pattern2_0 = arg1;
10621         let pattern3_0 = arg2;
10622         let pattern4_0 = arg3;
10623         // Rule at src/isa/x64/lower.isle line 1321.
10624         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10625         let expr1_0 = OperandSize::Size32;
10626         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10627         return Some(expr2_0);
10628     }
10629     if pattern0_0 == I64X2 {
10630         let pattern2_0 = arg1;
10631         let pattern3_0 = arg2;
10632         let pattern4_0 = arg3;
10633         // Rule at src/isa/x64/lower.isle line 1325.
10634         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10635         let expr1_0 = OperandSize::Size64;
10636         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10637         return Some(expr2_0);
10638     }
10639     if pattern0_0 == F32X4 {
10640         let pattern2_0 = arg1;
10641         let pattern3_0 = arg2;
10642         let pattern4_0 = arg3;
10643         // Rule at src/isa/x64/lower.isle line 1329.
10644         let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10645         let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0);
10646         let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?;
10647         return Some(expr2_0);
10648     }
10649     if pattern0_0 == F64X2 {
10650         let pattern2_0 = arg1;
10651         let pattern3_0 = arg2;
10652         if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 {
10653             let pattern5_0 = arg3;
10654             if pattern5_0 == 0 {
10655                 // Rule at src/isa/x64/lower.isle line 1351.
10656                 let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?;
10657                 let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?;
10658                 return Some(expr1_0);
10659             }
10660         }
10661         let pattern4_0 = arg3;
10662         if pattern4_0 == 0 {
10663             // Rule at src/isa/x64/lower.isle line 1353.
10664             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10665             let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?;
10666             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10667             let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?;
10668             return Some(expr3_0);
10669         }
10670         if pattern4_0 == 1 {
10671             // Rule at src/isa/x64/lower.isle line 1361.
10672             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10673             let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?;
10674             return Some(expr1_0);
10675         }
10676     }
10677     return None;
10678 }
10679 
10680 // Generated as internal constructor for term cmp_and_choose.
10681 pub fn constructor_cmp_and_choose<C: Context>(
10682     ctx: &mut C,
10683     arg0: Type,
10684     arg1: &CC,
10685     arg2: Value,
10686     arg3: Value,
10687 ) -> Option<ValueRegs> {
10688     let pattern0_0 = arg0;
10689     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
10690         let pattern2_0 = arg1;
10691         let pattern3_0 = arg2;
10692         let pattern4_0 = arg3;
10693         // Rule at src/isa/x64/lower.isle line 1369.
10694         let expr0_0 = constructor_put_in_gpr(ctx, pattern3_0)?;
10695         let expr1_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
10696         let expr2_0 = C::raw_operand_size_of_type(ctx, pattern1_0);
10697         let expr3_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
10698         let expr4_0 = constructor_x64_cmp(ctx, &expr2_0, &expr3_0, expr1_0)?;
10699         let expr5_0 = C::gpr_to_gpr_mem(ctx, expr1_0);
10700         let expr6_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr5_0, expr0_0)?;
10701         let expr7_0 = constructor_with_flags_reg(ctx, &expr4_0, &expr6_0)?;
10702         let expr8_0 = C::value_reg(ctx, expr7_0);
10703         return Some(expr8_0);
10704     }
10705     return None;
10706 }
10707 
10708 // Generated as internal constructor for term do_clz.
10709 pub fn constructor_do_clz<C: Context>(
10710     ctx: &mut C,
10711     arg0: Type,
10712     arg1: Type,
10713     arg2: Gpr,
10714 ) -> Option<Gpr> {
10715     let pattern0_0 = arg0;
10716     let pattern1_0 = arg1;
10717     let pattern2_0 = arg2;
10718     // Rule at src/isa/x64/lower.isle line 1823.
10719     let expr0_0: Type = I64;
10720     let expr1_0: i64 = -1;
10721     let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?;
10722     let expr3_0 = C::gpr_new(ctx, expr2_0);
10723     let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10724     let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10725     let expr6_0 = C::ty_bits_u64(ctx, pattern1_0);
10726     let expr7_0: u64 = 1;
10727     let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0);
10728     let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?;
10729     let expr10_0 = C::gpr_new(ctx, expr9_0);
10730     let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?;
10731     let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?;
10732     return Some(expr12_0);
10733 }
10734 
10735 // Generated as internal constructor for term do_ctz.
10736 pub fn constructor_do_ctz<C: Context>(
10737     ctx: &mut C,
10738     arg0: Type,
10739     arg1: Type,
10740     arg2: Gpr,
10741 ) -> Option<Gpr> {
10742     let pattern0_0 = arg0;
10743     let pattern1_0 = arg1;
10744     let pattern2_0 = arg2;
10745     // Rule at src/isa/x64/lower.isle line 1864.
10746     let expr0_0: Type = I64;
10747     let expr1_0 = C::ty_bits_u64(ctx, pattern1_0);
10748     let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
10749     let expr3_0 = C::gpr_new(ctx, expr2_0);
10750     let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10751     return Some(expr4_0);
10752 }
10753 
10754 // Generated as internal constructor for term do_popcnt.
10755 pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10756     let pattern0_0 = arg0;
10757     if pattern0_0 == I32 {
10758         let pattern2_0 = arg1;
10759         // Rule at src/isa/x64/lower.isle line 1955.
10760         let expr0_0: Type = I32;
10761         let expr1_0: u8 = 1;
10762         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10763         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10764         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10765         let expr5_0: Type = I32;
10766         let expr6_0: u64 = 2004318071;
10767         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10768         let expr8_0 = C::gpr_new(ctx, expr7_0);
10769         let expr9_0: Type = I32;
10770         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10771         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10772         let expr12_0: Type = I32;
10773         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10774         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10775         let expr15_0: Type = I32;
10776         let expr16_0: u8 = 1;
10777         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10778         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10779         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10780         let expr20_0: Type = I32;
10781         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10782         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10783         let expr23_0: Type = I32;
10784         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10785         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10786         let expr26_0: Type = I32;
10787         let expr27_0: u8 = 1;
10788         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10789         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10790         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10791         let expr31_0: Type = I32;
10792         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10793         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10794         let expr34_0: Type = I32;
10795         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10796         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10797         let expr37_0: Type = I32;
10798         let expr38_0: Type = I32;
10799         let expr39_0: u8 = 4;
10800         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10801         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10802         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10803         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10804         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10805         let expr45_0: Type = I32;
10806         let expr46_0: u32 = 252645135;
10807         let expr47_0 = RegMemImm::Imm { simm32: expr46_0 };
10808         let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0);
10809         let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?;
10810         let expr50_0: Type = I32;
10811         let expr51_0: u32 = 16843009;
10812         let expr52_0 = RegMemImm::Imm { simm32: expr51_0 };
10813         let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0);
10814         let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?;
10815         let expr55_0: Type = I32;
10816         let expr56_0: u8 = 24;
10817         let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 };
10818         let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0);
10819         let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?;
10820         return Some(expr59_0);
10821     }
10822     if pattern0_0 == I64 {
10823         let pattern2_0 = arg1;
10824         // Rule at src/isa/x64/lower.isle line 1912.
10825         let expr0_0: Type = I64;
10826         let expr1_0: u8 = 1;
10827         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10828         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10829         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10830         let expr5_0: Type = I64;
10831         let expr6_0: u64 = 8608480567731124087;
10832         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10833         let expr8_0 = C::gpr_new(ctx, expr7_0);
10834         let expr9_0: Type = I64;
10835         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10836         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10837         let expr12_0: Type = I64;
10838         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10839         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10840         let expr15_0: Type = I64;
10841         let expr16_0: u8 = 1;
10842         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10843         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10844         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10845         let expr20_0: Type = I64;
10846         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10847         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10848         let expr23_0: Type = I64;
10849         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10850         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10851         let expr26_0: Type = I64;
10852         let expr27_0: u8 = 1;
10853         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10854         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10855         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10856         let expr31_0: Type = I64;
10857         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10858         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10859         let expr34_0: Type = I64;
10860         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10861         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10862         let expr37_0: Type = I64;
10863         let expr38_0: Type = I64;
10864         let expr39_0: u8 = 4;
10865         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10866         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10867         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10868         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10869         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10870         let expr45_0: Type = I64;
10871         let expr46_0: u64 = 1085102592571150095;
10872         let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?;
10873         let expr48_0 = C::gpr_new(ctx, expr47_0);
10874         let expr49_0: Type = I64;
10875         let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
10876         let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?;
10877         let expr52_0: Type = I64;
10878         let expr53_0: u64 = 72340172838076673;
10879         let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?;
10880         let expr55_0 = C::gpr_new(ctx, expr54_0);
10881         let expr56_0: Type = I64;
10882         let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0);
10883         let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?;
10884         let expr59_0: Type = I64;
10885         let expr60_0: u8 = 56;
10886         let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 };
10887         let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0);
10888         let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?;
10889         return Some(expr63_0);
10890     }
10891     return None;
10892 }
10893 
10894 // Generated as internal constructor for term do_bitrev8.
10895 pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10896     let pattern0_0 = arg0;
10897     let pattern1_0 = arg1;
10898     // Rule at src/isa/x64/lower.isle line 2044.
10899     let expr0_0 = C::ty_mask(ctx, pattern0_0);
10900     let expr1_0: u64 = 6148914691236517205;
10901     let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0);
10902     let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?;
10903     let expr4_0 = C::gpr_new(ctx, expr3_0);
10904     let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
10905     let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?;
10906     let expr7_0: u8 = 1;
10907     let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 };
10908     let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0);
10909     let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?;
10910     let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
10911     let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?;
10912     let expr13_0: u8 = 1;
10913     let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 };
10914     let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0);
10915     let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?;
10916     let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0);
10917     let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?;
10918     let expr19_0: u64 = 3689348814741910323;
10919     let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0);
10920     let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?;
10921     let expr22_0 = C::gpr_new(ctx, expr21_0);
10922     let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10923     let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?;
10924     let expr25_0: u8 = 2;
10925     let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 };
10926     let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0);
10927     let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?;
10928     let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10929     let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?;
10930     let expr31_0: u8 = 2;
10931     let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 };
10932     let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0);
10933     let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?;
10934     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0);
10935     let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?;
10936     let expr37_0: u64 = 1085102592571150095;
10937     let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0);
10938     let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?;
10939     let expr40_0 = C::gpr_new(ctx, expr39_0);
10940     let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
10941     let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?;
10942     let expr43_0: u8 = 4;
10943     let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 };
10944     let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0);
10945     let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?;
10946     let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
10947     let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?;
10948     let expr49_0: u8 = 4;
10949     let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 };
10950     let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0);
10951     let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?;
10952     let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
10953     let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?;
10954     return Some(expr54_0);
10955 }
10956 
10957 // Generated as internal constructor for term do_bitrev16.
10958 pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10959     let pattern0_0 = arg0;
10960     let pattern1_0 = arg1;
10961     // Rule at src/isa/x64/lower.isle line 2067.
10962     let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?;
10963     let expr1_0 = C::ty_mask(ctx, pattern0_0);
10964     let expr2_0: u64 = 71777214294589695;
10965     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
10966     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
10967     let expr5_0 = C::gpr_new(ctx, expr4_0);
10968     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10969     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
10970     let expr8_0: u8 = 8;
10971     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
10972     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
10973     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
10974     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10975     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
10976     let expr14_0: u8 = 8;
10977     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
10978     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
10979     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
10980     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
10981     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
10982     return Some(expr19_0);
10983 }
10984 
10985 // Generated as internal constructor for term do_bitrev32.
10986 pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10987     let pattern0_0 = arg0;
10988     let pattern1_0 = arg1;
10989     // Rule at src/isa/x64/lower.isle line 2079.
10990     let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?;
10991     let expr1_0 = C::ty_mask(ctx, pattern0_0);
10992     let expr2_0: u64 = 281470681808895;
10993     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
10994     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
10995     let expr5_0 = C::gpr_new(ctx, expr4_0);
10996     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10997     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
10998     let expr8_0: u8 = 16;
10999     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
11000     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
11001     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
11002     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11003     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
11004     let expr14_0: u8 = 16;
11005     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
11006     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
11007     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
11008     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
11009     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
11010     return Some(expr19_0);
11011 }
11012 
11013 // Generated as internal constructor for term do_bitrev64.
11014 pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11015     let pattern0_0 = arg0;
11016     if pattern0_0 == I64 {
11017         let pattern2_0 = arg1;
11018         // Rule at src/isa/x64/lower.isle line 2091.
11019         let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?;
11020         let expr1_0: u64 = 4294967295;
11021         let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?;
11022         let expr3_0 = C::gpr_new(ctx, expr2_0);
11023         let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0);
11024         let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?;
11025         let expr6_0: u8 = 32;
11026         let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 };
11027         let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0);
11028         let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?;
11029         let expr10_0: u8 = 32;
11030         let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 };
11031         let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0);
11032         let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?;
11033         let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11034         let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?;
11035         return Some(expr15_0);
11036     }
11037     return None;
11038 }
11039 
11040 // Generated as internal constructor for term generic_sextend.
11041 pub fn constructor_generic_sextend<C: Context>(
11042     ctx: &mut C,
11043     arg0: Value,
11044     arg1: Type,
11045     arg2: Type,
11046 ) -> Option<InstOutput> {
11047     let pattern0_0 = arg0;
11048     let pattern1_0 = arg1;
11049     if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) {
11050         let pattern3_0 = arg2;
11051         if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) {
11052             // Rule at src/isa/x64/lower.isle line 2211.
11053             let expr0_0: Type = I32;
11054             let expr1_0 = ExtendKind::Sign;
11055             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11056             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11057             return Some(expr3_0);
11058         }
11059         if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) {
11060             // Rule at src/isa/x64/lower.isle line 2207.
11061             let expr0_0: Type = I64;
11062             let expr1_0 = ExtendKind::Sign;
11063             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11064             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11065             return Some(expr3_0);
11066         }
11067         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11068             // Rule at src/isa/x64/lower.isle line 2201.
11069             let expr0_0: Type = I64;
11070             let expr1_0 = ExtendKind::Sign;
11071             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11072             let expr3_0 = constructor_spread_sign_bit(ctx, expr2_0)?;
11073             let expr4_0 = C::gpr_to_reg(ctx, expr2_0);
11074             let expr5_0 = C::gpr_to_reg(ctx, expr3_0);
11075             let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0);
11076             let expr7_0 = C::output(ctx, expr6_0);
11077             return Some(expr7_0);
11078         }
11079     }
11080     if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) {
11081         let pattern3_0 = arg2;
11082         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11083             // Rule at src/isa/x64/lower.isle line 2197.
11084             let expr0_0 = C::put_in_reg(ctx, pattern0_0);
11085             let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
11086             let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?;
11087             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
11088             let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
11089             let expr5_0 = C::output(ctx, expr4_0);
11090             return Some(expr5_0);
11091         }
11092     }
11093     let pattern2_0 = arg2;
11094     if pattern2_0 == pattern1_0 {
11095         // Rule at src/isa/x64/lower.isle line 2187.
11096         let expr0_0 = constructor_output_value(ctx, pattern0_0)?;
11097         return Some(expr0_0);
11098     }
11099     return None;
11100 }
11101 
11102 // Generated as internal constructor for term spread_sign_bit.
11103 pub fn constructor_spread_sign_bit<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<Gpr> {
11104     let pattern0_0 = arg0;
11105     // Rule at src/isa/x64/lower.isle line 2193.
11106     let expr0_0: Type = I64;
11107     let expr1_0: u8 = 63;
11108     let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11109     let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11110     let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?;
11111     return Some(expr4_0);
11112 }
11113