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 trap_code_division_by_zero(&mut self) -> TrapCode;
83     fn trap_code_integer_overflow(&mut self) -> TrapCode;
84     fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
85     fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>;
86     fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
87     fn symbol_value_data(
88         &mut self,
89         arg0: GlobalValue,
90     ) -> Option<(ExternalName, RelocDistance, i64)>;
91     fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
92     fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
93     fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
94     fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
95     fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
96     fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
97     fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
98     fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode;
99     fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode;
100     fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode;
101     fn const_shift_lt_eq_3(&mut self, arg0: Value) -> Option<u8>;
102     fn sum_extend_fits_in_32_bits(
103         &mut self,
104         arg0: Offset32,
105         arg1: Type,
106         arg2: Imm64,
107     ) -> Option<u32>;
108     fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr;
109     fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
110     fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
111     fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
112     fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
113     fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
114     fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
115     fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
116     fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
117     fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
118     fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
119     fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
120     fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
121     fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
122     fn temp_writable_gpr(&mut self) -> WritableGpr;
123     fn temp_writable_xmm(&mut self) -> WritableXmm;
124     fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
125     fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
126     fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
127     fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
128     fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
129     fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
130     fn xmm_new(&mut self, arg0: Reg) -> Xmm;
131     fn gpr_new(&mut self, arg0: Reg) -> Gpr;
132     fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
133     fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
134     fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
135     fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
136     fn xmm0(&mut self) -> WritableXmm;
137     fn is_xmm_type(&mut self, arg0: Type) -> Option<Type>;
138     fn is_gpr_type(&mut self, arg0: Type) -> Option<Type>;
139     fn is_single_register_type(&mut self, arg0: Type) -> Option<Type>;
140     fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>;
141     fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>;
142     fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>;
143     fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>;
144     fn use_lzcnt(&mut self, arg0: Type) -> Option<()>;
145     fn use_bmi1(&mut self, arg0: Type) -> Option<()>;
146     fn use_popcnt(&mut self, arg0: Type) -> Option<()>;
147     fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
148     fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
149     fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
150     fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
151     fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
152     fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm;
153     fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
154     fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
155     fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
156     fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
157     fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
158     fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
159     fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
160     fn popcount_4bit_table(&mut self) -> VCodeConstant;
161     fn popcount_low_mask(&mut self) -> VCodeConstant;
162 }
163 
164 /// Internal type SideEffectNoResult: defined at src/prelude.isle line 402.
165 #[derive(Clone, Debug)]
166 pub enum SideEffectNoResult {
167     Inst { inst: MInst },
168 }
169 
170 /// Internal type ProducesFlags: defined at src/prelude.isle line 418.
171 #[derive(Clone, Debug)]
172 pub enum ProducesFlags {
173     ProducesFlagsSideEffect { inst: MInst },
174     ProducesFlagsReturnsReg { inst: MInst, result: Reg },
175     ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
176 }
177 
178 /// Internal type ConsumesFlags: defined at src/prelude.isle line 429.
179 #[derive(Clone, Debug)]
180 pub enum ConsumesFlags {
181     ConsumesFlagsReturnsResultWithProducer {
182         inst: MInst,
183         result: Reg,
184     },
185     ConsumesFlagsReturnsReg {
186         inst: MInst,
187         result: Reg,
188     },
189     ConsumesFlagsTwiceReturnsValueRegs {
190         inst1: MInst,
191         inst2: MInst,
192         result: ValueRegs,
193     },
194     ConsumesFlagsFourTimesReturnsValueRegs {
195         inst1: MInst,
196         inst2: MInst,
197         inst3: MInst,
198         inst4: MInst,
199         result: ValueRegs,
200     },
201 }
202 
203 /// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
204 #[derive(Clone)]
205 pub enum MInst {
206     Nop {
207         len: u8,
208     },
209     AluRmiR {
210         size: OperandSize,
211         op: AluRmiROpcode,
212         src1: Gpr,
213         src2: GprMemImm,
214         dst: WritableGpr,
215     },
216     UnaryRmR {
217         size: OperandSize,
218         op: UnaryRmROpcode,
219         src: GprMem,
220         dst: WritableGpr,
221     },
222     Not {
223         size: OperandSize,
224         src: Gpr,
225         dst: WritableGpr,
226     },
227     Neg {
228         size: OperandSize,
229         src: Gpr,
230         dst: WritableGpr,
231     },
232     Div {
233         size: OperandSize,
234         signed: bool,
235         divisor: GprMem,
236         dividend_lo: Gpr,
237         dividend_hi: 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_lo: Gpr,
253         dividend_hi: Gpr,
254         divisor: WritableGpr,
255         dst_quotient: WritableGpr,
256         dst_remainder: WritableGpr,
257         tmp: OptionWritableGpr,
258     },
259     SignExtendData {
260         size: OperandSize,
261         src: Gpr,
262         dst: WritableGpr,
263     },
264     Imm {
265         dst_size: OperandSize,
266         simm64: u64,
267         dst: WritableGpr,
268     },
269     MovRR {
270         size: OperandSize,
271         src: Gpr,
272         dst: WritableGpr,
273     },
274     MovzxRmR {
275         ext_mode: ExtMode,
276         src: GprMem,
277         dst: WritableGpr,
278     },
279     Mov64MR {
280         src: SyntheticAmode,
281         dst: WritableGpr,
282     },
283     LoadEffectiveAddress {
284         addr: SyntheticAmode,
285         dst: WritableGpr,
286     },
287     MovsxRmR {
288         ext_mode: ExtMode,
289         src: GprMem,
290         dst: WritableGpr,
291     },
292     MovRM {
293         size: OperandSize,
294         src: Gpr,
295         dst: SyntheticAmode,
296     },
297     ShiftR {
298         size: OperandSize,
299         kind: ShiftKind,
300         src: Gpr,
301         num_bits: Imm8Gpr,
302         dst: WritableGpr,
303     },
304     XmmRmiReg {
305         opcode: SseOpcode,
306         src1: Xmm,
307         src2: XmmMemImm,
308         dst: WritableXmm,
309     },
310     CmpRmiR {
311         size: OperandSize,
312         opcode: CmpOpcode,
313         src: GprMemImm,
314         dst: Gpr,
315     },
316     Setcc {
317         cc: CC,
318         dst: WritableGpr,
319     },
320     Cmove {
321         size: OperandSize,
322         cc: CC,
323         consequent: GprMem,
324         alternative: Gpr,
325         dst: WritableGpr,
326     },
327     XmmCmove {
328         size: OperandSize,
329         cc: CC,
330         consequent: XmmMem,
331         alternative: Xmm,
332         dst: WritableXmm,
333     },
334     Push64 {
335         src: GprMemImm,
336     },
337     Pop64 {
338         dst: WritableGpr,
339     },
340     XmmRmR {
341         op: SseOpcode,
342         src1: Xmm,
343         src2: XmmMem,
344         dst: WritableXmm,
345     },
346     XmmRmREvex {
347         op: Avx512Opcode,
348         src1: XmmMem,
349         src2: Xmm,
350         dst: WritableXmm,
351     },
352     XmmUnaryRmR {
353         op: SseOpcode,
354         src: XmmMem,
355         dst: WritableXmm,
356     },
357     XmmUnaryRmREvex {
358         op: Avx512Opcode,
359         src: XmmMem,
360         dst: WritableXmm,
361     },
362     XmmMovRM {
363         op: SseOpcode,
364         src: Reg,
365         dst: SyntheticAmode,
366     },
367     XmmLoadConst {
368         src: VCodeConstant,
369         dst: WritableReg,
370         ty: Type,
371     },
372     XmmToGpr {
373         op: SseOpcode,
374         src: Xmm,
375         dst: WritableGpr,
376         dst_size: OperandSize,
377     },
378     GprToXmm {
379         op: SseOpcode,
380         src: GprMem,
381         dst: WritableXmm,
382         src_size: OperandSize,
383     },
384     CvtUint64ToFloatSeq {
385         dst_size: OperandSize,
386         src: WritableGpr,
387         dst: WritableXmm,
388         tmp_gpr1: WritableGpr,
389         tmp_gpr2: WritableGpr,
390     },
391     CvtFloatToSintSeq {
392         dst_size: OperandSize,
393         src_size: OperandSize,
394         is_saturating: bool,
395         src: WritableXmm,
396         dst: WritableGpr,
397         tmp_gpr: WritableGpr,
398         tmp_xmm: WritableXmm,
399     },
400     CvtFloatToUintSeq {
401         dst_size: OperandSize,
402         src_size: OperandSize,
403         is_saturating: bool,
404         src: WritableXmm,
405         dst: WritableGpr,
406         tmp_gpr: WritableGpr,
407         tmp_xmm: WritableXmm,
408     },
409     XmmMinMaxSeq {
410         size: OperandSize,
411         is_min: bool,
412         lhs: Xmm,
413         rhs: Xmm,
414         dst: WritableXmm,
415     },
416     XmmCmpRmR {
417         op: SseOpcode,
418         src: XmmMem,
419         dst: Xmm,
420     },
421     XmmRmRImm {
422         op: SseOpcode,
423         src1: Reg,
424         src2: RegMem,
425         dst: WritableReg,
426         imm: u8,
427         size: OperandSize,
428     },
429     CallKnown {
430         dest: ExternalName,
431         uses: VecReg,
432         defs: VecWritableReg,
433         opcode: Opcode,
434     },
435     CallUnknown {
436         dest: RegMem,
437         uses: VecReg,
438         defs: VecWritableReg,
439         opcode: Opcode,
440     },
441     Ret {
442         rets: VecReg,
443     },
444     EpiloguePlaceholder,
445     JmpKnown {
446         dst: MachLabel,
447     },
448     JmpIf {
449         cc: CC,
450         taken: MachLabel,
451     },
452     JmpCond {
453         cc: CC,
454         taken: MachLabel,
455         not_taken: MachLabel,
456     },
457     JmpTableSeq {
458         idx: Reg,
459         tmp1: WritableReg,
460         tmp2: WritableReg,
461         default_target: MachLabel,
462         targets: VecMachLabel,
463         targets_for_term: VecMachLabel,
464     },
465     JmpUnknown {
466         target: RegMem,
467     },
468     TrapIf {
469         cc: CC,
470         trap_code: TrapCode,
471     },
472     Hlt,
473     Ud2 {
474         trap_code: TrapCode,
475     },
476     LoadExtName {
477         dst: WritableReg,
478         name: BoxExternalName,
479         offset: i64,
480     },
481     LockCmpxchg {
482         ty: Type,
483         replacement: Reg,
484         expected: Reg,
485         mem: SyntheticAmode,
486         dst_old: WritableReg,
487     },
488     AtomicRmwSeq {
489         ty: Type,
490         op: AtomicRmwOp,
491         address: Reg,
492         operand: Reg,
493         temp: WritableReg,
494         dst_old: WritableReg,
495     },
496     Fence {
497         kind: FenceKind,
498     },
499     VirtualSPOffsetAdj {
500         offset: i64,
501     },
502     XmmUninitializedValue {
503         dst: WritableXmm,
504     },
505     ElfTlsGetAddr {
506         symbol: ExternalName,
507     },
508     MachOTlsGetAddr {
509         symbol: ExternalName,
510     },
511     Unwind {
512         inst: UnwindInst,
513     },
514     DummyUse {
515         reg: Reg,
516     },
517 }
518 
519 /// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1202.
520 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
521 pub enum ExtendKind {
522     Sign,
523     Zero,
524 }
525 
526 // Generated as internal constructor for term output_reg.
527 pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
528     let pattern0_0 = arg0;
529     // Rule at src/prelude.isle line 86.
530     let expr0_0 = C::value_reg(ctx, pattern0_0);
531     let expr1_0 = C::output(ctx, expr0_0);
532     return Some(expr1_0);
533 }
534 
535 // Generated as internal constructor for term output_value.
536 pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> Option<InstOutput> {
537     let pattern0_0 = arg0;
538     // Rule at src/prelude.isle line 90.
539     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
540     let expr1_0 = C::output(ctx, expr0_0);
541     return Some(expr1_0);
542 }
543 
544 // Generated as internal constructor for term temp_reg.
545 pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Option<Reg> {
546     let pattern0_0 = arg0;
547     // Rule at src/prelude.isle line 110.
548     let expr0_0 = C::temp_writable_reg(ctx, pattern0_0);
549     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
550     return Some(expr1_0);
551 }
552 
553 // Generated as internal constructor for term lo_reg.
554 pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Option<Reg> {
555     let pattern0_0 = arg0;
556     // Rule at src/prelude.isle line 145.
557     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
558     let expr1_0: usize = 0;
559     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
560     return Some(expr2_0);
561 }
562 
563 // Generated as internal constructor for term side_effect.
564 pub fn constructor_side_effect<C: Context>(
565     ctx: &mut C,
566     arg0: &SideEffectNoResult,
567 ) -> Option<InstOutput> {
568     let pattern0_0 = arg0;
569     if let &SideEffectNoResult::Inst {
570         inst: ref pattern1_0,
571     } = pattern0_0
572     {
573         // Rule at src/prelude.isle line 407.
574         let expr0_0 = C::emit(ctx, pattern1_0);
575         let expr1_0 = C::output_none(ctx);
576         return Some(expr1_0);
577     }
578     return None;
579 }
580 
581 // Generated as internal constructor for term produces_flags_get_reg.
582 pub fn constructor_produces_flags_get_reg<C: Context>(
583     ctx: &mut C,
584     arg0: &ProducesFlags,
585 ) -> Option<Reg> {
586     let pattern0_0 = arg0;
587     if let &ProducesFlags::ProducesFlagsReturnsReg {
588         inst: ref pattern1_0,
589         result: pattern1_1,
590     } = pattern0_0
591     {
592         // Rule at src/prelude.isle line 445.
593         return Some(pattern1_1);
594     }
595     return None;
596 }
597 
598 // Generated as internal constructor for term produces_flags_ignore.
599 pub fn constructor_produces_flags_ignore<C: Context>(
600     ctx: &mut C,
601     arg0: &ProducesFlags,
602 ) -> Option<ProducesFlags> {
603     let pattern0_0 = arg0;
604     match pattern0_0 {
605         &ProducesFlags::ProducesFlagsReturnsReg {
606             inst: ref pattern1_0,
607             result: pattern1_1,
608         } => {
609             // Rule at src/prelude.isle line 450.
610             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
611                 inst: pattern1_0.clone(),
612             };
613             return Some(expr0_0);
614         }
615         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
616             inst: ref pattern1_0,
617             result: pattern1_1,
618         } => {
619             // Rule at src/prelude.isle line 452.
620             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
621                 inst: pattern1_0.clone(),
622             };
623             return Some(expr0_0);
624         }
625         _ => {}
626     }
627     return None;
628 }
629 
630 // Generated as internal constructor for term consumes_flags_concat.
631 pub fn constructor_consumes_flags_concat<C: Context>(
632     ctx: &mut C,
633     arg0: &ConsumesFlags,
634     arg1: &ConsumesFlags,
635 ) -> Option<ConsumesFlags> {
636     let pattern0_0 = arg0;
637     if let &ConsumesFlags::ConsumesFlagsReturnsReg {
638         inst: ref pattern1_0,
639         result: pattern1_1,
640     } = pattern0_0
641     {
642         let pattern2_0 = arg1;
643         if let &ConsumesFlags::ConsumesFlagsReturnsReg {
644             inst: ref pattern3_0,
645             result: pattern3_1,
646         } = pattern2_0
647         {
648             // Rule at src/prelude.isle line 459.
649             let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
650             let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
651                 inst1: pattern1_0.clone(),
652                 inst2: pattern3_0.clone(),
653                 result: expr0_0,
654             };
655             return Some(expr1_0);
656         }
657     }
658     return None;
659 }
660 
661 // Generated as internal constructor for term with_flags.
662 pub fn constructor_with_flags<C: Context>(
663     ctx: &mut C,
664     arg0: &ProducesFlags,
665     arg1: &ConsumesFlags,
666 ) -> Option<ValueRegs> {
667     let pattern0_0 = arg0;
668     match pattern0_0 {
669         &ProducesFlags::ProducesFlagsSideEffect {
670             inst: ref pattern1_0,
671         } => {
672             let pattern2_0 = arg1;
673             match pattern2_0 {
674                 &ConsumesFlags::ConsumesFlagsReturnsReg {
675                     inst: ref pattern3_0,
676                     result: pattern3_1,
677                 } => {
678                     // Rule at src/prelude.isle line 484.
679                     let expr0_0 = C::emit(ctx, pattern1_0);
680                     let expr1_0 = C::emit(ctx, pattern3_0);
681                     let expr2_0 = C::value_reg(ctx, pattern3_1);
682                     return Some(expr2_0);
683                 }
684                 &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
685                     inst1: ref pattern3_0,
686                     inst2: ref pattern3_1,
687                     result: pattern3_2,
688                 } => {
689                     // Rule at src/prelude.isle line 490.
690                     let expr0_0 = C::emit(ctx, pattern1_0);
691                     let expr1_0 = C::emit(ctx, pattern3_0);
692                     let expr2_0 = C::emit(ctx, pattern3_1);
693                     return Some(pattern3_2);
694                 }
695                 &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
696                     inst1: ref pattern3_0,
697                     inst2: ref pattern3_1,
698                     inst3: ref pattern3_2,
699                     inst4: ref pattern3_3,
700                     result: pattern3_4,
701                 } => {
702                     // Rule at src/prelude.isle line 502.
703                     let expr0_0 = C::emit(ctx, pattern1_0);
704                     let expr1_0 = C::emit(ctx, pattern3_0);
705                     let expr2_0 = C::emit(ctx, pattern3_1);
706                     let expr3_0 = C::emit(ctx, pattern3_2);
707                     let expr4_0 = C::emit(ctx, pattern3_3);
708                     return Some(pattern3_4);
709                 }
710                 _ => {}
711             }
712         }
713         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
714             inst: ref pattern1_0,
715             result: pattern1_1,
716         } => {
717             let pattern2_0 = arg1;
718             if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
719                 inst: ref pattern3_0,
720                 result: pattern3_1,
721             } = pattern2_0
722             {
723                 // Rule at src/prelude.isle line 478.
724                 let expr0_0 = C::emit(ctx, pattern1_0);
725                 let expr1_0 = C::emit(ctx, pattern3_0);
726                 let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
727                 return Some(expr2_0);
728             }
729         }
730         _ => {}
731     }
732     return None;
733 }
734 
735 // Generated as internal constructor for term with_flags_reg.
736 pub fn constructor_with_flags_reg<C: Context>(
737     ctx: &mut C,
738     arg0: &ProducesFlags,
739     arg1: &ConsumesFlags,
740 ) -> Option<Reg> {
741     let pattern0_0 = arg0;
742     let pattern1_0 = arg1;
743     // Rule at src/prelude.isle line 519.
744     let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?;
745     let expr1_0: usize = 0;
746     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
747     return Some(expr2_0);
748 }
749 
750 // Generated as internal constructor for term operand_size_bits.
751 pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> Option<u16> {
752     let pattern0_0 = arg0;
753     match pattern0_0 {
754         &OperandSize::Size8 => {
755             // Rule at src/isa/x64/inst.isle line 511.
756             let expr0_0: u16 = 8;
757             return Some(expr0_0);
758         }
759         &OperandSize::Size16 => {
760             // Rule at src/isa/x64/inst.isle line 512.
761             let expr0_0: u16 = 16;
762             return Some(expr0_0);
763         }
764         &OperandSize::Size32 => {
765             // Rule at src/isa/x64/inst.isle line 513.
766             let expr0_0: u16 = 32;
767             return Some(expr0_0);
768         }
769         &OperandSize::Size64 => {
770             // Rule at src/isa/x64/inst.isle line 514.
771             let expr0_0: u16 = 64;
772             return Some(expr0_0);
773         }
774         _ => {}
775     }
776     return None;
777 }
778 
779 // Generated as internal constructor for term amode_imm_reg_flags.
780 pub fn constructor_amode_imm_reg_flags<C: Context>(
781     ctx: &mut C,
782     arg0: u32,
783     arg1: Gpr,
784     arg2: MemFlags,
785 ) -> Option<Amode> {
786     let pattern0_0 = arg0;
787     let pattern1_0 = arg1;
788     let pattern2_0 = arg2;
789     // Rule at src/isa/x64/inst.isle line 771.
790     let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0);
791     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0);
792     return Some(expr1_0);
793 }
794 
795 // Generated as internal constructor for term amode_imm_reg_reg_shift_flags.
796 pub fn constructor_amode_imm_reg_reg_shift_flags<C: Context>(
797     ctx: &mut C,
798     arg0: u32,
799     arg1: Gpr,
800     arg2: Gpr,
801     arg3: u8,
802     arg4: MemFlags,
803 ) -> Option<Amode> {
804     let pattern0_0 = arg0;
805     let pattern1_0 = arg1;
806     let pattern2_0 = arg2;
807     let pattern3_0 = arg3;
808     let pattern4_0 = arg4;
809     // Rule at src/isa/x64/inst.isle line 778.
810     let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0);
811     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0);
812     return Some(expr1_0);
813 }
814 
815 // Generated as internal constructor for term to_amode.
816 pub fn constructor_to_amode<C: Context>(
817     ctx: &mut C,
818     arg0: MemFlags,
819     arg1: Value,
820     arg2: Offset32,
821 ) -> Option<Amode> {
822     let pattern0_0 = arg0;
823     let pattern1_0 = arg1;
824     if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) {
825         let pattern3_0 = C::inst_data(ctx, pattern2_0);
826         if let &InstructionData::Binary {
827             opcode: ref pattern4_0,
828             args: ref pattern4_1,
829         } = &pattern3_0
830         {
831             if let &Opcode::Iadd = pattern4_0 {
832                 let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
833                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
834                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
835                     match &pattern8_0 {
836                         &InstructionData::UnaryImm {
837                             opcode: ref pattern9_0,
838                             imm: pattern9_1,
839                         } => {
840                             if let &Opcode::Iconst = pattern9_0 {
841                                 let pattern11_0 = arg2;
842                                 let closure12 = || {
843                                     let expr0_0: Type = I64;
844                                     return Some(expr0_0);
845                                 };
846                                 if let Some(pattern12_0) = closure12() {
847                                     let closure13 = || {
848                                         return Some(pattern9_1);
849                                     };
850                                     if let Some(pattern13_0) = closure13() {
851                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
852                                             ctx,
853                                             pattern11_0,
854                                             pattern12_0,
855                                             pattern13_0,
856                                         ) {
857                                             // Rule at src/isa/x64/inst.isle line 825.
858                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
859                                             let expr1_0 = constructor_amode_imm_reg_flags(
860                                                 ctx,
861                                                 pattern14_0,
862                                                 expr0_0,
863                                                 pattern0_0,
864                                             )?;
865                                             return Some(expr1_0);
866                                         }
867                                     }
868                                 }
869                             }
870                         }
871                         &InstructionData::Binary {
872                             opcode: ref pattern9_0,
873                             args: ref pattern9_1,
874                         } => {
875                             if let &Opcode::Ishl = pattern9_0 {
876                                 let (pattern11_0, pattern11_1) =
877                                     C::unpack_value_array_2(ctx, pattern9_1);
878                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
879                                 {
880                                     let pattern13_0 = arg2;
881                                     // Rule at src/isa/x64/inst.isle line 817.
882                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
883                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
884                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
885                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
886                                         ctx,
887                                         expr0_0,
888                                         expr1_0,
889                                         expr2_0,
890                                         pattern12_0,
891                                         pattern0_0,
892                                     )?;
893                                     return Some(expr3_0);
894                                 }
895                             }
896                         }
897                         _ => {}
898                     }
899                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
900                         let pattern9_0 = C::value_type(ctx, pattern8_0);
901                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
902                         if let &InstructionData::Unary {
903                             opcode: ref pattern11_0,
904                             arg: pattern11_1,
905                         } = &pattern10_0
906                         {
907                             if let &Opcode::Uextend = pattern11_0 {
908                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
909                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
910                                     if let &InstructionData::UnaryImm {
911                                         opcode: ref pattern15_0,
912                                         imm: pattern15_1,
913                                     } = &pattern14_0
914                                     {
915                                         if let &Opcode::Iconst = pattern15_0 {
916                                             let pattern17_0 = arg2;
917                                             let closure18 = || {
918                                                 return Some(pattern9_0);
919                                             };
920                                             if let Some(pattern18_0) = closure18() {
921                                                 let closure19 = || {
922                                                     return Some(pattern15_1);
923                                                 };
924                                                 if let Some(pattern19_0) = closure19() {
925                                                     if let Some(pattern20_0) =
926                                                         C::sum_extend_fits_in_32_bits(
927                                                             ctx,
928                                                             pattern17_0,
929                                                             pattern18_0,
930                                                             pattern19_0,
931                                                         )
932                                                     {
933                                                         // Rule at src/isa/x64/inst.isle line 830.
934                                                         let expr0_0 = constructor_put_in_gpr(
935                                                             ctx, pattern6_1,
936                                                         )?;
937                                                         let expr1_0 =
938                                                             constructor_amode_imm_reg_flags(
939                                                                 ctx,
940                                                                 pattern20_0,
941                                                                 expr0_0,
942                                                                 pattern0_0,
943                                                             )?;
944                                                         return Some(expr1_0);
945                                                     }
946                                                 }
947                                             }
948                                         }
949                                     }
950                                 }
951                             }
952                         }
953                     }
954                 }
955                 if let Some(pattern7_0) = C::def_inst(ctx, pattern6_1) {
956                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
957                     match &pattern8_0 {
958                         &InstructionData::UnaryImm {
959                             opcode: ref pattern9_0,
960                             imm: pattern9_1,
961                         } => {
962                             if let &Opcode::Iconst = pattern9_0 {
963                                 let pattern11_0 = arg2;
964                                 let closure12 = || {
965                                     let expr0_0: Type = I64;
966                                     return Some(expr0_0);
967                                 };
968                                 if let Some(pattern12_0) = closure12() {
969                                     let closure13 = || {
970                                         return Some(pattern9_1);
971                                     };
972                                     if let Some(pattern13_0) = closure13() {
973                                         if let Some(pattern14_0) = C::sum_extend_fits_in_32_bits(
974                                             ctx,
975                                             pattern11_0,
976                                             pattern12_0,
977                                             pattern13_0,
978                                         ) {
979                                             // Rule at src/isa/x64/inst.isle line 827.
980                                             let expr0_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
981                                             let expr1_0 = constructor_amode_imm_reg_flags(
982                                                 ctx,
983                                                 pattern14_0,
984                                                 expr0_0,
985                                                 pattern0_0,
986                                             )?;
987                                             return Some(expr1_0);
988                                         }
989                                     }
990                                 }
991                             }
992                         }
993                         &InstructionData::Binary {
994                             opcode: ref pattern9_0,
995                             args: ref pattern9_1,
996                         } => {
997                             if let &Opcode::Ishl = pattern9_0 {
998                                 let (pattern11_0, pattern11_1) =
999                                     C::unpack_value_array_2(ctx, pattern9_1);
1000                                 if let Some(pattern12_0) = C::const_shift_lt_eq_3(ctx, pattern11_1)
1001                                 {
1002                                     let pattern13_0 = arg2;
1003                                     // Rule at src/isa/x64/inst.isle line 819.
1004                                     let expr0_0 = C::offset32_to_u32(ctx, pattern13_0);
1005                                     let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1006                                     let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
1007                                     let expr3_0 = constructor_amode_imm_reg_reg_shift_flags(
1008                                         ctx,
1009                                         expr0_0,
1010                                         expr1_0,
1011                                         expr2_0,
1012                                         pattern12_0,
1013                                         pattern0_0,
1014                                     )?;
1015                                     return Some(expr3_0);
1016                                 }
1017                             }
1018                         }
1019                         _ => {}
1020                     }
1021                     if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
1022                         let pattern9_0 = C::value_type(ctx, pattern8_0);
1023                         let pattern10_0 = C::inst_data(ctx, pattern7_0);
1024                         if let &InstructionData::Unary {
1025                             opcode: ref pattern11_0,
1026                             arg: pattern11_1,
1027                         } = &pattern10_0
1028                         {
1029                             if let &Opcode::Uextend = pattern11_0 {
1030                                 if let Some(pattern13_0) = C::def_inst(ctx, pattern11_1) {
1031                                     let pattern14_0 = C::inst_data(ctx, pattern13_0);
1032                                     if let &InstructionData::UnaryImm {
1033                                         opcode: ref pattern15_0,
1034                                         imm: pattern15_1,
1035                                     } = &pattern14_0
1036                                     {
1037                                         if let &Opcode::Iconst = pattern15_0 {
1038                                             let pattern17_0 = arg2;
1039                                             let closure18 = || {
1040                                                 return Some(pattern9_0);
1041                                             };
1042                                             if let Some(pattern18_0) = closure18() {
1043                                                 let closure19 = || {
1044                                                     return Some(pattern15_1);
1045                                                 };
1046                                                 if let Some(pattern19_0) = closure19() {
1047                                                     if let Some(pattern20_0) =
1048                                                         C::sum_extend_fits_in_32_bits(
1049                                                             ctx,
1050                                                             pattern17_0,
1051                                                             pattern18_0,
1052                                                             pattern19_0,
1053                                                         )
1054                                                     {
1055                                                         // Rule at src/isa/x64/inst.isle line 832.
1056                                                         let expr0_0 = constructor_put_in_gpr(
1057                                                             ctx, pattern6_0,
1058                                                         )?;
1059                                                         let expr1_0 =
1060                                                             constructor_amode_imm_reg_flags(
1061                                                                 ctx,
1062                                                                 pattern20_0,
1063                                                                 expr0_0,
1064                                                                 pattern0_0,
1065                                                             )?;
1066                                                         return Some(expr1_0);
1067                                                     }
1068                                                 }
1069                                             }
1070                                         }
1071                                     }
1072                                 }
1073                             }
1074                         }
1075                     }
1076                 }
1077                 let pattern7_0 = arg2;
1078                 // Rule at src/isa/x64/inst.isle line 835.
1079                 let expr0_0 = C::offset32_to_u32(ctx, pattern7_0);
1080                 let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
1081                 let expr2_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
1082                 let expr3_0: u8 = 0;
1083                 let expr4_0 = constructor_amode_imm_reg_reg_shift_flags(
1084                     ctx, expr0_0, expr1_0, expr2_0, expr3_0, pattern0_0,
1085                 )?;
1086                 return Some(expr4_0);
1087             }
1088         }
1089     }
1090     let pattern2_0 = arg2;
1091     // Rule at src/isa/x64/inst.isle line 838.
1092     let expr0_0 = C::offset32_to_u32(ctx, pattern2_0);
1093     let expr1_0 = constructor_put_in_gpr(ctx, pattern1_0)?;
1094     let expr2_0 = constructor_amode_imm_reg_flags(ctx, expr0_0, expr1_0, pattern0_0)?;
1095     return Some(expr2_0);
1096 }
1097 
1098 // Generated as internal constructor for term reg_to_gpr_mem_imm.
1099 pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> Option<GprMemImm> {
1100     let pattern0_0 = arg0;
1101     // Rule at src/isa/x64/inst.isle line 1032.
1102     let expr0_0 = C::gpr_new(ctx, pattern0_0);
1103     let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
1104     return Some(expr1_0);
1105 }
1106 
1107 // Generated as internal constructor for term put_in_gpr.
1108 pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1109     let pattern0_0 = arg0;
1110     // Rule at src/isa/x64/inst.isle line 1039.
1111     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1112     let expr1_0 = C::gpr_new(ctx, expr0_0);
1113     return Some(expr1_0);
1114 }
1115 
1116 // Generated as internal constructor for term put_in_gpr_mem.
1117 pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMem> {
1118     let pattern0_0 = arg0;
1119     // Rule at src/isa/x64/inst.isle line 1046.
1120     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1121     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
1122     return Some(expr1_0);
1123 }
1124 
1125 // Generated as internal constructor for term put_in_gpr_mem_imm.
1126 pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMemImm> {
1127     let pattern0_0 = arg0;
1128     // Rule at src/isa/x64/inst.isle line 1053.
1129     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1130     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1131     return Some(expr1_0);
1132 }
1133 
1134 // Generated as internal constructor for term put_in_xmm.
1135 pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Option<Xmm> {
1136     let pattern0_0 = arg0;
1137     // Rule at src/isa/x64/inst.isle line 1060.
1138     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1139     let expr1_0 = C::xmm_new(ctx, expr0_0);
1140     return Some(expr1_0);
1141 }
1142 
1143 // Generated as internal constructor for term put_in_xmm_mem.
1144 pub fn constructor_put_in_xmm_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMem> {
1145     let pattern0_0 = arg0;
1146     // Rule at src/isa/x64/inst.isle line 1067.
1147     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1148     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
1149     return Some(expr1_0);
1150 }
1151 
1152 // Generated as internal constructor for term put_in_xmm_mem_imm.
1153 pub fn constructor_put_in_xmm_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMemImm> {
1154     let pattern0_0 = arg0;
1155     // Rule at src/isa/x64/inst.isle line 1074.
1156     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1157     let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0);
1158     return Some(expr1_0);
1159 }
1160 
1161 // Generated as internal constructor for term output_gpr.
1162 pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<InstOutput> {
1163     let pattern0_0 = arg0;
1164     // Rule at src/isa/x64/inst.isle line 1079.
1165     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1166     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1167     return Some(expr1_0);
1168 }
1169 
1170 // Generated as internal constructor for term value_gprs.
1171 pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option<ValueRegs> {
1172     let pattern0_0 = arg0;
1173     let pattern1_0 = arg1;
1174     // Rule at src/isa/x64/inst.isle line 1084.
1175     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1176     let expr1_0 = C::gpr_to_reg(ctx, pattern1_0);
1177     let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0);
1178     return Some(expr2_0);
1179 }
1180 
1181 // Generated as internal constructor for term output_xmm.
1182 pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<InstOutput> {
1183     let pattern0_0 = arg0;
1184     // Rule at src/isa/x64/inst.isle line 1089.
1185     let expr0_0 = C::xmm_to_reg(ctx, pattern0_0);
1186     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1187     return Some(expr1_0);
1188 }
1189 
1190 // Generated as internal constructor for term value_regs_get_gpr.
1191 pub fn constructor_value_regs_get_gpr<C: Context>(
1192     ctx: &mut C,
1193     arg0: ValueRegs,
1194     arg1: usize,
1195 ) -> Option<Gpr> {
1196     let pattern0_0 = arg0;
1197     let pattern1_0 = arg1;
1198     // Rule at src/isa/x64/inst.isle line 1096.
1199     let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0);
1200     let expr1_0 = C::gpr_new(ctx, expr0_0);
1201     return Some(expr1_0);
1202 }
1203 
1204 // Generated as internal constructor for term lo_gpr.
1205 pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1206     let pattern0_0 = arg0;
1207     // Rule at src/isa/x64/inst.isle line 1109.
1208     let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?;
1209     let expr1_0 = C::gpr_new(ctx, expr0_0);
1210     return Some(expr1_0);
1211 }
1212 
1213 // Generated as internal constructor for term sink_load_to_gpr_mem_imm.
1214 pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
1215     ctx: &mut C,
1216     arg0: &SinkableLoad,
1217 ) -> Option<GprMemImm> {
1218     let pattern0_0 = arg0;
1219     // Rule at src/isa/x64/inst.isle line 1192.
1220     let expr0_0 = C::sink_load(ctx, pattern0_0);
1221     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1222     return Some(expr1_0);
1223 }
1224 
1225 // Generated as internal constructor for term extend_to_gpr.
1226 pub fn constructor_extend_to_gpr<C: Context>(
1227     ctx: &mut C,
1228     arg0: Value,
1229     arg1: Type,
1230     arg2: &ExtendKind,
1231 ) -> Option<Gpr> {
1232     let pattern0_0 = arg0;
1233     let pattern1_0 = C::value_type(ctx, pattern0_0);
1234     let pattern2_0 = arg1;
1235     if pattern2_0 == pattern1_0 {
1236         let pattern4_0 = arg2;
1237         // Rule at src/isa/x64/inst.isle line 1214.
1238         let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
1239         return Some(expr0_0);
1240     }
1241     let pattern3_0 = arg2;
1242     // Rule at src/isa/x64/inst.isle line 1217.
1243     let expr0_0 = C::ty_bits_u16(ctx, pattern1_0);
1244     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0);
1245     let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?;
1246     let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0);
1247     let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?;
1248     let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?;
1249     return Some(expr5_0);
1250 }
1251 
1252 // Generated as internal constructor for term extend.
1253 pub fn constructor_extend<C: Context>(
1254     ctx: &mut C,
1255     arg0: &ExtendKind,
1256     arg1: Type,
1257     arg2: &ExtMode,
1258     arg3: &GprMem,
1259 ) -> Option<Gpr> {
1260     let pattern0_0 = arg0;
1261     match pattern0_0 {
1262         &ExtendKind::Sign => {
1263             let pattern2_0 = arg1;
1264             let pattern3_0 = arg2;
1265             let pattern4_0 = arg3;
1266             // Rule at src/isa/x64/inst.isle line 1237.
1267             let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?;
1268             return Some(expr0_0);
1269         }
1270         &ExtendKind::Zero => {
1271             let pattern2_0 = arg1;
1272             let pattern3_0 = arg2;
1273             let pattern4_0 = arg3;
1274             // Rule at src/isa/x64/inst.isle line 1233.
1275             let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?;
1276             return Some(expr0_0);
1277         }
1278         _ => {}
1279     }
1280     return None;
1281 }
1282 
1283 // Generated as internal constructor for term sse_xor_op.
1284 pub fn constructor_sse_xor_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1285     let pattern0_0 = arg0;
1286     if pattern0_0 == F32X4 {
1287         // Rule at src/isa/x64/inst.isle line 1244.
1288         let expr0_0 = SseOpcode::Xorps;
1289         return Some(expr0_0);
1290     }
1291     if pattern0_0 == F64X2 {
1292         // Rule at src/isa/x64/inst.isle line 1245.
1293         let expr0_0 = SseOpcode::Xorpd;
1294         return Some(expr0_0);
1295     }
1296     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1297         // Rule at src/isa/x64/inst.isle line 1246.
1298         let expr0_0 = SseOpcode::Pxor;
1299         return Some(expr0_0);
1300     }
1301     return None;
1302 }
1303 
1304 // Generated as internal constructor for term sse_xor.
1305 pub fn constructor_sse_xor<C: Context>(
1306     ctx: &mut C,
1307     arg0: Type,
1308     arg1: Xmm,
1309     arg2: &XmmMem,
1310 ) -> Option<Xmm> {
1311     let pattern0_0 = arg0;
1312     let pattern1_0 = arg1;
1313     let pattern2_0 = arg2;
1314     // Rule at src/isa/x64/inst.isle line 1250.
1315     let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
1316     let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1317     return Some(expr1_0);
1318 }
1319 
1320 // Generated as internal constructor for term sse_cmp_op.
1321 pub fn constructor_sse_cmp_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1322     let pattern0_0 = arg0;
1323     if pattern0_0 == F32X4 {
1324         // Rule at src/isa/x64/inst.isle line 1259.
1325         let expr0_0 = SseOpcode::Cmpps;
1326         return Some(expr0_0);
1327     }
1328     if pattern0_0 == F64X2 {
1329         // Rule at src/isa/x64/inst.isle line 1260.
1330         let expr0_0 = SseOpcode::Cmppd;
1331         return Some(expr0_0);
1332     }
1333     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1334         if pattern1_0 == 8 {
1335             if pattern1_1 == 16 {
1336                 // Rule at src/isa/x64/inst.isle line 1255.
1337                 let expr0_0 = SseOpcode::Pcmpeqb;
1338                 return Some(expr0_0);
1339             }
1340         }
1341         if pattern1_0 == 16 {
1342             if pattern1_1 == 8 {
1343                 // Rule at src/isa/x64/inst.isle line 1256.
1344                 let expr0_0 = SseOpcode::Pcmpeqw;
1345                 return Some(expr0_0);
1346             }
1347         }
1348         if pattern1_0 == 32 {
1349             if pattern1_1 == 4 {
1350                 // Rule at src/isa/x64/inst.isle line 1257.
1351                 let expr0_0 = SseOpcode::Pcmpeqd;
1352                 return Some(expr0_0);
1353             }
1354         }
1355         if pattern1_0 == 64 {
1356             if pattern1_1 == 2 {
1357                 // Rule at src/isa/x64/inst.isle line 1258.
1358                 let expr0_0 = SseOpcode::Pcmpeqq;
1359                 return Some(expr0_0);
1360             }
1361         }
1362     }
1363     return None;
1364 }
1365 
1366 // Generated as internal constructor for term vector_all_ones.
1367 pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C, arg0: Type) -> Option<Xmm> {
1368     let pattern0_0 = arg0;
1369     // Rule at src/isa/x64/inst.isle line 1274.
1370     let expr0_0 = C::temp_writable_xmm(ctx);
1371     let expr1_0: Type = I32X4;
1372     let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?;
1373     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1374     let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?;
1375     let expr5_0 = MInst::XmmRmR {
1376         op: expr2_0,
1377         src1: expr3_0,
1378         src2: expr4_0,
1379         dst: expr0_0,
1380     };
1381     let expr6_0 = C::emit(ctx, &expr5_0);
1382     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1383     return Some(expr7_0);
1384 }
1385 
1386 // Generated as internal constructor for term make_i64x2_from_lanes.
1387 pub fn constructor_make_i64x2_from_lanes<C: Context>(
1388     ctx: &mut C,
1389     arg0: &GprMem,
1390     arg1: &GprMem,
1391 ) -> Option<Xmm> {
1392     let pattern0_0 = arg0;
1393     let pattern1_0 = arg1;
1394     // Rule at src/isa/x64/inst.isle line 1284.
1395     let expr0_0 = C::temp_writable_xmm(ctx);
1396     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1397     let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 };
1398     let expr3_0 = C::emit(ctx, &expr2_0);
1399     let expr4_0 = SseOpcode::Pinsrd;
1400     let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0);
1401     let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0);
1402     let expr7_0: u8 = 0;
1403     let expr8_0 = OperandSize::Size64;
1404     let expr9_0 = MInst::XmmRmRImm {
1405         op: expr4_0,
1406         src1: expr5_0,
1407         src2: expr6_0,
1408         dst: expr1_0,
1409         imm: expr7_0,
1410         size: expr8_0,
1411     };
1412     let expr10_0 = C::emit(ctx, &expr9_0);
1413     let expr11_0 = SseOpcode::Pinsrd;
1414     let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0);
1415     let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
1416     let expr14_0: u8 = 1;
1417     let expr15_0 = OperandSize::Size64;
1418     let expr16_0 = MInst::XmmRmRImm {
1419         op: expr11_0,
1420         src1: expr12_0,
1421         src2: expr13_0,
1422         dst: expr1_0,
1423         imm: expr14_0,
1424         size: expr15_0,
1425     };
1426     let expr17_0 = C::emit(ctx, &expr16_0);
1427     let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1428     return Some(expr18_0);
1429 }
1430 
1431 // Generated as internal constructor for term mov_rmi_to_xmm.
1432 pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> Option<XmmMemImm> {
1433     let pattern0_0 = arg0;
1434     match pattern0_0 {
1435         &RegMemImm::Imm { simm32: pattern1_0 } => {
1436             // Rule at src/isa/x64/inst.isle line 1305.
1437             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1438             return Some(expr0_0);
1439         }
1440         &RegMemImm::Reg { reg: pattern1_0 } => {
1441             // Rule at src/isa/x64/inst.isle line 1306.
1442             let expr0_0 = SseOpcode::Movd;
1443             let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0);
1444             let expr2_0 = OperandSize::Size32;
1445             let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?;
1446             let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0);
1447             return Some(expr4_0);
1448         }
1449         &RegMemImm::Mem {
1450             addr: ref pattern1_0,
1451         } => {
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         _ => {}
1457     }
1458     return None;
1459 }
1460 
1461 // Generated as internal constructor for term x64_load.
1462 pub fn constructor_x64_load<C: Context>(
1463     ctx: &mut C,
1464     arg0: Type,
1465     arg1: &SyntheticAmode,
1466     arg2: &ExtKind,
1467 ) -> Option<Reg> {
1468     let pattern0_0 = arg0;
1469     if pattern0_0 == I64 {
1470         let pattern2_0 = arg1;
1471         let pattern3_0 = arg2;
1472         // Rule at src/isa/x64/inst.isle line 1320.
1473         let expr0_0 = C::temp_writable_gpr(ctx);
1474         let expr1_0 = MInst::Mov64MR {
1475             src: pattern2_0.clone(),
1476             dst: expr0_0,
1477         };
1478         let expr2_0 = C::emit(ctx, &expr1_0);
1479         let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1480         return Some(expr3_0);
1481     }
1482     if pattern0_0 == F32 {
1483         let pattern2_0 = arg1;
1484         let pattern3_0 = arg2;
1485         // Rule at src/isa/x64/inst.isle line 1325.
1486         let expr0_0 = SseOpcode::Movss;
1487         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1488         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1489         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1490         return Some(expr3_0);
1491     }
1492     if pattern0_0 == F64 {
1493         let pattern2_0 = arg1;
1494         let pattern3_0 = arg2;
1495         // Rule at src/isa/x64/inst.isle line 1329.
1496         let expr0_0 = SseOpcode::Movsd;
1497         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1498         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1499         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1500         return Some(expr3_0);
1501     }
1502     if pattern0_0 == F32X4 {
1503         let pattern2_0 = arg1;
1504         let pattern3_0 = arg2;
1505         // Rule at src/isa/x64/inst.isle line 1333.
1506         let expr0_0 = SseOpcode::Movups;
1507         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1508         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1509         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1510         return Some(expr3_0);
1511     }
1512     if pattern0_0 == F64X2 {
1513         let pattern2_0 = arg1;
1514         let pattern3_0 = arg2;
1515         // Rule at src/isa/x64/inst.isle line 1337.
1516         let expr0_0 = SseOpcode::Movupd;
1517         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1518         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1519         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1520         return Some(expr3_0);
1521     }
1522     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1523         let pattern2_0 = arg1;
1524         let pattern3_0 = arg2;
1525         // Rule at src/isa/x64/inst.isle line 1341.
1526         let expr0_0 = SseOpcode::Movdqu;
1527         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1528         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1529         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1530         return Some(expr3_0);
1531     }
1532     if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) {
1533         let pattern2_0 = arg1;
1534         let pattern3_0 = arg2;
1535         if let &ExtKind::SignExtend = pattern3_0 {
1536             // Rule at src/isa/x64/inst.isle line 1316.
1537             let expr0_0 = C::ty_bytes(ctx, pattern1_0);
1538             let expr1_0: u16 = 8;
1539             let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
1540             let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?;
1541             let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?;
1542             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
1543             return Some(expr5_0);
1544         }
1545     }
1546     return None;
1547 }
1548 
1549 // Generated as internal constructor for term x64_mov.
1550 pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<Reg> {
1551     let pattern0_0 = arg0;
1552     // Rule at src/isa/x64/inst.isle line 1346.
1553     let expr0_0 = C::temp_writable_gpr(ctx);
1554     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
1555     let expr2_0 = MInst::Mov64MR {
1556         src: expr1_0,
1557         dst: expr0_0,
1558     };
1559     let expr3_0 = C::emit(ctx, &expr2_0);
1560     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1561     return Some(expr4_0);
1562 }
1563 
1564 // Generated as internal constructor for term x64_movzx.
1565 pub fn constructor_x64_movzx<C: Context>(
1566     ctx: &mut C,
1567     arg0: &ExtMode,
1568     arg1: &GprMem,
1569 ) -> Option<Gpr> {
1570     let pattern0_0 = arg0;
1571     let pattern1_0 = arg1;
1572     // Rule at src/isa/x64/inst.isle line 1352.
1573     let expr0_0 = C::temp_writable_gpr(ctx);
1574     let expr1_0 = MInst::MovzxRmR {
1575         ext_mode: pattern0_0.clone(),
1576         src: pattern1_0.clone(),
1577         dst: expr0_0,
1578     };
1579     let expr2_0 = C::emit(ctx, &expr1_0);
1580     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1581     return Some(expr3_0);
1582 }
1583 
1584 // Generated as internal constructor for term x64_movsx.
1585 pub fn constructor_x64_movsx<C: Context>(
1586     ctx: &mut C,
1587     arg0: &ExtMode,
1588     arg1: &GprMem,
1589 ) -> Option<Gpr> {
1590     let pattern0_0 = arg0;
1591     let pattern1_0 = arg1;
1592     // Rule at src/isa/x64/inst.isle line 1358.
1593     let expr0_0 = C::temp_writable_gpr(ctx);
1594     let expr1_0 = MInst::MovsxRmR {
1595         ext_mode: pattern0_0.clone(),
1596         src: pattern1_0.clone(),
1597         dst: expr0_0,
1598     };
1599     let expr2_0 = C::emit(ctx, &expr1_0);
1600     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1601     return Some(expr3_0);
1602 }
1603 
1604 // Generated as internal constructor for term x64_movss_load.
1605 pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1606     let pattern0_0 = arg0;
1607     // Rule at src/isa/x64/inst.isle line 1364.
1608     let expr0_0 = SseOpcode::Movss;
1609     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1610     return Some(expr1_0);
1611 }
1612 
1613 // Generated as internal constructor for term x64_movsd_load.
1614 pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1615     let pattern0_0 = arg0;
1616     // Rule at src/isa/x64/inst.isle line 1368.
1617     let expr0_0 = SseOpcode::Movsd;
1618     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1619     return Some(expr1_0);
1620 }
1621 
1622 // Generated as internal constructor for term x64_movups.
1623 pub fn constructor_x64_movups<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1624     let pattern0_0 = arg0;
1625     // Rule at src/isa/x64/inst.isle line 1372.
1626     let expr0_0 = SseOpcode::Movups;
1627     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1628     return Some(expr1_0);
1629 }
1630 
1631 // Generated as internal constructor for term x64_movupd.
1632 pub fn constructor_x64_movupd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1633     let pattern0_0 = arg0;
1634     // Rule at src/isa/x64/inst.isle line 1376.
1635     let expr0_0 = SseOpcode::Movupd;
1636     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1637     return Some(expr1_0);
1638 }
1639 
1640 // Generated as internal constructor for term x64_movdqu.
1641 pub fn constructor_x64_movdqu<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1642     let pattern0_0 = arg0;
1643     // Rule at src/isa/x64/inst.isle line 1380.
1644     let expr0_0 = SseOpcode::Movdqu;
1645     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1646     return Some(expr1_0);
1647 }
1648 
1649 // Generated as internal constructor for term x64_pmovsxbw.
1650 pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1651     let pattern0_0 = arg0;
1652     // Rule at src/isa/x64/inst.isle line 1384.
1653     let expr0_0 = SseOpcode::Pmovsxbw;
1654     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1655     return Some(expr1_0);
1656 }
1657 
1658 // Generated as internal constructor for term x64_pmovzxbw.
1659 pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1660     let pattern0_0 = arg0;
1661     // Rule at src/isa/x64/inst.isle line 1388.
1662     let expr0_0 = SseOpcode::Pmovzxbw;
1663     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1664     return Some(expr1_0);
1665 }
1666 
1667 // Generated as internal constructor for term x64_pmovsxwd.
1668 pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1669     let pattern0_0 = arg0;
1670     // Rule at src/isa/x64/inst.isle line 1392.
1671     let expr0_0 = SseOpcode::Pmovsxwd;
1672     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1673     return Some(expr1_0);
1674 }
1675 
1676 // Generated as internal constructor for term x64_pmovzxwd.
1677 pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1678     let pattern0_0 = arg0;
1679     // Rule at src/isa/x64/inst.isle line 1396.
1680     let expr0_0 = SseOpcode::Pmovzxwd;
1681     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1682     return Some(expr1_0);
1683 }
1684 
1685 // Generated as internal constructor for term x64_pmovsxdq.
1686 pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1687     let pattern0_0 = arg0;
1688     // Rule at src/isa/x64/inst.isle line 1400.
1689     let expr0_0 = SseOpcode::Pmovsxdq;
1690     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1691     return Some(expr1_0);
1692 }
1693 
1694 // Generated as internal constructor for term x64_pmovzxdq.
1695 pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1696     let pattern0_0 = arg0;
1697     // Rule at src/isa/x64/inst.isle line 1404.
1698     let expr0_0 = SseOpcode::Pmovzxdq;
1699     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1700     return Some(expr1_0);
1701 }
1702 
1703 // Generated as internal constructor for term x64_xmm_load_const.
1704 pub fn constructor_x64_xmm_load_const<C: Context>(
1705     ctx: &mut C,
1706     arg0: Type,
1707     arg1: VCodeConstant,
1708 ) -> Option<Xmm> {
1709     let pattern0_0 = arg0;
1710     let pattern1_0 = arg1;
1711     // Rule at src/isa/x64/inst.isle line 1409.
1712     let expr0_0 = C::temp_writable_xmm(ctx);
1713     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1714     let expr2_0 = MInst::XmmLoadConst {
1715         src: pattern1_0,
1716         dst: expr1_0,
1717         ty: pattern0_0,
1718     };
1719     let expr3_0 = C::emit(ctx, &expr2_0);
1720     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1721     return Some(expr4_0);
1722 }
1723 
1724 // Generated as internal constructor for term alu_rmi_r.
1725 pub fn constructor_alu_rmi_r<C: Context>(
1726     ctx: &mut C,
1727     arg0: Type,
1728     arg1: &AluRmiROpcode,
1729     arg2: Gpr,
1730     arg3: &GprMemImm,
1731 ) -> Option<Gpr> {
1732     let pattern0_0 = arg0;
1733     let pattern1_0 = arg1;
1734     let pattern2_0 = arg2;
1735     let pattern3_0 = arg3;
1736     // Rule at src/isa/x64/inst.isle line 1422.
1737     let expr0_0 = C::temp_writable_gpr(ctx);
1738     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1739     let expr2_0 = MInst::AluRmiR {
1740         size: expr1_0,
1741         op: pattern1_0.clone(),
1742         src1: pattern2_0,
1743         src2: pattern3_0.clone(),
1744         dst: expr0_0,
1745     };
1746     let expr3_0 = C::emit(ctx, &expr2_0);
1747     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1748     return Some(expr4_0);
1749 }
1750 
1751 // Generated as internal constructor for term x64_add.
1752 pub fn constructor_x64_add<C: Context>(
1753     ctx: &mut C,
1754     arg0: Type,
1755     arg1: Gpr,
1756     arg2: &GprMemImm,
1757 ) -> Option<Gpr> {
1758     let pattern0_0 = arg0;
1759     let pattern1_0 = arg1;
1760     let pattern2_0 = arg2;
1761     // Rule at src/isa/x64/inst.isle line 1430.
1762     let expr0_0 = AluRmiROpcode::Add;
1763     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1764     return Some(expr1_0);
1765 }
1766 
1767 // Generated as internal constructor for term x64_add_with_flags_paired.
1768 pub fn constructor_x64_add_with_flags_paired<C: Context>(
1769     ctx: &mut C,
1770     arg0: Type,
1771     arg1: Gpr,
1772     arg2: &GprMemImm,
1773 ) -> Option<ProducesFlags> {
1774     let pattern0_0 = arg0;
1775     let pattern1_0 = arg1;
1776     let pattern2_0 = arg2;
1777     // Rule at src/isa/x64/inst.isle line 1438.
1778     let expr0_0 = C::temp_writable_gpr(ctx);
1779     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1780     let expr2_0 = AluRmiROpcode::Add;
1781     let expr3_0 = MInst::AluRmiR {
1782         size: expr1_0,
1783         op: expr2_0,
1784         src1: pattern1_0,
1785         src2: pattern2_0.clone(),
1786         dst: expr0_0,
1787     };
1788     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1789     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1790         inst: expr3_0,
1791         result: expr4_0,
1792     };
1793     return Some(expr5_0);
1794 }
1795 
1796 // Generated as internal constructor for term x64_adc_paired.
1797 pub fn constructor_x64_adc_paired<C: Context>(
1798     ctx: &mut C,
1799     arg0: Type,
1800     arg1: Gpr,
1801     arg2: &GprMemImm,
1802 ) -> Option<ConsumesFlags> {
1803     let pattern0_0 = arg0;
1804     let pattern1_0 = arg1;
1805     let pattern2_0 = arg2;
1806     // Rule at src/isa/x64/inst.isle line 1450.
1807     let expr0_0 = C::temp_writable_gpr(ctx);
1808     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1809     let expr2_0 = AluRmiROpcode::Adc;
1810     let expr3_0 = MInst::AluRmiR {
1811         size: expr1_0,
1812         op: expr2_0,
1813         src1: pattern1_0,
1814         src2: pattern2_0.clone(),
1815         dst: expr0_0,
1816     };
1817     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1818     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1819         inst: expr3_0,
1820         result: expr4_0,
1821     };
1822     return Some(expr5_0);
1823 }
1824 
1825 // Generated as internal constructor for term x64_sub.
1826 pub fn constructor_x64_sub<C: Context>(
1827     ctx: &mut C,
1828     arg0: Type,
1829     arg1: Gpr,
1830     arg2: &GprMemImm,
1831 ) -> Option<Gpr> {
1832     let pattern0_0 = arg0;
1833     let pattern1_0 = arg1;
1834     let pattern2_0 = arg2;
1835     // Rule at src/isa/x64/inst.isle line 1462.
1836     let expr0_0 = AluRmiROpcode::Sub;
1837     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1838     return Some(expr1_0);
1839 }
1840 
1841 // Generated as internal constructor for term x64_sub_with_flags_paired.
1842 pub fn constructor_x64_sub_with_flags_paired<C: Context>(
1843     ctx: &mut C,
1844     arg0: Type,
1845     arg1: Gpr,
1846     arg2: &GprMemImm,
1847 ) -> Option<ProducesFlags> {
1848     let pattern0_0 = arg0;
1849     let pattern1_0 = arg1;
1850     let pattern2_0 = arg2;
1851     // Rule at src/isa/x64/inst.isle line 1470.
1852     let expr0_0 = C::temp_writable_gpr(ctx);
1853     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1854     let expr2_0 = AluRmiROpcode::Sub;
1855     let expr3_0 = MInst::AluRmiR {
1856         size: expr1_0,
1857         op: expr2_0,
1858         src1: pattern1_0,
1859         src2: pattern2_0.clone(),
1860         dst: expr0_0,
1861     };
1862     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1863     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
1864         inst: expr3_0,
1865         result: expr4_0,
1866     };
1867     return Some(expr5_0);
1868 }
1869 
1870 // Generated as internal constructor for term x64_sbb_paired.
1871 pub fn constructor_x64_sbb_paired<C: Context>(
1872     ctx: &mut C,
1873     arg0: Type,
1874     arg1: Gpr,
1875     arg2: &GprMemImm,
1876 ) -> Option<ConsumesFlags> {
1877     let pattern0_0 = arg0;
1878     let pattern1_0 = arg1;
1879     let pattern2_0 = arg2;
1880     // Rule at src/isa/x64/inst.isle line 1482.
1881     let expr0_0 = C::temp_writable_gpr(ctx);
1882     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1883     let expr2_0 = AluRmiROpcode::Sbb;
1884     let expr3_0 = MInst::AluRmiR {
1885         size: expr1_0,
1886         op: expr2_0,
1887         src1: pattern1_0,
1888         src2: pattern2_0.clone(),
1889         dst: expr0_0,
1890     };
1891     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1892     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
1893         inst: expr3_0,
1894         result: expr4_0,
1895     };
1896     return Some(expr5_0);
1897 }
1898 
1899 // Generated as internal constructor for term x64_mul.
1900 pub fn constructor_x64_mul<C: Context>(
1901     ctx: &mut C,
1902     arg0: Type,
1903     arg1: Gpr,
1904     arg2: &GprMemImm,
1905 ) -> Option<Gpr> {
1906     let pattern0_0 = arg0;
1907     let pattern1_0 = arg1;
1908     let pattern2_0 = arg2;
1909     // Rule at src/isa/x64/inst.isle line 1494.
1910     let expr0_0 = AluRmiROpcode::Mul;
1911     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1912     return Some(expr1_0);
1913 }
1914 
1915 // Generated as internal constructor for term x64_and.
1916 pub fn constructor_x64_and<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 1502.
1926     let expr0_0 = AluRmiROpcode::And;
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_with_flags_paired.
1932 pub fn constructor_x64_and_with_flags_paired<C: Context>(
1933     ctx: &mut C,
1934     arg0: Type,
1935     arg1: Gpr,
1936     arg2: &GprMemImm,
1937 ) -> Option<ProducesFlags> {
1938     let pattern0_0 = arg0;
1939     let pattern1_0 = arg1;
1940     let pattern2_0 = arg2;
1941     // Rule at src/isa/x64/inst.isle line 1509.
1942     let expr0_0 = C::temp_writable_gpr(ctx);
1943     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
1944     let expr2_0 = AluRmiROpcode::And;
1945     let expr3_0 = MInst::AluRmiR {
1946         size: expr1_0,
1947         op: expr2_0,
1948         src1: pattern1_0,
1949         src2: pattern2_0.clone(),
1950         dst: expr0_0,
1951     };
1952     let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 };
1953     return Some(expr4_0);
1954 }
1955 
1956 // Generated as internal constructor for term x64_or.
1957 pub fn constructor_x64_or<C: Context>(
1958     ctx: &mut C,
1959     arg0: Type,
1960     arg1: Gpr,
1961     arg2: &GprMemImm,
1962 ) -> Option<Gpr> {
1963     let pattern0_0 = arg0;
1964     let pattern1_0 = arg1;
1965     let pattern2_0 = arg2;
1966     // Rule at src/isa/x64/inst.isle line 1520.
1967     let expr0_0 = AluRmiROpcode::Or;
1968     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1969     return Some(expr1_0);
1970 }
1971 
1972 // Generated as internal constructor for term x64_xor.
1973 pub fn constructor_x64_xor<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 1528.
1983     let expr0_0 = AluRmiROpcode::Xor;
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 imm.
1989 pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Option<Reg> {
1990     let pattern0_0 = arg0;
1991     if pattern0_0 == I64 {
1992         let pattern2_0 = arg1;
1993         if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) {
1994             // Rule at src/isa/x64/inst.isle line 1568.
1995             let expr0_0 = C::temp_writable_gpr(ctx);
1996             let expr1_0 = OperandSize::Size32;
1997             let expr2_0 = MInst::Imm {
1998                 dst_size: expr1_0,
1999                 simm64: pattern3_0,
2000                 dst: expr0_0,
2001             };
2002             let expr3_0 = C::emit(ctx, &expr2_0);
2003             let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2004             return Some(expr4_0);
2005         }
2006     }
2007     if pattern0_0 == F32 {
2008         let pattern2_0 = arg1;
2009         if pattern2_0 == 0 {
2010             // Rule at src/isa/x64/inst.isle line 1597.
2011             let expr0_0 = C::temp_writable_xmm(ctx);
2012             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2013             let expr2_0 = SseOpcode::Xorps;
2014             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2015             let expr4_0 = MInst::XmmRmR {
2016                 op: expr2_0,
2017                 src1: expr1_0,
2018                 src2: expr3_0,
2019                 dst: expr0_0,
2020             };
2021             let expr5_0 = C::emit(ctx, &expr4_0);
2022             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2023             return Some(expr6_0);
2024         }
2025         // Rule at src/isa/x64/inst.isle line 1545.
2026         let expr0_0 = SseOpcode::Movd;
2027         let expr1_0: Type = I32;
2028         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2029         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2030         let expr4_0 = OperandSize::Size32;
2031         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2032         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2033         return Some(expr6_0);
2034     }
2035     if pattern0_0 == F64 {
2036         let pattern2_0 = arg1;
2037         if pattern2_0 == 0 {
2038             // Rule at src/isa/x64/inst.isle line 1609.
2039             let expr0_0 = C::temp_writable_xmm(ctx);
2040             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2041             let expr2_0 = SseOpcode::Xorpd;
2042             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2043             let expr4_0 = MInst::XmmRmR {
2044                 op: expr2_0,
2045                 src1: expr1_0,
2046                 src2: expr3_0,
2047                 dst: expr0_0,
2048             };
2049             let expr5_0 = C::emit(ctx, &expr4_0);
2050             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2051             return Some(expr6_0);
2052         }
2053         // Rule at src/isa/x64/inst.isle line 1551.
2054         let expr0_0 = SseOpcode::Movq;
2055         let expr1_0: Type = I64;
2056         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2057         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2058         let expr4_0 = OperandSize::Size64;
2059         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2060         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2061         return Some(expr6_0);
2062     }
2063     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
2064         let pattern2_0 = arg1;
2065         if pattern2_0 == 0 {
2066             // Rule at src/isa/x64/inst.isle line 1587.
2067             let expr0_0 = C::temp_writable_xmm(ctx);
2068             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2069             let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
2070             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2071             let expr4_0 = MInst::XmmRmR {
2072                 op: expr2_0,
2073                 src1: expr1_0,
2074                 src2: expr3_0,
2075                 dst: expr0_0,
2076             };
2077             let expr5_0 = C::emit(ctx, &expr4_0);
2078             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2079             return Some(expr6_0);
2080         }
2081     }
2082     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
2083         let pattern2_0 = arg1;
2084         if pattern2_0 == 0 {
2085             // Rule at src/isa/x64/inst.isle line 1574.
2086             let expr0_0 = C::temp_writable_gpr(ctx);
2087             let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2088             let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2089             let expr3_0 = AluRmiROpcode::Xor;
2090             let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
2091             let expr5_0 = MInst::AluRmiR {
2092                 size: expr2_0,
2093                 op: expr3_0,
2094                 src1: expr1_0,
2095                 src2: expr4_0,
2096                 dst: expr0_0,
2097             };
2098             let expr6_0 = C::emit(ctx, &expr5_0);
2099             let expr7_0 = C::gpr_to_reg(ctx, expr1_0);
2100             return Some(expr7_0);
2101         }
2102         // Rule at src/isa/x64/inst.isle line 1538.
2103         let expr0_0 = C::temp_writable_gpr(ctx);
2104         let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2105         let expr2_0 = MInst::Imm {
2106             dst_size: expr1_0,
2107             simm64: pattern2_0,
2108             dst: expr0_0,
2109         };
2110         let expr3_0 = C::emit(ctx, &expr2_0);
2111         let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2112         return Some(expr4_0);
2113     }
2114     return None;
2115 }
2116 
2117 // Generated as internal constructor for term imm_i64.
2118 pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Option<Reg> {
2119     let pattern0_0 = arg0;
2120     let pattern1_0 = arg1;
2121     // Rule at src/isa/x64/inst.isle line 1560.
2122     let expr0_0 = C::i64_as_u64(ctx, pattern1_0);
2123     let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
2124     return Some(expr1_0);
2125 }
2126 
2127 // Generated as internal constructor for term shift_r.
2128 pub fn constructor_shift_r<C: Context>(
2129     ctx: &mut C,
2130     arg0: Type,
2131     arg1: &ShiftKind,
2132     arg2: Gpr,
2133     arg3: &Imm8Gpr,
2134 ) -> Option<Gpr> {
2135     let pattern0_0 = arg0;
2136     let pattern1_0 = arg1;
2137     let pattern2_0 = arg2;
2138     let pattern3_0 = arg3;
2139     // Rule at src/isa/x64/inst.isle line 1622.
2140     let expr0_0 = C::temp_writable_gpr(ctx);
2141     let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2142     let expr2_0 = MInst::ShiftR {
2143         size: expr1_0,
2144         kind: pattern1_0.clone(),
2145         src: pattern2_0,
2146         num_bits: pattern3_0.clone(),
2147         dst: expr0_0,
2148     };
2149     let expr3_0 = C::emit(ctx, &expr2_0);
2150     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2151     return Some(expr4_0);
2152 }
2153 
2154 // Generated as internal constructor for term x64_rotl.
2155 pub fn constructor_x64_rotl<C: Context>(
2156     ctx: &mut C,
2157     arg0: Type,
2158     arg1: Gpr,
2159     arg2: &Imm8Gpr,
2160 ) -> Option<Gpr> {
2161     let pattern0_0 = arg0;
2162     let pattern1_0 = arg1;
2163     let pattern2_0 = arg2;
2164     // Rule at src/isa/x64/inst.isle line 1632.
2165     let expr0_0 = ShiftKind::RotateLeft;
2166     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2167     return Some(expr1_0);
2168 }
2169 
2170 // Generated as internal constructor for term x64_rotr.
2171 pub fn constructor_x64_rotr<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 1637.
2181     let expr0_0 = ShiftKind::RotateRight;
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_shl.
2187 pub fn constructor_x64_shl<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 1642.
2197     let expr0_0 = ShiftKind::ShiftLeft;
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_shr.
2203 pub fn constructor_x64_shr<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 1647.
2213     let expr0_0 = ShiftKind::ShiftRightLogical;
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_sar.
2219 pub fn constructor_x64_sar<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 1652.
2229     let expr0_0 = ShiftKind::ShiftRightArithmetic;
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 cmp_rmi_r.
2235 pub fn constructor_cmp_rmi_r<C: Context>(
2236     ctx: &mut C,
2237     arg0: &OperandSize,
2238     arg1: &CmpOpcode,
2239     arg2: &GprMemImm,
2240     arg3: Gpr,
2241 ) -> Option<ProducesFlags> {
2242     let pattern0_0 = arg0;
2243     let pattern1_0 = arg1;
2244     let pattern2_0 = arg2;
2245     let pattern3_0 = arg3;
2246     // Rule at src/isa/x64/inst.isle line 1657.
2247     let expr0_0 = MInst::CmpRmiR {
2248         size: pattern0_0.clone(),
2249         opcode: pattern1_0.clone(),
2250         src: pattern2_0.clone(),
2251         dst: pattern3_0,
2252     };
2253     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2254     return Some(expr1_0);
2255 }
2256 
2257 // Generated as internal constructor for term x64_cmp.
2258 pub fn constructor_x64_cmp<C: Context>(
2259     ctx: &mut C,
2260     arg0: &OperandSize,
2261     arg1: &GprMemImm,
2262     arg2: Gpr,
2263 ) -> Option<ProducesFlags> {
2264     let pattern0_0 = arg0;
2265     let pattern1_0 = arg1;
2266     let pattern2_0 = arg2;
2267     // Rule at src/isa/x64/inst.isle line 1666.
2268     let expr0_0 = CmpOpcode::Cmp;
2269     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2270     return Some(expr1_0);
2271 }
2272 
2273 // Generated as internal constructor for term x64_cmp_imm.
2274 pub fn constructor_x64_cmp_imm<C: Context>(
2275     ctx: &mut C,
2276     arg0: &OperandSize,
2277     arg1: u32,
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 1671.
2284     let expr0_0 = CmpOpcode::Cmp;
2285     let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 };
2286     let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0);
2287     let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?;
2288     return Some(expr3_0);
2289 }
2290 
2291 // Generated as internal constructor for term xmm_cmp_rm_r.
2292 pub fn constructor_xmm_cmp_rm_r<C: Context>(
2293     ctx: &mut C,
2294     arg0: &SseOpcode,
2295     arg1: &XmmMem,
2296     arg2: Xmm,
2297 ) -> Option<ProducesFlags> {
2298     let pattern0_0 = arg0;
2299     let pattern1_0 = arg1;
2300     let pattern2_0 = arg2;
2301     // Rule at src/isa/x64/inst.isle line 1676.
2302     let expr0_0 = MInst::XmmCmpRmR {
2303         op: pattern0_0.clone(),
2304         src: pattern1_0.clone(),
2305         dst: pattern2_0,
2306     };
2307     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2308     return Some(expr1_0);
2309 }
2310 
2311 // Generated as internal constructor for term x64_ucomis.
2312 pub fn constructor_x64_ucomis<C: Context>(
2313     ctx: &mut C,
2314     arg0: Value,
2315     arg1: Value,
2316 ) -> Option<ProducesFlags> {
2317     let pattern0_0 = arg0;
2318     let pattern1_0 = C::value_type(ctx, pattern0_0);
2319     if pattern1_0 == F32 {
2320         let pattern3_0 = arg1;
2321         // Rule at src/isa/x64/inst.isle line 1682.
2322         let expr0_0 = SseOpcode::Ucomiss;
2323         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2324         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2325         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2326         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2327         return Some(expr4_0);
2328     }
2329     if pattern1_0 == F64 {
2330         let pattern3_0 = arg1;
2331         // Rule at src/isa/x64/inst.isle line 1686.
2332         let expr0_0 = SseOpcode::Ucomisd;
2333         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2334         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2335         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2336         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2337         return Some(expr4_0);
2338     }
2339     return None;
2340 }
2341 
2342 // Generated as internal constructor for term x64_test.
2343 pub fn constructor_x64_test<C: Context>(
2344     ctx: &mut C,
2345     arg0: &OperandSize,
2346     arg1: &GprMemImm,
2347     arg2: Gpr,
2348 ) -> Option<ProducesFlags> {
2349     let pattern0_0 = arg0;
2350     let pattern1_0 = arg1;
2351     let pattern2_0 = arg2;
2352     // Rule at src/isa/x64/inst.isle line 1691.
2353     let expr0_0 = CmpOpcode::Test;
2354     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2355     return Some(expr1_0);
2356 }
2357 
2358 // Generated as internal constructor for term cmove.
2359 pub fn constructor_cmove<C: Context>(
2360     ctx: &mut C,
2361     arg0: Type,
2362     arg1: &CC,
2363     arg2: &GprMem,
2364     arg3: Gpr,
2365 ) -> Option<ConsumesFlags> {
2366     let pattern0_0 = arg0;
2367     let pattern1_0 = arg1;
2368     let pattern2_0 = arg2;
2369     let pattern3_0 = arg3;
2370     // Rule at src/isa/x64/inst.isle line 1698.
2371     let expr0_0 = C::temp_writable_gpr(ctx);
2372     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2373     let expr2_0 = MInst::Cmove {
2374         size: expr1_0,
2375         cc: pattern1_0.clone(),
2376         consequent: pattern2_0.clone(),
2377         alternative: pattern3_0,
2378         dst: expr0_0,
2379     };
2380     let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2381     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2382         inst: expr2_0,
2383         result: expr3_0,
2384     };
2385     return Some(expr4_0);
2386 }
2387 
2388 // Generated as internal constructor for term cmove_xmm.
2389 pub fn constructor_cmove_xmm<C: Context>(
2390     ctx: &mut C,
2391     arg0: Type,
2392     arg1: &CC,
2393     arg2: &XmmMem,
2394     arg3: Xmm,
2395 ) -> Option<ConsumesFlags> {
2396     let pattern0_0 = arg0;
2397     let pattern1_0 = arg1;
2398     let pattern2_0 = arg2;
2399     let pattern3_0 = arg3;
2400     // Rule at src/isa/x64/inst.isle line 1706.
2401     let expr0_0 = C::temp_writable_xmm(ctx);
2402     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2403     let expr2_0 = MInst::XmmCmove {
2404         size: expr1_0,
2405         cc: pattern1_0.clone(),
2406         consequent: pattern2_0.clone(),
2407         alternative: pattern3_0,
2408         dst: expr0_0,
2409     };
2410     let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
2411     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2412         inst: expr2_0,
2413         result: expr3_0,
2414     };
2415     return Some(expr4_0);
2416 }
2417 
2418 // Generated as internal constructor for term cmove_from_values.
2419 pub fn constructor_cmove_from_values<C: Context>(
2420     ctx: &mut C,
2421     arg0: Type,
2422     arg1: &CC,
2423     arg2: Value,
2424     arg3: Value,
2425 ) -> Option<ConsumesFlags> {
2426     let pattern0_0 = arg0;
2427     if pattern0_0 == I128 {
2428         let pattern2_0 = arg1;
2429         let pattern3_0 = arg2;
2430         let pattern4_0 = arg3;
2431         // Rule at src/isa/x64/inst.isle line 1717.
2432         let expr0_0 = C::put_in_regs(ctx, pattern3_0);
2433         let expr1_0 = C::put_in_regs(ctx, pattern4_0);
2434         let expr2_0 = C::temp_writable_gpr(ctx);
2435         let expr3_0 = C::temp_writable_gpr(ctx);
2436         let expr4_0 = OperandSize::Size64;
2437         let expr5_0: usize = 0;
2438         let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?;
2439         let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
2440         let expr8_0: usize = 0;
2441         let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?;
2442         let expr10_0 = MInst::Cmove {
2443             size: expr4_0,
2444             cc: pattern2_0.clone(),
2445             consequent: expr7_0,
2446             alternative: expr9_0,
2447             dst: expr2_0,
2448         };
2449         let expr11_0: usize = 1;
2450         let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?;
2451         let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
2452         let expr14_0: usize = 1;
2453         let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?;
2454         let expr16_0 = MInst::Cmove {
2455             size: expr4_0,
2456             cc: pattern2_0.clone(),
2457             consequent: expr13_0,
2458             alternative: expr15_0,
2459             dst: expr3_0,
2460         };
2461         let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2462         let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2463         let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0);
2464         let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2465             inst1: expr10_0,
2466             inst2: expr16_0,
2467             result: expr19_0,
2468         };
2469         return Some(expr20_0);
2470     }
2471     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2472         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2473             let pattern3_0 = arg1;
2474             let pattern4_0 = arg2;
2475             let pattern5_0 = arg3;
2476             // Rule at src/isa/x64/inst.isle line 1741.
2477             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
2478             let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?;
2479             let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2480             return Some(expr2_0);
2481         }
2482     }
2483     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2484         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2485             let pattern3_0 = arg1;
2486             let pattern4_0 = arg2;
2487             let pattern5_0 = arg3;
2488             // Rule at src/isa/x64/inst.isle line 1738.
2489             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
2490             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?;
2491             let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2492             return Some(expr2_0);
2493         }
2494     }
2495     return None;
2496 }
2497 
2498 // Generated as internal constructor for term cmove_or.
2499 pub fn constructor_cmove_or<C: Context>(
2500     ctx: &mut C,
2501     arg0: Type,
2502     arg1: &CC,
2503     arg2: &CC,
2504     arg3: &GprMem,
2505     arg4: Gpr,
2506 ) -> Option<ConsumesFlags> {
2507     let pattern0_0 = arg0;
2508     let pattern1_0 = arg1;
2509     let pattern2_0 = arg2;
2510     let pattern3_0 = arg3;
2511     let pattern4_0 = arg4;
2512     // Rule at src/isa/x64/inst.isle line 1748.
2513     let expr0_0 = C::temp_writable_gpr(ctx);
2514     let expr1_0 = C::temp_writable_gpr(ctx);
2515     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2516     let expr3_0 = MInst::Cmove {
2517         size: expr2_0,
2518         cc: pattern1_0.clone(),
2519         consequent: pattern3_0.clone(),
2520         alternative: pattern4_0,
2521         dst: expr1_0,
2522     };
2523     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
2524     let expr5_0 = MInst::Cmove {
2525         size: expr2_0,
2526         cc: pattern2_0.clone(),
2527         consequent: pattern3_0.clone(),
2528         alternative: expr4_0,
2529         dst: expr0_0,
2530     };
2531     let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?;
2532     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2533         inst1: expr3_0,
2534         inst2: expr5_0,
2535         result: expr6_0,
2536     };
2537     return Some(expr7_0);
2538 }
2539 
2540 // Generated as internal constructor for term cmove_or_xmm.
2541 pub fn constructor_cmove_or_xmm<C: Context>(
2542     ctx: &mut C,
2543     arg0: Type,
2544     arg1: &CC,
2545     arg2: &CC,
2546     arg3: &XmmMem,
2547     arg4: Xmm,
2548 ) -> Option<ConsumesFlags> {
2549     let pattern0_0 = arg0;
2550     let pattern1_0 = arg1;
2551     let pattern2_0 = arg2;
2552     let pattern3_0 = arg3;
2553     let pattern4_0 = arg4;
2554     // Rule at src/isa/x64/inst.isle line 1760.
2555     let expr0_0 = C::temp_writable_xmm(ctx);
2556     let expr1_0 = C::temp_writable_xmm(ctx);
2557     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2558     let expr3_0 = MInst::XmmCmove {
2559         size: expr2_0,
2560         cc: pattern1_0.clone(),
2561         consequent: pattern3_0.clone(),
2562         alternative: pattern4_0,
2563         dst: expr1_0,
2564     };
2565     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0);
2566     let expr5_0 = MInst::XmmCmove {
2567         size: expr2_0,
2568         cc: pattern2_0.clone(),
2569         consequent: pattern3_0.clone(),
2570         alternative: expr4_0,
2571         dst: expr0_0,
2572     };
2573     let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?;
2574     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2575         inst1: expr3_0,
2576         inst2: expr5_0,
2577         result: expr6_0,
2578     };
2579     return Some(expr7_0);
2580 }
2581 
2582 // Generated as internal constructor for term cmove_or_from_values.
2583 pub fn constructor_cmove_or_from_values<C: Context>(
2584     ctx: &mut C,
2585     arg0: Type,
2586     arg1: &CC,
2587     arg2: &CC,
2588     arg3: Value,
2589     arg4: Value,
2590 ) -> Option<ConsumesFlags> {
2591     let pattern0_0 = arg0;
2592     if pattern0_0 == I128 {
2593         let pattern2_0 = arg1;
2594         let pattern3_0 = arg2;
2595         let pattern4_0 = arg3;
2596         let pattern5_0 = arg4;
2597         // Rule at src/isa/x64/inst.isle line 1775.
2598         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
2599         let expr1_0 = C::put_in_regs(ctx, pattern5_0);
2600         let expr2_0 = C::temp_writable_gpr(ctx);
2601         let expr3_0 = C::temp_writable_gpr(ctx);
2602         let expr4_0 = C::temp_writable_gpr(ctx);
2603         let expr5_0 = C::temp_writable_gpr(ctx);
2604         let expr6_0 = OperandSize::Size64;
2605         let expr7_0: usize = 0;
2606         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?;
2607         let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0);
2608         let expr10_0: usize = 0;
2609         let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?;
2610         let expr12_0 = MInst::Cmove {
2611             size: expr6_0,
2612             cc: pattern2_0.clone(),
2613             consequent: expr9_0,
2614             alternative: expr11_0,
2615             dst: expr4_0,
2616         };
2617         let expr13_0: usize = 0;
2618         let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?;
2619         let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0);
2620         let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0);
2621         let expr17_0 = MInst::Cmove {
2622             size: expr6_0,
2623             cc: pattern3_0.clone(),
2624             consequent: expr15_0,
2625             alternative: expr16_0,
2626             dst: expr2_0,
2627         };
2628         let expr18_0: usize = 1;
2629         let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?;
2630         let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0);
2631         let expr21_0: usize = 1;
2632         let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?;
2633         let expr23_0 = MInst::Cmove {
2634             size: expr6_0,
2635             cc: pattern2_0.clone(),
2636             consequent: expr20_0,
2637             alternative: expr22_0,
2638             dst: expr5_0,
2639         };
2640         let expr24_0: usize = 1;
2641         let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?;
2642         let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0);
2643         let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0);
2644         let expr28_0 = MInst::Cmove {
2645             size: expr6_0,
2646             cc: pattern3_0.clone(),
2647             consequent: expr26_0,
2648             alternative: expr27_0,
2649             dst: expr3_0,
2650         };
2651         let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2652         let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2653         let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0);
2654         let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
2655             inst1: expr12_0,
2656             inst2: expr17_0,
2657             inst3: expr23_0,
2658             inst4: expr28_0,
2659             result: expr31_0,
2660         };
2661         return Some(expr32_0);
2662     }
2663     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2664         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2665             let pattern3_0 = arg1;
2666             let pattern4_0 = arg2;
2667             let pattern5_0 = arg3;
2668             let pattern6_0 = arg4;
2669             // Rule at src/isa/x64/inst.isle line 1797.
2670             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?;
2671             let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?;
2672             let expr2_0 = constructor_cmove_or_xmm(
2673                 ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0,
2674             )?;
2675             return Some(expr2_0);
2676         }
2677     }
2678     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2679         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2680             let pattern3_0 = arg1;
2681             let pattern4_0 = arg2;
2682             let pattern5_0 = arg3;
2683             let pattern6_0 = arg4;
2684             // Rule at src/isa/x64/inst.isle line 1794.
2685             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?;
2686             let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
2687             let expr2_0 =
2688                 constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?;
2689             return Some(expr2_0);
2690         }
2691     }
2692     return None;
2693 }
2694 
2695 // Generated as internal constructor for term x64_setcc.
2696 pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> Option<ConsumesFlags> {
2697     let pattern0_0 = arg0;
2698     // Rule at src/isa/x64/inst.isle line 1802.
2699     let expr0_0 = C::temp_writable_gpr(ctx);
2700     let expr1_0 = MInst::Setcc {
2701         cc: pattern0_0.clone(),
2702         dst: expr0_0,
2703     };
2704     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2705     let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2706         inst: expr1_0,
2707         result: expr2_0,
2708     };
2709     return Some(expr3_0);
2710 }
2711 
2712 // Generated as internal constructor for term xmm_rm_r.
2713 pub fn constructor_xmm_rm_r<C: Context>(
2714     ctx: &mut C,
2715     arg0: Type,
2716     arg1: &SseOpcode,
2717     arg2: Xmm,
2718     arg3: &XmmMem,
2719 ) -> Option<Xmm> {
2720     let pattern0_0 = arg0;
2721     let pattern1_0 = arg1;
2722     let pattern2_0 = arg2;
2723     let pattern3_0 = arg3;
2724     // Rule at src/isa/x64/inst.isle line 1810.
2725     let expr0_0 = C::temp_writable_xmm(ctx);
2726     let expr1_0 = MInst::XmmRmR {
2727         op: pattern1_0.clone(),
2728         src1: pattern2_0,
2729         src2: pattern3_0.clone(),
2730         dst: expr0_0,
2731     };
2732     let expr2_0 = C::emit(ctx, &expr1_0);
2733     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2734     return Some(expr3_0);
2735 }
2736 
2737 // Generated as internal constructor for term x64_paddb.
2738 pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2739     let pattern0_0 = arg0;
2740     let pattern1_0 = arg1;
2741     // Rule at src/isa/x64/inst.isle line 1817.
2742     let expr0_0: Type = I8X16;
2743     let expr1_0 = SseOpcode::Paddb;
2744     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2745     return Some(expr2_0);
2746 }
2747 
2748 // Generated as internal constructor for term x64_paddw.
2749 pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2750     let pattern0_0 = arg0;
2751     let pattern1_0 = arg1;
2752     // Rule at src/isa/x64/inst.isle line 1822.
2753     let expr0_0: Type = I16X8;
2754     let expr1_0 = SseOpcode::Paddw;
2755     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2756     return Some(expr2_0);
2757 }
2758 
2759 // Generated as internal constructor for term x64_paddd.
2760 pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2761     let pattern0_0 = arg0;
2762     let pattern1_0 = arg1;
2763     // Rule at src/isa/x64/inst.isle line 1827.
2764     let expr0_0: Type = I32X4;
2765     let expr1_0 = SseOpcode::Paddd;
2766     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2767     return Some(expr2_0);
2768 }
2769 
2770 // Generated as internal constructor for term x64_paddq.
2771 pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2772     let pattern0_0 = arg0;
2773     let pattern1_0 = arg1;
2774     // Rule at src/isa/x64/inst.isle line 1832.
2775     let expr0_0: Type = I64X2;
2776     let expr1_0 = SseOpcode::Paddq;
2777     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2778     return Some(expr2_0);
2779 }
2780 
2781 // Generated as internal constructor for term x64_paddsb.
2782 pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2783     let pattern0_0 = arg0;
2784     let pattern1_0 = arg1;
2785     // Rule at src/isa/x64/inst.isle line 1837.
2786     let expr0_0: Type = I8X16;
2787     let expr1_0 = SseOpcode::Paddsb;
2788     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2789     return Some(expr2_0);
2790 }
2791 
2792 // Generated as internal constructor for term x64_paddsw.
2793 pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2794     let pattern0_0 = arg0;
2795     let pattern1_0 = arg1;
2796     // Rule at src/isa/x64/inst.isle line 1842.
2797     let expr0_0: Type = I16X8;
2798     let expr1_0 = SseOpcode::Paddsw;
2799     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2800     return Some(expr2_0);
2801 }
2802 
2803 // Generated as internal constructor for term x64_paddusb.
2804 pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2805     let pattern0_0 = arg0;
2806     let pattern1_0 = arg1;
2807     // Rule at src/isa/x64/inst.isle line 1847.
2808     let expr0_0: Type = I8X16;
2809     let expr1_0 = SseOpcode::Paddusb;
2810     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2811     return Some(expr2_0);
2812 }
2813 
2814 // Generated as internal constructor for term x64_paddusw.
2815 pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2816     let pattern0_0 = arg0;
2817     let pattern1_0 = arg1;
2818     // Rule at src/isa/x64/inst.isle line 1852.
2819     let expr0_0: Type = I16X8;
2820     let expr1_0 = SseOpcode::Paddusw;
2821     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2822     return Some(expr2_0);
2823 }
2824 
2825 // Generated as internal constructor for term x64_psubb.
2826 pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2827     let pattern0_0 = arg0;
2828     let pattern1_0 = arg1;
2829     // Rule at src/isa/x64/inst.isle line 1857.
2830     let expr0_0: Type = I8X16;
2831     let expr1_0 = SseOpcode::Psubb;
2832     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2833     return Some(expr2_0);
2834 }
2835 
2836 // Generated as internal constructor for term x64_psubw.
2837 pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2838     let pattern0_0 = arg0;
2839     let pattern1_0 = arg1;
2840     // Rule at src/isa/x64/inst.isle line 1862.
2841     let expr0_0: Type = I16X8;
2842     let expr1_0 = SseOpcode::Psubw;
2843     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2844     return Some(expr2_0);
2845 }
2846 
2847 // Generated as internal constructor for term x64_psubd.
2848 pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2849     let pattern0_0 = arg0;
2850     let pattern1_0 = arg1;
2851     // Rule at src/isa/x64/inst.isle line 1867.
2852     let expr0_0: Type = I32X4;
2853     let expr1_0 = SseOpcode::Psubd;
2854     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2855     return Some(expr2_0);
2856 }
2857 
2858 // Generated as internal constructor for term x64_psubq.
2859 pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2860     let pattern0_0 = arg0;
2861     let pattern1_0 = arg1;
2862     // Rule at src/isa/x64/inst.isle line 1872.
2863     let expr0_0: Type = I64X2;
2864     let expr1_0 = SseOpcode::Psubq;
2865     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2866     return Some(expr2_0);
2867 }
2868 
2869 // Generated as internal constructor for term x64_psubsb.
2870 pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2871     let pattern0_0 = arg0;
2872     let pattern1_0 = arg1;
2873     // Rule at src/isa/x64/inst.isle line 1877.
2874     let expr0_0: Type = I8X16;
2875     let expr1_0 = SseOpcode::Psubsb;
2876     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2877     return Some(expr2_0);
2878 }
2879 
2880 // Generated as internal constructor for term x64_psubsw.
2881 pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2882     let pattern0_0 = arg0;
2883     let pattern1_0 = arg1;
2884     // Rule at src/isa/x64/inst.isle line 1882.
2885     let expr0_0: Type = I16X8;
2886     let expr1_0 = SseOpcode::Psubsw;
2887     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2888     return Some(expr2_0);
2889 }
2890 
2891 // Generated as internal constructor for term x64_psubusb.
2892 pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2893     let pattern0_0 = arg0;
2894     let pattern1_0 = arg1;
2895     // Rule at src/isa/x64/inst.isle line 1887.
2896     let expr0_0: Type = I8X16;
2897     let expr1_0 = SseOpcode::Psubusb;
2898     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2899     return Some(expr2_0);
2900 }
2901 
2902 // Generated as internal constructor for term x64_psubusw.
2903 pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2904     let pattern0_0 = arg0;
2905     let pattern1_0 = arg1;
2906     // Rule at src/isa/x64/inst.isle line 1892.
2907     let expr0_0: Type = I16X8;
2908     let expr1_0 = SseOpcode::Psubusw;
2909     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2910     return Some(expr2_0);
2911 }
2912 
2913 // Generated as internal constructor for term x64_pavgb.
2914 pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2915     let pattern0_0 = arg0;
2916     let pattern1_0 = arg1;
2917     // Rule at src/isa/x64/inst.isle line 1897.
2918     let expr0_0: Type = I8X16;
2919     let expr1_0 = SseOpcode::Pavgb;
2920     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2921     return Some(expr2_0);
2922 }
2923 
2924 // Generated as internal constructor for term x64_pavgw.
2925 pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2926     let pattern0_0 = arg0;
2927     let pattern1_0 = arg1;
2928     // Rule at src/isa/x64/inst.isle line 1902.
2929     let expr0_0: Type = I16X8;
2930     let expr1_0 = SseOpcode::Pavgw;
2931     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2932     return Some(expr2_0);
2933 }
2934 
2935 // Generated as internal constructor for term x64_pand.
2936 pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2937     let pattern0_0 = arg0;
2938     let pattern1_0 = arg1;
2939     // Rule at src/isa/x64/inst.isle line 1907.
2940     let expr0_0: Type = F32X4;
2941     let expr1_0 = SseOpcode::Pand;
2942     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2943     return Some(expr2_0);
2944 }
2945 
2946 // Generated as internal constructor for term x64_andps.
2947 pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2948     let pattern0_0 = arg0;
2949     let pattern1_0 = arg1;
2950     // Rule at src/isa/x64/inst.isle line 1912.
2951     let expr0_0: Type = F32X4;
2952     let expr1_0 = SseOpcode::Andps;
2953     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2954     return Some(expr2_0);
2955 }
2956 
2957 // Generated as internal constructor for term x64_andpd.
2958 pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2959     let pattern0_0 = arg0;
2960     let pattern1_0 = arg1;
2961     // Rule at src/isa/x64/inst.isle line 1917.
2962     let expr0_0: Type = F64X2;
2963     let expr1_0 = SseOpcode::Andpd;
2964     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2965     return Some(expr2_0);
2966 }
2967 
2968 // Generated as internal constructor for term x64_por.
2969 pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2970     let pattern0_0 = arg0;
2971     let pattern1_0 = arg1;
2972     // Rule at src/isa/x64/inst.isle line 1922.
2973     let expr0_0: Type = F32X4;
2974     let expr1_0 = SseOpcode::Por;
2975     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2976     return Some(expr2_0);
2977 }
2978 
2979 // Generated as internal constructor for term x64_orps.
2980 pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2981     let pattern0_0 = arg0;
2982     let pattern1_0 = arg1;
2983     // Rule at src/isa/x64/inst.isle line 1927.
2984     let expr0_0: Type = F32X4;
2985     let expr1_0 = SseOpcode::Orps;
2986     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2987     return Some(expr2_0);
2988 }
2989 
2990 // Generated as internal constructor for term x64_orpd.
2991 pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
2992     let pattern0_0 = arg0;
2993     let pattern1_0 = arg1;
2994     // Rule at src/isa/x64/inst.isle line 1932.
2995     let expr0_0: Type = F64X2;
2996     let expr1_0 = SseOpcode::Orpd;
2997     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
2998     return Some(expr2_0);
2999 }
3000 
3001 // Generated as internal constructor for term x64_pxor.
3002 pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3003     let pattern0_0 = arg0;
3004     let pattern1_0 = arg1;
3005     // Rule at src/isa/x64/inst.isle line 1937.
3006     let expr0_0: Type = I8X16;
3007     let expr1_0 = SseOpcode::Pxor;
3008     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3009     return Some(expr2_0);
3010 }
3011 
3012 // Generated as internal constructor for term x64_xorps.
3013 pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3014     let pattern0_0 = arg0;
3015     let pattern1_0 = arg1;
3016     // Rule at src/isa/x64/inst.isle line 1942.
3017     let expr0_0: Type = F32X4;
3018     let expr1_0 = SseOpcode::Xorps;
3019     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3020     return Some(expr2_0);
3021 }
3022 
3023 // Generated as internal constructor for term x64_xorpd.
3024 pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3025     let pattern0_0 = arg0;
3026     let pattern1_0 = arg1;
3027     // Rule at src/isa/x64/inst.isle line 1947.
3028     let expr0_0: Type = F64X2;
3029     let expr1_0 = SseOpcode::Xorpd;
3030     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3031     return Some(expr2_0);
3032 }
3033 
3034 // Generated as internal constructor for term x64_pmullw.
3035 pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3036     let pattern0_0 = arg0;
3037     let pattern1_0 = arg1;
3038     // Rule at src/isa/x64/inst.isle line 1952.
3039     let expr0_0: Type = I16X8;
3040     let expr1_0 = SseOpcode::Pmullw;
3041     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3042     return Some(expr2_0);
3043 }
3044 
3045 // Generated as internal constructor for term x64_pmulld.
3046 pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3047     let pattern0_0 = arg0;
3048     let pattern1_0 = arg1;
3049     // Rule at src/isa/x64/inst.isle line 1957.
3050     let expr0_0: Type = I16X8;
3051     let expr1_0 = SseOpcode::Pmulld;
3052     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3053     return Some(expr2_0);
3054 }
3055 
3056 // Generated as internal constructor for term x64_pmulhw.
3057 pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3058     let pattern0_0 = arg0;
3059     let pattern1_0 = arg1;
3060     // Rule at src/isa/x64/inst.isle line 1962.
3061     let expr0_0: Type = I16X8;
3062     let expr1_0 = SseOpcode::Pmulhw;
3063     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3064     return Some(expr2_0);
3065 }
3066 
3067 // Generated as internal constructor for term x64_pmulhuw.
3068 pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3069     let pattern0_0 = arg0;
3070     let pattern1_0 = arg1;
3071     // Rule at src/isa/x64/inst.isle line 1967.
3072     let expr0_0: Type = I16X8;
3073     let expr1_0 = SseOpcode::Pmulhuw;
3074     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3075     return Some(expr2_0);
3076 }
3077 
3078 // Generated as internal constructor for term x64_pmuldq.
3079 pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3080     let pattern0_0 = arg0;
3081     let pattern1_0 = arg1;
3082     // Rule at src/isa/x64/inst.isle line 1972.
3083     let expr0_0: Type = I16X8;
3084     let expr1_0 = SseOpcode::Pmuldq;
3085     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3086     return Some(expr2_0);
3087 }
3088 
3089 // Generated as internal constructor for term x64_pmuludq.
3090 pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3091     let pattern0_0 = arg0;
3092     let pattern1_0 = arg1;
3093     // Rule at src/isa/x64/inst.isle line 1977.
3094     let expr0_0: Type = I64X2;
3095     let expr1_0 = SseOpcode::Pmuludq;
3096     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3097     return Some(expr2_0);
3098 }
3099 
3100 // Generated as internal constructor for term x64_punpckhwd.
3101 pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3102     let pattern0_0 = arg0;
3103     let pattern1_0 = arg1;
3104     // Rule at src/isa/x64/inst.isle line 1982.
3105     let expr0_0: Type = I16X8;
3106     let expr1_0 = SseOpcode::Punpckhwd;
3107     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3108     return Some(expr2_0);
3109 }
3110 
3111 // Generated as internal constructor for term x64_punpcklwd.
3112 pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3113     let pattern0_0 = arg0;
3114     let pattern1_0 = arg1;
3115     // Rule at src/isa/x64/inst.isle line 1987.
3116     let expr0_0: Type = I16X8;
3117     let expr1_0 = SseOpcode::Punpcklwd;
3118     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3119     return Some(expr2_0);
3120 }
3121 
3122 // Generated as internal constructor for term x64_andnps.
3123 pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3124     let pattern0_0 = arg0;
3125     let pattern1_0 = arg1;
3126     // Rule at src/isa/x64/inst.isle line 1992.
3127     let expr0_0: Type = F32X4;
3128     let expr1_0 = SseOpcode::Andnps;
3129     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3130     return Some(expr2_0);
3131 }
3132 
3133 // Generated as internal constructor for term x64_andnpd.
3134 pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3135     let pattern0_0 = arg0;
3136     let pattern1_0 = arg1;
3137     // Rule at src/isa/x64/inst.isle line 1997.
3138     let expr0_0: Type = F64X2;
3139     let expr1_0 = SseOpcode::Andnpd;
3140     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3141     return Some(expr2_0);
3142 }
3143 
3144 // Generated as internal constructor for term x64_pandn.
3145 pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3146     let pattern0_0 = arg0;
3147     let pattern1_0 = arg1;
3148     // Rule at src/isa/x64/inst.isle line 2002.
3149     let expr0_0: Type = F64X2;
3150     let expr1_0 = SseOpcode::Pandn;
3151     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3152     return Some(expr2_0);
3153 }
3154 
3155 // Generated as internal constructor for term x64_addss.
3156 pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3157     let pattern0_0 = arg0;
3158     let pattern1_0 = arg1;
3159     // Rule at src/isa/x64/inst.isle line 2007.
3160     let expr0_0: Type = F32;
3161     let expr1_0 = SseOpcode::Addss;
3162     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3163     return Some(expr2_0);
3164 }
3165 
3166 // Generated as internal constructor for term x64_addsd.
3167 pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3168     let pattern0_0 = arg0;
3169     let pattern1_0 = arg1;
3170     // Rule at src/isa/x64/inst.isle line 2012.
3171     let expr0_0: Type = F64;
3172     let expr1_0 = SseOpcode::Addsd;
3173     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3174     return Some(expr2_0);
3175 }
3176 
3177 // Generated as internal constructor for term x64_addps.
3178 pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3179     let pattern0_0 = arg0;
3180     let pattern1_0 = arg1;
3181     // Rule at src/isa/x64/inst.isle line 2017.
3182     let expr0_0: Type = F32;
3183     let expr1_0 = SseOpcode::Addps;
3184     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3185     return Some(expr2_0);
3186 }
3187 
3188 // Generated as internal constructor for term x64_addpd.
3189 pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3190     let pattern0_0 = arg0;
3191     let pattern1_0 = arg1;
3192     // Rule at src/isa/x64/inst.isle line 2022.
3193     let expr0_0: Type = F32;
3194     let expr1_0 = SseOpcode::Addpd;
3195     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3196     return Some(expr2_0);
3197 }
3198 
3199 // Generated as internal constructor for term x64_subss.
3200 pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3201     let pattern0_0 = arg0;
3202     let pattern1_0 = arg1;
3203     // Rule at src/isa/x64/inst.isle line 2027.
3204     let expr0_0: Type = F32;
3205     let expr1_0 = SseOpcode::Subss;
3206     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3207     return Some(expr2_0);
3208 }
3209 
3210 // Generated as internal constructor for term x64_subsd.
3211 pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3212     let pattern0_0 = arg0;
3213     let pattern1_0 = arg1;
3214     // Rule at src/isa/x64/inst.isle line 2032.
3215     let expr0_0: Type = F64;
3216     let expr1_0 = SseOpcode::Subsd;
3217     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3218     return Some(expr2_0);
3219 }
3220 
3221 // Generated as internal constructor for term x64_subps.
3222 pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3223     let pattern0_0 = arg0;
3224     let pattern1_0 = arg1;
3225     // Rule at src/isa/x64/inst.isle line 2037.
3226     let expr0_0: Type = F32;
3227     let expr1_0 = SseOpcode::Subps;
3228     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3229     return Some(expr2_0);
3230 }
3231 
3232 // Generated as internal constructor for term x64_subpd.
3233 pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3234     let pattern0_0 = arg0;
3235     let pattern1_0 = arg1;
3236     // Rule at src/isa/x64/inst.isle line 2042.
3237     let expr0_0: Type = F32;
3238     let expr1_0 = SseOpcode::Subpd;
3239     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3240     return Some(expr2_0);
3241 }
3242 
3243 // Generated as internal constructor for term x64_mulss.
3244 pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3245     let pattern0_0 = arg0;
3246     let pattern1_0 = arg1;
3247     // Rule at src/isa/x64/inst.isle line 2047.
3248     let expr0_0: Type = F32;
3249     let expr1_0 = SseOpcode::Mulss;
3250     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3251     return Some(expr2_0);
3252 }
3253 
3254 // Generated as internal constructor for term x64_mulsd.
3255 pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3256     let pattern0_0 = arg0;
3257     let pattern1_0 = arg1;
3258     // Rule at src/isa/x64/inst.isle line 2052.
3259     let expr0_0: Type = F64;
3260     let expr1_0 = SseOpcode::Mulsd;
3261     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3262     return Some(expr2_0);
3263 }
3264 
3265 // Generated as internal constructor for term x64_mulps.
3266 pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3267     let pattern0_0 = arg0;
3268     let pattern1_0 = arg1;
3269     // Rule at src/isa/x64/inst.isle line 2057.
3270     let expr0_0: Type = F32;
3271     let expr1_0 = SseOpcode::Mulps;
3272     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3273     return Some(expr2_0);
3274 }
3275 
3276 // Generated as internal constructor for term x64_mulpd.
3277 pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3278     let pattern0_0 = arg0;
3279     let pattern1_0 = arg1;
3280     // Rule at src/isa/x64/inst.isle line 2062.
3281     let expr0_0: Type = F32;
3282     let expr1_0 = SseOpcode::Mulpd;
3283     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3284     return Some(expr2_0);
3285 }
3286 
3287 // Generated as internal constructor for term x64_divss.
3288 pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3289     let pattern0_0 = arg0;
3290     let pattern1_0 = arg1;
3291     // Rule at src/isa/x64/inst.isle line 2067.
3292     let expr0_0: Type = F32;
3293     let expr1_0 = SseOpcode::Divss;
3294     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3295     return Some(expr2_0);
3296 }
3297 
3298 // Generated as internal constructor for term x64_divsd.
3299 pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3300     let pattern0_0 = arg0;
3301     let pattern1_0 = arg1;
3302     // Rule at src/isa/x64/inst.isle line 2072.
3303     let expr0_0: Type = F64;
3304     let expr1_0 = SseOpcode::Divsd;
3305     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3306     return Some(expr2_0);
3307 }
3308 
3309 // Generated as internal constructor for term x64_divps.
3310 pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3311     let pattern0_0 = arg0;
3312     let pattern1_0 = arg1;
3313     // Rule at src/isa/x64/inst.isle line 2077.
3314     let expr0_0: Type = F32;
3315     let expr1_0 = SseOpcode::Divps;
3316     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3317     return Some(expr2_0);
3318 }
3319 
3320 // Generated as internal constructor for term x64_divpd.
3321 pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3322     let pattern0_0 = arg0;
3323     let pattern1_0 = arg1;
3324     // Rule at src/isa/x64/inst.isle line 2082.
3325     let expr0_0: Type = F32;
3326     let expr1_0 = SseOpcode::Divpd;
3327     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3328     return Some(expr2_0);
3329 }
3330 
3331 // Generated as internal constructor for term sse_blend_op.
3332 pub fn constructor_sse_blend_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3333     let pattern0_0 = arg0;
3334     if pattern0_0 == F32X4 {
3335         // Rule at src/isa/x64/inst.isle line 2086.
3336         let expr0_0 = SseOpcode::Blendvps;
3337         return Some(expr0_0);
3338     }
3339     if pattern0_0 == F64X2 {
3340         // Rule at src/isa/x64/inst.isle line 2087.
3341         let expr0_0 = SseOpcode::Blendvpd;
3342         return Some(expr0_0);
3343     }
3344     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3345         // Rule at src/isa/x64/inst.isle line 2088.
3346         let expr0_0 = SseOpcode::Pblendvb;
3347         return Some(expr0_0);
3348     }
3349     return None;
3350 }
3351 
3352 // Generated as internal constructor for term sse_mov_op.
3353 pub fn constructor_sse_mov_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3354     let pattern0_0 = arg0;
3355     if pattern0_0 == F32X4 {
3356         // Rule at src/isa/x64/inst.isle line 2091.
3357         let expr0_0 = SseOpcode::Movaps;
3358         return Some(expr0_0);
3359     }
3360     if pattern0_0 == F64X2 {
3361         // Rule at src/isa/x64/inst.isle line 2092.
3362         let expr0_0 = SseOpcode::Movapd;
3363         return Some(expr0_0);
3364     }
3365     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3366         // Rule at src/isa/x64/inst.isle line 2093.
3367         let expr0_0 = SseOpcode::Movdqa;
3368         return Some(expr0_0);
3369     }
3370     return None;
3371 }
3372 
3373 // Generated as internal constructor for term x64_blend.
3374 pub fn constructor_x64_blend<C: Context>(
3375     ctx: &mut C,
3376     arg0: Type,
3377     arg1: &XmmMem,
3378     arg2: &XmmMem,
3379     arg3: Xmm,
3380 ) -> Option<Xmm> {
3381     let pattern0_0 = arg0;
3382     let pattern1_0 = arg1;
3383     let pattern2_0 = arg2;
3384     let pattern3_0 = arg3;
3385     // Rule at src/isa/x64/inst.isle line 2097.
3386     let expr0_0 = C::xmm0(ctx);
3387     let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?;
3388     let expr2_0 = MInst::XmmUnaryRmR {
3389         op: expr1_0,
3390         src: pattern1_0.clone(),
3391         dst: expr0_0,
3392     };
3393     let expr3_0 = C::emit(ctx, &expr2_0);
3394     let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?;
3395     let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?;
3396     return Some(expr5_0);
3397 }
3398 
3399 // Generated as internal constructor for term x64_blendvpd.
3400 pub fn constructor_x64_blendvpd<C: Context>(
3401     ctx: &mut C,
3402     arg0: Xmm,
3403     arg1: &XmmMem,
3404     arg2: Xmm,
3405 ) -> Option<Xmm> {
3406     let pattern0_0 = arg0;
3407     let pattern1_0 = arg1;
3408     let pattern2_0 = arg2;
3409     // Rule at src/isa/x64/inst.isle line 2111.
3410     let expr0_0 = C::xmm0(ctx);
3411     let expr1_0 = SseOpcode::Movapd;
3412     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0);
3413     let expr3_0 = MInst::XmmUnaryRmR {
3414         op: expr1_0,
3415         src: expr2_0,
3416         dst: expr0_0,
3417     };
3418     let expr4_0 = C::emit(ctx, &expr3_0);
3419     let expr5_0: Type = F64X2;
3420     let expr6_0 = SseOpcode::Blendvpd;
3421     let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?;
3422     return Some(expr7_0);
3423 }
3424 
3425 // Generated as internal constructor for term x64_movsd_regmove.
3426 pub fn constructor_x64_movsd_regmove<C: Context>(
3427     ctx: &mut C,
3428     arg0: Xmm,
3429     arg1: &XmmMem,
3430 ) -> Option<Xmm> {
3431     let pattern0_0 = arg0;
3432     let pattern1_0 = arg1;
3433     // Rule at src/isa/x64/inst.isle line 2125.
3434     let expr0_0: Type = I8X16;
3435     let expr1_0 = SseOpcode::Movsd;
3436     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3437     return Some(expr2_0);
3438 }
3439 
3440 // Generated as internal constructor for term x64_movlhps.
3441 pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3442     let pattern0_0 = arg0;
3443     let pattern1_0 = arg1;
3444     // Rule at src/isa/x64/inst.isle line 2130.
3445     let expr0_0: Type = I8X16;
3446     let expr1_0 = SseOpcode::Movlhps;
3447     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3448     return Some(expr2_0);
3449 }
3450 
3451 // Generated as internal constructor for term x64_pmaxs.
3452 pub fn constructor_x64_pmaxs<C: Context>(
3453     ctx: &mut C,
3454     arg0: Type,
3455     arg1: Xmm,
3456     arg2: &XmmMem,
3457 ) -> Option<Xmm> {
3458     let pattern0_0 = arg0;
3459     if pattern0_0 == I8X16 {
3460         let pattern2_0 = arg1;
3461         let pattern3_0 = arg2;
3462         // Rule at src/isa/x64/inst.isle line 2135.
3463         let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?;
3464         return Some(expr0_0);
3465     }
3466     if pattern0_0 == I16X8 {
3467         let pattern2_0 = arg1;
3468         let pattern3_0 = arg2;
3469         // Rule at src/isa/x64/inst.isle line 2136.
3470         let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?;
3471         return Some(expr0_0);
3472     }
3473     if pattern0_0 == I32X4 {
3474         let pattern2_0 = arg1;
3475         let pattern3_0 = arg2;
3476         // Rule at src/isa/x64/inst.isle line 2137.
3477         let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?;
3478         return Some(expr0_0);
3479     }
3480     return None;
3481 }
3482 
3483 // Generated as internal constructor for term x64_pmaxsb.
3484 pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3485     let pattern0_0 = arg0;
3486     let pattern1_0 = arg1;
3487     // Rule at src/isa/x64/inst.isle line 2140.
3488     let expr0_0: Type = I8X16;
3489     let expr1_0 = SseOpcode::Pmaxsb;
3490     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3491     return Some(expr2_0);
3492 }
3493 
3494 // Generated as internal constructor for term x64_pmaxsw.
3495 pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3496     let pattern0_0 = arg0;
3497     let pattern1_0 = arg1;
3498     // Rule at src/isa/x64/inst.isle line 2142.
3499     let expr0_0: Type = I8X16;
3500     let expr1_0 = SseOpcode::Pmaxsw;
3501     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3502     return Some(expr2_0);
3503 }
3504 
3505 // Generated as internal constructor for term x64_pmaxsd.
3506 pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3507     let pattern0_0 = arg0;
3508     let pattern1_0 = arg1;
3509     // Rule at src/isa/x64/inst.isle line 2144.
3510     let expr0_0: Type = I8X16;
3511     let expr1_0 = SseOpcode::Pmaxsd;
3512     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3513     return Some(expr2_0);
3514 }
3515 
3516 // Generated as internal constructor for term x64_pmins.
3517 pub fn constructor_x64_pmins<C: Context>(
3518     ctx: &mut C,
3519     arg0: Type,
3520     arg1: Xmm,
3521     arg2: &XmmMem,
3522 ) -> Option<Xmm> {
3523     let pattern0_0 = arg0;
3524     if pattern0_0 == I8X16 {
3525         let pattern2_0 = arg1;
3526         let pattern3_0 = arg2;
3527         // Rule at src/isa/x64/inst.isle line 2148.
3528         let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?;
3529         return Some(expr0_0);
3530     }
3531     if pattern0_0 == I16X8 {
3532         let pattern2_0 = arg1;
3533         let pattern3_0 = arg2;
3534         // Rule at src/isa/x64/inst.isle line 2149.
3535         let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?;
3536         return Some(expr0_0);
3537     }
3538     if pattern0_0 == I32X4 {
3539         let pattern2_0 = arg1;
3540         let pattern3_0 = arg2;
3541         // Rule at src/isa/x64/inst.isle line 2150.
3542         let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?;
3543         return Some(expr0_0);
3544     }
3545     return None;
3546 }
3547 
3548 // Generated as internal constructor for term x64_pminsb.
3549 pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3550     let pattern0_0 = arg0;
3551     let pattern1_0 = arg1;
3552     // Rule at src/isa/x64/inst.isle line 2153.
3553     let expr0_0: Type = I8X16;
3554     let expr1_0 = SseOpcode::Pminsb;
3555     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3556     return Some(expr2_0);
3557 }
3558 
3559 // Generated as internal constructor for term x64_pminsw.
3560 pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3561     let pattern0_0 = arg0;
3562     let pattern1_0 = arg1;
3563     // Rule at src/isa/x64/inst.isle line 2155.
3564     let expr0_0: Type = I16X8;
3565     let expr1_0 = SseOpcode::Pminsw;
3566     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3567     return Some(expr2_0);
3568 }
3569 
3570 // Generated as internal constructor for term x64_pminsd.
3571 pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3572     let pattern0_0 = arg0;
3573     let pattern1_0 = arg1;
3574     // Rule at src/isa/x64/inst.isle line 2157.
3575     let expr0_0: Type = I32X4;
3576     let expr1_0 = SseOpcode::Pminsd;
3577     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3578     return Some(expr2_0);
3579 }
3580 
3581 // Generated as internal constructor for term x64_pmaxu.
3582 pub fn constructor_x64_pmaxu<C: Context>(
3583     ctx: &mut C,
3584     arg0: Type,
3585     arg1: Xmm,
3586     arg2: &XmmMem,
3587 ) -> Option<Xmm> {
3588     let pattern0_0 = arg0;
3589     if pattern0_0 == I8X16 {
3590         let pattern2_0 = arg1;
3591         let pattern3_0 = arg2;
3592         // Rule at src/isa/x64/inst.isle line 2161.
3593         let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?;
3594         return Some(expr0_0);
3595     }
3596     if pattern0_0 == I16X8 {
3597         let pattern2_0 = arg1;
3598         let pattern3_0 = arg2;
3599         // Rule at src/isa/x64/inst.isle line 2162.
3600         let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?;
3601         return Some(expr0_0);
3602     }
3603     if pattern0_0 == I32X4 {
3604         let pattern2_0 = arg1;
3605         let pattern3_0 = arg2;
3606         // Rule at src/isa/x64/inst.isle line 2163.
3607         let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?;
3608         return Some(expr0_0);
3609     }
3610     return None;
3611 }
3612 
3613 // Generated as internal constructor for term x64_pmaxub.
3614 pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3615     let pattern0_0 = arg0;
3616     let pattern1_0 = arg1;
3617     // Rule at src/isa/x64/inst.isle line 2166.
3618     let expr0_0: Type = I8X16;
3619     let expr1_0 = SseOpcode::Pmaxub;
3620     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3621     return Some(expr2_0);
3622 }
3623 
3624 // Generated as internal constructor for term x64_pmaxuw.
3625 pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3626     let pattern0_0 = arg0;
3627     let pattern1_0 = arg1;
3628     // Rule at src/isa/x64/inst.isle line 2168.
3629     let expr0_0: Type = I8X16;
3630     let expr1_0 = SseOpcode::Pmaxuw;
3631     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3632     return Some(expr2_0);
3633 }
3634 
3635 // Generated as internal constructor for term x64_pmaxud.
3636 pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3637     let pattern0_0 = arg0;
3638     let pattern1_0 = arg1;
3639     // Rule at src/isa/x64/inst.isle line 2170.
3640     let expr0_0: Type = I8X16;
3641     let expr1_0 = SseOpcode::Pmaxud;
3642     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3643     return Some(expr2_0);
3644 }
3645 
3646 // Generated as internal constructor for term x64_pminu.
3647 pub fn constructor_x64_pminu<C: Context>(
3648     ctx: &mut C,
3649     arg0: Type,
3650     arg1: Xmm,
3651     arg2: &XmmMem,
3652 ) -> Option<Xmm> {
3653     let pattern0_0 = arg0;
3654     if pattern0_0 == I8X16 {
3655         let pattern2_0 = arg1;
3656         let pattern3_0 = arg2;
3657         // Rule at src/isa/x64/inst.isle line 2174.
3658         let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?;
3659         return Some(expr0_0);
3660     }
3661     if pattern0_0 == I16X8 {
3662         let pattern2_0 = arg1;
3663         let pattern3_0 = arg2;
3664         // Rule at src/isa/x64/inst.isle line 2175.
3665         let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?;
3666         return Some(expr0_0);
3667     }
3668     if pattern0_0 == I32X4 {
3669         let pattern2_0 = arg1;
3670         let pattern3_0 = arg2;
3671         // Rule at src/isa/x64/inst.isle line 2176.
3672         let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?;
3673         return Some(expr0_0);
3674     }
3675     return None;
3676 }
3677 
3678 // Generated as internal constructor for term x64_pminub.
3679 pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3680     let pattern0_0 = arg0;
3681     let pattern1_0 = arg1;
3682     // Rule at src/isa/x64/inst.isle line 2179.
3683     let expr0_0: Type = I8X16;
3684     let expr1_0 = SseOpcode::Pminub;
3685     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3686     return Some(expr2_0);
3687 }
3688 
3689 // Generated as internal constructor for term x64_pminuw.
3690 pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3691     let pattern0_0 = arg0;
3692     let pattern1_0 = arg1;
3693     // Rule at src/isa/x64/inst.isle line 2181.
3694     let expr0_0: Type = I8X16;
3695     let expr1_0 = SseOpcode::Pminuw;
3696     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3697     return Some(expr2_0);
3698 }
3699 
3700 // Generated as internal constructor for term x64_pminud.
3701 pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3702     let pattern0_0 = arg0;
3703     let pattern1_0 = arg1;
3704     // Rule at src/isa/x64/inst.isle line 2183.
3705     let expr0_0: Type = I8X16;
3706     let expr1_0 = SseOpcode::Pminud;
3707     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3708     return Some(expr2_0);
3709 }
3710 
3711 // Generated as internal constructor for term x64_punpcklbw.
3712 pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3713     let pattern0_0 = arg0;
3714     let pattern1_0 = arg1;
3715     // Rule at src/isa/x64/inst.isle line 2187.
3716     let expr0_0: Type = I8X16;
3717     let expr1_0 = SseOpcode::Punpcklbw;
3718     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3719     return Some(expr2_0);
3720 }
3721 
3722 // Generated as internal constructor for term x64_punpckhbw.
3723 pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3724     let pattern0_0 = arg0;
3725     let pattern1_0 = arg1;
3726     // Rule at src/isa/x64/inst.isle line 2192.
3727     let expr0_0: Type = I8X16;
3728     let expr1_0 = SseOpcode::Punpckhbw;
3729     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3730     return Some(expr2_0);
3731 }
3732 
3733 // Generated as internal constructor for term x64_packsswb.
3734 pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3735     let pattern0_0 = arg0;
3736     let pattern1_0 = arg1;
3737     // Rule at src/isa/x64/inst.isle line 2197.
3738     let expr0_0: Type = I8X16;
3739     let expr1_0 = SseOpcode::Packsswb;
3740     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3741     return Some(expr2_0);
3742 }
3743 
3744 // Generated as internal constructor for term xmm_rm_r_imm.
3745 pub fn constructor_xmm_rm_r_imm<C: Context>(
3746     ctx: &mut C,
3747     arg0: &SseOpcode,
3748     arg1: Reg,
3749     arg2: &RegMem,
3750     arg3: u8,
3751     arg4: &OperandSize,
3752 ) -> Option<Xmm> {
3753     let pattern0_0 = arg0;
3754     let pattern1_0 = arg1;
3755     let pattern2_0 = arg2;
3756     let pattern3_0 = arg3;
3757     let pattern4_0 = arg4;
3758     // Rule at src/isa/x64/inst.isle line 2202.
3759     let expr0_0 = C::temp_writable_xmm(ctx);
3760     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3761     let expr2_0 = MInst::XmmRmRImm {
3762         op: pattern0_0.clone(),
3763         src1: pattern1_0,
3764         src2: pattern2_0.clone(),
3765         dst: expr1_0,
3766         imm: pattern3_0,
3767         size: pattern4_0.clone(),
3768     };
3769     let expr3_0 = C::emit(ctx, &expr2_0);
3770     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3771     return Some(expr4_0);
3772 }
3773 
3774 // Generated as internal constructor for term x64_palignr.
3775 pub fn constructor_x64_palignr<C: Context>(
3776     ctx: &mut C,
3777     arg0: Xmm,
3778     arg1: &XmmMem,
3779     arg2: u8,
3780     arg3: &OperandSize,
3781 ) -> Option<Xmm> {
3782     let pattern0_0 = arg0;
3783     let pattern1_0 = arg1;
3784     let pattern2_0 = arg2;
3785     let pattern3_0 = arg3;
3786     // Rule at src/isa/x64/inst.isle line 2214.
3787     let expr0_0 = SseOpcode::Palignr;
3788     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3789     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3790     let expr3_0 =
3791         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3792     return Some(expr3_0);
3793 }
3794 
3795 // Generated as internal constructor for term x64_cmpp.
3796 pub fn constructor_x64_cmpp<C: Context>(
3797     ctx: &mut C,
3798     arg0: Type,
3799     arg1: Xmm,
3800     arg2: &XmmMem,
3801     arg3: &FcmpImm,
3802 ) -> Option<Xmm> {
3803     let pattern0_0 = arg0;
3804     if pattern0_0 == F32X4 {
3805         let pattern2_0 = arg1;
3806         let pattern3_0 = arg2;
3807         let pattern4_0 = arg3;
3808         // Rule at src/isa/x64/inst.isle line 2223.
3809         let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3810         return Some(expr0_0);
3811     }
3812     if pattern0_0 == F64X2 {
3813         let pattern2_0 = arg1;
3814         let pattern3_0 = arg2;
3815         let pattern4_0 = arg3;
3816         // Rule at src/isa/x64/inst.isle line 2224.
3817         let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?;
3818         return Some(expr0_0);
3819     }
3820     return None;
3821 }
3822 
3823 // Generated as internal constructor for term x64_cmpps.
3824 pub fn constructor_x64_cmpps<C: Context>(
3825     ctx: &mut C,
3826     arg0: Xmm,
3827     arg1: &XmmMem,
3828     arg2: &FcmpImm,
3829 ) -> Option<Xmm> {
3830     let pattern0_0 = arg0;
3831     let pattern1_0 = arg1;
3832     let pattern2_0 = arg2;
3833     // Rule at src/isa/x64/inst.isle line 2227.
3834     let expr0_0 = SseOpcode::Cmpps;
3835     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3836     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3837     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3838     let expr4_0 = OperandSize::Size32;
3839     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3840     return Some(expr5_0);
3841 }
3842 
3843 // Generated as internal constructor for term x64_cmppd.
3844 pub fn constructor_x64_cmppd<C: Context>(
3845     ctx: &mut C,
3846     arg0: Xmm,
3847     arg1: &XmmMem,
3848     arg2: &FcmpImm,
3849 ) -> Option<Xmm> {
3850     let pattern0_0 = arg0;
3851     let pattern1_0 = arg1;
3852     let pattern2_0 = arg2;
3853     // Rule at src/isa/x64/inst.isle line 2238.
3854     let expr0_0 = SseOpcode::Cmppd;
3855     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3856     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3857     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
3858     let expr4_0 = OperandSize::Size32;
3859     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
3860     return Some(expr5_0);
3861 }
3862 
3863 // Generated as internal constructor for term x64_pinsrb.
3864 pub fn constructor_x64_pinsrb<C: Context>(
3865     ctx: &mut C,
3866     arg0: Xmm,
3867     arg1: &GprMem,
3868     arg2: u8,
3869 ) -> Option<Xmm> {
3870     let pattern0_0 = arg0;
3871     let pattern1_0 = arg1;
3872     let pattern2_0 = arg2;
3873     // Rule at src/isa/x64/inst.isle line 2247.
3874     let expr0_0 = SseOpcode::Pinsrb;
3875     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3876     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3877     let expr3_0 = OperandSize::Size32;
3878     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3879     return Some(expr4_0);
3880 }
3881 
3882 // Generated as internal constructor for term x64_pinsrw.
3883 pub fn constructor_x64_pinsrw<C: Context>(
3884     ctx: &mut C,
3885     arg0: Xmm,
3886     arg1: &GprMem,
3887     arg2: u8,
3888 ) -> Option<Xmm> {
3889     let pattern0_0 = arg0;
3890     let pattern1_0 = arg1;
3891     let pattern2_0 = arg2;
3892     // Rule at src/isa/x64/inst.isle line 2256.
3893     let expr0_0 = SseOpcode::Pinsrw;
3894     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3895     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3896     let expr3_0 = OperandSize::Size32;
3897     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3898     return Some(expr4_0);
3899 }
3900 
3901 // Generated as internal constructor for term x64_pinsrd.
3902 pub fn constructor_x64_pinsrd<C: Context>(
3903     ctx: &mut C,
3904     arg0: Xmm,
3905     arg1: &GprMem,
3906     arg2: u8,
3907     arg3: &OperandSize,
3908 ) -> Option<Xmm> {
3909     let pattern0_0 = arg0;
3910     let pattern1_0 = arg1;
3911     let pattern2_0 = arg2;
3912     let pattern3_0 = arg3;
3913     // Rule at src/isa/x64/inst.isle line 2265.
3914     let expr0_0 = SseOpcode::Pinsrd;
3915     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3916     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
3917     let expr3_0 =
3918         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
3919     return Some(expr3_0);
3920 }
3921 
3922 // Generated as internal constructor for term x64_pmaddwd.
3923 pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3924     let pattern0_0 = arg0;
3925     let pattern1_0 = arg1;
3926     // Rule at src/isa/x64/inst.isle line 2274.
3927     let expr0_0 = C::temp_writable_xmm(ctx);
3928     let expr1_0 = SseOpcode::Pmaddwd;
3929     let expr2_0 = MInst::XmmRmR {
3930         op: expr1_0,
3931         src1: pattern0_0,
3932         src2: pattern1_0.clone(),
3933         dst: expr0_0,
3934     };
3935     let expr3_0 = C::emit(ctx, &expr2_0);
3936     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3937     return Some(expr4_0);
3938 }
3939 
3940 // Generated as internal constructor for term x64_insertps.
3941 pub fn constructor_x64_insertps<C: Context>(
3942     ctx: &mut C,
3943     arg0: Xmm,
3944     arg1: &XmmMem,
3945     arg2: u8,
3946 ) -> Option<Xmm> {
3947     let pattern0_0 = arg0;
3948     let pattern1_0 = arg1;
3949     let pattern2_0 = arg2;
3950     // Rule at src/isa/x64/inst.isle line 2284.
3951     let expr0_0 = SseOpcode::Insertps;
3952     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
3953     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
3954     let expr3_0 = OperandSize::Size32;
3955     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
3956     return Some(expr4_0);
3957 }
3958 
3959 // Generated as internal constructor for term x64_pshufd.
3960 pub fn constructor_x64_pshufd<C: Context>(
3961     ctx: &mut C,
3962     arg0: &XmmMem,
3963     arg1: u8,
3964     arg2: &OperandSize,
3965 ) -> Option<Xmm> {
3966     let pattern0_0 = arg0;
3967     let pattern1_0 = arg1;
3968     let pattern2_0 = arg2;
3969     // Rule at src/isa/x64/inst.isle line 2293.
3970     let expr0_0 = C::temp_writable_xmm(ctx);
3971     let expr1_0 = SseOpcode::Pshufd;
3972     let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
3973     let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0);
3974     let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0);
3975     let expr5_0 = MInst::XmmRmRImm {
3976         op: expr1_0,
3977         src1: expr2_0,
3978         src2: expr3_0,
3979         dst: expr4_0,
3980         imm: pattern1_0,
3981         size: pattern2_0.clone(),
3982     };
3983     let expr6_0 = C::emit(ctx, &expr5_0);
3984     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3985     return Some(expr7_0);
3986 }
3987 
3988 // Generated as internal constructor for term x64_pshufb.
3989 pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3990     let pattern0_0 = arg0;
3991     let pattern1_0 = arg1;
3992     // Rule at src/isa/x64/inst.isle line 2305.
3993     let expr0_0 = C::temp_writable_xmm(ctx);
3994     let expr1_0 = SseOpcode::Pshufb;
3995     let expr2_0 = MInst::XmmRmR {
3996         op: expr1_0,
3997         src1: pattern0_0,
3998         src2: pattern1_0.clone(),
3999         dst: expr0_0,
4000     };
4001     let expr3_0 = C::emit(ctx, &expr2_0);
4002     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4003     return Some(expr4_0);
4004 }
4005 
4006 // Generated as internal constructor for term xmm_unary_rm_r.
4007 pub fn constructor_xmm_unary_rm_r<C: Context>(
4008     ctx: &mut C,
4009     arg0: &SseOpcode,
4010     arg1: &XmmMem,
4011 ) -> Option<Xmm> {
4012     let pattern0_0 = arg0;
4013     let pattern1_0 = arg1;
4014     // Rule at src/isa/x64/inst.isle line 2315.
4015     let expr0_0 = C::temp_writable_xmm(ctx);
4016     let expr1_0 = MInst::XmmUnaryRmR {
4017         op: pattern0_0.clone(),
4018         src: pattern1_0.clone(),
4019         dst: expr0_0,
4020     };
4021     let expr2_0 = C::emit(ctx, &expr1_0);
4022     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4023     return Some(expr3_0);
4024 }
4025 
4026 // Generated as internal constructor for term x64_pabsb.
4027 pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4028     let pattern0_0 = arg0;
4029     // Rule at src/isa/x64/inst.isle line 2322.
4030     let expr0_0 = SseOpcode::Pabsb;
4031     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4032     return Some(expr1_0);
4033 }
4034 
4035 // Generated as internal constructor for term x64_pabsw.
4036 pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4037     let pattern0_0 = arg0;
4038     // Rule at src/isa/x64/inst.isle line 2327.
4039     let expr0_0 = SseOpcode::Pabsw;
4040     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4041     return Some(expr1_0);
4042 }
4043 
4044 // Generated as internal constructor for term x64_pabsd.
4045 pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4046     let pattern0_0 = arg0;
4047     // Rule at src/isa/x64/inst.isle line 2332.
4048     let expr0_0 = SseOpcode::Pabsd;
4049     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4050     return Some(expr1_0);
4051 }
4052 
4053 // Generated as internal constructor for term xmm_unary_rm_r_evex.
4054 pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
4055     ctx: &mut C,
4056     arg0: &Avx512Opcode,
4057     arg1: &XmmMem,
4058 ) -> Option<Xmm> {
4059     let pattern0_0 = arg0;
4060     let pattern1_0 = arg1;
4061     // Rule at src/isa/x64/inst.isle line 2337.
4062     let expr0_0 = C::temp_writable_xmm(ctx);
4063     let expr1_0 = MInst::XmmUnaryRmREvex {
4064         op: pattern0_0.clone(),
4065         src: pattern1_0.clone(),
4066         dst: expr0_0,
4067     };
4068     let expr2_0 = C::emit(ctx, &expr1_0);
4069     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4070     return Some(expr3_0);
4071 }
4072 
4073 // Generated as internal constructor for term x64_vpabsq.
4074 pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4075     let pattern0_0 = arg0;
4076     // Rule at src/isa/x64/inst.isle line 2344.
4077     let expr0_0 = Avx512Opcode::Vpabsq;
4078     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4079     return Some(expr1_0);
4080 }
4081 
4082 // Generated as internal constructor for term x64_vpopcntb.
4083 pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4084     let pattern0_0 = arg0;
4085     // Rule at src/isa/x64/inst.isle line 2349.
4086     let expr0_0 = Avx512Opcode::Vpopcntb;
4087     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4088     return Some(expr1_0);
4089 }
4090 
4091 // Generated as internal constructor for term xmm_rm_r_evex.
4092 pub fn constructor_xmm_rm_r_evex<C: Context>(
4093     ctx: &mut C,
4094     arg0: &Avx512Opcode,
4095     arg1: &XmmMem,
4096     arg2: Xmm,
4097 ) -> Option<Xmm> {
4098     let pattern0_0 = arg0;
4099     let pattern1_0 = arg1;
4100     let pattern2_0 = arg2;
4101     // Rule at src/isa/x64/inst.isle line 2354.
4102     let expr0_0 = C::temp_writable_xmm(ctx);
4103     let expr1_0 = MInst::XmmRmREvex {
4104         op: pattern0_0.clone(),
4105         src1: pattern1_0.clone(),
4106         src2: pattern2_0,
4107         dst: expr0_0,
4108     };
4109     let expr2_0 = C::emit(ctx, &expr1_0);
4110     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4111     return Some(expr3_0);
4112 }
4113 
4114 // Generated as internal constructor for term x64_vpmullq.
4115 pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option<Xmm> {
4116     let pattern0_0 = arg0;
4117     let pattern1_0 = arg1;
4118     // Rule at src/isa/x64/inst.isle line 2366.
4119     let expr0_0 = Avx512Opcode::Vpmullq;
4120     let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4121     return Some(expr1_0);
4122 }
4123 
4124 // Generated as internal constructor for term mul_hi.
4125 pub fn constructor_mul_hi<C: Context>(
4126     ctx: &mut C,
4127     arg0: Type,
4128     arg1: bool,
4129     arg2: Gpr,
4130     arg3: &GprMem,
4131 ) -> Option<ValueRegs> {
4132     let pattern0_0 = arg0;
4133     let pattern1_0 = arg1;
4134     let pattern2_0 = arg2;
4135     let pattern3_0 = arg3;
4136     // Rule at src/isa/x64/inst.isle line 2375.
4137     let expr0_0 = C::temp_writable_gpr(ctx);
4138     let expr1_0 = C::temp_writable_gpr(ctx);
4139     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4140     let expr3_0 = MInst::MulHi {
4141         size: expr2_0,
4142         signed: pattern1_0,
4143         src1: pattern2_0,
4144         src2: pattern3_0.clone(),
4145         dst_lo: expr0_0,
4146         dst_hi: expr1_0,
4147     };
4148     let expr4_0 = C::emit(ctx, &expr3_0);
4149     let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4150     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
4151     let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?;
4152     return Some(expr7_0);
4153 }
4154 
4155 // Generated as internal constructor for term mulhi_u.
4156 pub fn constructor_mulhi_u<C: Context>(
4157     ctx: &mut C,
4158     arg0: Type,
4159     arg1: Gpr,
4160     arg2: &GprMem,
4161 ) -> Option<ValueRegs> {
4162     let pattern0_0 = arg0;
4163     let pattern1_0 = arg1;
4164     let pattern2_0 = arg2;
4165     // Rule at src/isa/x64/inst.isle line 2390.
4166     let expr0_0: bool = false;
4167     let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?;
4168     return Some(expr1_0);
4169 }
4170 
4171 // Generated as internal constructor for term xmm_rmi_xmm.
4172 pub fn constructor_xmm_rmi_xmm<C: Context>(
4173     ctx: &mut C,
4174     arg0: &SseOpcode,
4175     arg1: Xmm,
4176     arg2: &XmmMemImm,
4177 ) -> Option<Xmm> {
4178     let pattern0_0 = arg0;
4179     let pattern1_0 = arg1;
4180     let pattern2_0 = arg2;
4181     // Rule at src/isa/x64/inst.isle line 2395.
4182     let expr0_0 = C::temp_writable_xmm(ctx);
4183     let expr1_0 = MInst::XmmRmiReg {
4184         opcode: pattern0_0.clone(),
4185         src1: pattern1_0,
4186         src2: pattern2_0.clone(),
4187         dst: expr0_0,
4188     };
4189     let expr2_0 = C::emit(ctx, &expr1_0);
4190     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4191     return Some(expr3_0);
4192 }
4193 
4194 // Generated as internal constructor for term x64_psllw.
4195 pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4196     let pattern0_0 = arg0;
4197     let pattern1_0 = arg1;
4198     // Rule at src/isa/x64/inst.isle line 2405.
4199     let expr0_0 = SseOpcode::Psllw;
4200     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4201     return Some(expr1_0);
4202 }
4203 
4204 // Generated as internal constructor for term x64_pslld.
4205 pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4206     let pattern0_0 = arg0;
4207     let pattern1_0 = arg1;
4208     // Rule at src/isa/x64/inst.isle line 2410.
4209     let expr0_0 = SseOpcode::Pslld;
4210     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4211     return Some(expr1_0);
4212 }
4213 
4214 // Generated as internal constructor for term x64_psllq.
4215 pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4216     let pattern0_0 = arg0;
4217     let pattern1_0 = arg1;
4218     // Rule at src/isa/x64/inst.isle line 2415.
4219     let expr0_0 = SseOpcode::Psllq;
4220     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4221     return Some(expr1_0);
4222 }
4223 
4224 // Generated as internal constructor for term x64_psrlw.
4225 pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4226     let pattern0_0 = arg0;
4227     let pattern1_0 = arg1;
4228     // Rule at src/isa/x64/inst.isle line 2420.
4229     let expr0_0 = SseOpcode::Psrlw;
4230     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4231     return Some(expr1_0);
4232 }
4233 
4234 // Generated as internal constructor for term x64_psrld.
4235 pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4236     let pattern0_0 = arg0;
4237     let pattern1_0 = arg1;
4238     // Rule at src/isa/x64/inst.isle line 2425.
4239     let expr0_0 = SseOpcode::Psrld;
4240     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4241     return Some(expr1_0);
4242 }
4243 
4244 // Generated as internal constructor for term x64_psrlq.
4245 pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4246     let pattern0_0 = arg0;
4247     let pattern1_0 = arg1;
4248     // Rule at src/isa/x64/inst.isle line 2430.
4249     let expr0_0 = SseOpcode::Psrlq;
4250     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4251     return Some(expr1_0);
4252 }
4253 
4254 // Generated as internal constructor for term x64_psraw.
4255 pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4256     let pattern0_0 = arg0;
4257     let pattern1_0 = arg1;
4258     // Rule at src/isa/x64/inst.isle line 2435.
4259     let expr0_0 = SseOpcode::Psraw;
4260     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4261     return Some(expr1_0);
4262 }
4263 
4264 // Generated as internal constructor for term x64_psrad.
4265 pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4266     let pattern0_0 = arg0;
4267     let pattern1_0 = arg1;
4268     // Rule at src/isa/x64/inst.isle line 2440.
4269     let expr0_0 = SseOpcode::Psrad;
4270     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4271     return Some(expr1_0);
4272 }
4273 
4274 // Generated as internal constructor for term x64_pextrd.
4275 pub fn constructor_x64_pextrd<C: Context>(
4276     ctx: &mut C,
4277     arg0: Type,
4278     arg1: Xmm,
4279     arg2: u8,
4280 ) -> Option<Gpr> {
4281     let pattern0_0 = arg0;
4282     let pattern1_0 = arg1;
4283     let pattern2_0 = arg2;
4284     // Rule at src/isa/x64/inst.isle line 2445.
4285     let expr0_0 = C::temp_writable_gpr(ctx);
4286     let expr1_0 = SseOpcode::Pextrd;
4287     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4288     let expr3_0 = C::xmm_to_reg(ctx, pattern1_0);
4289     let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?;
4290     let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0);
4291     let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0);
4292     let expr7_0 = C::lane_type(ctx, pattern0_0);
4293     let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0);
4294     let expr9_0 = MInst::XmmRmRImm {
4295         op: expr1_0,
4296         src1: expr2_0,
4297         src2: expr5_0,
4298         dst: expr6_0,
4299         imm: pattern2_0,
4300         size: expr8_0,
4301     };
4302     let expr10_0 = C::emit(ctx, &expr9_0);
4303     let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4304     return Some(expr11_0);
4305 }
4306 
4307 // Generated as internal constructor for term gpr_to_xmm.
4308 pub fn constructor_gpr_to_xmm<C: Context>(
4309     ctx: &mut C,
4310     arg0: &SseOpcode,
4311     arg1: &GprMem,
4312     arg2: &OperandSize,
4313 ) -> Option<Xmm> {
4314     let pattern0_0 = arg0;
4315     let pattern1_0 = arg1;
4316     let pattern2_0 = arg2;
4317     // Rule at src/isa/x64/inst.isle line 2457.
4318     let expr0_0 = C::temp_writable_xmm(ctx);
4319     let expr1_0 = MInst::GprToXmm {
4320         op: pattern0_0.clone(),
4321         src: pattern1_0.clone(),
4322         dst: expr0_0,
4323         src_size: pattern2_0.clone(),
4324     };
4325     let expr2_0 = C::emit(ctx, &expr1_0);
4326     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4327     return Some(expr3_0);
4328 }
4329 
4330 // Generated as internal constructor for term x64_not.
4331 pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4332     let pattern0_0 = arg0;
4333     let pattern1_0 = arg1;
4334     // Rule at src/isa/x64/inst.isle line 2464.
4335     let expr0_0 = C::temp_writable_gpr(ctx);
4336     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4337     let expr2_0 = MInst::Not {
4338         size: expr1_0,
4339         src: pattern1_0,
4340         dst: expr0_0,
4341     };
4342     let expr3_0 = C::emit(ctx, &expr2_0);
4343     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4344     return Some(expr4_0);
4345 }
4346 
4347 // Generated as internal constructor for term x64_neg.
4348 pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4349     let pattern0_0 = arg0;
4350     let pattern1_0 = arg1;
4351     // Rule at src/isa/x64/inst.isle line 2472.
4352     let expr0_0 = C::temp_writable_gpr(ctx);
4353     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4354     let expr2_0 = MInst::Neg {
4355         size: expr1_0,
4356         src: pattern1_0,
4357         dst: expr0_0,
4358     };
4359     let expr3_0 = C::emit(ctx, &expr2_0);
4360     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4361     return Some(expr4_0);
4362 }
4363 
4364 // Generated as internal constructor for term x64_lea.
4365 pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Option<Gpr> {
4366     let pattern0_0 = arg0;
4367     // Rule at src/isa/x64/inst.isle line 2479.
4368     let expr0_0 = C::temp_writable_gpr(ctx);
4369     let expr1_0 = MInst::LoadEffectiveAddress {
4370         addr: pattern0_0.clone(),
4371         dst: expr0_0,
4372     };
4373     let expr2_0 = C::emit(ctx, &expr1_0);
4374     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4375     return Some(expr3_0);
4376 }
4377 
4378 // Generated as internal constructor for term x64_ud2.
4379 pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> Option<SideEffectNoResult> {
4380     let pattern0_0 = arg0;
4381     // Rule at src/isa/x64/inst.isle line 2486.
4382     let expr0_0 = MInst::Ud2 {
4383         trap_code: pattern0_0.clone(),
4384     };
4385     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4386     return Some(expr1_0);
4387 }
4388 
4389 // Generated as internal constructor for term x64_hlt.
4390 pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> Option<SideEffectNoResult> {
4391     // Rule at src/isa/x64/inst.isle line 2491.
4392     let expr0_0 = MInst::Hlt;
4393     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4394     return Some(expr1_0);
4395 }
4396 
4397 // Generated as internal constructor for term x64_lzcnt.
4398 pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4399     let pattern0_0 = arg0;
4400     let pattern1_0 = arg1;
4401     // Rule at src/isa/x64/inst.isle line 2496.
4402     let expr0_0 = C::temp_writable_gpr(ctx);
4403     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4404     let expr2_0 = UnaryRmROpcode::Lzcnt;
4405     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4406     let expr4_0 = MInst::UnaryRmR {
4407         size: expr1_0,
4408         op: expr2_0,
4409         src: expr3_0,
4410         dst: expr0_0,
4411     };
4412     let expr5_0 = C::emit(ctx, &expr4_0);
4413     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4414     return Some(expr6_0);
4415 }
4416 
4417 // Generated as internal constructor for term x64_tzcnt.
4418 pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4419     let pattern0_0 = arg0;
4420     let pattern1_0 = arg1;
4421     // Rule at src/isa/x64/inst.isle line 2504.
4422     let expr0_0 = C::temp_writable_gpr(ctx);
4423     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4424     let expr2_0 = UnaryRmROpcode::Tzcnt;
4425     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4426     let expr4_0 = MInst::UnaryRmR {
4427         size: expr1_0,
4428         op: expr2_0,
4429         src: expr3_0,
4430         dst: expr0_0,
4431     };
4432     let expr5_0 = C::emit(ctx, &expr4_0);
4433     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4434     return Some(expr6_0);
4435 }
4436 
4437 // Generated as internal constructor for term x64_bsr.
4438 pub fn constructor_x64_bsr<C: Context>(
4439     ctx: &mut C,
4440     arg0: Type,
4441     arg1: Gpr,
4442 ) -> Option<ProducesFlags> {
4443     let pattern0_0 = arg0;
4444     let pattern1_0 = arg1;
4445     // Rule at src/isa/x64/inst.isle line 2512.
4446     let expr0_0 = C::temp_writable_gpr(ctx);
4447     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4448     let expr2_0 = UnaryRmROpcode::Bsr;
4449     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4450     let expr4_0 = MInst::UnaryRmR {
4451         size: expr1_0,
4452         op: expr2_0,
4453         src: expr3_0,
4454         dst: expr0_0,
4455     };
4456     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4457     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4458         inst: expr4_0,
4459         result: expr5_0,
4460     };
4461     return Some(expr6_0);
4462 }
4463 
4464 // Generated as internal constructor for term bsr_or_else.
4465 pub fn constructor_bsr_or_else<C: Context>(
4466     ctx: &mut C,
4467     arg0: Type,
4468     arg1: Gpr,
4469     arg2: Gpr,
4470 ) -> Option<Gpr> {
4471     let pattern0_0 = arg0;
4472     let pattern1_0 = arg1;
4473     let pattern2_0 = arg2;
4474     // Rule at src/isa/x64/inst.isle line 2521.
4475     let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?;
4476     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4477     let expr2_0 = C::gpr_new(ctx, expr1_0);
4478     let expr3_0 = CC::Z;
4479     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4480     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4481     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4482     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4483     let expr8_0 = C::gpr_new(ctx, expr7_0);
4484     return Some(expr8_0);
4485 }
4486 
4487 // Generated as internal constructor for term x64_bsf.
4488 pub fn constructor_x64_bsf<C: Context>(
4489     ctx: &mut C,
4490     arg0: Type,
4491     arg1: Gpr,
4492 ) -> Option<ProducesFlags> {
4493     let pattern0_0 = arg0;
4494     let pattern1_0 = arg1;
4495     // Rule at src/isa/x64/inst.isle line 2532.
4496     let expr0_0 = C::temp_writable_gpr(ctx);
4497     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4498     let expr2_0 = UnaryRmROpcode::Bsf;
4499     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4500     let expr4_0 = MInst::UnaryRmR {
4501         size: expr1_0,
4502         op: expr2_0,
4503         src: expr3_0,
4504         dst: expr0_0,
4505     };
4506     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4507     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4508         inst: expr4_0,
4509         result: expr5_0,
4510     };
4511     return Some(expr6_0);
4512 }
4513 
4514 // Generated as internal constructor for term bsf_or_else.
4515 pub fn constructor_bsf_or_else<C: Context>(
4516     ctx: &mut C,
4517     arg0: Type,
4518     arg1: Gpr,
4519     arg2: Gpr,
4520 ) -> Option<Gpr> {
4521     let pattern0_0 = arg0;
4522     let pattern1_0 = arg1;
4523     let pattern2_0 = arg2;
4524     // Rule at src/isa/x64/inst.isle line 2541.
4525     let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?;
4526     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4527     let expr2_0 = C::gpr_new(ctx, expr1_0);
4528     let expr3_0 = CC::Z;
4529     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4530     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4531     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4532     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4533     let expr8_0 = C::gpr_new(ctx, expr7_0);
4534     return Some(expr8_0);
4535 }
4536 
4537 // Generated as internal constructor for term x64_popcnt.
4538 pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4539     let pattern0_0 = arg0;
4540     let pattern1_0 = arg1;
4541     // Rule at src/isa/x64/inst.isle line 2552.
4542     let expr0_0 = C::temp_writable_gpr(ctx);
4543     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4544     let expr2_0 = UnaryRmROpcode::Popcnt;
4545     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4546     let expr4_0 = MInst::UnaryRmR {
4547         size: expr1_0,
4548         op: expr2_0,
4549         src: expr3_0,
4550         dst: expr0_0,
4551     };
4552     let expr5_0 = C::emit(ctx, &expr4_0);
4553     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4554     return Some(expr6_0);
4555 }
4556 
4557 // Generated as internal constructor for term xmm_min_max_seq.
4558 pub fn constructor_xmm_min_max_seq<C: Context>(
4559     ctx: &mut C,
4560     arg0: Type,
4561     arg1: bool,
4562     arg2: Xmm,
4563     arg3: Xmm,
4564 ) -> Option<Xmm> {
4565     let pattern0_0 = arg0;
4566     let pattern1_0 = arg1;
4567     let pattern2_0 = arg2;
4568     let pattern3_0 = arg3;
4569     // Rule at src/isa/x64/inst.isle line 2560.
4570     let expr0_0 = C::temp_writable_xmm(ctx);
4571     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4572     let expr2_0 = MInst::XmmMinMaxSeq {
4573         size: expr1_0,
4574         is_min: pattern1_0,
4575         lhs: pattern2_0,
4576         rhs: pattern3_0,
4577         dst: expr0_0,
4578     };
4579     let expr3_0 = C::emit(ctx, &expr2_0);
4580     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4581     return Some(expr4_0);
4582 }
4583 
4584 // Generated as internal constructor for term x64_minss.
4585 pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4586     let pattern0_0 = arg0;
4587     let pattern1_0 = arg1;
4588     // Rule at src/isa/x64/inst.isle line 2568.
4589     let expr0_0 = C::temp_writable_xmm(ctx);
4590     let expr1_0 = SseOpcode::Minss;
4591     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4592     let expr3_0 = MInst::XmmRmR {
4593         op: expr1_0,
4594         src1: pattern0_0,
4595         src2: expr2_0,
4596         dst: expr0_0,
4597     };
4598     let expr4_0 = C::emit(ctx, &expr3_0);
4599     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4600     return Some(expr5_0);
4601 }
4602 
4603 // Generated as internal constructor for term x64_minsd.
4604 pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4605     let pattern0_0 = arg0;
4606     let pattern1_0 = arg1;
4607     // Rule at src/isa/x64/inst.isle line 2575.
4608     let expr0_0 = C::temp_writable_xmm(ctx);
4609     let expr1_0 = SseOpcode::Minsd;
4610     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4611     let expr3_0 = MInst::XmmRmR {
4612         op: expr1_0,
4613         src1: pattern0_0,
4614         src2: expr2_0,
4615         dst: expr0_0,
4616     };
4617     let expr4_0 = C::emit(ctx, &expr3_0);
4618     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4619     return Some(expr5_0);
4620 }
4621 
4622 // Generated as internal constructor for term x64_minps.
4623 pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4624     let pattern0_0 = arg0;
4625     let pattern1_0 = arg1;
4626     // Rule at src/isa/x64/inst.isle line 2583.
4627     let expr0_0 = C::temp_writable_xmm(ctx);
4628     let expr1_0 = SseOpcode::Minps;
4629     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4630     let expr3_0 = MInst::XmmRmR {
4631         op: expr1_0,
4632         src1: pattern0_0,
4633         src2: expr2_0,
4634         dst: expr0_0,
4635     };
4636     let expr4_0 = C::emit(ctx, &expr3_0);
4637     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4638     return Some(expr5_0);
4639 }
4640 
4641 // Generated as internal constructor for term x64_minpd.
4642 pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4643     let pattern0_0 = arg0;
4644     let pattern1_0 = arg1;
4645     // Rule at src/isa/x64/inst.isle line 2590.
4646     let expr0_0 = C::temp_writable_xmm(ctx);
4647     let expr1_0 = SseOpcode::Minpd;
4648     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4649     let expr3_0 = MInst::XmmRmR {
4650         op: expr1_0,
4651         src1: pattern0_0,
4652         src2: expr2_0,
4653         dst: expr0_0,
4654     };
4655     let expr4_0 = C::emit(ctx, &expr3_0);
4656     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4657     return Some(expr5_0);
4658 }
4659 
4660 // Generated as internal constructor for term x64_maxss.
4661 pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4662     let pattern0_0 = arg0;
4663     let pattern1_0 = arg1;
4664     // Rule at src/isa/x64/inst.isle line 2597.
4665     let expr0_0 = C::temp_writable_xmm(ctx);
4666     let expr1_0 = SseOpcode::Maxss;
4667     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4668     let expr3_0 = MInst::XmmRmR {
4669         op: expr1_0,
4670         src1: pattern0_0,
4671         src2: expr2_0,
4672         dst: expr0_0,
4673     };
4674     let expr4_0 = C::emit(ctx, &expr3_0);
4675     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4676     return Some(expr5_0);
4677 }
4678 
4679 // Generated as internal constructor for term x64_maxsd.
4680 pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4681     let pattern0_0 = arg0;
4682     let pattern1_0 = arg1;
4683     // Rule at src/isa/x64/inst.isle line 2604.
4684     let expr0_0 = C::temp_writable_xmm(ctx);
4685     let expr1_0 = SseOpcode::Maxsd;
4686     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4687     let expr3_0 = MInst::XmmRmR {
4688         op: expr1_0,
4689         src1: pattern0_0,
4690         src2: expr2_0,
4691         dst: expr0_0,
4692     };
4693     let expr4_0 = C::emit(ctx, &expr3_0);
4694     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4695     return Some(expr5_0);
4696 }
4697 
4698 // Generated as internal constructor for term x64_maxps.
4699 pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4700     let pattern0_0 = arg0;
4701     let pattern1_0 = arg1;
4702     // Rule at src/isa/x64/inst.isle line 2611.
4703     let expr0_0 = C::temp_writable_xmm(ctx);
4704     let expr1_0 = SseOpcode::Maxps;
4705     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4706     let expr3_0 = MInst::XmmRmR {
4707         op: expr1_0,
4708         src1: pattern0_0,
4709         src2: expr2_0,
4710         dst: expr0_0,
4711     };
4712     let expr4_0 = C::emit(ctx, &expr3_0);
4713     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4714     return Some(expr5_0);
4715 }
4716 
4717 // Generated as internal constructor for term x64_maxpd.
4718 pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4719     let pattern0_0 = arg0;
4720     let pattern1_0 = arg1;
4721     // Rule at src/isa/x64/inst.isle line 2618.
4722     let expr0_0 = C::temp_writable_xmm(ctx);
4723     let expr1_0 = SseOpcode::Maxpd;
4724     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4725     let expr3_0 = MInst::XmmRmR {
4726         op: expr1_0,
4727         src1: pattern0_0,
4728         src2: expr2_0,
4729         dst: expr0_0,
4730     };
4731     let expr4_0 = C::emit(ctx, &expr3_0);
4732     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4733     return Some(expr5_0);
4734 }
4735 
4736 // Generated as internal constructor for term x64_pcmpeq.
4737 pub fn constructor_x64_pcmpeq<C: Context>(
4738     ctx: &mut C,
4739     arg0: Type,
4740     arg1: Xmm,
4741     arg2: &XmmMem,
4742 ) -> Option<Xmm> {
4743     let pattern0_0 = arg0;
4744     if pattern0_0 == I8X16 {
4745         let pattern2_0 = arg1;
4746         let pattern3_0 = arg2;
4747         // Rule at src/isa/x64/inst.isle line 2625.
4748         let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?;
4749         return Some(expr0_0);
4750     }
4751     if pattern0_0 == I16X8 {
4752         let pattern2_0 = arg1;
4753         let pattern3_0 = arg2;
4754         // Rule at src/isa/x64/inst.isle line 2626.
4755         let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?;
4756         return Some(expr0_0);
4757     }
4758     if pattern0_0 == I32X4 {
4759         let pattern2_0 = arg1;
4760         let pattern3_0 = arg2;
4761         // Rule at src/isa/x64/inst.isle line 2627.
4762         let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?;
4763         return Some(expr0_0);
4764     }
4765     if pattern0_0 == I64X2 {
4766         let pattern2_0 = arg1;
4767         let pattern3_0 = arg2;
4768         // Rule at src/isa/x64/inst.isle line 2628.
4769         let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?;
4770         return Some(expr0_0);
4771     }
4772     return None;
4773 }
4774 
4775 // Generated as internal constructor for term x64_pcmpeqb.
4776 pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4777     let pattern0_0 = arg0;
4778     let pattern1_0 = arg1;
4779     // Rule at src/isa/x64/inst.isle line 2631.
4780     let expr0_0: Type = I8X16;
4781     let expr1_0 = SseOpcode::Pcmpeqb;
4782     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4783     return Some(expr2_0);
4784 }
4785 
4786 // Generated as internal constructor for term x64_pcmpeqw.
4787 pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4788     let pattern0_0 = arg0;
4789     let pattern1_0 = arg1;
4790     // Rule at src/isa/x64/inst.isle line 2633.
4791     let expr0_0: Type = I16X8;
4792     let expr1_0 = SseOpcode::Pcmpeqw;
4793     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4794     return Some(expr2_0);
4795 }
4796 
4797 // Generated as internal constructor for term x64_pcmpeqd.
4798 pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4799     let pattern0_0 = arg0;
4800     let pattern1_0 = arg1;
4801     // Rule at src/isa/x64/inst.isle line 2635.
4802     let expr0_0: Type = I32X4;
4803     let expr1_0 = SseOpcode::Pcmpeqd;
4804     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4805     return Some(expr2_0);
4806 }
4807 
4808 // Generated as internal constructor for term x64_pcmpeqq.
4809 pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4810     let pattern0_0 = arg0;
4811     let pattern1_0 = arg1;
4812     // Rule at src/isa/x64/inst.isle line 2637.
4813     let expr0_0: Type = I64X2;
4814     let expr1_0 = SseOpcode::Pcmpeqq;
4815     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4816     return Some(expr2_0);
4817 }
4818 
4819 // Generated as internal constructor for term x64_pcmpgt.
4820 pub fn constructor_x64_pcmpgt<C: Context>(
4821     ctx: &mut C,
4822     arg0: Type,
4823     arg1: Xmm,
4824     arg2: &XmmMem,
4825 ) -> Option<Xmm> {
4826     let pattern0_0 = arg0;
4827     if pattern0_0 == I8X16 {
4828         let pattern2_0 = arg1;
4829         let pattern3_0 = arg2;
4830         // Rule at src/isa/x64/inst.isle line 2641.
4831         let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?;
4832         return Some(expr0_0);
4833     }
4834     if pattern0_0 == I16X8 {
4835         let pattern2_0 = arg1;
4836         let pattern3_0 = arg2;
4837         // Rule at src/isa/x64/inst.isle line 2642.
4838         let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?;
4839         return Some(expr0_0);
4840     }
4841     if pattern0_0 == I32X4 {
4842         let pattern2_0 = arg1;
4843         let pattern3_0 = arg2;
4844         // Rule at src/isa/x64/inst.isle line 2643.
4845         let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?;
4846         return Some(expr0_0);
4847     }
4848     if pattern0_0 == I64X2 {
4849         let pattern2_0 = arg1;
4850         let pattern3_0 = arg2;
4851         // Rule at src/isa/x64/inst.isle line 2644.
4852         let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?;
4853         return Some(expr0_0);
4854     }
4855     return None;
4856 }
4857 
4858 // Generated as internal constructor for term x64_pcmpgtb.
4859 pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4860     let pattern0_0 = arg0;
4861     let pattern1_0 = arg1;
4862     // Rule at src/isa/x64/inst.isle line 2647.
4863     let expr0_0: Type = I8X16;
4864     let expr1_0 = SseOpcode::Pcmpgtb;
4865     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4866     return Some(expr2_0);
4867 }
4868 
4869 // Generated as internal constructor for term x64_pcmpgtw.
4870 pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4871     let pattern0_0 = arg0;
4872     let pattern1_0 = arg1;
4873     // Rule at src/isa/x64/inst.isle line 2649.
4874     let expr0_0: Type = I16X8;
4875     let expr1_0 = SseOpcode::Pcmpgtw;
4876     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4877     return Some(expr2_0);
4878 }
4879 
4880 // Generated as internal constructor for term x64_pcmpgtd.
4881 pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4882     let pattern0_0 = arg0;
4883     let pattern1_0 = arg1;
4884     // Rule at src/isa/x64/inst.isle line 2651.
4885     let expr0_0: Type = I32X4;
4886     let expr1_0 = SseOpcode::Pcmpgtd;
4887     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4888     return Some(expr2_0);
4889 }
4890 
4891 // Generated as internal constructor for term x64_pcmpgtq.
4892 pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4893     let pattern0_0 = arg0;
4894     let pattern1_0 = arg1;
4895     // Rule at src/isa/x64/inst.isle line 2653.
4896     let expr0_0: Type = I64X2;
4897     let expr1_0 = SseOpcode::Pcmpgtq;
4898     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4899     return Some(expr2_0);
4900 }
4901 
4902 // Generated as internal constructor for term reg_to_xmm_mem.
4903 pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4904     let pattern0_0 = arg0;
4905     // Rule at src/isa/x64/inst.isle line 2709.
4906     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4907     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
4908     return Some(expr1_0);
4909 }
4910 
4911 // Generated as internal constructor for term xmm_to_reg_mem.
4912 pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
4913     let pattern0_0 = arg0;
4914     // Rule at src/isa/x64/inst.isle line 2712.
4915     let expr0_0 = C::xmm_new(ctx, pattern0_0);
4916     let expr1_0 = C::xmm_to_reg(ctx, expr0_0);
4917     let expr2_0 = RegMem::Reg { reg: expr1_0 };
4918     let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0);
4919     return Some(expr3_0);
4920 }
4921 
4922 // Generated as internal constructor for term writable_gpr_to_r_reg.
4923 pub fn constructor_writable_gpr_to_r_reg<C: Context>(
4924     ctx: &mut C,
4925     arg0: WritableGpr,
4926 ) -> Option<Reg> {
4927     let pattern0_0 = arg0;
4928     // Rule at src/isa/x64/inst.isle line 2716.
4929     let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0);
4930     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
4931     return Some(expr1_0);
4932 }
4933 
4934 // Generated as internal constructor for term writable_gpr_to_gpr_mem.
4935 pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
4936     ctx: &mut C,
4937     arg0: WritableGpr,
4938 ) -> Option<GprMem> {
4939     let pattern0_0 = arg0;
4940     // Rule at src/isa/x64/inst.isle line 2719.
4941     let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0);
4942     let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0);
4943     return Some(expr1_0);
4944 }
4945 
4946 // Generated as internal constructor for term writable_gpr_to_value_regs.
4947 pub fn constructor_writable_gpr_to_value_regs<C: Context>(
4948     ctx: &mut C,
4949     arg0: WritableGpr,
4950 ) -> Option<ValueRegs> {
4951     let pattern0_0 = arg0;
4952     // Rule at src/isa/x64/inst.isle line 2722.
4953     let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?;
4954     let expr1_0 = C::value_reg(ctx, expr0_0);
4955     return Some(expr1_0);
4956 }
4957 
4958 // Generated as internal constructor for term writable_xmm_to_r_reg.
4959 pub fn constructor_writable_xmm_to_r_reg<C: Context>(
4960     ctx: &mut C,
4961     arg0: WritableXmm,
4962 ) -> Option<Reg> {
4963     let pattern0_0 = arg0;
4964     // Rule at src/isa/x64/inst.isle line 2725.
4965     let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0);
4966     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
4967     return Some(expr1_0);
4968 }
4969 
4970 // Generated as internal constructor for term writable_xmm_to_xmm_mem.
4971 pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
4972     ctx: &mut C,
4973     arg0: WritableXmm,
4974 ) -> Option<XmmMem> {
4975     let pattern0_0 = arg0;
4976     // Rule at src/isa/x64/inst.isle line 2728.
4977     let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0);
4978     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
4979     return Some(expr1_0);
4980 }
4981 
4982 // Generated as internal constructor for term writable_xmm_to_value_regs.
4983 pub fn constructor_writable_xmm_to_value_regs<C: Context>(
4984     ctx: &mut C,
4985     arg0: WritableXmm,
4986 ) -> Option<ValueRegs> {
4987     let pattern0_0 = arg0;
4988     // Rule at src/isa/x64/inst.isle line 2731.
4989     let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?;
4990     let expr1_0 = C::value_reg(ctx, expr0_0);
4991     return Some(expr1_0);
4992 }
4993 
4994 // Generated as internal constructor for term synthetic_amode_to_gpr_mem.
4995 pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
4996     ctx: &mut C,
4997     arg0: &SyntheticAmode,
4998 ) -> Option<GprMem> {
4999     let pattern0_0 = arg0;
5000     // Rule at src/isa/x64/inst.isle line 2738.
5001     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5002     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
5003     return Some(expr1_0);
5004 }
5005 
5006 // Generated as internal constructor for term amode_to_gpr_mem.
5007 pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<GprMem> {
5008     let pattern0_0 = arg0;
5009     // Rule at src/isa/x64/inst.isle line 2736.
5010     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5011     let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?;
5012     return Some(expr1_0);
5013 }
5014 
5015 // Generated as internal constructor for term amode_to_xmm_mem.
5016 pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<XmmMem> {
5017     let pattern0_0 = arg0;
5018     // Rule at src/isa/x64/inst.isle line 2741.
5019     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5020     let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?;
5021     return Some(expr1_0);
5022 }
5023 
5024 // Generated as internal constructor for term synthetic_amode_to_xmm_mem.
5025 pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
5026     ctx: &mut C,
5027     arg0: &SyntheticAmode,
5028 ) -> Option<XmmMem> {
5029     let pattern0_0 = arg0;
5030     // Rule at src/isa/x64/inst.isle line 2744.
5031     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5032     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
5033     return Some(expr1_0);
5034 }
5035 
5036 // Generated as internal constructor for term lower.
5037 pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
5038     let pattern0_0 = arg0;
5039     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5040         let pattern2_0 = C::value_type(ctx, pattern1_0);
5041         if pattern2_0 == I128 {
5042             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5043                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5044                 if let &InstructionData::Unary {
5045                     opcode: ref pattern6_0,
5046                     arg: pattern6_1,
5047                 } = &pattern5_0
5048                 {
5049                     if let &Opcode::Popcnt = pattern6_0 {
5050                         // Rule at src/isa/x64/lower.isle line 1883.
5051                         let expr0_0: Type = I64;
5052                         let expr1_0 = C::put_in_regs(ctx, pattern6_1);
5053                         let expr2_0: usize = 0;
5054                         let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
5055                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5056                         let expr5_0: Type = I64;
5057                         let expr6_0 = C::put_in_regs(ctx, pattern6_1);
5058                         let expr7_0: usize = 1;
5059                         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5060                         let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?;
5061                         let expr10_0: Type = I64;
5062                         let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
5063                         let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
5064                         let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
5065                         let expr14_0: Type = I64;
5066                         let expr15_0: u64 = 0;
5067                         let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
5068                         let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
5069                         let expr18_0 = C::output(ctx, expr17_0);
5070                         return Some(expr18_0);
5071                     }
5072                 }
5073             }
5074         }
5075         if pattern2_0 == I8X16 {
5076             if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
5077                 if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) {
5078                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
5079                     if let &InstructionData::Unary {
5080                         opcode: ref pattern7_0,
5081                         arg: pattern7_1,
5082                     } = &pattern6_0
5083                     {
5084                         if let &Opcode::Popcnt = pattern7_0 {
5085                             // Rule at src/isa/x64/lower.isle line 1975.
5086                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
5087                             let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?;
5088                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
5089                             return Some(expr2_0);
5090                         }
5091                     }
5092                 }
5093             }
5094         }
5095         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
5096             if let Some(()) = C::use_lzcnt(ctx, pattern2_0) {
5097                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5098                 if let &InstructionData::Unary {
5099                     opcode: ref pattern6_0,
5100                     arg: pattern6_1,
5101                 } = &pattern5_0
5102                 {
5103                     if let &Opcode::Clz = pattern6_0 {
5104                         // Rule at src/isa/x64/lower.isle line 1791.
5105                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5106                         let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?;
5107                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5108                         return Some(expr2_0);
5109                     }
5110                 }
5111             }
5112             if let Some(()) = C::use_bmi1(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::Ctz = pattern6_0 {
5120                         // Rule at src/isa/x64/lower.isle line 1833.
5121                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5122                         let expr1_0 = constructor_x64_tzcnt(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_popcnt(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::Popcnt = pattern6_0 {
5136                         // Rule at src/isa/x64/lower.isle line 1869.
5137                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5138                         let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?;
5139                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5140                         return Some(expr2_0);
5141                     }
5142                 }
5143             }
5144         }
5145         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
5146             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5147                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5148                 if let &InstructionData::Unary {
5149                     opcode: ref pattern6_0,
5150                     arg: pattern6_1,
5151                 } = &pattern5_0
5152                 {
5153                     if let &Opcode::Popcnt = pattern6_0 {
5154                         // Rule at src/isa/x64/lower.isle line 1876.
5155                         let expr0_0: Type = I32;
5156                         let expr1_0: Type = I32;
5157                         let expr2_0 = ExtendKind::Zero;
5158                         let expr3_0 =
5159                             constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?;
5160                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5161                         let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
5162                         return Some(expr5_0);
5163                     }
5164                 }
5165             }
5166         }
5167     }
5168     let pattern0_0 = arg0;
5169     let pattern1_0 = C::inst_data(ctx, pattern0_0);
5170     match &pattern1_0 {
5171         &InstructionData::NullAry {
5172             opcode: ref pattern2_0,
5173         } => {
5174             if let &Opcode::Debugtrap = pattern2_0 {
5175                 // Rule at src/isa/x64/lower.isle line 2261.
5176                 let expr0_0 = constructor_x64_hlt(ctx)?;
5177                 let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5178                 return Some(expr1_0);
5179             }
5180         }
5181         &InstructionData::UnaryIeee32 {
5182             opcode: ref pattern2_0,
5183             imm: pattern2_1,
5184         } => {
5185             if let &Opcode::F32const = pattern2_0 {
5186                 let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1);
5187                 // Rule at src/isa/x64/lower.isle line 46.
5188                 let expr0_0: Type = F32;
5189                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5190                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5191                 return Some(expr2_0);
5192             }
5193         }
5194         &InstructionData::UnaryIeee64 {
5195             opcode: ref pattern2_0,
5196             imm: pattern2_1,
5197         } => {
5198             if let &Opcode::F64const = pattern2_0 {
5199                 let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1);
5200                 // Rule at src/isa/x64/lower.isle line 51.
5201                 let expr0_0: Type = F64;
5202                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5203                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5204                 return Some(expr2_0);
5205             }
5206         }
5207         &InstructionData::Trap {
5208             opcode: ref pattern2_0,
5209             code: ref pattern2_1,
5210         } => {
5211             match pattern2_0 {
5212                 &Opcode::Trap => {
5213                     // Rule at src/isa/x64/lower.isle line 1434.
5214                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5215                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5216                     return Some(expr1_0);
5217                 }
5218                 &Opcode::ResumableTrap => {
5219                     // Rule at src/isa/x64/lower.isle line 1439.
5220                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5221                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5222                     return Some(expr1_0);
5223                 }
5224                 _ => {}
5225             }
5226         }
5227         &InstructionData::TernaryImm8 {
5228             opcode: ref pattern2_0,
5229             args: ref pattern2_1,
5230             imm: pattern2_2,
5231         } => {
5232             if let &Opcode::Insertlane = pattern2_0 {
5233                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5234                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5235                 let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2);
5236                 // Rule at src/isa/x64/lower.isle line 1302.
5237                 let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5238                 let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1);
5239                 let expr2_0 =
5240                     constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?;
5241                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5242                 return Some(expr3_0);
5243             }
5244         }
5245         &InstructionData::FloatCompare {
5246             opcode: ref pattern2_0,
5247             args: ref pattern2_1,
5248             cond: ref pattern2_2,
5249         } => {
5250             if let &Opcode::Fcmp = pattern2_0 {
5251                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5252                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5253                 if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) {
5254                     match pattern2_2 {
5255                         &FloatCC::Equal => {
5256                             // Rule at src/isa/x64/lower.isle line 1571.
5257                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5258                             let expr1_0 = CC::NP;
5259                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5260                             let expr3_0 = CC::Z;
5261                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5262                             let expr5_0 =
5263                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5264                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5265                             let expr7_0: usize = 0;
5266                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5267                             let expr9_0: usize = 1;
5268                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5269                             let expr11_0: Type = I32;
5270                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5271                             let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?;
5272                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5273                             return Some(expr14_0);
5274                         }
5275                         &FloatCC::GreaterThan => {
5276                             // Rule at src/isa/x64/lower.isle line 1599.
5277                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5278                             let expr1_0 = CC::NBE;
5279                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5280                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5281                             let expr4_0 = C::output(ctx, expr3_0);
5282                             return Some(expr4_0);
5283                         }
5284                         &FloatCC::GreaterThanOrEqual => {
5285                             // Rule at src/isa/x64/lower.isle line 1601.
5286                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5287                             let expr1_0 = CC::NB;
5288                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5289                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5290                             let expr4_0 = C::output(ctx, expr3_0);
5291                             return Some(expr4_0);
5292                         }
5293                         &FloatCC::LessThan => {
5294                             // Rule at src/isa/x64/lower.isle line 1611.
5295                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5296                             let expr1_0 = CC::NBE;
5297                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5298                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5299                             let expr4_0 = C::output(ctx, expr3_0);
5300                             return Some(expr4_0);
5301                         }
5302                         &FloatCC::LessThanOrEqual => {
5303                             // Rule at src/isa/x64/lower.isle line 1614.
5304                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5305                             let expr1_0 = CC::NB;
5306                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5307                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5308                             let expr4_0 = C::output(ctx, expr3_0);
5309                             return Some(expr4_0);
5310                         }
5311                         &FloatCC::NotEqual => {
5312                             // Rule at src/isa/x64/lower.isle line 1580.
5313                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5314                             let expr1_0 = CC::P;
5315                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5316                             let expr3_0 = CC::NZ;
5317                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
5318                             let expr5_0 =
5319                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
5320                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
5321                             let expr7_0: usize = 0;
5322                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5323                             let expr9_0: usize = 1;
5324                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
5325                             let expr11_0: Type = I32;
5326                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
5327                             let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?;
5328                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
5329                             return Some(expr14_0);
5330                         }
5331                         &FloatCC::Ordered => {
5332                             // Rule at src/isa/x64/lower.isle line 1591.
5333                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5334                             let expr1_0 = CC::NP;
5335                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5336                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5337                             let expr4_0 = C::output(ctx, expr3_0);
5338                             return Some(expr4_0);
5339                         }
5340                         &FloatCC::OrderedNotEqual => {
5341                             // Rule at src/isa/x64/lower.isle line 1595.
5342                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5343                             let expr1_0 = CC::NZ;
5344                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5345                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5346                             let expr4_0 = C::output(ctx, expr3_0);
5347                             return Some(expr4_0);
5348                         }
5349                         &FloatCC::Unordered => {
5350                             // Rule at src/isa/x64/lower.isle line 1593.
5351                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5352                             let expr1_0 = CC::P;
5353                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5354                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5355                             let expr4_0 = C::output(ctx, expr3_0);
5356                             return Some(expr4_0);
5357                         }
5358                         &FloatCC::UnorderedOrEqual => {
5359                             // Rule at src/isa/x64/lower.isle line 1597.
5360                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5361                             let expr1_0 = CC::Z;
5362                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5363                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5364                             let expr4_0 = C::output(ctx, expr3_0);
5365                             return Some(expr4_0);
5366                         }
5367                         &FloatCC::UnorderedOrGreaterThan => {
5368                             // Rule at src/isa/x64/lower.isle line 1617.
5369                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5370                             let expr1_0 = CC::B;
5371                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5372                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5373                             let expr4_0 = C::output(ctx, expr3_0);
5374                             return Some(expr4_0);
5375                         }
5376                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5377                             // Rule at src/isa/x64/lower.isle line 1620.
5378                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
5379                             let expr1_0 = CC::BE;
5380                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5381                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5382                             let expr4_0 = C::output(ctx, expr3_0);
5383                             return Some(expr4_0);
5384                         }
5385                         &FloatCC::UnorderedOrLessThan => {
5386                             // Rule at src/isa/x64/lower.isle line 1603.
5387                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5388                             let expr1_0 = CC::B;
5389                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5390                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5391                             let expr4_0 = C::output(ctx, expr3_0);
5392                             return Some(expr4_0);
5393                         }
5394                         &FloatCC::UnorderedOrLessThanOrEqual => {
5395                             // Rule at src/isa/x64/lower.isle line 1605.
5396                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
5397                             let expr1_0 = CC::BE;
5398                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
5399                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
5400                             let expr4_0 = C::output(ctx, expr3_0);
5401                             return Some(expr4_0);
5402                         }
5403                         _ => {}
5404                     }
5405                 }
5406                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5407                     match pattern2_2 {
5408                         &FloatCC::Equal => {
5409                             // Rule at src/isa/x64/lower.isle line 1628.
5410                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5411                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5412                             let expr2_0 = FcmpImm::Equal;
5413                             let expr3_0 =
5414                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5415                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5416                             return Some(expr4_0);
5417                         }
5418                         &FloatCC::GreaterThan => {
5419                             // Rule at src/isa/x64/lower.isle line 1648.
5420                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5421                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5422                             let expr2_0 = FcmpImm::LessThan;
5423                             let expr3_0 =
5424                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5425                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5426                             return Some(expr4_0);
5427                         }
5428                         &FloatCC::GreaterThanOrEqual => {
5429                             // Rule at src/isa/x64/lower.isle line 1650.
5430                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5431                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5432                             let expr2_0 = FcmpImm::LessThanOrEqual;
5433                             let expr3_0 =
5434                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5435                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5436                             return Some(expr4_0);
5437                         }
5438                         &FloatCC::LessThan => {
5439                             // Rule at src/isa/x64/lower.isle line 1632.
5440                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5441                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5442                             let expr2_0 = FcmpImm::LessThan;
5443                             let expr3_0 =
5444                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5445                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5446                             return Some(expr4_0);
5447                         }
5448                         &FloatCC::LessThanOrEqual => {
5449                             // Rule at src/isa/x64/lower.isle line 1634.
5450                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5451                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5452                             let expr2_0 = FcmpImm::LessThanOrEqual;
5453                             let expr3_0 =
5454                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5455                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5456                             return Some(expr4_0);
5457                         }
5458                         &FloatCC::NotEqual => {
5459                             // Rule at src/isa/x64/lower.isle line 1630.
5460                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5461                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5462                             let expr2_0 = FcmpImm::NotEqual;
5463                             let expr3_0 =
5464                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5465                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5466                             return Some(expr4_0);
5467                         }
5468                         &FloatCC::Ordered => {
5469                             // Rule at src/isa/x64/lower.isle line 1636.
5470                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5471                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5472                             let expr2_0 = FcmpImm::Ordered;
5473                             let expr3_0 =
5474                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5475                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5476                             return Some(expr4_0);
5477                         }
5478                         &FloatCC::Unordered => {
5479                             // Rule at src/isa/x64/lower.isle line 1638.
5480                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5481                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5482                             let expr2_0 = FcmpImm::Unordered;
5483                             let expr3_0 =
5484                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5485                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5486                             return Some(expr4_0);
5487                         }
5488                         &FloatCC::UnorderedOrGreaterThan => {
5489                             // Rule at src/isa/x64/lower.isle line 1640.
5490                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5491                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5492                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5493                             let expr3_0 =
5494                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5495                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5496                             return Some(expr4_0);
5497                         }
5498                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
5499                             // Rule at src/isa/x64/lower.isle line 1642.
5500                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5501                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5502                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5503                             let expr3_0 =
5504                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5505                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5506                             return Some(expr4_0);
5507                         }
5508                         &FloatCC::UnorderedOrLessThan => {
5509                             // Rule at src/isa/x64/lower.isle line 1652.
5510                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5511                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5512                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
5513                             let expr3_0 =
5514                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5515                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5516                             return Some(expr4_0);
5517                         }
5518                         &FloatCC::UnorderedOrLessThanOrEqual => {
5519                             // Rule at src/isa/x64/lower.isle line 1654.
5520                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5521                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5522                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
5523                             let expr3_0 =
5524                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
5525                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
5526                             return Some(expr4_0);
5527                         }
5528                         _ => {}
5529                     }
5530                 }
5531             }
5532         }
5533         &InstructionData::IntCompare {
5534             opcode: ref pattern2_0,
5535             args: ref pattern2_1,
5536             cond: ref pattern2_2,
5537         } => {
5538             if let &Opcode::Icmp = pattern2_0 {
5539                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5540                 let pattern5_0 = C::value_type(ctx, pattern4_0);
5541                 if pattern5_0 == I128 {
5542                     match pattern2_2 {
5543                         &IntCC::Equal => {
5544                             // Rule at src/isa/x64/lower.isle line 1522.
5545                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5546                             let expr1_0: usize = 0;
5547                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5548                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5549                             let expr4_0: usize = 1;
5550                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5551                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5552                             let expr7_0: usize = 0;
5553                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5554                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5555                             let expr10_0: usize = 1;
5556                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5557                             let expr12_0 = OperandSize::Size64;
5558                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5559                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5560                             let expr15_0 = CC::Z;
5561                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5562                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5563                             let expr18_0 = OperandSize::Size64;
5564                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5565                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5566                             let expr21_0 = CC::Z;
5567                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5568                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5569                             let expr24_0: Type = I64;
5570                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5571                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5572                             let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?;
5573                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5574                             let expr29_0 = OperandSize::Size64;
5575                             let expr30_0: u32 = 1;
5576                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5577                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5578                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5579                             let expr34_0 =
5580                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5581                             let expr35_0 = CC::NZ;
5582                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5583                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5584                             let expr38_0 = C::output(ctx, expr37_0);
5585                             return Some(expr38_0);
5586                         }
5587                         &IntCC::NotEqual => {
5588                             // Rule at src/isa/x64/lower.isle line 1541.
5589                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
5590                             let expr1_0: usize = 0;
5591                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5592                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
5593                             let expr4_0: usize = 1;
5594                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
5595                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
5596                             let expr7_0: usize = 0;
5597                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5598                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
5599                             let expr10_0: usize = 1;
5600                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
5601                             let expr12_0 = OperandSize::Size64;
5602                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
5603                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
5604                             let expr15_0 = CC::NZ;
5605                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
5606                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
5607                             let expr18_0 = OperandSize::Size64;
5608                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
5609                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
5610                             let expr21_0 = CC::NZ;
5611                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
5612                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
5613                             let expr24_0: Type = I64;
5614                             let expr25_0 = C::gpr_new(ctx, expr17_0);
5615                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
5616                             let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?;
5617                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
5618                             let expr29_0 = OperandSize::Size64;
5619                             let expr30_0: u32 = 1;
5620                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
5621                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
5622                             let expr33_0 = C::gpr_new(ctx, expr28_0);
5623                             let expr34_0 =
5624                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
5625                             let expr35_0 = CC::NZ;
5626                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
5627                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
5628                             let expr38_0 = C::output(ctx, expr37_0);
5629                             return Some(expr38_0);
5630                         }
5631                         _ => {}
5632                     }
5633                 }
5634                 if pattern5_0 == I64X2 {
5635                     match pattern2_2 {
5636                         &IntCC::SignedGreaterThanOrEqual => {
5637                             // Rule at src/isa/x64/lower.isle line 1507.
5638                             let expr0_0: Type = I64X2;
5639                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5640                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5641                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5642                             let expr4_0: Type = I64X2;
5643                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5644                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5645                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5646                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5647                             return Some(expr8_0);
5648                         }
5649                         &IntCC::SignedLessThanOrEqual => {
5650                             // Rule at src/isa/x64/lower.isle line 1511.
5651                             let expr0_0: Type = I64X2;
5652                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5653                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5654                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
5655                             let expr4_0: Type = I64X2;
5656                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
5657                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
5658                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
5659                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
5660                             return Some(expr8_0);
5661                         }
5662                         _ => {}
5663                     }
5664                 }
5665                 if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) {
5666                     // Rule at src/isa/x64/lower.isle line 1447.
5667                     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0);
5668                     let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?;
5669                     let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
5670                     let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
5671                     let expr4_0 = C::intcc_to_cc(ctx, pattern2_2);
5672                     let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5673                     let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5674                     let expr7_0 = C::output(ctx, expr6_0);
5675                     return Some(expr7_0);
5676                 }
5677                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
5678                     match pattern2_2 {
5679                         &IntCC::Equal => {
5680                             // Rule at src/isa/x64/lower.isle line 1456.
5681                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5682                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5683                             let expr2_0 =
5684                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5685                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5686                             return Some(expr3_0);
5687                         }
5688                         &IntCC::NotEqual => {
5689                             // Rule at src/isa/x64/lower.isle line 1460.
5690                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5691                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5692                             let expr2_0 =
5693                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
5694                             let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5695                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
5696                             let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?;
5697                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5698                             return Some(expr6_0);
5699                         }
5700                         &IntCC::SignedGreaterThan => {
5701                             // Rule at src/isa/x64/lower.isle line 1467.
5702                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5703                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5704                             let expr2_0 =
5705                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5706                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5707                             return Some(expr3_0);
5708                         }
5709                         &IntCC::SignedGreaterThanOrEqual => {
5710                             // Rule at src/isa/x64/lower.isle line 1492.
5711                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5712                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5713                             let expr2_0 =
5714                                 constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?;
5715                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5716                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5717                             let expr5_0 =
5718                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5719                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5720                             return Some(expr6_0);
5721                         }
5722                         &IntCC::SignedLessThan => {
5723                             // Rule at src/isa/x64/lower.isle line 1469.
5724                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5725                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
5726                             let expr2_0 =
5727                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
5728                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
5729                             return Some(expr3_0);
5730                         }
5731                         &IntCC::SignedLessThanOrEqual => {
5732                             // Rule at src/isa/x64/lower.isle line 1495.
5733                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5734                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5735                             let expr2_0 =
5736                                 constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?;
5737                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5738                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5739                             let expr5_0 =
5740                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5741                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5742                             return Some(expr6_0);
5743                         }
5744                         &IntCC::UnsignedGreaterThan => {
5745                             // Rule at src/isa/x64/lower.isle line 1471.
5746                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5747                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5748                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5749                             let expr3_0 =
5750                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5751                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5752                             let expr5_0 =
5753                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5754                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5755                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5756                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5757                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5758                             return Some(expr9_0);
5759                         }
5760                         &IntCC::UnsignedGreaterThanOrEqual => {
5761                             // Rule at src/isa/x64/lower.isle line 1498.
5762                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5763                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5764                             let expr2_0 =
5765                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5766                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5767                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5768                             let expr5_0 =
5769                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5770                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5771                             return Some(expr6_0);
5772                         }
5773                         &IntCC::UnsignedLessThan => {
5774                             // Rule at src/isa/x64/lower.isle line 1481.
5775                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5776                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
5777                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5778                             let expr3_0 =
5779                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?;
5780                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
5781                             let expr5_0 =
5782                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5783                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
5784                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
5785                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
5786                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
5787                             return Some(expr9_0);
5788                         }
5789                         &IntCC::UnsignedLessThanOrEqual => {
5790                             // Rule at src/isa/x64/lower.isle line 1501.
5791                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5792                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
5793                             let expr2_0 =
5794                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?;
5795                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
5796                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
5797                             let expr5_0 =
5798                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
5799                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
5800                             return Some(expr6_0);
5801                         }
5802                         _ => {}
5803                     }
5804                 }
5805             }
5806         }
5807         &InstructionData::Unary {
5808             opcode: ref pattern2_0,
5809             arg: pattern2_1,
5810         } => {
5811             match pattern2_0 {
5812                 &Opcode::IsNull => {
5813                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5814                     if pattern4_0 == R64 {
5815                         // Rule at src/isa/x64/lower.isle line 2104.
5816                         let expr0_0 = OperandSize::Size64;
5817                         let expr1_0: u32 = 0;
5818                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5819                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5820                         let expr4_0 = CC::Z;
5821                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5822                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5823                         let expr7_0 = C::output(ctx, expr6_0);
5824                         return Some(expr7_0);
5825                     }
5826                 }
5827                 &Opcode::IsInvalid => {
5828                     let pattern4_0 = C::value_type(ctx, pattern2_1);
5829                     if pattern4_0 == R64 {
5830                         // Rule at src/isa/x64/lower.isle line 2112.
5831                         let expr0_0 = OperandSize::Size64;
5832                         let expr1_0: u32 = 4294967295;
5833                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
5834                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
5835                         let expr4_0 = CC::Z;
5836                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
5837                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
5838                         let expr7_0 = C::output(ctx, expr6_0);
5839                         return Some(expr7_0);
5840                     }
5841                 }
5842                 _ => {}
5843             }
5844         }
5845         _ => {}
5846     }
5847     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5848         let pattern2_0 = C::value_type(ctx, pattern1_0);
5849         if pattern2_0 == B128 {
5850             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5851             match &pattern4_0 {
5852                 &InstructionData::UnaryBool {
5853                     opcode: ref pattern5_0,
5854                     imm: pattern5_1,
5855                 } => {
5856                     if let &Opcode::Bconst = pattern5_0 {
5857                         if pattern5_1 == true {
5858                             // Rule at src/isa/x64/lower.isle line 39.
5859                             let expr0_0: Type = B64;
5860                             let expr1_0: u64 = 1;
5861                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5862                             let expr3_0: Type = B64;
5863                             let expr4_0: u64 = 0;
5864                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5865                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5866                             let expr7_0 = C::output(ctx, expr6_0);
5867                             return Some(expr7_0);
5868                         }
5869                         if pattern5_1 == false {
5870                             // Rule at src/isa/x64/lower.isle line 34.
5871                             let expr0_0: Type = B64;
5872                             let expr1_0: u64 = 0;
5873                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
5874                             let expr3_0: Type = B64;
5875                             let expr4_0: u64 = 0;
5876                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
5877                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
5878                             let expr7_0 = C::output(ctx, expr6_0);
5879                             return Some(expr7_0);
5880                         }
5881                     }
5882                 }
5883                 &InstructionData::Binary {
5884                     opcode: ref pattern5_0,
5885                     args: ref pattern5_1,
5886                 } => {
5887                     match pattern5_0 {
5888                         &Opcode::Band => {
5889                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5890                             // Rule at src/isa/x64/lower.isle line 344.
5891                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
5892                             let expr1_0: usize = 0;
5893                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
5894                             let expr3_0: usize = 1;
5895                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
5896                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
5897                             let expr6_0: Type = I64;
5898                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
5899                             let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?;
5900                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
5901                             let expr10_0 = C::output(ctx, expr9_0);
5902                             return Some(expr10_0);
5903                         }
5904                         &Opcode::Bor => {
5905                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5906                             // Rule at src/isa/x64/lower.isle line 410.
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_or(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::Bxor => {
5921                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
5922                             // Rule at src/isa/x64/lower.isle line 468.
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_xor(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                         _ => {}
5937                     }
5938                 }
5939                 &InstructionData::Unary {
5940                     opcode: ref pattern5_0,
5941                     arg: pattern5_1,
5942                 } => {
5943                     if let &Opcode::Bnot = pattern5_0 {
5944                         // Rule at src/isa/x64/lower.isle line 1269.
5945                         let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
5946                         let expr1_0 = C::output(ctx, expr0_0);
5947                         return Some(expr1_0);
5948                     }
5949                 }
5950                 _ => {}
5951             }
5952         }
5953         if pattern2_0 == I8 {
5954             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5955             if let &InstructionData::Unary {
5956                 opcode: ref pattern5_0,
5957                 arg: pattern5_1,
5958             } = &pattern4_0
5959             {
5960                 if let &Opcode::Bitrev = pattern5_0 {
5961                     // Rule at src/isa/x64/lower.isle line 2026.
5962                     let expr0_0: Type = I32;
5963                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
5964                     let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?;
5965                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
5966                     return Some(expr3_0);
5967                 }
5968             }
5969         }
5970         if pattern2_0 == I16 {
5971             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5972             if let &InstructionData::Unary {
5973                 opcode: ref pattern5_0,
5974                 arg: pattern5_1,
5975             } = &pattern4_0
5976             {
5977                 if let &Opcode::Bitrev = pattern5_0 {
5978                     // Rule at src/isa/x64/lower.isle line 2029.
5979                     let expr0_0: Type = I32;
5980                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
5981                     let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?;
5982                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
5983                     return Some(expr3_0);
5984                 }
5985             }
5986         }
5987         if pattern2_0 == I32 {
5988             let pattern4_0 = C::inst_data(ctx, pattern0_0);
5989             if let &InstructionData::Unary {
5990                 opcode: ref pattern5_0,
5991                 arg: pattern5_1,
5992             } = &pattern4_0
5993             {
5994                 if let &Opcode::Bitrev = pattern5_0 {
5995                     // Rule at src/isa/x64/lower.isle line 2032.
5996                     let expr0_0: Type = I32;
5997                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
5998                     let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?;
5999                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6000                     return Some(expr3_0);
6001                 }
6002             }
6003         }
6004         if pattern2_0 == I64 {
6005             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6006             if let &InstructionData::Unary {
6007                 opcode: ref pattern5_0,
6008                 arg: pattern5_1,
6009             } = &pattern4_0
6010             {
6011                 match pattern5_0 {
6012                     &Opcode::Bitrev => {
6013                         // Rule at src/isa/x64/lower.isle line 2035.
6014                         let expr0_0: Type = I64;
6015                         let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6016                         let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?;
6017                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6018                         return Some(expr3_0);
6019                     }
6020                     &Opcode::Uextend => {
6021                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
6022                             if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
6023                                 let pattern9_0 = C::value_type(ctx, pattern8_0);
6024                                 if pattern9_0 == I32 {
6025                                     let pattern11_0 = C::inst_data(ctx, pattern7_0);
6026                                     match &pattern11_0 {
6027                                         &InstructionData::Binary {
6028                                             opcode: ref pattern12_0,
6029                                             args: ref pattern12_1,
6030                                         } => {
6031                                             match pattern12_0 {
6032                                                 &Opcode::Iadd => {
6033                                                     let (pattern14_0, pattern14_1) =
6034                                                         C::unpack_value_array_2(ctx, pattern12_1);
6035                                                     // Rule at src/isa/x64/lower.isle line 2151.
6036                                                     let expr0_0 =
6037                                                         constructor_output_value(ctx, pattern5_1)?;
6038                                                     return Some(expr0_0);
6039                                                 }
6040                                                 &Opcode::Isub => {
6041                                                     let (pattern14_0, pattern14_1) =
6042                                                         C::unpack_value_array_2(ctx, pattern12_1);
6043                                                     // Rule at src/isa/x64/lower.isle line 2157.
6044                                                     let expr0_0 =
6045                                                         constructor_output_value(ctx, pattern5_1)?;
6046                                                     return Some(expr0_0);
6047                                                 }
6048                                                 &Opcode::Imul => {
6049                                                     let (pattern14_0, pattern14_1) =
6050                                                         C::unpack_value_array_2(ctx, pattern12_1);
6051                                                     // Rule at src/isa/x64/lower.isle line 2160.
6052                                                     let expr0_0 =
6053                                                         constructor_output_value(ctx, pattern5_1)?;
6054                                                     return Some(expr0_0);
6055                                                 }
6056                                                 &Opcode::IaddIfcout => {
6057                                                     let (pattern14_0, pattern14_1) =
6058                                                         C::unpack_value_array_2(ctx, pattern12_1);
6059                                                     // Rule at src/isa/x64/lower.isle line 2154.
6060                                                     let expr0_0 =
6061                                                         constructor_output_value(ctx, pattern5_1)?;
6062                                                     return Some(expr0_0);
6063                                                 }
6064                                                 &Opcode::Band => {
6065                                                     let (pattern14_0, pattern14_1) =
6066                                                         C::unpack_value_array_2(ctx, pattern12_1);
6067                                                     // Rule at src/isa/x64/lower.isle line 2163.
6068                                                     let expr0_0 =
6069                                                         constructor_output_value(ctx, pattern5_1)?;
6070                                                     return Some(expr0_0);
6071                                                 }
6072                                                 &Opcode::Bor => {
6073                                                     let (pattern14_0, pattern14_1) =
6074                                                         C::unpack_value_array_2(ctx, pattern12_1);
6075                                                     // Rule at src/isa/x64/lower.isle line 2166.
6076                                                     let expr0_0 =
6077                                                         constructor_output_value(ctx, pattern5_1)?;
6078                                                     return Some(expr0_0);
6079                                                 }
6080                                                 &Opcode::Bxor => {
6081                                                     let (pattern14_0, pattern14_1) =
6082                                                         C::unpack_value_array_2(ctx, pattern12_1);
6083                                                     // Rule at src/isa/x64/lower.isle line 2169.
6084                                                     let expr0_0 =
6085                                                         constructor_output_value(ctx, pattern5_1)?;
6086                                                     return Some(expr0_0);
6087                                                 }
6088                                                 &Opcode::Ishl => {
6089                                                     let (pattern14_0, pattern14_1) =
6090                                                         C::unpack_value_array_2(ctx, pattern12_1);
6091                                                     // Rule at src/isa/x64/lower.isle line 2172.
6092                                                     let expr0_0 =
6093                                                         constructor_output_value(ctx, pattern5_1)?;
6094                                                     return Some(expr0_0);
6095                                                 }
6096                                                 &Opcode::Ushr => {
6097                                                     let (pattern14_0, pattern14_1) =
6098                                                         C::unpack_value_array_2(ctx, pattern12_1);
6099                                                     // Rule at src/isa/x64/lower.isle line 2175.
6100                                                     let expr0_0 =
6101                                                         constructor_output_value(ctx, pattern5_1)?;
6102                                                     return Some(expr0_0);
6103                                                 }
6104                                                 _ => {}
6105                                             }
6106                                         }
6107                                         &InstructionData::Load {
6108                                             opcode: ref pattern12_0,
6109                                             arg: pattern12_1,
6110                                             flags: pattern12_2,
6111                                             offset: pattern12_3,
6112                                         } => {
6113                                             if let &Opcode::Uload32 = pattern12_0 {
6114                                                 // Rule at src/isa/x64/lower.isle line 2178.
6115                                                 let expr0_0 =
6116                                                     constructor_output_value(ctx, pattern5_1)?;
6117                                                 return Some(expr0_0);
6118                                             }
6119                                         }
6120                                         _ => {}
6121                                     }
6122                                 }
6123                             }
6124                         }
6125                         let pattern7_0 = C::value_type(ctx, pattern5_1);
6126                         if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6127                             // Rule at src/isa/x64/lower.isle line 2133.
6128                             let expr0_0: Type = I64;
6129                             let expr1_0 = ExtendKind::Zero;
6130                             let expr2_0 =
6131                                 constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6132                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
6133                             return Some(expr3_0);
6134                         }
6135                     }
6136                     _ => {}
6137                 }
6138             }
6139         }
6140         if pattern2_0 == I128 {
6141             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6142             match &pattern4_0 {
6143                 &InstructionData::UnaryImm {
6144                     opcode: ref pattern5_0,
6145                     imm: pattern5_1,
6146                 } => {
6147                     if let &Opcode::Iconst = pattern5_0 {
6148                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
6149                         // Rule at src/isa/x64/lower.isle line 15.
6150                         let expr0_0: Type = I64;
6151                         let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?;
6152                         let expr2_0: Type = I64;
6153                         let expr3_0: u64 = 0;
6154                         let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?;
6155                         let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0);
6156                         let expr6_0 = C::output(ctx, expr5_0);
6157                         return Some(expr6_0);
6158                     }
6159                 }
6160                 &InstructionData::Binary {
6161                     opcode: ref pattern5_0,
6162                     args: ref pattern5_1,
6163                 } => {
6164                     match pattern5_0 {
6165                         &Opcode::Iadd => {
6166                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6167                             // Rule at src/isa/x64/lower.isle line 111.
6168                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6169                             let expr1_0: usize = 0;
6170                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6171                             let expr3_0: usize = 1;
6172                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6173                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6174                             let expr6_0: usize = 0;
6175                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6176                             let expr8_0: usize = 1;
6177                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6178                             let expr10_0: Type = I64;
6179                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6180                             let expr12_0 = constructor_x64_add_with_flags_paired(
6181                                 ctx, expr10_0, expr2_0, &expr11_0,
6182                             )?;
6183                             let expr13_0: Type = I64;
6184                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6185                             let expr15_0 =
6186                                 constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6187                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6188                             let expr17_0 = C::output(ctx, expr16_0);
6189                             return Some(expr17_0);
6190                         }
6191                         &Opcode::Isub => {
6192                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6193                             // Rule at src/isa/x64/lower.isle line 257.
6194                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6195                             let expr1_0: usize = 0;
6196                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6197                             let expr3_0: usize = 1;
6198                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6199                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6200                             let expr6_0: usize = 0;
6201                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6202                             let expr8_0: usize = 1;
6203                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6204                             let expr10_0: Type = I64;
6205                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6206                             let expr12_0 = constructor_x64_sub_with_flags_paired(
6207                                 ctx, expr10_0, expr2_0, &expr11_0,
6208                             )?;
6209                             let expr13_0: Type = I64;
6210                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6211                             let expr15_0 =
6212                                 constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
6213                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
6214                             let expr17_0 = C::output(ctx, expr16_0);
6215                             return Some(expr17_0);
6216                         }
6217                         &Opcode::Imul => {
6218                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6219                             // Rule at src/isa/x64/lower.isle line 957.
6220                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6221                             let expr1_0: usize = 0;
6222                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6223                             let expr3_0: usize = 1;
6224                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6225                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6226                             let expr6_0: usize = 0;
6227                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6228                             let expr8_0: usize = 1;
6229                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6230                             let expr10_0: Type = I64;
6231                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6232                             let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?;
6233                             let expr13_0: Type = I64;
6234                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6235                             let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?;
6236                             let expr16_0: Type = I64;
6237                             let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0);
6238                             let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?;
6239                             let expr19_0: Type = I64;
6240                             let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0);
6241                             let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?;
6242                             let expr22_0: usize = 0;
6243                             let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?;
6244                             let expr24_0: usize = 1;
6245                             let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?;
6246                             let expr26_0: Type = I64;
6247                             let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0);
6248                             let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?;
6249                             let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?;
6250                             let expr30_0 = C::output(ctx, expr29_0);
6251                             return Some(expr30_0);
6252                         }
6253                         &Opcode::Band => {
6254                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6255                             // Rule at src/isa/x64/lower.isle line 334.
6256                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6257                             let expr1_0: usize = 0;
6258                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6259                             let expr3_0: usize = 1;
6260                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6261                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6262                             let expr6_0: usize = 0;
6263                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6264                             let expr8_0: usize = 1;
6265                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6266                             let expr10_0: Type = I64;
6267                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6268                             let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?;
6269                             let expr13_0: Type = I64;
6270                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6271                             let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?;
6272                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6273                             let expr17_0 = C::output(ctx, expr16_0);
6274                             return Some(expr17_0);
6275                         }
6276                         &Opcode::Bor => {
6277                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6278                             // Rule at src/isa/x64/lower.isle line 407.
6279                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6280                             let expr1_0 = C::put_in_regs(ctx, pattern7_1);
6281                             let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?;
6282                             let expr3_0 = C::output(ctx, expr2_0);
6283                             return Some(expr3_0);
6284                         }
6285                         &Opcode::Bxor => {
6286                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6287                             // Rule at src/isa/x64/lower.isle line 458.
6288                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6289                             let expr1_0: usize = 0;
6290                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6291                             let expr3_0: usize = 1;
6292                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6293                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
6294                             let expr6_0: usize = 0;
6295                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
6296                             let expr8_0: usize = 1;
6297                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
6298                             let expr10_0: Type = I64;
6299                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6300                             let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?;
6301                             let expr13_0: Type = I64;
6302                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6303                             let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?;
6304                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
6305                             let expr17_0 = C::output(ctx, expr16_0);
6306                             return Some(expr17_0);
6307                         }
6308                         &Opcode::Rotl => {
6309                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6310                             // Rule at src/isa/x64/lower.isle line 830.
6311                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6312                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6313                             let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?;
6314                             let expr3_0: Type = I64;
6315                             let expr4_0: Type = I64;
6316                             let expr5_0: u64 = 128;
6317                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6318                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6319                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6320                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6321                             let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?;
6322                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6323                             let expr12_0 = C::output(ctx, expr11_0);
6324                             return Some(expr12_0);
6325                         }
6326                         &Opcode::Rotr => {
6327                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6328                             // Rule at src/isa/x64/lower.isle line 870.
6329                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
6330                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6331                             let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?;
6332                             let expr3_0: Type = I64;
6333                             let expr4_0: Type = I64;
6334                             let expr5_0: u64 = 128;
6335                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6336                             let expr7_0 = C::gpr_new(ctx, expr6_0);
6337                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
6338                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
6339                             let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?;
6340                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
6341                             let expr12_0 = C::output(ctx, expr11_0);
6342                             return Some(expr12_0);
6343                         }
6344                         &Opcode::Ishl => {
6345                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6346                             // Rule at src/isa/x64/lower.isle line 522.
6347                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6348                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6349                             let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?;
6350                             let expr3_0 = C::output(ctx, expr2_0);
6351                             return Some(expr3_0);
6352                         }
6353                         &Opcode::Ushr => {
6354                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6355                             // Rule at src/isa/x64/lower.isle line 623.
6356                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6357                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6358                             let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?;
6359                             let expr3_0 = C::output(ctx, expr2_0);
6360                             return Some(expr3_0);
6361                         }
6362                         &Opcode::Sshr => {
6363                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6364                             // Rule at src/isa/x64/lower.isle line 728.
6365                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
6366                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
6367                             let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?;
6368                             let expr3_0 = C::output(ctx, expr2_0);
6369                             return Some(expr3_0);
6370                         }
6371                         _ => {}
6372                     }
6373                 }
6374                 &InstructionData::Unary {
6375                     opcode: ref pattern5_0,
6376                     arg: pattern5_1,
6377                 } => {
6378                     match pattern5_0 {
6379                         &Opcode::Bnot => {
6380                             // Rule at src/isa/x64/lower.isle line 1266.
6381                             let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
6382                             let expr1_0 = C::output(ctx, expr0_0);
6383                             return Some(expr1_0);
6384                         }
6385                         &Opcode::Bitrev => {
6386                             // Rule at src/isa/x64/lower.isle line 2038.
6387                             let expr0_0: Type = I64;
6388                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6389                             let expr2_0: usize = 1;
6390                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6391                             let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?;
6392                             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
6393                             let expr6_0: Type = I64;
6394                             let expr7_0 = C::put_in_regs(ctx, pattern5_1);
6395                             let expr8_0: usize = 0;
6396                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?;
6397                             let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?;
6398                             let expr11_0 = C::gpr_to_reg(ctx, expr10_0);
6399                             let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0);
6400                             let expr13_0 = C::output(ctx, expr12_0);
6401                             return Some(expr13_0);
6402                         }
6403                         &Opcode::Clz => {
6404                             // Rule at src/isa/x64/lower.isle line 1808.
6405                             let expr0_0: Type = I64;
6406                             let expr1_0: Type = I64;
6407                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6408                             let expr3_0: usize = 1;
6409                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6410                             let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?;
6411                             let expr6_0: Type = I64;
6412                             let expr7_0: Type = I64;
6413                             let expr8_0: Type = I64;
6414                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6415                             let expr10_0: usize = 0;
6416                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6417                             let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?;
6418                             let expr13_0: u32 = 64;
6419                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6420                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6421                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6422                             let expr17_0 = OperandSize::Size64;
6423                             let expr18_0: u32 = 64;
6424                             let expr19_0 =
6425                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6426                             let expr20_0: Type = I64;
6427                             let expr21_0 = CC::NZ;
6428                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0);
6429                             let expr23_0 =
6430                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?;
6431                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6432                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6433                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6434                             let expr27_0: Type = I64;
6435                             let expr28_0: u64 = 0;
6436                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6437                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6438                             let expr31_0 = C::output(ctx, expr30_0);
6439                             return Some(expr31_0);
6440                         }
6441                         &Opcode::Ctz => {
6442                             // Rule at src/isa/x64/lower.isle line 1850.
6443                             let expr0_0: Type = I64;
6444                             let expr1_0: Type = I64;
6445                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
6446                             let expr3_0: usize = 0;
6447                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
6448                             let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?;
6449                             let expr6_0: Type = I64;
6450                             let expr7_0: Type = I64;
6451                             let expr8_0: Type = I64;
6452                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
6453                             let expr10_0: usize = 1;
6454                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6455                             let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?;
6456                             let expr13_0: u32 = 64;
6457                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
6458                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
6459                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
6460                             let expr17_0 = OperandSize::Size64;
6461                             let expr18_0: u32 = 64;
6462                             let expr19_0 =
6463                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
6464                             let expr20_0: Type = I64;
6465                             let expr21_0 = CC::Z;
6466                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0);
6467                             let expr23_0 =
6468                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?;
6469                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
6470                             let expr25_0 = C::gpr_new(ctx, expr24_0);
6471                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
6472                             let expr27_0: Type = I64;
6473                             let expr28_0: u64 = 0;
6474                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
6475                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
6476                             let expr31_0 = C::output(ctx, expr30_0);
6477                             return Some(expr31_0);
6478                         }
6479                         &Opcode::Popcnt => {
6480                             // Rule at src/isa/x64/lower.isle line 1902.
6481                             let expr0_0: Type = I64;
6482                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
6483                             let expr2_0: usize = 0;
6484                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
6485                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
6486                             let expr5_0: Type = I64;
6487                             let expr6_0 = C::put_in_regs(ctx, pattern5_1);
6488                             let expr7_0: usize = 1;
6489                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6490                             let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?;
6491                             let expr10_0: Type = I64;
6492                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
6493                             let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
6494                             let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
6495                             let expr14_0: Type = I64;
6496                             let expr15_0: u64 = 0;
6497                             let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
6498                             let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
6499                             let expr18_0 = C::output(ctx, expr17_0);
6500                             return Some(expr18_0);
6501                         }
6502                         &Opcode::Bint => {
6503                             // Rule at src/isa/x64/lower.isle line 2253.
6504                             let expr0_0: Type = I64;
6505                             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
6506                             let expr2_0: u32 = 1;
6507                             let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
6508                             let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0);
6509                             let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?;
6510                             let expr6_0 = C::gpr_to_reg(ctx, expr5_0);
6511                             let expr7_0: Type = I64;
6512                             let expr8_0: u64 = 0;
6513                             let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?;
6514                             let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0);
6515                             let expr11_0 = C::output(ctx, expr10_0);
6516                             return Some(expr11_0);
6517                         }
6518                         &Opcode::Uextend => {
6519                             let pattern7_0 = C::value_type(ctx, pattern5_1);
6520                             if pattern7_0 == I64 {
6521                                 // Rule at src/isa/x64/lower.isle line 2125.
6522                                 let expr0_0 = C::put_in_reg(ctx, pattern5_1);
6523                                 let expr1_0: Type = I64;
6524                                 let expr2_0: u64 = 0;
6525                                 let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
6526                                 let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
6527                                 let expr5_0 = C::output(ctx, expr4_0);
6528                                 return Some(expr5_0);
6529                             }
6530                             if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
6531                                 // Rule at src/isa/x64/lower.isle line 2129.
6532                                 let expr0_0: Type = I64;
6533                                 let expr1_0 = ExtendKind::Zero;
6534                                 let expr2_0 =
6535                                     constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
6536                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
6537                                 let expr4_0: Type = I64;
6538                                 let expr5_0: u64 = 0;
6539                                 let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
6540                                 let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0);
6541                                 let expr8_0 = C::output(ctx, expr7_0);
6542                                 return Some(expr8_0);
6543                             }
6544                         }
6545                         _ => {}
6546                     }
6547                 }
6548                 &InstructionData::BinaryImm64 {
6549                     opcode: ref pattern5_0,
6550                     arg: pattern5_1,
6551                     imm: pattern5_2,
6552                 } => {
6553                     if let &Opcode::IaddImm = pattern5_0 {
6554                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
6555                         // Rule at src/isa/x64/lower.isle line 210.
6556                         let expr0_0 = C::put_in_regs(ctx, pattern5_1);
6557                         let expr1_0: usize = 0;
6558                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6559                         let expr3_0: usize = 1;
6560                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6561                         let expr5_0: Type = I64;
6562                         let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?;
6563                         let expr7_0 = C::gpr_new(ctx, expr6_0);
6564                         let expr8_0: Type = I64;
6565                         let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
6566                         let expr10_0 =
6567                             constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?;
6568                         let expr11_0: Type = I64;
6569                         let expr12_0: u32 = 0;
6570                         let expr13_0 = RegMemImm::Imm { simm32: expr12_0 };
6571                         let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0);
6572                         let expr15_0 =
6573                             constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?;
6574                         let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?;
6575                         let expr17_0 = C::output(ctx, expr16_0);
6576                         return Some(expr17_0);
6577                     }
6578                 }
6579                 _ => {}
6580             }
6581         }
6582         if pattern2_0 == F32 {
6583             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6584             match &pattern4_0 {
6585                 &InstructionData::Binary {
6586                     opcode: ref pattern5_0,
6587                     args: ref pattern5_1,
6588                 } => {
6589                     match pattern5_0 {
6590                         &Opcode::Fadd => {
6591                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6592                             // Rule at src/isa/x64/lower.isle line 2276.
6593                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6594                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6595                             let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?;
6596                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6597                             return Some(expr3_0);
6598                         }
6599                         &Opcode::Fsub => {
6600                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6601                             // Rule at src/isa/x64/lower.isle line 2287.
6602                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6603                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6604                             let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?;
6605                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6606                             return Some(expr3_0);
6607                         }
6608                         &Opcode::Fmul => {
6609                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6610                             // Rule at src/isa/x64/lower.isle line 2298.
6611                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6612                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6613                             let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?;
6614                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6615                             return Some(expr3_0);
6616                         }
6617                         &Opcode::Fdiv => {
6618                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6619                             // Rule at src/isa/x64/lower.isle line 2309.
6620                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6621                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6622                             let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?;
6623                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6624                             return Some(expr3_0);
6625                         }
6626                         &Opcode::Fmin => {
6627                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6628                             // Rule at src/isa/x64/lower.isle line 2320.
6629                             let expr0_0: Type = F32;
6630                             let expr1_0: bool = true;
6631                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6632                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6633                             let expr4_0 = constructor_xmm_min_max_seq(
6634                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6635                             )?;
6636                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6637                             return Some(expr5_0);
6638                         }
6639                         &Opcode::FminPseudo => {
6640                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6641                             // Rule at src/isa/x64/lower.isle line 2489.
6642                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6643                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6644                             let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?;
6645                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6646                             return Some(expr3_0);
6647                         }
6648                         &Opcode::Fmax => {
6649                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6650                             // Rule at src/isa/x64/lower.isle line 2392.
6651                             let expr0_0: Type = F32;
6652                             let expr1_0: bool = false;
6653                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6654                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6655                             let expr4_0 = constructor_xmm_min_max_seq(
6656                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6657                             )?;
6658                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6659                             return Some(expr5_0);
6660                         }
6661                         &Opcode::FmaxPseudo => {
6662                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6663                             // Rule at src/isa/x64/lower.isle line 2500.
6664                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6665                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6666                             let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?;
6667                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6668                             return Some(expr3_0);
6669                         }
6670                         _ => {}
6671                     }
6672                 }
6673                 &InstructionData::Load {
6674                     opcode: ref pattern5_0,
6675                     arg: pattern5_1,
6676                     flags: pattern5_2,
6677                     offset: pattern5_3,
6678                 } => {
6679                     if let &Opcode::Load = pattern5_0 {
6680                         // Rule at src/isa/x64/lower.isle line 2543.
6681                         let expr0_0 =
6682                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6683                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6684                         let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?;
6685                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6686                         return Some(expr3_0);
6687                     }
6688                 }
6689                 _ => {}
6690             }
6691         }
6692         if pattern2_0 == F64 {
6693             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6694             match &pattern4_0 {
6695                 &InstructionData::Binary {
6696                     opcode: ref pattern5_0,
6697                     args: ref pattern5_1,
6698                 } => {
6699                     match pattern5_0 {
6700                         &Opcode::Fadd => {
6701                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6702                             // Rule at src/isa/x64/lower.isle line 2278.
6703                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6704                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6705                             let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?;
6706                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6707                             return Some(expr3_0);
6708                         }
6709                         &Opcode::Fsub => {
6710                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6711                             // Rule at src/isa/x64/lower.isle line 2289.
6712                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6713                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6714                             let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?;
6715                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6716                             return Some(expr3_0);
6717                         }
6718                         &Opcode::Fmul => {
6719                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6720                             // Rule at src/isa/x64/lower.isle line 2300.
6721                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6722                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6723                             let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?;
6724                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6725                             return Some(expr3_0);
6726                         }
6727                         &Opcode::Fdiv => {
6728                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6729                             // Rule at src/isa/x64/lower.isle line 2311.
6730                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6731                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6732                             let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?;
6733                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6734                             return Some(expr3_0);
6735                         }
6736                         &Opcode::Fmin => {
6737                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6738                             // Rule at src/isa/x64/lower.isle line 2322.
6739                             let expr0_0: Type = F64;
6740                             let expr1_0: bool = true;
6741                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6742                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6743                             let expr4_0 = constructor_xmm_min_max_seq(
6744                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6745                             )?;
6746                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6747                             return Some(expr5_0);
6748                         }
6749                         &Opcode::FminPseudo => {
6750                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6751                             // Rule at src/isa/x64/lower.isle line 2491.
6752                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6753                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6754                             let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?;
6755                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6756                             return Some(expr3_0);
6757                         }
6758                         &Opcode::Fmax => {
6759                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6760                             // Rule at src/isa/x64/lower.isle line 2394.
6761                             let expr0_0: Type = F64;
6762                             let expr1_0: bool = false;
6763                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6764                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6765                             let expr4_0 = constructor_xmm_min_max_seq(
6766                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
6767                             )?;
6768                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
6769                             return Some(expr5_0);
6770                         }
6771                         &Opcode::FmaxPseudo => {
6772                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6773                             // Rule at src/isa/x64/lower.isle line 2502.
6774                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
6775                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6776                             let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?;
6777                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6778                             return Some(expr3_0);
6779                         }
6780                         _ => {}
6781                     }
6782                 }
6783                 &InstructionData::Load {
6784                     opcode: ref pattern5_0,
6785                     arg: pattern5_1,
6786                     flags: pattern5_2,
6787                     offset: pattern5_3,
6788                 } => {
6789                     if let &Opcode::Load = pattern5_0 {
6790                         // Rule at src/isa/x64/lower.isle line 2545.
6791                         let expr0_0 =
6792                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
6793                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
6794                         let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?;
6795                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6796                         return Some(expr3_0);
6797                     }
6798                 }
6799                 _ => {}
6800             }
6801         }
6802         if pattern2_0 == I8X16 {
6803             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6804             match &pattern4_0 {
6805                 &InstructionData::Binary {
6806                     opcode: ref pattern5_0,
6807                     args: ref pattern5_1,
6808                 } => {
6809                     match pattern5_0 {
6810                         &Opcode::Imin => {
6811                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6812                             // Rule at src/isa/x64/lower.isle line 1401.
6813                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6814                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6815                             let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?;
6816                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6817                             return Some(expr3_0);
6818                         }
6819                         &Opcode::Umin => {
6820                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6821                             // Rule at src/isa/x64/lower.isle line 1423.
6822                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6823                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6824                             let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?;
6825                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6826                             return Some(expr3_0);
6827                         }
6828                         &Opcode::Imax => {
6829                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6830                             // Rule at src/isa/x64/lower.isle line 1390.
6831                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6832                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6833                             let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?;
6834                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6835                             return Some(expr3_0);
6836                         }
6837                         &Opcode::Umax => {
6838                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6839                             // Rule at src/isa/x64/lower.isle line 1412.
6840                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6841                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6842                             let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?;
6843                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6844                             return Some(expr3_0);
6845                         }
6846                         &Opcode::Ishl => {
6847                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6848                             // Rule at src/isa/x64/lower.isle line 534.
6849                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6850                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6851                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6852                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
6853                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6854                             let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?;
6855                             let expr6_0: Type = I8X16;
6856                             let expr7_0 = ExtKind::None;
6857                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6858                             let expr9_0: Type = I8X16;
6859                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6860                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6861                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6862                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6863                             return Some(expr13_0);
6864                         }
6865                         &Opcode::Ushr => {
6866                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6867                             // Rule at src/isa/x64/lower.isle line 633.
6868                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6869                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6870                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
6871                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
6872                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6873                             let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?;
6874                             let expr6_0: Type = I8X16;
6875                             let expr7_0 = ExtKind::None;
6876                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
6877                             let expr9_0: Type = I8X16;
6878                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
6879                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
6880                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
6881                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
6882                             return Some(expr13_0);
6883                         }
6884                         &Opcode::Sshr => {
6885                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6886                             let pattern8_0 = C::value_type(ctx, pattern7_1);
6887                             // Rule at src/isa/x64/lower.isle line 749.
6888                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6889                             let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6890                             let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?;
6891                             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
6892                             let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?;
6893                             let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
6894                             let expr6_0 =
6895                                 constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?;
6896                             let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?;
6897                             let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?;
6898                             let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0);
6899                             let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?;
6900                             let expr11_0 = constructor_output_xmm(ctx, expr10_0)?;
6901                             return Some(expr11_0);
6902                         }
6903                         _ => {}
6904                     }
6905                 }
6906                 &InstructionData::Unary {
6907                     opcode: ref pattern5_0,
6908                     arg: pattern5_1,
6909                 } => {
6910                     match pattern5_0 {
6911                         &Opcode::Ineg => {
6912                             // Rule at src/isa/x64/lower.isle line 889.
6913                             let expr0_0: Type = I8X16;
6914                             let expr1_0: u64 = 0;
6915                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
6916                             let expr3_0 = C::xmm_new(ctx, expr2_0);
6917                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
6918                             let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?;
6919                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6920                             return Some(expr6_0);
6921                         }
6922                         &Opcode::Iabs => {
6923                             // Rule at src/isa/x64/lower.isle line 1210.
6924                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
6925                             let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?;
6926                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
6927                             return Some(expr2_0);
6928                         }
6929                         &Opcode::Popcnt => {
6930                             // Rule at src/isa/x64/lower.isle line 2009.
6931                             let expr0_0 = C::popcount_4bit_table(ctx);
6932                             let expr1_0: Type = I8X16;
6933                             let expr2_0 = C::popcount_low_mask(ctx);
6934                             let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?;
6935                             let expr4_0: Type = I8X16;
6936                             let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6937                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6938                             let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?;
6939                             let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
6940                             let expr9_0: u32 = 4;
6941                             let expr10_0 = RegMemImm::Imm { simm32: expr9_0 };
6942                             let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?;
6943                             let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?;
6944                             let expr13_0: Type = I8X16;
6945                             let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6946                             let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?;
6947                             let expr16_0: Type = I8X16;
6948                             let expr17_0 = C::popcount_4bit_table(ctx);
6949                             let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?;
6950                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
6951                             let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?;
6952                             let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0);
6953                             let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?;
6954                             let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0);
6955                             let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?;
6956                             let expr25_0 = constructor_output_xmm(ctx, expr24_0)?;
6957                             return Some(expr25_0);
6958                         }
6959                         _ => {}
6960                     }
6961                 }
6962                 _ => {}
6963             }
6964         }
6965         if pattern2_0 == I16X8 {
6966             let pattern4_0 = C::inst_data(ctx, pattern0_0);
6967             match &pattern4_0 {
6968                 &InstructionData::Binary {
6969                     opcode: ref pattern5_0,
6970                     args: ref pattern5_1,
6971                 } => {
6972                     match pattern5_0 {
6973                         &Opcode::Imin => {
6974                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6975                             // Rule at src/isa/x64/lower.isle line 1404.
6976                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6977                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6978                             let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?;
6979                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6980                             return Some(expr3_0);
6981                         }
6982                         &Opcode::Umin => {
6983                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6984                             // Rule at src/isa/x64/lower.isle line 1426.
6985                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6986                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6987                             let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?;
6988                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6989                             return Some(expr3_0);
6990                         }
6991                         &Opcode::Imax => {
6992                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
6993                             // Rule at src/isa/x64/lower.isle line 1393.
6994                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
6995                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
6996                             let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?;
6997                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6998                             return Some(expr3_0);
6999                         }
7000                         &Opcode::Umax => {
7001                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7002                             // Rule at src/isa/x64/lower.isle line 1415.
7003                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7004                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7005                             let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?;
7006                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7007                             return Some(expr3_0);
7008                         }
7009                         &Opcode::Ishl => {
7010                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7011                             // Rule at src/isa/x64/lower.isle line 576.
7012                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7013                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7014                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7015                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
7016                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7017                             return Some(expr4_0);
7018                         }
7019                         &Opcode::Ushr => {
7020                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7021                             // Rule at src/isa/x64/lower.isle line 678.
7022                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7023                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7024                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7025                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
7026                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7027                             return Some(expr4_0);
7028                         }
7029                         &Opcode::Sshr => {
7030                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7031                             // Rule at src/isa/x64/lower.isle line 776.
7032                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7033                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7034                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7035                             let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?;
7036                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7037                             return Some(expr4_0);
7038                         }
7039                         _ => {}
7040                     }
7041                 }
7042                 &InstructionData::Unary {
7043                     opcode: ref pattern5_0,
7044                     arg: pattern5_1,
7045                 } => {
7046                     match pattern5_0 {
7047                         &Opcode::Ineg => {
7048                             // Rule at src/isa/x64/lower.isle line 892.
7049                             let expr0_0: Type = I16X8;
7050                             let expr1_0: u64 = 0;
7051                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7052                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7053                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7054                             let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?;
7055                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7056                             return Some(expr6_0);
7057                         }
7058                         &Opcode::Iabs => {
7059                             // Rule at src/isa/x64/lower.isle line 1213.
7060                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7061                             let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?;
7062                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7063                             return Some(expr2_0);
7064                         }
7065                         _ => {}
7066                     }
7067                 }
7068                 &InstructionData::Load {
7069                     opcode: ref pattern5_0,
7070                     arg: pattern5_1,
7071                     flags: pattern5_2,
7072                     offset: pattern5_3,
7073                 } => {
7074                     match pattern5_0 {
7075                         &Opcode::Uload8x8 => {
7076                             // Rule at src/isa/x64/lower.isle line 2558.
7077                             let expr0_0 =
7078                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7079                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7080                             let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?;
7081                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7082                             return Some(expr3_0);
7083                         }
7084                         &Opcode::Sload8x8 => {
7085                             // Rule at src/isa/x64/lower.isle line 2556.
7086                             let expr0_0 =
7087                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7088                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7089                             let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?;
7090                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7091                             return Some(expr3_0);
7092                         }
7093                         _ => {}
7094                     }
7095                 }
7096                 _ => {}
7097             }
7098         }
7099         if pattern2_0 == I32X4 {
7100             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7101             match &pattern4_0 {
7102                 &InstructionData::Binary {
7103                     opcode: ref pattern5_0,
7104                     args: ref pattern5_1,
7105                 } => {
7106                     match pattern5_0 {
7107                         &Opcode::Imin => {
7108                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7109                             // Rule at src/isa/x64/lower.isle line 1407.
7110                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7111                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7112                             let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?;
7113                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7114                             return Some(expr3_0);
7115                         }
7116                         &Opcode::Umin => {
7117                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7118                             // Rule at src/isa/x64/lower.isle line 1429.
7119                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7120                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7121                             let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?;
7122                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7123                             return Some(expr3_0);
7124                         }
7125                         &Opcode::Imax => {
7126                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7127                             // Rule at src/isa/x64/lower.isle line 1396.
7128                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7129                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7130                             let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?;
7131                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7132                             return Some(expr3_0);
7133                         }
7134                         &Opcode::Umax => {
7135                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7136                             // Rule at src/isa/x64/lower.isle line 1418.
7137                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7138                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7139                             let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?;
7140                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7141                             return Some(expr3_0);
7142                         }
7143                         &Opcode::Ishl => {
7144                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7145                             // Rule at src/isa/x64/lower.isle line 579.
7146                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7147                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7148                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7149                             let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?;
7150                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7151                             return Some(expr4_0);
7152                         }
7153                         &Opcode::Ushr => {
7154                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7155                             // Rule at src/isa/x64/lower.isle line 681.
7156                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7157                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7158                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7159                             let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?;
7160                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7161                             return Some(expr4_0);
7162                         }
7163                         &Opcode::Sshr => {
7164                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7165                             // Rule at src/isa/x64/lower.isle line 779.
7166                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7167                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7168                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7169                             let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?;
7170                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7171                             return Some(expr4_0);
7172                         }
7173                         &Opcode::WideningPairwiseDotProductS => {
7174                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7175                             // Rule at src/isa/x64/lower.isle line 2266.
7176                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7177                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7178                             let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?;
7179                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7180                             return Some(expr3_0);
7181                         }
7182                         _ => {}
7183                     }
7184                 }
7185                 &InstructionData::Unary {
7186                     opcode: ref pattern5_0,
7187                     arg: pattern5_1,
7188                 } => {
7189                     match pattern5_0 {
7190                         &Opcode::Ineg => {
7191                             // Rule at src/isa/x64/lower.isle line 895.
7192                             let expr0_0: Type = I32X4;
7193                             let expr1_0: u64 = 0;
7194                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7195                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7196                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7197                             let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?;
7198                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7199                             return Some(expr6_0);
7200                         }
7201                         &Opcode::Iabs => {
7202                             // Rule at src/isa/x64/lower.isle line 1216.
7203                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7204                             let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?;
7205                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7206                             return Some(expr2_0);
7207                         }
7208                         _ => {}
7209                     }
7210                 }
7211                 &InstructionData::Load {
7212                     opcode: ref pattern5_0,
7213                     arg: pattern5_1,
7214                     flags: pattern5_2,
7215                     offset: pattern5_3,
7216                 } => {
7217                     match pattern5_0 {
7218                         &Opcode::Uload16x4 => {
7219                             // Rule at src/isa/x64/lower.isle line 2562.
7220                             let expr0_0 =
7221                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7222                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7223                             let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?;
7224                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7225                             return Some(expr3_0);
7226                         }
7227                         &Opcode::Sload16x4 => {
7228                             // Rule at src/isa/x64/lower.isle line 2560.
7229                             let expr0_0 =
7230                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7231                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7232                             let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?;
7233                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7234                             return Some(expr3_0);
7235                         }
7236                         _ => {}
7237                     }
7238                 }
7239                 _ => {}
7240             }
7241         }
7242         if pattern2_0 == I64X2 {
7243             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7244             match &pattern4_0 {
7245                 &InstructionData::Binary {
7246                     opcode: ref pattern5_0,
7247                     args: ref pattern5_1,
7248                 } => {
7249                     match pattern5_0 {
7250                         &Opcode::Ishl => {
7251                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7252                             // Rule at src/isa/x64/lower.isle line 582.
7253                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7254                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7255                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7256                             let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?;
7257                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7258                             return Some(expr4_0);
7259                         }
7260                         &Opcode::Ushr => {
7261                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7262                             // Rule at src/isa/x64/lower.isle line 684.
7263                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7264                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
7265                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
7266                             let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?;
7267                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
7268                             return Some(expr4_0);
7269                         }
7270                         &Opcode::Sshr => {
7271                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7272                             // Rule at src/isa/x64/lower.isle line 790.
7273                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7274                             let expr1_0: Type = I64;
7275                             let expr2_0: u8 = 0;
7276                             let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?;
7277                             let expr4_0: Type = I64;
7278                             let expr5_0: u8 = 1;
7279                             let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?;
7280                             let expr7_0: Type = I64;
7281                             let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0);
7282                             let expr9_0: Type = I64;
7283                             let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?;
7284                             let expr11_0: Type = I64;
7285                             let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?;
7286                             let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0);
7287                             let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
7288                             let expr15_0 =
7289                                 constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?;
7290                             let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
7291                             return Some(expr16_0);
7292                         }
7293                         _ => {}
7294                     }
7295                 }
7296                 &InstructionData::Unary {
7297                     opcode: ref pattern5_0,
7298                     arg: pattern5_1,
7299                 } => {
7300                     match pattern5_0 {
7301                         &Opcode::Ineg => {
7302                             // Rule at src/isa/x64/lower.isle line 898.
7303                             let expr0_0: Type = I64X2;
7304                             let expr1_0: u64 = 0;
7305                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7306                             let expr3_0 = C::xmm_new(ctx, expr2_0);
7307                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
7308                             let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?;
7309                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
7310                             return Some(expr6_0);
7311                         }
7312                         &Opcode::Iabs => {
7313                             // Rule at src/isa/x64/lower.isle line 1230.
7314                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7315                             let expr1_0: Type = I64X2;
7316                             let expr2_0: u64 = 0;
7317                             let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
7318                             let expr4_0 = C::xmm_new(ctx, expr3_0);
7319                             let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7320                             let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?;
7321                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
7322                             let expr8_0 =
7323                                 constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?;
7324                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7325                             return Some(expr9_0);
7326                         }
7327                         _ => {}
7328                     }
7329                 }
7330                 &InstructionData::Load {
7331                     opcode: ref pattern5_0,
7332                     arg: pattern5_1,
7333                     flags: pattern5_2,
7334                     offset: pattern5_3,
7335                 } => {
7336                     match pattern5_0 {
7337                         &Opcode::Uload32x2 => {
7338                             // Rule at src/isa/x64/lower.isle line 2566.
7339                             let expr0_0 =
7340                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7341                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7342                             let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?;
7343                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7344                             return Some(expr3_0);
7345                         }
7346                         &Opcode::Sload32x2 => {
7347                             // Rule at src/isa/x64/lower.isle line 2564.
7348                             let expr0_0 =
7349                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7350                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7351                             let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?;
7352                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7353                             return Some(expr3_0);
7354                         }
7355                         _ => {}
7356                     }
7357                 }
7358                 _ => {}
7359             }
7360         }
7361         if pattern2_0 == F32X4 {
7362             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7363             match &pattern4_0 {
7364                 &InstructionData::Binary {
7365                     opcode: ref pattern5_0,
7366                     args: ref pattern5_1,
7367                 } => {
7368                     match pattern5_0 {
7369                         &Opcode::Fadd => {
7370                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7371                             // Rule at src/isa/x64/lower.isle line 2280.
7372                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7373                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7374                             let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?;
7375                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7376                             return Some(expr3_0);
7377                         }
7378                         &Opcode::Fsub => {
7379                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7380                             // Rule at src/isa/x64/lower.isle line 2291.
7381                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7382                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7383                             let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?;
7384                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7385                             return Some(expr3_0);
7386                         }
7387                         &Opcode::Fmul => {
7388                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7389                             // Rule at src/isa/x64/lower.isle line 2302.
7390                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7391                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7392                             let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?;
7393                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7394                             return Some(expr3_0);
7395                         }
7396                         &Opcode::Fdiv => {
7397                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7398                             // Rule at src/isa/x64/lower.isle line 2313.
7399                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7400                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7401                             let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?;
7402                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7403                             return Some(expr3_0);
7404                         }
7405                         &Opcode::Fmin => {
7406                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7407                             // Rule at src/isa/x64/lower.isle line 2337.
7408                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7409                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7410                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7411                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7412                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7413                             let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?;
7414                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7415                             let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?;
7416                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7417                             let expr9_0 = FcmpImm::Unordered;
7418                             let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?;
7419                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7420                             let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?;
7421                             let expr13_0: u32 = 10;
7422                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7423                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7424                             let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?;
7425                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7426                             let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?;
7427                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7428                             return Some(expr19_0);
7429                         }
7430                         &Opcode::FminPseudo => {
7431                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7432                             // Rule at src/isa/x64/lower.isle line 2493.
7433                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7434                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7435                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
7436                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7437                             return Some(expr3_0);
7438                         }
7439                         &Opcode::Fmax => {
7440                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7441                             // Rule at src/isa/x64/lower.isle line 2400.
7442                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7443                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7444                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7445                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7446                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7447                             let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?;
7448                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7449                             let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?;
7450                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7451                             let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?;
7452                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7453                             let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?;
7454                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7455                             let expr13_0 = FcmpImm::Unordered;
7456                             let expr14_0 =
7457                                 constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?;
7458                             let expr15_0: u32 = 10;
7459                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7460                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7461                             let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?;
7462                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7463                             let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?;
7464                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7465                             return Some(expr21_0);
7466                         }
7467                         &Opcode::FmaxPseudo => {
7468                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7469                             // Rule at src/isa/x64/lower.isle line 2504.
7470                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7471                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7472                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
7473                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7474                             return Some(expr3_0);
7475                         }
7476                         _ => {}
7477                     }
7478                 }
7479                 &InstructionData::Unary {
7480                     opcode: ref pattern5_0,
7481                     arg: pattern5_1,
7482                 } => {
7483                     if let &Opcode::Fabs = pattern5_0 {
7484                         // Rule at src/isa/x64/lower.isle line 1238.
7485                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7486                         let expr1_0: Type = F32X4;
7487                         let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7488                         let expr3_0: u32 = 1;
7489                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7490                         let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7491                         let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?;
7492                         let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7493                         let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?;
7494                         let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7495                         return Some(expr9_0);
7496                     }
7497                 }
7498                 &InstructionData::Load {
7499                     opcode: ref pattern5_0,
7500                     arg: pattern5_1,
7501                     flags: pattern5_2,
7502                     offset: pattern5_3,
7503                 } => {
7504                     if let &Opcode::Load = pattern5_0 {
7505                         // Rule at src/isa/x64/lower.isle line 2547.
7506                         let expr0_0 =
7507                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7508                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7509                         let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?;
7510                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7511                         return Some(expr3_0);
7512                     }
7513                 }
7514                 _ => {}
7515             }
7516         }
7517         if pattern2_0 == F64X2 {
7518             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7519             match &pattern4_0 {
7520                 &InstructionData::Binary {
7521                     opcode: ref pattern5_0,
7522                     args: ref pattern5_1,
7523                 } => {
7524                     match pattern5_0 {
7525                         &Opcode::Fadd => {
7526                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7527                             // Rule at src/isa/x64/lower.isle line 2282.
7528                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7529                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7530                             let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?;
7531                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7532                             return Some(expr3_0);
7533                         }
7534                         &Opcode::Fsub => {
7535                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7536                             // Rule at src/isa/x64/lower.isle line 2293.
7537                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7538                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7539                             let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?;
7540                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7541                             return Some(expr3_0);
7542                         }
7543                         &Opcode::Fmul => {
7544                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7545                             // Rule at src/isa/x64/lower.isle line 2304.
7546                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7547                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7548                             let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?;
7549                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7550                             return Some(expr3_0);
7551                         }
7552                         &Opcode::Fdiv => {
7553                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7554                             // Rule at src/isa/x64/lower.isle line 2315.
7555                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7556                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7557                             let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?;
7558                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7559                             return Some(expr3_0);
7560                         }
7561                         &Opcode::Fmin => {
7562                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7563                             // Rule at src/isa/x64/lower.isle line 2380.
7564                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7565                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7566                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7567                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7568                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7569                             let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?;
7570                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7571                             let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?;
7572                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7573                             let expr9_0 = FcmpImm::Unordered;
7574                             let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?;
7575                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
7576                             let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?;
7577                             let expr13_0: u32 = 13;
7578                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7579                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
7580                             let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?;
7581                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
7582                             let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?;
7583                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
7584                             return Some(expr19_0);
7585                         }
7586                         &Opcode::FminPseudo => {
7587                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7588                             // Rule at src/isa/x64/lower.isle line 2495.
7589                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7590                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7591                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
7592                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7593                             return Some(expr3_0);
7594                         }
7595                         &Opcode::Fmax => {
7596                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7597                             // Rule at src/isa/x64/lower.isle line 2443.
7598                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7599                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7600                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7601                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7602                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7603                             let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?;
7604                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
7605                             let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?;
7606                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7607                             let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?;
7608                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
7609                             let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?;
7610                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
7611                             let expr13_0 = FcmpImm::Unordered;
7612                             let expr14_0 =
7613                                 constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?;
7614                             let expr15_0: u32 = 13;
7615                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
7616                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
7617                             let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?;
7618                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
7619                             let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?;
7620                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
7621                             return Some(expr21_0);
7622                         }
7623                         &Opcode::FmaxPseudo => {
7624                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7625                             // Rule at src/isa/x64/lower.isle line 2506.
7626                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7627                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7628                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
7629                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7630                             return Some(expr3_0);
7631                         }
7632                         _ => {}
7633                     }
7634                 }
7635                 &InstructionData::Unary {
7636                     opcode: ref pattern5_0,
7637                     arg: pattern5_1,
7638                 } => {
7639                     if let &Opcode::Fabs = pattern5_0 {
7640                         // Rule at src/isa/x64/lower.isle line 1244.
7641                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7642                         let expr1_0: Type = F64X2;
7643                         let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
7644                         let expr3_0: u32 = 1;
7645                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7646                         let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
7647                         let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?;
7648                         let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
7649                         let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?;
7650                         let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
7651                         return Some(expr9_0);
7652                     }
7653                 }
7654                 &InstructionData::Load {
7655                     opcode: ref pattern5_0,
7656                     arg: pattern5_1,
7657                     flags: pattern5_2,
7658                     offset: pattern5_3,
7659                 } => {
7660                     if let &Opcode::Load = pattern5_0 {
7661                         // Rule at src/isa/x64/lower.isle line 2549.
7662                         let expr0_0 =
7663                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7664                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7665                         let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?;
7666                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7667                         return Some(expr3_0);
7668                     }
7669                 }
7670                 _ => {}
7671             }
7672         }
7673         let pattern3_0 = C::inst_data(ctx, pattern0_0);
7674         match &pattern3_0 {
7675             &InstructionData::NullAry {
7676                 opcode: ref pattern4_0,
7677             } => {
7678                 if let &Opcode::Null = pattern4_0 {
7679                     // Rule at src/isa/x64/lower.isle line 56.
7680                     let expr0_0: u64 = 0;
7681                     let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?;
7682                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
7683                     return Some(expr2_0);
7684                 }
7685             }
7686             &InstructionData::Binary {
7687                 opcode: ref pattern4_0,
7688                 args: ref pattern4_1,
7689             } => {
7690                 if let &Opcode::BandNot = pattern4_0 {
7691                     let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
7692                     // Rule at src/isa/x64/lower.isle line 1205.
7693                     let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?;
7694                     let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?;
7695                     let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?;
7696                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7697                     return Some(expr3_0);
7698                 }
7699             }
7700             &InstructionData::Ternary {
7701                 opcode: ref pattern4_0,
7702                 args: ref pattern4_1,
7703             } => {
7704                 if let &Opcode::Select = pattern4_0 {
7705                     let (pattern6_0, pattern6_1, pattern6_2) =
7706                         C::unpack_value_array_3(ctx, pattern4_1);
7707                     if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
7708                         let pattern8_0 = C::inst_data(ctx, pattern7_0);
7709                         match &pattern8_0 {
7710                             &InstructionData::FloatCompare {
7711                                 opcode: ref pattern9_0,
7712                                 args: ref pattern9_1,
7713                                 cond: ref pattern9_2,
7714                             } => {
7715                                 if let &Opcode::Fcmp = pattern9_0 {
7716                                     let (pattern11_0, pattern11_1) =
7717                                         C::unpack_value_array_2(ctx, pattern9_1);
7718                                     match pattern9_2 {
7719                                         &FloatCC::Equal => {
7720                                             // Rule at src/isa/x64/lower.isle line 1742.
7721                                             let expr0_0 = constructor_x64_ucomis(
7722                                                 ctx,
7723                                                 pattern11_0,
7724                                                 pattern11_1,
7725                                             )?;
7726                                             let expr1_0 = CC::NZ;
7727                                             let expr2_0 = CC::P;
7728                                             let expr3_0 = constructor_cmove_or_from_values(
7729                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2,
7730                                                 pattern6_1,
7731                                             )?;
7732                                             let expr4_0 =
7733                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7734                                             let expr5_0 = C::output(ctx, expr4_0);
7735                                             return Some(expr5_0);
7736                                         }
7737                                         &FloatCC::GreaterThan => {
7738                                             // Rule at src/isa/x64/lower.isle line 1694.
7739                                             let expr0_0 = constructor_x64_ucomis(
7740                                                 ctx,
7741                                                 pattern11_1,
7742                                                 pattern11_0,
7743                                             )?;
7744                                             let expr1_0 = CC::NBE;
7745                                             let expr2_0 = constructor_cmove_from_values(
7746                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7747                                             )?;
7748                                             let expr3_0 =
7749                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7750                                             let expr4_0 = C::output(ctx, expr3_0);
7751                                             return Some(expr4_0);
7752                                         }
7753                                         &FloatCC::GreaterThanOrEqual => {
7754                                             // Rule at src/isa/x64/lower.isle line 1697.
7755                                             let expr0_0 = constructor_x64_ucomis(
7756                                                 ctx,
7757                                                 pattern11_1,
7758                                                 pattern11_0,
7759                                             )?;
7760                                             let expr1_0 = CC::NB;
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::LessThan => {
7770                                             // Rule at src/isa/x64/lower.isle line 1717.
7771                                             let expr0_0 = constructor_x64_ucomis(
7772                                                 ctx,
7773                                                 pattern11_0,
7774                                                 pattern11_1,
7775                                             )?;
7776                                             let expr1_0 = CC::NBE;
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::LessThanOrEqual => {
7786                                             // Rule at src/isa/x64/lower.isle line 1720.
7787                                             let expr0_0 = constructor_x64_ucomis(
7788                                                 ctx,
7789                                                 pattern11_0,
7790                                                 pattern11_1,
7791                                             )?;
7792                                             let expr1_0 = CC::NB;
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::NotEqual => {
7802                                             // Rule at src/isa/x64/lower.isle line 1745.
7803                                             let expr0_0 = constructor_x64_ucomis(
7804                                                 ctx,
7805                                                 pattern11_0,
7806                                                 pattern11_1,
7807                                             )?;
7808                                             let expr1_0 = CC::NZ;
7809                                             let expr2_0 = CC::P;
7810                                             let expr3_0 = constructor_cmove_or_from_values(
7811                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1,
7812                                                 pattern6_2,
7813                                             )?;
7814                                             let expr4_0 =
7815                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
7816                                             let expr5_0 = C::output(ctx, expr4_0);
7817                                             return Some(expr5_0);
7818                                         }
7819                                         &FloatCC::Ordered => {
7820                                             // Rule at src/isa/x64/lower.isle line 1688.
7821                                             let expr0_0 = constructor_x64_ucomis(
7822                                                 ctx,
7823                                                 pattern11_1,
7824                                                 pattern11_0,
7825                                             )?;
7826                                             let expr1_0 = CC::NP;
7827                                             let expr2_0 = constructor_cmove_from_values(
7828                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
7829                                             )?;
7830                                             let expr3_0 =
7831                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
7832                                             let expr4_0 = C::output(ctx, expr3_0);
7833                                             return Some(expr4_0);
7834                                         }
7835                                         &FloatCC::Unordered => {
7836                                             // Rule at src/isa/x64/lower.isle line 1691.
7837                                             let expr0_0 = constructor_x64_ucomis(
7838                                                 ctx,
7839                                                 pattern11_1,
7840                                                 pattern11_0,
7841                                             )?;
7842                                             let expr1_0 = CC::P;
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::UnorderedOrGreaterThan => {
7852                                             // Rule at src/isa/x64/lower.isle line 1723.
7853                                             let expr0_0 = constructor_x64_ucomis(
7854                                                 ctx,
7855                                                 pattern11_0,
7856                                                 pattern11_1,
7857                                             )?;
7858                                             let expr1_0 = CC::B;
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::UnorderedOrGreaterThanOrEqual => {
7868                                             // Rule at src/isa/x64/lower.isle line 1726.
7869                                             let expr0_0 = constructor_x64_ucomis(
7870                                                 ctx,
7871                                                 pattern11_0,
7872                                                 pattern11_1,
7873                                             )?;
7874                                             let expr1_0 = CC::BE;
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::UnorderedOrLessThan => {
7884                                             // Rule at src/isa/x64/lower.isle line 1700.
7885                                             let expr0_0 = constructor_x64_ucomis(
7886                                                 ctx,
7887                                                 pattern11_1,
7888                                                 pattern11_0,
7889                                             )?;
7890                                             let expr1_0 = CC::B;
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::UnorderedOrLessThanOrEqual => {
7900                                             // Rule at src/isa/x64/lower.isle line 1703.
7901                                             let expr0_0 = constructor_x64_ucomis(
7902                                                 ctx,
7903                                                 pattern11_1,
7904                                                 pattern11_0,
7905                                             )?;
7906                                             let expr1_0 = CC::BE;
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                                         _ => {}
7916                                     }
7917                                 }
7918                             }
7919                             &InstructionData::IntCompare {
7920                                 opcode: ref pattern9_0,
7921                                 args: ref pattern9_1,
7922                                 cond: ref pattern9_2,
7923                             } => {
7924                                 if let &Opcode::Icmp = pattern9_0 {
7925                                     let (pattern11_0, pattern11_1) =
7926                                         C::unpack_value_array_2(ctx, pattern9_1);
7927                                     let pattern12_0 = C::value_type(ctx, pattern11_0);
7928                                     if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) {
7929                                         // Rule at src/isa/x64/lower.isle line 1753.
7930                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
7931                                         let expr1_0 = constructor_put_in_gpr(ctx, pattern11_1)?;
7932                                         let expr2_0 = C::raw_operand_size_of_type(ctx, pattern13_0);
7933                                         let expr3_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7934                                         let expr4_0 =
7935                                             constructor_x64_cmp(ctx, &expr2_0, &expr3_0, expr0_0)?;
7936                                         let expr5_0 = C::intcc_to_cc(ctx, pattern9_2);
7937                                         let expr6_0 = constructor_cmove_from_values(
7938                                             ctx, pattern2_0, &expr5_0, pattern6_1, pattern6_2,
7939                                         )?;
7940                                         let expr7_0 =
7941                                             constructor_with_flags(ctx, &expr4_0, &expr6_0)?;
7942                                         let expr8_0 = C::output(ctx, expr7_0);
7943                                         return Some(expr8_0);
7944                                     }
7945                                 }
7946                             }
7947                             _ => {}
7948                         }
7949                     }
7950                     let pattern7_0 = C::value_type(ctx, pattern6_0);
7951                     if pattern7_0 == B1 {
7952                         // Rule at src/isa/x64/lower.isle line 1771.
7953                         let expr0_0: Type = B1;
7954                         let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0);
7955                         let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
7956                         let expr3_0: u32 = 1;
7957                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
7958                         let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0);
7959                         let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?;
7960                         let expr7_0 = CC::NZ;
7961                         let expr8_0 = constructor_cmove_from_values(
7962                             ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2,
7963                         )?;
7964                         let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?;
7965                         let expr10_0 = C::output(ctx, expr9_0);
7966                         return Some(expr10_0);
7967                     }
7968                     if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) {
7969                         // Rule at src/isa/x64/lower.isle line 1778.
7970                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0);
7971                         let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
7972                         let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7973                         let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?;
7974                         let expr4_0 = CC::NZ;
7975                         let expr5_0 = constructor_cmove_from_values(
7976                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
7977                         )?;
7978                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
7979                         let expr7_0 = C::output(ctx, expr6_0);
7980                         return Some(expr7_0);
7981                     }
7982                 }
7983             }
7984             &InstructionData::Unary {
7985                 opcode: ref pattern4_0,
7986                 arg: pattern4_1,
7987             } => {
7988                 match pattern4_0 {
7989                     &Opcode::Breduce => {
7990                         let pattern6_0 = C::value_type(ctx, pattern4_1);
7991                         if pattern6_0 == pattern2_0 {
7992                             // Rule at src/isa/x64/lower.isle line 2239.
7993                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
7994                             return Some(expr0_0);
7995                         }
7996                     }
7997                     &Opcode::Bextend => {
7998                         let pattern6_0 = C::value_type(ctx, pattern4_1);
7999                         // Rule at src/isa/x64/lower.isle line 2220.
8000                         let expr0_0 =
8001                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8002                         return Some(expr0_0);
8003                     }
8004                     &Opcode::Ireduce => {
8005                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8006                         if pattern6_0 == pattern2_0 {
8007                             // Rule at src/isa/x64/lower.isle line 2228.
8008                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8009                             return Some(expr0_0);
8010                         }
8011                     }
8012                     &Opcode::Uextend => {
8013                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8014                         if pattern6_0 == pattern2_0 {
8015                             // Rule at src/isa/x64/lower.isle line 2121.
8016                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
8017                             return Some(expr0_0);
8018                         }
8019                     }
8020                     &Opcode::Sextend => {
8021                         let pattern6_0 = C::value_type(ctx, pattern4_1);
8022                         // Rule at src/isa/x64/lower.isle line 2214.
8023                         let expr0_0 =
8024                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
8025                         return Some(expr0_0);
8026                     }
8027                     _ => {}
8028                 }
8029             }
8030             _ => {}
8031         }
8032         if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
8033             if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) {
8034                 if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) {
8035                     if pattern5_0 == 64 {
8036                         if pattern5_1 == 2 {
8037                             let pattern8_0 = C::inst_data(ctx, pattern0_0);
8038                             if let &InstructionData::Binary {
8039                                 opcode: ref pattern9_0,
8040                                 args: ref pattern9_1,
8041                             } = &pattern8_0
8042                             {
8043                                 if let &Opcode::Imul = pattern9_0 {
8044                                     let (pattern11_0, pattern11_1) =
8045                                         C::unpack_value_array_2(ctx, pattern9_1);
8046                                     // Rule at src/isa/x64/lower.isle line 992.
8047                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?;
8048                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?;
8049                                     let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?;
8050                                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8051                                     return Some(expr3_0);
8052                                 }
8053                             }
8054                         }
8055                     }
8056                 }
8057             }
8058             if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) {
8059                 if pattern2_0 == I64X2 {
8060                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8061                     if let &InstructionData::Unary {
8062                         opcode: ref pattern7_0,
8063                         arg: pattern7_1,
8064                     } = &pattern6_0
8065                     {
8066                         if let &Opcode::Iabs = pattern7_0 {
8067                             // Rule at src/isa/x64/lower.isle line 1220.
8068                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8069                             let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?;
8070                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8071                             return Some(expr2_0);
8072                         }
8073                     }
8074                 }
8075             }
8076         }
8077         if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) {
8078             if pattern3_0 == 8 {
8079                 if pattern3_1 == 16 {
8080                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8081                     if let &InstructionData::Binary {
8082                         opcode: ref pattern7_0,
8083                         args: ref pattern7_1,
8084                     } = &pattern6_0
8085                     {
8086                         match pattern7_0 {
8087                             &Opcode::AvgRound => {
8088                                 let (pattern9_0, pattern9_1) =
8089                                     C::unpack_value_array_2(ctx, pattern7_1);
8090                                 // Rule at src/isa/x64/lower.isle line 903.
8091                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8092                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8093                                 let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?;
8094                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8095                                 return Some(expr3_0);
8096                             }
8097                             &Opcode::UaddSat => {
8098                                 let (pattern9_0, pattern9_1) =
8099                                     C::unpack_value_array_2(ctx, pattern7_1);
8100                                 // Rule at src/isa/x64/lower.isle line 136.
8101                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8102                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8103                                 let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?;
8104                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8105                                 return Some(expr3_0);
8106                             }
8107                             &Opcode::SaddSat => {
8108                                 let (pattern9_0, pattern9_1) =
8109                                     C::unpack_value_array_2(ctx, pattern7_1);
8110                                 // Rule at src/isa/x64/lower.isle line 126.
8111                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8112                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8113                                 let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?;
8114                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8115                                 return Some(expr3_0);
8116                             }
8117                             &Opcode::UsubSat => {
8118                                 let (pattern9_0, pattern9_1) =
8119                                     C::unpack_value_array_2(ctx, pattern7_1);
8120                                 // Rule at src/isa/x64/lower.isle line 282.
8121                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8122                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8123                                 let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?;
8124                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8125                                 return Some(expr3_0);
8126                             }
8127                             &Opcode::SsubSat => {
8128                                 let (pattern9_0, pattern9_1) =
8129                                     C::unpack_value_array_2(ctx, pattern7_1);
8130                                 // Rule at src/isa/x64/lower.isle line 272.
8131                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8132                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8133                                 let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?;
8134                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8135                                 return Some(expr3_0);
8136                             }
8137                             &Opcode::Iadd => {
8138                                 let (pattern9_0, pattern9_1) =
8139                                     C::unpack_value_array_2(ctx, pattern7_1);
8140                                 // Rule at src/isa/x64/lower.isle line 94.
8141                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8142                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8143                                 let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?;
8144                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8145                                 return Some(expr3_0);
8146                             }
8147                             &Opcode::Isub => {
8148                                 let (pattern9_0, pattern9_1) =
8149                                     C::unpack_value_array_2(ctx, pattern7_1);
8150                                 // Rule at src/isa/x64/lower.isle line 240.
8151                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8152                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8153                                 let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?;
8154                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8155                                 return Some(expr3_0);
8156                             }
8157                             _ => {}
8158                         }
8159                     }
8160                 }
8161             }
8162             if pattern3_0 == 16 {
8163                 if pattern3_1 == 8 {
8164                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8165                     if let &InstructionData::Binary {
8166                         opcode: ref pattern7_0,
8167                         args: ref pattern7_1,
8168                     } = &pattern6_0
8169                     {
8170                         match pattern7_0 {
8171                             &Opcode::AvgRound => {
8172                                 let (pattern9_0, pattern9_1) =
8173                                     C::unpack_value_array_2(ctx, pattern7_1);
8174                                 // Rule at src/isa/x64/lower.isle line 907.
8175                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8176                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8177                                 let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?;
8178                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8179                                 return Some(expr3_0);
8180                             }
8181                             &Opcode::UaddSat => {
8182                                 let (pattern9_0, pattern9_1) =
8183                                     C::unpack_value_array_2(ctx, pattern7_1);
8184                                 // Rule at src/isa/x64/lower.isle line 140.
8185                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8186                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8187                                 let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?;
8188                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8189                                 return Some(expr3_0);
8190                             }
8191                             &Opcode::SaddSat => {
8192                                 let (pattern9_0, pattern9_1) =
8193                                     C::unpack_value_array_2(ctx, pattern7_1);
8194                                 // Rule at src/isa/x64/lower.isle line 130.
8195                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8196                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8197                                 let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?;
8198                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8199                                 return Some(expr3_0);
8200                             }
8201                             &Opcode::UsubSat => {
8202                                 let (pattern9_0, pattern9_1) =
8203                                     C::unpack_value_array_2(ctx, pattern7_1);
8204                                 // Rule at src/isa/x64/lower.isle line 286.
8205                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8206                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8207                                 let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?;
8208                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8209                                 return Some(expr3_0);
8210                             }
8211                             &Opcode::SsubSat => {
8212                                 let (pattern9_0, pattern9_1) =
8213                                     C::unpack_value_array_2(ctx, pattern7_1);
8214                                 // Rule at src/isa/x64/lower.isle line 276.
8215                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8216                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8217                                 let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?;
8218                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8219                                 return Some(expr3_0);
8220                             }
8221                             &Opcode::Iadd => {
8222                                 let (pattern9_0, pattern9_1) =
8223                                     C::unpack_value_array_2(ctx, pattern7_1);
8224                                 // Rule at src/isa/x64/lower.isle line 98.
8225                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8226                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8227                                 let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?;
8228                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8229                                 return Some(expr3_0);
8230                             }
8231                             &Opcode::Isub => {
8232                                 let (pattern9_0, pattern9_1) =
8233                                     C::unpack_value_array_2(ctx, pattern7_1);
8234                                 // Rule at src/isa/x64/lower.isle line 244.
8235                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8236                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8237                                 let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?;
8238                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8239                                 return Some(expr3_0);
8240                             }
8241                             &Opcode::Imul => {
8242                                 let (pattern9_0, pattern9_1) =
8243                                     C::unpack_value_array_2(ctx, pattern7_1);
8244                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8245                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8246                                     if let &InstructionData::Unary {
8247                                         opcode: ref pattern12_0,
8248                                         arg: pattern12_1,
8249                                     } = &pattern11_0
8250                                     {
8251                                         match pattern12_0 {
8252                                             &Opcode::SwidenLow => {
8253                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8254                                                 if let Some((pattern15_0, pattern15_1)) =
8255                                                     C::multi_lane(ctx, pattern14_0)
8256                                                 {
8257                                                     if pattern15_0 == 8 {
8258                                                         if pattern15_1 == 16 {
8259                                                             if let Some(pattern18_0) =
8260                                                                 C::def_inst(ctx, pattern9_1)
8261                                                             {
8262                                                                 let pattern19_0 =
8263                                                                     C::inst_data(ctx, pattern18_0);
8264                                                                 if let &InstructionData::Unary {
8265                                                                     opcode: ref pattern20_0,
8266                                                                     arg: pattern20_1,
8267                                                                 } = &pattern19_0
8268                                                                 {
8269                                                                     if let &Opcode::SwidenLow =
8270                                                                         pattern20_0
8271                                                                     {
8272                                                                         let pattern22_0 =
8273                                                                             C::value_type(
8274                                                                                 ctx,
8275                                                                                 pattern20_1,
8276                                                                             );
8277                                                                         if let Some((
8278                                                                             pattern23_0,
8279                                                                             pattern23_1,
8280                                                                         )) = C::multi_lane(
8281                                                                             ctx,
8282                                                                             pattern22_0,
8283                                                                         ) {
8284                                                                             if pattern23_0 == 8 {
8285                                                                                 if pattern23_1 == 16
8286                                                                                 {
8287                                                                                     // Rule at src/isa/x64/lower.isle line 1080.
8288                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8289                                                                                     let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?;
8290                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8291                                                                                     let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?;
8292                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8293                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8294                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8295                                                                                     return Some(
8296                                                                                         expr6_0,
8297                                                                                     );
8298                                                                                 }
8299                                                                             }
8300                                                                         }
8301                                                                     }
8302                                                                 }
8303                                                             }
8304                                                         }
8305                                                     }
8306                                                 }
8307                                             }
8308                                             &Opcode::SwidenHigh => {
8309                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8310                                                 if let Some((pattern15_0, pattern15_1)) =
8311                                                     C::multi_lane(ctx, pattern14_0)
8312                                                 {
8313                                                     if pattern15_0 == 8 {
8314                                                         if pattern15_1 == 16 {
8315                                                             if let Some(pattern18_0) =
8316                                                                 C::def_inst(ctx, pattern9_1)
8317                                                             {
8318                                                                 let pattern19_0 =
8319                                                                     C::inst_data(ctx, pattern18_0);
8320                                                                 if let &InstructionData::Unary {
8321                                                                     opcode: ref pattern20_0,
8322                                                                     arg: pattern20_1,
8323                                                                 } = &pattern19_0
8324                                                                 {
8325                                                                     if let &Opcode::SwidenHigh =
8326                                                                         pattern20_0
8327                                                                     {
8328                                                                         let pattern22_0 =
8329                                                                             C::value_type(
8330                                                                                 ctx,
8331                                                                                 pattern20_1,
8332                                                                             );
8333                                                                         if let Some((
8334                                                                             pattern23_0,
8335                                                                             pattern23_1,
8336                                                                         )) = C::multi_lane(
8337                                                                             ctx,
8338                                                                             pattern22_0,
8339                                                                         ) {
8340                                                                             if pattern23_0 == 8 {
8341                                                                                 if pattern23_1 == 16
8342                                                                                 {
8343                                                                                     // Rule at src/isa/x64/lower.isle line 1040.
8344                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8345                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8346                                                                                     let expr2_0: u8 = 8;
8347                                                                                     let expr3_0 = OperandSize::Size32;
8348                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8349                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8350                                                                                     let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?;
8351                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8352                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8353                                                                                     let expr9_0: u8 = 8;
8354                                                                                     let expr10_0 = OperandSize::Size32;
8355                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8356                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8357                                                                                     let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?;
8358                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8359                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8360                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8361                                                                                     return Some(
8362                                                                                         expr16_0,
8363                                                                                     );
8364                                                                                 }
8365                                                                             }
8366                                                                         }
8367                                                                     }
8368                                                                 }
8369                                                             }
8370                                                         }
8371                                                     }
8372                                                 }
8373                                             }
8374                                             &Opcode::UwidenLow => {
8375                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8376                                                 if let Some((pattern15_0, pattern15_1)) =
8377                                                     C::multi_lane(ctx, pattern14_0)
8378                                                 {
8379                                                     if pattern15_0 == 8 {
8380                                                         if pattern15_1 == 16 {
8381                                                             if let Some(pattern18_0) =
8382                                                                 C::def_inst(ctx, pattern9_1)
8383                                                             {
8384                                                                 let pattern19_0 =
8385                                                                     C::inst_data(ctx, pattern18_0);
8386                                                                 if let &InstructionData::Unary {
8387                                                                     opcode: ref pattern20_0,
8388                                                                     arg: pattern20_1,
8389                                                                 } = &pattern19_0
8390                                                                 {
8391                                                                     if let &Opcode::UwidenLow =
8392                                                                         pattern20_0
8393                                                                     {
8394                                                                         let pattern22_0 =
8395                                                                             C::value_type(
8396                                                                                 ctx,
8397                                                                                 pattern20_1,
8398                                                                             );
8399                                                                         if let Some((
8400                                                                             pattern23_0,
8401                                                                             pattern23_1,
8402                                                                         )) = C::multi_lane(
8403                                                                             ctx,
8404                                                                             pattern22_0,
8405                                                                         ) {
8406                                                                             if pattern23_0 == 8 {
8407                                                                                 if pattern23_1 == 16
8408                                                                                 {
8409                                                                                     // Rule at src/isa/x64/lower.isle line 1156.
8410                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8411                                                                                     let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?;
8412                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8413                                                                                     let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?;
8414                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8415                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
8416                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8417                                                                                     return Some(
8418                                                                                         expr6_0,
8419                                                                                     );
8420                                                                                 }
8421                                                                             }
8422                                                                         }
8423                                                                     }
8424                                                                 }
8425                                                             }
8426                                                         }
8427                                                     }
8428                                                 }
8429                                             }
8430                                             &Opcode::UwidenHigh => {
8431                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8432                                                 if let Some((pattern15_0, pattern15_1)) =
8433                                                     C::multi_lane(ctx, pattern14_0)
8434                                                 {
8435                                                     if pattern15_0 == 8 {
8436                                                         if pattern15_1 == 16 {
8437                                                             if let Some(pattern18_0) =
8438                                                                 C::def_inst(ctx, pattern9_1)
8439                                                             {
8440                                                                 let pattern19_0 =
8441                                                                     C::inst_data(ctx, pattern18_0);
8442                                                                 if let &InstructionData::Unary {
8443                                                                     opcode: ref pattern20_0,
8444                                                                     arg: pattern20_1,
8445                                                                 } = &pattern19_0
8446                                                                 {
8447                                                                     if let &Opcode::UwidenHigh =
8448                                                                         pattern20_0
8449                                                                     {
8450                                                                         let pattern22_0 =
8451                                                                             C::value_type(
8452                                                                                 ctx,
8453                                                                                 pattern20_1,
8454                                                                             );
8455                                                                         if let Some((
8456                                                                             pattern23_0,
8457                                                                             pattern23_1,
8458                                                                         )) = C::multi_lane(
8459                                                                             ctx,
8460                                                                             pattern22_0,
8461                                                                         ) {
8462                                                                             if pattern23_0 == 8 {
8463                                                                                 if pattern23_1 == 16
8464                                                                                 {
8465                                                                                     // Rule at src/isa/x64/lower.isle line 1116.
8466                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8467                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8468                                                                                     let expr2_0: u8 = 8;
8469                                                                                     let expr3_0 = OperandSize::Size32;
8470                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
8471                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
8472                                                                                     let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?;
8473                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8474                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8475                                                                                     let expr9_0: u8 = 8;
8476                                                                                     let expr10_0 = OperandSize::Size32;
8477                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
8478                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8479                                                                                     let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?;
8480                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
8481                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
8482                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8483                                                                                     return Some(
8484                                                                                         expr16_0,
8485                                                                                     );
8486                                                                                 }
8487                                                                             }
8488                                                                         }
8489                                                                     }
8490                                                                 }
8491                                                             }
8492                                                         }
8493                                                     }
8494                                                 }
8495                                             }
8496                                             _ => {}
8497                                         }
8498                                     }
8499                                 }
8500                                 // Rule at src/isa/x64/lower.isle line 984.
8501                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8502                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8503                                 let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?;
8504                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8505                                 return Some(expr3_0);
8506                             }
8507                             _ => {}
8508                         }
8509                     }
8510                 }
8511             }
8512             if pattern3_0 == 32 {
8513                 if pattern3_1 == 4 {
8514                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8515                     if let &InstructionData::Binary {
8516                         opcode: ref pattern7_0,
8517                         args: ref pattern7_1,
8518                     } = &pattern6_0
8519                     {
8520                         match pattern7_0 {
8521                             &Opcode::Iadd => {
8522                                 let (pattern9_0, pattern9_1) =
8523                                     C::unpack_value_array_2(ctx, pattern7_1);
8524                                 // Rule at src/isa/x64/lower.isle line 102.
8525                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8526                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8527                                 let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?;
8528                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8529                                 return Some(expr3_0);
8530                             }
8531                             &Opcode::Isub => {
8532                                 let (pattern9_0, pattern9_1) =
8533                                     C::unpack_value_array_2(ctx, pattern7_1);
8534                                 // Rule at src/isa/x64/lower.isle line 248.
8535                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8536                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8537                                 let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?;
8538                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8539                                 return Some(expr3_0);
8540                             }
8541                             &Opcode::Imul => {
8542                                 let (pattern9_0, pattern9_1) =
8543                                     C::unpack_value_array_2(ctx, pattern7_1);
8544                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8545                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8546                                     if let &InstructionData::Unary {
8547                                         opcode: ref pattern12_0,
8548                                         arg: pattern12_1,
8549                                     } = &pattern11_0
8550                                     {
8551                                         match pattern12_0 {
8552                                             &Opcode::SwidenLow => {
8553                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8554                                                 if let Some((pattern15_0, pattern15_1)) =
8555                                                     C::multi_lane(ctx, pattern14_0)
8556                                                 {
8557                                                     if pattern15_0 == 16 {
8558                                                         if pattern15_1 == 8 {
8559                                                             if let Some(pattern18_0) =
8560                                                                 C::def_inst(ctx, pattern9_1)
8561                                                             {
8562                                                                 let pattern19_0 =
8563                                                                     C::inst_data(ctx, pattern18_0);
8564                                                                 if let &InstructionData::Unary {
8565                                                                     opcode: ref pattern20_0,
8566                                                                     arg: pattern20_1,
8567                                                                 } = &pattern19_0
8568                                                                 {
8569                                                                     if let &Opcode::SwidenLow =
8570                                                                         pattern20_0
8571                                                                     {
8572                                                                         let pattern22_0 =
8573                                                                             C::value_type(
8574                                                                                 ctx,
8575                                                                                 pattern20_1,
8576                                                                             );
8577                                                                         if let Some((
8578                                                                             pattern23_0,
8579                                                                             pattern23_1,
8580                                                                         )) = C::multi_lane(
8581                                                                             ctx,
8582                                                                             pattern22_0,
8583                                                                         ) {
8584                                                                             if pattern23_0 == 16 {
8585                                                                                 if pattern23_1 == 8
8586                                                                                 {
8587                                                                                     // Rule at src/isa/x64/lower.isle line 1090.
8588                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8589                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8590                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8591                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8592                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8593                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8594                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8595                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8596                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8597                                                                                     return Some(
8598                                                                                         expr8_0,
8599                                                                                     );
8600                                                                                 }
8601                                                                             }
8602                                                                         }
8603                                                                     }
8604                                                                 }
8605                                                             }
8606                                                         }
8607                                                     }
8608                                                 }
8609                                             }
8610                                             &Opcode::SwidenHigh => {
8611                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8612                                                 if let Some((pattern15_0, pattern15_1)) =
8613                                                     C::multi_lane(ctx, pattern14_0)
8614                                                 {
8615                                                     if pattern15_0 == 16 {
8616                                                         if pattern15_1 == 8 {
8617                                                             if let Some(pattern18_0) =
8618                                                                 C::def_inst(ctx, pattern9_1)
8619                                                             {
8620                                                                 let pattern19_0 =
8621                                                                     C::inst_data(ctx, pattern18_0);
8622                                                                 if let &InstructionData::Unary {
8623                                                                     opcode: ref pattern20_0,
8624                                                                     arg: pattern20_1,
8625                                                                 } = &pattern19_0
8626                                                                 {
8627                                                                     if let &Opcode::SwidenHigh =
8628                                                                         pattern20_0
8629                                                                     {
8630                                                                         let pattern22_0 =
8631                                                                             C::value_type(
8632                                                                                 ctx,
8633                                                                                 pattern20_1,
8634                                                                             );
8635                                                                         if let Some((
8636                                                                             pattern23_0,
8637                                                                             pattern23_1,
8638                                                                         )) = C::multi_lane(
8639                                                                             ctx,
8640                                                                             pattern22_0,
8641                                                                         ) {
8642                                                                             if pattern23_0 == 16 {
8643                                                                                 if pattern23_1 == 8
8644                                                                                 {
8645                                                                                     // Rule at src/isa/x64/lower.isle line 1054.
8646                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8647                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8648                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8649                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8650                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8651                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
8652                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8653                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8654                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8655                                                                                     return Some(
8656                                                                                         expr8_0,
8657                                                                                     );
8658                                                                                 }
8659                                                                             }
8660                                                                         }
8661                                                                     }
8662                                                                 }
8663                                                             }
8664                                                         }
8665                                                     }
8666                                                 }
8667                                             }
8668                                             &Opcode::UwidenLow => {
8669                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8670                                                 if let Some((pattern15_0, pattern15_1)) =
8671                                                     C::multi_lane(ctx, pattern14_0)
8672                                                 {
8673                                                     if pattern15_0 == 16 {
8674                                                         if pattern15_1 == 8 {
8675                                                             if let Some(pattern18_0) =
8676                                                                 C::def_inst(ctx, pattern9_1)
8677                                                             {
8678                                                                 let pattern19_0 =
8679                                                                     C::inst_data(ctx, pattern18_0);
8680                                                                 if let &InstructionData::Unary {
8681                                                                     opcode: ref pattern20_0,
8682                                                                     arg: pattern20_1,
8683                                                                 } = &pattern19_0
8684                                                                 {
8685                                                                     if let &Opcode::UwidenLow =
8686                                                                         pattern20_0
8687                                                                     {
8688                                                                         let pattern22_0 =
8689                                                                             C::value_type(
8690                                                                                 ctx,
8691                                                                                 pattern20_1,
8692                                                                             );
8693                                                                         if let Some((
8694                                                                             pattern23_0,
8695                                                                             pattern23_1,
8696                                                                         )) = C::multi_lane(
8697                                                                             ctx,
8698                                                                             pattern22_0,
8699                                                                         ) {
8700                                                                             if pattern23_0 == 16 {
8701                                                                                 if pattern23_1 == 8
8702                                                                                 {
8703                                                                                     // Rule at src/isa/x64/lower.isle line 1166.
8704                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8705                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8706                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8707                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8708                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8709                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8710                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8711                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
8712                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8713                                                                                     return Some(
8714                                                                                         expr8_0,
8715                                                                                     );
8716                                                                                 }
8717                                                                             }
8718                                                                         }
8719                                                                     }
8720                                                                 }
8721                                                             }
8722                                                         }
8723                                                     }
8724                                                 }
8725                                             }
8726                                             &Opcode::UwidenHigh => {
8727                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8728                                                 if let Some((pattern15_0, pattern15_1)) =
8729                                                     C::multi_lane(ctx, pattern14_0)
8730                                                 {
8731                                                     if pattern15_0 == 16 {
8732                                                         if pattern15_1 == 8 {
8733                                                             if let Some(pattern18_0) =
8734                                                                 C::def_inst(ctx, pattern9_1)
8735                                                             {
8736                                                                 let pattern19_0 =
8737                                                                     C::inst_data(ctx, pattern18_0);
8738                                                                 if let &InstructionData::Unary {
8739                                                                     opcode: ref pattern20_0,
8740                                                                     arg: pattern20_1,
8741                                                                 } = &pattern19_0
8742                                                                 {
8743                                                                     if let &Opcode::UwidenHigh =
8744                                                                         pattern20_0
8745                                                                     {
8746                                                                         let pattern22_0 =
8747                                                                             C::value_type(
8748                                                                                 ctx,
8749                                                                                 pattern20_1,
8750                                                                             );
8751                                                                         if let Some((
8752                                                                             pattern23_0,
8753                                                                             pattern23_1,
8754                                                                         )) = C::multi_lane(
8755                                                                             ctx,
8756                                                                             pattern22_0,
8757                                                                         ) {
8758                                                                             if pattern23_0 == 16 {
8759                                                                                 if pattern23_1 == 8
8760                                                                                 {
8761                                                                                     // Rule at src/isa/x64/lower.isle line 1130.
8762                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
8763                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
8764                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8765                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
8766                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
8767                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
8768                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8769                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
8770                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
8771                                                                                     return Some(
8772                                                                                         expr8_0,
8773                                                                                     );
8774                                                                                 }
8775                                                                             }
8776                                                                         }
8777                                                                     }
8778                                                                 }
8779                                                             }
8780                                                         }
8781                                                     }
8782                                                 }
8783                                             }
8784                                             _ => {}
8785                                         }
8786                                     }
8787                                 }
8788                                 // Rule at src/isa/x64/lower.isle line 987.
8789                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8790                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8791                                 let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?;
8792                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8793                                 return Some(expr3_0);
8794                             }
8795                             _ => {}
8796                         }
8797                     }
8798                 }
8799             }
8800             if pattern3_0 == 64 {
8801                 if pattern3_1 == 2 {
8802                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
8803                     if let &InstructionData::Binary {
8804                         opcode: ref pattern7_0,
8805                         args: ref pattern7_1,
8806                     } = &pattern6_0
8807                     {
8808                         match pattern7_0 {
8809                             &Opcode::Iadd => {
8810                                 let (pattern9_0, pattern9_1) =
8811                                     C::unpack_value_array_2(ctx, pattern7_1);
8812                                 // Rule at src/isa/x64/lower.isle line 106.
8813                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8814                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8815                                 let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?;
8816                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8817                                 return Some(expr3_0);
8818                             }
8819                             &Opcode::Isub => {
8820                                 let (pattern9_0, pattern9_1) =
8821                                     C::unpack_value_array_2(ctx, pattern7_1);
8822                                 // Rule at src/isa/x64/lower.isle line 252.
8823                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
8824                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
8825                                 let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?;
8826                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8827                                 return Some(expr3_0);
8828                             }
8829                             &Opcode::Imul => {
8830                                 let (pattern9_0, pattern9_1) =
8831                                     C::unpack_value_array_2(ctx, pattern7_1);
8832                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
8833                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
8834                                     if let &InstructionData::Unary {
8835                                         opcode: ref pattern12_0,
8836                                         arg: pattern12_1,
8837                                     } = &pattern11_0
8838                                     {
8839                                         match pattern12_0 {
8840                                             &Opcode::SwidenLow => {
8841                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8842                                                 if let Some((pattern15_0, pattern15_1)) =
8843                                                     C::multi_lane(ctx, pattern14_0)
8844                                                 {
8845                                                     if pattern15_0 == 32 {
8846                                                         if pattern15_1 == 4 {
8847                                                             if let Some(pattern18_0) =
8848                                                                 C::def_inst(ctx, pattern9_1)
8849                                                             {
8850                                                                 let pattern19_0 =
8851                                                                     C::inst_data(ctx, pattern18_0);
8852                                                                 if let &InstructionData::Unary {
8853                                                                     opcode: ref pattern20_0,
8854                                                                     arg: pattern20_1,
8855                                                                 } = &pattern19_0
8856                                                                 {
8857                                                                     if let &Opcode::SwidenLow =
8858                                                                         pattern20_0
8859                                                                     {
8860                                                                         let pattern22_0 =
8861                                                                             C::value_type(
8862                                                                                 ctx,
8863                                                                                 pattern20_1,
8864                                                                             );
8865                                                                         if let Some((
8866                                                                             pattern23_0,
8867                                                                             pattern23_1,
8868                                                                         )) = C::multi_lane(
8869                                                                             ctx,
8870                                                                             pattern22_0,
8871                                                                         ) {
8872                                                                             if pattern23_0 == 32 {
8873                                                                                 if pattern23_1 == 4
8874                                                                                 {
8875                                                                                     // Rule at src/isa/x64/lower.isle line 1102.
8876                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8877                                                                                     let expr1_0: u8 = 80;
8878                                                                                     let expr2_0 = OperandSize::Size32;
8879                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
8880                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8881                                                                                     let expr5_0: u8 = 80;
8882                                                                                     let expr6_0 = OperandSize::Size32;
8883                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
8884                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8885                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
8886                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
8887                                                                                     return Some(
8888                                                                                         expr10_0,
8889                                                                                     );
8890                                                                                 }
8891                                                                             }
8892                                                                         }
8893                                                                     }
8894                                                                 }
8895                                                             }
8896                                                         }
8897                                                     }
8898                                                 }
8899                                             }
8900                                             &Opcode::SwidenHigh => {
8901                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8902                                                 if let Some((pattern15_0, pattern15_1)) =
8903                                                     C::multi_lane(ctx, pattern14_0)
8904                                                 {
8905                                                     if pattern15_0 == 32 {
8906                                                         if pattern15_1 == 4 {
8907                                                             if let Some(pattern18_0) =
8908                                                                 C::def_inst(ctx, pattern9_1)
8909                                                             {
8910                                                                 let pattern19_0 =
8911                                                                     C::inst_data(ctx, pattern18_0);
8912                                                                 if let &InstructionData::Unary {
8913                                                                     opcode: ref pattern20_0,
8914                                                                     arg: pattern20_1,
8915                                                                 } = &pattern19_0
8916                                                                 {
8917                                                                     if let &Opcode::SwidenHigh =
8918                                                                         pattern20_0
8919                                                                     {
8920                                                                         let pattern22_0 =
8921                                                                             C::value_type(
8922                                                                                 ctx,
8923                                                                                 pattern20_1,
8924                                                                             );
8925                                                                         if let Some((
8926                                                                             pattern23_0,
8927                                                                             pattern23_1,
8928                                                                         )) = C::multi_lane(
8929                                                                             ctx,
8930                                                                             pattern22_0,
8931                                                                         ) {
8932                                                                             if pattern23_0 == 32 {
8933                                                                                 if pattern23_1 == 4
8934                                                                                 {
8935                                                                                     // Rule at src/isa/x64/lower.isle line 1066.
8936                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8937                                                                                     let expr1_0: u8 = 250;
8938                                                                                     let expr2_0 = OperandSize::Size32;
8939                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
8940                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
8941                                                                                     let expr5_0: u8 = 250;
8942                                                                                     let expr6_0 = OperandSize::Size32;
8943                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
8944                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8945                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
8946                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
8947                                                                                     return Some(
8948                                                                                         expr10_0,
8949                                                                                     );
8950                                                                                 }
8951                                                                             }
8952                                                                         }
8953                                                                     }
8954                                                                 }
8955                                                             }
8956                                                         }
8957                                                     }
8958                                                 }
8959                                             }
8960                                             &Opcode::UwidenLow => {
8961                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
8962                                                 if let Some((pattern15_0, pattern15_1)) =
8963                                                     C::multi_lane(ctx, pattern14_0)
8964                                                 {
8965                                                     if pattern15_0 == 32 {
8966                                                         if pattern15_1 == 4 {
8967                                                             if let Some(pattern18_0) =
8968                                                                 C::def_inst(ctx, pattern9_1)
8969                                                             {
8970                                                                 let pattern19_0 =
8971                                                                     C::inst_data(ctx, pattern18_0);
8972                                                                 if let &InstructionData::Unary {
8973                                                                     opcode: ref pattern20_0,
8974                                                                     arg: pattern20_1,
8975                                                                 } = &pattern19_0
8976                                                                 {
8977                                                                     if let &Opcode::UwidenLow =
8978                                                                         pattern20_0
8979                                                                     {
8980                                                                         let pattern22_0 =
8981                                                                             C::value_type(
8982                                                                                 ctx,
8983                                                                                 pattern20_1,
8984                                                                             );
8985                                                                         if let Some((
8986                                                                             pattern23_0,
8987                                                                             pattern23_1,
8988                                                                         )) = C::multi_lane(
8989                                                                             ctx,
8990                                                                             pattern22_0,
8991                                                                         ) {
8992                                                                             if pattern23_0 == 32 {
8993                                                                                 if pattern23_1 == 4
8994                                                                                 {
8995                                                                                     // Rule at src/isa/x64/lower.isle line 1178.
8996                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
8997                                                                                     let expr1_0: u8 = 80;
8998                                                                                     let expr2_0 = OperandSize::Size32;
8999                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9000                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9001                                                                                     let expr5_0: u8 = 80;
9002                                                                                     let expr6_0 = OperandSize::Size32;
9003                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9004                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9005                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9006                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9007                                                                                     return Some(
9008                                                                                         expr10_0,
9009                                                                                     );
9010                                                                                 }
9011                                                                             }
9012                                                                         }
9013                                                                     }
9014                                                                 }
9015                                                             }
9016                                                         }
9017                                                     }
9018                                                 }
9019                                             }
9020                                             &Opcode::UwidenHigh => {
9021                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9022                                                 if let Some((pattern15_0, pattern15_1)) =
9023                                                     C::multi_lane(ctx, pattern14_0)
9024                                                 {
9025                                                     if pattern15_0 == 32 {
9026                                                         if pattern15_1 == 4 {
9027                                                             if let Some(pattern18_0) =
9028                                                                 C::def_inst(ctx, pattern9_1)
9029                                                             {
9030                                                                 let pattern19_0 =
9031                                                                     C::inst_data(ctx, pattern18_0);
9032                                                                 if let &InstructionData::Unary {
9033                                                                     opcode: ref pattern20_0,
9034                                                                     arg: pattern20_1,
9035                                                                 } = &pattern19_0
9036                                                                 {
9037                                                                     if let &Opcode::UwidenHigh =
9038                                                                         pattern20_0
9039                                                                     {
9040                                                                         let pattern22_0 =
9041                                                                             C::value_type(
9042                                                                                 ctx,
9043                                                                                 pattern20_1,
9044                                                                             );
9045                                                                         if let Some((
9046                                                                             pattern23_0,
9047                                                                             pattern23_1,
9048                                                                         )) = C::multi_lane(
9049                                                                             ctx,
9050                                                                             pattern22_0,
9051                                                                         ) {
9052                                                                             if pattern23_0 == 32 {
9053                                                                                 if pattern23_1 == 4
9054                                                                                 {
9055                                                                                     // Rule at src/isa/x64/lower.isle line 1142.
9056                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9057                                                                                     let expr1_0: u8 = 250;
9058                                                                                     let expr2_0 = OperandSize::Size32;
9059                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
9060                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9061                                                                                     let expr5_0: u8 = 250;
9062                                                                                     let expr6_0 = OperandSize::Size32;
9063                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
9064                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9065                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
9066                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
9067                                                                                     return Some(
9068                                                                                         expr10_0,
9069                                                                                     );
9070                                                                                 }
9071                                                                             }
9072                                                                         }
9073                                                                     }
9074                                                                 }
9075                                                             }
9076                                                         }
9077                                                     }
9078                                                 }
9079                                             }
9080                                             _ => {}
9081                                         }
9082                                     }
9083                                 }
9084                                 // Rule at src/isa/x64/lower.isle line 1018.
9085                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9086                                 let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?;
9087                                 let expr2_0: u32 = 32;
9088                                 let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
9089                                 let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?;
9090                                 let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?;
9091                                 let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9092                                 let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?;
9093                                 let expr8_0: u32 = 32;
9094                                 let expr9_0 = RegMemImm::Imm { simm32: expr8_0 };
9095                                 let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?;
9096                                 let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?;
9097                                 let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9098                                 let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?;
9099                                 let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9100                                 let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?;
9101                                 let expr16_0: u32 = 32;
9102                                 let expr17_0 = RegMemImm::Imm { simm32: expr16_0 };
9103                                 let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?;
9104                                 let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?;
9105                                 let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9106                                 let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?;
9107                                 let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0);
9108                                 let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?;
9109                                 let expr24_0 = constructor_output_xmm(ctx, expr23_0)?;
9110                                 return Some(expr24_0);
9111                             }
9112                             _ => {}
9113                         }
9114                     }
9115                 }
9116             }
9117             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9118             match &pattern4_0 {
9119                 &InstructionData::Binary {
9120                     opcode: ref pattern5_0,
9121                     args: ref pattern5_1,
9122                 } => {
9123                     match pattern5_0 {
9124                         &Opcode::Band => {
9125                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9126                             // Rule at src/isa/x64/lower.isle line 328.
9127                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9128                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9129                             let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?;
9130                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9131                             return Some(expr3_0);
9132                         }
9133                         &Opcode::Bor => {
9134                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9135                             // Rule at src/isa/x64/lower.isle line 392.
9136                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9137                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9138                             let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?;
9139                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9140                             return Some(expr3_0);
9141                         }
9142                         &Opcode::Bxor => {
9143                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9144                             // Rule at src/isa/x64/lower.isle line 453.
9145                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9146                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9147                             let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?;
9148                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9149                             return Some(expr3_0);
9150                         }
9151                         _ => {}
9152                     }
9153                 }
9154                 &InstructionData::Ternary {
9155                     opcode: ref pattern5_0,
9156                     args: ref pattern5_1,
9157                 } => {
9158                     match pattern5_0 {
9159                         &Opcode::Bitselect => {
9160                             let (pattern7_0, pattern7_1, pattern7_2) =
9161                                 C::unpack_value_array_3(ctx, pattern5_1);
9162                             // Rule at src/isa/x64/lower.isle line 1279.
9163                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
9164                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
9165                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9166                             let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?;
9167                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?;
9168                             let expr5_0 =
9169                                 constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?;
9170                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9171                             let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?;
9172                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9173                             return Some(expr8_0);
9174                         }
9175                         &Opcode::Vselect => {
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 1293.
9179                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?;
9180                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9181                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?;
9182                             let expr3_0 = constructor_x64_blend(
9183                                 ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0,
9184                             )?;
9185                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9186                             return Some(expr4_0);
9187                         }
9188                         _ => {}
9189                     }
9190                 }
9191                 &InstructionData::Unary {
9192                     opcode: ref pattern5_0,
9193                     arg: pattern5_1,
9194                 } => {
9195                     if let &Opcode::Bnot = pattern5_0 {
9196                         // Rule at src/isa/x64/lower.isle line 1274.
9197                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
9198                         let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?;
9199                         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9200                         let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?;
9201                         let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
9202                         return Some(expr4_0);
9203                     }
9204                 }
9205                 _ => {}
9206             }
9207         }
9208         if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) {
9209             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9210             if let &InstructionData::Unary {
9211                 opcode: ref pattern5_0,
9212                 arg: pattern5_1,
9213             } = &pattern4_0
9214             {
9215                 if let &Opcode::Uextend = pattern5_0 {
9216                     let pattern7_0 = C::value_type(ctx, pattern5_1);
9217                     if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
9218                         // Rule at src/isa/x64/lower.isle line 2137.
9219                         let expr0_0: Type = I32;
9220                         let expr1_0 = ExtendKind::Zero;
9221                         let expr2_0 =
9222                             constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
9223                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9224                         return Some(expr3_0);
9225                     }
9226                 }
9227             }
9228             if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) {
9229                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
9230                 if let &InstructionData::Load {
9231                     opcode: ref pattern6_0,
9232                     arg: pattern6_1,
9233                     flags: pattern6_2,
9234                     offset: pattern6_3,
9235                 } = &pattern5_0
9236                 {
9237                     if let &Opcode::Load = pattern6_0 {
9238                         // Rule at src/isa/x64/lower.isle line 2517.
9239                         let expr0_0 = C::ty_bits_u16(ctx, pattern3_0);
9240                         let expr1_0: u16 = 64;
9241                         let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
9242                         let expr3_0 =
9243                             constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?;
9244                         let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?;
9245                         let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?;
9246                         let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9247                         return Some(expr6_0);
9248                     }
9249                 }
9250             }
9251         }
9252         if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) {
9253             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9254             match &pattern4_0 {
9255                 &InstructionData::UnaryImm {
9256                     opcode: ref pattern5_0,
9257                     imm: pattern5_1,
9258                 } => {
9259                     if let &Opcode::Iconst = pattern5_0 {
9260                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
9261                         // Rule at src/isa/x64/lower.isle line 10.
9262                         let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9263                         let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
9264                         return Some(expr1_0);
9265                     }
9266                 }
9267                 &InstructionData::UnaryBool {
9268                     opcode: ref pattern5_0,
9269                     imm: pattern5_1,
9270                 } => {
9271                     if let &Opcode::Bconst = pattern5_0 {
9272                         if pattern5_1 == true {
9273                             // Rule at src/isa/x64/lower.isle line 28.
9274                             let expr0_0: u64 = 1;
9275                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9276                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9277                             return Some(expr2_0);
9278                         }
9279                         if pattern5_1 == false {
9280                             // Rule at src/isa/x64/lower.isle line 24.
9281                             let expr0_0: u64 = 0;
9282                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
9283                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9284                             return Some(expr2_0);
9285                         }
9286                     }
9287                 }
9288                 &InstructionData::Binary {
9289                     opcode: ref pattern5_0,
9290                     args: ref pattern5_1,
9291                 } => {
9292                     match pattern5_0 {
9293                         &Opcode::Imin => {
9294                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9295                             // Rule at src/isa/x64/lower.isle line 1382.
9296                             let expr0_0 = CC::L;
9297                             let expr1_0 = constructor_cmp_and_choose(
9298                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9299                             )?;
9300                             let expr2_0 = C::output(ctx, expr1_0);
9301                             return Some(expr2_0);
9302                         }
9303                         &Opcode::Umin => {
9304                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9305                             // Rule at src/isa/x64/lower.isle line 1376.
9306                             let expr0_0 = CC::B;
9307                             let expr1_0 = constructor_cmp_and_choose(
9308                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9309                             )?;
9310                             let expr2_0 = C::output(ctx, expr1_0);
9311                             return Some(expr2_0);
9312                         }
9313                         &Opcode::Imax => {
9314                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9315                             // Rule at src/isa/x64/lower.isle line 1385.
9316                             let expr0_0 = CC::NL;
9317                             let expr1_0 = constructor_cmp_and_choose(
9318                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9319                             )?;
9320                             let expr2_0 = C::output(ctx, expr1_0);
9321                             return Some(expr2_0);
9322                         }
9323                         &Opcode::Umax => {
9324                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9325                             // Rule at src/isa/x64/lower.isle line 1379.
9326                             let expr0_0 = CC::NB;
9327                             let expr1_0 = constructor_cmp_and_choose(
9328                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
9329                             )?;
9330                             let expr2_0 = C::output(ctx, expr1_0);
9331                             return Some(expr2_0);
9332                         }
9333                         &Opcode::Iadd => {
9334                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9335                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9336                                 // Rule at src/isa/x64/lower.isle line 74.
9337                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9338                                 let expr1_0 =
9339                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9340                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9341                                 return Some(expr2_0);
9342                             }
9343                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9344                                 // Rule at src/isa/x64/lower.isle line 86.
9345                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9346                                 let expr1_0 =
9347                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9348                                 let expr2_0 =
9349                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9350                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9351                                 return Some(expr3_0);
9352                             }
9353                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9354                                 // Rule at src/isa/x64/lower.isle line 70.
9355                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9356                                 let expr1_0 =
9357                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9358                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9359                                 return Some(expr2_0);
9360                             }
9361                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9362                                 // Rule at src/isa/x64/lower.isle line 80.
9363                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9364                                 let expr1_0 =
9365                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9366                                 let expr2_0 =
9367                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9368                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9369                                 return Some(expr3_0);
9370                             }
9371                             // Rule at src/isa/x64/lower.isle line 64.
9372                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9373                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9374                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9375                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9376                             return Some(expr3_0);
9377                         }
9378                         &Opcode::Isub => {
9379                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9380                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9381                                 // Rule at src/isa/x64/lower.isle line 228.
9382                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9383                                 let expr1_0 =
9384                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9385                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9386                                 return Some(expr2_0);
9387                             }
9388                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9389                                 // Rule at src/isa/x64/lower.isle line 233.
9390                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9391                                 let expr1_0 =
9392                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9393                                 let expr2_0 =
9394                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9395                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9396                                 return Some(expr3_0);
9397                             }
9398                             // Rule at src/isa/x64/lower.isle line 223.
9399                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9400                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9401                             let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
9402                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9403                             return Some(expr3_0);
9404                         }
9405                         &Opcode::Imul => {
9406                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9407                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9408                                 // Rule at src/isa/x64/lower.isle line 925.
9409                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9410                                 let expr1_0 =
9411                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9412                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9413                                 return Some(expr2_0);
9414                             }
9415                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9416                                 // Rule at src/isa/x64/lower.isle line 937.
9417                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9418                                 let expr1_0 =
9419                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9420                                 let expr2_0 =
9421                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9422                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9423                                 return Some(expr3_0);
9424                             }
9425                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9426                                 // Rule at src/isa/x64/lower.isle line 921.
9427                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9428                                 let expr1_0 =
9429                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9430                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9431                                 return Some(expr2_0);
9432                             }
9433                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9434                                 // Rule at src/isa/x64/lower.isle line 931.
9435                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9436                                 let expr1_0 =
9437                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9438                                 let expr2_0 =
9439                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9440                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9441                                 return Some(expr3_0);
9442                             }
9443                             // Rule at src/isa/x64/lower.isle line 916.
9444                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9445                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9446                             let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
9447                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9448                             return Some(expr3_0);
9449                         }
9450                         &Opcode::IaddIfcout => {
9451                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9452                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9453                                 // Rule at src/isa/x64/lower.isle line 171.
9454                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9455                                 let expr1_0 =
9456                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9457                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9458                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9459                                 return Some(expr3_0);
9460                             }
9461                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9462                                 // Rule at src/isa/x64/lower.isle line 181.
9463                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9464                                 let expr1_0 =
9465                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9466                                 let expr2_0 =
9467                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9468                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9469                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9470                                 return Some(expr4_0);
9471                             }
9472                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9473                                 // Rule at src/isa/x64/lower.isle line 167.
9474                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9475                                 let expr1_0 =
9476                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9477                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
9478                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
9479                                 return Some(expr3_0);
9480                             }
9481                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9482                                 // Rule at src/isa/x64/lower.isle line 177.
9483                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9484                                 let expr1_0 =
9485                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9486                                 let expr2_0 =
9487                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9488                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9489                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9490                                 return Some(expr4_0);
9491                             }
9492                             // Rule at src/isa/x64/lower.isle line 161.
9493                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9494                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9495                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
9496                             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
9497                             let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
9498                             return Some(expr4_0);
9499                         }
9500                         &Opcode::Band => {
9501                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9502                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9503                                 // Rule at src/isa/x64/lower.isle line 317.
9504                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9505                                 let expr1_0 =
9506                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9507                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9508                                 return Some(expr2_0);
9509                             }
9510                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9511                                 // Rule at src/isa/x64/lower.isle line 305.
9512                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9513                                 let expr1_0 =
9514                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9515                                 let expr2_0 =
9516                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9517                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9518                                 return Some(expr3_0);
9519                             }
9520                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9521                                 // Rule at src/isa/x64/lower.isle line 313.
9522                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9523                                 let expr1_0 =
9524                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9525                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9526                                 return Some(expr2_0);
9527                             }
9528                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9529                                 // Rule at src/isa/x64/lower.isle line 300.
9530                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9531                                 let expr1_0 =
9532                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9533                                 let expr2_0 =
9534                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9535                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9536                                 return Some(expr3_0);
9537                             }
9538                             // Rule at src/isa/x64/lower.isle line 295.
9539                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9540                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9541                             let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
9542                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9543                             return Some(expr3_0);
9544                         }
9545                         &Opcode::Bor => {
9546                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9547                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9548                                 // Rule at src/isa/x64/lower.isle line 381.
9549                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9550                                 let expr1_0 =
9551                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9552                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9553                                 return Some(expr2_0);
9554                             }
9555                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9556                                 // Rule at src/isa/x64/lower.isle line 370.
9557                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9558                                 let expr1_0 =
9559                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9560                                 let expr2_0 =
9561                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9562                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9563                                 return Some(expr3_0);
9564                             }
9565                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9566                                 // Rule at src/isa/x64/lower.isle line 377.
9567                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9568                                 let expr1_0 =
9569                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9570                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9571                                 return Some(expr2_0);
9572                             }
9573                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9574                                 // Rule at src/isa/x64/lower.isle line 365.
9575                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9576                                 let expr1_0 =
9577                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9578                                 let expr2_0 =
9579                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9580                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9581                                 return Some(expr3_0);
9582                             }
9583                             // Rule at src/isa/x64/lower.isle line 360.
9584                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9585                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9586                             let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
9587                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9588                             return Some(expr3_0);
9589                         }
9590                         &Opcode::Bxor => {
9591                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9592                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
9593                                 // Rule at src/isa/x64/lower.isle line 447.
9594                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9595                                 let expr1_0 =
9596                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9597                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9598                                 return Some(expr2_0);
9599                             }
9600                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
9601                                 // Rule at src/isa/x64/lower.isle line 436.
9602                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
9603                                 let expr1_0 =
9604                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9605                                 let expr2_0 =
9606                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9607                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9608                                 return Some(expr3_0);
9609                             }
9610                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
9611                                 // Rule at src/isa/x64/lower.isle line 443.
9612                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9613                                 let expr1_0 =
9614                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
9615                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9616                                 return Some(expr2_0);
9617                             }
9618                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
9619                                 // Rule at src/isa/x64/lower.isle line 431.
9620                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9621                                 let expr1_0 =
9622                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
9623                                 let expr2_0 =
9624                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9625                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9626                                 return Some(expr3_0);
9627                             }
9628                             // Rule at src/isa/x64/lower.isle line 426.
9629                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9630                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
9631                             let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
9632                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9633                             return Some(expr3_0);
9634                         }
9635                         &Opcode::Ishl => {
9636                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9637                             // Rule at src/isa/x64/lower.isle line 483.
9638                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9639                             let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9640                             let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?;
9641                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9642                             return Some(expr3_0);
9643                         }
9644                         &Opcode::Ushr => {
9645                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9646                             // Rule at src/isa/x64/lower.isle line 589.
9647                             let expr0_0 = ExtendKind::Zero;
9648                             let expr1_0 =
9649                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9650                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9651                             let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9652                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9653                             return Some(expr4_0);
9654                         }
9655                         &Opcode::Sshr => {
9656                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9657                             // Rule at src/isa/x64/lower.isle line 691.
9658                             let expr0_0 = ExtendKind::Sign;
9659                             let expr1_0 =
9660                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
9661                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
9662                             let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?;
9663                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9664                             return Some(expr4_0);
9665                         }
9666                         _ => {}
9667                     }
9668                 }
9669                 &InstructionData::Unary {
9670                     opcode: ref pattern5_0,
9671                     arg: pattern5_1,
9672                 } => {
9673                     match pattern5_0 {
9674                         &Opcode::Ineg => {
9675                             // Rule at src/isa/x64/lower.isle line 884.
9676                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9677                             let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?;
9678                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9679                             return Some(expr2_0);
9680                         }
9681                         &Opcode::Bnot => {
9682                             // Rule at src/isa/x64/lower.isle line 1253.
9683                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9684                             let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?;
9685                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9686                             return Some(expr2_0);
9687                         }
9688                         &Opcode::Breduce => {
9689                             // Rule at src/isa/x64/lower.isle line 2242.
9690                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9691                             let expr1_0: usize = 0;
9692                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9693                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9694                             return Some(expr3_0);
9695                         }
9696                         &Opcode::Bint => {
9697                             // Rule at src/isa/x64/lower.isle line 2250.
9698                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9699                             let expr1_0: u32 = 1;
9700                             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
9701                             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
9702                             let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?;
9703                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9704                             return Some(expr5_0);
9705                         }
9706                         &Opcode::Ireduce => {
9707                             // Rule at src/isa/x64/lower.isle line 2234.
9708                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
9709                             let expr1_0: usize = 0;
9710                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
9711                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9712                             return Some(expr3_0);
9713                         }
9714                         _ => {}
9715                     }
9716                 }
9717                 &InstructionData::BinaryImm64 {
9718                     opcode: ref pattern5_0,
9719                     arg: pattern5_1,
9720                     imm: pattern5_2,
9721                 } => {
9722                     if let &Opcode::IaddImm = pattern5_0 {
9723                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
9724                         // Rule at src/isa/x64/lower.isle line 196.
9725                         let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9726                         let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
9727                         let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
9728                         let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?;
9729                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9730                         return Some(expr4_0);
9731                     }
9732                 }
9733                 _ => {}
9734             }
9735         }
9736         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
9737             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9738             match &pattern4_0 {
9739                 &InstructionData::Binary {
9740                     opcode: ref pattern5_0,
9741                     args: ref pattern5_1,
9742                 } => {
9743                     match pattern5_0 {
9744                         &Opcode::Rotl => {
9745                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9746                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9747                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9748                                 if let &InstructionData::UnaryImm {
9749                                     opcode: ref pattern10_0,
9750                                     imm: pattern10_1,
9751                                 } = &pattern9_0
9752                                 {
9753                                     if let &Opcode::Iconst = pattern10_0 {
9754                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9755                                         // Rule at src/isa/x64/lower.isle line 823.
9756                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9757                                         let expr1_0 = C::const_to_type_masked_imm8(
9758                                             ctx,
9759                                             pattern12_0,
9760                                             pattern3_0,
9761                                         );
9762                                         let expr2_0 = constructor_x64_rotl(
9763                                             ctx, pattern3_0, expr0_0, &expr1_0,
9764                                         )?;
9765                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9766                                         return Some(expr3_0);
9767                                     }
9768                                 }
9769                             }
9770                             // Rule at src/isa/x64/lower.isle line 817.
9771                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9772                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9773                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9774                             let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?;
9775                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9776                             return Some(expr4_0);
9777                         }
9778                         &Opcode::Rotr => {
9779                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9780                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9781                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9782                                 if let &InstructionData::UnaryImm {
9783                                     opcode: ref pattern10_0,
9784                                     imm: pattern10_1,
9785                                 } = &pattern9_0
9786                                 {
9787                                     if let &Opcode::Iconst = pattern10_0 {
9788                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9789                                         // Rule at src/isa/x64/lower.isle line 863.
9790                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9791                                         let expr1_0 = C::const_to_type_masked_imm8(
9792                                             ctx,
9793                                             pattern12_0,
9794                                             pattern3_0,
9795                                         );
9796                                         let expr2_0 = constructor_x64_rotr(
9797                                             ctx, pattern3_0, expr0_0, &expr1_0,
9798                                         )?;
9799                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9800                                         return Some(expr3_0);
9801                                     }
9802                                 }
9803                             }
9804                             // Rule at src/isa/x64/lower.isle line 857.
9805                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
9806                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9807                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
9808                             let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?;
9809                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
9810                             return Some(expr4_0);
9811                         }
9812                         _ => {}
9813                     }
9814                 }
9815                 &InstructionData::Unary {
9816                     opcode: ref pattern5_0,
9817                     arg: pattern5_1,
9818                 } => {
9819                     match pattern5_0 {
9820                         &Opcode::Clz => {
9821                             // Rule at src/isa/x64/lower.isle line 1798.
9822                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9823                             let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9824                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9825                             return Some(expr2_0);
9826                         }
9827                         &Opcode::Ctz => {
9828                             // Rule at src/isa/x64/lower.isle line 1840.
9829                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9830                             let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?;
9831                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9832                             return Some(expr2_0);
9833                         }
9834                         &Opcode::Popcnt => {
9835                             // Rule at src/isa/x64/lower.isle line 1892.
9836                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
9837                             let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?;
9838                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
9839                             return Some(expr2_0);
9840                         }
9841                         _ => {}
9842                     }
9843                 }
9844                 _ => {}
9845             }
9846         }
9847         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
9848             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9849             match &pattern4_0 {
9850                 &InstructionData::Binary {
9851                     opcode: ref pattern5_0,
9852                     args: ref pattern5_1,
9853                 } => {
9854                     match pattern5_0 {
9855                         &Opcode::Rotl => {
9856                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9857                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9858                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9859                                 if let &InstructionData::UnaryImm {
9860                                     opcode: ref pattern10_0,
9861                                     imm: pattern10_1,
9862                                 } = &pattern9_0
9863                                 {
9864                                     if let &Opcode::Iconst = pattern10_0 {
9865                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9866                                         // Rule at src/isa/x64/lower.isle line 809.
9867                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9868                                         let expr1_0 = C::const_to_type_masked_imm8(
9869                                             ctx,
9870                                             pattern12_0,
9871                                             pattern3_0,
9872                                         );
9873                                         let expr2_0 = constructor_x64_rotl(
9874                                             ctx, pattern3_0, expr0_0, &expr1_0,
9875                                         )?;
9876                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9877                                         return Some(expr3_0);
9878                                     }
9879                                 }
9880                             }
9881                             // Rule at src/isa/x64/lower.isle line 805.
9882                             let expr0_0: Type = I32;
9883                             let expr1_0 = ExtendKind::Zero;
9884                             let expr2_0 =
9885                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
9886                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9887                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
9888                             let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?;
9889                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9890                             return Some(expr6_0);
9891                         }
9892                         &Opcode::Rotr => {
9893                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
9894                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
9895                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
9896                                 if let &InstructionData::UnaryImm {
9897                                     opcode: ref pattern10_0,
9898                                     imm: pattern10_1,
9899                                 } = &pattern9_0
9900                                 {
9901                                     if let &Opcode::Iconst = pattern10_0 {
9902                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
9903                                         // Rule at src/isa/x64/lower.isle line 849.
9904                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9905                                         let expr1_0 = C::const_to_type_masked_imm8(
9906                                             ctx,
9907                                             pattern12_0,
9908                                             pattern3_0,
9909                                         );
9910                                         let expr2_0 = constructor_x64_rotr(
9911                                             ctx, pattern3_0, expr0_0, &expr1_0,
9912                                         )?;
9913                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
9914                                         return Some(expr3_0);
9915                                     }
9916                                 }
9917                             }
9918                             // Rule at src/isa/x64/lower.isle line 845.
9919                             let expr0_0: Type = I32;
9920                             let expr1_0 = ExtendKind::Zero;
9921                             let expr2_0 =
9922                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
9923                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
9924                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
9925                             let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?;
9926                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
9927                             return Some(expr6_0);
9928                         }
9929                         _ => {}
9930                     }
9931                 }
9932                 &InstructionData::Unary {
9933                     opcode: ref pattern5_0,
9934                     arg: pattern5_1,
9935                 } => {
9936                     match pattern5_0 {
9937                         &Opcode::Clz => {
9938                             // Rule at src/isa/x64/lower.isle line 1803.
9939                             let expr0_0: Type = I32;
9940                             let expr1_0: Type = I32;
9941                             let expr2_0 = ExtendKind::Zero;
9942                             let expr3_0 =
9943                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9944                             let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?;
9945                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9946                             return Some(expr5_0);
9947                         }
9948                         &Opcode::Ctz => {
9949                             // Rule at src/isa/x64/lower.isle line 1845.
9950                             let expr0_0: Type = I32;
9951                             let expr1_0: Type = I32;
9952                             let expr2_0 = ExtendKind::Zero;
9953                             let expr3_0 =
9954                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9955                             let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?;
9956                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9957                             return Some(expr5_0);
9958                         }
9959                         &Opcode::Popcnt => {
9960                             // Rule at src/isa/x64/lower.isle line 1897.
9961                             let expr0_0: Type = I32;
9962                             let expr1_0: Type = I32;
9963                             let expr2_0 = ExtendKind::Zero;
9964                             let expr3_0 =
9965                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
9966                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
9967                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
9968                             return Some(expr5_0);
9969                         }
9970                         _ => {}
9971                     }
9972                 }
9973                 _ => {}
9974             }
9975         }
9976         if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) {
9977             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9978             if let &InstructionData::Load {
9979                 opcode: ref pattern5_0,
9980                 arg: pattern5_1,
9981                 flags: pattern5_2,
9982                 offset: pattern5_3,
9983             } = &pattern4_0
9984             {
9985                 if let &Opcode::Load = pattern5_0 {
9986                     // Rule at src/isa/x64/lower.isle line 2521.
9987                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
9988                     let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?;
9989                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
9990                     return Some(expr2_0);
9991                 }
9992             }
9993         }
9994         if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) {
9995             let pattern4_0 = C::inst_data(ctx, pattern0_0);
9996             if let &InstructionData::Load {
9997                 opcode: ref pattern5_0,
9998                 arg: pattern5_1,
9999                 flags: pattern5_2,
10000                 offset: pattern5_3,
10001             } = &pattern4_0
10002             {
10003                 if let &Opcode::Load = pattern5_0 {
10004                     // Rule at src/isa/x64/lower.isle line 2551.
10005                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10006                     let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
10007                     let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?;
10008                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10009                     return Some(expr3_0);
10010                 }
10011             }
10012         }
10013         if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) {
10014             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10015             if let &InstructionData::Load {
10016                 opcode: ref pattern5_0,
10017                 arg: pattern5_1,
10018                 flags: pattern5_2,
10019                 offset: pattern5_3,
10020             } = &pattern4_0
10021             {
10022                 match pattern5_0 {
10023                     &Opcode::Uload8 => {
10024                         // Rule at src/isa/x64/lower.isle line 2526.
10025                         let expr0_0 = ExtMode::BQ;
10026                         let expr1_0 =
10027                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10028                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10029                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10030                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10031                         return Some(expr4_0);
10032                     }
10033                     &Opcode::Sload8 => {
10034                         // Rule at src/isa/x64/lower.isle line 2528.
10035                         let expr0_0 = ExtMode::BQ;
10036                         let expr1_0 =
10037                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10038                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10039                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10040                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10041                         return Some(expr4_0);
10042                     }
10043                     &Opcode::Uload16 => {
10044                         // Rule at src/isa/x64/lower.isle line 2530.
10045                         let expr0_0 = ExtMode::WQ;
10046                         let expr1_0 =
10047                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10048                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10049                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10050                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10051                         return Some(expr4_0);
10052                     }
10053                     &Opcode::Sload16 => {
10054                         // Rule at src/isa/x64/lower.isle line 2532.
10055                         let expr0_0 = ExtMode::WQ;
10056                         let expr1_0 =
10057                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10058                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10059                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10060                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10061                         return Some(expr4_0);
10062                     }
10063                     &Opcode::Uload32 => {
10064                         // Rule at src/isa/x64/lower.isle line 2534.
10065                         let expr0_0 = ExtMode::LQ;
10066                         let expr1_0 =
10067                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10068                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10069                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
10070                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10071                         return Some(expr4_0);
10072                     }
10073                     &Opcode::Sload32 => {
10074                         // Rule at src/isa/x64/lower.isle line 2536.
10075                         let expr0_0 = ExtMode::LQ;
10076                         let expr1_0 =
10077                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
10078                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
10079                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
10080                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10081                         return Some(expr4_0);
10082                     }
10083                     _ => {}
10084                 }
10085             }
10086         }
10087     }
10088     return None;
10089 }
10090 
10091 // Generated as internal constructor for term output_ifcout.
10092 pub fn constructor_output_ifcout<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
10093     let pattern0_0 = arg0;
10094     // Rule at src/isa/x64/lower.isle line 157.
10095     let expr0_0 = C::value_reg(ctx, pattern0_0);
10096     let expr1_0 = C::value_regs_invalid(ctx);
10097     let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0);
10098     return Some(expr2_0);
10099 }
10100 
10101 // Generated as internal constructor for term sse_and.
10102 pub fn constructor_sse_and<C: Context>(
10103     ctx: &mut C,
10104     arg0: Type,
10105     arg1: Xmm,
10106     arg2: &XmmMem,
10107 ) -> Option<Xmm> {
10108     let pattern0_0 = arg0;
10109     if pattern0_0 == F32X4 {
10110         let pattern2_0 = arg1;
10111         let pattern3_0 = arg2;
10112         // Rule at src/isa/x64/lower.isle line 324.
10113         let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?;
10114         return Some(expr0_0);
10115     }
10116     if pattern0_0 == F64X2 {
10117         let pattern2_0 = arg1;
10118         let pattern3_0 = arg2;
10119         // Rule at src/isa/x64/lower.isle line 325.
10120         let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?;
10121         return Some(expr0_0);
10122     }
10123     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10124         let pattern2_0 = arg1;
10125         let pattern3_0 = arg2;
10126         // Rule at src/isa/x64/lower.isle line 326.
10127         let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?;
10128         return Some(expr0_0);
10129     }
10130     return None;
10131 }
10132 
10133 // Generated as internal constructor for term sse_or.
10134 pub fn constructor_sse_or<C: Context>(
10135     ctx: &mut C,
10136     arg0: Type,
10137     arg1: Xmm,
10138     arg2: &XmmMem,
10139 ) -> Option<Xmm> {
10140     let pattern0_0 = arg0;
10141     if pattern0_0 == F32X4 {
10142         let pattern2_0 = arg1;
10143         let pattern3_0 = arg2;
10144         // Rule at src/isa/x64/lower.isle line 388.
10145         let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?;
10146         return Some(expr0_0);
10147     }
10148     if pattern0_0 == F64X2 {
10149         let pattern2_0 = arg1;
10150         let pattern3_0 = arg2;
10151         // Rule at src/isa/x64/lower.isle line 389.
10152         let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?;
10153         return Some(expr0_0);
10154     }
10155     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10156         let pattern2_0 = arg1;
10157         let pattern3_0 = arg2;
10158         // Rule at src/isa/x64/lower.isle line 390.
10159         let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?;
10160         return Some(expr0_0);
10161     }
10162     return None;
10163 }
10164 
10165 // Generated as internal constructor for term or_i128.
10166 pub fn constructor_or_i128<C: Context>(
10167     ctx: &mut C,
10168     arg0: ValueRegs,
10169     arg1: ValueRegs,
10170 ) -> Option<ValueRegs> {
10171     let pattern0_0 = arg0;
10172     let pattern1_0 = arg1;
10173     // Rule at src/isa/x64/lower.isle line 399.
10174     let expr0_0: usize = 0;
10175     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10176     let expr2_0: usize = 1;
10177     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10178     let expr4_0: usize = 0;
10179     let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?;
10180     let expr6_0: usize = 1;
10181     let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?;
10182     let expr8_0: Type = I64;
10183     let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10184     let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?;
10185     let expr11_0: Type = I64;
10186     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
10187     let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?;
10188     let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?;
10189     return Some(expr14_0);
10190 }
10191 
10192 // Generated as internal constructor for term shl_i128.
10193 pub fn constructor_shl_i128<C: Context>(
10194     ctx: &mut C,
10195     arg0: ValueRegs,
10196     arg1: Gpr,
10197 ) -> Option<ValueRegs> {
10198     let pattern0_0 = arg0;
10199     let pattern1_0 = arg1;
10200     // Rule at src/isa/x64/lower.isle line 489.
10201     let expr0_0: usize = 0;
10202     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10203     let expr2_0: usize = 1;
10204     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10205     let expr4_0: Type = I64;
10206     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10207     let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?;
10208     let expr7_0: Type = I64;
10209     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10210     let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?;
10211     let expr10_0: Type = I64;
10212     let expr11_0: Type = I64;
10213     let expr12_0: Type = I64;
10214     let expr13_0: u64 = 64;
10215     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10216     let expr15_0 = C::gpr_new(ctx, expr14_0);
10217     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10218     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10219     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10220     let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?;
10221     let expr20_0: Type = I64;
10222     let expr21_0: u64 = 0;
10223     let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?;
10224     let expr23_0 = C::gpr_new(ctx, expr22_0);
10225     let expr24_0 = OperandSize::Size64;
10226     let expr25_0: u32 = 127;
10227     let expr26_0 = RegMemImm::Imm { simm32: expr25_0 };
10228     let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0);
10229     let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?;
10230     let expr29_0: Type = I64;
10231     let expr30_0 = CC::Z;
10232     let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0);
10233     let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?;
10234     let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?;
10235     let expr34_0 = C::gpr_new(ctx, expr33_0);
10236     let expr35_0: Type = I64;
10237     let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
10238     let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?;
10239     let expr38_0 = OperandSize::Size64;
10240     let expr39_0: u32 = 64;
10241     let expr40_0 = RegMemImm::Imm { simm32: expr39_0 };
10242     let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0);
10243     let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?;
10244     let expr43_0: Type = I64;
10245     let expr44_0 = CC::Z;
10246     let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
10247     let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?;
10248     let expr47_0: Type = I64;
10249     let expr48_0 = CC::Z;
10250     let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0);
10251     let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?;
10252     let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?;
10253     let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?;
10254     return Some(expr52_0);
10255 }
10256 
10257 // Generated as internal constructor for term ishl_i8x16_mask.
10258 pub fn constructor_ishl_i8x16_mask<C: Context>(
10259     ctx: &mut C,
10260     arg0: &RegMemImm,
10261 ) -> Option<SyntheticAmode> {
10262     let pattern0_0 = arg0;
10263     match pattern0_0 {
10264         &RegMemImm::Imm { simm32: pattern1_0 } => {
10265             // Rule at src/isa/x64/lower.isle line 552.
10266             let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0);
10267             return Some(expr0_0);
10268         }
10269         &RegMemImm::Reg { reg: pattern1_0 } => {
10270             // Rule at src/isa/x64/lower.isle line 561.
10271             let expr0_0 = C::ishl_i8x16_mask_table(ctx);
10272             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10273             let expr2_0: Type = I64;
10274             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10275             let expr4_0: u8 = 4;
10276             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10277             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10278             let expr7_0: u32 = 0;
10279             let expr8_0: u8 = 0;
10280             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10281             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10282             return Some(expr10_0);
10283         }
10284         &RegMemImm::Mem {
10285             addr: ref pattern1_0,
10286         } => {
10287             // Rule at src/isa/x64/lower.isle line 571.
10288             let expr0_0: Type = I64;
10289             let expr1_0 = ExtKind::None;
10290             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10291             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10292             let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?;
10293             return Some(expr4_0);
10294         }
10295         _ => {}
10296     }
10297     return None;
10298 }
10299 
10300 // Generated as internal constructor for term shr_i128.
10301 pub fn constructor_shr_i128<C: Context>(
10302     ctx: &mut C,
10303     arg0: ValueRegs,
10304     arg1: Gpr,
10305 ) -> Option<ValueRegs> {
10306     let pattern0_0 = arg0;
10307     let pattern1_0 = arg1;
10308     // Rule at src/isa/x64/lower.isle line 596.
10309     let expr0_0: usize = 0;
10310     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10311     let expr2_0: usize = 1;
10312     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10313     let expr4_0: Type = I64;
10314     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10315     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10316     let expr7_0: Type = I64;
10317     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10318     let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?;
10319     let expr10_0: Type = I64;
10320     let expr11_0: Type = I64;
10321     let expr12_0: Type = I64;
10322     let expr13_0: u64 = 64;
10323     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10324     let expr15_0 = C::gpr_new(ctx, expr14_0);
10325     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10326     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10327     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10328     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10329     let expr20_0 = OperandSize::Size64;
10330     let expr21_0: u32 = 127;
10331     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10332     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10333     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10334     let expr25_0: Type = I64;
10335     let expr26_0 = CC::Z;
10336     let expr27_0: Type = I64;
10337     let expr28_0: u64 = 0;
10338     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10339     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10340     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10341     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10342     let expr33_0 = C::gpr_new(ctx, expr32_0);
10343     let expr34_0: Type = I64;
10344     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0);
10345     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?;
10346     let expr37_0 = OperandSize::Size64;
10347     let expr38_0: u32 = 64;
10348     let expr39_0 = RegMemImm::Imm { simm32: expr38_0 };
10349     let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0);
10350     let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?;
10351     let expr42_0: Type = I64;
10352     let expr43_0 = CC::Z;
10353     let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10354     let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?;
10355     let expr46_0: Type = I64;
10356     let expr47_0 = CC::Z;
10357     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10358     let expr49_0: Type = I64;
10359     let expr50_0: u64 = 0;
10360     let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?;
10361     let expr52_0 = C::gpr_new(ctx, expr51_0);
10362     let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?;
10363     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?;
10364     let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?;
10365     return Some(expr55_0);
10366 }
10367 
10368 // Generated as internal constructor for term ushr_i8x16_mask.
10369 pub fn constructor_ushr_i8x16_mask<C: Context>(
10370     ctx: &mut C,
10371     arg0: &RegMemImm,
10372 ) -> Option<SyntheticAmode> {
10373     let pattern0_0 = arg0;
10374     match pattern0_0 {
10375         &RegMemImm::Imm { simm32: pattern1_0 } => {
10376             // Rule at src/isa/x64/lower.isle line 653.
10377             let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0);
10378             return Some(expr0_0);
10379         }
10380         &RegMemImm::Reg { reg: pattern1_0 } => {
10381             // Rule at src/isa/x64/lower.isle line 662.
10382             let expr0_0 = C::ushr_i8x16_mask_table(ctx);
10383             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
10384             let expr2_0: Type = I64;
10385             let expr3_0 = C::gpr_new(ctx, pattern1_0);
10386             let expr4_0: u8 = 4;
10387             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
10388             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
10389             let expr7_0: u32 = 0;
10390             let expr8_0: u8 = 0;
10391             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
10392             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
10393             return Some(expr10_0);
10394         }
10395         &RegMemImm::Mem {
10396             addr: ref pattern1_0,
10397         } => {
10398             // Rule at src/isa/x64/lower.isle line 673.
10399             let expr0_0: Type = I64;
10400             let expr1_0 = ExtKind::None;
10401             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
10402             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
10403             let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?;
10404             return Some(expr4_0);
10405         }
10406         _ => {}
10407     }
10408     return None;
10409 }
10410 
10411 // Generated as internal constructor for term sar_i128.
10412 pub fn constructor_sar_i128<C: Context>(
10413     ctx: &mut C,
10414     arg0: ValueRegs,
10415     arg1: Gpr,
10416 ) -> Option<ValueRegs> {
10417     let pattern0_0 = arg0;
10418     let pattern1_0 = arg1;
10419     // Rule at src/isa/x64/lower.isle line 698.
10420     let expr0_0: usize = 0;
10421     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
10422     let expr2_0: usize = 1;
10423     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
10424     let expr4_0: Type = I64;
10425     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10426     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
10427     let expr7_0: Type = I64;
10428     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
10429     let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?;
10430     let expr10_0: Type = I64;
10431     let expr11_0: Type = I64;
10432     let expr12_0: Type = I64;
10433     let expr13_0: u64 = 64;
10434     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
10435     let expr15_0 = C::gpr_new(ctx, expr14_0);
10436     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
10437     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
10438     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
10439     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
10440     let expr20_0 = OperandSize::Size64;
10441     let expr21_0: u32 = 127;
10442     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
10443     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
10444     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
10445     let expr25_0: Type = I64;
10446     let expr26_0 = CC::Z;
10447     let expr27_0: Type = I64;
10448     let expr28_0: u64 = 0;
10449     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
10450     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
10451     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
10452     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
10453     let expr33_0 = C::gpr_new(ctx, expr32_0);
10454     let expr34_0: Type = I64;
10455     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10456     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?;
10457     let expr37_0: Type = I64;
10458     let expr38_0: u8 = 63;
10459     let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0);
10460     let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?;
10461     let expr41_0 = OperandSize::Size64;
10462     let expr42_0: u32 = 64;
10463     let expr43_0 = RegMemImm::Imm { simm32: expr42_0 };
10464     let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0);
10465     let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?;
10466     let expr46_0: Type = I64;
10467     let expr47_0 = CC::Z;
10468     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
10469     let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?;
10470     let expr50_0: Type = I64;
10471     let expr51_0 = CC::Z;
10472     let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
10473     let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?;
10474     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?;
10475     let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?;
10476     return Some(expr55_0);
10477 }
10478 
10479 // Generated as internal constructor for term sshr_i8x16_bigger_shift.
10480 pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
10481     ctx: &mut C,
10482     arg0: Type,
10483     arg1: &RegMemImm,
10484 ) -> Option<XmmMemImm> {
10485     let pattern0_0 = arg0;
10486     let pattern1_0 = arg1;
10487     match pattern1_0 {
10488         &RegMemImm::Imm { simm32: pattern2_0 } => {
10489             // Rule at src/isa/x64/lower.isle line 762.
10490             let expr0_0: u32 = 8;
10491             let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0);
10492             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10493             let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0);
10494             return Some(expr3_0);
10495         }
10496         &RegMemImm::Reg { reg: pattern2_0 } => {
10497             // Rule at src/isa/x64/lower.isle line 764.
10498             let expr0_0 = C::gpr_new(ctx, pattern2_0);
10499             let expr1_0: u32 = 8;
10500             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10501             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
10502             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?;
10503             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10504             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10505             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10506             return Some(expr7_0);
10507         }
10508         &RegMemImm::Mem {
10509             addr: ref pattern2_0,
10510         } => {
10511             // Rule at src/isa/x64/lower.isle line 768.
10512             let expr0_0: u64 = 8;
10513             let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
10514             let expr2_0 = C::gpr_new(ctx, expr1_0);
10515             let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0);
10516             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?;
10517             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10518             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
10519             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
10520             return Some(expr7_0);
10521         }
10522         _ => {}
10523     }
10524     return None;
10525 }
10526 
10527 // Generated as internal constructor for term sse_and_not.
10528 pub fn constructor_sse_and_not<C: Context>(
10529     ctx: &mut C,
10530     arg0: Type,
10531     arg1: Xmm,
10532     arg2: &XmmMem,
10533 ) -> Option<Xmm> {
10534     let pattern0_0 = arg0;
10535     if pattern0_0 == F32X4 {
10536         let pattern2_0 = arg1;
10537         let pattern3_0 = arg2;
10538         // Rule at src/isa/x64/lower.isle line 1194.
10539         let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?;
10540         return Some(expr0_0);
10541     }
10542     if pattern0_0 == F64X2 {
10543         let pattern2_0 = arg1;
10544         let pattern3_0 = arg2;
10545         // Rule at src/isa/x64/lower.isle line 1195.
10546         let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?;
10547         return Some(expr0_0);
10548     }
10549     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
10550         let pattern2_0 = arg1;
10551         let pattern3_0 = arg2;
10552         // Rule at src/isa/x64/lower.isle line 1196.
10553         let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?;
10554         return Some(expr0_0);
10555     }
10556     return None;
10557 }
10558 
10559 // Generated as internal constructor for term i128_not.
10560 pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> Option<ValueRegs> {
10561     let pattern0_0 = arg0;
10562     // Rule at src/isa/x64/lower.isle line 1259.
10563     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
10564     let expr1_0: usize = 0;
10565     let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10566     let expr3_0: usize = 1;
10567     let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
10568     let expr5_0: Type = I64;
10569     let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?;
10570     let expr7_0: Type = I64;
10571     let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?;
10572     let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?;
10573     return Some(expr9_0);
10574 }
10575 
10576 // Generated as internal constructor for term vec_insert_lane.
10577 pub fn constructor_vec_insert_lane<C: Context>(
10578     ctx: &mut C,
10579     arg0: Type,
10580     arg1: Xmm,
10581     arg2: &RegMem,
10582     arg3: u8,
10583 ) -> Option<Xmm> {
10584     let pattern0_0 = arg0;
10585     if pattern0_0 == I8X16 {
10586         let pattern2_0 = arg1;
10587         let pattern3_0 = arg2;
10588         let pattern4_0 = arg3;
10589         // Rule at src/isa/x64/lower.isle line 1313.
10590         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10591         let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10592         return Some(expr1_0);
10593     }
10594     if pattern0_0 == I16X8 {
10595         let pattern2_0 = arg1;
10596         let pattern3_0 = arg2;
10597         let pattern4_0 = arg3;
10598         // Rule at src/isa/x64/lower.isle line 1317.
10599         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10600         let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?;
10601         return Some(expr1_0);
10602     }
10603     if pattern0_0 == I32X4 {
10604         let pattern2_0 = arg1;
10605         let pattern3_0 = arg2;
10606         let pattern4_0 = arg3;
10607         // Rule at src/isa/x64/lower.isle line 1321.
10608         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10609         let expr1_0 = OperandSize::Size32;
10610         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10611         return Some(expr2_0);
10612     }
10613     if pattern0_0 == I64X2 {
10614         let pattern2_0 = arg1;
10615         let pattern3_0 = arg2;
10616         let pattern4_0 = arg3;
10617         // Rule at src/isa/x64/lower.isle line 1325.
10618         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
10619         let expr1_0 = OperandSize::Size64;
10620         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
10621         return Some(expr2_0);
10622     }
10623     if pattern0_0 == F32X4 {
10624         let pattern2_0 = arg1;
10625         let pattern3_0 = arg2;
10626         let pattern4_0 = arg3;
10627         // Rule at src/isa/x64/lower.isle line 1329.
10628         let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10629         let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0);
10630         let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?;
10631         return Some(expr2_0);
10632     }
10633     if pattern0_0 == F64X2 {
10634         let pattern2_0 = arg1;
10635         let pattern3_0 = arg2;
10636         if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 {
10637             let pattern5_0 = arg3;
10638             if pattern5_0 == 0 {
10639                 // Rule at src/isa/x64/lower.isle line 1351.
10640                 let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?;
10641                 let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?;
10642                 return Some(expr1_0);
10643             }
10644         }
10645         let pattern4_0 = arg3;
10646         if pattern4_0 == 0 {
10647             // Rule at src/isa/x64/lower.isle line 1353.
10648             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10649             let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?;
10650             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10651             let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?;
10652             return Some(expr3_0);
10653         }
10654         if pattern4_0 == 1 {
10655             // Rule at src/isa/x64/lower.isle line 1361.
10656             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
10657             let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?;
10658             return Some(expr1_0);
10659         }
10660     }
10661     return None;
10662 }
10663 
10664 // Generated as internal constructor for term cmp_and_choose.
10665 pub fn constructor_cmp_and_choose<C: Context>(
10666     ctx: &mut C,
10667     arg0: Type,
10668     arg1: &CC,
10669     arg2: Value,
10670     arg3: Value,
10671 ) -> Option<ValueRegs> {
10672     let pattern0_0 = arg0;
10673     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
10674         let pattern2_0 = arg1;
10675         let pattern3_0 = arg2;
10676         let pattern4_0 = arg3;
10677         // Rule at src/isa/x64/lower.isle line 1369.
10678         let expr0_0 = constructor_put_in_gpr(ctx, pattern3_0)?;
10679         let expr1_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
10680         let expr2_0 = C::raw_operand_size_of_type(ctx, pattern1_0);
10681         let expr3_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
10682         let expr4_0 = constructor_x64_cmp(ctx, &expr2_0, &expr3_0, expr1_0)?;
10683         let expr5_0 = C::gpr_to_gpr_mem(ctx, expr1_0);
10684         let expr6_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr5_0, expr0_0)?;
10685         let expr7_0 = constructor_with_flags_reg(ctx, &expr4_0, &expr6_0)?;
10686         let expr8_0 = C::value_reg(ctx, expr7_0);
10687         return Some(expr8_0);
10688     }
10689     return None;
10690 }
10691 
10692 // Generated as internal constructor for term do_clz.
10693 pub fn constructor_do_clz<C: Context>(
10694     ctx: &mut C,
10695     arg0: Type,
10696     arg1: Type,
10697     arg2: Gpr,
10698 ) -> Option<Gpr> {
10699     let pattern0_0 = arg0;
10700     let pattern1_0 = arg1;
10701     let pattern2_0 = arg2;
10702     // Rule at src/isa/x64/lower.isle line 1823.
10703     let expr0_0: Type = I64;
10704     let expr1_0: i64 = -1;
10705     let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?;
10706     let expr3_0 = C::gpr_new(ctx, expr2_0);
10707     let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10708     let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
10709     let expr6_0 = C::ty_bits_u64(ctx, pattern1_0);
10710     let expr7_0: u64 = 1;
10711     let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0);
10712     let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?;
10713     let expr10_0 = C::gpr_new(ctx, expr9_0);
10714     let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?;
10715     let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?;
10716     return Some(expr12_0);
10717 }
10718 
10719 // Generated as internal constructor for term do_ctz.
10720 pub fn constructor_do_ctz<C: Context>(
10721     ctx: &mut C,
10722     arg0: Type,
10723     arg1: Type,
10724     arg2: Gpr,
10725 ) -> Option<Gpr> {
10726     let pattern0_0 = arg0;
10727     let pattern1_0 = arg1;
10728     let pattern2_0 = arg2;
10729     // Rule at src/isa/x64/lower.isle line 1864.
10730     let expr0_0: Type = I64;
10731     let expr1_0 = C::ty_bits_u64(ctx, pattern1_0);
10732     let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
10733     let expr3_0 = C::gpr_new(ctx, expr2_0);
10734     let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
10735     return Some(expr4_0);
10736 }
10737 
10738 // Generated as internal constructor for term do_popcnt.
10739 pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10740     let pattern0_0 = arg0;
10741     if pattern0_0 == I32 {
10742         let pattern2_0 = arg1;
10743         // Rule at src/isa/x64/lower.isle line 1955.
10744         let expr0_0: Type = I32;
10745         let expr1_0: u8 = 1;
10746         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10747         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10748         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10749         let expr5_0: Type = I32;
10750         let expr6_0: u64 = 2004318071;
10751         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10752         let expr8_0 = C::gpr_new(ctx, expr7_0);
10753         let expr9_0: Type = I32;
10754         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10755         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10756         let expr12_0: Type = I32;
10757         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10758         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10759         let expr15_0: Type = I32;
10760         let expr16_0: u8 = 1;
10761         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10762         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10763         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10764         let expr20_0: Type = I32;
10765         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10766         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10767         let expr23_0: Type = I32;
10768         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10769         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10770         let expr26_0: Type = I32;
10771         let expr27_0: u8 = 1;
10772         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10773         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10774         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10775         let expr31_0: Type = I32;
10776         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10777         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10778         let expr34_0: Type = I32;
10779         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10780         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10781         let expr37_0: Type = I32;
10782         let expr38_0: Type = I32;
10783         let expr39_0: u8 = 4;
10784         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10785         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10786         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10787         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10788         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10789         let expr45_0: Type = I32;
10790         let expr46_0: u32 = 252645135;
10791         let expr47_0 = RegMemImm::Imm { simm32: expr46_0 };
10792         let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0);
10793         let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?;
10794         let expr50_0: Type = I32;
10795         let expr51_0: u32 = 16843009;
10796         let expr52_0 = RegMemImm::Imm { simm32: expr51_0 };
10797         let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0);
10798         let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?;
10799         let expr55_0: Type = I32;
10800         let expr56_0: u8 = 24;
10801         let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 };
10802         let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0);
10803         let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?;
10804         return Some(expr59_0);
10805     }
10806     if pattern0_0 == I64 {
10807         let pattern2_0 = arg1;
10808         // Rule at src/isa/x64/lower.isle line 1912.
10809         let expr0_0: Type = I64;
10810         let expr1_0: u8 = 1;
10811         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
10812         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
10813         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
10814         let expr5_0: Type = I64;
10815         let expr6_0: u64 = 8608480567731124087;
10816         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
10817         let expr8_0 = C::gpr_new(ctx, expr7_0);
10818         let expr9_0: Type = I64;
10819         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10820         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
10821         let expr12_0: Type = I64;
10822         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
10823         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
10824         let expr15_0: Type = I64;
10825         let expr16_0: u8 = 1;
10826         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
10827         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
10828         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
10829         let expr20_0: Type = I64;
10830         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10831         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
10832         let expr23_0: Type = I64;
10833         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10834         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
10835         let expr26_0: Type = I64;
10836         let expr27_0: u8 = 1;
10837         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
10838         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
10839         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
10840         let expr31_0: Type = I64;
10841         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
10842         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
10843         let expr34_0: Type = I64;
10844         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
10845         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
10846         let expr37_0: Type = I64;
10847         let expr38_0: Type = I64;
10848         let expr39_0: u8 = 4;
10849         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
10850         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
10851         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
10852         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
10853         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
10854         let expr45_0: Type = I64;
10855         let expr46_0: u64 = 1085102592571150095;
10856         let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?;
10857         let expr48_0 = C::gpr_new(ctx, expr47_0);
10858         let expr49_0: Type = I64;
10859         let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
10860         let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?;
10861         let expr52_0: Type = I64;
10862         let expr53_0: u64 = 72340172838076673;
10863         let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?;
10864         let expr55_0 = C::gpr_new(ctx, expr54_0);
10865         let expr56_0: Type = I64;
10866         let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0);
10867         let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?;
10868         let expr59_0: Type = I64;
10869         let expr60_0: u8 = 56;
10870         let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 };
10871         let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0);
10872         let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?;
10873         return Some(expr63_0);
10874     }
10875     return None;
10876 }
10877 
10878 // Generated as internal constructor for term do_bitrev8.
10879 pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10880     let pattern0_0 = arg0;
10881     let pattern1_0 = arg1;
10882     // Rule at src/isa/x64/lower.isle line 2044.
10883     let expr0_0 = C::ty_mask(ctx, pattern0_0);
10884     let expr1_0: u64 = 6148914691236517205;
10885     let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0);
10886     let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?;
10887     let expr4_0 = C::gpr_new(ctx, expr3_0);
10888     let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
10889     let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?;
10890     let expr7_0: u8 = 1;
10891     let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 };
10892     let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0);
10893     let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?;
10894     let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
10895     let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?;
10896     let expr13_0: u8 = 1;
10897     let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 };
10898     let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0);
10899     let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?;
10900     let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0);
10901     let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?;
10902     let expr19_0: u64 = 3689348814741910323;
10903     let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0);
10904     let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?;
10905     let expr22_0 = C::gpr_new(ctx, expr21_0);
10906     let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10907     let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?;
10908     let expr25_0: u8 = 2;
10909     let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 };
10910     let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0);
10911     let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?;
10912     let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
10913     let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?;
10914     let expr31_0: u8 = 2;
10915     let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 };
10916     let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0);
10917     let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?;
10918     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0);
10919     let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?;
10920     let expr37_0: u64 = 1085102592571150095;
10921     let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0);
10922     let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?;
10923     let expr40_0 = C::gpr_new(ctx, expr39_0);
10924     let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
10925     let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?;
10926     let expr43_0: u8 = 4;
10927     let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 };
10928     let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0);
10929     let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?;
10930     let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
10931     let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?;
10932     let expr49_0: u8 = 4;
10933     let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 };
10934     let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0);
10935     let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?;
10936     let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
10937     let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?;
10938     return Some(expr54_0);
10939 }
10940 
10941 // Generated as internal constructor for term do_bitrev16.
10942 pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10943     let pattern0_0 = arg0;
10944     let pattern1_0 = arg1;
10945     // Rule at src/isa/x64/lower.isle line 2067.
10946     let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?;
10947     let expr1_0 = C::ty_mask(ctx, pattern0_0);
10948     let expr2_0: u64 = 71777214294589695;
10949     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
10950     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
10951     let expr5_0 = C::gpr_new(ctx, expr4_0);
10952     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10953     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
10954     let expr8_0: u8 = 8;
10955     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
10956     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
10957     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
10958     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10959     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
10960     let expr14_0: u8 = 8;
10961     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
10962     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
10963     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
10964     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
10965     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
10966     return Some(expr19_0);
10967 }
10968 
10969 // Generated as internal constructor for term do_bitrev32.
10970 pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10971     let pattern0_0 = arg0;
10972     let pattern1_0 = arg1;
10973     // Rule at src/isa/x64/lower.isle line 2079.
10974     let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?;
10975     let expr1_0 = C::ty_mask(ctx, pattern0_0);
10976     let expr2_0: u64 = 281470681808895;
10977     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0);
10978     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
10979     let expr5_0 = C::gpr_new(ctx, expr4_0);
10980     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10981     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
10982     let expr8_0: u8 = 16;
10983     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
10984     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
10985     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
10986     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
10987     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
10988     let expr14_0: u8 = 16;
10989     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
10990     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
10991     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
10992     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
10993     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
10994     return Some(expr19_0);
10995 }
10996 
10997 // Generated as internal constructor for term do_bitrev64.
10998 pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
10999     let pattern0_0 = arg0;
11000     if pattern0_0 == I64 {
11001         let pattern2_0 = arg1;
11002         // Rule at src/isa/x64/lower.isle line 2091.
11003         let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?;
11004         let expr1_0: u64 = 4294967295;
11005         let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?;
11006         let expr3_0 = C::gpr_new(ctx, expr2_0);
11007         let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0);
11008         let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?;
11009         let expr6_0: u8 = 32;
11010         let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 };
11011         let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0);
11012         let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?;
11013         let expr10_0: u8 = 32;
11014         let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 };
11015         let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0);
11016         let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?;
11017         let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11018         let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?;
11019         return Some(expr15_0);
11020     }
11021     return None;
11022 }
11023 
11024 // Generated as internal constructor for term generic_sextend.
11025 pub fn constructor_generic_sextend<C: Context>(
11026     ctx: &mut C,
11027     arg0: Value,
11028     arg1: Type,
11029     arg2: Type,
11030 ) -> Option<InstOutput> {
11031     let pattern0_0 = arg0;
11032     let pattern1_0 = arg1;
11033     if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) {
11034         let pattern3_0 = arg2;
11035         if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) {
11036             // Rule at src/isa/x64/lower.isle line 2211.
11037             let expr0_0: Type = I32;
11038             let expr1_0 = ExtendKind::Sign;
11039             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11040             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11041             return Some(expr3_0);
11042         }
11043         if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) {
11044             // Rule at src/isa/x64/lower.isle line 2207.
11045             let expr0_0: Type = I64;
11046             let expr1_0 = ExtendKind::Sign;
11047             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
11048             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11049             return Some(expr3_0);
11050         }
11051         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11052             // Rule at src/isa/x64/lower.isle line 2201.
11053             let expr0_0: Type = I64;
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_spread_sign_bit(ctx, expr2_0)?;
11057             let expr4_0 = C::gpr_to_reg(ctx, expr2_0);
11058             let expr5_0 = C::gpr_to_reg(ctx, expr3_0);
11059             let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0);
11060             let expr7_0 = C::output(ctx, expr6_0);
11061             return Some(expr7_0);
11062         }
11063     }
11064     if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) {
11065         let pattern3_0 = arg2;
11066         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
11067             // Rule at src/isa/x64/lower.isle line 2197.
11068             let expr0_0 = C::put_in_reg(ctx, pattern0_0);
11069             let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
11070             let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?;
11071             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
11072             let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
11073             let expr5_0 = C::output(ctx, expr4_0);
11074             return Some(expr5_0);
11075         }
11076     }
11077     let pattern2_0 = arg2;
11078     if pattern2_0 == pattern1_0 {
11079         // Rule at src/isa/x64/lower.isle line 2187.
11080         let expr0_0 = constructor_output_value(ctx, pattern0_0)?;
11081         return Some(expr0_0);
11082     }
11083     return None;
11084 }
11085 
11086 // Generated as internal constructor for term spread_sign_bit.
11087 pub fn constructor_spread_sign_bit<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<Gpr> {
11088     let pattern0_0 = arg0;
11089     // Rule at src/isa/x64/lower.isle line 2193.
11090     let expr0_0: Type = I64;
11091     let expr1_0: u8 = 63;
11092     let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11093     let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11094     let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?;
11095     return Some(expr4_0);
11096 }
11097